Wie mit VBCodeProvider erstellte Assembly in separate AppDomain schieben ?

  • VB.NET
  • .NET (FX) 1.0–2.0

    Wie mit VBCodeProvider erstellte Assembly in separate AppDomain schieben ?

    Hallo Gemeinde,

    ich erstelle gerade eine VB.NET-Applikation und bin nun an einem Punkt angelangt, bei dem ich alleine leider nicht mehr weiter komme.
    Vielleicht kann mir ja jemand von Euch weiterhelfen ?

    Es geht um folgendes:

    Es gibt eine Hauptapplikation, die dem User nur als EXE vorliegen soll. Das Programm soll einen Waferprober steuern, der der Reihe
    nach alle Chips auf einem Siliziumwafer durchstept und dabei jeden Chip mit Nadeln kontaktiert, um an ihm Funktionstests durchzuführen.
    Da unterschiedliche Arten von Chips aber unterschiedliche Funktionstests benötigen, sollen diese Tests in eine Subroutine ausgelagert
    werden, die der User nach seinen Anforderungen jeweils editieren kann.
    Die Subroutine soll sich in einer separaten Datei befinden, die zur Laufzeit dann von der Hauptapplikation eingelesen wird und deren
    Quellcode dann mit dem VBCodeProvider zu einer Assembly wird, auf die dann von der Applikation zugegriffen wird.

    Dies funktioniert soweit auch schon; ich kann auch aus der dynamisch kompillierten Subroutine heraus auf Objekte und Public Shared
    Variablen der Hauptapplikation zugreifen.

    Allerdings wird die dynamsich erstellte Assembly zur selben AppDomain hinzugefügt, wie die Hauptapplikation. D. h. sie läßt sich leider
    nur entladen, indem die gesamte Applikation geschlossen wird, was aber nicht in meinem Sinne ist. Ohne Entlademöglichkeit der
    Assembly wächst aber leider der Speicherverbrauch ziemlich stark an, da in der dynamischen Subroutine viel mit mehrdimensionalen
    Arrays gearbeitet wird.

    Ich habe gelesen, daß es eine Möglichkeit gibt, Assemblies wieder zu entladen, wenn sie zu einer anderen AppDomain hinzugefügt
    werden, als der AppDomain der Hauptapplikation. Der Begriff Marshalling ist mir dabei außerdem noch über den Weg gelaufen,
    aber leider kann ich damit nichts anfangen.
    Alles, was ich zu der Thematik gefunden habe, bezog sich nur auf C# und nicht auf VB.NET.
    Ich könnte eines der C#-Beispiele ev. sogar zu VB.NET konvertieren, aber ich bekomme es leider nicht hin, das Thema "separate
    AppDomain" mit "durch VBCodeProvider dynamisch generierte Assembly" zu verheiraten.

    Hier ist eine eingedampfte Beispielapplikation, die aus einer Datei namens "Code.txt" eine Subroutine lädt und mit VBCodeProvider
    eine dynamische Assembly erstellt. Könnte mir vielleicht jemand dieses Beispiel so umschreiben, daß mir daraus ersichtlich wird,
    wie ich die dynamsiche Assembly in eine separate AppDomain bekomme (und weiterhin daraus auf die Hauptapplikation zugreifen
    kann) ?

    VB.NET-Quellcode

    1. Imports System.IO
    2. Imports System.Reflection
    3. Imports System.CodeDom
    4. Imports System.CodeDom.Compiler
    5. Imports Microsoft.VisualBasic
    7. Public Class Form1
    9. Public Shared obj As Object
    10. Public Shared compResults as Object
    11. Public Shared Dummy as Integer = 1
    12. Public Shared Float(1000,1000,50) as Double
    14. Private Sub Form1_Load( ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
    15. Dim input = My.Computer.FileSystem.ReadAllText("Code.txt")
    16. Dim code as String = ""
    17. code = code & "Imports Microsoft.VisualBasic" & vbCrLf
    18. code = code & "Imports System" & vbCrLf
    19. code = code & "Imports System.Text" & vbCrLf
    20. code = code & "Imports System.Drawing" & vbCrLf
    21. code = code & "Imports System.Diagnostics" & vbCrLf
    22. code = code & "Imports DynamicCompile.Form1" & vbCrLf
    23. code = code & "Public Class DynamicClass" & vbCrLf
    24. code = code & " Public Sub DynamicSub(ByVal f as DynamicCompile.Form1)" & vbCrLf
    25. code = code & input & vbCrLf
    26. code = code & " End Sub" & vbCrLf
    27. code = code & "End Class" & vbCrLf
    29. Debug.Print(code)
    30. Debug.Print("Dummy: "+Str(Dummy))
    32. Dim vbProv = New VBCodeProvider()
    34. Dim vbParams = New CompilerParameters()
    35. vbParams.ReferencedAssemblies.Add("mscorlib.dll")
    37. Dim asm as Assembly
    38. For Each asm in AppDomain.CurrentDomain.GetAssemblies()
    39. vbParams.ReferencedAssemblies.Add(asm.Location)
    40. Next asm
    42. vbParams.CompilerOptions = "/t:library"
    43. vbParams.GenerateExecutable = False
    44. vbParams.GenerateInMemory = True
    45. vbParams.IncludeDebugInformation = True
    47. compResults = vbProv.CompileAssemblyFromSource(vbParams, code.ToString)
    49. If compResults.Errors.Count > 0 Then
    50. Dim er as CompilerError
    51. For Each er In compResults.Errors
    52. MessageBox.Show(er.ToString())
    53. Next er
    54. Else
    55. 'To do:
    56. 'Um ein Unload der dynamisch kompillierten Assembly zu ermöglichen,
    57. 'muß diese in einer neuen AppDomain erstellt werden.
    58. obj = compResults.CompiledAssembly.CreateInstance("DynamicClass")
    59. End If
    60. End Sub
    62. Public Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    63. Dim args() As Object = {Me}
    64. Dim t As Type
    65. 'Call the dynamically compiled subroutine twice
    66. t = obj.GetType().InvokeMember("DynamicSub", BindingFlags.InvokeMethod, Nothing, obj, args)
    67. t = obj.GetType().InvokeMember("DynamicSub", BindingFlags.InvokeMethod, Nothing, obj, args)
    68. Debug.Print("Dummy: "+Str(Dummy))
    69. End Sub
    71. Public Shared Sub Test(ByVal TextToDisplay as String)
    72. Debug.Print(TextToDisplay)
    73. End Sub
    75. End Class


    Hier ist noch der Inhalt der Datei "Code.txt":

    VB.NET-Quellcode

    1. 'This is a comment
    3. Dim arr(1000,1000,50) as Double
    5. f.Text = "Form1's title changed by subroutine in dynamically compiled class."
    6. f.Button1.Backcolor = Color.Red
    8. f.Textbox1.Text = "Textbox1.Text changed by subroutine in dynamically compiled class."
    10. f.Label1.Text = "Label1.Text modified"
    12. Call Test("Subroutine ""Test"" is called from another dynamically compiled class.")
    14. Debug.Print("""Debug.Print"" is called from another dynamically compiled class.")
    16. Debug.Print("Dummy: "+Str(Dummy))
    18. f.Dummy = 2
    20. Dim i, j, k as Integer
    21. For i = 0 To 1000
    22. For j = 0 To 1000
    23. For k = 0 To 50
    24. f.Float(i,j,k) = arr(i,j,k)
    25. Next k
    26. Next j
    27. Next i


    Ich bedanke mich schon einmal herzlich für jede hilfreiche Antwort !

Facebook