Faire interagir du code VBCodeProvider avec le code qui y fait recours

Version imprimable

1 pièce(s) jointe(s)

Bonjour,

Je souhaite que l'utilisateur puisse taper un script que mon programme va exécuter
Plutôt que de tout créer de A à Z, il est assez facile d’exécuter un code VB tapé dans une zone de texte :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
    Private Function RunVbCode(ByVal CodeSource As String) As String
        Dim vbCodeProv As VBCodeProvider = New VBCodeProvider
        Dim cParam As CodeDom.Compiler.CompilerParameters = New CodeDom.Compiler.CompilerParameters
 
        ' Ajout des références
        cParam.ReferencedAssemblies.Add("System.dll")
 
        ' Options du compilateur
        cParam.CompilerOptions = "/t:library"  'L'assembly est une bibliothèque de classe,
        cParam.GenerateInMemory = True         'générée uniquement en mémoire.
 
        ' Génération du code source
        Dim sCode As System.Text.StringBuilder = New System.Text.StringBuilder("")
        sCode.AppendLine("Imports System")
        sCode.AppendLine("Namespace StringAsCode")
        sCode.AppendLine(vbTab & "Class VbCodeInString")
        sCode.AppendLine(vbTab & vbTab & "Public Function Main() as string")
        sCode.AppendLine(vbTab & vbTab & vbTab & "Try")
        sCode.AppendLine(CodeSource) 'Là on insère le code tapé par l'utilisateur dans la zone de texte
        sCode.AppendLine(vbTab & vbTab & vbTab & "Return ""OK""")
        sCode.AppendLine(vbTab & vbTab & vbTab & "Catch ex As Exception")
        sCode.AppendLine(vbTab & vbTab & vbTab & vbTab & "Return ex.Message")
        sCode.AppendLine(vbTab & vbTab & vbTab & "End Try")
        sCode.AppendLine(vbTab & vbTab & "End Function")
        sCode.AppendLine(vbTab & "End Class")
        sCode.AppendLine("End Namespace")
 
        ' Résultat de la compilation
        Dim cResult As CodeDom.Compiler.CompilerResults = vbCodeProv.CompileAssemblyFromSource(cParam, sCode.ToString())
        If cResult.Errors.Count > 0 Then
            Dim Errors As String = "Erreur(s) : "
            For Each ce As CodeDom.Compiler.CompilerError In cResult.Errors
                Errors &= vbCrLf & ce.ErrorText
            Next ce
            Return Errors
        Else
            ' Récupération de l'assembly généré
            Dim myAssembly As System.Reflection.Assembly = cResult.CompiledAssembly
            ' Instanciation de EvalVbCode
            Dim oVbCode As Object = myAssembly.CreateInstance("StringAsCode.VbCodeInString")
            ' Récupération du type de Main()
            Dim tVbCode As Type = oVbCode.GetType()
            ' Récupération de la function Main()
            Dim functionVbCode As Reflection.MethodInfo = tVbCode.GetMethod("Main")
            ' Invocation de la function Main()
            Return CType(functionVbCode.Invoke(oVbCode, Nothing), String) 'Remarque : si la fonction Main() a des paramètres, on les passe à la place de Nothing
        End If
    End Function
 
    Private Sub ButRun_Click(sender As Object, e As EventArgs) Handles ButRun.Click
        'Debug.Print("RUN : " & ExecuteCommand(Txt.Text))
        MsgBox("RUN : " & RunVbCode(Txt.Text))
 
    End Sub

Voici le résultat :

Pièce jointe 623949

Mais ce code est presque totalement "déconnecté" de mon application...
C'est comme si je lançait un .exe indépendant.
On peut juste passer des paramètres à la fonction Main() et récupérer le résultat de la fonction Main()
Paramètres et résultat dont les types et le nombre ne sont pas modifiables au moment de l'exectution.

Ce que je voudrais, c'est que le code tapé dans la zone de texte puisse utiliser des fonctions et des variables publiques de mon application
Savez-vous comment faire ?

A bientôt

20/08/2022, 22h11
Pol63

le mieux est que ca soit toi qui donnes à dispo à cette méthode des objets ayant tout ce qui pourrait être nécessaire dedans
et donc que cette méthode prennent des paramètres
tu pourras donc l'appeler en lui passant en paramètres la ou les instances nécessaires

dans l'autre sens c'est faisable aussi
21/08/2022, 18h52
Pol63

j'oubliais, en referencedassemblies il faut aussi ajouter la ou les dll/exe qui contiennent les choses qui vont être passées
22/08/2022, 10h52
electroremy

Si je comprends bien ce que tu dis, il faut que je compile le code à exécuter en incluant une DLL avec mes fonctions à moi

Le soucis, c'est que le code compilé sera "autonome", c'est à dire qu'il n'aura pas accès aux variables ni aux fonctions du code du programme qui lance la compilation

Ou alors, en plus d'inclure une DLL avec mes fonctions à moi, il faut que je passe tout ce qui est nécessaire en paramètres et que je récupère tous les résultats avec une valeur de retour (qui peut être un objet contenant plein de choses) - même si c'est possible ça va être très lourd, car les données en questions peuvent êtres très lourdes - genre données "3D", j'arrive à consommer toute la RAM disponible :mouarf:

Y a-t-il quelque chose de plus "subtil", je pense à faire une classe qui permettrait à mon programme de communiquer avec celui compilé ?

Bien sûr il reste la solution de refaire moi-même un langage de script mais c'est réinventer la roue

A bientôt
24/08/2022, 11h55
Pol63

non ce n'est pas ca que je dis
le code que tu compiles est intégré à ton code, quand tu fais invoke c'est ton programme qui l'appelle, comme si c'était une méthode que tu avais déjà écrite dans ton projet

donc si cette méthode prend quelque chose en paramètre elle peut y accéder
si cette méthode appelle quelque chose de shared dans ton code elle peut y avoir accès (enfin si dans referencesassemblies tu ajoutes tes assemblies avant la compilation, comme tu ajoutes system.dll)

et il n'y a pas de problème de mémoire, si tu passe un objet seule la référence est passée à la méthode, donc 4 ou 8 octets peu importe la taille réelle de l'objet
24/08/2022, 14h13
electroremy

Merci pour ta réponse, qui montrent qu'une solution est possible

Mais j'avoue que je n'ai pas tout compris :aie: :mouarf:

Il faudrait donc :
- que dans le code de mon application :je déclare 'shared' toutes les fonctions que je veux appeler dans le code invoké
- et qu'en plus, j'ajoute dans 'referencesassemblies' les 'assemblies' correspondant aux fonctions 'shared'

Je vais chercher de ce côté...

S'il existe un exemple ou un tuto je suis preneur, car je vais y aller en mode bourrin :mrgreen: :aie:

A bientôt
24/08/2022, 15h44
Pol63

l'histoire du shared c'était si tu avais déjà le cas où n'importe quel morceau de ton appli pouvait demander des choses au reste de l'appli sans avoir de référence

tu disais "Ce que je voudrais, c'est que le code tapé dans la zone de texte puisse utiliser des fonctions et des variables publiques de mon application"
c'est possible, il suffit qu'elles soient shared, ou que tu aies une ou des instances de quelque chose en paramètre de ta méthode
au lieu de main() ca serait main(appData as AppData) par exemple

par contre dans les 2 cas ta méthode va être compilé dans une dll virtuelle, et il faut que cette dll connaisse ton code pour pouvoir interragir avec lui, d'où le cParam.ReferencedAssemblies.Add(ton code)
pour ca tu peux faire un for each assembly in appdomain.current.getassemblies() ca contient tous les assemblies chargées à l'instant T (dont system.dll ^^) pour l'ajouter à la dll virtuelle