Lista de elenco <T> para listar <Interface>

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

}

Como posso transmitir List<Client>para List<IDic>?

Você não pode lançá- lo (preservando a identidade de referência) - isso não seria seguro. Por exemplo:

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

Agora você pode converter List<Apple>a IEnumerable<IFruit>em .NET 4 / C # 4 devido à covariância, mas se quiser, List<IFruit>terá que criar uma nova lista. Por exemplo:

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

Mas isso não é o mesmo que lançar a lista original - porque agora existem duas listas separadas . Isso é seguro, mas você precisa entender que as alterações feitas em uma lista não serão vistas na outra lista. (Modificações nos objetos aos quais as listas se referem serão vistas, é claro.)

Um iterador Cast e .ToList ():

List<IDic> casted = input.Cast<IDic>().ToList() vai fazer o truque.

Originalmente, eu disse que a covariância funcionaria - mas, como Jon corretamente apontou; não, não vai!

E originalmente eu também estupidamente à esquerda para fora da ToList()chamada

Eu também tive esse problema e depois de ler a resposta de Jon Skeet, modifiquei meu código de uso List<T>para uso IEnumerable<T>. Embora isso não responda à pergunta original do OP de como posso lançar List<Client>paraList<IDic> , evita a necessidade de fazê-lo e, portanto, pode ser útil para outras pessoas que enfrentam esse problema. É claro que isso pressupõe que o código que requer o uso de List<IDic>está sob seu controle.

Por exemplo:

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

Ao invés de:

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

Se você pode usar o LINQ, você pode fazer isso ...

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

Só é possível criando novos List<IDic>e transferindo todos os elementos.

No .Net 3.5, você pode fazer o seguinte:

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

O construtor de List neste caso leva um IEnumerable.
lista, porém, só é conversível para IEnumerable. Mesmo que myObj possa ser conversível em ISomeInterface, o tipo IEnumerable não é conversível em IEnumerable.