VB.NET及其他语言是否支持程序化编辑代码？有无类VBE的实现方式

Great question! VBA's ability to programmatically tweak modules via the VBE feels like a superpower, and you're right—dynamic code manipulation is a fascinating area. Let's break down how to do similar things in VB.NET and other popular languages.

VB.NET Options #

VB.NET is a compiled language, so it doesn't let you directly edit existing compiled modules at runtime like VBA does. But you have two strong approaches to achieve similar results:

1. CodeDOM (Legacy but Straightforward) #

CodeDOM lets you generate code as strings, compile it into a dynamic assembly, and load it at runtime. For example, if you want to add a Hello() function alongside your existing test() in a module:

Imports System.CodeDom.Compiler
Imports Microsoft.VisualBasic

' Build code string with original test() + new Hello()
Dim code As String = "
Module ModuleA
    Sub test()
        Console.WriteLine(""Original test method"")
    End Sub
    Sub Hello()
        Console.WriteLine(""Hello from dynamic method!"")
    End Sub
End Module"

' Compile the code in memory
Dim provider As New VBCodeProvider()
Dim parameters As New CompilerParameters() With {
    .GenerateInMemory = True,
    .ReferencedAssemblies.Add("System.dll")
}
Dim results As CompilerResults = provider.CompileAssemblyFromSource(parameters, code)

' Load and execute the dynamic methods
Dim assembly = results.CompiledAssembly
Dim moduleType = assembly.GetType("ModuleA")
moduleType.GetMethod("test").Invoke(Nothing, Nothing)
moduleType.GetMethod("Hello").Invoke(Nothing, Nothing)

Note: This creates a new compiled assembly with both methods—you can't modify an already loaded assembly directly.

2. Roslyn Compiler API (Modern & Powerful) #

Roslyn is Microsoft's "Compiler-as-a-Service" toolset, which lets you work with syntax trees directly. You can generate or modify code structure programmatically, then compile it on the fly. For adding an AddTeacher() method to your School class:

Imports Microsoft.CodeAnalysis
Imports Microsoft.CodeAnalysis.VisualBasic
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax

' Start with your existing School class code
Dim originalCode As String = "
Public Class School
    Public Sub AddStudent(name As String)
        Console.WriteLine(""Added student: "" & name)
    End Sub
End Class"

' Parse into a syntax tree
Dim tree = VisualBasicSyntaxTree.ParseText(originalCode)
Dim root = tree.GetRoot()

' Build the new AddTeacher method syntax
Dim newMethod = VisualBasicSyntaxFactory.SubStatement(
    VisualBasicSyntaxFactory.Identifier("AddTeacher"),
    VisualBasicSyntaxFactory.ParameterList(
        VisualBasicSyntaxFactory.SingletonSeparatedList(
            VisualBasicSyntaxFactory.Parameter(
                VisualBasicSyntaxFactory.Identifier("name")
            ).WithAsClause(
                VisualBasicSyntaxFactory.SimpleAsClause(
                    VisualBasicSyntaxFactory.PredefinedType(
                        VisualBasicSyntaxFactory.Token(SyntaxKind.StringKeyword)
                    )
                )
            )
        )
    ),
    VisualBasicSyntaxFactory.Block(
        VisualBasicSyntaxFactory.SingletonList(Of StatementSyntax)(
            VisualBasicSyntaxFactory.ExpressionStatement(
                VisualBasicSyntaxFactory.InvocationExpression(
                    VisualBasicSyntaxFactory.MemberAccessExpression(
                        SyntaxKind.SimpleMemberAccessExpression,
                        VisualBasicSyntaxFactory.IdentifierName("Console"),
                        VisualBasicSyntaxFactory.IdentifierName("WriteLine")
                    ),
                    VisualBasicSyntaxFactory.ArgumentList(
                        VisualBasicSyntaxFactory.SingletonSeparatedList(
                            VisualBasicSyntaxFactory.Argument(
                                VisualBasicSyntaxFactory.BinaryExpression(
                                    SyntaxKind.ConcatenateExpression,
                                    VisualBasicSyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, VisualBasicSyntaxFactory.Token(SyntaxKind.StringLiteralToken, """Added teacher: """)),
                                    VisualBasicSyntaxFactory.IdentifierName("name")
                                )
                            )
                        )
                    )
                )
            )
        )
    )
).WithModifiers(VisualBasicSyntaxFactory.TokenList(VisualBasicSyntaxFactory.Token(SyntaxKind.PublicKeyword)))

' Insert the new method into the class
Dim updatedRoot = root.ReplaceNode(
    root.DescendantNodes().OfType(Of ClassBlockSyntax)().First(),
    root.DescendantNodes().OfType(Of ClassBlockSyntax)().First().AddMembers(newMethod)
)

' Compile the updated code
Dim compilation = VisualBasicCompilation.Create(
    "DynamicSchoolAssembly",
    syntaxTrees:={VisualBasicSyntaxTree.Create(updatedRoot)},
    references:={MetadataReference.CreateFromFile(GetType(Object).Assembly.Location)}
)

' Load and use the updated class
Using ms As New IO.MemoryStream()
    Dim result = compilation.Emit(ms)
    If result.Success Then
        ms.Seek(0, IO.SeekOrigin.Begin)
        Dim assembly = System.Reflection.Assembly.Load(ms.ToArray())
        Dim schoolType = assembly.GetType("School")
        Dim school = Activator.CreateInstance(schoolType)
        schoolType.GetMethod("AddStudent").Invoke(school, {"Alice"})
        schoolType.GetMethod("AddTeacher").Invoke(school, {"Mr. Smith"})
    End If
End Using

Roslyn eliminates messy string concatenation for complex code and gives you fine-grained control over syntax structure.

Other Languages #

Let's quickly cover a couple more popular options:

Python (Dynamic Language) #

Python makes this trivial since it's dynamically typed and allows runtime modification:

# Existing test function
def test():
    print("Original test function")

# Add Hello() dynamically
exec("""
def Hello():
    print("Hello from dynamic function!")
""")

test()
Hello()

# Add AddTeacher to the School class
class School:
    def AddStudent(self, name):
        print(f"Added student: {name}")

def AddTeacher(self, name):
    print(f"Added teacher: {name}")

School.AddTeacher = AddTeacher  # Attach method to the class
school = School()
school.AddStudent("Bob")
school.AddTeacher("Ms. Lee")

JavaScript #

Similar to Python, you can modify objects and classes at runtime:

// Existing School class
class School {
    AddStudent(name) {
        console.log(`Added student: ${name}`);
    }
}

// Add AddTeacher method dynamically
School.prototype.AddTeacher = function(name) {
    console.log(`Added teacher: ${name}`);
};

const school = new School();
school.AddStudent("Charlie");
school.AddTeacher("Dr. Brown");

Key Difference from VBA #

VBA lets you modify the live, running VBA project directly (changes persist in the module). For compiled languages like VB.NET, you're typically generating new compiled assemblies or using reflection to work with dynamic code—you can't edit already loaded compiled code. Dynamic languages like Python/JS are closer to VBA's flexibility here.

内容的提问来源于stack exchange，提问作者Sum