如何将“类列表”转换为“其接口列表”？

Question

I need to cast a class list to its own interface list.

So I have interface Demo_Interface and two classes based on Demo_Interface , Now I create list of classes like List<Test_Class1>

And I have a function with List<Demo_Interface> parameter.

Here's interface :

       interface Demo_Interface
        {
            int test_int { get; set; }
        }

Here's Entire Code :

using System;
using System.Collections.Generic;

namespace ConsoleApp3
{
    class Program
    {
        ///// Main Interface
        interface Demo_Interface
        {
            int test_int { get; set; }
        }

        //// Class 1 Based On Demo_Interface
        class Test_Class1 : Demo_Interface
        {
            public int test_int { get; set; }
            public string test_string { get; set; }

        }
        ///// Class 2 Based On Demo_Interface
        class Test_Class2 : Demo_Interface
        {
            public int test_int { get; set; }
            public string test_string { get; set; }

        }

        //// And Main Class
        class Main_Class
        {
            public List<Test_Class1> class_list_1 { get; set; }

            public List<Test_Class2> class_list_2 { get; set; }

            public Main_Class()
            {
                class_list_1 = new List<Test_Class1>() { };
                class_list_2 = new List<Test_Class2>() { };
            }
        }

        //// Console Main
        static void Main(string[] args)
        {
            var new_main_class = new Main_Class();

            Output_Class(new_main_class.class_list_1); ///// ==> ERROR

            Console.ReadKey();
        }

        //// Simple Function for do something with interface
        static void Output_Class(List<Demo_Interface> inter_input)
        {
            for (int i = 0; i < inter_input.Count; i++)
            {
                Console.WriteLine("{0} - {1}",i, inter_input[i].test_int);
            }
        }
    }
}

How Can I cast List<Test_Class1> to List<Demo_Interface> , When Test_Class1 uses Demo_Interface ?

Answer 1

You can try

List<Test_Class1> testDemo = new List<Test_Class1>(); //list of Test_Class1 instances
List<Demo_Interface> result = testDemo.ToList<Demo_Interface>();

This is safe because we are not directly casting testDemo to its interface. We are keeping testDemo as it is and we are creating result which is list of Demo_Interface

Answer 2

If you need only to enumerate through the List<Demo_Interface> like shown in example, you don't have to do any kind of explicit casting. List<T> implements IEnumerable<T> which is covariant generic type.

Covariance for collections enables implicit conversion of a collection of a more derived type to a collection of a less derived type

In your case, List<Test_Class1> implements IEnumerable<Test_Class1> , but since Test_Class1 implements Demo_Interface , you can take advantage of generics variance and write, for example, something like this:

IEnumerable<Test_Class1> col = new List<Test_Class1>();
IEnumerable<Demo_Interface> colImplicit = col;

That basically means that your Output_Class method can take IEnumerable<Demo_Interface> argument and you'll be able to pass both lists without casting them explicitly using Cast<T> or creating a new collection using ToList<T> .

private void Output_Class(IEnumerable<Demo_Interface> inter_input)
{
    // do your thing
}

// Method invocation
Output_Class(new_main_class.class_list_1);

Answer 3

You cannot cast a List<ClassThatImplementsInterface> as a List<IInterfaceItImplements> .

If you could, and you did this:

var classList = new List<ClassThatImplementsInterface>();
var interfaceList = (List<IInterfaceItImplements>)classList;

... then you would be able to do this:

interfaceList.Add(new SomeOtherClassThatImplementsTheInterface);

But casting the list doesn't create a new list. In the above example there aren't two lists. There are two variables with references to the same list. If you could cast as seen above, you would be able to define a list of one type and add a completely different type to it. The compiler prevents that.

You could

• create a new List<IDemoInterface> and add the items to it. (Or an array, IEnumerable, etc.)
• Leave the list as-is, and just cast individual items when/if you need to. In most cases we wouldn't need to cast something as an interface it implements.

If we need to cast a whole collection as a different type, it's likely because we're passing it as an argument.

That's actually a good reason not to define a method argument as a collection type like a List<T> which can be modified unless it's our intent to modify the collection.

That's one reason why we pass less-specific collection types, like IEnumerable<T> .

Suppose the method argument looks like this:

void MethodINeedToPassTheArgumentTo(IEnumerable<IDemoInterface> items)

Now we can take our List<TestClass> and do this:

MethodINeedToPassTheArgumentTo(testClassList.Cast<IDemoInterface>);

We're not creating a new collection. We're passing a reference that allows the other method to view the items in the list, each individually cast as IDemoInterface . For practical purposes it looks to the other method like a collection of IDemoInterface , and that's okay because the other item can't modify the collection. It can't attempt to add other types into the List<TestClass> .