Cast List <T> a List <Interface>

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

}

¿Cómo puedo enviar List<Client>a List<IDic>?

No puede transmitirlo (conservando la identidad de referencia), eso no sería seguro. Por ejemplo:

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

Ahora puede convertir List<Apple>a IEnumerable<IFruit>en .NET 4 / C # 4 debido a la covarianza, pero si desea un List<IFruit>, tendrá que crear una nueva lista. Por ejemplo:

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

Pero esto no es lo mismo que lanzar la lista original, porque ahora hay dos listas separadas . Esto es seguro, pero debe comprender que los cambios realizados en una lista no se verán en la otra. (Por supuesto, se verán las modificaciones a los objetos a los que se refieren las listas).

Un iterador Cast y .ToList ():

List<IDic> casted = input.Cast<IDic>().ToList() hará el truco.

Al principio dije que la covarianza funcionaría, pero como Jon ha señalado correctamente; ¡No, no lo hará!

Y originalmente también dejé estúpidamente la ToList()llamada

Yo también tuve este problema y, después de leer la respuesta de Jon Skeet, modifiqué mi código de uso List<T>a uso IEnumerable<T>. Aunque esto no responde a la pregunta original de la OP de ¿Cómo puedo enviar contenido List<Client>aList<IDic> , no evita la necesidad de hacerlo y por lo tanto puede ser de utilidad para otros que se encuentran con este problema. Por supuesto, esto supone que el código que requiere el uso List<IDic>está bajo su control.

P.ej:

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

En vez de:

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

Si puede usar LINQ, puede hacer esto ...

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

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

Solo es posible creando nuevos List<IDic>y transfiriendo todos los elementos.

En .Net 3.5, puede hacer lo siguiente:

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

El constructor de List en este caso toma un IEnumerable. aunque la
lista solo es convertible a IEnumerable. Aunque myObj puede convertirse en ISomeInterface, el tipo IEnumerable no se puede convertir en IEnumerable.