虽然我们可以继承基类/接口，但为什么不能使用相同的类/接口声明一个List<>？
interface A
{ }
class B : A
{ }
class C : B
{ }
class Test
{
static void Main(string[] args)
{
A a = new C(); // OK
List<A> listOfA = new List<C>(); // compiler Error
}
}
有什么绕过的方法吗？
让这个工作的方法是迭代列表并将元素转换。这可以使用ConvertAll完成：
List<A> listOfA = new List<C>().ConvertAll(x => (A)x);
你也可以使用Linq：
List<A> listOfA = new List<C>().Cast<A>().ToList();
ConvertAll 还是 Cast？ - Martin BraunIEnumerable 而不是 List 进行此转换呢？例如：List<Animal> listAnimals = listGiraffes as List<Animal>; 是不可能的，但是 IEnumerable<Animal> eAnimals = listGiraffes as IEnumerable<Animal> 可以。 - Jéf BuenoIEnumerable<T>和IEnumerator<T>都被标记为支持协变，编译器已经验证了这一点。 - Eric Lippert引用Eric的伟大解释：
发生了什么？你想让长颈鹿列表包含一只老虎吗？你想要程序崩溃吗？还是你想要编译器在一开始就保护你免受崩溃的影响，使赋值非法？ 我们选择后者。
但是如果你想选择运行时崩溃而不是编译错误怎么办？通常你会使用Cast<>或ConvertAll<>，但这样会产生两个问题：它将创建一个列表的副本。如果在新列表中添加或删除内容，则原始列表不会反映这些更改。其次，由于它创建包含现有对象的新列表，因此会带来很大的性能和内存开销。
我遇到了同样的问题，因此我创建了一个包装类，可以在不创建全新列表的情况下转换泛型列表。
在原始问题中，你可以使用以下代码：
class Test
{
static void Main(string[] args)
{
A a = new C(); // OK
IList<A> listOfA = new List<C>().CastList<C,A>(); // now ok!
}
}
这里是包装类（加上一个扩展方法CastList方便使用）
public class CastedList<TTo, TFrom> : IList<TTo>
{
public IList<TFrom> BaseList;
public CastedList(IList<TFrom> baseList)
{
BaseList = baseList;
}
// IEnumerable
IEnumerator IEnumerable.GetEnumerator() { return BaseList.GetEnumerator(); }
// IEnumerable<>
public IEnumerator<TTo> GetEnumerator() { return new CastedEnumerator<TTo, TFrom>(BaseList.GetEnumerator()); }
// ICollection
public int Count { get { return BaseList.Count; } }
public bool IsReadOnly { get { return BaseList.IsReadOnly; } }
public void Add(TTo item) { BaseList.Add((TFrom)(object)item); }
public void Clear() { BaseList.Clear(); }
public bool Contains(TTo item) { return BaseList.Contains((TFrom)(object)item); }
public void CopyTo(TTo[] array, int arrayIndex) { BaseList.CopyTo((TFrom[])(object)array, arrayIndex); }
public bool Remove(TTo item) { return BaseList.Remove((TFrom)(object)item); }
// IList
public TTo this[int index]
{
get { return (TTo)(object)BaseList[index]; }
set { BaseList[index] = (TFrom)(object)value; }
}
public int IndexOf(TTo item) { return BaseList.IndexOf((TFrom)(object)item); }
public void Insert(int index, TTo item) { BaseList.Insert(index, (TFrom)(object)item); }
public void RemoveAt(int index) { BaseList.RemoveAt(index); }
}
public class CastedEnumerator<TTo, TFrom> : IEnumerator<TTo>
{
public IEnumerator<TFrom> BaseEnumerator;
public CastedEnumerator(IEnumerator<TFrom> baseEnumerator)
{
BaseEnumerator = baseEnumerator;
}
// IDisposable
public void Dispose() { BaseEnumerator.Dispose(); }
// IEnumerator
object IEnumerator.Current { get { return BaseEnumerator.Current; } }
public bool MoveNext() { return BaseEnumerator.MoveNext(); }
public void Reset() { BaseEnumerator.Reset(); }
// IEnumerator<>
public TTo Current { get { return (TTo)(object)BaseEnumerator.Current; } }
}
public static class ListExtensions
{
public static IList<TTo> CastList<TFrom, TTo>(this IList<TFrom> list)
{
return new CastedList<TTo, TFrom>(list);
}
}
IEnumerable，它将起作用（至少在C# 4.0中，我没有尝试过之前的版本）。当然，这只是一个强制转换，它仍然是一个列表。List<A> listOfA = new List<C>(); // 编译器错误
请改用 -
IEnumerable<A> listOfA = new List<C>(); // 编译器错误-不再出现! :)List<A> listOfA = new List<C>(); // compiler Error替换为IEnumerable<A> listOfA = new List<C>(); // compiler error - no more! :)。 - PhistucKIEnumerable 中时隐式转换到 A 可行，但当它们在 List 中时却不可行。有人知道原因吗？ - Raphael Royer-Rivardvoid DoesThisWork()
{
List<C> DerivedList = new List<C>();
List<A> BaseList = DerivedList;
BaseList.Add(new B());
C FirstItem = DerivedList.First();
}
这应该可以工作吗？列表中的第一个项目是类型为“B”，但DerivedList项目的类型是C。
现在，假设我们真的只想要创建一个通用函数，它可以操作实现A接口的某种类型的列表，但我们不关心那个类型是什么：
void ThisWorks<T>(List<T> GenericList) where T:A
{
}
void Test()
{
ThisWorks(new List<B>());
ThisWorks(new List<C>());
}
您只能强制转换为只读列表。例如：
IEnumerable<A> enumOfA = new List<C>();//This works
IReadOnlyCollection<A> ro_colOfA = new List<C>();//This works
IReadOnlyList<A> ro_listOfA = new List<C>();//This works
而且，您无法为支持保存元素的列表执行此操作。原因是：
List<string> listString=new List<string>();
List<object> listObject=(List<object>)listString;//Assume that this is possible
listObject.Add(new object());
现在怎么办？请记住，listObject和listString实际上是同一个列表，所以listString现在有了对象元素 - 这是不应该发生的，并且它确实没有。
IReadOnlyList，IEnumerable => 无误差且类型安全。 这可能是您需要的。List<> => 无误差/不类型安全Array => 类型安全/引发运行时错误dynamic或List<object> => 通用/ 不类型安全/ 引发运行时错误它们都可以很好地工作！没有任何棘手的编程需要！
using System; using System.Collections.Generic; using System.Linq;
interface IAnimal
{
public string Name { get; }
}
class Bear : IAnimal
{
public string BearName = "aBear";
public string Name => BearName;
}
class Cat : IAnimal
{
public string CatName = "aCat";
public string Name => CatName;
}
// Dog has no base class/interface; it isn't related to the other classes
// But it also provides a <Name> property (what a coincidence!)
class Dog
{
public string DogName = "aDog";
public string Name => DogName;
}
public class AssignDerivedClass {
private static string AnyName(dynamic anymal) => anymal switch
{
IAnimal animal => animal.Name,
Dog dog => dog.DogName,
string s => s,
_ => "Any unknown Animal"
};
public static void TestIEnumerableAndIReadonlyList()
{
var cats = new List<Cat>()
{
new Cat() { CatName = "Cat-3" },
};
IEnumerable<IAnimal> animalsEnumerable = cats;
IReadOnlyList<IAnimal> animalsReadOnlyList = cats;
var extendedEnumerable = animalsReadOnlyList.Append(new Bear());
(extendedEnumerable.First() as Cat).CatName = "Cat-3a";
Console.WriteLine("Cat names: {0}, {1}, {2}, {3}",
cats.ElementAt(0).CatName,
animalsReadOnlyList[^1].Name,
AnyName(animalsEnumerable.Last()),
AnyName(extendedEnumerable.ElementAt(1)));
}
// Result => Cat names: Cat-3a, Cat-3a, Cat-3a, aBear
List<>: List<A> listOfA = new()将一只猫添加到一个应该是熊的动物列表中：
public static void TestListOfInterface()
{
var bears = new List<IAnimal>()
{
new Bear() { BearName = "Bear-1" },
};
bears.Add(new Cat() { CatName = "Cat-2" });
string bearNames = string.Join(", ", bears.Select(animal => animal.Name));
Console.WriteLine($"Bear names: {bearNames}");
static string VerifyBear(IAnimal bear)
=> (bear as Bear)?.Name ?? "disguised as a bear!!!";
string bearInfo0 = VerifyBear(bears[0]);
string bearInfo1 = VerifyBear(bears[1]);
Console.WriteLine($"One animal is {bearInfo0}, the other one is {bearInfo1}");
}
// Bear names: Bear-1, Cat-2
// One animal is Bear-1, the other one is disguised as a bear!!!
数组：创建一个Bear[]数组，保证所有的数组元素都引用了Bear实例。数组中的熊：
public static void TestArray()
{
Bear[] bears = { new Bear(), null };
IAnimal[] bearAnimals = bears;
try { bearAnimals[1] = new Cat(); } // => ArrayTypeMismatchException
catch (Exception e) { Console.Error.WriteLine(e); } // type incompatible with array
bearAnimals[1] = new Bear() { BearName = "Bear-2" };
Console.WriteLine($"Bear names: {bearAnimals[0].Name}, {bears[1].BearName}");
}
// Result => Bear names: aBear, Bear-2
dynamic 和 List<dynamic>: 最通用的解决方案将列表分配给dynamic或使用List<dynamic>：
public static void TestDynamicListAndArray()
{
dynamic any = new List<Cat>() // List of specific class - or of interface
{
new Cat() { CatName = "Cat-1" },
new Cat() { CatName = "Cat-2" },
};
try { any[0].BearName = "Bear-1"; } // => RuntimeBinderException
catch (Exception e) { Console.Error.WriteLine(e); } // Cat has no BearName
try { any.Add(new Bear()); } // => RuntimeBinderException
catch (Exception e) { Console.Error.WriteLine(e); } // no matching overload
any[1].CatName += 'a';
Console.WriteLine($"Animal names: {any[0].CatName}, {any[1].Name}");
var mix = new List<dynamic>
{
new Bear() {BearName = "Bear-3"},
new Dog() {DogName = "Dog-4"},
"Cat-5", // 100MHz ;-)
};
Console.WriteLine($"{AnyName(mix[0])}, {mix[1].Name}, {AnyName(mix[2])}");
try { Console.WriteLine($"Names: {any[2].Name}"); } // => RuntimeBinderException
catch (Exception e) { Console.Error.WriteLine(e); } // no definition for 'Name'
any = new Bear() { BearName = "Bear-6" }; // Scalar - not a List or Array!
try { Console.WriteLine($"{AnyName(any[0])}"); } // => RuntimeBinderException
catch (Exception e) { Console.Error.WriteLine(e); } // cannot apply indexing []
}
//Animal names: Bear-1, Cat-2a
//Bear-3, Dog-4, Cat-5
} //end of class AssignDerivedClass
public static List<TTo> Cast<TFrom, TTo>(List<TFrom> fromlist)
where TFrom : class
where TTo : class
{
return fromlist.ConvertAll(x => x as TTo);
}
这是对BigJim的精彩答案的扩展。
在我的情况下，我有一个带有Children字典的NodeBase类，并且我需要一种从子项中通用地进行O(1)查找的方法。我试图在Children的getter中返回一个私有字典字段，因此显然我想避免昂贵的复制/迭代。因此，我使用了Bigjim的代码将Dictionary<whatever specific type>转换为通用的Dictionary<NodeBase>：
// Abstract parent class
public abstract class NodeBase
{
public abstract IDictionary<string, NodeBase> Children { get; }
...
}
// Implementing child class
public class RealNode : NodeBase
{
private Dictionary<string, RealNode> containedNodes;
public override IDictionary<string, NodeBase> Children
{
// Using a modification of Bigjim's code to cast the Dictionary:
return new IDictionary<string, NodeBase>().CastDictionary<string, RealNode, NodeBase>();
}
...
}
这个方法很有效。然而，最终我遇到了无关的限制，并最终在基类中创建了一个抽象的FindChild()方法来进行查找。结果，这消除了一开始需要转换字典的需求。（我能够用一个简单的IEnumerable替换它来达到我的目的。）
所以你可能会问的问题（特别是如果性能是一个阻止你使用.Cast<>或.ConvertAll<>的问题）是：
“我真的需要转换整个集合吗？还是可以使用一个抽象方法来保存执行任务所需的特殊知识，从而避免直接访问集合？”
有时候，最简单的解决方案就是最好的。
可能会晚一些。
将其转换为数组也可以完成任务。
main()
{
List<Camel> camels = new List<Camel>();
Reproducton(camels.ToArray());
}
public void Reproducton(Animal[] animals)
{
foreach(var animal in animals.ToList())
{
var baby = animal.Reproduce();
}
}