CODEWITHSUNDEEP
c#.netinterfacecasting
Andrew Kalashnikov
Andrew Kalashnikov

Reputation: 3173

Cast List<T> to List<Interface>

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

}

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

Upvotes: 155

Views: 79392

Answers (10)

Godfather
Godfather

Reputation: 1129

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;
}

Upvotes: 1

Minh Nguyen
Minh Nguyen

Reputation: 2201

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);

Upvotes: 0

Kwame
Kwame

Reputation: 143

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

Upvotes: 1

Kent Aguilar
Kent Aguilar

Reputation: 5348

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.

Upvotes: 0

Ɖiamond ǤeezeƦ
Ɖiamond ǤeezeƦ

Reputation: 3331

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
}

Upvotes: 12

Jon Skeet
Jon Skeet

Reputation: 1500815

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.)

Upvotes: 321

Andras Zoltan
Andras Zoltan

Reputation: 42353

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

Upvotes: 10

Marc Messing
Marc Messing

Reputation: 344

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

Upvotes: 5

musefan
musefan

Reputation: 48415

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();

Upvotes: 5

Piotr Auguscik
Piotr Auguscik

Reputation: 3681

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

Upvotes: 0

Related Questions