我有一个名为Client的类，它是Configurable的子类。
我有一个ObservableCollection<Client>，我需要将其视为ObservableCollection<Configurable>。这将允许我从一些通用布局生成代码数据绑定到列表。它还必须允许我清除列表，并将项目添加到列表中。当然，在向列表中添加项时，必须执行运行时类型检查以验证添加的常规项（Configurable）是否为适当的类型（Client）。
我想象的是一个名为ObservableSurrogateCollection<T>的类。 T是一般类（Configurable）。您可以通过将其ObservableCollection<T2>交给T2来构建它，其中T是ReadOnlyObservableCollection<T>的子类。您可以对其进行数据绑定，并且包装列表上的所有集合更改事件都已正确路由（两个方向）。
这是否存在？这不是我应该做的事吗？我想我读过.NET 4.0会在语言层面支持这样的功能吗？
我看过这些选项：
ObservableCollection。这非常接近。但是，因为它是只读的，所以无法添加或清除项目。 提前感谢您的帮助！
答案 0 :(得分：2)
不，这不存在AFAIK，但不应该难以实施;当然，它确实涉及方差的细微差别，因此您的收藏必须在分配/添加时期望铸造问题。请注意 arrays （T[]）已经就像这样（引用类型的数组有变量支持，带有类型检查等），但是你不能添加到一个数组，它不会触发更改事件。
实现这一点很大程度上是一个封装工作;对象构造（当数据绑定到新行时）将是棘手的一点，并可能迫使您添加额外的接口。
4.0不会在此处添加任何内容：What C# 4.0 covariance *doesn't* do
未经测试，但是：
public class ObservableCollection<TBase, TActual> : IList<TBase>, IBindingList, INotifyCollectionChanged
where TBase : class
where TActual : class, TBase
{
private readonly ObservableCollection<TActual> innerList;
public ObservableCollection()
: this((IEnumerable<TActual>)null) {}
public ObservableCollection(IEnumerable<TBase> data)
: this(data == null ? null : data.Cast<TActual>()) {}
public ObservableCollection(IEnumerable<TActual> data)
{
innerList = data == null ? new ObservableCollection<TActual>()
: new ObservableCollection<TActual>(data);
innerList.CollectionChanged += new NotifyCollectionChangedEventHandler(innerList_CollectionChanged);
}
void innerList_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
ListChangedEventHandler handler = ListChanged;
if(handler != null) {
ListChangedEventArgs args = null;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
args = new ListChangedEventArgs(ListChangedType.ItemAdded, e.NewStartingIndex);
break;
case NotifyCollectionChangedAction.Remove:
args = new ListChangedEventArgs(ListChangedType.ItemDeleted, e.OldStartingIndex);
break;
case NotifyCollectionChangedAction.Reset:
args = new ListChangedEventArgs(ListChangedType.Reset, -1);
break;
case NotifyCollectionChangedAction.Replace:
args = new ListChangedEventArgs(ListChangedType.ItemChanged, e.NewStartingIndex);
break;
case NotifyCollectionChangedAction.Move:
args = new ListChangedEventArgs(ListChangedType.ItemMoved, e.NewStartingIndex, e.OldStartingIndex);
break;
}
if(args != null) handler(this, args);
}
NotifyCollectionChangedEventHandler handler2 = CollectionChanged;
if (handler2 != null) handler2(this, e);
}
public void AddIndex(PropertyDescriptor property) {}
public object AddNew()
{
TActual obj = (TActual)Activator.CreateInstance(typeof(TActual));
Add(obj);
return obj;
}
public bool AllowEdit { get { return !IsReadOnly; } }
public bool AllowNew { get { return !IsFixedSize; } }
public bool AllowRemove { get { return !IsFixedSize; } }
public void ApplySort(PropertyDescriptor property, ListSortDirection direction)
{
throw new System.NotImplementedException();
}
public int Find(PropertyDescriptor property, object key)
{
throw new System.NotImplementedException();
}
public bool IsSorted { get { return false; } }
public event ListChangedEventHandler ListChanged;
public event NotifyCollectionChangedEventHandler CollectionChanged;
public void RemoveIndex(PropertyDescriptor property) { }
public void RemoveSort()
{
throw new System.NotImplementedException();
}
public ListSortDirection SortDirection
{
get { return ListSortDirection.Ascending; }
}
public PropertyDescriptor SortProperty
{
get { throw new System.NotImplementedException(); }
}
public bool SupportsChangeNotification { get { return true; } }
public bool SupportsSearching { get { return false; } }
public bool SupportsSorting { get { return false; } }
int IList.Add(object value)
{
int index = innerList.Count;
Add((TBase)value);
return index;
}
public void Add(TBase value)
{
innerList.Add((TActual)value);
}
public void Clear()
{
innerList.Clear();
}
bool IList.Contains(object value)
{
return Contains((TBase)value);
}
public bool Contains(TBase value)
{
return innerList.Contains((TActual)value);
}
int IList.IndexOf(object value)
{
return IndexOf((TBase)value);
}
public int IndexOf(TBase value)
{
return innerList.IndexOf((TActual)value);
}
void IList.Insert(int index, object value)
{
Insert(index, (TBase)value);
}
public void Insert(int index, TBase value)
{
innerList.Insert(index, (TActual)value);
}
public bool IsFixedSize
{
get { return ((IList)innerList).IsFixedSize; }
}
public bool IsReadOnly
{
get { return ((IList)innerList).IsReadOnly; }
}
void IList.Remove(object value)
{
Remove((TBase)value);
}
public bool Remove(TBase value)
{
return innerList.Remove((TActual)value);
}
public void RemoveAt(int index)
{
innerList.RemoveAt(index);
}
object IList.this[int index]
{
get { return innerList[index]; }
set { innerList[index] = (TActual)value; }
}
public TBase this[int index]
{
get { return innerList[index]; }
set { innerList[index] = (TActual)value; }
}
void ICollection.CopyTo(System.Array array, int index)
{
((IList)innerList).CopyTo(array, index);
}
public void CopyTo(TBase[] array, int index)
{
innerList.CopyTo((TActual[])array, index);
}
public int Count { get { return innerList.Count; } }
public bool IsSynchronized
{
get { return ((IList)innerList).IsSynchronized; }
}
public object SyncRoot
{
get { return ((IList)innerList).SyncRoot; }
}
public IEnumerator<TBase> GetEnumerator()
{
return innerList.Cast<TBase>().GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return innerList.GetEnumerator();
}
}