存储其父 ObservableCollection 的通用继承类

Question

I have several collections, each of specific class. I need that every instance (model) store its parent collection (to be able to reach other instances because of data validation). Trying to find some smart solution - starting to doubt if there is such.

So far I came up with following.

Generic base-class:

public class ModelBase<T> : ObservableObject, IDataErrorInfo
{
    public CustomObservableCollection<T> ParentCollection;

    public int Id { get; set; }  // some generic prop
}

Individual classes (models):

public class Model1: ModelBase<Model1>
{
    public string Name { get; set; } // Some specific prop

    // Data Error validation here, e.g. check of uniqueness
    if (ParentCollection?.Where(c => c.Id != Id).Any(c => c.Name == Name) == true)
    {
    }

}

public class Model2: ModelBase<Model2>
{}

Custom ObservableCollection:

public class CustomObservableCollection<T> : ObservableCollection<T> where T : ModelBase<T>
{
    public CustomObservableCollection() : base() { }

    public CustomObservableCollection(List<T> list)
            : base(list)
    {
        foreach (T item in list)
        {
            item.ParentCollection = this;
        }
    }

    public void AddEdit(T item)
    {
        item.ParentCollection = this;

        base.Add(item);
    }

    protected override void InsertItem(int index, T item)
    {
        base.InsertItem(index, item);

        item.ParentCollection = this;

        // Initialize values
    }

    // Generic method - I would like to call this directly from command handler regardless of type T
    public void MoveItemUp(object parameter) 
    {

    }

}

Usage:

CustomObservableCollection<Model1> Model1Collection = new (listOfModel1instances);

I've been also trying to use Interfaces, but without success.

Answer 1

Since each item in your collection needs to be aware of its parent collection, one way to solve this objective is to define an interface like ISourceAware and constrain CustomObservableCollection<T> to accept only items that implement it by adding where T: ISourceAware to its declaration.

public interface ISourceAware
{
    ICollection Source { get; set; }
}
public class CustomObservableCollection<T> : ObservableCollection<T> where T: ISourceAware
{
    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        base.OnCollectionChanged(e);
        if(e.Action.Equals(NotifyCollectionChangedAction.Add)) 
        {
            foreach (ISourceAware iitem in e.NewItems)
            {
                iitem.Source = this;
#if DEBUG
                var item = (Item)iitem;
                // Try a loopback test
                Console.WriteLine(
                    $"Index of {item.Description} is {item.ParentCollection.IndexOf(item)}");
#endif
            }
        }
    }
} 

The collection handles its own CollectionChanged notification to set itself as the Source of any item added to it. This addresses the primary issue of storing their parent ObservableCollection - you can use it for validation however you see fit.

---

A minimal example of a class that implements ISourceAware :

public class Item : ISourceAware
{
    public string Description { get; set; } = string.Empty;
    public ICollection Source { get; set; }
    public CustomObservableCollection<Item> ParentCollection =>
        (CustomObservableCollection<Item>)Source;
}

---

Test

Here's the quick console code I wrote to test this answer.

internal class Program
{
    static void Main(string[] args)
    {
        Console.Title = "Test ISourceAware";
        var collection = new CustomObservableCollection<Item>();

        collection.Add(new Item { Description = "Item 1" });
        collection.Add(new Item { Description = "Item 2" });

        Console.ReadKey();
    }
}