निम्नलिखित कोड उदाहरण में, हमारे पास अपरिवर्तनीय वस्तुओं के लिए एक वर्ग है जो एक कमरे का प्रतिनिधित्व करता है। उत्तर, दक्षिण, पूर्व और पश्चिम अन्य कमरों में बाहर निकलते हैं।
public sealed class Room
{
public Room(string name, Room northExit, Room southExit, Room eastExit, Room westExit)
{
this.Name = name;
this.North = northExit;
this.South = southExit;
this.East = eastExit;
this.West = westExit;
}
public string Name { get; }
public Room North { get; }
public Room South { get; }
public Room East { get; }
public Room West { get; }
}तो हम देखते हैं, इस वर्ग को रिफ्लेक्टिव सर्कुलर संदर्भ के साथ डिज़ाइन किया गया है। लेकिन क्योंकि अपरिवर्तनीय वर्ग, मैं 'चिकन या अंडे' की समस्या से जूझ रहा हूं। मुझे यकीन है कि अनुभवी कार्यात्मक प्रोग्रामर जानते हैं कि इससे कैसे निपटें। इसे C # में कैसे हैंडल किया जा सकता है?
मैं एक पाठ-आधारित साहसिक खेल को कोड करने का प्रयास कर रहा हूं, लेकिन सीखने के लिए कार्यात्मक प्रोग्रामिंग सिद्धांतों का उपयोग कर रहा हूं। मैं इस अवधारणा पर अटका हुआ हूं और कुछ मदद का उपयोग कर सकता हूं !!! धन्यवाद।
अद्यतन करें:
यहाँ आलसी आरंभीकरण के संबंध में माइक नाकिस के उत्तर पर आधारित एक कार्यान्वयन कार्यान्वयन है:
using System;
public sealed class Room
{
private readonly Func<Room> north;
private readonly Func<Room> south;
private readonly Func<Room> east;
private readonly Func<Room> west;
public Room(
string name,
Func<Room> northExit = null,
Func<Room> southExit = null,
Func<Room> eastExit = null,
Func<Room> westExit = null)
{
this.Name = name;
var dummyDelegate = new Func<Room>(() => { return null; });
this.north = northExit ?? dummyDelegate;
this.south = southExit ?? dummyDelegate;
this.east = eastExit ?? dummyDelegate;
this.west = westExit ?? dummyDelegate;
}
public string Name { get; }
public override string ToString()
{
return this.Name;
}
public Room North
{
get { return this.north(); }
}
public Room South
{
get { return this.south(); }
}
public Room East
{
get { return this.east(); }
}
public Room West
{
get { return this.west(); }
}
public static void Main(string[] args)
{
Room kitchen = null;
Room library = null;
kitchen = new Room(
name: "Kitchen",
northExit: () => library
);
library = new Room(
name: "Library",
southExit: () => kitchen
);
Console.WriteLine(
$"The {kitchen} has a northen exit that " +
$"leads to the {kitchen.North}.");
Console.WriteLine(
$"The {library} has a southern exit that " +
$"leads to the {library.South}.");
Console.ReadKey();
}
}Roomउदाहरण है।
type List a = Nil | Cons of a * List a। और एक बाइनरी ट्री type Tree a = Leaf a | Cons of Tree a * Tree a:। जैसा कि आप देख सकते हैं, वे दोनों सेल्फ रेफ़रेंशियल (पुनरावर्ती) हैं। यहाँ आप कैसे अपने कमरे को परिभाषित करेंगे: type Room = Nil | Open of {name: string, south: Room, east: Room, north: Room, west: Room}।
Roomकक्षा की परिभाषा और List हास्केल में जो मैंने ऊपर लिखा था, उसी तरह की हैं।