Sérialiser un objet puis le désérialiser en tant que liste <object> C#

Question

Je suis coincé dans ce problème et j'ai cherché partout des réponses mais je n'ai pas trouvé quelque chose qui corresponde à mon problème. Je veux sérialiser objet et l'enregistrer dans un fichier binaire, et deserialize comme liste car il va retourner plusieurs lignes d'enregistrements.

Alors, voici ma classe

[Serializable] 
public class DTOMultiConfig 
{ 
    public string Key { get; set; } 
    public string KeyValue { get; set; } 
} 

[Serializable] 
public class DTOMultiConfigs : List<DTOMultiConfig> 
{ 
    public void Dispose() 
    { 
    } 
} 

et je suis en utilisant ces méthodes que j'ai trouvé en ligne. Voilà comment je sérialiser mon objet, cette partie fonctionne

public void Editor_Config(DTOMultiConfig dto) 
{ 
    if (dto.ID == 0)//new 
    { 
     dto.ID = 0; 
     WriteToBinaryFile(BinPath, dto, true); 
    } 
    else//edit 
    { 
    } 
} 

public static void WriteToBinaryFile<T>(string filePath, T objectToWrite, bool append = false) 
{ 
    using (Stream stream = System.IO.File.Open(filePath, append ? FileMode.Append : FileMode.Create)) 
    { 
     var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); 
     binaryFormatter.Serialize(stream, objectToWrite); 
    } 
} 

Voici comment j'utilise la méthode deserialize, je ne suis pas sûr, je suis sûr que je suis en train de faire dans le mauvais sens parce qu'il ne fonctionne pas à tout. Le ReadFromBinaryFile cesse de fonctionner juste avant l'instruction 'return'.

public PartialViewResult ShowListOfConfigs() 
{ 
    List<DTOMultiConfig> dto = new List<DTOMultiConfig>(); 

    //DESERIALIZE 

    dto = ReadFromBinaryFile<List<DTOMultiConfig>>(BinPath); 
    return PartialView("_ListOfConfigs", dto); 
} 

public static T ReadFromBinaryFile<T>(string filePath) 
{ 
    using (Stream stream = System.IO.File.Open(filePath, FileMode.Open)) 
    { 
     var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); 
     return (T)binaryFormatter.Deserialize(stream); 
    } 
} 

Toutes les réponses avec quelques explications seront appréciées.

Answer 1

Laissez-moi essayer d'expliquer. Imaginez que vous n'utilisiez pas un sérialiseur binaire mais plutôt un Serializer XML. Dans ce cas, ce que vous seriez en train d'écrire regarderait un peu comme ceci:

<DTOMultiConfig> 
    <Key>SomeKey</Key> 
    <Value>SomeValue</Value> 
</DTOMultiConfig> 

Maintenant, lorsque vous lisez vos données, vous essayez de désérialiser votre seule instance dans une liste qui, cependant, devrait ressemble quelque peu à ceci:

<ListOfDTOMultiConfigs> 
    <DTOMultiConfig> 
    <Key>SomeKey</Key> 
    <Value>SomeValue</Value> 
    </DTOMultiConfig> 
    [...potentially more elements here...] 
</ListOfDTOMultiConfigs> 

Cela ne peut simplement pas fonctionner. Dans un monde binaire, les données réelles dans le fichier sembleraient différentes. Cependant, le même problème persiste: Vous ne pouvez pas écrire un type et en lire un autre à moins que leur structure ne soit absolument identique.

Afin de traiter votre cas concret, vous pouvez relire un seul élément et le mettre dans une liste si vous avez besoin de la liste. Ou vous pouvez écrire une liste avec un seul élément dans votre fichier et ensuite lire cette liste en utilisant votre code ci-dessus.

EDIT:

Dans votre commentaire ci-dessus, vous dites que vous attendez que l'écriture d'un seul élément deux fois au fichier devrait vous donner une liste. Pour en revenir à mon exemple ci-dessus, l'écriture d'un seul élément serait deux fois vous donner ceci:

<DTOMultiConfig> 
    <Key>SomeKey</Key> 
    <Value>SomeValue</Value> 
</DTOMultiConfig> 
<DTOMultiConfig> 
    <Key>SomeKey</Key> 
    <Value>SomeValue</Value> 
</DTOMultiConfig> 

Si vous comparez cela à mon exemple pour la représentation d'une liste ci-dessus, vous verrez qu'ils ne sont pas identiques et ne peut donc pas être utilisé de manière interchangeable.