C# 将CollectionBase子类强制转换为泛型列表，而不显式指定类型

我有

CollectionBase

的子类，如下所示：

公共抽象类基列表：CollectionBase
{
公共抽象类型ListType{get；}
}
公共类MyClassList:BaseList
{
公共覆盖类型ListType
{
获取{return typeof（MyClass）；}
}
}

所以我知道编译时的类型。我想将一个方法

ToGenericList（）

添加到 my

BaseList

类，该类将任何

BaseList

转换为类型为的泛型

List

列表类型

这不起作用：

public List ToGeneric（）
{
return List.Cast（）.ToList（）；
}

因为“类型参数无法从用法中推断。”显然，我可以 只要这样做：

someList.Cast（）.ToList（）；

或者这个：

someList.ToGeneric（）；

但是，当我处理具有 列表的列表，我想在它们上面使用一堆LINQ方法，类名有30多个字符长

有没有不涉及调用方指定类型或名称的解决方案

---

是否进行强制转换？

没有办法让编译器根据返回类型进行推断。一个选项是向每个集合类型添加一个方法以返回泛型集合：

public class MyClassList : BaseList
{
    public override Type ListType
    {
        get { return typeof(MyClass); }
    }
    public List<MyClass> ToGeneric()
    {
        return this.Cast<MyClass>.ToList();
    }
}

公共类MyClassList:BaseList
{
公共覆盖类型ListType
{
获取{return typeof（MyClass）；}
}
通用公共列表（）
{
返回此.Cast.ToList（）；
}
}

请注意，没有办法将其放在基类上，因为唯一需要更改的是返回类型（不能仅通过更改返回类型来重载方法）

---

如果您不能/不想更改基类型，您可以使它们成为扩展方法，但您仍然必须为每个类型都有一个方法。

没有办法让编译器根据返回类型进行推断。一个选项是向每个集合类型添加一个方法以返回泛型集合：

public class MyClassList : BaseList
{
    public override Type ListType
    {
        get { return typeof(MyClass); }
    }
    public List<MyClass> ToGeneric()
    {
        return this.Cast<MyClass>.ToList();
    }
}

公共类MyClassList:BaseList
{
公共覆盖类型ListType
{
获取{return typeof（MyClass）；}
}
通用公共列表（）
{
返回此.Cast.ToList（）；
}
}

请注意，没有办法将其放在基类上，因为唯一需要更改的是返回类型（不能仅通过更改返回类型来重载方法）

---

如果您不能/不想更改基类型，您可以使它们成为扩展方法，但您仍然必须为每个类型都有一个方法。

没有办法让编译器根据返回类型进行推断。一个选项是向每个集合类型添加一个方法以返回泛型集合：

public class MyClassList : BaseList
{
    public override Type ListType
    {
        get { return typeof(MyClass); }
    }
    public List<MyClass> ToGeneric()
    {
        return this.Cast<MyClass>.ToList();
    }
}

公共类MyClassList:BaseList
{
公共覆盖类型ListType
{
获取{return typeof（MyClass）；}
}
通用公共列表（）
{
返回此.Cast.ToList（）；
}
}

请注意，没有办法将其放在基类上，因为唯一需要更改的是返回类型（不能仅通过更改返回类型来重载方法）

---

如果您不能/不想更改基类型，您可以使它们成为扩展方法，但您仍然必须为每个类型都有一个方法。

没有办法让编译器根据返回类型进行推断。一个选项是向每个集合类型添加一个方法以返回泛型集合：

public class MyClassList : BaseList
{
    public override Type ListType
    {
        get { return typeof(MyClass); }
    }
    public List<MyClass> ToGeneric()
    {
        return this.Cast<MyClass>.ToList();
    }
}

公共类MyClassList:BaseList
{
公共覆盖类型ListType
{
获取{return typeof（MyClass）；}
}
通用公共列表（）
{
返回此.Cast.ToList（）；
}
}

请注意，没有办法将其放在基类上，因为唯一需要更改的是返回类型（不能仅通过更改返回类型来重载方法）

---

如果您不能/不想更改基本类型，您可以将其作为扩展方法，但每个类型都必须有一个方法。

如果列表有特定的命名约定，您可以尝试“大爆炸”方法

首先，声明第二个基类，引入中间层次结构级别：

public abstract class BaseList<T> : BaseList, IList<T>
{
    public override Type ListType { get { return typeof(T); } }

    // Delegate IList<T> implementation to the base class

    public new IEnumerator<T> GetEnumerator()
    {
        return base.Cast<T>().GetEnumerator();
    }

    public void Add(T item)
    {
        base.Add(item);
    }

    public bool Contains(T item)
    {
        return base.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        base.CopyTo(array, arrayIndex);
    }

    public bool Remove(T item)
    {
        return base.Remove(item);
    }

    public int IndexOf(T item)
    {
        return base.IndexOf(item);
    }

    public void Insert(int index, T item)
    {
        base.Insert(index, item);
    }

    public new T this[int index]
    {
        get { return (T)base[index]; }
        set { base[index] = value; }
    }
}

替换为：

class$1列表：基本列表

这是否可行取决于您的代码库，但这可能只是一个开始

---

一旦完成，您就可以摆脱现在多余的

列表类型

覆盖。

如果您的列表有特定的命名约定，您可以尝试“大爆炸”方法

首先，声明第二个基类，引入中间层次结构级别：

public abstract class BaseList<T> : BaseList, IList<T>
{
    public override Type ListType { get { return typeof(T); } }

    // Delegate IList<T> implementation to the base class

    public new IEnumerator<T> GetEnumerator()
    {
        return base.Cast<T>().GetEnumerator();
    }

    public void Add(T item)
    {
        base.Add(item);
    }

    public bool Contains(T item)
    {
        return base.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        base.CopyTo(array, arrayIndex);
    }

    public bool Remove(T item)
    {
        return base.Remove(item);
    }

    public int IndexOf(T item)
    {
        return base.IndexOf(item);
    }

    public void Insert(int index, T item)
    {
        base.Insert(index, item);
    }

    public new T this[int index]
    {
        get { return (T)base[index]; }
        set { base[index] = value; }
    }
}

替换为：

class$1列表：基本列表

这是否可行取决于您的代码库，但这可能只是一个开始

---

一旦完成，您就可以摆脱现在多余的

列表类型

覆盖。

如果您的列表有特定的命名约定，您可以尝试“大爆炸”方法

首先，声明第二个基类，引入中间层次结构级别：

public abstract class BaseList<T> : BaseList, IList<T>
{
    public override Type ListType { get { return typeof(T); } }

    // Delegate IList<T> implementation to the base class

    public new IEnumerator<T> GetEnumerator()
    {
        return base.Cast<T>().GetEnumerator();
    }

    public void Add(T item)
    {
        base.Add(item);
    }

    public bool Contains(T item)
    {
        return base.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        base.CopyTo(array, arrayIndex);
    }

    public bool Remove(T item)
    {
        return base.Remove(item);
    }

    public int IndexOf(T item)
    {
        return base.IndexOf(item);
    }

    public void Insert(int index, T item)
    {
        base.Insert(index, item);
    }

    public new T this[int index]
    {
        get { return (T)base[index]; }
        set { base[index] = value; }
    }
}

替换为：

class$1列表：基本列表

这是否可行取决于您的代码库，但这可能只是一个开始

---

一旦完成，您就可以摆脱现在多余的

列表类型

覆盖。

如果您的列表有特定的命名约定，您可以尝试“大爆炸”方法

首先，声明第二个基类，引入中间层次结构级别：

public abstract class BaseList<T> : BaseList, IList<T>
{
    public override Type ListType { get { return typeof(T); } }

    // Delegate IList<T> implementation to the base class

    public new IEnumerator<T> GetEnumerator()
    {
        return base.Cast<T>().GetEnumerator();
    }

    public void Add(T item)
    {
        base.Add(item);
    }

    public bool Contains(T item)
    {
        return base.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        base.CopyTo(array, arrayIndex);
    }

    public bool Remove(T item)
    {
        return base.Remove(item);
    }

    public int IndexOf(T item)
    {
        return base.IndexOf(item);
    }

    public void Insert(int index, T item)
    {
        base.Insert(index, item);
    }

    public new T this[int index]
    {
        get { return (T)base[index]; }
        set { base[index] = value; }
    }
}

替换为：

class$1列表：基本列表

这是否可行取决于您的代码库，但这可能只是一个开始

---

一旦完成，您就可以摆脱现在多余的

列表类型

覆盖。

是否有一个特定的原因让您不首先创建一个通用的

基本列表

。我没有设计这个系统，这个人不再为这家公司工作了，同事们在为这个系统编写新代码时模仿了以前的设计