Why Can't I Directly Cast a `List` to a `List` in C#?

Casting List to List

Consider the following code:

public interface IDic
{
    int Id { get; set; }
    string Name { get; set; }
}
public class Client : IDic
{

}

List<client> clients = new List<client>();</client></client>

Many programmers may assume that they can cast this List to a List:

List<idic> dics = (List<idic>)clients;</idic></idic>

However, this is not a valid cast. This type of cast is not allowed because it would violate type safety. If you attempt this cast, the following error will occur:

Cannot convert type 'System.Collections.Generic.List<client>' to 'System.Collections.Generic.List<idic>'</idic></client>

Why is this Cast Not Allowed?

The reason this cast is disallowed is due to the potential for unsafe behavior. For example, imagine this scenario:

public interface IFruit {}

public class Apple : IFruit {}
public class Banana : IFruit {}

...

List<apple> apples = new List<apple>();
List<ifruit> fruit = (List<ifruit>)apples; // Assumed cast
fruit.Add(new Banana());

// Eek - it's a banana!
Apple apple = apples[0];</ifruit></ifruit></apple></apple>

In this example, the List is cast to a List. This allows a Banana object to be added to the fruit list. However, when the first element of the apples list is accessed, it is still treated as an Apple. This can lead to unexpected behavior and potential bugs.

Safe Conversion Options

While you cannot directly cast a List to a List, there are safe ways to convert between these types.

• ToList(): In .NET 4.0 and above, you can use the ToList() method to convert a List to a new List. This method creates a new list with the same elements but using the specified interface type.

List<ifruit> fruit = apples.ToList<ifruit>();</ifruit></ifruit>

• Cast().ToList(): In .NET 3.5, you can use the Cast() method to get an IEnumerable from a List. Then, you can use ToList() to create a new List from the IEnumerable.

List<ifruit> fruit = apples.Cast<ifruit>().ToList();</ifruit></ifruit>

It's important to note that these conversions create new lists. Changes made to one list will not be reflected in the other. However, changes made to the objects in the lists will be visible in both lists.

The above is the detailed content of Why Can't I Directly Cast a `List` to a `List` in C#?. For more information, please follow other related articles on the PHP Chinese website!