// Constructor
/// <summary>
/// Create a <see cref="ScriptType"/> from a <see cref="Type"/>.
/// </summary>
/// <param name="type">The <see cref="Type"/> to create the <see cref="ScriptType"/> from</param>
public ScriptType(Type type)
{
this.assembly = null;
this.rawType = type;
// Create member proxies
fields = new ScriptFieldProxy(true, this);
properies = new ScriptPropertyProxy(true, this);
}
internal ScriptType(ScriptAssembly assembly, Type type)
{
this.assembly = assembly;
this.rawType = type;
// Create member proxies
fields = new ScriptFieldProxy(true, this);
properies = new ScriptPropertyProxy(true, this);
}
private ScriptAssembly RegisterAssembly(Assembly assembly, ScriptSecurityMode securityMode, CodeSecurityEngine securityEngine, bool isRuntimeCompiled, CompilationResult compileResult = null)
{
// Check for error
if (assembly == null)
{
return(null);
}
// Reset report
securityResult = null;
// Create script assembly
ScriptAssembly scriptAssembly = new ScriptAssembly(this, assembly, securityEngine, compileResult);
// Check for ensure security mode
bool performSecurityCheck = (securityMode == ScriptSecurityMode.EnsureSecurity);
// Get value from settings
if (securityMode == ScriptSecurityMode.UseSettings)
{
performSecurityCheck = RoslynCSharp.Settings.SecurityCheckCode;
}
// Check for security checks
if (performSecurityCheck == true)
{
// Perform code validation
if (scriptAssembly.SecurityCheckAssembly(RoslynCSharp.Settings.SecurityRestrictions, out securityResult) == false)
{
// Log the error
RoslynCSharp.LogError(securityResult.GetSummaryText());
RoslynCSharp.LogError(securityResult.GetAllText(true));
// Dont load the assembly
return(null);
}
else
{
RoslynCSharp.Log(securityResult.GetSummaryText());
}
}
// Mark as runtime compiled
if (isRuntimeCompiled == true)
{
scriptAssembly.MarkAsRuntimeCompiled();
}
lock (this)
{
// Register with domain
this.loadedAssemblies.Add(scriptAssembly);
}
// Return result
return(scriptAssembly);
}
/// <summary>
/// Attempts to load a managed assembly from the specified raw bytes.
/// Use <see cref="SecurityResult"/> to get the output from the code validation request.
/// </summary>
/// <param name="assemblyBytes">The raw data representing the file structure of the managed assembly, The result of <see cref="File.ReadAllBytes(string)"/> for example.</param>
/// <returns>An instance of <see cref="ScriptAssembly"/> representing the loaded assembly or null if an error occurs</returns>
/// <param name="securityMode">The security mode which determines whether code validation will run</param>
public ScriptAssembly LoadAssembly(byte[] assemblyBytes, ScriptSecurityMode securityMode = ScriptSecurityMode.UseSettings)
{
// Check for disposed
CheckDisposed();
// Load the assembly
Assembly assembly = sandbox.Load(assemblyBytes);
// Create script assembly
return(RegisterAssembly(ScriptAssembly.CreateAssembly(this, assembly, assemblyBytes), securityMode)); //RegisterAssembly(assembly, null, assemblyBytes, securityMode, false);
}
/// <summary>
/// Attempts to load the specified managed assembly into the sandbox app domain.
/// Use <see cref="SecurityResult"/> to get the output from the code validation request.
/// </summary>
/// <param name="name">The <see cref="AssemblyName"/> representing the assembly to load</param>
/// <param name="securityMode">The security mode which determines whether code validation will run</param>
/// <returns>An instance of <see cref="ScriptAssembly"/> representing the loaded assembly or null if an error occurs</returns>
public ScriptAssembly LoadAssembly(AssemblyName name, ScriptSecurityMode securityMode = ScriptSecurityMode.UseSettings)
{
// Check for disposed
CheckDisposed();
// Load the assembly
Assembly assembly = sandbox.Load(name);
// Create script assembly
return(RegisterAssembly(ScriptAssembly.CreateAssembly(this, assembly, assembly.Location), securityMode)); //RegisterAssembly(assembly, assembly.Location, null, securityMode, false);
}
// Methods
/// <summary>
/// Main entry point for async code.
/// </summary>
protected override void RunAsyncOperation()
{
ScriptAssembly result = null;
lock (compileDomain)
{
switch (sourceCompileType)
{
case CompileType.CompileSource:
{
if (sourceOrFiles.Length == 1)
{
// Compile the source
result = compileDomain.CompileAndLoadSource(sourceOrFiles[0], securityMode, additionalReferences);
}
else
{
// Compile the sources
result = compileDomain.CompileAndLoadSources(sourceOrFiles, securityMode, additionalReferences);
}
break;
}
case CompileType.CompileFile:
{
if (sourceOrFiles.Length == 1)
{
// Compile the file
result = compileDomain.CompileAndLoadFile(sourceOrFiles[0], securityMode, additionalReferences);
}
else
{
// Compile the files
result = compileDomain.CompileAndLoadFiles(sourceOrFiles, securityMode, additionalReferences);
}
break;
}
}
// Store result
lock (assemblyAccessLock)
{
compileResult = result;
}
// Set successful flag
isSuccessful = compileDomain.CompileResult.Success;
// Set verified flag
isSecurityVerified = (compileDomain.SecurityResult != null)
? compileDomain.SecurityResult.IsSecurityVerified
: false;
}
}
public ScriptAssembly RegisterAssembly(ScriptAssembly scriptAssembly, ScriptSecurityMode securityMode)
{
// Check for error
if (scriptAssembly == null)
{
return(null);
}
// Reset report
securityResult = null;
// Check for ensure security mode
bool performSecurityCheck = (securityMode == ScriptSecurityMode.EnsureSecurity);
// Get value from settings
if (securityMode == ScriptSecurityMode.UseSettings)
{
performSecurityCheck = RoslynCSharp.Settings.SecurityCheckCode;
}
// Check for security checks
if (performSecurityCheck == true)
{
CodeSecurityRestrictions restrictions = RoslynCSharp.Settings.SecurityRestrictions;
// Use pinvoke option
restrictions.AllowPInvoke = RoslynCSharp.Settings.AllowPInvoke;
// Perform code validation
if (scriptAssembly.SecurityCheckAssembly(restrictions, out securityResult) == false)
{
// Log the error
RoslynCSharp.LogError(securityResult.GetSummaryText());
RoslynCSharp.LogError(securityResult.GetAllText(true));
// Dont load the assembly
return(null);
}
else
{
RoslynCSharp.Log(securityResult.GetSummaryText());
}
}
lock (this)
{
// Register with domain
this.loadedAssemblies.Add(scriptAssembly);
}
// Return result
return(scriptAssembly);
}
/// <summary>
/// Compile and load the specified C# source file.
/// Use <see cref="CompileResult"/> to get the output from the compile request.
/// Use <see cref="SecurityResult"/> to get the output from the code validation request.
/// This does the same as <see cref="CompileAndLoadFileAsync(string, ScriptSecurityMode)"/> but returns the main type of the <see cref="ScriptAssembly"/> for convenience.
/// </summary>
/// <param name="cSharpFile">The filepath to a file containing C# code</param>
/// <param name="securityMode">The code validation used to verify the code</param>
/// <returns>The main type of the compiled assembly or null if the compile failed, security validation failed or there was no main type</returns>
public ScriptType CompileAndLoadMainFile(string cSharpFile, ScriptSecurityMode securityMode = ScriptSecurityMode.UseSettings, IMetadataReferenceProvider[] additionalReferenceAssemblies = null)
{
// Send compile request
ScriptAssembly assembly = CompileAndLoadFile(cSharpFile, securityMode, additionalReferenceAssemblies);
// Try to get main type
if (assembly != null && assembly.MainType != null)
{
return(assembly.MainType);
}
return(null);
}
/// <summary>
/// Attempts to load the specified managed assembly into the sandbox app domain.
/// Use <see cref="SecurityResult"/> to get the output from the code validation request.
/// </summary>
/// <param name="fullPath">The full path the the .dll file</param>
/// <param name="securityMode">The security mode which determines whether code validation will run</param>
/// <returns>An instance of <see cref="ScriptAssembly"/> representing the loaded assembly or null if an error occurs</returns>
public ScriptAssembly LoadAssembly(string fullPath, ScriptSecurityMode securityMode = ScriptSecurityMode.UseSettings)
{
// Check for disposed
CheckDisposed();
// Create an assembly name object
AssemblyName name = AssemblyName.GetAssemblyName(fullPath);// new AssemblyName();
//name.CodeBase = fullPath;
// Load the assembly
Assembly assembly = sandbox.Load(name);
// Create script assembly
return(RegisterAssembly(ScriptAssembly.CreateAssembly(this, assembly, fullPath), securityMode)); //RegisterAssembly<ScriptAssembly>(assembly, fullPath, null, securityMode, false);
}
/// <summary>
/// Attempts to load a managed assembly from the raw assembly data.
/// Any exceptions thrown while loading will be caught.
/// </summary>
/// <param name="data">The raw data representing the file structure of the managed assembly, The result of <see cref="File.ReadAllBytes(string)"/> for example.</param>
/// <param name="result">An instance of <see cref="ScriptAssembly"/> representing the loaded assembly or null if the load failed</param>
/// <param name="securityMode">The security mode which determines whether code validation will run</param>
/// <returns>True if the assembly was loaded successfully or false if an error occured</returns>
public bool TryLoadAssembly(byte[] data, out ScriptAssembly result, ScriptSecurityMode securityMode = ScriptSecurityMode.UseSettings)
{
// Even though this method is safe we cannot allow access to a disposed domain
CheckDisposed();
try
{
// Call through
result = LoadAssembly(data, securityMode);
return(true);
}
catch (Exception)
{
result = null;
return(false);
}
}
/// <summary>
/// Compile and load the specified C# source files.
/// Use <see cref="CompileResult"/> to get the output from the compile request.
/// Use <see cref="SecurityResult"/> to get the output from the code validation request.
/// </summary>
/// <param name="cSharpFiles">An array of filepaths to C# source files</param>
/// <param name="securityMode">The code validation used to verify the code</param>
/// <returns>The compiled and loaded assembly or null if the compil or security verification failed</returns>
public ScriptAssembly CompileAndLoadFiles(string[] cSharpFiles, ScriptSecurityMode securityMode = ScriptSecurityMode.UseSettings, IMetadataReferenceProvider[] additionalReferenceAssemblies = null)
{
// Make sure the compiler is initialized and the domain is valid
CheckDisposed();
CheckCompiler();
lock (this)
{
// Compile from file
compileResult = sharedCompiler.CompileFromFiles(cSharpFiles, additionalReferenceAssemblies);
// Log to console
LogCompilerOutputToConsole();
// Security check
return(RegisterAssembly(ScriptAssembly.CreateAssembly(this, CompileResult), securityMode)); //RegisterAssembly(compileResult.OutputAssembly, compileResult.OutputFile, compileResult.OutputAssemblyImage, securityMode, true, compileResult);
}
}
public static ScriptAssembly CreateAssembly(ScriptDomain domain, Assembly rawAssembly, byte[] assemblyImage)
{
if (rawAssembly == null)
{
return(null);
}
ScriptAssembly asm = new ScriptAssembly()
{
domain = domain,
rawAssembly = rawAssembly,
rawAssemblyImage = assemblyImage,
};
// Build the assembly
asm.BuildAssembly();
return(asm);
}
public static ScriptAssembly CreateAssembly(ScriptDomain domain, Assembly rawAssembly, string assemblyPath)
{
if (rawAssembly == null)
{
return(null);
}
ScriptAssembly asm = new ScriptAssembly()
{
domain = domain,
rawAssembly = rawAssembly,
assemblyPath = assemblyPath,
};
// Build the assembly
asm.BuildAssembly();
return(asm);
}
// Methods
/// <summary>
/// Main entry point for async code.
/// </summary>
protected override void RunAsyncOperation()
{
ScriptAssembly result = null;
lock (loadDomain)
{
switch (loadType)
{
case AssemblyLoadType.LoadByName:
{
result = loadDomain.LoadAssembly(asmName, securityMode);
break;
}
case AssemblyLoadType.LoadByPath:
{
result = loadDomain.LoadAssembly(asmPath, securityMode);
break;
}
case AssemblyLoadType.LoadFromBytes:
{
result = loadDomain.LoadAssembly(asmBytes, securityMode);
break;
}
}
// Store result
lock (assemblyAccessLock)
{
loadResult = result;
}
}
// Set successful flag
isSuccessful = result != null;
// Set verified flag
isSecurityVerified = (loadDomain.SecurityResult != null)
? loadDomain.SecurityResult.IsSecurityVerified
: false;
}
protected internal virtual ScriptType BuildScriptType(ScriptAssembly owner, ScriptType parent, Type type)
{
return(new ScriptType(owner, parent, type));
}
