Persistere un oggetto che non è contrassegnato come serializzabile

Question

Ho bisogno di mantenere un oggetto che non è contrassegnato con l'attributo serializable. L'oggetto proviene da una libreria di terze parti che non posso modificare.

Ho bisogno di memorizzarlo in un posto fisso, come ad esempio il file system, quindi la soluzione ottimale sarebbe serializzare l'oggetto in un file, ma dal momento che non è contrassegnato come serializzabile, non è una scala soluzione avanzata.

È un oggetto piuttosto complesso, che contiene anche una raccolta di altri oggetti.

Avete qualche suggerimento su come risolvere questo problema? Il codice non verrà mai eseguito in un ambiente di produzione, quindi sto bene con quasi tutte le soluzioni e le prestazioni.

Answer 1

XmlSerializer può essere un utile prima cosa da provare, i tipi sono pubblici, ecc.

Se ciò fallisce, v2 di protobuf-net (in corso, si dovrebbe d per costruire dal sorgente, ma posso aiutare) funziona con oggetti non attribuiti, quindi ideale per tipi al di fuori del tuo controllo - devi solo dirgli cosa includere (tramite DSL). Il codice v2 non è completo, ma copre gli scenari più comuni, comprese le raccolte ecc. (Il lavoro incompleto è principalmente callback ed enumerazioni).

Answer 2

Non so se è eccessivo per il vostro utilizzo, ma ho giocato ultimamente con db4o. Persisterà qualsiasi oggetto, basta chiamare IObjectContainer.Store (oggetto) ed è leggero e basato su file. Non richiede alcuna installazione.

Non ho ancora avuto problemi con esso.

Answer 3

questo è un modo si potrebbe fare:

http://www.codeproject.com/KB/dotnet/Surrogate_Serialization.aspx

Ecco il link MSDN mostrarla:

http://msdn.microsoft.com/en-us/magazine/cc188950.aspx

Answer 4

È possibile scrivere un metodo ricorsivo che esegua il grafico degli oggetti utilizzando il reflection per mantenere l'oggetto ... Riportarlo potrebbe essere molto più difficile. Chissà se qualcuno di questi oggetti contiene riferimenti a risorse non gestite o di sistema. Se dovessi fare qualcosa di pazzesco, sceglierei il metodo .GetFields(...) per il tipo.

Un'altra idea ...

Se sei solo facendo questo per accelerare lo sviluppo perché non avvolgere le loro clases con le proprie classi adattatore. Ciò ti consentirebbe di sostituire le librerie di terze parti con le tue classi di simulazione semplificate e di consentire migliori possibilità di sostituzione e riutilizzo in seguito.

Malato come è ... Questo è stato più facile di quanto pensassi. (Anche se questo funziona ... perche avvolgendo le classi terze parti.)

public static class Tools 
{ 
    public static XElement AsXml(this object input) 
    { 
     return input.AsXml(string.Empty); 
    } 
    public static XElement AsXml(this object input, string name) 
    { 
     if (string.IsNullOrEmpty(name)) 
      name = input.GetType().Name; 

     var xname = XmlConvert.EncodeName(name); 

     if (input == null) 
      return new XElement(xname); 

     if (input is string || input is int || input is float /* others */) 
      return new XElement(xname, input); 

     var type = input.GetType(); 
     var fields = type.GetFields(BindingFlags.Instance | 
            BindingFlags.NonPublic) 
         .Union(type.GetFields(BindingFlags.Instance | 
               BindingFlags.Public)); 

     var elems = fields.Select(f => f.GetValue(input) 
             .AsXml(f.Name)); 

     return new XElement(xname, elems); 
    } 
    public static void ToObject(this XElement input, object result) 
    { 
     if (input == null || result == null) 
      throw new ArgumentNullException(); 

     var type = result.GetType(); 
     var fields = type.GetFields(BindingFlags.Instance | 
            BindingFlags.NonPublic) 
         .Union(type.GetFields(BindingFlags.Instance | 
               BindingFlags.Public)); 

     var values = from elm in input.Elements() 
        let name = XmlConvert.DecodeName(elm.Name.LocalName) 
        join field in fields on name equals field.Name 
        let backType = field.FieldType 
        let val = elm.Value 
        let parsed = backType.AsValue(val, elm) 
        select new 
        { 
         field, 
         parsed 
        }; 

     foreach (var item in values) 
      item.field.SetValue(result, item.parsed);    
    } 

    public static object AsValue(this Type backType, 
             string val, 
             XElement elm) 
    { 
     if (backType == typeof(string)) 
      return (object)val; 
     if (backType == typeof(int)) 
      return (object)int.Parse(val); 
     if (backType == typeof(float)) 
      return (float)int.Parse(val); 

     object ret = FormatterServices.GetUninitializedObject(backType); 
     elm.ToObject(ret); 
     return ret; 
    } 
} 
public class Program 
{ 
    public static void Main(string[] args) 
    { 
     var obj = new { Matt = "hi", Other = new { ID = 1 } }; 
     var other = new { Matt = "zzz", Other = new { ID = 5 } }; 
     var ret = obj.AsXml(); 
     ret.ToObject(other); 
     Console.WriteLine(obj); //{ Matt = hi, Other = { ID = 1 } } 
     Console.WriteLine(other); //{ Matt = hi, Other = { ID = 1 } } 
    } 
} 

Answer 5

///Here OBJECT is Class name and Object_to_write is instance 
XmlSerializer serializer = new XmlSerializer(typeof(OBJECT)); 
using (TextWriter writer = new StreamWriter(@"C:\Xml.xml")) 
{ 
    serializer.Serialize(writer, OBJECT_to_Write); 
}