C# code:

namespace CompilingExperiments
{
    public class Program
    {
        static int MyValue = 0;
        public static void DoAThing()
        {
            MyValue++;
            Console.WriteLine($"did a thing {MyValue}");
        }

        static void VBSample()
        {
            SyntaxTree syntaxTree = VisualBasicSyntaxTree.ParseText(@"
Imports System

Namespace RoslynCompileSample
   Class Writer
       Private Const MyValue = 123
       Sub Write(str as String)
         Console.WriteLine (str)
       End Sub
        Sub _Execute
            ;
        End Sub
    End Class
End Namespace"
            );

            SyntaxNode rootNode = syntaxTree.GetRoot();

            var allMethods = rootNode.DescendantNodes().OfType<MethodStatementSyntax>();
            var methodNode = allMethods.First(x => x.Identifier.Text == "_Execute");

            var nodeToReplace = methodNode.Parent.DescendantNodes().OfType<EmptyStatementSyntax>().First();

            string usercode = @"
CompilingExperiments.Program.DoAThing()
CompilingExperiments.Program.DoAThing()
";
            SyntaxTree userCodeTree = VisualBasicSyntaxTree.ParseText(
                                     usercode, new VisualBasicParseOptions(kind: SourceCodeKind.Script)
                                 );

            SyntaxNode userCodeRoot = userCodeTree.GetRoot();
            var injectedSyntaxNode = rootNode.ReplaceNode(nodeToReplace, userCodeRoot.ChildNodes());

            string assemblyName = Path.GetRandomFileName();
            MetadataReference[] references = new MetadataReference[]
            {
                MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
                MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
                MetadataReference.CreateFromFile(typeof(Program).Assembly.Location)
            };

            VisualBasicCompilation compilation = VisualBasicCompilation.Create(
                assemblyName,
                syntaxTrees: new[] { injectedSyntaxNode.SyntaxTree },
                references: references,
                options: new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));

            RunCompiledCode(compilation);
        }

        static void RunCompiledCode(Compilation compilation)
        {
            Assembly assembly = null;

            using (var ms = new MemoryStream())
            {
                EmitResult result = compilation.Emit(ms);

                if (!result.Success)
                {
                    IEnumerable<Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
                        diagnostic.IsWarningAsError ||
                        diagnostic.Severity == DiagnosticSeverity.Error);

                    foreach (Diagnostic diagnostic in failures)
                    {
                        Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
                    }
                }
                else
                {
                    ms.Seek(0, SeekOrigin.Begin);
                    assembly = Assembly.Load(ms.ToArray());
                }
            }

            if (assembly != null)
            {
                Type type = assembly.GetType("RoslynCompileSample.Writer");
                object obj = Activator.CreateInstance(type);

                type.InvokeMember("_Execute",
                    BindingFlags.Default | BindingFlags.InvokeMethod,
                    null,
                    obj,
                    null);
            }
        }
    }
}