C# 使用泛型类型扩展集合

我的目标是扩展集合对象以支持在集合中添加、更新或删除项时标记。提供了一个扩展特定类型的示例（示例2）。我希望保持它的通用性，这样我就不必为我拥有的每个集合嵌入一个新类

以下是我到目前为止的情况：

public class ChangedEventArgs<T> : EventArgs
{
    public readonly T ChangedItem;
    public readonly T ReplacedWith;
    public readonly ChangeType ChangeType;

    public ChangedEventArgs(ChangeType change, T item, T replacement)
    {
        ChangeType = change;
        ChangedItem = item;
        ReplacedWith = replacement;
    }
}

public enum ChangeType
{
    Added,
    Removed,
    Replaced,
    Cleared
};

class CollectionChangeTracked<T> : Collection<T>
{
    public event EventHandler<ChangedEventArgs<T>> Changed;

    protected override void InsertItem<TParam>(int index, TParam newItem)
    {
        base.InsertItem(index, newItem);

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(ChangeType.Added, newItem, null));
        }
    }

    protected override void SetItem<TParam>(int index, TParam newItem)
    {
        string replaced = Items[index];
        base.SetItem(index, newItem);

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs(ChangeType.Replaced, replaced, newItem));
        }
    }

    protected override void RemoveItem<TParam>(int index)
    {
        TParam removedItem = Items[index];
        base.RemoveItem(index);

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(ChangeType.Removed, removedItem, null));
        }
    }

    protected override void ClearItems()
    {
        base.ClearItems();

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs(ChangeType.Cleared, null, null));
        }
    }
}

公共类ChangedEventArgs:EventArgs
{
公共只读T ChangedItem；
公共只读T替换为；
公共只读ChangeType ChangeType；
公共ChangedEventArgs（变更类型变更、T项、T替换）
{
变更类型=变更；
ChangedItem=项目；
替换为=替换；
}
}
公共枚举更改类型
{
补充，
远离的，
取代，
变明朗
};
类CollectionChangeTracked:集合
{
公共事件事件处理程序已更改；
受保护的覆盖无效插入项（int索引，TParam newItem）
{
base.InsertItem（索引，newItem）；
EventHandler temp=已更改；
如果（温度！=null）
{
temp（this，newchangedventargs（ChangeType.Added，newItem，null））；
}
}
受保护的覆盖无效SetItem（int索引，TParam newItem）
{
替换的字符串=项[索引]；
base.SetItem（索引，newItem）；
EventHandler temp=已更改；
如果（温度！=null）
{
临时（此，新ChangedEventArgs（ChangeType.Replaced，Replaced，newItem））；
}
}
受保护的覆盖void removietem（int索引）
{
TParam removedItem=项目[索引]；
基本删除项（索引）；
EventHandler temp=已更改；
如果（温度！=null）
{
temp（这个，新的ChangedEventArgs（ChangeType.Removed，removedItem，null））；
}
}
受保护的覆盖无效ClearItems（）
{
base.ClearItems（）；
EventHandler temp=已更改；
如果（温度！=null）
{
temp（这个，新的ChangedEventArgs（ChangeType.Cleared，null，null））；
}
}
}

问题: 我在以下行收到错误：base.InsertItem（index，newItem） 它说我有无效的论点，但仅此而已。SetItem和RemoveItem中存在相同问题

更新了编译以下内容的代码：

public class ChangedEventArgs<T> : EventArgs
{
    public readonly T ChangedItem;
    public readonly T? ReplacedWith;
    public readonly ChangeType ChangeType;

    public ChangedEventArgs(ChangeType change, T item, T? replacement)
    {
        ChangeType = change;
        ChangedItem = item;
        ReplacedWith = replacement;
    }
}

public enum ChangeType
{
    Added,
    Removed,
    Replaced,
    Cleared
};

class CollectionChangeTracked<T> : Collection<T>
{
    public event EventHandler<ChangedEventArgs<T>> Changed;

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

        EventHandler<ChangedEventArgs<T>> temp = Changed;

        if (temp != null)
            temp(this, new ChangedEventArgs<T>(ChangeType.Added, newItem, default(T)));
    }


    protected override void SetItem(int index, T newItem)
    {
        T replaced = Items[index];
        base.SetItem(index, newItem);

        EventHandler<ChangedEventArgs<T>> temp = Changed;

        if (temp != null)
            temp(this, new ChangedEventArgs<T>(ChangeType.Replaced, replaced, newItem));
    }

    protected override void RemoveItem(int index)
    {
        T removedItem = Items[index];
        base.RemoveItem(index);

        EventHandler<ChangedEventArgs<T>> temp = Changed;

        if (temp != null)
            temp(this, new ChangedEventArgs<T>(ChangeType.Removed, removedItem, null));
    }

    protected override void ClearItems()
    {
        base.ClearItems();

        EventHandler<ChangedEventArgs<T>> temp = Changed;

        if (temp != null)
            temp(this, new ChangedEventArgs<T>(ChangeType.Cleared, null, null));
    }

公共类ChangedEventArgs:EventArgs
{
公共只读T ChangedItem；
公共只读T？替换为；
公共只读ChangeType ChangeType；
公共ChangedEventArgs（变更类型变更、T项、T替换）
{
变更类型=变更；
ChangedItem=项目；
替换为=替换；
}
}
公共枚举更改类型
{
补充，
远离的，
取代，
变明朗
};
类CollectionChangeTracked:集合
{
公共事件事件处理程序已更改；
受保护的重写void插入项（int索引，T newItem）
{
base.InsertItem（索引，newItem）；
EventHandler temp=已更改；
如果（温度！=null）
temp（这个，新的ChangedEventArgs（ChangeType.Added，newItem，默认值（T））；
}
受保护的覆盖无效SetItem（int索引，T newItem）
{
T替换=项目[索引]；
base.SetItem（索引，newItem）；
EventHandler temp=已更改；
如果（温度！=null）
临时（此，新ChangedEventArgs（ChangeType.Replaced，Replaced，newItem））；
}
受保护的覆盖void removietem（int索引）
{
T removedItem=项目[索引]；
基本删除项（索引）；
EventHandler temp=已更改；
如果（温度！=null）
temp（这个，新的ChangedEventArgs（ChangeType.Removed，removedItem，null））；
}
受保护的覆盖无效ClearItems（）
{
base.ClearItems（）；
EventHandler temp=已更改；
如果（温度！=null）
temp（这个，新的ChangedEventArgs（ChangeType.Cleared，null，null））；
}

我想这会有所帮助，但我猜你的问题有点含糊不清，没有完成

 public class ChangedEventArgs<T> : EventArgs
    {
        public readonly T ChangedItem;
        public readonly T ReplacedWith;
        public readonly ChangeType ChangeType;

        public ChangedEventArgs(ChangeType change, T item, T replacement)
        {
            ChangeType = change;
            ChangedItem = item;
            ReplacedWith = replacement;
        }
    }

公共类ChangedEventArgs:EventArgs
{
公共只读T ChangedItem；
公共只读T替换为；
公共只读ChangeType ChangeType；
公共ChangedEventArgs（变更类型变更、T项、T替换）
{
变更类型=变更；
ChangedItem=项目；
替换为=替换；
}
}

@daveL完全正确，您需要的是一个通用事件参数：

public class ChangedEventArgs<T> : EventArgs
{
    public readonly T ChangedItem;
    public readonly T ReplacedWith;
    public readonly ChangeType ChangeType;

    public ChangedEventArgs(ChangeType change, T item, T replacement)
    {
        ChangeType = change;
        ChangedItem = item;
        ReplacedWith = replacement;
    }
}

然后，您的单个方法，而不是将类型重新定义为

TParam

，应该使用在类级别定义的

T

：

protected override void InsertItem(int index, T newItem)
{
    base.InsertItem(index, newItem);
    EventHandler<ChangedEventArgs<T>> temp = Changed;
    if (temp != null)
    {
      // Added <T> after ChangedEventArgs  
      temp(this, new ChangedEventArgs<T>(ChangeType.Added, newItem, default(T)));
    }
}

protected override void InsertItem（int index，T newItem）
{
base.InsertItem（索引，newItem）；
EventHandler temp=已更改；
如果（温度！=null）
{
//在ChangedEventArgs之后添加
temp（这个，新的ChangedEventArgs（ChangeType.Added，newItem，默认值（T））；
}
}

---

实例：

您必须将ChangedEventArgs类定义为泛型

试试这个：

public class ChangedEventArgs<T> : EventArgs
{
    public readonly T ChangedItem;
    public readonly ChangeType ChangeType;
    public readonly T ReplacedWith;

    public ChangedEventArgs(ChangeType change, T item,
        T replacement)
    {
        ChangeType = change;
        ChangedItem = item;
        ReplacedWith = replacement;
    }
}

public enum ChangeType
{
    Added,
    Removed,
    Replaced,
    Cleared
};

class CollectionChangeTracked<T> : Collection<T> 
{
    public event EventHandler<ChangedEventArgs<T>> Changed;

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

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(
                ChangeType.Added, newItem, default(T)));
        }
    }

    protected override void SetItem(int index, T newItem)
    {
        T replaced = Items[index];
        base.SetItem(index, newItem);

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(
                ChangeType.Replaced, replaced, newItem));
        }
    }

    protected override void RemoveItem(int index)
    {
        T removedItem = Items[index];
        base.RemoveItem(index);

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(
                ChangeType.Removed, removedItem, default(T)));
        }
    }

    protected override void ClearItems()
    {
        base.ClearItems();

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(
                ChangeType.Cleared, default(T), default(T)));
        }
    }
}

公共类ChangedEventArgs:EventArgs
{
公共只读T ChangedItem；
公共只读ChangeType ChangeType；
公共只读T替换为；
公共ChangedEventArgs（变更类型变更，T项，
（T更换）
{
变更类型=变更；
ChangedItem=项目；
替换为=替换；
}
}
公共枚举更改类型
{
补充，
远离的，
取代，
变明朗
};
类CollectionChangeTracked:集合
{
公共事件事件处理程序已更改；
受保护的重写void插入项（int索引，T newItem）
{
base.InsertItem（索引，newItem）；
EventHandler temp=已更改；
如果（温度！=null）
{
临时工（此，新变更）(
ChangeType.Added，newItem，默认值（T））；
}
}
受保护的覆盖无效SetItem（int索引，T newItem）
{
T替换=项目[索引]；
base.SetItem（索引，newItem）；
EventHandler temp=已更改；
如果（温度！=null）
{
临时工（此，新变更）
public class ChangedEventArgs<T> : EventArgs
{
    public readonly T ChangedItem;
    public readonly ChangeType ChangeType;
    public readonly T ReplacedWith;

    public ChangedEventArgs(ChangeType change, T item,
        T replacement)
    {
        ChangeType = change;
        ChangedItem = item;
        ReplacedWith = replacement;
    }
}

public enum ChangeType
{
    Added,
    Removed,
    Replaced,
    Cleared
};

class CollectionChangeTracked<T> : Collection<T> 
{
    public event EventHandler<ChangedEventArgs<T>> Changed;

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

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(
                ChangeType.Added, newItem, default(T)));
        }
    }

    protected override void SetItem(int index, T newItem)
    {
        T replaced = Items[index];
        base.SetItem(index, newItem);

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(
                ChangeType.Replaced, replaced, newItem));
        }
    }

    protected override void RemoveItem(int index)
    {
        T removedItem = Items[index];
        base.RemoveItem(index);

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(
                ChangeType.Removed, removedItem, default(T)));
        }
    }

    protected override void ClearItems()
    {
        base.ClearItems();

        EventHandler<ChangedEventArgs<T>> temp = Changed;
        if (temp != null)
        {
            temp(this, new ChangedEventArgs<T>(
                ChangeType.Cleared, default(T), default(T)));
        }
    }
}