public static Assembly Compile(string sSource, string[] referencedAssemblies)
{
Microsoft.CSharp.CSharpCodeProvider comp = new Microsoft.CSharp.CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
if (!PlatformDetector.IsUnix)
{
cp.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().CodeBase.Replace("file:///", ""));
}
else
{
cp.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().CodeBase.Replace("file://", ""));
}
cp.GenerateExecutable = false;
cp.GenerateInMemory = true;
foreach (var assembly in referencedAssemblies)
{
cp.ReferencedAssemblies.Add(Path.Combine(
AppDomain.CurrentDomain.BaseDirectory
, assembly + ".dll"));
}
CompilerResults cr = comp.CompileAssemblyFromSource(cp, sSource);
if (cr.Errors.HasErrors)
{
StringBuilder sError = new StringBuilder();
sError.Append("Error Compiling Expression: ");
foreach (CompilerError err in cr.Errors)
sError.AppendFormat("{0}\n", err.ErrorText);
throw new ApplicationException("Ошибка компиляции выражения: " + sError.ToString() + "\n" + sSource);
}
return cr.CompiledAssembly;
}
public static string GenTableAdapters(System.IO.Stream xmlStream, TypedDataSetGenerator.GenerateOption genOption, string customToolNamespace)
{
try
{
EnsureCustomDbProviders();
var designSource = Activator.CreateInstance(assm.GetType("System.Data.Design.DesignDataSource"));
designSource.Invoke("ReadXmlSchema", xmlStream, string.Empty );
var dataSourceGeneratorType = assm.GetType("System.Data.Design.TypedDataSourceCodeGenerator");
//get the specific constructor
var constructor = dataSourceGeneratorType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic,
null, CallingConventions.Any, new Type[0], new ParameterModifier[0]);
var dataSourceGenerator = constructor.Invoke(null);
var codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
dataSourceGenerator.SetInternalPropertyValue("CodeProvider", codeProvider);
var codeCompileUnit = new CodeCompileUnit();
var codeNamespace = new CodeNamespace(customToolNamespace);
codeCompileUnit.Namespaces.Add(codeNamespace);
dataSourceGenerator.InvokeInternal("GenerateDataSource", designSource, codeCompileUnit, codeNamespace, customToolNamespace, genOption );
var writer = new StringWriter();
var adapterNameSpace = codeCompileUnit.Namespaces[1];
codeProvider.GenerateCodeFromNamespace(adapterNameSpace, writer, new CodeGeneratorOptions());
//codeProvider.GenerateCodeFromCompileUnit(codeCompileUnit, writer, options);
var res = writer.ToString();
return (string)res;
}
catch (Exception e)
{
return e.ToString();
}
}
public bool execScript(string dirPath)
{
Microsoft.CSharp.CSharpCodeProvider csharp = new Microsoft.CSharp.CSharpCodeProvider();
// Setup default params for compiler
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
compilerParams.IncludeDebugInformation = false;
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
compilerParams.ReferencedAssemblies.Add("System.Windows.Forms.dll");
compilerParams.ReferencedAssemblies.Add("NoxShared.dll");
// Compile C# script
CompilerResults results = csharp.CompileAssemblyFromFile(compilerParams, Directory.GetFiles(dirPath, "*.cs"));
// Error handling
if (results.Errors.Count > 0)
{
foreach (CompilerError e in results.Errors)
System.Diagnostics.Debug.WriteLine(String.Format("{0} {1}: {2}", e.FileName, e.Line, e.ErrorText));
return false;
}
// Save assembly in class variable
scriptAssembly = results.CompiledAssembly;
// Create Script Instance
if (initScript())
{
// Run Script
return runScript();
}
return false;
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
if (_csStatement != null)
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromStatement(_csStatement, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
if (_vbStatement != null)
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromStatement(_vbStatement, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
// public ���\�b�h
public void CompileFile(string filePath)
{
if(!File.Exists(filePath)){
throw new Exception("�t�@�C��������܂��� : " + filePath);
}
CodeDomProvider myCompiler;
string ext = Path.GetExtension(filePath).ToLower();
switch(ext){
case JsExt:
myCompiler = new Microsoft.JScript.JScriptCodeProvider();
break;
case CsExt:
myCompiler = new Microsoft.CSharp.CSharpCodeProvider();
break;
case VbExt:
myCompiler = new Microsoft.VisualBasic.VBCodeProvider();
break;
default:
throw new Exception("���Ή��̃t�@�C���g���q�ł�: " + filePath);
}
myPluginDllPath = mySetting.TemplateDir + Path.GetFileNameWithoutExtension(filePath) + ".dll";
string code = Util.LoadFile(filePath);
CompilerParameters cp = new CompilerParameters();
cp.GenerateExecutable = true;
cp.OutputAssembly = myPluginDllPath;
CompilerResults cr = myCompiler.CompileAssemblyFromSource(cp, code);
foreach(string s in cr.Output){
Console.WriteLine(s);
}
myCompiler.Dispose();
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("continue;");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Continue For");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("var {0} = ", provider.CreateEscapedIdentifier(VariableName));
provider.GenerateCodeFromExpression(InitExpression, tw, opts);
tw.Write(";");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Dim {0} = ", provider.CreateEscapedIdentifier(VariableName));
provider.GenerateCodeFromExpression(InitExpression, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public static Assembly Compile(string sourcecode, string[] references, CompileLanguage language = CompileLanguage.CSharp)
{
CodeDomProvider comp = null;
switch (language)
{
case CompileLanguage.VisualBasic:
comp = new Microsoft.VisualBasic.VBCodeProvider();
break;
case CompileLanguage.CSharp:
default:
comp = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
CompilerParameters cp = new CompilerParameters();
foreach (string reference in references)
{
cp.ReferencedAssemblies.Add(reference);
}
cp.GenerateInMemory = true;
CompilerResults cr = comp.CompileAssemblyFromSource(cp, sourcecode);
if (cr.Errors.HasErrors)
{
string error = string.Empty;
foreach (CompilerError err in cr.Errors)
{
error += err.ErrorText + System.Environment.NewLine;
}
System.Diagnostics.Trace.WriteLine(error);
return null;
}
return cr.CompiledAssembly;
}
public override object Execute(string code)
{
ICodeCompiler compiler = new Microsoft.CSharp.CSharpCodeProvider().CreateCompiler();
CompilerParameters cmpParams = new System.CodeDom.Compiler.CompilerParameters();
cmpParams.GenerateInMemory = true;
cmpParams.GenerateExecutable = true;
//cmpParams.CompilerOptions = "/t:exe";
foreach (string ass in this._referencedAssemblies)
cmpParams.ReferencedAssemblies.Add(ass+".dll");
string codeString = this.GenerateReferenceString();
codeString = this.InsertCode(code);
CompilerResults results = compiler.CompileAssemblyFromSource(cmpParams, codeString);
// foreach (System.CodeDom.Compiler.CompilerError ce in results.Errors)
// this.Put(ce.ErrorText);
if (results.Errors.Count == 0 && results.CompiledAssembly!=null)
{
System.Reflection.MethodInfo methodInfo = results.CompiledAssembly.EntryPoint;
return methodInfo.Invoke(null, null);
}
return null;
}
//-----------------------------------------------------------------------------
// Internal Methods
//-----------------------------------------------------------------------------
// Compile the final code for a script only to find any errors and/or warnings.
private static ScriptCompileResult CompileScript(string code)
{
// Setup the compile options.
CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = false; // We want a Dll (Class Library)
options.GenerateInMemory = true;
// Add the assembly references.
Assembly zeldaApiAssembly = Assembly.GetAssembly(typeof(ZeldaAPI.CustomScriptBase));
options.ReferencedAssemblies.Add(zeldaApiAssembly.Location);
// Create a C# code provider and compile the code.
Microsoft.CSharp.CSharpCodeProvider csProvider = new Microsoft.CSharp.CSharpCodeProvider();
CompilerResults csResult = csProvider.CompileAssemblyFromSource(options, code);
// Copy warnings and errors into the ScriptComileResult.
ScriptCompileResult result = new ScriptCompileResult();
foreach (CompilerError csError in csResult.Errors) {
ScriptCompileError error = new ScriptCompileError(csError.Line,
csError.Column, csError.ErrorNumber, csError.ErrorText, csError.IsWarning);
if (error.IsWarning)
result.Warnings.Add(error);
else
result.Errors.Add(error);
}
return result;
}
public static void createAssembly(string code)
{
string[] sources = { code };
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = (bool)launchArguments.flags["createbinary"];
if ((bool)launchArguments.flags["createbinary"])
parameters.OutputAssembly = IO.getExePath();
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
parameters.ReferencedAssemblies.Add("System.Drawing.dll");
using (Microsoft.CSharp.CSharpCodeProvider CodeProv =
new Microsoft.CSharp.CSharpCodeProvider())
{
CompilerResults results = CodeProv.CompileAssemblyFromSource(parameters, sources);
if (results.Errors.HasErrors)
debug.throwException("Compilation error", String.Join(Environment.NewLine, results.Errors.Cast<CompilerError>().Select(n => n.ToString())), debug.importance.Fatal);
if (!(bool)launchArguments.flags["createbinary"])
{
Console.WriteLine("Initializing ListSharp");
var type = results.CompiledAssembly.GetType("MainClass");
var obj = Activator.CreateInstance(type);
var output = type.GetMethod("Execute").Invoke(obj, new object[] { });
Console.WriteLine(output);
}
}
}
public static string ParseString(string input)
{
var provider = new Microsoft.CSharp.CSharpCodeProvider();
var parameters = new System.CodeDom.Compiler.CompilerParameters()
{
GenerateExecutable = false,
GenerateInMemory = true,
};
var code = @"
namespace Tmp
{
public class TmpClass
{
public static string GetValue()
{
return """ + input + @""";
}
}
}";
var compileResult = provider.CompileAssemblyFromSource(parameters, code);
if (compileResult.Errors.HasErrors)
{
return input;
//throw new ArgumentException(compileResult.Errors.Cast<System.CodeDom.Compiler.CompilerError>().First(e => !e.IsWarning).ErrorText);
}
var asmb = compileResult.CompiledAssembly;
var method = asmb.GetType("Tmp.TmpClass").GetMethod("GetValue");
return method.Invoke(null, null) as string;
}
private static CodeDomProvider GetCodeDomProvider(string fileExtension)
{
CodeDomProvider cdp;
switch (fileExtension)
{
case ".fsx":
cdp = CodeDomProvider.CreateProvider("f#");
break;
case ".csx":
cdp = new Microsoft.CSharp.CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v3.5" } });
break;
case ".vbx":
cdp = new Microsoft.VisualBasic.VBCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v3.5" } });
break;
case ".jsx":
// Have to figure out better JS support
cdp = CodeDomProvider.CreateProvider("js");
break;
default:
if (CodeDomProvider.IsDefinedExtension(fileExtension))
{
cdp = CodeDomProvider.CreateProvider(CodeDomProvider.GetLanguageFromExtension(fileExtension));
}
else
{
throw new ScriptDoesNotCompileException("Unknown extension.");
}
break;
}
return cdp;
}
private void GenerateCS()
{
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringWriter sw = new StringWriter();
provider.GenerateCodeFromMember(_method, sw, opts);
StringReader sr = new StringReader(sw.GetStringBuilder().ToString());
string line = sr.ReadLine();
while (string.IsNullOrEmpty(line))
line = sr.ReadLine();
int idx = line.IndexOf(" " + _method.Name + "(");
idx = line.LastIndexOf(' ', idx - 1);
if (_method.Statements.Count > 0)
{
Text = "partial" + line.Remove(0, idx);
Text = sw.GetStringBuilder().Replace(line, Text).ToString();
}
else
{
line = "partial" + line.Remove(0, idx);
idx = line.LastIndexOf(')');
Text = line.Remove(idx + 1) + ";" + Environment.NewLine;
}
}
}
/// <summary>
/// 动态编译
/// </summary>
/// <param name="formula">需编译的内容</param>
/// <param name="returnType">返回类型</param>
/// <param name="obj">参数</param>
/// <returns></returns>
public static object Calculate(string formula, string returnType, object obj)
{
try
{
string paramExp = obj.GetType().ToString() + " obj";
object calculated = null;
Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters parameter = new System.CodeDom.Compiler.CompilerParameters();
parameter.ReferencedAssemblies.Add("System.dll");
parameter.GenerateExecutable = false; //<--不要生成 EXE 文件
parameter.GenerateInMemory = true; //在内存中运行
string codeDom = GenerateCodeBlocks(formula, returnType, paramExp);
System.CodeDom.Compiler.CompilerResults result = provider.CompileAssemblyFromSource(parameter,codeDom);//动态编译后的结果
if (result.Errors.Count > 0)
{
return null;
}
System.Reflection.MethodInfo newMethod = result.CompiledAssembly.GetType("Maike.Calculation").GetMethod("dowork");
calculated = result.CompiledAssembly.GetType("Maike.Calculation").GetMethod("dowork").Invoke(null, new object[] { obj });
return calculated;
}
catch
{
return null;
}
}
static void Main(params string[] args)
{
var path = @"..\..\..\Mubble.Data\Raw\Database.dbml";
var dataTypeAssemblyPath = @"..\..\..\Mubble.Data\bin\Debug\Mubble.Data.dll";
var dataTypePath = @"..\..\..\Mubble.Data\Generated\DataTypes.xml";
var output = @"..\..\..\Mubble.Data\Generated\RecordTypes.cs";
var dataTypeOutput = @"..\..\..\Mubble.Data\Generated\DataTypes.cs";
LoadDataTypeAssembly(dataTypeAssemblyPath, dataTypePath);
var cs = new Microsoft.CSharp.CSharpCodeProvider();
var types = DataObjectHelper.Convert(dataTypePath);
var c = Generate(types.ToCompileUnit(), cs);
File.WriteAllText(dataTypeOutput, c);
var database = DbmlHelper.Convert(path);
var code = Generate(database.ToCompileUnit(), cs);
File.WriteAllText(output, code);
//Console.ReadLine();
}
/// <summary>
/// Writes the code to string in the specific language
/// and returns the string
/// </summary>
public static string Create(Language language, string expression, RegexOptions options)
{
CodeCompileUnit unit = Create(expression, options);
System.Text.StringBuilder builder = new System.Text.StringBuilder();
using (System.IO.StringWriter stringWriter = new System.IO.StringWriter(builder))
{
System.CodeDom.Compiler.ICodeGenerator generator;
switch (language)
{
case Language.CSharp:
System.CodeDom.Compiler.CodeGeneratorOptions genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions();
genOptions.BracingStyle = "C";
generator = new Microsoft.CSharp.CSharpCodeProvider().CreateGenerator();
generator.GenerateCodeFromCompileUnit(unit, stringWriter, genOptions);
break;
case Language.VisualBasic:
generator = new Microsoft.VisualBasic.VBCodeProvider().CreateGenerator();
generator.GenerateCodeFromCompileUnit(unit, stringWriter, null);
break;
}
return builder.ToString();
}
}
public static void service_info_methods()
{
uri = new Uri("http://localhost:60377/Service1.asmx?wsdl");
WebRequest webRequest = WebRequest.Create(uri);
System.IO.Stream requestStream = webRequest.GetResponse().GetResponseStream();
// Get a WSDL file describing a service
ServiceDescription sd = ServiceDescription.Read(requestStream);
string sdName = sd.Services[0].Name;
// Initialize a service description servImport
ServiceDescriptionImporter servImport = new ServiceDescriptionImporter();
servImport.AddServiceDescription(sd, String.Empty, String.Empty);
servImport.ProtocolName = "Soap";
servImport.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
CodeNamespace nameSpace = new CodeNamespace();
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(nameSpace);
// Set Warnings
ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit);
if (warnings == 0)
{
StringWriter stringWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture);
Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider();
prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions());
string[] assemblyReferences = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
CompilerParameters param = new CompilerParameters(assemblyReferences);
param.GenerateExecutable = false;
param.GenerateInMemory = true;
param.TreatWarningsAsErrors = false;
param.WarningLevel = 4;
CompilerResults results = new CompilerResults(new TempFileCollection());
results = prov.CompileAssemblyFromDom(param, codeCompileUnit);
Assembly assembly = results.CompiledAssembly;
service = assembly.GetType(sdName);
methodInfo = service.GetMethods();
int c = 0;
foreach (MethodInfo t in methodInfo)
{
if (t.Name == "Discover")
break;
c++;
}
listurl = new string[c]; c = 0;
foreach (MethodInfo t in methodInfo)
{
if (t.Name == "Discover")
break;
listurl[c++] = t.Name;
}
}
}
public CSharpRoslynCompilerService(bool strictMode = true, Func<ParserBase> markupParserFactory = null)
: base(new RazorEngine.Compilation.CSharp.CSharpRazorCodeLanguage(strictMode),
markupParserFactory)
{
#if !RAZOR4
_codeDomProvider = new Microsoft.CSharp.CSharpCodeProvider();
#endif
}
public static string Friendly(Type type)
{
using (var provider = new Microsoft.CSharp.CSharpCodeProvider())
{
var @ref = new CodeTypeReference(type);
return provider.GetTypeOutput(@ref);
}
}
public EmbeddedScripting()
{
CodeProvider = new Microsoft.CSharp.CSharpCodeProvider();
Parameters = new CompilerParameters();
Parameters.GenerateExecutable = false;
Parameters.GenerateInMemory = true;
Parameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
}
static void CompileScripts( Dictionary<string, Script> scripts, Dictionary<string, CommandDelegate> commands, ClassicBot main )
{
foreach( var keypair in scripts ) {
Script script = keypair.Value;
if( String.IsNullOrEmpty( script.Code ) ) continue;
CodeDomProvider compiler;
if( script.IsCSharp ) {
compiler = new Microsoft.CSharp.CSharpCodeProvider( new Dictionary<string, string>{ { "CompilerVersion", "v2.0" } } );
} else {
compiler = new Microsoft.VisualBasic.VBCodeProvider( new Dictionary<string, string>{ { "CompilerVersion", "v2.0" } } );
}
CompilerParameters cParams = new CompilerParameters {
GenerateExecutable = false,
GenerateInMemory = true,
//CompilerOptions = "/unsafe", Causes errors with the Visual Basic Compiler.
TreatWarningsAsErrors = false,
WarningLevel = 4,
};
if( script.KnownReferences == null || script.KnownReferences.Length == 0 ) { // Add defalt references.
cParams.ReferencedAssemblies.Add( "System.dll" );
cParams.ReferencedAssemblies.Add( "LibClassicBot.dll" );
} else {
cParams.ReferencedAssemblies.AddRange( script.KnownReferences );
}
CompilerResults results = compiler.CompileAssemblyFromSource( cParams, script.Code );
if( results.Errors.Count != 0 ) {
try {
foreach( CompilerError error in results.Errors ) {
string errorMsg = String.Format( "{0} Line: {1} {2}", error.ErrorNumber, error.Line, error.ErrorText );
if( error.IsWarning ) {
main.Log( LogType.Error, "Warning while compiling script " + keypair.Key, errorMsg );
} else {
main.Log( LogType.Error, "Error while compiling script " + keypair.Key, errorMsg );
}
}
} catch( Exception e ) {
main.Log( LogType.Error, "Error while trying to display errors. " , e.ToString() );
}
continue;
}
compiler.Dispose();
Type[] types = results.CompiledAssembly.GetTypes();
for( int i = 0; i < types.Length; i++ ) {
Type type = types[i];
if( type.IsSubclassOf( typeof( Plugin ) ) ) {
Plugin plugin = (Plugin)Activator.CreateInstance( type );
plugin.Initialize( main );
if( !commands.ContainsKey( plugin.CommandName ) ) {
main.Log( LogType.BotActivity, "Loaded command " + plugin.CommandName );
commands.Add( plugin.CommandName, plugin.Command );
}
}
}
}
}
private void GenerateCS()
{
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringWriter sw = new StringWriter();
List<CodeTypeReference> implTypes = new List<CodeTypeReference>();
if (_property.ImplementationTypes != null)
{
var arr = new CodeTypeReference[_property.ImplementationTypes.Count];
_property.ImplementationTypes.CopyTo(arr, 0);
_property.ImplementationTypes.Clear();
_property.PrivateImplementationType = null;
implTypes.AddRange(arr);
}
provider.GenerateCodeFromMember(_property, sw, opts);
foreach (CodeTypeReference tr in implTypes)
{
_property.ImplementationTypes.Add(tr);
}
//StringReader sr = new StringReader(sw.GetStringBuilder().ToString());
//string line = sr.ReadLine();
//while (string.IsNullOrEmpty(line) || line.StartsWith("/") || line.StartsWith("["))
// line = sr.ReadLine();
StringBuilder sb = new StringBuilder();
if (InterfaceProperties != null)
{
foreach (CodeTypeReference tr in implTypes)
{
string prop;
if (InterfaceProperties.TryGetValue(tr, out prop))
{
var newProp = Define.Property(_property.Type, MemberAttributes.Private, prop).Implements(tr);
if (_property.HasGet)
{
newProp.GetStatements.Add(Emit.@return(()=>[email protected](_property.Name)));
newProp.HasGet = true;
}
if (_property.HasSet)
{
newProp.SetStatements.Add(Emit.assignProperty(_property.Name, () => CodeDom.VarRef("value")));
newProp.HasSet = true;
}
StringWriter swNew = new StringWriter();
provider.GenerateCodeFromMember(CodeDomTreeProcessor.ProcessMember(newProp, CodeDomGenerator.Language.CSharp),
swNew, opts);
sb.Append(swNew.ToString());
}
}
if (sb.Length > 0)
sb.Insert(0, Environment.NewLine);
}
Text = sw.GetStringBuilder().ToString() + sb.ToString();
}
}
static void Main(string[] args)
{
CodeDomProvider codeDomProvider = new Microsoft.CSharp.CSharpCodeProvider();
string[] assemblyNames = new string[]{
"mscorlib.dll",
"System.dll",
"System.Data.dll",
"System.Drawing.dll",
"System.Xml.dll",
"System.Core.dll",
"System.Windows.Forms.dll"
};
CompilerParameters compilerParameters = new CompilerParameters(assemblyNames){
OutputAssembly = "OutputAssembly.dll",
GenerateExecutable = false,
GenerateInMemory = true,
WarningLevel = 3,
CompilerOptions = "/optimize",
IncludeDebugInformation = false,
//TempFiles = new TempFileCollection(".", true)
};
CompilerResults compilerResults = codeDomProvider.CompileAssemblyFromSource(
compilerParameters,
new string[] { Code });
/* This prints low-level messages like this, as well as error messages:
*
* G:\tmp\CsCompilerTest\WorkingDir> "C:\Windows\Microsoft.NET\Framework\v4.0.30319
* \csc.exe" /t:library /utf8output /out:"C:\Users\Adam Sawicki\AppData\Local\Temp\
* 0pdzupen.dll" /debug- /optimize+ /w:3 /optimize "C:\Users\Adam Sawicki\AppData\
* Local\Temp\0pdzupen.0.cs"
* Microsoft (R) Visual C# 2010 Compiler version 4.0.30319.1
* Copyright (C) Microsoft Corporation. All rights reserved.
*/
foreach (String message in compilerResults.Output)
Console.WriteLine(message);
/* This prints error messages in form of:
*
* c:\Users\Adam Sawicki\AppData\Local\Temp\4kbqoyz2.0.cs(7,9) : error CS0103: The
* name 'Console' does not exist in the current context
*/
//foreach (CompilerError error in compilerResults.Errors)
// Console.WriteLine(error.ToString());
Assembly assembly = compilerResults.CompiledAssembly;
if (assembly == null) return;
object obj = assembly.CreateInstance("MainClass");
if (obj == null) return;
Type type = obj.GetType();
type.InvokeMember("Main", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public, null, obj, new object[] { });
}
/// <summary>
/// Generates an Assembly from a script filename
/// </summary>
/// <param name="filename">The filename of the script</param>
/// <param name="references">Assembly references for the script</param>
/// <returns>The generated assembly</returns>
public Assembly CreateAssembly(string filename, IList references)
{
// ensure that compilerErrors is null
compilerErrors = null;
string extension = Path.GetExtension(filename);
// Select the correct CodeDomProvider based on script file extension
CodeDomProvider codeProvider = null;
switch (extension)
{
case ".cs":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".vb":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
default:
throw new InvalidOperationException("Script files must have a .cs or .vb.");
}
// Set compiler parameters
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.CompilerOptions = "/target:library /optimize";
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
compilerParams.IncludeDebugInformation = false;
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
// Add custom references
foreach (string reference in references)
{
if (!compilerParams.ReferencedAssemblies.Contains(reference))
{
compilerParams.ReferencedAssemblies.Add(reference);
}
}
// Do the compilation
CompilerResults results = codeProvider.CompileAssemblyFromFile(compilerParams,
filename);
//Do we have any compiler errors
if (results.Errors.Count > 0)
{
compilerErrors = results.Errors;
throw new Exception(
"Compiler error(s) encountered and saved to AssemblyFactory.CompilerErrors");
}
Assembly createdAssembly = results.CompiledAssembly;
return createdAssembly;
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("foreach (");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(IterationItemType), tw, opts);
tw.Write(" {0} in ", provider.CreateValidIdentifier(IterationItemName));
provider.GenerateCodeFromExpression(IterExpression, tw, opts);
tw.WriteLine(")");
tw.WriteLine("{");
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.WriteLine("}");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("For Each {0} As ", provider.CreateValidIdentifier(IterationItemName));
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(IterationItemType), tw, opts);
tw.Write(" in ");
provider.GenerateCodeFromExpression(IterExpression, tw, opts);
tw.WriteLine();
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.WriteLine("Next");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.WriteLine("do");
tw.WriteLine("{");
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.Write("} while (");
if (TestExpression != null)
provider.GenerateCodeFromExpression(TestExpression, tw, opts);
tw.WriteLine(");");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.WriteLine("Do");
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.Write("Loop Until ");
if (TestExpression != null)
provider.GenerateCodeFromExpression(TestExpression, tw, opts);
tw.WriteLine();
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
/// <summary>
/// Gets the primitive value literal.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>System.String.</returns>
public static string GetPrimitiveValueLiteral(object value)
{
using (var writer = new StringWriter(CultureInfo.InvariantCulture))
using (var provider = new Microsoft.CSharp.CSharpCodeProvider())
{
provider.GenerateCodeFromExpression(new CodePrimitiveExpression(value), writer, null);
return writer.ToString();
}
}
public Assembly CreateAssembly(string filename, IList references)
{
compilerErrors = null;
string extension = Path.GetExtension(filename);
CodeDomProvider codeProvider = null;
switch (extension)
{
case ".cs":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".vb":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
default:
throw new InvalidOperationException("Script files must have a .cs or .vb.");
}
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.CompilerOptions = "/target:library /optimize";
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
compilerParams.IncludeDebugInformation = false;
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
foreach (string reference in references)
{
if (!compilerParams.ReferencedAssemblies.Contains(reference))
{
compilerParams.ReferencedAssemblies.Add(reference);
}
}
CompilerResults results = codeProvider.CompileAssemblyFromFile(compilerParams,
filename);
if (results.Errors.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError item in results.Errors)
{
sb.AppendFormat("{0} line:{1} {2}\r\n", item.FileName, item.Line, item.ErrorText);
}
compilerErrors = results.Errors;
throw new Exception(
"Compiler error(s)\r\n" + sb.ToString());
}
Assembly createdAssembly = results.CompiledAssembly;
return createdAssembly;
}
public ASLMethod(String code)
{
using (var provider =
new Microsoft.CSharp.CSharpCodeProvider())
{
var builder = new StringBuilder();
builder
.AppendLine("using System;")
.AppendLine("using System.Collections.Generic;")
.AppendLine("using System.Linq;")
.AppendLine("using System.Reflection;")
.AppendLine("using System.Text;")
.AppendLine("public class CompiledScript")
.AppendLine("{")
.AppendLine("public dynamic Execute(dynamic timer, dynamic old, dynamic current)")
.AppendLine("{")
.Append(code)
.Append("return null;")
.AppendLine("}")
.AppendLine("}");
var parameters = new System.CodeDom.Compiler.CompilerParameters()
{
GenerateInMemory = true,
CompilerOptions = "/optimize",
};
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add("System.Data.dll");
parameters.ReferencedAssemblies.Add("System.Data.DataSetExtensions.dll");
parameters.ReferencedAssemblies.Add("System.Drawing.dll");
parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
parameters.ReferencedAssemblies.Add("System.Xml.dll");
parameters.ReferencedAssemblies.Add("System.Xml.Linq.dll");
parameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
var res = provider.CompileAssemblyFromSource(parameters, builder.ToString());
if (res.Errors.HasErrors)
{
var errorMessage = "";
foreach (var error in res.Errors)
{
errorMessage += error + "\r\n";
}
throw new ArgumentException(errorMessage, "code");
}
var type = res.CompiledAssembly.GetType("CompiledScript");
CompiledCode = Activator.CreateInstance(type);
}
}
private CodeDomProvider GetProviderAndSetExtension(string codeLanguage, ref string outputFile)
{
String codeLang;
if (!_codeLangMapping.TryGetValue(codeLanguage, out codeLang))
{
throw new NotSupportedException("The specified code language is not supported: '" +
CodeLanguage +
"'");
}
CodeDomProvider provider;
switch (codeLang)
{
case CSharp:
provider = new Microsoft.CSharp.CSharpCodeProvider();
outputFile = Path.ChangeExtension(outputFile, ".cs");
break;
case VisualBasic:
provider = new Microsoft.VisualBasic.VBCodeProvider();
outputFile = Path.ChangeExtension(outputFile, ".vb");
break;
case FSharp_cl:
provider = new FSharp.Compiler.CodeDom.FSharpCodeProvider();
outputFile = Path.ChangeExtension(outputFile, ".fs");
break;
case CPP:
// We load the CppCodeProvider via reflection since a hard reference would
// require client machines to have the provider installed just to run the task.
// This way relieves us of the dependency.
try
{
Assembly cppCodeProvider = Assembly.Load(CppCodeProviderAssembly);
provider = cppCodeProvider.CreateInstance(CppCodeProviderType)
as CodeDomProvider;
}
catch (FileLoadException fileLoadEx)
{
String fusionMessage = String.IsNullOrEmpty(fileLoadEx.FusionLog)
? "Turn on fusion logging to diagnose the problem further. " +
"(Check http://blogs.msdn.com/suzcook/archive" +
"/2003/05/29/57120.aspx for more info)"
: "Check fusion log: " + fileLoadEx.FusionLog;
Log.LogError("The C++/CLI code provider could not be loaded. " +
fileLoadEx.Message +
(fileLoadEx.InnerException?.Message ?? "") +
fusionMessage);
provider = null;
}
catch (FileNotFoundException)
{
Log.LogError("The C++/CLI code provider wasn't found. " +
"Make sure you have Visual C++ installed.");
provider = null;
}
outputFile = Path.ChangeExtension(outputFile, ".cpp");
break;
default:
throw new InvalidOperationException("Shouldn't reach here.");
}
return(provider);
}
// Get a code generator for the specified language. language can either be a known abbreviation
// for C#, VB or JScript. Or it can be a fully-qualified (with assembly) name for an ICodeGenerator
// or a CodeDomProvider.
void CreateCodeGenerator(string language, ref ICodeGenerator codeGen, ref string fileExtension)
{
CodeDomProvider codeProvider = null;
if ((string.Compare(language, "CSharp", true) == 0) ||
(string.Compare(language, "C#", true) == 0) ||
(string.Compare(language, "CS", true) == 0))
{
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
}
else if (string.Compare(language, "VB", true) == 0)
{
throw new Exception("VisualBasic not supported in the SSCLI");
}
else if ((string.Compare(language, "js", true) == 0) ||
(string.Compare(language, "jscript", true) == 0))
{
Type t = Type.GetType("Microsoft.JScript.JScriptCodeProvider, " + AssemblyRef.MicrosoftJScript);
codeProvider = (CodeDomProvider)Activator.CreateInstance(t);
}
else
{
//try to reflect a custom code generator
//ignore case when reflecting; language argument must specify the namespace
Type t = Type.GetType(language, false, true);
if (t == null)
{
throw new InvalidOperationException(Res.GetString(Res.ErrLanguage, language));
}
object o = Activator.CreateInstance(t);
if (o is CodeDomProvider)
{
codeProvider = (CodeDomProvider)o;
}
else if (o is ICodeGenerator)
{
codeGen = (ICodeGenerator)o;
}
else
{
throw new InvalidOperationException(Res.GetString(Res.ErrLanguage, language));
}
}
if (codeProvider != null)
{
codeGen = codeProvider.CreateGenerator();
fileExtension = codeProvider.FileExtension;
if (fileExtension == null)
{
fileExtension = string.Empty;
}
else if (fileExtension.Length > 0 && fileExtension[0] != '.')
{
fileExtension = "." + fileExtension;
}
}
else
{
fileExtension = ".src";
}
}
/// <summary>
/// Compiles a given string script
/// </summary>
/// <returns>True if compilation ok</returns>
public bool Compile()
{
// Already compiled ?
if (IsCompiled)
{
return(true);
}
IsCompiled = false;
IsModified = false;
HasErrors = false;
Errors = null;
CompiledAssembly = null;
// Generate the compiler provider
switch (Language)
{
case ScriptLanguage.CSharp:
{
ScriptProvider = new Microsoft.CSharp.CSharpCodeProvider();
if (ScriptProvider == null)
{
Trace.WriteLine("Failed to initialize a new instance of the CSharpCodeProvider class");
return(false);
}
}
break;
case ScriptLanguage.VBNet:
{
ScriptProvider = new Microsoft.VisualBasic.VBCodeProvider();
if (ScriptProvider == null)
{
Trace.WriteLine("Failed to initialize a new instance of the VBCodeProvider class");
return(false);
}
}
break;
default:
{
Trace.WriteLine("Unknown scripting language !!!");
return(false);
}
}
// Compile
CompilerResults results = ScriptProvider.CompileAssemblyFromSource(Params, sourceCode);
if (results.Errors.Count == 0)
{
CompiledAssembly = results.CompiledAssembly;
IsCompiled = true;
return(true);
}
Errors = results.Errors;
HasErrors = true;
Trace.WriteLine("Compile complete -- " + Errors.Count + " error(s).");
foreach (CompilerError error in Errors)
{
Trace.WriteLine("line " + error.Line + " : " + error.ErrorText);
}
return(IsCompiled);
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
if (_params.Count != 1 || _params[0].Type != null)
{
tw.Write("(");
}
for (int i = 0; i < _params.Count; i++)
{
if (i > 0)
{
tw.Write(", ");
}
if (_params[i].Type != null)
{
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(_params[i].Type), tw, opts);
tw.Write(" ");
}
tw.Write(_params[i].Name);
}
if (_params.Count != 1 || _params[0].Type != null)
{
tw.Write(")");
}
tw.WriteLine(" => ");
tw.WriteLine("{");
tw.Indent++;
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.Write("}");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
throw new NotImplementedException();
//tw.Write("Function(");
//for (int i = 0; i < _params.Count; i++)
//{
// if (i > 0)
// tw.Write(", ");
// tw.Write(_params[i].Name);
// if (_params[i].Type != null)
// {
// tw.Write(" As ");
// provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(_params[i].Type), tw, opts);
// }
//}
//tw.Write(") ");
//provider.GenerateCodeFromExpression(Statements, tw, opts);
//Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
private string GenerateDataSet(DataSet pDs, string pNamespace, string pTableName, string pSchemaName, string pDatabaseName)
{
Microsoft.CSharp.CSharpCodeProvider cp = new Microsoft.CSharp.CSharpCodeProvider();
CodeNamespace cns = new CodeNamespace(pNamespace);
//get autoincrement column if available
string sAutoIncColName = IdentityColumnName;
//set autoincrement seed and step to -1
if (!String.IsNullOrEmpty(sAutoIncColName) && checkBoxPkIsIdentity.Checked)
{
pDs.Tables[0].Columns[sAutoIncColName].AutoIncrement = true;
pDs.Tables[0].Columns[sAutoIncColName].AutoIncrementStep = -1;
pDs.Tables[0].Columns[sAutoIncColName].AutoIncrementSeed = -1;
}
using (StringWriter schemaWr = new StringWriter())
{
pDs.WriteXmlSchema(schemaWr);
System.Data.Design.TypedDataSetGenerator.Generate(schemaWr.ToString(), new CodeCompileUnit(), cns, cp, System.Data.Design.TypedDataSetGenerator.GenerateOption.LinqOverTypedDatasets);
}
string name = cns.Types[0].Name;
//Change DataSet type name
name = pDs.Tables[0].TableName + textBoxDataSetSuffix.Text;
cns.Types[0].Name = name;
CodeMemberMethod oClone = (CodeMemberMethod)FindMember("Clone", cns.Types[0].Members);
CodeCastExpression exp =
new CodeCastExpression(name,
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeBaseReferenceExpression(), "Clone"),
new CodePrimitiveExpression[] { }));
CodeVariableDeclarationStatement cvds = new CodeVariableDeclarationStatement(name, "cln", exp);
oClone.Statements[0] = cvds;
foreach (CodeAttributeDeclaration cad in cns.Types[0].CustomAttributes)
{
if (cad.Name == "System.ComponentModel.ToolboxItem")
{
((CodePrimitiveExpression)cad.Arguments[0].Value).Value = false;
break;
}
}
// Find DataTable.
// Add Attributes.
CodeTypeDeclaration oDataTable = (CodeTypeDeclaration)FindMember(pTableName + "DataTable", cns.Types[0].Members);
AddTableSchemaMember(oDataTable, pSchemaName);
AddDatabaseMember(oDataTable, pDatabaseName);
AddFullTableNameMember(oDataTable, TableFullName);
AddFullTableNameAttribute(oDataTable, TableFullName);
// Add HasAutoIcrementColumn and AutoIncrementColumnName properties...
AddAutoIncrementColNameMember(oDataTable, sAutoIncColName);
if (sAutoIncColName == string.Empty)
{
AddHasAutoIncrementMember(oDataTable, false);
}
else
{
AddHasAutoIncrementMember(oDataTable, true);
}
AddAutoIncrementColumnNameAttribute(oDataTable, sAutoIncColName);
//Change dataset name in Initvars method.
CodeMemberMethod oInitClass = (CodeMemberMethod)FindMember("InitClass", cns.Types[0].Members);
((CodeAssignStatement)oInitClass.Statements[0]).Right = new CodePrimitiveExpression(name);
//Change dataset type in GetTypedDataSetSchema method.
CodeMemberMethod oGetTypedDataSetSchema = (CodeMemberMethod)FindMember("GetTypedDataSetSchema", cns.Types[0].Members);
CodeObjectCreateExpression exp2 = new CodeObjectCreateExpression(name, new CodePrimitiveExpression[] { });
CodeVariableDeclarationStatement cvds2 = new CodeVariableDeclarationStatement(name, "ds", exp2);
oGetTypedDataSetSchema.Statements[0] = cvds2;
//Change type in GetTypedTableSchema of table.
oGetTypedDataSetSchema = (CodeMemberMethod)FindMember("GetTypedTableSchema", ((CodeTypeDeclaration)FindMember(pDs.Tables[0].TableName + "DataTable", cns.Types[0].Members)).Members);
exp2 = new CodeObjectCreateExpression(name, new CodePrimitiveExpression[] { });
cvds2 = new CodeVariableDeclarationStatement(name, "ds", exp2);
oGetTypedDataSetSchema.Statements[2] = cvds2;
StringBuilder sb = new StringBuilder();
TextWriter tw = new StringWriter(sb);
CodeGeneratorOptions cgo = new CodeGeneratorOptions();
cp.GenerateCodeFromNamespace(cns, tw, cgo);
return(sb.ToString());
}
public void CompileAndRun(string language, string code, string[] references, Dictionary <string, object> variablevalues, CodeActivityContext context)
{
CompilerResults compile = null;
if (!cache.ContainsKey(code))
{
CompilerParameters CompilerParams = new CompilerParameters();
string outputDirectory = System.IO.Directory.GetCurrentDirectory();
//CompilerParams.GenerateInMemory = true;
CompilerParams.TreatWarningsAsErrors = false;
CompilerParams.GenerateExecutable = false;
CompilerParams.CompilerOptions = "/optimize /d:DEBUG";
CompilerParams.IncludeDebugInformation = true;
CompilerParams.GenerateInMemory = false;
CompilerParams.OutputAssembly = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString().Replace("-", "") + ".dll");
CompilerParams.ReferencedAssemblies.AddRange(references);
// CompilerParams.ReferencedAssemblies.Add(@"C:\code\openrpa\bin\Microsoft.Office.Tools.Excel.dll");
CodeDomProvider provider = null;
if (language == "VB")
{
provider = new Microsoft.VisualBasic.VBCodeProvider();
}
else
{
provider = new Microsoft.CSharp.CSharpCodeProvider();
}
compile = provider.CompileAssemblyFromSource(CompilerParams, new[] { code });
if (compile.Errors.HasErrors)
{
string text = "";
foreach (CompilerError ce in compile.Errors)
{
if (!ce.IsWarning)
{
text += ce.ToString();
Log.Error(ce.ToString());
}
}
throw new Exception(text);
}
cache.Add(code, compile);
}
else
{
compile = cache[code];
}
//ExpoloreAssembly(compile.CompiledAssembly);
Module module = compile.CompiledAssembly.GetModules()[0];
Type mt = null;
MethodInfo methInfo = null;
if (module != null)
{
mt = module.GetType("Expression");
}
if (module != null && mt == null)
{
mt = module.GetType("SomeNamespace.Expression");
}
if (mt != null)
{
methInfo = mt.GetMethod("ExpressionValue");
foreach (var v in variablevalues)
{
var p = mt.GetField(v.Key);
if (p != null)
{
p.SetValue(mt, v.Value);
}
}
}
if (methInfo != null)
{
ExceptionDispatchInfo exceptionDispatchInfo = null;
try
{
methInfo.Invoke(null, new object[] { });
}
catch (Exception ex)
{
exceptionDispatchInfo = ExceptionDispatchInfo.Capture(ex);
}
if (exceptionDispatchInfo != null)
{
exceptionDispatchInfo.Throw();
}
var vars = context.DataContext.GetProperties();
foreach (dynamic v in vars)
{
var p = mt.GetField(v.DisplayName);
if (p == null)
{
continue;
}
var value = p.GetValue(mt);
v.SetValue(context.DataContext, value);
}
}
}
public Type GetProxyTypeForStateInterface()
{
if (_proxyTypeCache == null)
{
List <Type> typesRequired = new List <Type>();
typesRequired.Add(_interfaceType);
// Create a code compile unit and a namespace
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace("Esmf.StateTypes");
// Add some imports statements to the namespace
ns.Imports.Add(new CodeNamespaceImport("System"));
// ns.Imports.Add(new CodeNamespaceImport("System.Drawing"));
// Add the namespace to the code compile unit
ccu.Namespaces.Add(ns);
string implementationTypeName = _interfaceName.StartsWith("I", StringComparison.OrdinalIgnoreCase) ? _interfaceName.Substring(1) : String.Format("{0}Implementation", _interfaceName);
CodeTypeDeclaration ctd = new CodeTypeDeclaration(implementationTypeName);
ctd.BaseTypes.Add(_interfaceType);
ctd.BaseTypes.Add(typeof(IStateObjectConnections));
ns.Types.Add(ctd);
foreach (StateFieldStructure field in _fields)
{
if (!typesRequired.Contains(field.Type))
{
typesRequired.Add(field.Type);
}
if (field.Dimensions.Count == 0)
{
CodeTypeReference tt = new CodeTypeReference(field.Type);
CodeTypeReference ttGetter = new CodeTypeReference(typeof(NonDimensionalFieldGetter <>));
ttGetter.TypeArguments.Add(tt);
string _fieldGetter = String.Format("_{0}FieldGetter", field.Name);
CodeMemberField newGetterField = new CodeMemberField(ttGetter, _fieldGetter);
ctd.Members.Add(newGetterField);
CodeMemberProperty p = new CodeMemberProperty();
p.Name = String.Format("{0}.{1}", _interfaceType, field.Name);
p.Type = tt;
p.Attributes -= MemberAttributes.Private;
CodeStatementCollection getStatements = p.GetStatements;
getStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
_fieldGetter),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
new CodeStatement[] { new CodeMethodReturnStatement(new CodeDelegateInvokeExpression(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), _fieldGetter))) },
new CodeStatement[] { new CodeThrowExceptionStatement(new CodeObjectCreateExpression(new CodeTypeReference(typeof(InvalidOperationException)))) }));
if (field.CanWrite)
{
CodeTypeReference ttSetter = new CodeTypeReference(typeof(NonDimensionalFieldSetter <>));
ttSetter.TypeArguments.Add(tt);
string _fieldSetter = String.Format("_{0}FieldSetter", field.Name);
CodeMemberField newSetterField = new CodeMemberField(ttSetter, _fieldSetter);
ctd.Members.Add(newSetterField);
CodeStatementCollection setStatements = p.SetStatements;
setStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
_fieldSetter),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
new CodeStatement[] { new CodeExpressionStatement(new CodeDelegateInvokeExpression(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), _fieldSetter), new CodeExpression[] { new CodePropertySetValueReferenceExpression() })) },
new CodeStatement[] { new CodeThrowExceptionStatement(new CodeObjectCreateExpression(new CodeTypeReference(typeof(InvalidOperationException)))) }));
}
ctd.Members.Add(p);
}
else if (field.Dimensions.Count > 0)
{
CodeTypeReference tt;
if (field.CanWrite)
{
if (field.Dimensions.Count == 1)
{
tt = new CodeTypeReference(typeof(Esmf.IVariable1Dimensional <,>));
}
else if (field.Dimensions.Count == 2)
{
tt = new CodeTypeReference(typeof(Esmf.IVariable2Dimensional <, ,>));
}
else
{
throw new InvalidOperationException("Can't have parameters with more than 2 dimensions");
}
}
else
{
if (field.Dimensions.Count == 1)
{
tt = new CodeTypeReference(typeof(Esmf.IParameter1Dimensional <,>));
}
else if (field.Dimensions.Count == 2)
{
tt = new CodeTypeReference(typeof(Esmf.IParameter2Dimensional <, ,>));
}
else
{
throw new InvalidOperationException("Can't have fields with more than 2 dimensions");
}
}
foreach (StateFieldDimensionStructure sfds in field.Dimensions)
{
tt.TypeArguments.Add(sfds.Type);
if (!typesRequired.Contains(sfds.Type))
{
typesRequired.Add(sfds.Type);
}
}
tt.TypeArguments.Add(field.Type);
string fieldName = String.Format("_{0}Field", field.Name);
CodeMemberField newField = new CodeMemberField(tt, fieldName);
ctd.Members.Add(newField);
CodeMemberProperty p = new CodeMemberProperty();
p.Name = String.Format("{0}.{1}", _interfaceType, field.Name);
p.Type = tt;
p.Attributes -= MemberAttributes.Private;
CodeStatementCollection statements = p.GetStatements;
statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
fieldName),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
new CodeStatement[] { new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName)) },
new CodeStatement[] { new CodeThrowExceptionStatement(new CodeObjectCreateExpression(new CodeTypeReference(typeof(InvalidOperationException)))) }));
ctd.Members.Add(p);
}
}
GenerateCodeForIStateObjectConnection(ctd);
CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add(typeof(IParameter1Dimensional <,>).Module.FullyQualifiedName);
List <string> modules = new List <string>();
foreach (Type t in typesRequired)
{
if (!modules.Contains(t.Module.FullyQualifiedName))
{
modules.Add(t.Module.FullyQualifiedName);
}
}
foreach (string s in modules)
{
cp.ReferencedAssemblies.Add(s);
}
cp.GenerateInMemory = true;
string assemblyDirectory = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "Temp");
if (!Directory.Exists(assemblyDirectory))
{
Directory.CreateDirectory(assemblyDirectory);
}
cp.OutputAssembly = Path.Combine(assemblyDirectory, string.Format("AutoGenerated{0}.dll", Guid.NewGuid()));
CompilerResults results = provider.CompileAssemblyFromDom(cp, ccu);
if (results.Errors.HasErrors)
{
foreach (CompilerError err in results.Errors)
{
Console.WriteLine();
Console.WriteLine(err);
}
}
//CodeDomProvider provider2 = new Microsoft.CSharp.CSharpCodeProvider();
//using (System.IO.TextWriter output = System.IO.File.CreateText(@"C:\Users\davidanthoff\Documents\Visual Studio 2005\Projects\test.cs"))
//{
// provider2.GenerateCodeFromCompileUnit(ccu, output, new CodeGeneratorOptions());
//}
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
_proxyTypeCache = results.CompiledAssembly.GetType("Esmf.StateTypes." + implementationTypeName);
AppDomain.CurrentDomain.AssemblyResolve -= new ResolveEventHandler(CurrentDomain_AssemblyResolve);
return(_proxyTypeCache);
}
else
{
return(_proxyTypeCache);
}
}
static void Main(string[] args)
{
var stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
string codeToCompile = @"
public class SomeClass
{
public int Add42 (int parameter)
{
return parameter += 42;
}
}";
Dictionary <string, string> providerOptions = new Dictionary <string, string>
{
{ "CompilerVersion", "v4.0" }
};
var csCodeProvider = new Microsoft.CSharp.CSharpCodeProvider(providerOptions);
var compilerParameters = new System.CodeDom.Compiler.CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true
};
System.CodeDom.Compiler.CompilerResults compilerResults = csCodeProvider.CompileAssemblyFromSource(compilerParameters, codeToCompile);
stopWatch.Stop();
Console.WriteLine(string.Format("compile time: {0}", stopWatch.Elapsed));
stopWatch.Restart();
object typeInstance = compilerResults.CompiledAssembly.CreateInstance("SomeClass");
System.Reflection.MethodInfo mi = typeInstance.GetType().GetMethod("Add42");
int i, methodOutput;
var parameterList = new object[1];
for (i = 0; i < 1000000; i++)
{
parameterList[0] = i;
methodOutput = (int)mi.Invoke(typeInstance, parameterList);
}
stopWatch.Stop();
Console.WriteLine(string.Format("time to call function {0} times: {1}", i.ToString("##,#"), stopWatch.Elapsed));
stopWatch.Restart();
for (i = 0; i < 1000000; i++)
{
methodOutput = Add43(i);
}
stopWatch.Stop();
Console.WriteLine(string.Format("time to call function {0} times: {1}", i.ToString("##,#"), stopWatch.Elapsed));
Console.ReadLine();
}
public CSharpScript(string code)
{
using (var provider =
new Microsoft.CSharp.CSharpCodeProvider())
{
var builder = new StringBuilder();
builder
.AppendLine("using System;")
.AppendLine("using System.Collections.Generic;")
.AppendLine("using System.Linq;")
.AppendLine("using System.Reflection;")
.AppendLine("using System.Text;")
.AppendLine("public class CompiledScript")
.AppendLine("{")
.AppendLine("private Dictionary<String, dynamic> dict = new Dictionary<string,dynamic>();")
.AppendLine("public dynamic this[string name]")
.AppendLine("{")
.AppendLine("get")
.AppendLine("{")
.AppendLine("return dict[name];")
.AppendLine("}")
.AppendLine("set")
.AppendLine("{")
.AppendLine("if (dict.ContainsKey(name))")
.AppendLine("dict[name] = value;")
.AppendLine("else")
.AppendLine("dict.Add(name, value);")
.AppendLine("}")
.AppendLine("}")
.AppendLine("public dynamic Execute()")
.AppendLine("{")
.Append(code)
.Append("return null;")
.AppendLine("}")
.AppendLine("}");
var parameters = new System.CodeDom.Compiler.CompilerParameters()
{
GenerateInMemory = true,
CompilerOptions = "/optimize",
};
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add("System.Data.dll");
parameters.ReferencedAssemblies.Add("System.Data.DataSetExtensions.dll");
parameters.ReferencedAssemblies.Add("System.Drawing.dll");
parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
parameters.ReferencedAssemblies.Add("System.Xml.dll");
parameters.ReferencedAssemblies.Add("System.Xml.Linq.dll");
parameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
var res = provider.CompileAssemblyFromSource(parameters, builder.ToString());
if (res.Errors.HasErrors)
{
var errorMessage = "";
foreach (var error in res.Errors)
{
errorMessage += error + "\r\n";
}
throw new ArgumentException(errorMessage, "code");
}
var type = res.CompiledAssembly.GetType("CompiledScript");
CompiledCode = Activator.CreateInstance(type);
}
}
/// <summary>
/// Generates an Assembly from a list of script filenames
/// </summary>
/// <param name="filenames">The filenames of the scripts</param>
/// <param name="references">Assembly references for the script</param>
/// <returns>The generated assembly</returns>
public Assembly CreateAssembly(IList filenames, IList references)
{
string fileType = null;
foreach (string filename in filenames)
{
string extension = Path.GetExtension(filename);
if (fileType == null)
{
fileType = extension;
}
else if (fileType != extension)
{
throw new ArgumentException("All files in the file list must be of the same type.");
}
}
// ensure that compilerErrors is null
compilerErrors = null;
// Select the correct CodeDomProvider based on script file extension
CodeDomProvider codeProvider = null;
switch (fileType)
{
case ".cs":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".vb":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
default:
throw new InvalidOperationException("Script files must have a .cs, .vb, or .js extension, for C#, Visual Basic.NET, or JScript respectively.");
}
// Set compiler parameters
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.CompilerOptions = "/target:library /optimize";
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
compilerParams.IncludeDebugInformation = false;
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
// Add custom references
foreach (string reference in references)
{
if (!compilerParams.ReferencedAssemblies.Contains(reference))
{
compilerParams.ReferencedAssemblies.Add(reference);
}
}
// Do the compilation
CompilerResults results = codeProvider.CompileAssemblyFromFile(
compilerParams, (string[])ArrayList.Adapter(filenames).ToArray(typeof(string)));
if (results.Errors.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError item in results.Errors)
{
sb.AppendFormat("{0} line:{1} {2}\r\n", item.FileName, item.Line, item.ErrorText);
}
compilerErrors = results.Errors;
throw new Exception(
"Compiler error(s)\r\n" + sb.ToString());
}
Assembly createdAssembly = results.CompiledAssembly;
return(createdAssembly);
}
private static Type BuildTypeCodeDom(Type baseInterface, string className, string fieldsPrefix, params Type[] types)
{
var compileUnit = new CodeCompileUnit();
CodeNamespace globalNamespace = new CodeNamespace();
globalNamespace.Imports.Add(new CodeNamespaceImport("System"));
globalNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
globalNamespace.Imports.Add(new CodeNamespaceImport("System.Linq"));
globalNamespace.Imports.Add(new CodeNamespaceImport("System.Text"));
var classNamespace = new CodeNamespace("STS.General.Data");
var generatedClass = new CodeTypeDeclaration(className);
generatedClass.IsClass = true;
generatedClass.Attributes = MemberAttributes.Public;
for (int i = 0; i < types.Length; i++)
{
generatedClass.TypeParameters.Add(new CodeTypeParameter("T" + fieldsPrefix + i));
}
if (baseInterface != null)
{
generatedClass.BaseTypes.Add(baseInterface);
}
var serializableAttribute = new CodeTypeReference(typeof(System.SerializableAttribute));
generatedClass.CustomAttributes.Add(new CodeAttributeDeclaration(serializableAttribute));
classNamespace.Types.Add(generatedClass);
compileUnit.Namespaces.Add(globalNamespace);
compileUnit.Namespaces.Add(classNamespace);
CodeMemberField[] fields = new CodeMemberField[types.Length];
for (int i = 0; i < fields.Length; i++)
{
fields[i] = new CodeMemberField("T" + fieldsPrefix + i, fieldsPrefix + i);
fields[i].Attributes = MemberAttributes.Public;
generatedClass.Members.Add(fields[i]);
}
CodeConstructor defaultConstructor = new CodeConstructor();
defaultConstructor.Attributes = MemberAttributes.Public;
generatedClass.Members.Add(defaultConstructor);
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public;
for (int i = 0; i < types.Length; i++)
{
CodeTypeReference type = new CodeTypeReference("T" + fieldsPrefix + i);
constructor.Parameters.Add(new CodeParameterDeclarationExpression(type, fieldsPrefix.ToLower() + i));
}
for (int i = 0; i < types.Length; i++)
{
CodeFieldReferenceExpression left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldsPrefix + i);
constructor.Statements.Add(new CodeAssignStatement(left, new CodeArgumentReferenceExpression(fieldsPrefix.ToLower() + i)));
}
generatedClass.Members.Add(constructor);
string stsdbAssemblyName = Assembly.GetExecutingAssembly().Location;
string[] assemblies = { "System.dll", "mscorlib.dll", stsdbAssemblyName };
CompilerParameters parameters = new CompilerParameters(assemblies);
CodeDomProvider runTimeProvider = new Microsoft.CSharp.CSharpCodeProvider();
parameters = new CompilerParameters(assemblies);
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = true;
parameters.IncludeDebugInformation = true;
parameters.CompilerOptions = "/optimize";
CompilerResults compilerResults = runTimeProvider.CompileAssemblyFromDom(parameters, compileUnit);
var generatedType = compilerResults.CompiledAssembly.GetTypes()[0];
return(generatedType.MakeGenericType(types));
}
public void HiddenAssemblyTest()
{
const string code = @"
namespace Foo
{
public class HiddenAssemblyLogger
{
public void LogDebug(NLog.Logger logger)
{
logger.Debug(""msg"");
}
}
}
";
var provider = new Microsoft.CSharp.CSharpCodeProvider();
var parameters = new System.CodeDom.Compiler.CompilerParameters();
// reference the NLog dll
parameters.ReferencedAssemblies.Add("NLog.dll");
// the assembly should be generated in memory
parameters.GenerateInMemory = true;
// generate a dll instead of an executable
parameters.GenerateExecutable = false;
// compile code and generate assembly
System.CodeDom.Compiler.CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
Assert.False(results.Errors.HasErrors, "Compiler errors: " + string.Join(";", results.Errors));
// create nlog configuration
LogManager.Configuration = CreateConfigurationFromString(@"
<nlog>
<targets><target name='debug' type='Debug' layout='${callsite} ${message}' /></targets>
<rules>
<logger name='*' minlevel='Debug' writeTo='debug' />
</rules>
</nlog>");
// create logger
Logger logger = LogManager.GetLogger("A");
// load HiddenAssemblyLogger type
Assembly compiledAssembly = results.CompiledAssembly;
Type hiddenAssemblyLoggerType = compiledAssembly.GetType("Foo.HiddenAssemblyLogger");
Assert.NotNull(hiddenAssemblyLoggerType);
// load methodinfo
MethodInfo logDebugMethod = hiddenAssemblyLoggerType.GetMethod("LogDebug");
Assert.NotNull(logDebugMethod);
// instantiate the HiddenAssemblyLogger from previously generated assembly
object instance = Activator.CreateInstance(hiddenAssemblyLoggerType);
// Add the previously generated assembly to the "blacklist"
LogManager.AddHiddenAssembly(compiledAssembly);
// call the log method
logDebugMethod.Invoke(instance, new object[] { logger });
MethodBase currentMethod = MethodBase.GetCurrentMethod();
AssertDebugLastMessage("debug", currentMethod.DeclaringType.FullName + "." + currentMethod.Name + " msg");
}
private static Assembly GenerateTestAssembly()
{
const string code = @"
using System;
using System.Reflection;
[assembly: AssemblyVersion(""" + AssemblyVersionTest + @""")]
[assembly: AssemblyFileVersion(""" + AssemblyFileVersionTest + @""")]
[assembly: AssemblyInformationalVersion(""" + AssemblyInformationalVersionTest + @""")]
namespace LogTester
{
public class LoggerTest
{
public void TestLog(NLog.Logger logger, Assembly assembly)
{
if (System.Reflection.Assembly.GetEntryAssembly() == null)
{
// In some unit testing scenarios we cannot find the entry assembly
// So we attempt to force this to be set, which can also still fail
// This is not expected to be necessary in Visual Studio
// See https://github.com/Microsoft/vstest/issues/649
try
{
SetEntryAssembly(assembly);
}
catch (InvalidOperationException ioex)
{
logger.Debug(ioex, ""Skip: No entry assembly"");
return;
}
}
logger.Debug(""Pass: Test fully executed"");
}
private static void SetEntryAssembly(Assembly assembly)
{
var manager = new AppDomainManager();
var domain = AppDomain.CurrentDomain;
if (domain == null)
throw new InvalidOperationException(""Current app domain is null"");
var entryAssemblyField = manager.GetType().GetField(""m_entryAssembly"", BindingFlags.Instance | BindingFlags.NonPublic);
if (entryAssemblyField == null)
throw new InvalidOperationException(""Unable to find field m_entryAssembly"");
entryAssemblyField.SetValue(manager, assembly);
var domainManagerField = domain.GetType().GetField(""_domainManager"", BindingFlags.Instance | BindingFlags.NonPublic);
if (domainManagerField == null)
throw new InvalidOperationException(""Unable to find field _domainManager"");
domainManagerField.SetValue(domain, manager);
}
}
}";
var provider = new Microsoft.CSharp.CSharpCodeProvider();
var parameters = new System.CodeDom.Compiler.CompilerParameters
{
GenerateInMemory = true,
GenerateExecutable = false,
ReferencedAssemblies = { "NLog.dll" }
};
System.CodeDom.Compiler.CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
var compiledAssembly = results.CompiledAssembly;
return(compiledAssembly);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
if (textEditor == null)
{
Log.Error("textEditor is null?");
return;
}
this.errors.Text = "";
var language = textEditor.SyntaxHighlighting.Name;
var code = textEditor.Text;
string error = "";
try
{
textEditor.ShowLineNumbers = true;
//if (language == "VB" || language == "C#")
//{
// textEditor.ShowLineNumbers = false;
//}
}
catch (Exception ex)
{
Log.Error("set ShowLineNumbers: " + ex.ToString());
}
var newtitle = "Editor";
Task.Run(() => {
if (language == "VB" || language == "C#")
{
var variables = new Dictionary <string, Type>();
foreach (var variableModel in Variables)
{
var variable = variableModel.GetCurrentValue() as System.Activities.LocationReference;
variables.Add(variable.Name, variable.Type);
}
if (language == "VB")
{
var header = CodeEditor.CodeEditor.GetVBHeaderText(variables, "Expression", textEditor.Namespaces);
int numLines = header.Split('\n').Length;
Log.Information("Header (add to line numbers): " + numLines);
newtitle = "Editor (Add " + numLines + " to line numbers)";
}
else if (language == "C#")
{
var header = CodeEditor.CodeEditor.GetCSharpHeaderText(variables, "Expression", textEditor.Namespaces);
int numLines = header.Split('\n').Length;
Log.Information("Header (add to line numbers): " + numLines);
newtitle = "Editor (Add " + numLines + " to line numbers)";
}
string sourcecode = code;
textEditor.Variables = variables;
if (language == "VB")
{
sourcecode = CodeEditor.CodeEditor.GetVBHeaderText(variables, "Expression", textEditor.Namespaces) + code + CodeEditor.CodeEditor.GetVBFooterText();
}
if (language == "C#")
{
sourcecode = CodeEditor.CodeEditor.GetCSharpHeaderText(variables, "Expression", textEditor.Namespaces) + code + CodeEditor.CodeEditor.GetCSharpFooterText();
}
var references = InvokeCode.GetAssemblyLocations();
var CompilerParams = new System.CodeDom.Compiler.CompilerParameters();
//CompilerParams.GenerateInMemory = true;
CompilerParams.TreatWarningsAsErrors = false;
CompilerParams.GenerateExecutable = false;
CompilerParams.CompilerOptions = "/optimize /d:DEBUG";
CompilerParams.IncludeDebugInformation = true;
CompilerParams.GenerateInMemory = false;
CompilerParams.OutputAssembly = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString().Replace("-", "") + ".dll");
CompilerParams.ReferencedAssemblies.AddRange(references);
// CompilerParams.ReferencedAssemblies.Add(@"C:\code\openrpa\bin\Microsoft.Office.Tools.Excel.dll");
System.CodeDom.Compiler.CodeDomProvider provider = null;
if (language == "VB")
{
provider = new Microsoft.VisualBasic.VBCodeProvider();
}
else
{
provider = new Microsoft.CSharp.CSharpCodeProvider();
}
System.CodeDom.Compiler.CompilerResults compile = provider.CompileAssemblyFromSource(CompilerParams, new[] { sourcecode });
if (compile.Errors.HasErrors)
{
string text = "Compile error: ";
foreach (System.CodeDom.Compiler.CompilerError ce in compile.Errors)
{
text += "rn" + ce.ToString();
}
error = text;
}
}
if (language == "PowerShell")
{
Collection <System.Management.Automation.PSParseError> errors;
System.Management.Automation.PSParser.Tokenize(code, out errors);
if (errors != null && errors.Count > 0)
{
foreach (var _e in errors.Take(5))
{
error += "(" + _e.Token.StartLine + ":" + _e.Token.StartColumn + ") " + _e.Message + Environment.NewLine;
}
}
}
if (language == "AutoHotkey")
{
//if (sharpAHK.ahkGlobal.ahkdll == null) { InvokeCode.New_AHKSession(true); }
//sharpAHK.ahkGlobal.ahkdll.Reset();
//try
//{
// //sharpAHK.ahkGlobal.ahkdll.LoadScript(code);
//}
//catch (Exception ex)
//{
// error = ex.ToString();
//}
}
if (language == "Python")
{
//var engine = IronPython.Hosting.Python.CreateEngine();
//var source = engine.CreateScriptSourceFromString(code, Microsoft.Scripting.SourceCodeKind.Statements);
//var errors = new ErrorListener();
//var command = source.Compile(errors);
//if (command == null)
//{
// foreach (var _e in errors.errors.Take(5))
// {
// error += _e.source.ToString() + "(" + _e.span.Start + "): " + _e.message + Environment.NewLine;
// }
//}
}
GenericTools.RunUI(this, () =>
{
Title = newtitle;
this.errors.Text = error;
this.errors.Visibility = (string.IsNullOrEmpty(this.errors.Text) ? Visibility.Hidden : Visibility.Visible);
});
});
}
CompilePackageAssembly(
bool enforceBamAssemblyVersions = true,
bool enableClean = true)
{
// validate build root
if (null == Graph.Instance.BuildRoot)
{
throw new Exception("Build root has not been specified");
}
var gatherSourceProfile = new TimeProfile(ETimingProfiles.GatherSource);
gatherSourceProfile.StartProfile();
IdentifyAllPackages(enforceBamAssemblyVersions: enforceBamAssemblyVersions);
var cleanFirst = CommandLineProcessor.Evaluate(new Options.CleanFirst());
if (enableClean && cleanFirst && System.IO.Directory.Exists(Graph.Instance.BuildRoot))
{
Log.Info("Deleting build root '{0}'", Graph.Instance.BuildRoot);
try
{
// make sure no files are read-only, which may have happened as part of collation preserving file attributes
var dirInfo = new System.IO.DirectoryInfo(Graph.Instance.BuildRoot);
foreach (var file in dirInfo.EnumerateFiles("*", System.IO.SearchOption.AllDirectories))
{
file.Attributes &= ~System.IO.FileAttributes.ReadOnly;
}
System.IO.Directory.Delete(Graph.Instance.BuildRoot, true);
}
catch (System.IO.IOException ex)
{
Log.Info("Failed to delete build root, because {0}. Continuing", ex.Message);
}
}
BuildModeUtilities.ValidateBuildModePackage();
var definitions = new StringArray();
// gather source files
var sourceCode = new StringArray();
int packageIndex = 0;
foreach (var package in Graph.Instance.Packages)
{
Log.DebugMessage("{0}: '{1}' @ '{2}'", packageIndex, package.Version, (package.PackageRepositories.Count > 0) ? package.PackageRepositories[0] : "Not in a repository");
// to compile with debug information, you must compile the files
// to compile without, we need to file contents to hash the source
if (Graph.Instance.CompileWithDebugSymbols)
{
var scripts = package.GetScriptFiles();
sourceCode.AddRange(scripts);
Log.DebugMessage(scripts.ToString("\n\t"));
}
else
{
foreach (var scriptFile in package.GetScriptFiles())
{
using (var reader = new System.IO.StreamReader(scriptFile))
{
sourceCode.Add(reader.ReadToEnd());
}
Log.DebugMessage("\t'{0}'", scriptFile);
}
}
foreach (var define in package.Definitions)
{
if (!definitions.Contains(define))
{
definitions.Add(define);
}
}
++packageIndex;
}
// add/remove other definitions
definitions.Add(VersionDefineForCompiler);
definitions.Add(HostPlatformDefineForCompiler);
definitions.AddRange(Features.PreprocessorDefines);
definitions.Sort();
gatherSourceProfile.StopProfile();
var assemblyCompileProfile = new TimeProfile(ETimingProfiles.AssemblyCompilation);
assemblyCompileProfile.StartProfile();
// assembly is written to the build root
var cachedAssemblyPathname = System.IO.Path.Combine(Graph.Instance.BuildRoot, ".CachedPackageAssembly");
cachedAssemblyPathname = System.IO.Path.Combine(cachedAssemblyPathname, Graph.Instance.MasterPackage.Name) + ".dll";
var hashPathName = System.IO.Path.ChangeExtension(cachedAssemblyPathname, "hash");
string thisHashCode = null;
var cacheAssembly = !CommandLineProcessor.Evaluate(new Options.DisableCacheAssembly());
string compileReason = null;
if (Graph.Instance.CompileWithDebugSymbols)
{
compileReason = "debug symbols were enabled";
}
else
{
// can an existing assembly be reused?
thisHashCode = GetPackageHash(sourceCode, definitions, Graph.Instance.MasterPackage.BamAssemblies);
if (cacheAssembly)
{
if (System.IO.File.Exists(hashPathName))
{
using (var reader = new System.IO.StreamReader(hashPathName))
{
var diskHashCode = reader.ReadLine();
if (diskHashCode.Equals(thisHashCode))
{
Log.DebugMessage("Cached assembly used '{0}', with hash {1}", cachedAssemblyPathname, diskHashCode);
Log.Detail("Re-using existing package assembly");
Graph.Instance.ScriptAssemblyPathname = cachedAssemblyPathname;
assemblyCompileProfile.StopProfile();
return;
}
else
{
compileReason = "package source has changed since the last compile";
}
}
}
else
{
compileReason = "no previously compiled package assembly exists";
}
}
else
{
compileReason = "user has disabled package assembly caching";
}
}
// use the compiler in the current runtime version to build the assembly of packages
var clrVersion = System.Environment.Version;
Log.Detail("Compiling package assembly, CLR {0}{1}, because {2}.",
clrVersion.ToString(),
Graph.Instance.ProcessState.TargetFrameworkVersion != null ? (", targetting " + Graph.Instance.ProcessState.TargetFrameworkVersion) : string.Empty,
compileReason);
var providerOptions = new System.Collections.Generic.Dictionary <string, string>();
var compilerVersion = System.String.Format("v{0}.{1}", clrVersion.Major, clrVersion.Minor);
providerOptions.Add("CompilerVersion", compilerVersion);
if (Graph.Instance.ProcessState.RunningMono)
{
Log.DebugMessage("Compiling assembly for Mono");
}
using (var provider = new Microsoft.CSharp.CSharpCodeProvider(providerOptions))
{
var compilerParameters = new System.CodeDom.Compiler.CompilerParameters();
compilerParameters.TreatWarningsAsErrors = true;
compilerParameters.WarningLevel = 4;
compilerParameters.GenerateExecutable = false;
compilerParameters.GenerateInMemory = false;
if (Graph.Instance.CompileWithDebugSymbols)
{
compilerParameters.OutputAssembly = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Graph.Instance.MasterPackage.Name) + ".dll";
}
else
{
compilerParameters.OutputAssembly = cachedAssemblyPathname;
}
var compilerOptions = "/checked+ /unsafe-";
if (Graph.Instance.CompileWithDebugSymbols)
{
compilerParameters.IncludeDebugInformation = true;
compilerOptions += " /optimize-";
}
else
{
compilerOptions += " /optimize+";
}
compilerOptions += " /platform:anycpu";
// define strings
compilerOptions += " /define:" + definitions.ToString(';');
compilerParameters.CompilerOptions = compilerOptions;
if (provider.Supports(System.CodeDom.Compiler.GeneratorSupport.Resources))
{
// Bam assembly
// TODO: Q: why is it only for the master package? Why not all of them, which may have additional dependencies?
foreach (var assembly in Graph.Instance.MasterPackage.BamAssemblies)
{
var assemblyFileName = System.String.Format("{0}.dll", assembly.Name);
var assemblyPathName = System.IO.Path.Combine(Graph.Instance.ProcessState.ExecutableDirectory, assemblyFileName);
compilerParameters.ReferencedAssemblies.Add(assemblyPathName);
}
// DotNet assembly
foreach (var desc in Graph.Instance.MasterPackage.DotNetAssemblies)
{
var assemblyFileName = System.String.Format("{0}.dll", desc.Name);
compilerParameters.ReferencedAssemblies.Add(assemblyFileName);
}
if (Graph.Instance.ProcessState.RunningMono)
{
compilerParameters.ReferencedAssemblies.Add("Mono.Posix.dll");
}
}
else
{
throw new Exception("C# compiler does not support Resources");
}
// this will create the build root directory as necessary
IOWrapper.CreateDirectory(System.IO.Path.GetDirectoryName(compilerParameters.OutputAssembly));
var results = Graph.Instance.CompileWithDebugSymbols ?
provider.CompileAssemblyFromFile(compilerParameters, sourceCode.ToArray()) :
provider.CompileAssemblyFromSource(compilerParameters, sourceCode.ToArray());
if (results.Errors.HasErrors || results.Errors.HasWarnings)
{
var message = new System.Text.StringBuilder();
message.AppendFormat("Failed to compile package '{0}'. There are {1} errors.", Graph.Instance.MasterPackage.FullName, results.Errors.Count);
message.AppendLine();
foreach (System.CodeDom.Compiler.CompilerError error in results.Errors)
{
message.AppendFormat("\t{0}({1}): {2} {3}", error.FileName, error.Line, error.ErrorNumber, error.ErrorText);
message.AppendLine();
}
if (!Graph.Instance.CompileWithDebugSymbols)
{
message.AppendLine();
ICommandLineArgument debugOption = new Options.UseDebugSymbols();
message.AppendFormat("Use the {0}/{1} command line option with bam for more accurate error messages.", debugOption.LongName, debugOption.ShortName);
message.AppendLine();
}
message.AppendLine();
ICommandLineArgument createDebugProjectOption = new Options.CreateDebugProject();
message.AppendFormat("Use the {0}/{1} command line option with bam to create an editable IDE project containing the build scripts.", createDebugProjectOption.LongName, createDebugProjectOption.ShortName);
message.AppendLine();
throw new Exception(message.ToString());
}
if (!Graph.Instance.CompileWithDebugSymbols)
{
if (cacheAssembly)
{
using (var writer = new System.IO.StreamWriter(hashPathName))
{
writer.WriteLine(thisHashCode);
}
}
else
{
// will not throw if the file doesn't exist
System.IO.File.Delete(hashPathName);
}
}
Log.DebugMessage("Written assembly to '{0}'", compilerParameters.OutputAssembly);
Graph.Instance.ScriptAssemblyPathname = compilerParameters.OutputAssembly;
}
assemblyCompileProfile.StopProfile();
}
private void OnMESCall1()
{
try
{
//WEB服务地址
string url = this.textBoxMesAddr.Text;
//客户端代理服务命名空间，可以设置成需要的值。
string ns = string.Format("JCJProxMES");
//获取WSDL
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);//服务的描述信息都可以通过ServiceDescription获取
string classname = sd.Services[0].Name;
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(ns);
//生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
Microsoft.CSharp.CSharpCodeProvider csc = new Microsoft.CSharp.CSharpCodeProvider();
//设定编译参数
System.CodeDom.Compiler.CompilerParameters cplist = new System.CodeDom.Compiler.CompilerParameters();
cplist.GenerateExecutable = false;
cplist.GenerateInMemory = true;
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
System.CodeDom.Compiler.CompilerResults cr = csc.CompileAssemblyFromDom(cplist, ccu);
if (cr.Errors.HasErrors == true)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例
System.Reflection.Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(ns + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
//实例化方法
System.Reflection.MethodInfo helloWorld = t.GetMethod("DxTestDataUpload");
//设置参数
object device = textBox1.Text.Trim();
object workstation_sn = textBox2.Text.Trim();
object emp_no = textBox3.Text.Trim();
object mo_number = textBox4.Text.Trim();
object container_no = textBox5.Text.Trim();
object product_sn = textBox6.Text.Trim();
object union_list = textBox7.Text.Trim();
object mod_level = textBox8.Text.Trim();
object test_re = textBox9.Text.Trim();
object test_val = textBox10.Text.Trim();
object test_time = textBox11.Text.Trim();
object mark = textBox12.Text.Trim();
object m_flag = int.Parse(textBox13.Text.Trim());
object[] addParams = new object[] { m_flag, device, workstation_sn, emp_no, mo_number, container_no, product_sn, union_list, mod_level, test_re, test_val, test_time, mark };
//参数赋值并调用方法
object helloWorldReturn = helloWorld.Invoke(obj, addParams);
Console.WriteLine(helloWorldReturn.ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
/// <summary>
/// 加载运行脚本
/// </summary>
/// <param name="strCode"></param>
private void StartScript(string strCode)
{
//创建应用域
var appSetup = new AppDomainSetup();
appSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
var appdomain = AppDomain.CreateDomain("ClientSpace", null, appSetup);
//创建编译器
var provider = new Microsoft.CSharp.CSharpCodeProvider();
//配置编译参数
var compilerParameters = new System.CodeDom.Compiler.CompilerParameters();
compilerParameters.ReferencedAssemblies.Add("System.dll");
compilerParameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
compilerParameters.ReferencedAssemblies.Add("System.Drawing.dll");
compilerParameters.GenerateInMemory = false;
compilerParameters.OutputAssembly = "client.dll";
//读取代码编译
var usercore = Spoonson.Apps.SuperTerm.Properties.Resources.usercore;
var compilerResults = provider.CompileAssemblyFromSource(compilerParameters, usercore, strCode);
if (compilerResults.Errors.HasErrors)
{
string strErrorMessage = "";
for (int i = 0; i < compilerResults.Errors.Count; i++)
{
strErrorMessage += "\r\nline: " + compilerResults.Errors[i].Line.ToString() + " " + compilerResults.Errors[i].ErrorText + Environment.NewLine;
}
Logger.Error("编译失败 " + compilerResults.Errors.Count);
Logger.Error(strErrorMessage);
return;
}
compilerResults = null;
//创建用户线程
StopScript();
ScriptProcess = new System.Threading.Thread(new System.Threading.ThreadStart(delegate()
{
try
{
var bfi = BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance;
var remoteLoader = appdomain.CreateInstanceFrom("RemoteLoader.dll", "Spoonson.Common.RemoteLoader", false, bfi, null, null, null, null).Unwrap() as Spoonson.Common.RemoteLoader;
var plugin = remoteLoader.Create("client.dll", "UserSpace.UserCode", new object[] { Controller });
plugin = null;
}
catch (System.Threading.ThreadAbortException e)
{
//处理线程终止过程
Logger.Error(e.ToString());
Logger.Warn("线程被用户终止");
}
finally
{
AppDomain.Unload(appdomain);
appdomain = null;
System.IO.File.Delete("client.dll");
}
}));
ScriptProcess.Start();
}
public static void Generate(
string output_path,
List <CodeTypeDelegate> delegates,
List <CodeMemberMethod> functions,
List <CodeMemberField> constants
)
{
string filename = Path.Combine(output_path, Properties.Bind.Default.OutputClass + ".cs");
if (!Directory.Exists(Properties.Bind.Default.OutputPath))
{
Directory.CreateDirectory(Properties.Bind.Default.OutputPath);
}
CodeNamespace ns = new CodeNamespace(Properties.Bind.Default.OutputNamespace);
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices"));
ns.Imports.Add(new CodeNamespaceImport("System.Text"));
foreach (string key in SpecTranslator.CSTypes.Keys)
{
ns.Imports.Add(new CodeNamespaceImport(key + " = System." + SpecTranslator.CSTypes[key].BaseType));
}
constants.Sort(new CodeTypeNameComparer <CodeMemberField>());
functions.Sort(new CodeTypeNameComparer <CodeMemberMethod>());
delegates.Sort(new CodeTypeNameComparer <CodeTypeDelegate>());
ns.Types.Add(GenerateGlClass(functions, constants));
ns.Types.Add(GenerateDelegatesClass(delegates));
ns.Types.Add(GenerateImportsClass(delegates));
CodeCompileUnit cu = new CodeCompileUnit();
/*
* cu.AssemblyCustomAttributes.Add(
* new CodeAttributeDeclaration(
* "System.CLSCompliant",
* new CodeAttributeArgument[] {
* new CodeAttributeArgument(
* new CodeSnippetExpression("true")
* )
* }
* )
* );
*/
cu.StartDirectives.Add(new CodeDirective());
cu.Namespaces.Add(ns);
using (StreamWriter sw = new StreamWriter(filename, false))
{
Console.WriteLine("Writing Tao.OpenGl.Gl class to {0}", filename);
Microsoft.CSharp.CSharpCodeProvider cs = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
options.BracingStyle = "C";
options.BlankLinesBetweenMembers = false;
options.VerbatimOrder = true;
cs.GenerateCodeFromCompileUnit(cu, sw, options);
sw.Flush();
}
}
public FactoryIF getFactory(int level)
{
if (level.Equals(1))
{
return(new LevelOneFactory());
}
else if (level.Equals(2))
{
return(new LevelTwoFactory());
}
else if (level.Equals(3))
{
return(new LevelThreeFactory());
}
else if (level.Equals(4))
{
return(new LevelFourFactory());
}
else if (level.Equals(5))
{
return(new LevelFiveFactory());
}
else
{
try
{
LevelPlayer player = LevelPlayer.getInstance();
string dlevel = player.getFile();
String code;
String line;
//Pass the file path and file name to the StreamReader constructor
StreamReader sr = new StreamReader(dlevel);
//Read the first line of text
line = sr.ReadLine();
code = line;
//Continue to read until you reach end of file
while (line != null)
{
//Read the next line
line = sr.ReadLine();
code = code + "\n" + line;
}
//close the file
sr.Close();
Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider();
ICodeCompiler compiler = provider.CreateCompiler();
System.CodeDom.Compiler.CompilerParameters compilerparams = new CompilerParameters();
compilerparams.GenerateExecutable = false;
compilerparams.GenerateInMemory = true;
compilerparams.ReferencedAssemblies.Add("System.dll");
compilerparams.ReferencedAssemblies.Add("System.Core.dll");
compilerparams.ReferencedAssemblies.Add(typeof(Program).Assembly.Location);
CompilerResults results = compiler.CompileAssemblyFromSource(compilerparams, code);
Assembly compiled = null;
if (results.Errors.HasErrors)
{
StringBuilder errors = new StringBuilder("Compiler Errors :\r\n");
foreach (CompilerError error in results.Errors)
{
errors.AppendFormat("Line {0},{1}\t: {2}\n",
error.Line, error.Column, error.ErrorText);
}
throw new Exception(errors.ToString());
}
else
{
compiled = results.CompiledAssembly;
}
int last = dlevel.LastIndexOf('\\');
last += 1;
Type type = compiled.GetType("WordBlaster.AbstractFactory." + dlevel.Substring(last, (dlevel.Count() - last - 4)));
FactoryIF dynlvl = (FactoryIF)Activator.CreateInstance(type);
return(dynlvl);
}
catch (Exception e)
{
Console.WriteLine("Could not load file, starting normally...");
return(new LevelOneFactory()); //if we could not load it in just start normally
}
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("while (");
if (TestExpression != null)
{
provider.GenerateCodeFromExpression(TestExpression, tw, opts);
}
tw.WriteLine(")");
tw.WriteLine("{");
tw.Indent++;
if (Statements != null)
{
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
}
tw.Indent--;
tw.WriteLine("}");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Do While ");
if (TestExpression != null)
{
provider.GenerateCodeFromExpression(TestExpression, tw, opts);
}
tw.WriteLine();
tw.Indent++;
if (Statements != null)
{
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
}
tw.Indent--;
tw.WriteLine("Loop");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
private void CreateResourceFromImage(bool entire)
{
Bitmap bitmap = null;
if (entire)
{
bitmap = (Bitmap)(zoomPanControl.ZoomPanImage.Clone());
}
else if (HasImageSelection && !entire)
{
bitmap = ((Bitmap)zoomPanControl.ZoomPanImage).Clone(partBox, ((Bitmap)zoomPanControl.ZoomPanImage).PixelFormat);
}
if (bitmap != null)
{
if (Statics.DTE.Solution.IsOpen)
{
foreach (EnvDTE.Project proj in Statics.DTE.Solution.Projects)
{
if (proj.Name.Contains("Test"))
{
try
{
string resFile, resDesignFile, resNameSpace;
System.CodeDom.Compiler.CodeDomProvider provider;
if (proj.FileName.EndsWith("vbproj"))
{
resFile = Path.GetDirectoryName(proj.FileName) + @"\My Project\Resources.resx";
resDesignFile = Path.GetDirectoryName(proj.FileName) + @"\My Project\Resources.Designer.vb";
vbNS = resNameSpace = proj.Properties.Item("RootNamespace").Value.ToString();
provider = new Microsoft.VisualBasic.VBCodeProvider();
}
else
{
resFile = Path.GetDirectoryName(proj.FileName) + @"\Properties\Resources.resx";
resDesignFile = Path.GetDirectoryName(proj.FileName) + @"\Properties\Resources.Designer.cs";
resNameSpace = proj.Properties.Item("DefaultNamespace").Value + ".Properties";
provider = new Microsoft.CSharp.CSharpCodeProvider();
}
ImageInputForm inputForm = new ImageInputForm();
inputForm.ShowDialog();
System.Resources.ResXResourceReader reader = new System.Resources.ResXResourceReader(resFile);
using (System.Resources.ResXResourceWriter writer = new System.Resources.ResXResourceWriter(resFile + ".new"))
{
System.Collections.IDictionaryEnumerator iterator = reader.GetEnumerator();
while (iterator.MoveNext())
{
writer.AddResource(iterator.Key.ToString(), iterator.Value);
}
writer.AddResource(inputForm.Input, bitmap);
writer.Generate();
}
File.Copy(resFile + ".new", resFile, true);
File.Delete(resFile + ".new");
string[] unMatched;
System.CodeDom.CodeCompileUnit unit = System.Resources.Tools.StronglyTypedResourceBuilder.Create(resFile, "Resources",
resNameSpace,
provider,
true, out unMatched);
using (StreamWriter designWriter = new StreamWriter(resDesignFile))
{
provider.GenerateCodeFromCompileUnit(unit, designWriter,
new System.CodeDom.Compiler.CodeGeneratorOptions());
}
MessageBox.Show("Image generation succeeded", "Resources Updated");
if (entire)
{
entireResName = inputForm.Input;
NotifyPropertyChanged("EntireResName");
}
else
{
partResName = inputForm.Input;
NotifyPropertyChanged("PartialResName");
}
return;
}
catch (Exception ex)
{
MessageBox.Show("Image generation failed\n" + ex.Message, "Resources Did Not Update");
return;
}
}
}
MessageBox.Show("You need to have a project open, named *Test*", "Resources Did Not Update");
return;
}
MessageBox.Show("You need to have a solution open with a project named *Test*", "Resources Did Not Update");
return;
}
}
internal void GenerateCode(LazyTextWriterCreator target)
{
Debug.Assert(target != null, "target parameter is null");
IndentedTextWriter indentedTextWriter = null;
System.IO.Stream tempFileStream = null;
System.IO.StreamReader reader = null;
System.IO.StreamWriter writer = null;
TempFileCollection tempFiles = null;
try
{
CodeDomProvider provider = null;
switch (Language)
{
case LanguageOption.GenerateCSharpCode:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case LanguageOption.GenerateVBCode:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
}
_isLanguageCaseSensitive = (provider.LanguageOptions & LanguageOptions.CaseInsensitive) == 0;
new NamespaceEmitter(this, this.NamespacePrefix, target.TargetFilePath).Emit();
// if there were errors we don't need the output file
if (RealErrorsExist)
{
return;
}
if (FixUps.Count == 0 || !FixUpCollection.IsLanguageSupported(Language))
{
indentedTextWriter = new IndentedTextWriter(target.GetOrCreateTextWriter(), "\t");
}
else
{
// need to write to a temporary file so we can do fixups...
tempFiles = new TempFileCollection(Path.GetTempPath());
string filename = Path.Combine(tempFiles.TempDir, "EdmCodeGenFixup-" + Guid.NewGuid().ToString() + ".tmp");
tempFiles.AddFile(filename, false);
tempFileStream = new System.IO.FileStream(filename, System.IO.FileMode.CreateNew, System.IO.FileAccess.ReadWrite,
System.IO.FileShare.None);
indentedTextWriter = new IndentedTextWriter(new System.IO.StreamWriter(tempFileStream), "\t");
}
CodeGeneratorOptions styleOptions = new CodeGeneratorOptions();
styleOptions.BracingStyle = "C";
styleOptions.BlankLinesBetweenMembers = false;
styleOptions.VerbatimOrder = true;
provider.GenerateCodeFromCompileUnit(CompileUnit, indentedTextWriter, styleOptions);
// if we wrote to a temp file need to post process the file...
if (tempFileStream != null)
{
indentedTextWriter.Flush();
tempFileStream.Seek(0, System.IO.SeekOrigin.Begin);
reader = new System.IO.StreamReader(tempFileStream);
FixUps.Do(reader, target.GetOrCreateTextWriter(), Language, !String.IsNullOrEmpty(SourceObjectNamespaceName));
}
}
catch (System.UnauthorizedAccessException ex)
{
AddError(ModelBuilderErrorCode.SecurityError, EdmSchemaErrorSeverity.Error, ex);
}
catch (System.IO.FileNotFoundException ex)
{
AddError(ModelBuilderErrorCode.FileNotFound, EdmSchemaErrorSeverity.Error, ex);
}
catch (System.Security.SecurityException ex)
{
AddError(ModelBuilderErrorCode.SecurityError, EdmSchemaErrorSeverity.Error, ex);
}
catch (System.IO.DirectoryNotFoundException ex)
{
AddError(ModelBuilderErrorCode.DirectoryNotFound, EdmSchemaErrorSeverity.Error, ex);
}
catch (System.IO.IOException ex)
{
AddError(ModelBuilderErrorCode.IOException, EdmSchemaErrorSeverity.Error, ex);
}
finally
{
if (indentedTextWriter != null)
{
indentedTextWriter.Close();
}
if (tempFileStream != null)
{
tempFileStream.Close();
}
if (tempFiles != null)
{
tempFiles.Delete();
((IDisposable)tempFiles).Dispose();
}
if (reader != null)
{
reader.Close();
}
if (writer != null)
{
writer.Close();
}
}
}
static void Main()
{
Inventory store1 = new Inventory();
store1.pencils = 5;
store1.pens = 10;
store1.paper = 15;
DataContractSerializer surrogateDcs =
new DataContractSerializer(typeof(Inventory), null, int.MaxValue, false, false, new InventoryTypeSurrogate());
// Plug in the surrogate in order to use the serializer.
Console.WriteLine("Plug in a surrogate for the Inventory class\n");
StringWriter sw2 = new StringWriter();
XmlWriter xw2 = XmlWriter.Create(sw2);
try
{
surrogateDcs.WriteObject(xw2, store1);
}
catch (InvalidDataContractException)
{
Console.WriteLine(" We should never get here");
}
xw2.Flush();
sw2.Flush();
Console.Write(sw2.ToString());
Console.WriteLine("\n\n Serialization succeeded. Now doing deserialization...\n");
StringReader tr = new StringReader(sw2.ToString());
XmlReader xr = XmlReader.Create(tr);
Inventory newstore = (Inventory)surrogateDcs.ReadObject(xr);
Console.Write("Deserialized Inventory data: \nPens:" + newstore.pens + "\nPencils: " + newstore.pencils + "\nPaper: " + newstore.paper);
Console.WriteLine("\n\n Deserialization succeeded. Now doing schema export/import...\n");
//The following code demonstrates schema export with a surrogate.
//The surrogate indicates how to export the non-DataContract Inventory type.
//Without the surrogate, schema export would fail.
XsdDataContractExporter xsdexp = new XsdDataContractExporter();
xsdexp.Options = new ExportOptions();
xsdexp.Options.DataContractSurrogate = new InventoryTypeSurrogate();
try
{
xsdexp.Export(typeof(Inventory));
}
catch (Exception) { }
//Write out exported schema to a file
using (FileStream fs = new FileStream("sample.xsd", FileMode.Create))
{
foreach (XmlSchema sch in xsdexp.Schemas.Schemas())
{
sch.Write(fs);
}
}
//The following code demonstrates schema import with a surrogate.
//The surrogate is used to indicate that the Inventory class already exists
//and that there is no need to generate a new class when importing the
//"InventorySurrogated" data contract.
XsdDataContractImporter xsdimp = new XsdDataContractImporter();
xsdimp.Options = new ImportOptions();
xsdimp.Options.DataContractSurrogate = new InventoryTypeSurrogate();
xsdimp.Import(xsdexp.Schemas);
//Write out the imported schema to a C-Sharp file
using (FileStream fs = new FileStream("sample.cs", FileMode.Create))
{
TextWriter tw = new StreamWriter(fs);
CodeDomProvider cdp = new Microsoft.CSharp.CSharpCodeProvider();
cdp.GenerateCodeFromCompileUnit(xsdimp.CodeCompileUnit, tw, null);
tw.Flush();
}
Console.WriteLine("\n\n To see the results of schema export and import,");
Console.WriteLine(" see SAMPLE.XSD and SAMPLE.CS.\n");
Console.WriteLine(" Press ENTER to terminate the sample.\n");
Console.ReadLine();
}
/// <summary>
/// Generate a C# assembly, compile it and load it up
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void generateCSharpButton_Click(object sender, System.EventArgs e)
{
CodeExpression[] emptyParams = new CodeExpression[] { };
// Generate the C# for the control
CodeCompileUnit ccu = new CodeCompileUnit( );
// Create a namespace
CodeNamespace ns = new CodeNamespace("MyControls");
// Add some imports statements
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Drawing"));
ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
// Add the namespace to the code compile unit
ccu.Namespaces.Add(ns);
// Now create the class
CodeTypeDeclaration ctd = new CodeTypeDeclaration("MyControl");
ctd.BaseTypes.Add(typeof(System.Windows.Forms.UserControl));
// Add the type to the namespace
ns.Types.Add(ctd);
// Add the default constructor
CodeConstructor constructor = new CodeConstructor( );
constructor.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression( ), "InitializeComponent", emptyParams));
constructor.Attributes = MemberAttributes.Public;
ctd.Members.Add(constructor);
// Create the private member variable to hold the label
CodeMemberField labelField = new CodeMemberField(typeof(System.Windows.Forms.Label), "_label");
ctd.Members.Add(labelField);
// Now add the InitializeComponent method
CodeMemberMethod initializeComponent = new CodeMemberMethod( );
initializeComponent.Name = "InitializeComponent";
initializeComponent.ReturnType = new CodeTypeReference(typeof(void));
CodeAssignStatement labelNew = new CodeAssignStatement(new CodeVariableReferenceExpression("_label"),
new CodeObjectCreateExpression(typeof(System.Windows.Forms.Label), emptyParams));
initializeComponent.Statements.Add(labelNew);
// Add the SuspendLayout() call
initializeComponent.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression( ), "SuspendLayout", emptyParams));
CodeBinaryOperatorExpression leftAndRight = new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(System.Windows.Forms.AnchorStyles)), "Left"),
CodeBinaryOperatorType.BitwiseOr,
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(System.Windows.Forms.AnchorStyles)), "Right"));
CodeBinaryOperatorExpression topToo = new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(System.Windows.Forms.AnchorStyles)), "Top"),
CodeBinaryOperatorType.BitwiseOr,
leftAndRight);
// Setup the Anchor property of the label
initializeComponent.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("_label"), "Anchor"),
topToo));
// And setup the border style
initializeComponent.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("_label"), "BorderStyle"),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(System.Windows.Forms.BorderStyle)), "Fixed3D")));
// Set the location of the control
initializeComponent.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("_label"), "Location"),
new CodeObjectCreateExpression(typeof(System.Drawing.Point),
new CodeExpression[] { new CodePrimitiveExpression(8),
new CodePrimitiveExpression(8) })));
// Set the name of the control
initializeComponent.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("_label"), "Name"),
new CodePrimitiveExpression("_label")));
// Set the size of the control
initializeComponent.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("_label"), "Size"),
new CodeObjectCreateExpression(typeof(System.Drawing.Size),
new CodeExpression[] { new CodePrimitiveExpression(312),
new CodePrimitiveExpression(23) })));
// Set the tab index
initializeComponent.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("_label"), "TabIndex"),
new CodePrimitiveExpression(0)));
// And then the text!
initializeComponent.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("_label"), "Text"),
new CodePrimitiveExpression(messageText.Text)));
// Now add the label control to the controls collection
initializeComponent.Statements.Add(
new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression( ), "Controls"), "Add",
new CodeExpression[] { new CodeVariableReferenceExpression("_label") }));
// And set the name of the control to MyControl
initializeComponent.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression( ), "Name"),
new CodePrimitiveExpression("MyControl")));
// And the size of the control
initializeComponent.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression( ), "Size"),
new CodeObjectCreateExpression(typeof(System.Drawing.Size),
new CodeExpression[] { new CodePrimitiveExpression(328),
new CodePrimitiveExpression(100) })));
// Add the ResumeLayout ( false ) call
initializeComponent.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression( ), "ResumeLayout", new CodeExpression [] { new CodePrimitiveExpression(false) }));
// And finally add initializeComponent to the members for the class
ctd.Members.Add(initializeComponent);
// Finally create the C#
CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider( );
#if DEBUG
// Generate the source code on disk
ICodeGenerator generator = provider.CreateGenerator( );
using (StreamWriter sw = new StreamWriter("code.cs", false))
{
CodeGeneratorOptions options = new CodeGeneratorOptions( );
options.BracingStyle = "C";
generator.GenerateCodeFromCompileUnit(ccu, sw, options);
}
#endif
ICodeCompiler compiler = provider.CreateGenerator( ) as ICodeCompiler;
CompilerParameters cp = new CompilerParameters(new string[] { "System.dll", "System.Windows.Forms.dll", "System.Drawing.dll" });
cp.GenerateInMemory = true;
cp.OutputAssembly = "AutoGenerated";
CompilerResults results = compiler.CompileAssemblyFromDom(cp, ccu);
if (results.Errors.Count == 0)
{
Type t = results.CompiledAssembly.GetType("MyControls.MyControl");
Control c = Activator.CreateInstance(t) as Control;
c.Dock = DockStyle.Fill;
controlPanel.SuspendLayout( );
controlPanel.Controls.Clear( );
controlPanel.Controls.Add(c);
controlPanel.ResumeLayout( );
}
else
{
CompilerError error = results.Errors[0];
int i = 0;
i++;
}
}
/// <summary>
/// Process a template and returns the processed file.
/// </summary>
/// <param name="templateText">The template text.</param>
/// <returns></returns>
public string ProcessTemplate(string templateText)
{
// Initialize TemplateEngine state
_doTemplateCode = new StringBuilder();
_doTemplateClassCode = new StringBuilder();
_isTemplateClassCode = false;
Assembly templateAssembly = null;
_directives = new List <Directive>();
// Parse the T4 template text
Parse(templateText);
// Build parameters for template
var parametersCode = new StringBuilder();
foreach (var parameterValueType in _parameters.Values)
{
parametersCode.Append(string.Format(System.Globalization.CultureInfo.InvariantCulture, "public {0} {1} {{ get; set; }}\n", parameterValueType.Type.FullName, parameterValueType.Name));
}
// Build import namespaces for template
var importNamespaceCode = new StringBuilder();
foreach (var directive in _directives)
{
if (directive.Name == "import")
{
importNamespaceCode.Append("using " + directive.Attributes["namespace"] + ";\n");
}
}
// Expand final template class code
// Parameter {0} = List of import namespaces.
// Parameter {1} = List of parameters declaration.
// Parameter {2} = Body of template code
// Parameter {3} = Body of template class level code
string templateSourceCode = string.Format(GenericTemplateCodeText, importNamespaceCode, parametersCode, _doTemplateCode, _doTemplateClassCode);
// Creates the C# compiler, compiling for 3.5
//var codeProvider = new Microsoft.CSharp.CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", "v3.5" } });
var codeProvider = new Microsoft.CSharp.CSharpCodeProvider(new Dictionary <string, string>()
{
{ "CompilerVersion", "v4.0" }
});
var compilerParameters = new CompilerParameters {
GenerateInMemory = true, GenerateExecutable = false
};
// Adds assembly from CurrentDomain
// TODO, implement T4 directive "assembly"?
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
try
{
string location = assembly.Location;
if (!String.IsNullOrEmpty(location))
{
compilerParameters.ReferencedAssemblies.Add(location);
}
}
catch (NotSupportedException)
{
// avoid problem with previous dynamic assemblies
}
}
// Compiles the code
var compilerResults = codeProvider.CompileAssemblyFromSource(compilerParameters, templateSourceCode);
// Output any errors
foreach (var compilerError in compilerResults.Errors)
{
Logger.Error(compilerError.ToString());
}
// If successful, gets the compiled assembly
if (compilerResults.Errors.Count == 0 && compilerResults.CompiledAssembly != null)
{
templateAssembly = compilerResults.CompiledAssembly;
// File.WriteAllText(templateFile + ".txt", src);
}
else
{
Logger.Fatal("Template [{0}] contains error", TemplateFileName);
}
// Get a new templatizer instance
var templatizer = (Templatizer)Activator.CreateInstance(templateAssembly.GetType("TemplateImpl"));
// Set all parameters for the template
foreach (var parameterValueType in _parameters.Values)
{
var propertyInfo = templatizer.GetType().GetProperty(parameterValueType.Name);
propertyInfo.SetValue(templatizer, parameterValueType.Value, null);
}
// Run the templatizer
templatizer.Process();
// Returns the text
return(templatizer.ToString());
}
/// <summary>
/// Generates an Assembly from a script filename
/// </summary>
/// <param name="filename">The filename of the script</param>
/// <param name="references">Assembly references for the script</param>
/// <returns>The generated assembly</returns>
public Assembly CreateAssembly(string filename, IList references)
{
// ensure that compilerErrors is null
compilerErrors = null;
string extension = Path.GetExtension(filename);
// Select the correct CodeDomProvider based on script file extension
CodeDomProvider codeProvider = null;
switch (extension)
{
case ".cs":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".vb":
codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case ".js":
// codeProvider = new Microsoft.JScript.JScriptCodeProvider();
break;
default:
throw new InvalidOperationException("Script files must have a .cs, .vb, or .js extension, for C#, Visual Basic.NET, or JScript respectively.");
}
ICodeCompiler compiler = codeProvider.CreateCompiler();
// Set compiler parameters
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.CompilerOptions = "/target:library /optimize";
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
compilerParams.IncludeDebugInformation = false;
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
// Add custom references
foreach (string reference in references)
{
if (!compilerParams.ReferencedAssemblies.Contains(reference))
{
compilerParams.ReferencedAssemblies.Add(reference);
}
}
// Do the compilation
CompilerResults results = compiler.CompileAssemblyFromFile(compilerParams,
filename);
//Do we have any compiler errors
if (results.Errors.Count > 0)
{
compilerErrors = results.Errors;
throw new Exception(
"Compiler error(s) encountered and saved to AssemblyFactory.CompilerErrors");
}
Assembly createdAssembly = results.CompiledAssembly;
return(createdAssembly);
}
System.Reflection.Assembly _CompileSource(string Input, bool InputIsFile, bool exe, string outputname)
{
string[] asmrefs = new string[AssemblyReferences.Count];
List <string> assemblydirs = new List <string>();
char[] slashes = new char[] { '/', '\\' };
for (int i = 0; i < asmrefs.Length; i++)
{
string ar = AssemblyReferences[i];
int ils = ar.LastIndexOfAny(slashes);
if (-1 != ils)
{
assemblydirs.Add(ar.Substring(0, ils));
ar = ar.Substring(ils + 1);
}
asmrefs[i] = ar;
}
StringBuilder localcompileropts = new StringBuilder();
{
for (int i = 0; i < assemblydirs.Count; i++)
{
localcompileropts.Append(" /lib:\"" + assemblydirs[i] + "\"");
}
}
System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters(asmrefs);
cp.IncludeDebugInformation = _compilerdbg;
System.CodeDom.Compiler.CompilerResults cr = null;
bool alreadylogged = false;
string reason = "";
for (int rotor = 1; ; rotor++)
{
#if DEBUG
if (rotor > 3)
{
throw new System.IO.FileNotFoundException("ArrayComboList.CompileSource dynamic C# compilation: Unable to create DLL" + reason);
}
#endif
try
{
cp.OutputAssembly = outputname;
cp.GenerateExecutable = exe;
cp.GenerateInMemory = false;
cp.CompilerOptions = getcompileropts() + localcompileropts.ToString();
{
System.Threading.Mutex mdc = new System.Threading.Mutex(false, "DynCmp");
try
{
mdc.WaitOne();
}
catch (System.Threading.AbandonedMutexException)
{
}
try
{
Dictionary <string, string> providerOptions = new Dictionary <string, string>();
providerOptions["CompilerVersion"] = "v3.5";
using (Microsoft.CSharp.CSharpCodeProvider cscp = new Microsoft.CSharp.CSharpCodeProvider(providerOptions))
{
if (InputIsFile)
{
cr = cscp.CompileAssemblyFromFile(cp, Input);
}
else
{
cr = cscp.CompileAssemblyFromSource(cp, Input);
}
}
}
finally
{
mdc.ReleaseMutex();
mdc.Close();
}
}
if (cr.Errors.HasErrors)
{
try
{
lock (typeof(Compiler))
{
if (InputIsFile)
{
System.IO.File.Copy(Input, "error.cs", true); // overwrite=true
}
else
{
System.IO.File.WriteAllText("error.cs", Input);
}
}
}
catch
{
}
for (int i = 0; i < cr.Errors.Count; i++)
{
if (!cr.Errors[i].IsWarning)
{
throw new Exception("CompileSource code compile error: " + cr.Errors[i].ToString());
}
}
throw new Exception("CompileSource code compile error: " + cr.Errors[0].ToString());
}
if (0 != cr.NativeCompilerReturnValue)
{
//LogLine("CompileSource code compile did not return 0 (returned " + cr.NativeCompilerReturnValue.ToString() + "): ");
for (int i = 0; i < cr.Output.Count; i++)
{
string ss = cr.Output[i].Trim();
if (0 != ss.Length)
{
//LogLine(" C" + rotor.ToString() + "- " + cr.Output[i]);
}
}
}
#if DEBUG
if (rotor > 1)
{
System.Threading.Thread.Sleep(1000 * (rotor - 1));
}
#else
System.Threading.Thread.Sleep(1000 * rotor);
#endif
break; // Good.
}
catch (System.IO.IOException e)
{
if (!alreadylogged)
{
alreadylogged = true;
//LogLine("Rotor retry: " + e.ToString());
}
reason = ": " + e.ToString();
continue;
}
}
return(cr.CompiledAssembly);
}
private void OutputGeneratedCode(CodeCompileUnit compileUnit)
{
CodeDomProvider generator = null;
switch (options.Language)
{
case SupportedLanguage.CS:
generator = new Microsoft.CSharp.CSharpCodeProvider();
break;
case SupportedLanguage.VB:
generator = new Microsoft.VisualBasic.VBCodeProvider();
break;
case SupportedLanguage.CPP:
generator = new Microsoft.VisualC.CppCodeProvider();
break;
case SupportedLanguage.JS:
generator = new Microsoft.JScript.JScriptCodeProvider();
break;
case SupportedLanguage.PY:
generator = new PythonProvider();
break;
default:
Console.WriteLine("Unknown language detected. Falling back to default C#");
generator = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
var genOptions = new CodeGeneratorOptions()
{
BlankLinesBetweenMembers = true,
VerbatimOrder = false,
ElseOnClosing = false,
BracingStyle = "C",
IndentString = " "
};
if (options.UseFolders)
{
foreach (var file in MetaFacade.SplitCompileUnit(compileUnit))
{
var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension);
CheckDirectoryExists(fileInfo.Directory);
using (var sw = new StreamWriter(fileInfo.Create()))
{
generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions);
}
}
}
else
{
using (var sw = new StreamWriter(options.OutputFile))
{
generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions);
}
}
}
internal static void EmitCodeToAddIntoCustomStdBinding(Type standardBindingType, string generatedElementClassName, string generatedCollectionElementClassName, string srcFile)
{
CodeMemberMethod applyCfgMethodForStdBinding = new CodeMemberMethod();
applyCfgMethodForStdBinding.Name = MethodNameConstants.ApplyConfigurationMethod;
string paramConfigName = "configurationName";
CodeVariableReferenceExpression paramVarRef = new CodeVariableReferenceExpression(paramConfigName);
applyCfgMethodForStdBinding.Parameters.Add(new CodeParameterDeclarationExpression(
CodeDomHelperObjects.stringTypeRef,
paramConfigName));
string bindingsString = "bindings";
CodeVariableReferenceExpression bindingsVarRef = new CodeVariableReferenceExpression(bindingsString);
string sectionString = "section";
CodeVariableReferenceExpression sectionVarRef = new CodeVariableReferenceExpression(sectionString);
string elementString = "element";
CodeVariableReferenceExpression elementVarRef = new CodeVariableReferenceExpression(elementString);
string topLevelSectionNameInConfig = "system.serviceModel/bindings/";
string subSectionNameInConfig = Helpers.TurnFirstCharLower(standardBindingType.Name);
CodeVariableDeclarationStatement bindingsInit = new CodeVariableDeclarationStatement(
new CodeTypeReference(TypeNameConstants.BindingsSection),
bindingsString,
new CodeCastExpression(TypeNameConstants.BindingsSection,
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(TypeNameConstants.ConfigurationManager),
MethodNameConstants.GetSectionMethod,
new CodePrimitiveExpression(topLevelSectionNameInConfig))));
applyCfgMethodForStdBinding.Statements.Add(bindingsInit);
CodeVariableDeclarationStatement sectionInit = new CodeVariableDeclarationStatement(
new CodeTypeReference(generatedCollectionElementClassName),
sectionString,
new CodeCastExpression(generatedCollectionElementClassName,
new CodeArrayIndexerExpression(
bindingsVarRef,
new CodePrimitiveExpression(subSectionNameInConfig))));
applyCfgMethodForStdBinding.Statements.Add(sectionInit);
CodeVariableDeclarationStatement elementInit = new CodeVariableDeclarationStatement(
new CodeTypeReference(generatedElementClassName),
elementString,
new CodeArrayIndexerExpression(
new CodeFieldReferenceExpression(
sectionVarRef,
PropertyNameConstants.BindingsProperty),
paramVarRef));
applyCfgMethodForStdBinding.Statements.Add(elementInit);
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(
elementVarRef,
CodeBinaryOperatorType.IdentityEquality,
CodeDomHelperObjects.NullRef);
CodeThrowExceptionStatement ctes = new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
new CodeTypeReference(typeof(ConfigurationErrorsException)),
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(CodeDomHelperObjects.stringTypeRef),
MethodNameConstants.FormatMethod,
CodeDomHelperObjects.cultureInfoCurrent,
new CodePrimitiveExpression("There is no binding named {0} at {1}."),
paramVarRef,
new CodePropertyReferenceExpression(
sectionVarRef, PropertyNameConstants.BindingNameProperty))));
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(
elementVarRef,
MethodNameConstants.ApplyConfigurationMethod,
CodeDomHelperObjects.ThisRef);
CodeStatement[] trueStatements = { ctes };
CodeStatement[] falseStatements = { new CodeExpressionStatement(cmie) };
CodeConditionStatement ccs = new CodeConditionStatement(cboe, trueStatements, falseStatements);
applyCfgMethodForStdBinding.Statements.Add(ccs);
string indent = " ";
CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider();
using (System.IO.StreamWriter sbSW = new System.IO.StreamWriter(srcFile, false))
{
using (IndentedTextWriter sbTW = new IndentedTextWriter(sbSW, indent))
{
provider.GenerateCodeFromMember(
applyCfgMethodForStdBinding,
sbTW,
new CodeGeneratorOptions());
}
}
}
private void _SaveSfxStub(string exeToGenerate, SelfExtractorSaveOptions options)
{
string nameOfIconFile = null;
string stubExe = null;
string unpackedResourceDir = null;
string tmpDir = null;
try
{
if (File.Exists(exeToGenerate))
{
if (Verbose)
{
StatusMessageTextWriter.WriteLine("The existing file ({0}) will be overwritten.", exeToGenerate);
}
}
if (!exeToGenerate.EndsWith(".exe"))
{
if (Verbose)
{
StatusMessageTextWriter.WriteLine("Warning: The generated self-extracting file will not have an .exe extension.");
}
}
// workitem 10553
tmpDir = TempFileFolder ?? Path.GetDirectoryName(exeToGenerate);
stubExe = GenerateTempPathname(tmpDir, "exe");
// get the Chama.Utils.Ionic.Zip assembly
Assembly a1 = typeof(ZipFile).Assembly;
using (var csharp = new Microsoft.CSharp.CSharpCodeProvider())
{
// The following is a perfect opportunity for a linq query, but
// I cannot use it. The generated SFX needs to run on .NET 2.0,
// and using LINQ would break that. Here's what it would look
// like:
//
// var settings = (from x in SettingsList
// where x.Flavor == flavor
// select x).First();
ExtractorSettings settings = null;
foreach (var x in SettingsList)
{
if (x.Flavor == options.Flavor)
{
settings = x;
break;
}
}
// sanity check; should never happen
if (settings == null)
{
throw new BadStateException(String.Format("While saving a Self-Extracting Zip, Cannot find that flavor ({0})?", options.Flavor));
}
// This is the list of referenced assemblies. Chama.Utils.Ionic.Zip is
// needed here. Also if it is the winforms (gui) extractor, we
// need other referenced assemblies, like
// System.Windows.Forms.dll, etc.
var cp = new System.CodeDom.Compiler.CompilerParameters();
cp.ReferencedAssemblies.Add(a1.Location);
if (settings.ReferencedAssemblies != null)
{
foreach (string ra in settings.ReferencedAssemblies)
{
cp.ReferencedAssemblies.Add(ra);
}
}
cp.GenerateInMemory = false;
cp.GenerateExecutable = true;
cp.IncludeDebugInformation = false;
cp.CompilerOptions = "";
Assembly a2 = Assembly.GetExecutingAssembly();
// Use this to concatenate all the source code resources into a
// single module.
var sb = new System.Text.StringBuilder();
// In case there are compiler errors later, we allocate a source
// file name now. If errors are detected, we'll spool the source
// code as well as the errors (in comments) into that filename,
// and throw an exception with the filename. Makes it easier to
// diagnose. This should be rare; most errors happen only
// during devlpmt of DotNetZip itself, but there are rare
// occasions when they occur in other cases.
string sourceFile = GenerateTempPathname(tmpDir, "cs");
// // debugging: enumerate the resources in this assembly
// Console.WriteLine("Resources in this assembly:");
// foreach (string rsrc in a2.GetManifestResourceNames())
// {
// Console.WriteLine(rsrc);
// }
// Console.WriteLine();
// all the source code is embedded in the DLL as a zip file.
using (ZipFile zip = ZipFile.Read(a2.GetManifestResourceStream("Chama.Utils.Ionic.Zip.Resources.ZippedResources.zip")))
{
// // debugging: enumerate the files in the embedded zip
// Console.WriteLine("Entries in the embbedded zip:");
// foreach (ZipEntry entry in zip)
// {
// Console.WriteLine(entry.FileName);
// }
// Console.WriteLine();
unpackedResourceDir = GenerateTempPathname(tmpDir, "tmp");
if (String.IsNullOrEmpty(options.IconFile))
{
// Use the ico file that is embedded into the Chama.Utils.Ionic.Zip
// DLL itself. To do this we must unpack the icon to
// the filesystem, in order to specify it on the cmdline
// of csc.exe. This method will remove the unpacked
// file later.
System.IO.Directory.CreateDirectory(unpackedResourceDir);
ZipEntry e = zip["zippedFile.ico"];
// Must not extract a readonly file - it will be impossible to
// delete later.
if ((e.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
e.Attributes ^= FileAttributes.ReadOnly;
}
e.Extract(unpackedResourceDir);
nameOfIconFile = Path.Combine(unpackedResourceDir, "zippedFile.ico");
cp.CompilerOptions += String.Format("/win32icon:\"{0}\"", nameOfIconFile);
}
else
{
cp.CompilerOptions += String.Format("/win32icon:\"{0}\"", options.IconFile);
}
cp.OutputAssembly = stubExe;
if (options.Flavor == SelfExtractorFlavor.WinFormsApplication)
{
cp.CompilerOptions += " /target:winexe";
}
if (!String.IsNullOrEmpty(options.AdditionalCompilerSwitches))
{
cp.CompilerOptions += " " + options.AdditionalCompilerSwitches;
}
if (String.IsNullOrEmpty(cp.CompilerOptions))
{
cp.CompilerOptions = null;
}
if ((settings.CopyThroughResources != null) && (settings.CopyThroughResources.Count != 0))
{
if (!Directory.Exists(unpackedResourceDir))
{
System.IO.Directory.CreateDirectory(unpackedResourceDir);
}
foreach (string re in settings.CopyThroughResources)
{
string filename = Path.Combine(unpackedResourceDir, re);
ExtractResourceToFile(a2, re, filename);
// add the file into the target assembly as an embedded resource
cp.EmbeddedResources.Add(filename);
}
}
// add the Chama.Utils.Ionic.Utils.Zip DLL as an embedded resource
cp.EmbeddedResources.Add(a1.Location);
// file header
sb.Append("// " + Path.GetFileName(sourceFile) + "\n")
.Append("// --------------------------------------------\n//\n")
.Append("// This SFX source file was generated by DotNetZip ")
.Append(ZipFile.LibraryVersion.ToString())
.Append("\n// at ")
.Append(System.DateTime.Now.ToString("yyyy MMMM dd HH:mm:ss"))
.Append("\n//\n// --------------------------------------------\n\n\n");
// assembly attributes
if (!String.IsNullOrEmpty(options.Description))
{
sb.Append("[assembly: System.Reflection.AssemblyTitle(\""
+ options.Description.Replace("\"", "")
+ "\")]\n");
}
else
{
sb.Append("[assembly: System.Reflection.AssemblyTitle(\"DotNetZip SFX Archive\")]\n");
}
if (!String.IsNullOrEmpty(options.ProductVersion))
{
sb.Append("[assembly: System.Reflection.AssemblyInformationalVersion(\""
+ options.ProductVersion.Replace("\"", "")
+ "\")]\n");
}
// workitem
string copyright =
(String.IsNullOrEmpty(options.Copyright))
? "Extractor: Copyright ?Dino Chiesa 2008-2011"
: options.Copyright.Replace("\"", "");
if (!String.IsNullOrEmpty(options.ProductName))
{
sb.Append("[assembly: System.Reflection.AssemblyProduct(\"")
.Append(options.ProductName.Replace("\"", ""))
.Append("\")]\n");
}
else
{
sb.Append("[assembly: System.Reflection.AssemblyProduct(\"DotNetZip\")]\n");
}
sb.Append("[assembly: System.Reflection.AssemblyCopyright(\"" + copyright + "\")]\n")
.Append(String.Format("[assembly: System.Reflection.AssemblyVersion(\"{0}\")]\n", ZipFile.LibraryVersion.ToString()));
if (options.FileVersion != null)
{
sb.Append(String.Format("[assembly: System.Reflection.AssemblyFileVersion(\"{0}\")]\n",
options.FileVersion.ToString()));
}
sb.Append("\n\n\n");
// Set the default extract location if it is available
string extractLoc = options.DefaultExtractDirectory;
if (extractLoc != null)
{
// remove double-quotes and replace slash with double-slash.
// This, because the value is going to be embedded into a
// cs file as a quoted string, and it needs to be escaped.
extractLoc = extractLoc.Replace("\"", "").Replace("\\", "\\\\");
}
string postExCmdLine = options.PostExtractCommandLine;
if (postExCmdLine != null)
{
postExCmdLine = postExCmdLine.Replace("\\", "\\\\");
postExCmdLine = postExCmdLine.Replace("\"", "\\\"");
}
foreach (string rc in settings.ResourcesToCompile)
{
using (Stream s = zip[rc].OpenReader())
{
if (s == null)
{
throw new ZipException(String.Format("missing resource '{0}'", rc));
}
using (StreamReader sr = new StreamReader(s))
{
while (sr.Peek() >= 0)
{
string line = sr.ReadLine();
if (extractLoc != null)
{
line = line.Replace("@@EXTRACTLOCATION", extractLoc);
}
line = line.Replace("@@REMOVE_AFTER_EXECUTE", options.RemoveUnpackedFilesAfterExecute.ToString());
line = line.Replace("@@QUIET", options.Quiet.ToString());
if (!String.IsNullOrEmpty(options.SfxExeWindowTitle))
{
line = line.Replace("@@SFX_EXE_WINDOW_TITLE", options.SfxExeWindowTitle);
}
line = line.Replace("@@EXTRACT_EXISTING_FILE", ((int)options.ExtractExistingFile).ToString());
if (postExCmdLine != null)
{
line = line.Replace("@@POST_UNPACK_CMD_LINE", postExCmdLine);
}
sb.Append(line).Append("\n");
}
}
sb.Append("\n\n");
}
}
}
string LiteralSource = sb.ToString();
#if DEBUGSFX
// for debugging only
string sourceModule = GenerateTempPathname(tmpDir, "cs");
using (StreamWriter sw = File.CreateText(sourceModule))
{
sw.Write(LiteralSource);
}
Console.WriteLine("source: {0}", sourceModule);
#endif
var cr = csharp.CompileAssemblyFromSource(cp, LiteralSource);
if (cr == null)
{
throw new SfxGenerationException("Cannot compile the extraction logic!");
}
if (Verbose)
{
foreach (string output in cr.Output)
{
StatusMessageTextWriter.WriteLine(output);
}
}
if (cr.Errors.Count != 0)
{
using (TextWriter tw = new StreamWriter(sourceFile))
{
// first, the source we compiled
tw.Write(LiteralSource);
// now, append the compile errors
tw.Write("\n\n\n// ------------------------------------------------------------------\n");
tw.Write("// Errors during compilation: \n//\n");
string p = Path.GetFileName(sourceFile);
foreach (System.CodeDom.Compiler.CompilerError error in cr.Errors)
{
tw.Write(String.Format("// {0}({1},{2}): {3} {4}: {5}\n//\n",
p, // 0
error.Line, // 1
error.Column, // 2
error.IsWarning ? "Warning" : "error", // 3
error.ErrorNumber, // 4
error.ErrorText)); // 5
}
}
throw new SfxGenerationException(String.Format("Errors compiling the extraction logic! {0}", sourceFile));
}
OnSaveEvent(ZipProgressEventType.Saving_AfterCompileSelfExtractor);
// Now, copy the resulting EXE image to the _writestream.
// Because this stub exe is being saved first, the effect will be to
// concatenate the exe and the zip data together.
using (System.IO.Stream input = System.IO.File.OpenRead(stubExe))
{
byte[] buffer = new byte[4000];
int n = 1;
while (n != 0)
{
n = input.Read(buffer, 0, buffer.Length);
if (n != 0)
{
WriteStream.Write(buffer, 0, n);
}
}
}
}
OnSaveEvent(ZipProgressEventType.Saving_AfterSaveTempArchive);
}
finally
{
try
{
if (Directory.Exists(unpackedResourceDir))
{
try { Directory.Delete(unpackedResourceDir, true); }
catch (System.IO.IOException exc1)
{
StatusMessageTextWriter.WriteLine("Warning: Exception: {0}", exc1);
}
}
if (File.Exists(stubExe))
{
try { File.Delete(stubExe); }
catch (System.IO.IOException exc1)
{
StatusMessageTextWriter.WriteLine("Warning: Exception: {0}", exc1);
}
}
}
catch (System.IO.IOException) { }
}
return;
}
