/// <summary>Adds a new assembly to this collection.</summary>
/// <param name="key">The full name of the assembly which code was generated for.</param>
/// <param name="value">The raw generated assembly.</param>
public void Add(string key, GeneratedAssembly value)
{
if (!string.IsNullOrWhiteSpace(key))
{
Assemblies[key] = value;
}
}
/// <summary>
/// Generates and loads code for the specified inputs.
/// </summary>
/// <param name="inputs">The assemblies to generate code for.</param>
public void GenerateAndLoadForAssemblies(params Assembly[] inputs)
{
if (inputs == null)
{
throw new ArgumentNullException("inputs");
}
var timer = Stopwatch.StartNew();
foreach (var input in inputs)
{
RegisterGeneratedCodeTargets(input);
TryLoadGeneratedAssemblyFromCache(input);
}
var grainAssemblies = inputs.Where(ShouldGenerateCodeForAssembly).ToList();
if (grainAssemblies.Count == 0)
{
// Already up to date.
return;
}
try
{
// Generate code for newly loaded assemblies.
var generatedSyntax = GenerateForAssemblies(grainAssemblies, true);
var compiled = default(byte[]);
if (generatedSyntax.Syntax != null)
{
compiled = CompileAndLoad(generatedSyntax);
}
foreach (var assembly in generatedSyntax.SourceAssemblies)
{
var generatedAssembly = new GeneratedAssembly { Loaded = true, RawBytes = compiled };
CompiledAssemblies.AddOrUpdate(
assembly.GetName().FullName,
generatedAssembly,
(_, __) => generatedAssembly);
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
(int)ErrorCode.CodeGenCompilationSucceeded,
"Generated code for {0} assemblies in {1}ms",
generatedSyntax.SourceAssemblies.Count,
timer.ElapsedMilliseconds);
}
}
catch (Exception exception)
{
var message = string.Format(
"Exception generating code for input assemblies:\n{0}\nException: {1}",
string.Join("\n", grainAssemblies.Select(_ => _.GetName().FullName)),
TraceLogger.PrintException(exception));
Logger.Warn((int)ErrorCode.CodeGenCompilationFailed, message, exception);
throw;
}
}
/// <summary>
/// Ensures that code generation has been run for the provided assembly.
/// </summary>
/// <param name="input">
/// The assembly to generate code for.
/// </param>
public void GenerateAndLoadForAssembly(Assembly input)
{
try
{
RegisterGeneratedCodeTargets(input);
if (!ShouldGenerateCodeForAssembly(input))
{
TryLoadGeneratedAssemblyFromCache(input);
return;
}
var timer = Stopwatch.StartNew();
var generated = GenerateForAssemblies(new List<Assembly> { input }, true);
var compiled = default(byte[]);
if (generated.Syntax != null)
{
compiled = CompileAndLoad(generated);
}
foreach (var assembly in generated.SourceAssemblies)
{
var generatedAssembly = new GeneratedAssembly { Loaded = true, RawBytes = compiled };
CompiledAssemblies.AddOrUpdate(
assembly.GetName().FullName,
generatedAssembly,
(_, __) => generatedAssembly);
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
(int)ErrorCode.CodeGenCompilationSucceeded,
"Generated code for 1 assembly in {0}ms",
timer.ElapsedMilliseconds);
}
}
catch (Exception exception)
{
var message = string.Format(
"Exception generating code for input assembly {0}\nException: {1}",
input.GetName().FullName,
TraceLogger.PrintException(exception));
Logger.Warn((int)ErrorCode.CodeGenCompilationFailed, message, exception);
throw;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GeneratedAssembly"/> class.
/// </summary>
/// <param name="other">The other instance.</param>
public GeneratedAssembly(GeneratedAssembly other)
{
this.RawBytes = other.RawBytes;
this.DebugSymbolRawBytes = other.DebugSymbolRawBytes;
this.Assembly = other.Assembly;
}
/// <summary>
/// Adds a pre-generated assembly.
/// </summary>
/// <param name="targetAssemblyName">
/// The name of the assembly the provided <paramref name="generatedAssembly"/> targets.
/// </param>
/// <param name="generatedAssembly">
/// The generated assembly.
/// </param>
public void AddGeneratedAssembly(string targetAssemblyName, GeneratedAssembly generatedAssembly)
{
CompiledAssemblies.TryAdd(targetAssemblyName, new CachedAssembly(generatedAssembly));
}
public CachedAssembly(GeneratedAssembly generated) : base(generated)
{
}
/// <summary>
/// Adds a pre-generated assembly to the assembly cache.
/// </summary>
/// <param name="targetAssemblyName">
/// The name of the assembly the provided <paramref name="generatedAssembly"/> targets.
/// </param>
/// <param name="generatedAssembly">
/// The generated assembly.
/// </param>
public static void AddGeneratedAssembly(string targetAssemblyName, GeneratedAssembly generatedAssembly)
{
if (codeGeneratorCacheInstance != null)
{
codeGeneratorCacheInstance.AddGeneratedAssembly(targetAssemblyName, generatedAssembly);
}
else
{
Log.Warn(
ErrorCode.CodeGenDllMissing,
"CodeGenerationManager.AddCachedAssembly called but no code generator has been loaded.");
}
}
/// <summary>
/// Ensures that code generation has been run for the provided assembly.
/// </summary>
/// <param name="input">
/// The assembly to generate code for.
/// </param>
public void GenerateAndLoadForAssembly(Assembly input)
{
if (!ShouldGenerateCodeForAssembly(input))
{
TryLoadGeneratedAssemblyFromCache(input);
return;
}
var timer = Stopwatch.StartNew();
var generated = GenerateForAssemblies(new List<Assembly> { input }, true);
var compiled = default(byte[]);
if (generated.Syntax != null)
{
compiled = CompileAndLoad(generated);
}
foreach (var assembly in generated.SourceAssemblies)
{
var generatedAssembly = new GeneratedAssembly { Loaded = true, RawBytes = compiled };
CompiledAssemblies.AddOrUpdate(
assembly.GetName().FullName,
generatedAssembly,
(_, __) => generatedAssembly);
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
(int)ErrorCode.CodeGenCompilationSucceeded,
"Generated code for 1 assembly in {0}ms",
timer.ElapsedMilliseconds);
}
}
/// <summary>
/// Generates and loads code for the specified inputs.
/// </summary>
/// <param name="inputs">The assemblies to generate code for.</param>
public void GenerateAndLoadForAssemblies(params Assembly[] inputs)
{
if (inputs == null)
{
throw new ArgumentNullException("inputs");
}
var timer = Stopwatch.StartNew();
foreach (var input in inputs)
{
TryLoadGeneratedAssemblyFromCache(input);
}
var grainAssemblies = inputs.Where(ShouldGenerateCodeForAssembly).ToList();
if (grainAssemblies.Count == 0)
{
// Already up to date.
return;
}
// Generate code for newly loaded assemblies.
var generatedSyntax = GenerateForAssemblies(grainAssemblies, true);
var compiled = default(byte[]);
if (generatedSyntax.Syntax != null)
{
compiled = CompileAndLoad(generatedSyntax);
}
foreach (var assembly in generatedSyntax.SourceAssemblies)
{
var generatedAssembly = new GeneratedAssembly { Loaded = true, RawBytes = compiled };
CompiledAssemblies.AddOrUpdate(
assembly.GetName().FullName,
generatedAssembly,
(_, __) => generatedAssembly);
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
(int)ErrorCode.CodeGenCompilationSucceeded,
"Generated code for {0} assemblies in {1}ms",
generatedSyntax.SourceAssemblies.Count,
timer.ElapsedMilliseconds);
}
}
/// <summary>
/// Loads the specified assembly.
/// </summary>
/// <param name="asm">The assembly to load.</param>
private static Assembly LoadAssembly(GeneratedAssembly asm)
{
#if ORLEANS_BOOTSTRAP
throw new NotImplementedException();
#elif NETSTANDARD
Assembly result;
result = Orleans.PlatformServices.PlatformAssemblyLoader.LoadFromBytes(asm.RawBytes, asm.DebugSymbolRawBytes);
AppDomain.CurrentDomain.AddAssembly(result);
return result;
#else
if (asm.DebugSymbolRawBytes != null)
{
return Assembly.Load(
asm.RawBytes,
asm.DebugSymbolRawBytes);
}
else
{
return Assembly.Load(asm.RawBytes);
}
#endif
}
/// <summary>Adds a cached assembly to the code generator.</summary>
/// <param name="targetAssemblyName">The assembly which the cached assembly was generated for.</param>
/// <param name="cachedAssembly">The generated assembly.</param>
public void AddCachedAssembly(string targetAssemblyName, GeneratedAssembly cachedAssembly)
{
CodeGeneratorManager.AddGeneratedAssembly(targetAssemblyName, cachedAssembly);
}
public Task AddCachedAssembly(string targetAssemblyName, GeneratedAssembly cachedAssembly)
{
CodeGeneratorManager.AddGeneratedAssembly(targetAssemblyName, cachedAssembly);
return TaskDone.Done;
}
/// <summary>
/// Initializes a new instance of the <see cref="GeneratedAssembly"/> class.
/// </summary>
/// <param name="other">The other instance.</param>
public GeneratedAssembly(GeneratedAssembly other)
{
this.RawBytes = other.RawBytes;
this.Assembly = other.Assembly;
}
