/// <summary> /// Creates an instance of T /// </summary> /// <typeparam name="T">The type of object to create</typeparam> /// <param name="name">Name of the class</param> /// <returns>A reference to the newly created object.</returns> public T CreateInstance <T>(string name) where T : class { if (!IsCompiled) { Trace.WriteLine("Script \"" + Name + "\" is not compiled. Can't create a new instance \"" + name + "\" of type \"" + typeof(T).Name + "\""); return(default(T)); } // Get type Type t = CompiledAssembly.GetType(name); if (t == null) { Trace.WriteLine("Type \"" + name + "\" not found."); return(default(T)); } // Check interface if (!typeof(T).IsAssignableFrom(t)) { Trace.WriteLine("Type \"" + name + "\" found, but not an instance of \"" + typeof(T).Name + "\"."); return(default(T)); } // Create an instance return(Activator.CreateInstance(t) as T); }
/// <summary> /// Gets all class implementing an interface /// </summary> /// <param name="type">Type of the interface or null for evey interfaces</param> /// <returns>List of classes</returns> public List <string> GetImplementedInterfaces(Type type) { List <string> list = new List <string>(); if (!IsCompiled) { Compile(); } if (CompiledAssembly == null) { return(list); } // Loop through types looking for one that implements the given interface foreach (Type t in CompiledAssembly.GetTypes()) { foreach (Type ty in t.GetInterfaces()) { if (ty == type || type == null) { list.Add(t.Name); } } } list.Sort(); return(list); }
/// <summary> /// Gets a list of specific methods /// </summary> /// <param name="types">An array of type's parameters</param> /// <param name="ret">Retrun value</param> /// <returns></returns> public List <string> GetMethods(Type[] types, Type ret) { List <string> list = new List <string>(); if (!IsCompiled) { Compile(); } if (CompiledAssembly == null) { return(list); } // Loop through types looking for one that implements the given interface foreach (Type t in CompiledAssembly.GetTypes()) { foreach (MethodInfo m in t.GetMethods()) { // return value if (m.ReturnType != ret) { continue; } // Parameters bool ok = false; int id = 0; foreach (ParameterInfo pi in m.GetParameters()) { // Index overrun if (id >= types.Length) { ok = false; break; } // Parameters differents if (pi.ParameterType != types[id]) { ok = false; break; } ok = true; // Next id++; } if (ok && id == types.Length) { list.Add(m.Name); } } } return(list); }
/// <summary> /// Returns all methods /// </summary> /// <returns>Returns a list of method's name</returns> public List <string> GetMethods() { List <string> list = new List <string>(); if (!IsCompiled) { Compile(); } if (CompiledAssembly == null) { return(list); } // Loop through types looking for one that implements the given interface foreach (Type t in CompiledAssembly.GetTypes()) { foreach (MethodInfo m in t.GetMethods()) { list.Add(m.Name); } } list.Sort(); return(list); }
/// <summary> /// Invoke a method in the script /// </summary> /// <param name="method">Method's name</param> /// <param name="args">Arguments</param> /// <returns>true if args or false</returns> // http://msdn.microsoft.com/en-us/library/3y322t50%28v=VS.90%29.aspx => Reflection.Emmit() public bool Invoke(string method, params object[] args) { if (!IsCompiled) { Trace.WriteLine("Invoking method \"" + method + "\" on uncompiled script \"" + Name + "\""); return(false); } try { Type[] type = CompiledAssembly.GetTypes(); MethodInfo[] mi = type[0].GetMethods(); object instance = Activator.CreateInstance(type[0]); object result = type[0].InvokeMember(method, BindingFlags.Default | BindingFlags.InvokeMethod, null, instance, args); } catch (Exception e) { Trace.WriteLine("Exception invoking \"" + method + "\" on uncompiled script \"" + Name + "\" : " + e.Message); } return(true); }
public object executeFirstMethod() { if (CompiledAssembly.notNull()) { var parametersValues = InvocationParameters.valuesArray(); return(CompiledAssembly.executeFirstMethod(ExecuteInStaThread, ExecuteInMtaThread, parametersValues)); } return(null); }
internal static void Process(string name, byte[] peData, byte[] pdbData, string[] defines, string[] references) { var compiledAssembly = new CompiledAssembly { Name = name, InMemoryAssembly = new InMemoryAssembly(peData, pdbData), Defines = defines, References = references }; new PostProcessor().Process(compiledAssembly); }
static bool ProcessArgs(string[] args) { bool success = true; try { var options = new Options(); OptionSet optionSet = new OptionSet() .Add("a|assembly=", a => { options.AssemblyPath = a; }) .Add("o|outputDir=", a => { options.OutputDir = a; }) .Add("p|processors=", a => options.ILPostProcessorPaths = a.Split(',')) .Add("f|assemblyFolders=", a => options.AssemblyFolderPaths = a.Split(',')) .Add("r|assemblyReferences=", a => options.ReferenceAssemblyPaths = a.Split(',')) .Add("d|defines=", a => options.Defines = a.Split(',')); optionSet.Parse(args); AssemblyFolderPaths = options.AssemblyFolderPaths.ToArray(); NamedILPostProcessors = options.ILPostProcessorPaths .Select(p => Assembly.LoadFrom(p)) .SelectMany(asm => asm.GetTypes().Where(t => typeof(ILPostProcessor).IsAssignableFrom(t))) .Select(t => new NamedILPostProcessorWrapper(t.FullName, (ILPostProcessor)Activator.CreateInstance(t))) .ToArray(); OutputAsmPath = Path.Combine(options.OutputDir, Path.GetFileName(options.AssemblyPath)); OutputPdbPath = Path.ChangeExtension(OutputAsmPath, "pdb"); InputAssembly = new CompiledAssembly(options.AssemblyPath, options.ReferenceAssemblyPaths.ToArray(), options.Defines?.ToArray() ?? Array.Empty <string>()); } catch (Exception e) { var rtle = e as ReflectionTypeLoadException; if (rtle == null) { throw; } Console.Error.WriteLine("ILPostProcessorRunner caught the following exception while processing arguments:\n" + e); if (rtle != null) { foreach (Exception inner in rtle.LoaderExceptions) { Console.Error.WriteLine(inner); } } success = false; } return(success); }
/// <summary> /// Create an instance of the specified type, adding it to the Instances collection. /// </summary> public IRuntimeSemanticType Create(string typeName, IRuntimeSemanticType parent = null) { Assert.That(SemanticTypes.ContainsKey(typeName), "The semantic type " + typeName + " has not been declared."); IRuntimeSemanticType t = (IRuntimeSemanticType)CompiledAssembly.CreateInstance("SemanticTypes." + typeName); t.Initialize(this); Guid guid = Guid.NewGuid(); // We create a unique key for this instance. Instances[guid] = (new SemanticTypeInstance() { Name = typeName, Instance = t, Parent = parent, Key = guid, Definition = SemanticTypes[typeName] }); NewSemanticType.Fire(this, new NewSemanticTypeEventArgs(t)); return(t); }
public static Assembly CompileScreenSouceCode(String strSourceCode, String strViewNo) { if (System.IO.Directory.Exists(@"Temp") == false) { System.IO.Directory.CreateDirectory(@"Temp"); } iCount++; CompiledAssembly ass = (CompiledAssembly)Compiler.CompileAssembly(strSourceCode, CodeType.CSharp, String.Format(@"TempScreen{0}_{1}.dll", strViewNo, iCount), new string[] { "System.dll", "System.Data.dll", "System.Core.dll", "Microsoft.CSharp.dll", "System.Drawing.dll", "System.Windows.Forms.dll", "ABCBaseScreen.dll", "dll", "ABCControls.dll", "ABCStudio.exe", "ABCApp.exe", "BaseObjects.dll", "BusinessObjects.dll", "DevExpress.Data.v12.1.dll", "DevExpress.Utils.v12.1.dll", "DevExpress.XtraBars.v12.1.dll", "DevExpress.XtraEditors.v12.1.dll" }); if (ass == null || ass.Errors.Errors.Length > 0) { return(null); } return(ass.Assembly); }
static bool ProcessArgs(string[] args) { bool success = true; try { Parser.Default.ParseArguments <Options>(args) .WithParsed <Options>(o => { NamedILPostProcessors = o.ILPostProcessorPaths .Select(p => Assembly.LoadFrom(p)) .SelectMany(asm => asm.GetTypes().Where(t => typeof(ILPostProcessor).IsAssignableFrom(t))) .Select(t => new NamedILPostProcessorWrapper(t.FullName, (ILPostProcessor)Activator.CreateInstance(t))) .ToArray(); var assemblyPath = args[0]; OutputAsmPath = Path.Combine(o.OutputDir, Path.GetFileName(assemblyPath)); OutputPdbPath = Path.ChangeExtension(OutputAsmPath, "pdb"); InputAssembly = new CompiledAssembly(assemblyPath, o.ReferenceAssemblyPaths.ToArray(), o.ScriptingDefines.ToArray()); }); } catch (Exception e) { Console.WriteLine("ILPostProcessorRunner caught the following exception while processing arguments:\n" + e); var rtle = e as ReflectionTypeLoadException; if (rtle != null) { foreach (Exception inner in rtle.LoaderExceptions) { Console.WriteLine(inner); } } success = false; } return(success); }
private void EmitContentFiles(string outDir) { if (string.IsNullOrEmpty(_cSharpProject.FilePath)) { return; } var p = Project1.Load(_cSharpProject.FilePath); var contentFiles = (from i in p.Items where i.BuildAction == BuildActions.Content select PathUtil.MakeWinPath(i.Name, PathUtil.SeparatorProcessing.Append)).ToArray(); if (!contentFiles.Any()) { return; } var attr = CompiledAssembly.GetCustomAttribute <ResourcesDirectoryAttribute>(); var srcDir = PathUtil.MakeWinPath(attr == null ? null : attr.Source, PathUtil.SeparatorProcessing.Append, PathUtil.SeparatorProcessing.Append).ToLower(); var dstDir = PathUtil.MakeWinPath(attr == null ? null : attr.Destination, PathUtil.SeparatorProcessing.Append, PathUtil.SeparatorProcessing.Append); // ReSharper disable once PossibleNullReferenceException var projectDir = new FileInfo(_cSharpProject.FilePath).Directory.FullName; foreach (var fileName in contentFiles) { if (!fileName.ToLower().StartsWith(srcDir)) { continue; } var relDestFilename = dstDir + fileName.Substring(srcDir.Length); var dstFile = Path.Combine(outDir, relDestFilename.Substring(1)); var srcFile = Path.Combine(projectDir, fileName.Substring(1)); Console.WriteLine("copy {0} to {1}", fileName, relDestFilename); // ReSharper disable once PossibleNullReferenceException new FileInfo(dstFile).Directory.Create(); File.Copy(srcFile, dstFile, true); } }
private AssemblyLoadResult CompileInMemory(string name, Compilation compilation, IEnumerable <ResourceDescription> resources) { using (var pdbStream = new MemoryStream()) using (var assemblyStream = new MemoryStream()) { #if DESKTOP EmitResult result = compilation.Emit(assemblyStream, pdbStream: pdbStream, manifestResources: resources); #else EmitResult result = compilation.Emit(assemblyStream); #endif if (!result.Success) { return(ReportCompilationError(result)); } var assemblyBytes = assemblyStream.ToArray(); #if DESKTOP var pdbBytes = pdbStream.ToArray(); #endif var compiled = new CompiledAssembly { #if DESKTOP Assembly = Assembly.Load(assemblyBytes, pdbBytes), #else Assembly = Assembly.Load(assemblyBytes), #endif MetadataReference = compilation.ToMetadataReference() }; _compiledAssemblies[name] = compiled; return(new AssemblyLoadResult(compiled.Assembly)); } }
private static bool Run(Options options) { TypeCollection totalTypeCollection; try { totalTypeCollection = LoadAll(options); } catch (IOException e) { Console.WriteLine("Error loading files: " + e.Message); return(false); } options.Log("Preparing output template C# source code."); string template = Assembly.GetExecutingAssembly() .GetEmbeddedResourceText("Crossdox/DefaultTemplates/SingleDocument.template"); string sourceCode = SourceCodeGenerator.CreateFullSourceFile(template, "SingleDocument.template", new[] { new TemplateArg(typeof(NameInfo), "RootNamespace"), new TemplateArg(typeof(TypeCollection), "Types") }, includeName => { string includeText = Assembly.GetExecutingAssembly() .GetEmbeddedResourceText("Crossdox/DefaultTemplates/" + includeName); return(includeText); } ); options.Log("Compiling output template source code."); string crossdoxCacheFolder = Path.Combine(Path.GetTempPath(), "crossdox"); CompiledAssemblyCache assemblyCache = new CompiledAssemblyCache(crossdoxCacheFolder); CompiledAssembly compiledAssembly = assemblyCache.LoadOrCompile(options, sourceCode, "SingleDocument.template"); if (compiledAssembly.HasErrors) { foreach (string error in compiledAssembly.Errors) { Console.Error.WriteLine("Error compiling script: " + error); } return(false); } Assembly assembly = compiledAssembly.ToAssembly(); options.Log("Reflecting against template assembly."); Type compiledTemplate = assembly.GetType("TemplateScript.CompiledTemplate"); ConstructorInfo constructor = compiledTemplate.GetConstructor(Type.EmptyTypes); object compiledTemplateInstance = constructor.Invoke(new object[0]); MethodInfo runMethod = compiledTemplate.GetMethod("Run"); object[] runArgs = new object[] { new NameInfo(null, "Test", null, null, default), totalTypeCollection, }; options.Log("Invoking template assembly Run() method."); string result; try { result = (string)runMethod.Invoke(compiledTemplateInstance, runArgs); } catch (TargetInvocationException e) { if (e.InnerException != null) { Console.Error.WriteLine("Error running script: " + e.InnerException); } else { Console.Error.WriteLine("Error running script: " + e); } return(false); } if (result != null) { Console.WriteLine(result); } return(true); }
private AssemblyLoadResult CompileInMemory(string name, Compilation compilation, IEnumerable<ResourceDescription> resources) { using (var pdbStream = new MemoryStream()) using (var assemblyStream = new MemoryStream()) { #if DESKTOP EmitResult result = compilation.Emit(assemblyStream, pdbStream: pdbStream, manifestResources: resources); #else EmitResult result = compilation.Emit(assemblyStream); #endif if (!result.Success) { return ReportCompilationError(result); } var assemblyBytes = assemblyStream.ToArray(); #if DESKTOP var pdbBytes = pdbStream.ToArray(); #endif var compiled = new CompiledAssembly { #if DESKTOP Assembly = Assembly.Load(assemblyBytes, pdbBytes), #else Assembly = Assembly.Load(assemblyBytes), #endif MetadataReference = compilation.ToMetadataReference() }; _compiledAssemblies[name] = compiled; return new AssemblyLoadResult(compiled.Assembly); } }