das serialisieren/Deserialisieren eines assembly-Objekts zu und aus einem byte array

Sagen wir erstellen eine (ausführbare) assembly in den Speicher durch
Zusammenstellung einer code-Zeichenfolge. Dann möchte ich dies serialisieren Montage
Objekt in ein byte-array und speichern Sie dann in einer Datenbank. Dann später
auf ich Sie abrufen möchten, und das byte-array aus der Datenbank und Deserialisieren
das byte-array wieder in ein assembly-Objekt, rufen Sie dann den Eintrag
Punkt der Versammlung.

Zuerst habe ich nur versucht, das zu tun diese Serialisierung wie ich jedes andere Objekt einfach in .net, aber anscheinend funktioniert nicht mit einem assembly-Objekt. Die assembly-Objekt enthält eine Methode namens " GetObjectData die bekommt Serialisierung notwendigen Daten zu instanziieren der Montage. Also ich bin etwas verwirrt, wie ich Stück alles zusammen für mein Szenario.

Die Antwort nur braucht, um zu zeigen, wie Sie ein assembly-Objekt, konvertieren es in ein byte-array zu konvertieren, dass Sie zurück in eine assembly, und führen Sie die Eingabe-Methode auf dem deserialisiert Montage.

InformationsquelleAutor Beaker | 2011-10-02
  1. 4

    Einer Montage ist bequemer vertreten, einfach als binäre dll-Datei. Wenn Sie denken, es wie, der rest der Probleme verdunsten. Insbesondere, schauen Sie auf Assembly.Load(byte[]) für laden eine Assembly aus binäre. Zu schreiben es als binary, nutzen CompileAssemblyFromSource und Blick auf das Ergebnis ist PathToAssembly - dann File.ReadAllBytes(path) zu erhalten, die Binär aus der Datei.

    • Aber was ist, wenn Sie die Zusammenstellung ganz in Erinnerung?
    • dann ist das ein Schmerz ;p ich habe nicht sofort eine Antwort gibt, außer "kompilieren, um die temp-Ordner wäre einfacher hier"
    • wenn niemand kommt mit einem in-memory-Antwort innerhalb einer Woche, dann werde ich mark dieses die Antwort.
    InformationsquelleAutor Marc Gravell
  2. 1

    Einen schmutzigen trick, um die Montage-bytes mit der spiegelung:

      MethodInfo pi = assembly.GetType().GetMethod("GetRawBytes", BindingFlags.Instance | BindingFlags.NonPublic);
  object o = pi.Invoke(assembly, null);

  byte[] assemblyBytes = (byte[])o;

    Erklärung: zumindest in meinem Beispiel (assembly geladen wurde aus dem byte-array) der assembly-Instanz war der Typ "System.Reflexion.RuntimeAssembly". Dies ist eine interne Klasse, also nur zugegriffen werden, unter Verwendung von reflektion ab. "RuntimeAssembly" hat eine Methode "GetRawBytes", die Rückkehr der Baugruppe bytes.

    InformationsquelleAutor wknauf
  3. 1

    Hier ist mein Beispiel:

    public static byte[] SerializeAssembly()
{
  var compilerOptions = new Dictionary<string, string> { { "CompilerVersion", "v4.0" } };
  CSharpCodeProvider provider = new CSharpCodeProvider(compilerOptions);

  CompilerParameters parameters = new CompilerParameters()
  {
    GenerateExecutable = false,
    GenerateInMemory = false,
    OutputAssembly = "Examples.dll",
    IncludeDebugInformation = false,
  };
  parameters.ReferencedAssemblies.Add("System.dll");

  ICodeCompiler compiler = provider.CreateCompiler();
  CompilerResults results = compiler.CompileAssemblyFromSource(parameters, StringClassFile());

  return File.ReadAllBytes(results.CompiledAssembly.Location);
}

private static Assembly DeserializeAssembyl(object fromDataReader)
{
  byte[] arr = (byte[])fromDataReader;
  return Assembly.Load(arr);
}



private string StringClassFile()
    {
      return "using System;" +
      "using System.IO;" +
      "using System.Threading;" +
      "namespace Examples" +
      "{" +
      " public class FileCreator" +
      " {" +
      "     private string FolderPath { get; set; }" +
      "     public FileCreator(string folderPath)" +
      "     {" +
      "         this.FolderPath = folderPath;" +
      "     }" +
      "     public void CreateFile(Guid name)" +
      "     {" +
      "         string fileName = string.Format(\"{0}.txt\", name.ToString());" +
      "         string path = Path.Combine(this.FolderPath, fileName);" +
      "         if (!File.Exists(path))" +
      "         {" +
      "             using (StreamWriter sw = File.CreateText(path))" +
      "             {" +
      "                 sw.WriteLine(\"file: {0}\", fileName);" +
      "                 sw.WriteLine(\"Created from thread id: {0}\", Thread.CurrentThread.ManagedThreadId);" +
      "             }" +
      "         }" +
      "         else" +
      "         {" +
      "             throw new Exception(string.Format(\"duplicated file found {0}\", fileName));" +
      "         }" +
      "     }" +
      " }" +
      "}";
    }
    InformationsquelleAutor Ro.
  4. 0

    System.Reflection.Assembly ist ISerializable und kann einfach serialisiert werden, etwa so:

    Assembly asm = Assembly.GetExecutingAssembly();
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream();
formatter.Serialize(stream, asm);

    und Deserialisierung ist nur als einfache, aber nennen BinaryFormatter.Deserialize statt.

    • Deserializating es wird nicht zu den gleichen Versammlung... In anderen Worten, die Größe des Speicher-stream, die Sie erstellen, ist nicht gleich die Größe der assembly-Datei.
    • Wahrscheinlich nicht, aber Sie fragten speziell zum serialisieren des Objekts, die dies tun wird. Es bedeutet nicht unbedingt, es wird das sein, was der Programmierer erwartet. Obwohl, ich würde wollen, um zu testen, und überprüfen Sie Ihre Aussage, ich denke, es sollte einen funktionell identischen Baugruppe.
    • System.Reflexion.Montage-System implementiert.- Laufzeit.Serialisierung.ISerializable-Schnittstelle und in einem GetObjectData-Methode serialisiert seiner Eigenschaft FullName. Beim Deserialisieren lädt die Versammlung aus Ihrer FullName-so funktioniert es beim serialisieren und Deserialisieren für Baugruppen bekannt, die für die Anwendungsdomäne, aber es ist nicht "serialisieren eine Montage-Lösung".referencesource.microsoft.com/#mscorlib/system/reflection/...
    InformationsquelleAutor Michael J. Gray
Schreibe einen Kommentar