मुझे लगता है कि किसी संग्रह में किसी चीज़ को जोड़ने का सबसे आम तरीका है Addकि किसी तरह की विधि का उपयोग करना जो एक संग्रह प्रदान करता है:
class Item {}
var items = new List<Item>();
items.Add(new Item());
और वास्तव में इसके बारे में कुछ भी असामान्य नहीं है।
मुझे आश्चर्य है कि हम ऐसा क्यों नहीं करते हैं:
var item = new Item();
item.AddTo(items);
यह किसी भी तरह अधिक प्राकृतिक लगता है तो पहली विधि है। यह andvtange होगा कि जब Itemवर्ग की तरह एक संपत्ति है Parent:
class Item
{
public object Parent { get; private set; }
}
आप सेटर को निजी बना सकते हैं। बेशक इस मामले में आप एक एक्सटेंशन विधि का उपयोग नहीं कर सकते।
लेकिन शायद मैं गलत हूं और मैंने इस पैटर्न को पहले कभी नहीं देखा है क्योंकि यह बहुत असामान्य है? क्या आपको पता है कि ऐसा कोई पैटर्न है?
में C#एक विस्तार विधि के लिए उपयोगी होगा
public static T AddTo(this T item, IList<T> list)
{
list.Add(item);
return item;
}
अन्य भाषाओं के बारे में कैसे? मुझे लगता है कि उनमें से अधिकांश में Itemकक्षा को एक ICollectionItemइंटरफ़ेस देना था ।
अद्यतन-1
मैं इसके बारे में थोड़ा और सोच रहा हूं और यह पैटर्न उदाहरण के लिए वास्तव में उपयोगी होगा यदि आप एक आइटम को कई संग्रह में नहीं जोड़ना चाहते हैं।
परीक्षण ICollectableइंटरफ़ेस:
interface ICollectable<T>
{
// Gets a value indicating whether the item can be in multiple collections.
bool CanBeInMultipleCollections { get; }
// Gets a list of item's owners.
List<ICollection<T>> Owners { get; }
// Adds the item to a collection.
ICollectable<T> AddTo(ICollection<T> collection);
// Removes the item from a collection.
ICollectable<T> RemoveFrom(ICollection<T> collection);
// Checks if the item is in a collection.
bool IsIn(ICollection<T> collection);
}
और एक नमूना कार्यान्वयन:
class NodeList : List<NodeList>, ICollectable<NodeList>
{
#region ICollectable implementation.
List<ICollection<NodeList>> owners = new List<ICollection<NodeList>>();
public bool CanBeInMultipleCollections
{
get { return false; }
}
public ICollectable<NodeList> AddTo(ICollection<NodeList> collection)
{
if (IsIn(collection))
{
throw new InvalidOperationException("Item already added.");
}
if (!CanBeInMultipleCollections)
{
bool isInAnotherCollection = owners.Count > 0;
if (isInAnotherCollection)
{
throw new InvalidOperationException("Item is already in another collection.");
}
}
collection.Add(this);
owners.Add(collection);
return this;
}
public ICollectable<NodeList> RemoveFrom(ICollection<NodeList> collection)
{
owners.Remove(collection);
collection.Remove(this);
return this;
}
public List<ICollection<NodeList>> Owners
{
get { return owners; }
}
public bool IsIn(ICollection<NodeList> collection)
{
return collection.Contains(this);
}
#endregion
}
उपयोग:
var rootNodeList1 = new NodeList();
var rootNodeList2 = new NodeList();
var subNodeList4 = new NodeList().AddTo(rootNodeList1);
// Let's move it to the other root node:
subNodeList4.RemoveFrom(rootNodeList1).AddTo(rootNodeList2);
// Let's try to add it to the first root node again...
// and it will throw an exception because it can be in only one collection at the same time.
subNodeList4.AddTo(rootNodeList1);
add(item, collection), लेकिन यह अच्छी ओओ शैली नहीं है।
item.AddTo(items)मान लें कि आपके पास एक्सटेंशन विधियों के बिना एक भाषा है: प्राकृतिक या नहीं, AddTo का समर्थन करने के लिए प्रत्येक प्रकार को इस पद्धति की आवश्यकता होगी और इसे हर प्रकार के संग्रह के लिए प्रदान करना होगा जो कि सहायक हो। यह सब कुछ मैंने कभी सुना है के बीच निर्भरता शुरू करने का सबसे अच्छा उदाहरण की तरह है: पी - मुझे लगता है कि यहाँ झूठे आधार कुछ प्रोग्रामिंग अमूर्त को 'वास्तविक' जीवन में मॉडल करने की कोशिश कर रहे हैं। जो अक्सर गलत हो जाता है।