Cast List to List

Question

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

}

How can I cast List<Client> to List<IDic>?

Answer 1

You can't cast it (preserving reference identity) - that would be unsafe. For example:

public interface IFruit {}

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

...

List<Apple> apples = new List<Apple>();
List<IFruit> fruit = apples; // Fortunately not allowed
fruit.Add(new Banana());

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

Now you can convert a List<Apple> to an IEnumerable<IFruit> in .NET 4 / C# 4 due to covariance, but if you want a List<IFruit> you'd have to create a new list. For example:

// In .NET 4, using the covariance of IEnumerable<T>
List<IFruit> fruit = apples.ToList<IFruit>();

// In .NET 3.5
List<IFruit> fruit = apples.Cast<IFruit>().ToList();

But this is not the same as casting the original list - because now there are two separate lists. This is safe, but you need to understand that changes made to one list won't be seen in the other list. (Modifications to the objects that the lists refer to will be seen, of course.)

Answer 2

A Cast iterator and .ToList():

List<IDic> casted = input.Cast<IDic>().ToList() will do the trick.

Originally I said covariance would work - but as Jon has rightly pointed out; no it won't!

And originally I also stupidly left off the ToList() call

Answer 3

I too had this problem and after reading Jon Skeet's answer I modified my code from using List<T> to use IEnumerable<T>. Although this does not answer the OP's original question of How can I cast List<Client> to List<IDic>, it does avoid the need to do so and thus may be helpful to others who encounter this issue. This of course assumes that the code that requires the use of List<IDic> is under your control.

E.g.:

public void ProcessIDic(IEnumerable<IDic> sequence)
{
   // Implementation
}

Instead of:

public void ProcessIDic(List<IDic> list)
{
   // Implementation
}

Answer 4

If you can use LINQ then you can do this...

List<Client> clientList = new List<Client>();
List<IDic> list = clientList.Select(c => (IDic)c).ToList();

Answer 5

List<Client> listOfA = new List<Client>();
List<IDic> list = listOfA.Cast<IDic>().ToList();

Answer 6

OfType

You can try something like:

        using (var dbContext = YourDatabaseContext())
        {
            var list = dbContext.Clients.Where(x => x.Happy)
                .OfType<IDic>()
                .ToList();
        }

See https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.oftype

Answer 7

If you don't need to modify the contents of the original list, you can implicitly convert a List into a IReadOnlyList which will let you iterate over it's contents as IDics without creating a new list.

List<Client> myClients = new List<Client>();
myClients.Add(new Client());

IReadOnlyList<IDic> castedClients = myClients;
foreach(IDic val in castedClients)
{
    //do something;
}

The conversion can also occur while simply returning the list like so :

public IReadOnlyList<IDic> getClientsAsIDic()
{
    return myClients;
}

Answer 8

In .Net 3.5, you can do the following:

List<ISomeInterface> interfaceList = new List<ISomeInterface>(list.Cast<ISomeInterface>());

The constructor for List in this case takes an IEnumerable.
list though is only convertible to IEnumerable. Even though myObj may be convertible to ISomeInterface the type IEnumerable is not convertible to IEnumerable.

Answer 9

If you want to process the original list without creating a separated reference, you could define the generic method like this:

public void DoIterate<T>(List<T> myCollection) where T : IDic
{
   foreach (T item in myCollection)
   {
      //update a property of interface
      item.Name = "new Name";
   }
}

Calling this method above to process the list without having to cast specific object to interface:

List<Client> clients = new List<Client>();
DoIterate(clients);

Answer 10

Its only possible by creating new List<IDic> and transfering all elements.