protected override void ConfigureHostSetup(HostSetup hostSetup, TestPackage testPackage, string assemblyPath, AssemblyMetadata assemblyMetadata)
{
base.ConfigureHostSetup(hostSetup, testPackage, assemblyPath, assemblyMetadata);
// csUnit always creates its own AppDomain with shadow copy enabled so we do not need this.
hostSetup.ShadowCopy = false;
}
protected override void ConfigureHostSetup(HostSetup hostSetup, TestPackage testPackage,
string assemblyPath, AssemblyMetadata assemblyMetadata)
{
base.ConfigureHostSetup(hostSetup, testPackage, assemblyPath, assemblyMetadata);
if (hostSetup.ProcessorArchitecture == ProcessorArchitecture.Amd64
|| hostSetup.ProcessorArchitecture == ProcessorArchitecture.IA64)
throw new ModelException("Cannot run MSTest tests compiled for 64bit because MSTest.exe throws exceptions when run without isolation as a 64bit process.");
hostSetup.ProcessorArchitecture = ProcessorArchitecture.X86;
}
/// <summary>
/// Load the assembly in the reflection context by name. Will succeed if the referenced assembly name can
/// be found using default assembly loading rules (i.e. it is in the current directory or the GAC)
/// </summary>
/// <param name="assemblyName">The full name of the assembly</param>
/// <returns>Information on the given assembly, if it was loaded successfully, or null if there is an
/// assembly loading issue. </returns>
public AssemblyMetadata GetReflectedAssemblyInfo(string assemblyName)
{
if (string.IsNullOrWhiteSpace(assemblyName))
{
throw new ArgumentException("assemblyName");
}
AssemblyMetadata result = null;
try
{
result = new AssemblyMetadata(Assembly.ReflectionOnlyLoad(assemblyName));
}
catch
{
}
return result;
}
/// <summary>
/// Extracts types, extensions and namespaces data from given assembly and adds it to global
/// collections to make sure we have unique data accross all assemblies in a package.
/// </summary>
public void ProcessAssembly(AssemblyMetadata assembly)
{
try
{
var metadata = MetadataReference.CreateFromFile(assembly.FullPath);
// create an empty CSharp compillation and add a single reference to given assembly.
// Note: Even though we do use CSharp compillation here, we only se it to retrieve
// metadata, that should be common accross .Net assemblies (most of the times according to Roslyn)
var compilation = CSharpCompilation.Create("dummy.dll", references: new[] { metadata });
var assemblySymbol = (IAssemblySymbol)compilation.GetAssemblyOrModuleSymbol(metadata);
ProcessNamespace(assembly, assemblySymbol.GlobalNamespace);
}
catch(Exception e)
{
Debug.Write(e.ToString());
}
}
protected override Metadata GetMetadataImpl()
{
return(AssemblyMetadata.CreateFromImage(_metadataBytes));
}
internal static MetadataReference CompileIL(string ilSource, bool prependDefaultHeader = true, bool embedInteropTypes = false, bool autoInherit = true)
{
EmitILToArray(ilSource, prependDefaultHeader, includePdb: false, assemblyBytes: out var assemblyBytes, pdbBytes: out var pdbBytes, autoInherit: autoInherit);
return(AssemblyMetadata.CreateFromImage(assemblyBytes).GetReference(embedInteropTypes: embedInteropTypes));
}
private void CompileTimeAndRuntimeAssemblies(
ImmutableArray <MetadataReference> compileReferences,
ImmutableArray <MetadataReference> runtimeReferences,
string storageAssemblyName)
{
var source =
@"class C
{
static void M(LibraryA.A a, LibraryB.B b, Windows.Data.Text.TextSegment t, Windows.Storage.StorageFolder f)
{
}
}";
var compilation0 = CreateEmptyCompilation(source, compileReferences, TestOptions.DebugDll);
WithRuntimeInstance(compilation0, runtimeReferences, runtime =>
{
var context = CreateMethodContext(runtime, "C.M");
string error;
var testData = new CompilationTestData();
context.CompileExpression("(object)a ?? (object)b ?? (object)t ?? f", out error, testData);
Assert.Null(error);
testData.GetMethodData("<>x.<>m0").VerifyIL(
@"{
// Code size 17 (0x11)
.maxstack 2
IL_0000: ldarg.0
IL_0001: dup
IL_0002: brtrue.s IL_0010
IL_0004: pop
IL_0005: ldarg.1
IL_0006: dup
IL_0007: brtrue.s IL_0010
IL_0009: pop
IL_000a: ldarg.2
IL_000b: dup
IL_000c: brtrue.s IL_0010
IL_000e: pop
IL_000f: ldarg.3
IL_0010: ret
}");
testData = new CompilationTestData();
var result = context.CompileExpression("default(Windows.Storage.StorageFolder)", out error, testData);
Assert.Null(error);
var methodData = testData.GetMethodData("<>x.<>m0");
methodData.VerifyIL(
@"{
// Code size 2 (0x2)
.maxstack 1
IL_0000: ldnull
IL_0001: ret
}");
// Check return type is from runtime assembly.
var assemblyReference = AssemblyMetadata.CreateFromImage(result.Assembly).GetReference();
var compilation = CSharpCompilation.Create(
assemblyName: ExpressionCompilerUtilities.GenerateUniqueName(),
references: runtimeReferences.Concat(ImmutableArray.Create <MetadataReference>(assemblyReference)));
var assembly = ImmutableArray.CreateRange(result.Assembly);
using (var metadata = ModuleMetadata.CreateFromImage(ImmutableArray.CreateRange(assembly)))
{
var reader = metadata.MetadataReader;
var typeDef = reader.GetTypeDef("<>x");
var methodHandle = reader.GetMethodDefHandle(typeDef, "<>m0");
var module = (PEModuleSymbol)compilation.GetMember("<>x").ContainingModule;
var metadataDecoder = new MetadataDecoder(module);
SignatureHeader signatureHeader;
BadImageFormatException metadataException;
var parameters = metadataDecoder.GetSignatureForMethod(methodHandle, out signatureHeader, out metadataException);
Assert.Equal(5, parameters.Length);
var actualReturnType = parameters[0].Type;
Assert.Equal(TypeKind.Class, actualReturnType.TypeKind); // not error
var expectedReturnType = compilation.GetMember("Windows.Storage.StorageFolder");
Assert.Equal(expectedReturnType, actualReturnType);
Assert.Equal(storageAssemblyName, actualReturnType.ContainingAssembly.Name);
}
});
}
public PEDeltaAssemblyBuilder(
SourceAssemblySymbol sourceAssembly,
string outputName,
OutputKind outputKind,
ModulePropertiesForSerialization serializationProperties,
IEnumerable <ResourceDescription> manifestResources,
Func <AssemblySymbol, AssemblyIdentity> assemblySymbolMapper,
EmitBaseline previousGeneration,
IEnumerable <SemanticEdit> edits)
: base(sourceAssembly, outputName, outputKind, serializationProperties, manifestResources, assemblySymbolMapper, additionalTypes: ImmutableArray <NamedTypeSymbol> .Empty, metadataOnly: false)
{
var context = new Context(this, null, new DiagnosticBag());
var module = previousGeneration.OriginalMetadata;
var compilation = sourceAssembly.DeclaringCompilation;
var metadataAssembly = compilation.GetBoundReferenceManager().CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata.Create(module), MetadataImportOptions.All);
var metadataDecoder = new Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE.MetadataDecoder(metadataAssembly.PrimaryModule);
previousGeneration = EnsureInitialized(previousGeneration, metadataDecoder);
var matchToMetadata = new SymbolMatcher(previousGeneration.AnonymousTypeMap, sourceAssembly, context, metadataAssembly);
SymbolMatcher matchToPrevious = null;
if (previousGeneration.Ordinal > 0)
{
var previousAssembly = ((CSharpCompilation)previousGeneration.Compilation).SourceAssembly;
var previousContext = new Context((PEModuleBuilder)previousGeneration.PEModuleBuilder, null, new DiagnosticBag());
matchToPrevious = new SymbolMatcher(previousGeneration.AnonymousTypeMap, sourceAssembly, context, previousAssembly, previousContext);
}
this.previousDefinitions = new DefinitionMap(previousGeneration.OriginalMetadata.Module, metadataDecoder, matchToMetadata, matchToPrevious, GenerateMethodMap(edits));
this.previousGeneration = previousGeneration;
this.changes = new SymbolChanges(this.previousDefinitions, edits);
}
protected virtual MemoryStream CreateAndCompileToStream(string templateSource, RazorEngineCompilationOptions options)
{
templateSource = this.WriteDirectives(templateSource, options);
RazorProjectEngine engine = RazorProjectEngine.Create(
RazorConfiguration.Default,
RazorProjectFileSystem.Create(@"."),
(builder) =>
{
builder.SetNamespace(options.TemplateNamespace);
});
string fileName = string.IsNullOrWhiteSpace(options.TemplateFilename) ? Path.GetRandomFileName() : options.TemplateFilename;
RazorSourceDocument document = RazorSourceDocument.Create(templateSource, fileName);
RazorCodeDocument codeDocument = engine.Process(
document,
null,
new List <RazorSourceDocument>(),
new List <TagHelperDescriptor>());
RazorCSharpDocument razorCSharpDocument = codeDocument.GetCSharpDocument();
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(razorCSharpDocument.GeneratedCode);
CSharpCompilation compilation = CSharpCompilation.Create(
fileName,
new[]
{
syntaxTree
},
options.ReferencedAssemblies
.Select(ass =>
{
#if NETSTANDARD2_0
return(MetadataReference.CreateFromFile(ass.Location));
#else
unsafe
{
ass.TryGetRawMetadata(out byte *blob, out int length);
ModuleMetadata moduleMetadata = ModuleMetadata.CreateFromMetadata((IntPtr)blob, length);
AssemblyMetadata assemblyMetadata = AssemblyMetadata.Create(moduleMetadata);
PortableExecutableReference metadataReference = assemblyMetadata.GetReference();
return(metadataReference);
}
#endif
})
.Concat(options.MetadataReferences)
.ToList(),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
MemoryStream memoryStream = new MemoryStream();
EmitResult emitResult = compilation.Emit(memoryStream);
if (!emitResult.Success)
{
RazorEngineCompilationException exception = new RazorEngineCompilationException()
{
Errors = emitResult.Diagnostics.ToList(),
GeneratedCode = razorCSharpDocument.GeneratedCode
};
throw exception;
}
memoryStream.Position = 0;
return(memoryStream);
}
/// <summary>
/// Configures the host setup prior to the initialization of the script runtime.
/// </summary>
/// <remarks>
/// <para>
/// The default implementation does nothing. Subclasses may override this method
/// to customize the host setup.
/// </para>
/// </remarks>
/// <param name="hostSetup">The host setup, not null.</param>
/// <param name="testPackage">The test package, not null.</param>
/// <param name="assemblyPath">The assembly path, not null.</param>
/// <param name="assemblyMetadata">The assembly metadata, not null.</param>
protected virtual void ConfigureHostSetup(HostSetup hostSetup, TestPackage testPackage, string assemblyPath, AssemblyMetadata assemblyMetadata)
{
}
/// <summary>
/// </summary>
/// <param name="assemblyMetadata">
/// </param>
/// <returns>
/// </returns>
private ModuleReferences<AssemblySymbol> LoadReferences(AssemblyMetadata assemblyMetadata)
{
var peReferences = ImmutableArray.CreateRange(assemblyMetadata.Assembly.AssemblyReferences.Select(this.LoadAssemblySymbolOrMissingAssemblySymbol));
var moduleReferences = new ModuleReferences<AssemblySymbol>(
assemblyMetadata.Assembly.AssemblyReferences, peReferences, ImmutableArray.CreateRange(this.unifiedAssemblies));
return moduleReferences;
}
public static ModuleInstance Create(ImmutableArray <byte> assemblyImage, ISymUnmanagedReader symReader, bool includeLocalSignatures = true)
{
// create a new instance of metadata, the resulting object takes an ownership:
return(Create(AssemblyMetadata.CreateFromImage(assemblyImage), symReader, includeLocalSignatures));
}
private static string GetLibKey(AssemblyMetadata metadata, Platform.AbstractPlatform platform)
{
return(metadata.CanonicalKey + "#" + platform.Name);
}
public void AssemblyMetadataShouldNotBeNullTest()
{
AssemblyMetadata assemblyMetadata = new AssemblyMetadata();
Assert.IsTrue(assemblyMetadata != null);
}
private void Initialize(Assembly assembly)
{
_metadata = new AssemblyMetadata(assembly);
_debugDirectoryBuilder = new DebugDirectoryBuilder();
}
public unsafe static void DoMyDynamicCompile()
{
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(
"using System.Collections.Generic; " +
"using Microsoft.AspNet.Mvc; " +
"using DynamicApi.Web.Models; " +
"using DynamicApi.Web.Repositories; " +
"namespace DynamicApi.Web.Controllers {" +
"[Route(\"api /[controller]\")] " +
"public class ValuesController : Controller<Values> { public ValuesController(IRepository<Values> repository) : base(repository) { }}}");
string assemblyName = Path.GetRandomFileName();
byte * b;
int length;
MetadataReference reference = null;
var assembly = typeof(Controller <>).GetTypeInfo().Assembly; //let's grab the Controller in-memory assembly
if (assembly.TryGetRawMetadata(out b, out length))
{
var moduleMetadata = ModuleMetadata.CreateFromMetadata((IntPtr)b, length);
var assemblyMetadata = AssemblyMetadata.Create(moduleMetadata);
reference = assemblyMetadata.GetReference();
}
MetadataReference[] references = new MetadataReference[]
{
MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location),
MetadataReference.CreateFromFile(typeof(Attribute).GetTypeInfo().Assembly.Location),
MetadataReference.CreateFromFile(typeof(Controller).GetTypeInfo().Assembly.Location),
MetadataReference.CreateFromFile(typeof(RouteAttribute).GetTypeInfo().Assembly.Location),
reference
};
var compilation = CSharpCompilation.Create(
assemblyName,
syntaxTrees: new[] { syntaxTree },
references: references,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
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.Load(new AssemblyName(assemblyName));
//var myAssembly = Assembly.Load(ms.ToArray());
}
}
}
private ValueTuple <Metadata, ImmutableArray <ITemporaryStreamStorage> >?TryReadMetadataFrom(
ObjectReader reader, SerializationKinds kind, CancellationToken cancellationToken)
{
var imageKind = reader.ReadInt32();
if (imageKind == MetadataFailed)
{
// error case
return(null);
}
var metadataKind = (MetadataImageKind)imageKind;
if (metadataKind == MetadataImageKind.Assembly)
{
using (var pooledMetadata = Creator.CreateList <ModuleMetadata>())
using (var pooledStorage = Creator.CreateList <ITemporaryStreamStorage>())
{
var count = reader.ReadInt32();
for (var i = 0; i < count; i++)
{
metadataKind = (MetadataImageKind)reader.ReadInt32();
Contract.ThrowIfFalse(metadataKind == MetadataImageKind.Module);
var tuple = ReadModuleMetadataFrom(reader, kind, cancellationToken);
pooledMetadata.Object.Add(tuple.Item1);
pooledStorage.Object.Add(tuple.Item2);
}
return(ValueTuple.Create <Metadata, ImmutableArray <ITemporaryStreamStorage> >(AssemblyMetadata.Create(pooledMetadata.Object), pooledStorage.Object.ToImmutableArrayOrEmpty()));
}
}
Contract.ThrowIfFalse(metadataKind == MetadataImageKind.Module);
var moduleInfo = ReadModuleMetadataFrom(reader, kind, cancellationToken);
return(ValueTuple.Create <Metadata, ImmutableArray <ITemporaryStreamStorage> >(moduleInfo.Item1, ImmutableArray.Create(moduleInfo.Item2)));
}
/// <summary>
/// Creates a host setup for a particular assembly within a test package.
/// </summary>
/// <param name="testPackage">The test package, not null.</param>
/// <param name="assemblyPath">The assembly path, not null.</param>
/// <param name="assemblyMetadata">The assembly metadata, not null.</param>
/// <returns>The host setup setup.</returns>
protected HostSetup CreateHostSetup(TestPackage testPackage, string assemblyPath, AssemblyMetadata assemblyMetadata)
{
HostSetup hostSetup = testPackage.CreateHostSetup();
ConfigureHostSetupForAssembly(hostSetup, assemblyPath, assemblyMetadata);
ConfigureHostSetup(hostSetup, testPackage, assemblyPath, assemblyMetadata);
return hostSetup;
}
public SQLDeserialization()
{
asmMetadata = new AssemblyMetadata();
asm = new AssemblyContext();
}
/// <summary>
/// </summary>
/// <param name="assemblyMetadata">
/// </param>
/// <returns>
/// </returns>
private static PEAssemblySymbol GetAssemblySymbol(AssemblyMetadata assemblyMetadata)
{
return new PEAssemblySymbol(assemblyMetadata.Assembly, DocumentationProvider.Default, isLinked: false, importOptions: MetadataImportOptions.All);
}
/// <summary>
/// Use Roslyn to create an assembly.
/// </summary>
/// <param name="fn">File to compile. Also used for assembly name.</param>
/// <returns></returns>
public bool Compile(string fn)
{
CompiledAssembly = null;
Errors.Clear();
string sc = File.ReadAllText(fn);
string newAssyName = Path.GetFileNameWithoutExtension(fn);
// Assemble references.
var mr = new List <MetadataReference>();
// Remarks:
// Performance considerations:
// It is recommended to use Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromFile(System.String)
// API when creating multiple references to the same assembly. Reusing Microsoft.CodeAnalysis.AssemblyMetadata
// object allows for sharing data across these references.
//var myAssy = Assembly.GetExecutingAssembly();
//var refAssys = myAssy.GetReferencedAssemblies();
// Add reference to almost everything we have loaded now.
var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
List <string> ignore = new List <string> {
"Dex9.exe", "Microsoft.CodeAnalysis.dll", "Microsoft.CodeAnalysis.CSharp.dll"
};
foreach (var lassy in loadedAssemblies)
{
string loc = lassy.Location;
if (ignore.TrueForAll(i => !loc.Contains(i)))
{
Debug.WriteLine(loc);
AssemblyMetadata amd = AssemblyMetadata.CreateFromFile(loc);
mr.Add(amd.GetReference());
}
}
// Parse the source.
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(sc);
CSharpCompilationOptions opts = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
CSharpCompilation compilation = CSharpCompilation.Create(newAssyName, new[] { syntaxTree }, mr, opts);
// Compile the source.
using (var memoryStream = new MemoryStream())
{
var result = compilation.Emit(memoryStream);
if (result.Success)
{
memoryStream.Seek(0, SeekOrigin.Begin);
CompiledAssembly = Assembly.Load(memoryStream.ToArray());
}
else
{
foreach (var diag in result.Diagnostics)
{
Errors.Add(FormatDiagnostic(diag, fn));
}
}
}
return(Errors.Count == 0 && CompiledAssembly != null);
}
public void NamesFromTypeArguments_LongTuples()
{
var source =
@"class A1 { }
class A2 { }
class A3 { }
class A4 { }
class A5 { }
class A6 { }
class A7 { }
class A8 { }
class B1 { }
class B2 { }
class B3 { }
class B4 { }
class B5 { }
class B6 { }
class B7 { }
class B8 { }
class B9 { }
class B10 { }
class C1 { }
class C2 { }
class A<T, U>
{
(dynamic A1, A2 A2, T A3, A4 A4, A5 A5, U A6, A7 A7, A8 A8, (T A9, U A10) A11) F =
(new A1(), new A2(), default(T), new A4(), new A5(), default(U), new A7(), new A8(), (default(T), default(U)));
}
class B
{
A<((dynamic B1, B2 B2) B3, B4 B4, dynamic B5, B6 B6, B7 B7, dynamic B8, B9 B9, B10 B10, dynamic B11), (C1 C1, (C2 C2, dynamic C3) C4)> G =
new A<((dynamic B1, B2 B2) B3, B4 B4, dynamic B5, B6 B6, B7 B7, dynamic B8, B9 B9, B10 B10, dynamic B11), (C1 C1, (C2 C2, dynamic C3) C4)>();
}";
var assembly0 = GenerateTupleAssembly();
var reference0 = AssemblyMetadata.CreateFromImage(assembly0).GetReference();
var compilation1 = CSharpTestBaseBase.CreateCompilationWithMscorlib45AndCSruntime(source, additionalRefs: new[] { reference0 });
var assembly1 = compilation1.EmitToArray();
var runtime = new DkmClrRuntimeInstance(ReflectionUtilities.GetMscorlib(ReflectionUtilities.Load(assembly0), ReflectionUtilities.Load(assembly1)));
using (runtime.Load())
{
var type = runtime.GetType("B");
var value = type.Instantiate();
var evalResult = FormatResult("o", value);
var children = GetChildren(evalResult);
Verify(children,
EvalResult(
"G",
"{A<((object, B2), B4, object, B6, B7, object, B9, B10, object), (C1, (C2, object))>}",
"A<((dynamic B1, B2 B2) B3, B4 B4, dynamic B5, B6 B6, B7 B7, dynamic B8, B9 B9, B10 B10, dynamic B11), (C1 C1, (C2 C2, dynamic C3) C4)> {A<((object, B2), B4, object, B6, B7, object, B9, B10, object), (C1, (C2, object))>}",
"o.G",
DkmEvaluationResultFlags.Expandable));
children = GetChildren(children[0]);
Verify(children,
EvalResult(
"F",
"({A1}, {A2}, ((null, null), null, null, null, null, null, null, null, null), {A4}, {A5}, (null, (null, null)), {A7}, {A8}, (((null, null), null, null, null, null, null, null, null, null), (null, (null, null))))",
"(dynamic A1, A2 A2, ((dynamic B1, B2 B2) B3, B4 B4, dynamic B5, B6 B6, B7 B7, dynamic B8, B9 B9, B10 B10, dynamic B11) A3, A4 A4, A5 A5, (C1 C1, (C2 C2, dynamic C3) C4) A6, A7 A7, A8 A8, (((dynamic B1, B2 B2) B3, B4 B4, dynamic B5, B6 B6, B7 B7, dynamic B8, B9 B9, B10 B10, dynamic B11) A9, (C1 C1, (C2 C2, dynamic C3) C4) A10) A11) {(object, A2, ((object, B2), B4, object, B6, B7, object, B9, B10, object), A4, A5, (C1, (C2, object)), A7, A8, (((object, B2), B4, object, B6, B7, object, B9, B10, object), (C1, (C2, object))))}",
"o.G.F",
DkmEvaluationResultFlags.Expandable));
}
}
static void Main(string[] args)
{
tracer.Tracer(TraceEventType.Information, "Program started");
string pathToDll = @"..\..\..\Logic\bin\Debug\Logic.dll";
Assembly dotNetAssembly = Assembly.LoadFrom(pathToDll);
assemblyMetadata = new AssemblyMetadata(dotNetAssembly);
// add namespaces to Dictionary
Console.WriteLine("Choose namespace");
foreach (NamespaceMetadata @namespace in assemblyMetadata.m_Namespaces)
{
namespaces.Add(@namespace.m_NamespaceName, @namespace);
Console.WriteLine(@namespace.m_NamespaceName);
}
// get namespace name from user
string userInput;
bool trigger = true;
do
{
Console.Write(">>> ");
userInput = Console.ReadLine();
if (userInput == null)
{
Console.WriteLine("No input from user!");
tracer.Tracer(TraceEventType.Warning, "No input from user!");
}
if (namespaces.ContainsKey(userInput))
{
trigger = false;
selectedNamespace = userInput;
tracer.Tracer(TraceEventType.Information, "selected namespace" + selectedNamespace);
// list types from selected dll file from namespace Reflection
tracer.Tracer(TraceEventType.Start, "default types display");
ListDefaultTypes(userInput);
tracer.Tracer(TraceEventType.Stop, "default types displayed");
}
} while (trigger);
do
{
// print command prompt
Console.Write(">>> ");
userInput = Console.ReadLine();
if (userInput == null)
{
Console.WriteLine("No input from user!");
tracer.Tracer(TraceEventType.Warning, "No input from user!");
continue;
}
string command = userInput.Split(' ')[0];
switch (command)
{
case "list":
tracer.Tracer(TraceEventType.Start, "listing start");
if (userInput.Split(' ').Length == 2)
{
string selectedType = userInput.Split(' ')[1];
if (expandableTypes.ContainsKey(selectedType))
{
ExpandType(selectedType);
}
else
{
Console.WriteLine("Invalid type name");
}
tracer.Tracer(TraceEventType.Start, "expanded type " + selectedType);
}
else
{
Console.WriteLine("Write the type that you want to expand!");
tracer.Tracer(TraceEventType.Warning, "no type specified");
}
tracer.Tracer(TraceEventType.Stop, "listing stop");
break;
case "back":
tracer.Tracer(TraceEventType.Information, "go back");
GoBack();
break;
case "exit":
tracer.Tracer(TraceEventType.Information, "Program stopped");
return;
case "help":
tracer.Tracer(TraceEventType.Information, "help");
Console.WriteLine("Available commands:\n" +
"\tlist [type to expand]\n" +
"\tback\n" +
"\texit");
break;
default:
tracer.Tracer(TraceEventType.Warning, "invalid command");
Console.WriteLine("Invalid command");
break;
}
} while (true);
}
private EmitBaseline.MetadataSymbols GetOrCreateMetadataSymbols(EmitBaseline initialBaseline, CSharpCompilation compilation)
{
if (initialBaseline.LazyMetadataSymbols != null)
{
return(initialBaseline.LazyMetadataSymbols);
}
var originalMetadata = initialBaseline.OriginalMetadata;
// The purpose of this compilation is to provide PE symbols for original metadata.
// We need to transfer the references from the current source compilation but don't need its syntax trees.
var metadataCompilation = compilation.RemoveAllSyntaxTrees();
var metadataAssembly = metadataCompilation.GetBoundReferenceManager().CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata.Create(originalMetadata), MetadataImportOptions.All);
var metadataDecoder = new MetadataDecoder(metadataAssembly.PrimaryModule);
var metadataAnonymousTypes = GetAnonymousTypeMapFromMetadata(originalMetadata.MetadataReader, metadataDecoder);
var metadataSymbols = new EmitBaseline.MetadataSymbols(metadataAnonymousTypes, metadataDecoder);
return(InterlockedOperations.Initialize(ref initialBaseline.LazyMetadataSymbols, metadataSymbols));
}
/// <summary>
/// Initializes an instance of <see cref="UpdateManager"/> on the entry assembly.
/// </summary>
public UpdateManager(IPackageResolver resolver, IPackageExtractor extractor)
: this(AssemblyMetadata.FromEntryAssembly(), resolver, extractor)
{
}
private AssemblyMetadata CompileWithRoslynInMemory(string[] source)
{
var srcFileName = Path.GetFileNameWithoutExtension(this.FirstSource);
var assemblyName = srcFileName;
var defineSeparators = new[] { ';', ' ' };
var syntaxTrees =
source.Select(
s =>
CSharpSyntaxTree.ParseText(
SourceText.From(new FileStream(s, FileMode.Open, FileAccess.Read), Encoding.UTF8),
new CSharpParseOptions(
LanguageVersion.Experimental,
preprocessorSymbols: this.Options["DefineConstants"].Split(defineSeparators, StringSplitOptions.RemoveEmptyEntries)),
s));
var assemblies = new List <MetadataImageReference>();
this.Assemblies = this.LoadReferencesForCompiling(assemblies);
var options =
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary).WithAllowUnsafe(true)
.WithOptimizations(!this.DebugInfo)
.WithRuntimeMetadataVersion("4.5");
var compilation = CSharpCompilation.Create(assemblyName, syntaxTrees, assemblies.ToArray(), options);
var dllStream = new MemoryStream();
var pdbStream = new MemoryStream();
PEModuleBuilder.OnMethodBoundBodySynthesizedDelegate peModuleBuilderOnOnMethodBoundBodySynthesized = (symbol, body) =>
{
var key = symbol.ToKeyString();
Debug.Assert(!this.boundBodyByMethodSymbol.ContainsKey(key), "Check if method is partial");
this.boundBodyByMethodSymbol[key] = body;
};
PEModuleBuilder.OnSourceMethodDelegate peModuleBuilderOnSourceMethod = (symbol, sourceMethod) =>
{
var key = symbol.ToKeyString();
Debug.Assert(!this.sourceMethodByMethodSymbol.ContainsKey(key), "Check if method is partial");
this.sourceMethodByMethodSymbol[key] = sourceMethod;
};
PEModuleBuilder.OnMethodBoundBodySynthesized += peModuleBuilderOnOnMethodBoundBodySynthesized;
PEModuleBuilder.OnSourceMethod += peModuleBuilderOnSourceMethod;
var result = compilation.Emit(peStream: dllStream, pdbStream: pdbStream);
PEModuleBuilder.OnMethodBoundBodySynthesized -= peModuleBuilderOnOnMethodBoundBodySynthesized;
PEModuleBuilder.OnSourceMethod -= peModuleBuilderOnSourceMethod;
if (result.Diagnostics.Length > 0)
{
var errors = result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error).ToList();
Console.WriteLine(@"Errors: {0}", errors.Count);
foreach (var diagnostic in errors)
{
Console.WriteLine(diagnostic);
}
var diagnostics = result.Diagnostics.Where(d => d.Severity != DiagnosticSeverity.Error);
Console.WriteLine(@"Warnings/Info: {0}", diagnostics.Count());
foreach (var diagnostic in diagnostics)
{
Console.WriteLine(diagnostic);
}
}
dllStream.Flush();
dllStream.Position = 0;
pdbStream.Flush();
pdbStream.Position = 0;
// Successful Compile
return(AssemblyMetadata.CreateFromImageStream(dllStream));
}
public void BadImageFormat()
{
var invalidModuleName = Temp.CreateFile().WriteAllBytes(TestResources.MetadataTests.Invalid.InvalidModuleName);
Assert.Throws <BadImageFormatException>(() => AssemblyMetadata.CreateFromFile(invalidModuleName.Path));
}
public bool GetOrAddMetadata(FileKey key, ValueSource <Optional <AssemblyMetadata> > metadataSource, out AssemblyMetadata metadata)
{
lock (_gate)
{
if (TryGetMetadata_NoLock(key, out var cachedMetadata))
{
metadata = cachedMetadata;
return(false);
}
EnsureCapacity_NoLock();
var newMetadata = metadataSource.GetValueOrNull();
// the source is expected to keep the metadata alive at this point
Contract.ThrowIfNull(newMetadata);
// don't use "Add" since key might already exist with already released metadata
_metadataCache[key] = metadataSource;
metadata = newMetadata;
return(true);
}
}
public void IncorrectCustomAssemblyTableSize_TooManyMethodSpecs()
{
var metadata = AssemblyMetadata.CreateFromImage(TestResources.MetadataTests.Invalid.IncorrectCustomAssemblyTableSize_TooManyMethodSpecs);
Assert.Throws <BadImageFormatException>(() => metadata.GetModules());
}
/// <summary>
/// 将模板内容编译并输出内存流
/// </summary>
/// <param name="templateSource"></param>
/// <param name="options"></param>
/// <returns></returns>
private static MemoryStream CreateAndCompileToStream(string templateSource, ViewEngineOptions options)
{
templateSource = WriteDirectives(templateSource, options);
var engine = RazorProjectEngine.Create(
RazorConfiguration.Default,
RazorProjectFileSystem.Create(@"."),
(builder) =>
{
builder.SetNamespace(options.TemplateNamespace);
});
var fileName = Path.GetRandomFileName();
var document = RazorSourceDocument.Create(templateSource, fileName);
var codeDocument = engine.Process(
document,
null,
new List <RazorSourceDocument>(),
new List <TagHelperDescriptor>());
var razorCSharpDocument = codeDocument.GetCSharpDocument();
var syntaxTree = CSharpSyntaxTree.ParseText(razorCSharpDocument.GeneratedCode);
var compilation = CSharpCompilation.Create(
fileName,
new[]
{
syntaxTree
},
options.ReferencedAssemblies
.Select(ass =>
{
// MetadataReference.CreateFromFile(ass.Location)
unsafe
{
ass.TryGetRawMetadata(out byte *blob, out int length);
var moduleMetadata = ModuleMetadata.CreateFromMetadata((IntPtr)blob, length);
var assemblyMetadata = AssemblyMetadata.Create(moduleMetadata);
var metadataReference = assemblyMetadata.GetReference();
return(metadataReference);
}
})
.Concat(options.MetadataReferences)
.ToList(),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var memoryStream = new MemoryStream();
var emitResult = compilation.Emit(memoryStream);
if (!emitResult.Success)
{
var errors = emitResult.Diagnostics.ToList();
var exception = new ViewEngineTemplateException($"Unable to compile template: {errors.FirstOrDefault()}")
{
Errors = errors,
GeneratedCode = razorCSharpDocument.GeneratedCode
};
throw exception;
}
memoryStream.Position = 0;
return(memoryStream);
}
public VMAssemblyMetadata(AssemblyBase baseAssembly)
{
AssemblyMetadata = new AssemblyMetadata(baseAssembly);
Namespaces = baseAssembly.Namespaces?.Select(ns => new NamespaceMetadata(ns));
}
protected void Generate()
{
Setup();
var stringBuilder = new StringBuilder();
stringBuilder.Append(@"namespace Razor.Orm.Template {
internal static class GeneratedTemplateFactory {");
foreach (var item in assembly.GetManifestResourceNames())
{
var name = item.Replace('.', '_');
RazorSourceDocument razorSourceDocument = null;
var stream = new MemoryStream();
assembly.GetManifestResourceStream(item).CopyTo(stream);
using (stream)
using (var writer = new StreamWriter(stream, Encoding.UTF8))
{
writer.WriteLine("@using System");
writer.WriteLine("@using System");
writer.WriteLine("@using System.Collections.Generic");
writer.WriteLine("@using System.Linq");
writer.WriteLine("@using System.Threading.Tasks");
writer.Flush();
stream.Position = 0;
razorSourceDocument = RazorSourceDocument.ReadFrom(stream, name, Encoding.UTF8);
}
var razorCodeDocument = RazorCodeDocument.Create(razorSourceDocument);
engine.Process(razorCodeDocument);
var generatedCode = razorCodeDocument.GetCSharpDocument().GeneratedCode;
Parse(generatedCode);
stringBuilder.Append($@"
private static {name}_GeneratedTemplate private_{name}_instance = new {name}_GeneratedTemplate();
internal static {name}_GeneratedTemplate {name}_Instance
{{
get
{{
return private_{name}_instance;
}}
}} ");
}
stringBuilder.Append(" } }");
var defaultTemplateFactoryCode = stringBuilder.ToString();
Parse(defaultTemplateFactoryCode);
var references = DependencyContext.Load(Assembly.GetEntryAssembly()).CompileLibraries.SelectMany(library => library.ResolveReferencePaths());
if (!references.Any())
{
throw new Exception(Labels.CantLoadMetadataReferenceException);
}
var metadataRerefences = new List <MetadataReference>
{
AssemblyMetadata.CreateFromFile(assembly.Location).GetReference()
};
var libraryPaths = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var reference in references)
{
if (libraryPaths.Add(reference))
{
using (var stream = File.OpenRead(reference))
{
metadataRerefences.Add(AssemblyMetadata.Create(ModuleMetadata.CreateFromStream(stream, PEStreamOptions.PrefetchMetadata))
.GetReference(filePath: reference));
}
}
}
var compilation = CSharpCompilation.Create(assemblyName)
.WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(metadataRerefences).AddSyntaxTrees(syntaxTrees);
using (var assemblyStream = new MemoryStream())
{
var result = compilation.Emit(assemblyStream);
if (!result.Success)
{
var diagnostics = new StringBuilder();
diagnostics.AppendLine(Labels.CompileException);
foreach (var diagnostic in result.Diagnostics.Where(d => d.IsWarningAsError || d.Severity == DiagnosticSeverity.Error))
{
var lineSpan = diagnostic.Location.SourceTree.GetMappedLineSpan(diagnostic.Location.SourceSpan);
diagnostics.AppendLine($"- ({lineSpan.StartLinePosition.Line}:{lineSpan.StartLinePosition.Character}) {diagnostic.GetMessage()}");
}
throw new Exception(diagnostics.ToString());
}
assemblyStream.Seek(0, SeekOrigin.Begin);
var generatedAssembly = AssemblyLoadContext.Default.LoadFromStream(assemblyStream);
foreach (var item in generatedAssembly.GetExportedTypes())
{
GeneratedDao(types.First(e => e.IsAssignableFrom(item)), item);
}
}
}
public void CompilationReferences_More()
{
string src1 = @"
using System;
class C
{
public static int F(object a) { return 1; }
public static void Main() { Console.WriteLine(F(null)); }
}
";
string src2 = @"
using System;
class C
{
public static int F(object a) { return 1; }
public static void Main() { F(null); }
}
";
// Let's say an IL rewriter inserts a new overload of F that references
// a type in a new AssemblyRef.
string srcPE = @"
using System;
class C
{
public static int F(System.Diagnostics.Process a) { return 2; }
public static int F(object a) { return 1; }
public static void Main() { F(null); }
}
";
var md1 = AssemblyMetadata.CreateFromStream(CreateEmptyCompilation(srcPE, new[] { MscorlibRef, SystemRef }).EmitToStream());
var c1 = CreateEmptyCompilation(src1, new[] { MscorlibRef });
var c2 = c1.WithSource(src2);
var baseline = EmitBaseline.CreateInitialBaseline(md1.GetModules()[0], handle => default(EditAndContinueMethodDebugInformation));
var mdStream = new MemoryStream();
var ilStream = new MemoryStream();
var pdbStream = new MemoryStream();
var updatedMethods = new List <MethodDefinitionHandle>();
var edits = new[]
{
new SemanticEdit(
SemanticEditKind.Update,
c1.GlobalNamespace.GetMember <NamedTypeSymbol>("C").GetMember("Main"),
c2.GlobalNamespace.GetMember <NamedTypeSymbol>("C").GetMember("Main"))
};
c2.EmitDifference(baseline, edits, mdStream, ilStream, pdbStream, updatedMethods);
var actualIL = ImmutableArray.Create(ilStream.ToArray()).GetMethodIL();
// Symbol matcher should ignore overloads with missing type symbols and match
// F(object).
var expectedIL = @"
{
// Code size 8 (0x8)
.maxstack 8
IL_0000: ldnull
IL_0001: call 0x06000002
IL_0006: pop
IL_0007: ret
}";
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL);
}
public void TestTypetoDocumentNavigation()
{
string sourceA = @"
using System;
public partial class C
{
int x = 1;
}
";
string sourceB = @"
using System;
public partial class C
{
int y = 1;
public void F2()
{
#line 1 ""a.txt""
int z = 1;
#line default
}
}
";
var c1 = CreateCompilation(new[]
{
SyntaxFactory.ParseSyntaxTree(sourceA, path: "X.cs", encoding: Encoding.UTF8),
SyntaxFactory.ParseSyntaxTree(sourceB, path: "Z.cs", encoding: Encoding.UTF8)
}, options: TestOptions.DebugDll);
var pdbStream = new MemoryStream();
var peImage = c1.EmitToArray(EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.PortablePdb), pdbStream: pdbStream);
pdbStream.Position = 0;
string source2 = @"
using System;
public class Program
{
public static void Main() { }
}
";
var assemblyMetadata = AssemblyMetadata.CreateFromImage(peImage);
var metadataReference = assemblyMetadata.GetReference();
var c2 = CreateCompilation(new[] { source2 }, new[] { metadataReference }, options: TestOptions.DebugDll);
var typeC = c2.GetTypeByMetadataName("C");
Symbol symbol = typeC.GetMethod("F2");
//symbol = (PEMethodSymbol)symbol;
using var provider = MetadataReaderProvider.FromPortablePdbStream(pdbStream);
var pdbReader = provider.GetMetadataReader();
var docList = FindSourceDocuments(symbol, pdbReader);
Assert.Equal(0x30000002, MetadataTokens.GetToken(docList[0]));
// go through all methods and collect documents.
}
public void CompilationReferences_Less()
{
// Add some references that are actually not used in the source.
// The only actual reference stored in the metadata image would be: mscorlib (rowid 1).
// If we incorrectly assume the references are the same we will map TypeRefs of
// Mscorlib to System.Windows.Forms.
var references = new[] { SystemWindowsFormsRef, MscorlibRef, SystemCoreRef };
string src1 = @"
using System;
using System.Threading.Tasks;
class C
{
public Task<int> F() { Console.WriteLine(123); return null; }
public static void Main() { Console.WriteLine(1); }
}
";
string src2 = @"
using System;
using System.Threading.Tasks;
class C
{
public Task<int> F() { Console.WriteLine(123); return null; }
public static void Main() { Console.WriteLine(2); }
}
";
var c1 = CreateEmptyCompilation(src1, references);
var c2 = c1.WithSource(src2);
var md1 = AssemblyMetadata.CreateFromStream(c1.EmitToStream());
var baseline = EmitBaseline.CreateInitialBaseline(md1.GetModules()[0], handle => default(EditAndContinueMethodDebugInformation));
var mdStream = new MemoryStream();
var ilStream = new MemoryStream();
var pdbStream = new MemoryStream();
var updatedMethods = new List <MethodDefinitionHandle>();
var edits = new[]
{
new SemanticEdit(
SemanticEditKind.Update,
c1.GlobalNamespace.GetMember <NamedTypeSymbol>("C").GetMember("Main"),
c2.GlobalNamespace.GetMember <NamedTypeSymbol>("C").GetMember("Main"))
};
c2.EmitDifference(baseline, edits, mdStream, ilStream, pdbStream, updatedMethods);
var actualIL = ImmutableArray.Create(ilStream.ToArray()).GetMethodIL();
var expectedIL = @"
{
// Code size 7 (0x7)
.maxstack 8
IL_0000: ldc.i4.2
IL_0001: call 0x0A000006
IL_0006: ret
}";
// If the references are mismatched then the symbol matcher won't be able to find Task<T>
// and will recompile the method body of F (even though the method hasn't changed).
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL);
}
/// <summary>
/// Reqursively goes through all namespaces in the assembly and discovers unique types, extensions and namespaces.
/// </summary>
private void ProcessNamespace(AssemblyMetadata assembly, INamespaceSymbol namespaceSymbol)
{
var assemblyName = Path.GetFileName(assembly.FullPath);
if (string.IsNullOrEmpty(assemblyName) || namespaceSymbol == null)
{
return;
}
var fullNamespaceName = (namespaceSymbol.ContainingNamespace == null || string.IsNullOrEmpty(namespaceSymbol.ContainingNamespace.Name))
? namespaceSymbol.Name
: namespaceSymbol.ContainingNamespace + "." + namespaceSymbol.Name;
foreach (var typeName in namespaceSymbol.GetTypeMembers())
{
try
{
// keep only public types
if (typeName.DeclaredAccessibility != Accessibility.Public)
{
continue;
}
var typeFullName = string.IsNullOrEmpty(fullNamespaceName)
? typeName.Name
: typeName.ContainingNamespace + "." + typeName.Name;
// if we meet this type first time - remember it
if (!_types.ContainsKey(typeFullName))
{
var newType = new TypeModel
{
Name = typeName.Name,
FullName = typeFullName,
AssemblyName = assemblyName,
PackageName = _package.Id,
PackageVersion = _package.Version
};
newType.TargetFrameworks.AddRange(assembly.TargetFrameworks);
_types.Add(typeFullName, newType);
// if namespace contains at least one type and we meet this namespace first time - remember it
if (!string.IsNullOrEmpty(fullNamespaceName) && !_namespaces.ContainsKey(fullNamespaceName))
{
var newNamespace = new NamespaceModel
{
Name = fullNamespaceName,
AssemblyName = assemblyName,
PackageName = _package.Id,
PackageVersion = _package.Version
};
newNamespace.TargetFrameworks.AddRange(assembly.TargetFrameworks);
_namespaces.Add(fullNamespaceName, newNamespace);
}
else
{
var namespaceModel = _namespaces[fullNamespaceName];
namespaceModel.MergeTargetFrameworks(assembly.TargetFrameworks);
}
}
else
{
var typeModel = _types[typeFullName];
typeModel.MergeTargetFrameworks(assembly.TargetFrameworks);
if (!string.IsNullOrEmpty(fullNamespaceName))
{
var namespaceModel = _namespaces[fullNamespaceName];
namespaceModel.MergeTargetFrameworks(assembly.TargetFrameworks);
}
}
// if type is static, then it might contain extension methdos
if (typeName.IsStatic)
{
foreach (var member in typeName.GetMembers())
{
// proceed only if static type's member is a method and it is public
var method = member as IMethodSymbol;
if (method == null || method.DeclaredAccessibility != Accessibility.Public)
{
continue;
}
if (method.IsExtensionMethod)
{
var thisParameter = method.Parameters[0];
var extensionMethodTypeName = thisParameter.Type.ContainingNamespace + "." + thisParameter.Type.Name;
var extensionFullName = extensionMethodTypeName + "." + method.Name;
// if we meet this extension first time - remember it
if (!_extensions.ContainsKey(extensionFullName))
{
var newExtension = new ExtensionModel
{
Name = method.Name,
FullName = extensionFullName,
AssemblyName = assemblyName,
PackageName = _package.Id,
PackageVersion = _package.Version,
Namespace = fullNamespaceName
};
newExtension.TargetFrameworks.AddRange(assembly.TargetFrameworks);
_extensions.Add(extensionFullName, newExtension);
}
else
{
var extensionModel = _extensions[extensionFullName];
extensionModel.MergeTargetFrameworks(assembly.TargetFrameworks);
}
}
}
}
}
catch(Exception e)
{
Debug.Write(e.ToString());
}
}
// recurse to chilren namespaces
foreach (var childNamespace in namespaceSymbol.GetNamespaceMembers())
{
if (childNamespace.NamespaceKind == NamespaceKind.Module)
{
ProcessNamespace(assembly, childNamespace);
}
}
}
public AssemblyTreeViewItem(AssemblyMetadata assemblyMetadata) : base()
{
this.assemblyMetadata = assemblyMetadata;
Name = assemblyMetadata.Name;
}
/// <summary>
/// </summary>
/// <param name="assemblyMetadata">
/// </param>
/// <returns>
/// </returns>
private AssemblySymbol LoadAssemblySymbol(AssemblyMetadata assemblyMetadata)
{
AssemblySymbol symbol;
if (this.cache.TryGetValue(assemblyMetadata.Assembly.Identity, out symbol))
{
return symbol;
}
var assemblySymbol = GetAssemblySymbol(assemblyMetadata);
this.cache[assemblyMetadata.Assembly.Identity] = assemblySymbol;
this.unifiedAssemblies.Add(new UnifiedAssembly<AssemblySymbol>(assemblySymbol, assemblyMetadata.Assembly.Identity));
var moduleReferences = this.LoadReferences(assemblyMetadata);
foreach (var module in assemblySymbol.Modules)
{
module.SetReferences(moduleReferences);
}
this.SetCorLib(assemblySymbol);
return assemblySymbol;
}
public void TypeOutsideModule()
{
var sourceA =
@"using System;
public class A<T>
{
public static void M(Action f)
{
object o;
try
{
f();
}
catch (Exception)
{
}
}
}";
var sourceB =
@"using System;
class E : Exception
{
internal object F;
}
class B
{
static void Main()
{
A<int>.M(() => { throw new E(); });
}
}";
var assemblyNameA = "0A93FF0B-31A2-47C8-B24D-16A2D77AB5C5";
var compilationA = CreateCompilationWithMscorlib(sourceA, options: TestOptions.DebugDll, assemblyName: assemblyNameA);
byte[] exeA;
byte[] pdbA;
ImmutableArray <MetadataReference> referencesA;
compilationA.EmitAndGetReferences(out exeA, out pdbA, out referencesA);
var metadataA = AssemblyMetadata.CreateFromImage(exeA);
var referenceA = metadataA.GetReference();
var assemblyNameB = "9BAC6622-86EB-4EC5-94A1-9A1E6D0C24B9";
var compilationB = CreateCompilationWithMscorlib(sourceB, options: TestOptions.DebugExe, references: new[] { referenceA }, assemblyName: assemblyNameB);
byte[] exeB;
byte[] pdbB;
ImmutableArray <MetadataReference> referencesB;
compilationB.EmitAndGetReferences(out exeB, out pdbB, out referencesB);
var metadataB = AssemblyMetadata.CreateFromImage(exeB);
var referenceB = metadataB.GetReference();
var modulesBuilder = ArrayBuilder <ModuleInstance> .GetInstance();
modulesBuilder.Add(MscorlibRef.ToModuleInstance(fullImage: null, symReader: null));
modulesBuilder.Add(referenceA.ToModuleInstance(fullImage: exeA, symReader: new SymReader(pdbA)));
modulesBuilder.Add(referenceB.ToModuleInstance(fullImage: exeB, symReader: new SymReader(pdbB)));
modulesBuilder.Add(ExpressionCompilerTestHelpers.IntrinsicAssemblyReference.ToModuleInstance(fullImage: null, symReader: null));
using (var runtime = new RuntimeInstance(modulesBuilder.ToImmutableAndFree()))
{
var context = CreateMethodContext(
runtime,
"A.M");
var aliases = ImmutableArray.Create(
ExceptionAlias("E, 9BAC6622-86EB-4EC5-94A1-9A1E6D0C24B9, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"),
ObjectIdAlias(1, "A`1[[B, 9BAC6622-86EB-4EC5-94A1-9A1E6D0C24B9, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]], 0A93FF0B-31A2-47C8-B24D-16A2D77AB5C5, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"));
string error;
var testData = new CompilationTestData();
context.CompileExpression(
"$exception",
DkmEvaluationFlags.TreatAsExpression,
aliases,
out error,
testData);
Assert.Null(error);
testData.GetMethodData("<>x<T>.<>m0").VerifyIL(
@"{
// Code size 11 (0xb)
.maxstack 1
.locals init (object V_0) //o
IL_0000: call ""System.Exception Microsoft.VisualStudio.Debugger.Clr.IntrinsicMethods.GetException()""
IL_0005: castclass ""E""
IL_000a: ret
}");
ResultProperties resultProperties;
ImmutableArray <AssemblyIdentity> missingAssemblyIdentities;
testData = new CompilationTestData();
context.CompileAssignment(
"o",
"$1",
aliases,
DiagnosticFormatter.Instance,
out resultProperties,
out error,
out missingAssemblyIdentities,
EnsureEnglishUICulture.PreferredOrNull,
testData);
Assert.Empty(missingAssemblyIdentities);
Assert.Null(error);
testData.GetMethodData("<>x<T>.<>m0").VerifyIL(
@"{
// Code size 17 (0x11)
.maxstack 1
.locals init (object V_0) //o
IL_0000: ldstr ""$1""
IL_0005: call ""object Microsoft.VisualStudio.Debugger.Clr.IntrinsicMethods.GetObjectByAlias(string)""
IL_000a: castclass ""A<B>""
IL_000f: stloc.0
IL_0010: ret
}");
}
}
/// <summary>
/// </summary>
/// <param name="assemblyMetadata">
/// </param>
/// <returns>
/// </returns>
public IEnumerable<string> AllReferencesHelper(AssemblyMetadata assemblyMetadata)
{
yield return assemblyMetadata.Assembly.Identity.Name;
foreach (var reference in this.LoadReferences(assemblyMetadata).Names)
{
foreach (var referenceName in this.AllReferencesHelper(this.GetAssemblyMetadata(reference)))
{
yield return referenceName;
}
}
}
public static void Compile(string code, bool isDebug, out Assembly compiledAssembly, out IList <string> errors, out IList <string> warnings)
{
var assemblyName = "CodeGenerationAssembly" + Interlocked.Increment(ref _suffix);
var metadataList =
SerializerDebugging.CodeSerializerDependentAssemblies.Select(
a =>
a is string
?AssemblyMetadata.CreateFromFile(a as string)
: AssemblyMetadata.CreateFromImage(a as byte[])
).ToArray();
try
{
var compilation =
CSharpCompilation.Create(
assemblyName,
new[] { CSharpSyntaxTree.ParseText(code) },
metadataList.Select(m => m.GetReference()),
new CSharpCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
optimizationLevel: isDebug?OptimizationLevel.Debug: OptimizationLevel.Release,
// Suppress CS0436 because gen/*.cs will conflict with testing serializers.
specificDiagnosticOptions: new[] { new KeyValuePair <string, ReportDiagnostic>("CS0436", ReportDiagnostic.Suppress) }
)
);
var emitOptions = new EmitOptions(runtimeMetadataVersion: "v4.0.30319");
EmitResult result;
if (SerializerDebugging.DumpEnabled)
{
var assemblyPath = Path.Combine(SerializerDebugging.DumpDirectory ?? Path.GetTempPath(), assemblyName + ".dll");
using (var fileStream = File.OpenWrite(assemblyPath))
{
result = compilation.Emit(fileStream, options: emitOptions);
fileStream.Flush();
}
if (result.Success)
{
compiledAssembly = Assembly.LoadFrom(assemblyPath);
SerializerDebugging.AddCompiledCodeAssembly(assemblyPath);
}
else
{
compiledAssembly = null;
}
}
else
{
using (var buffer = new MemoryStream())
{
result = compilation.Emit(buffer, options: emitOptions);
if (result.Success)
{
var image = buffer.ToArray();
compiledAssembly = Assembly.Load(image);
SerializerDebugging.AddCompiledCodeAssembly(assemblyName, image);
}
else
{
compiledAssembly = null;
}
}
}
errors = BuildCompilationError(result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error));
warnings = BuildCompilationError(result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Warning));
}
finally
{
foreach (var metadata in metadataList)
{
metadata.Dispose();
}
}
}
public void Load(string fileName)
{
Stream fs = System.IO.File.OpenRead(fileName);
fs.Seek(128, SeekOrigin.Begin);
filename = fileName;
BinaryReader binaryReader = new BinaryReader(fs);
header = new PEFileHeader();
header.LoadFrom(binaryReader);
sections = new SectionTable[header.NumberOfSections];
for (int i = 0; i < header.NumberOfSections; ++i) {
sections[i] = new SectionTable();
sections[i].LoadFrom(binaryReader);
}
uint rawDataSize = 0;
for (int i = 0; i < header.NumberOfSections; ++i) {
rawDataSize += sections[i].SizeOfRawData;
}
// read all sections to a memory buffer and relocate all pointer in the sections
// to raw data indices in the buffer
rawSectionData = new byte[rawDataSize];
int curOffset = 0;
for (int i = 0; i < header.NumberOfSections; ++i) {
fs.Seek((int)sections[i].PointerToRawData, SeekOrigin.Begin);
fs.Read(rawSectionData, curOffset, (int)sections[i].SizeOfRawData);
sections[i].PointerToRawData = (uint)curOffset;
curOffset += (int)sections[i].SizeOfRawData;
}
binaryReader.Close();
fs.Close();
fs = new MemoryStream(rawSectionData);
binaryReader = new BinaryReader(fs);
uint cliHeaderPos = LookupRVA(header.DataDirectories.CliHeader);
fs.Seek((int)cliHeaderPos, SeekOrigin.Begin);
cliHeader = new CLIHeader();
cliHeader.LoadFrom(binaryReader);
uint metaDataPos = LookupRVA(cliHeader.MetaData);
fs.Seek((int)metaDataPos, SeekOrigin.Begin);
AssemblyMetadata met = new AssemblyMetadata();
met.LoadFrom(binaryReader);
foreach (StreamHeader streamHeader in met.StreamHeaders) {
uint offset = LookupRVA(cliHeader.MetaData + streamHeader.Offset);
fs.Seek((int)offset, SeekOrigin.Begin);
switch (streamHeader.Name) {
case "#~":
metadataTable.LoadFrom(binaryReader);
break;
case "#Strings":
stringHeap = new byte[streamHeader.Size];
fs.Read(stringHeap, 0, stringHeap.Length);
break;
case "#US":
userStringHeap = new byte[streamHeader.Size];
fs.Read(userStringHeap, 0, userStringHeap.Length);
break;
case "#GUID":
guidHeap = new byte[streamHeader.Size];
fs.Read(guidHeap, 0, guidHeap.Length);
break;
case "#Blob":
blobHeap = new byte[streamHeader.Size];
fs.Read(blobHeap, 0, blobHeap.Length);
break;
}
}
}
private void ConfigureHostSetupForAssembly(HostSetup hostSetup, string assemblyPath, AssemblyMetadata assemblyMetadata)
{
string assemblyDir = Path.GetDirectoryName(assemblyPath);
if (hostSetup.ApplicationBaseDirectory == null)
hostSetup.ApplicationBaseDirectory = assemblyDir;
if (hostSetup.WorkingDirectory == null)
hostSetup.WorkingDirectory = assemblyDir;
hostSetup.ConfigurationFileLocation = ConfigurationFileLocation.AppBase;
string assemblyConfigFilePath = assemblyPath + @".config";
if (File.Exists(assemblyConfigFilePath))
{
string configurationXml = File.ReadAllText(assemblyConfigFilePath);
hostSetup.Configuration.ConfigurationXml = configurationXml;
if (hostSetup.RuntimeVersion == null)
hostSetup.RuntimeVersion = GetPreferredRuntimeVersion(configurationXml);
}
foreach (AssemblyBinding assemblyBinding in RuntimeAccessor.Instance.GetAllPluginAssemblyBindings())
{
if (assemblyBinding.CodeBase != null)
hostSetup.Configuration.AddAssemblyBinding(assemblyBinding);
}
if (hostSetup.ProcessorArchitecture == ProcessorArchitecture.None
|| hostSetup.ProcessorArchitecture == ProcessorArchitecture.MSIL)
hostSetup.ProcessorArchitecture = assemblyMetadata.ProcessorArchitecture;
if (hostSetup.RuntimeVersion == null)
hostSetup.RuntimeVersion = assemblyMetadata.RuntimeVersion;
ConfigureHostSetupForAssembly(hostSetup, assemblyPath);
}
