C# - Comment utiliser une interface pour une liste générique lors de la sérialisation

Question

J'ai une liste générique et je veux la sérialiser. Je veux utiliser une interface pour la liste générique qui ne peut pas être sérialisée donc vous devez utiliser l'instance. Comme ceci MyClass implémente IMyClass.

List<IMyClass> list = DeserializeMyClass(path); //Can't do this right 

ont donc à faire

List<MyClass> list = DeserializeMyClass(path); 

Alors question est ce que je peux maintenant jeter à

List<IMyClass> ilist = (IMyClass)list; 

Malcolm

Answer 1

Ok c'est ce qu'il aurait dû être:

Listl<IMyclass> list = DeserializeMyClass(path); //Can't do this right 

doivent donc faire:

List<MyClass> list = DeserializeMyClass(path); 

Alors question est ce que je peux maintenant jeter à:

List<IMyclass> ilist = (IMyClass)list; 

Answer 2

Cela fonctionne, mais je ne suis pas sûr que c'est la meilleure façon:

List<Test> list = new List<Test>(); 
List<ITest> ilist = list.ConvertAll<ITest>(x => (ITest)x); 

Answer 3

Vous semblez courir au fait que C# 3.0 manque de co- et de contre-variance.

Vous voulez probablement utiliser:

list.Cast<IMayClass>().ToList(); 

Answer 4

Je sais que c'est une vieille question, mais pour ceux qui sont à la recherche d'une réponse est ici comment vous pouvez faire est .NET v4

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Runtime.Serialization.Formatters.Binary; 

    namespace ConsoleApplication6 
    { 
     internal class Program 
     { 
      private static void Main(string[] args) 
      { 
       List<ImyInterface> list = new List<ImyInterface>(); 

       list.Add(new MyClass {MyData = "Test1", SpecialData = "special"}); 
       list.Add(new MyOtherClass {MyData = "Test2", OtherData = "other"}); 

       Serialize("c:\\test.dat", list); 
       List<ImyInterface> theList = Deserialize<List<ImyInterface>>("c:\\test.dat"); 
      } 

      public static void Serialize<T>(string filename, T objectToSerialize) 
      { 
       Stream stream = File.Open(filename, FileMode.Create); 
       BinaryFormatter bFormatter = new BinaryFormatter(); 
       bFormatter.Serialize(stream, objectToSerialize); 
       stream.Close(); 
      } 

      public static T Deserialize<T>(string filename) 
      { 
       Stream stream = File.Open(filename, FileMode.Open); 
       BinaryFormatter bFormatter = new BinaryFormatter(); 
       T objectToSerialize = (T) bFormatter.Deserialize(stream); 
       stream.Close(); 
       return objectToSerialize; 
      } 
     } 

     public interface ImyInterface 
     { 
      string MyData { get; set; } 
     } 

     [Serializable] 
     public class MyClass : ImyInterface 
     { 
      public string MyData { get; set; } 
      public string SpecialData { get; set; } 
     } 

     [Serializable] 
     public class MyOtherClass : ImyInterface 
     { 
      public string MyData { get; set; } 
      public string OtherData { get; set; } 
     } 
    } 

Answer 5

vous pouvez sérialiser et désérialiser les interfaces avec le BinaryFormatter, mais ce n'est pas la sérialisation Xml ... Ce que vous avez décrit est exactement ce dont j'ai besoin. En outre, toutes mes classes concrètes sont génériques .. je: interface IMyInterface MyConcreteClass1 classe MyConcreteClass2 classe

et je dois aussi sérialiser une collection de ces objets (liste), avec sérialisation Xml ... regards comme c'est impossible!