private bool init(string generateCode, params string[] referenceAssemblies)
{
bool flag = false;
result = null;
using (CSharpCodeProvider provider = new CSharpCodeProvider())
{
ICodeCompiler objICodeCompiler = provider.CreateCompiler();
CompilerParameters objCompilerParameters = new CompilerParameters();
if (referenceAssemblies != null)
objCompilerParameters.ReferencedAssemblies.AddRange(referenceAssemblies);
objCompilerParameters.GenerateExecutable = false;
objCompilerParameters.GenerateInMemory = true;
result = objICodeCompiler.CompileAssemblyFromSource(objCompilerParameters, generateCode);
}
if (result != null)
{
if (result.Errors.Count > 0 && ErrorHandler != null)
{
ErrorHandler(result.Errors);
}
else
{
flag = true;
}
}
return flag;
}
public void CompileSiteModels()
{
DirectoryInfo di = new DirectoryInfo(SysPath.SiteModelsDirectory);
FileInfo[] fiar = di.GetFiles("*.cs");
String[] fisar = new String[fiar.Length];
for (int i = 0; i < fiar.Length; i++)
{
fisar[i] = fiar[i].FullName;
}
CompilerParameters parameters = new CompilerParameters(new String[] { "System.dll", "NStag.dll", "nhibernate.dll" });
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = true;
parameters.OutputAssembly = this.DomainName;
parameters.CompilerOptions = String.Concat("/lib:", SysPath.GetLibDirectory());
CSharpCodeProvider cprovider = new CSharpCodeProvider();
CompilerResults results = cprovider.CompileAssemblyFromFile(parameters, cspath);
if (results.Errors.HasErrors)
{
throw new Exception(results.Errors[0].ErrorText);
}
}
public Tuple<StringCollection, Assembly> Compile(string[] dllFiles, string[] sourceFiles, string outputAssemblyPath)
{
var providerOptions = new Dictionary<string,
string> { {
"CompilerVersion",
"v4.0"
}
};
CodeDomProvider codeProvider = new CSharpCodeProvider(providerOptions);
var compilerParameters = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = true
};
compilerParameters.ReferencedAssemblies.AddRange(dllFiles);
compilerParameters.ReferencedAssemblies.Add("System.dll");
compilerParameters.ReferencedAssemblies.Add("System.Core.dll");
compilerParameters.ReferencedAssemblies.Add("System.Web.Services.dll");
compilerParameters.ReferencedAssemblies.Add("System.ComponentModel.dll");
compilerParameters.ReferencedAssemblies.Add("System.Xml.Serialization.dll");
var result = codeProvider.CompileAssemblyFromFile(compilerParameters, sourceFiles);
return new Tuple<StringCollection,
Assembly>(result.Output, result.Errors.Count > 0 ? null : result.CompiledAssembly);
}
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
string @namespace = "EnterpriseServerBase.WebService.DynamicWebCalling";
if ((classname == null) || (classname == ""))
{
classname = WebServiceProxy.GetWsClassName(url);
}
try
{
//获取WSDL
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);
//生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider csc = new CSharpCodeProvider();
ICodeCompiler icc = csc.CreateCompiler();
//设定编译参数
CompilerParameters cplist = new 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");
//编译代理类
CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
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(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(methodname);
return mi.Invoke(obj, args);
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
}
}
public static void OutputAssembly(Dictionary<string, string> generated, IEnumerable<string> assemblies, string assemblyPath)
{
var providerOptions = new Dictionary<string, string> {{"CompilerVersion", "v4.0"}};
using (var codeProvider = new CSharpCodeProvider(providerOptions))
{
string[] sources = (from p in generated.Keys select generated[p]).ToArray();
List<string> assemblyPaths = new List<string>(assemblies);
assemblyPaths.Add(typeof (ManifestEventAttribute).Assembly.Location);
var compilerParameters = new CompilerParameters(
assemblyPaths.ToArray(),
assemblyPath,
false);
CompilerResults results = codeProvider.CompileAssemblyFromSource(compilerParameters, sources);
if (results.Errors.Count == 0)
return;
var sb = new StringBuilder();
foreach (object o in results.Errors)
{
sb.AppendLine(o.ToString());
}
string errors = sb.ToString();
throw new Exception(errors);
}
}
private static object ExecuteScript(string script, ScriptExecutionOptions options)
{
object result = null;
CompilerParameters cpar = new CompilerParameters();
cpar.GenerateInMemory = true;
cpar.ReferencedAssemblies.Add("mscorlib.dll");
cpar.ReferencedAssemblies.Add("System.dll");
cpar.ReferencedAssemblies.Add("System.Core.dll");
cpar.ReferencedAssemblies.Add("System.Data.dll");
cpar.ReferencedAssemblies.Add("System.Xml.dll");
cpar.ReferencedAssemblies.Add(typeof(CSharpScriptingProvider).Assembly.Location);
string code = Properties.Resources.ScriptProviderCSharpTemplate;
code = code.Replace("{Source}", script);
CSharpCodeProvider csp = new CSharpCodeProvider();
CompilerResults res = csp.CompileAssemblyFromSource(cpar, code);
if (!res.Errors.HasErrors)
{
MethodInfo func = res.CompiledAssembly.ExportedTypes.First().GetMethods().First();
result = func.Invoke(null, new object[] { options });
}
return result;
}
public bool Compile(string src)
{
var param = new CompilerParameters(new string[]
{
"System.dll",
"mscorlib.dll",
"System.Data.dll",
"System.Xml.dll",
"System.Xml.Linq.dll",
"lib.dll",
"compiler.dll",
});
param.GenerateInMemory = true;
param.GenerateExecutable = false;
param.IncludeDebugInformation = false;
_provider = new CSharpCodeProvider(
new Dictionary<string, string>()
{
{ "CompilerVersion", "v4.0" },
});
_results = _provider.CompileAssemblyFromSource(param, src);
if (_results.Errors.Count > 0)
{
foreach (CompilerError err in _results.Errors)
{
if (err.IsWarning) Console.WriteLine("[Warning] {0}: [{1}] {2}", err.Line, err.ErrorNumber, err.ErrorText);
else Console.WriteLine("[Error] {0}: [{1}] {2}", err.Line, err.ErrorNumber, err.ErrorText);
}
return false;
}
return true;
}
public void UpdateSource()
{
_codeType = null;
_codeInstance = null;
if (Source == null)
return;
var provider = new CSharpCodeProvider();
var options = new CompilerParameters { GenerateInMemory = true };
string qn = typeof(Point3D).Assembly.Location;
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add(qn);
string src = template.Replace("#code#", Source);
CompilerResults compilerResults = provider.CompileAssemblyFromSource(options, src);
if (!compilerResults.Errors.HasErrors)
{
Errors = null;
var assembly = compilerResults.CompiledAssembly;
_codeInstance = assembly.CreateInstance("MyNamespace.MyEvaluator");
_codeType = _codeInstance.GetType();
}
else
{
// correct line numbers
Errors = compilerResults.Errors;
for (int i = 0; i < Errors.Count; i++)
Errors[i].Line -= 17;
}
_w = ParameterW;
UpdateModel();
}
/// <summary>
/// Returns the C# literal representation of a given primitive expression.
/// (Useful for escaping strings)
/// </summary>
private static string PrimitiveLiteral(this string input)
{
var writer = new StringWriter();
var provider = new CSharpCodeProvider();
provider.GenerateCodeFromExpression(new CodePrimitiveExpression(input), writer, null);
return writer.ToString();
}
public static CompilerResults CompileFile(string input, string output, params string[] references)
{
CreateOutput(output);
List<string> referencedAssemblies = new List<string>(references.Length + 3);
referencedAssemblies.AddRange(references);
referencedAssemblies.Add("System.dll");
referencedAssemblies.Add(typeof(IModule).Assembly.CodeBase.Replace(@"file:///", ""));
referencedAssemblies.Add(typeof(ModuleAttribute).Assembly.CodeBase.Replace(@"file:///", ""));
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters(referencedAssemblies.ToArray(), output);
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(input))
{
if (stream == null)
{
throw new ArgumentException("input");
}
StreamReader reader = new StreamReader(stream);
string source = reader.ReadToEnd();
CompilerResults results = codeProvider.CompileAssemblyFromSource(cp, source);
ThrowIfCompilerError(results);
return results;
}
}
public void Execute(string scriptCode)
{
string[] source = new string[1];
source[0] = scriptCode;
CSharp.CSharpCodeProvider cscp = new CSharp.CSharpCodeProvider();
this.Compile(cscp, source[0]);
}
/// <summary>
/// get an Assembly according to wsdl path.
/// </summary>
/// <param name="wsdl">wsdl path</param>
/// <param name="nameSpace">namespace</param>
/// <returns>return Assembly</returns>
public static Assembly GetWebServiceAssembly(string wsdl, string nameSpace)
{
try
{
System.Net.WebClient webClient = new System.Net.WebClient();
System.IO.Stream webStream = webClient.OpenRead(wsdl);
ServiceDescription serviceDescription = ServiceDescription.Read(webStream);
ServiceDescriptionImporter serviceDescroptImporter = new ServiceDescriptionImporter();
serviceDescroptImporter.AddServiceDescription(serviceDescription, "", "");
System.CodeDom.CodeNamespace codeNameSpace = new System.CodeDom.CodeNamespace(nameSpace);
System.CodeDom.CodeCompileUnit codeCompileUnit = new System.CodeDom.CodeCompileUnit();
codeCompileUnit.Namespaces.Add(codeNameSpace);
serviceDescroptImporter.Import(codeNameSpace, codeCompileUnit);
System.CodeDom.Compiler.CodeDomProvider codeDom = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters codeParameters = new System.CodeDom.Compiler.CompilerParameters();
codeParameters.GenerateExecutable = false;
codeParameters.GenerateInMemory = true;
codeParameters.ReferencedAssemblies.Add("System.dll");
codeParameters.ReferencedAssemblies.Add("System.XML.dll");
codeParameters.ReferencedAssemblies.Add("System.Web.Services.dll");
codeParameters.ReferencedAssemblies.Add("System.Data.dll");
System.CodeDom.Compiler.CompilerResults compilerResults = codeDom.CompileAssemblyFromDom(codeParameters, codeCompileUnit);
return(compilerResults.CompiledAssembly);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
///
/// </summary>
/// <param name="url"></param>
public SIC_WebServiceAgent(string url)
{
XmlTextReader reader = new XmlTextReader(url + "?wsdl");
//创建和格式化 WSDL 文档
ServiceDescription sd = ServiceDescription.Read(reader);
//创建客户端代理代理类
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, null, null);
//使用 CodeDom 编译客户端代理类
CodeNamespace cn = new CodeNamespace(CODE_NAMESPACE);
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
Microsoft.CSharp.CSharpCodeProvider icc = new Microsoft.CSharp.CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
CompilerResults cr = icc.CompileAssemblyFromDom(cp, ccu);
agentType = cr.CompiledAssembly.GetTypes()[0];
Agent = Activator.CreateInstance(agentType);
}
/// <summary>
/// This method Parses and compiles the source code into an Assembly and returns it
/// </summary>
/// <param name="baseClassType">The Type of the Base class the generated class descends from</param>
/// <param name="namespaceOfGeneratedClass">The Namespace of the generated class</param>
/// <param name="generatedClassName">The Class Name of the generated class</param>
/// <param name="sourceCodeReader">A Text reader that is a warpper around the "Template" that is to be parsed and compiled</param>
/// <returns>An instance of a generated assembly that contains the generated class</returns>
public Assembly ParseAndCompileTemplate(Type baseClassType, string namespaceOfGeneratedClass, string generatedClassName, TextReader sourceCodeReader)
{
RazorTemplateEngine engine = InitializeRazorEngine(baseClassType, namespaceOfGeneratedClass, generatedClassName);
GeneratorResults razorResults = engine.GenerateCode(sourceCodeReader);
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CodeGeneratorOptions options = new CodeGeneratorOptions();
string generatedCode = null;
using (StringWriter writer = new StringWriter())
{
codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, writer, options);
generatedCode = writer.GetStringBuilder().ToString();
}
var outputAssemblyName = Path.GetTempPath() + Guid.NewGuid().ToString("N") + ".dll";
CompilerParameters compilerParameters = new CompilerParameters(new string[]{}, outputAssemblyName);
compilerParameters.ReferencedAssemblies.Add("System.dll");
compilerParameters.ReferencedAssemblies.Add("System.Core.dll");
compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().CodeBase.Substring(8));
compilerParameters.GenerateInMemory = false;
CompilerResults compilerResults = codeProvider.CompileAssemblyFromDom(compilerParameters, razorResults.GeneratedCode);
if (compilerResults.Errors.Count > 0)
{
var compileErrors = new StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError compileError in compilerResults.Errors)
compileErrors.Append(String.Format("Line: {0}\t Col: {1}\t Error: {2}\r\n", compileError.Line, compileError.Column, compileError.ErrorText));
throw new Exception(compileErrors.ToString() + generatedCode);
}
return compilerResults.CompiledAssembly;
}
public Expression(string expression)
{
CompilerParameters p = new CompilerParameters();
p.GenerateInMemory = true;
System.Text.RegularExpressions.MatchCollection mc = System.Text.RegularExpressions.Regex.Matches(expression, @"\{([^\}]*)\}");
string paramsStr = "";
for (int i = 0; i < mc.Count; i++)
{
string mcValue = mc[i].Value;
string mcGroupValue = mc[i].Groups[1].Value;
if (!ExpressionKey.Contains(mcGroupValue))
{
ExpressionKey.Add(mcGroupValue);
paramsStr += "double d" + i + ",";
expression = expression.Replace(mcValue, "d" + i);
}
}
this.ExpressionBody = expression;
paramsStr = paramsStr.TrimEnd(',');
string clsStr = String.Format("using System;sealed class Expression{{public double Compute({0}){{return {1};}}}}", paramsStr, expression);
CompilerResults cr = new CSharpCodeProvider().CompileAssemblyFromSource(p, clsStr);
if (cr.Errors.Count > 0)
{
string msg = "Expression(\"" + expression + "\"): \n";
foreach (CompilerError err in cr.Errors) msg += err.ToString() + "\n";
throw new Exception(msg);
}
instance = cr.CompiledAssembly.CreateInstance("Expression");
method = instance.GetType().GetMethod("Compute");
}
static void CompileAndRun(string code)
{
var csc = new CSharpCodeProvider();
var parameters = new CompilerParameters(new[] { "mscorlib.dll", "System.Core.dll" }, "teste.exe", true)
{
GenerateExecutable = true
};
CompilerResults compiledAssembly = csc.CompileAssemblyFromSource(parameters,
code);
var errors = compiledAssembly.Errors
.Cast<CompilerError>()
.ToList();
if (errors.Any())
{
errors.ForEach(Console.WriteLine);
return;
}
Module module = compiledAssembly.CompiledAssembly.GetModules()[0];
Type mt = null;
if (module != null)
mt = module.GetType("Program");
MethodInfo methInfo = null;
if (mt != null)
methInfo = mt.GetMethod("Main");
if (methInfo != null)
Console.WriteLine(methInfo.Invoke(null, null));
}
public static void RunTransformations(string userCode)
{
using (var codeProvider = new CSharpCodeProvider())
{
string code =
@"using Aitako.DSL;using System; using Aitako.DSL.Components;using System.Collections.Generic; public class Runner { public void Execute() { " +
userCode + " Service.Execute();}}";
CompilerResults compilerResult =
codeProvider.CompileAssemblyFromSource(
new CompilerParameters(new[] {"Aitako.DSL.dll"}) {GenerateInMemory = true}, code);
if (compilerResult.Errors.Count > 0)
{
foreach (object error in compilerResult.Errors)
{
Console.WriteLine(error.ToString());
}
return;
}
Type compiledType = compilerResult.CompiledAssembly.GetType("Runner");
object instance = Activator.CreateInstance(compiledType);
object output = compiledType.GetMethod("Execute").Invoke(instance, new object[] {});
Console.WriteLine(output);
}
}
public static void CompileIntoAssembly(string outputPath, IEnumerable<string> references, List<string> files)
{
CodeDomProvider provider = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters()
{
GenerateExecutable = false,
OutputAssembly = outputPath,
IncludeDebugInformation = true,
CompilerOptions = "/unsafe"
};
foreach (var @ref in references)
cp.ReferencedAssemblies.Add(@ref);
CompilerResults cr = provider.CompileAssemblyFromFile(cp, files.ToArray());
if (cr.Errors.HasErrors)
{
var message = new StringBuilder();
message.Append("Error compiling generated files.\n");
foreach(var error in cr.Errors)
message.AppendFormat(" {0}\n",error.ToString());
throw new Exception(message.ToString());
}
}
public static ICalc GetCalc(string csCode)
{
ICalc obj = null;
#if !NETCOREAPP3_0 && !NETSTANDARD2_0 && !NETSTANDARD2_1
using (Microsoft.CSharp.CSharpCodeProvider csProvider = new Microsoft.CSharp.CSharpCodeProvider())
{
var prm = new System.CodeDom.Compiler.CompilerParameters();
prm.GenerateInMemory = true;
prm.GenerateExecutable = false;
#if NET451 || NET471
prm.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
#endif
counter++;
// Implement the interface in the dynamic code
var res = csProvider.CompileAssemblyFromSource(prm,
String.Format(@"public class CompiledCalc{0} : ICalc { public Exception LastError { get; set; }
public object Calc() { {1} }}", counter, csCode));
var type = res.CompiledAssembly.GetType(string.Format("CompiledCalc{0}", counter));
try
{
obj = Activator.CreateInstance(type) as ICalc;
}
catch (Exception ex)
{
obj = obj ?? new CalcEmpty();
obj.LastError = ex;
}
}
#endif
return(obj);
}
public static string compilerte(string outputname, string sourcecode)
{
var codeProvider = new CSharpCodeProvider();
var provider = CodeDomProvider.CreateProvider("CSharp");
var exeName = outputname;
var cp = new CompilerParameters
{
GenerateExecutable = true,
OutputAssembly = exeName,
GenerateInMemory = false,
TreatWarningsAsErrors = false
};
var cr = provider.CompileAssemblyFromSource(cp, translatetocsharp(sourcecode));
if (cr.Errors.Count > 0)
{
var builder = new StringBuilder();
builder.Append("Cehape broke our codes that were supposed to be compiled here: " + cr.PathToAssembly);
foreach (CompilerError ce in cr.Errors)
{
builder.Append(Environment.NewLine + ce.ToString());
}
codeProvider.Dispose();
return builder.ToString();
}
else
{
codeProvider.Dispose();
return ("We were able to compile {0} successfully without cehape messing with it.".Replace("{0}", cr.PathToAssembly));
}
}
static Assembly CompileSettings(string inputFilePath)
{
string fileName = Path.GetFileNameWithoutExtension(inputFilePath);
string code = File.ReadAllText(inputFilePath);
code = "using SettingsCompiler;\r\n\r\n" + "namespace " + fileName + "\r\n{\r\n" + code;
code += "\r\n}";
Dictionary<string, string> compilerOpts = new Dictionary<string, string> { { "CompilerVersion", "v4.0" } };
CSharpCodeProvider compiler = new CSharpCodeProvider(compilerOpts);
string[] sources = { code };
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.GenerateInMemory = true;
compilerParams.ReferencedAssemblies.Add("System.dll");
compilerParams.ReferencedAssemblies.Add("SettingsCompilerAttributes.dll");
CompilerResults results = compiler.CompileAssemblyFromSource(compilerParams, sources);
if(results.Errors.HasErrors)
{
string errMsg = "Errors were returned from the C# compiler:\r\n\r\n";
foreach(CompilerError compilerError in results.Errors)
{
int lineNum = compilerError.Line - 4;
errMsg += inputFilePath + "(" + lineNum + "): " + compilerError.ErrorText + "\r\n";
}
throw new Exception(errMsg);
}
return results.CompiledAssembly;
}
private void GenerateHelper()
{
using (GenParamsForm gpf = new GenParamsForm())
{
gpf.Namespace = _rootCategory.Name;
if (gpf.ShowDialog(this) == DialogResult.OK)
{
CodeCompileUnit ccu = HelperGenerator.Generate(_rootCategory,
gpf.Namespace, gpf.IsInternal);
CSharpCodeProvider cscp = new CSharpCodeProvider();
CodeGeneratorOptions cgo = new CodeGeneratorOptions();
cgo.BracingStyle = "C";
using (StreamWriter sw = new StreamWriter(
Path.Combine(_directory, _rootCategory.TreeName + ".cs")))
cscp.GenerateCodeFromCompileUnit(ccu, sw, cgo);
if (gpf.ShowResult)
using (ShowResultForm srf = new ShowResultForm())
using (StringWriter strW = new StringWriter())
{
cscp.GenerateCodeFromCompileUnit(ccu, strW, cgo);
srf.Result = strW.ToString();
srf.ShowDialog(this);
}
}
}
}
/// <summary>
/// Compiles the srcipt and returns an evaluator (a delegate)
/// which takes in time and returns audioFrame values
/// </summary>
/// <returns>A delegate of type Func<double,double></returns>
public Func<double, double> Compile()
{
var codeProvider = new CSharpCodeProvider();
var compilerResults =
codeProvider.CompileAssemblyFromSource(
new CompilerParameters(new[] {"TuneItDynamicBase.dll"}) {GenerateInMemory = true},
@"
using System;
using TuneItDynamicBase;
public class DynamicCompiledScript : DynamicCompiledScriptBase
{
public override Func<double, double> Evaluator
{
get
{
return delegate(double time)
{"
+ script + @"
};
}
}
}
");
if (compilerResults.Errors.HasErrors)
{
return null;
}
var dynamicScriptInstance = (IDynamicScript) compilerResults.CompiledAssembly.CreateInstance("DynamicCompiledScript");
if (dynamicScriptInstance == null)
{
return null;
}
return dynamicScriptInstance.Evaluator;
}
protected static AssemblyDef CompileLegacy(string code, bool optimize, bool useDebug, int compilerVersion)
{
CSharpCodeProvider provider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v" + new Version(compilerVersion, 0) } });
CompilerParameters options = new CompilerParameters();
options.CompilerOptions = "/unsafe /o" + (optimize ? "+" : "-") + (useDebug ? " /debug" : "");
if (compilerVersion >= 4)
options.ReferencedAssemblies.Add("System.Core.dll");
CompilerResults results = provider.CompileAssemblyFromSource(options, code);
try
{
if (results.Errors.Count > 0)
{
StringBuilder b = new StringBuilder("Compiler error:");
foreach (var error in results.Errors)
{
b.AppendLine(error.ToString());
}
throw new Exception(b.ToString());
}
return Utils.OpenAssembly(results.PathToAssembly);
}
finally
{
File.Delete(results.PathToAssembly);
results.TempFiles.Delete();
}
}
internal static void MainThreadEntry(object state)
{
var args = (string[])state;
if (args.Length < 2)
throw new Exception("Dunno what to run.");
var appDirectory = Path.GetFullPath(args[1]);
var appFile = Path.Combine(appDirectory, "App.cs");
var appConfigFile = Path.Combine(appDirectory, "BlazeApp.json.config");
if (!File.Exists(appConfigFile))
throw new Exception("App configuration file was not found.");
if (!File.Exists(appFile))
throw new Exception("No app entry found.");
var appConfigFileContent = File.ReadAllText(appConfigFile);
var appConfig = JsonConvert.DeserializeObject<AppConfiguration>(appConfigFileContent);
var tempAssemblyPath = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
var codeProvider = new CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", appConfig.CompilerVersion } });
var compilerParameters = new CompilerParameters(appConfig.References, tempAssemblyPath, false)
{
GenerateInMemory = true
};
var compilerResult = codeProvider.CompileAssemblyFromFile(compilerParameters, new[] { appFile });
if (compilerResult.Errors.Count > 0)
throw new Exception("There were errors during compilation.");
// TODO: Invoke compiled entry method -- http://stackoverflow.com/questions/14479074/c-sharp-reflection-load-assembly-and-invoke-a-method-if-it-exists
}
public static CompilerResults Compile(this DirectoryInfo[] compileTargets, string fileName, string[] referenceAssemblies, bool executable)
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = executable;
parameters.OutputAssembly = fileName;
List<string> compilerOptions = new List<string>();
foreach (string referenceAssembly in referenceAssemblies)
{
compilerOptions.Add("/reference:" + referenceAssembly);
}
parameters.CompilerOptions = compilerOptions.ToArray().ToDelimited(" ");
List<string> fileNames = new List<string>();
foreach (DirectoryInfo targetDirectory in compileTargets)
{
foreach (FileInfo fileInfo in FsUtil.GetFilesWithExtension(targetDirectory.FullName, ".cs"))
{
fileNames.Add(fileInfo.FullName);
}
}
return codeProvider.CompileAssemblyFromFile(parameters, fileNames.ToArray());//.CompileAssemblyFromFileBatch(parameters, fileNames.ToArray());
}
static void Main(string[] args)
{
// Output some program information using Console.WriteLine.
Console.WriteLine("This program compiles a CodeDOM program that incorrectly declares multiple data");
Console.WriteLine("types to demonstrate handling compiler errors programmatically.");
Console.WriteLine("");
// Compile the CodeCompileUnit retrieved from the GetCompileUnit() method.
CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider();
// Initialize a CompilerParameters with the options for compilation.
string[] assemblies = new String[] { "System.dll" };
CompilerParameters options = new CompilerParameters(assemblies, "output.exe");
// Compile the CodeDOM graph and store the results in a CompilerResults.
CompilerResults results = provider.CompileAssemblyFromDom(options, GetCompileUnit());
// Compilation produces errors. Print out each error.
Console.WriteLine("Listing errors from compilation: ");
Console.WriteLine("");
for (int i = 0; i < results.Errors.Count; i++)
{
Console.WriteLine(results.Errors[i].ToString());
}
}
public void PostProcessGeneratedCodeAddsApplicationInstanceProperty() {
const string expectedPropertyCode = @"
protected Foo.Bar ApplicationInstance {
get {
return ((Foo.Bar)(Context.ApplicationInstance));
}
}
";
// Arrange
CodeCompileUnit generatedCode = new CodeCompileUnit();
CodeNamespace generatedNamespace = new CodeNamespace();
CodeTypeDeclaration generatedClass = new CodeTypeDeclaration();
CodeMemberMethod executeMethod = new CodeMemberMethod();
WebPageRazorHost host = new WebPageRazorHost("Foo.cshtml") {
GlobalAsaxTypeName = "Foo.Bar"
};
// Act
host.PostProcessGeneratedCode(generatedCode, generatedNamespace, generatedClass, executeMethod);
// Assert
CodeMemberProperty property = generatedClass.Members[0] as CodeMemberProperty;
Assert.IsNotNull(property);
CSharpCodeProvider provider = new CSharpCodeProvider();
StringBuilder builder = new StringBuilder();
using(StringWriter writer = new StringWriter(builder)) {
provider.GenerateCodeFromMember(property, writer, new CodeDom.Compiler.CodeGeneratorOptions());
}
Assert.AreEqual(expectedPropertyCode, builder.ToString());
}
public static String GenerateCSharpCode(CodeCompileUnit compileunit)
{
// Generate the code with the C# code provider.
CSharpCodeProvider provider = new CSharpCodeProvider();
// Build the output file name.
String sourceFile;
if (provider.FileExtension[0] == '.')
{
sourceFile = "HelloWorld" + provider.FileExtension;
}
else
{
sourceFile = "HelloWorld." + provider.FileExtension;
}
// Create a TextWriter to a StreamWriter to the output file.
IndentedTextWriter tw = new IndentedTextWriter(
new StreamWriter(sourceFile, false), " ");
// Generate source code using the code provider.
provider.GenerateCodeFromCompileUnit(compileunit, tw,
new CodeGeneratorOptions());
// Close the output file.
tw.Close();
return sourceFile;
}
private static Assembly Compile(CodeCompileUnit codeCompileUnit)
{
var compilerParameters = new CompilerParameters();
compilerParameters.GenerateInMemory = true;
compilerParameters.ReferencedAssemblies.Add("System.dll");
compilerParameters.ReferencedAssemblies.Add("System.Core.dll");
compilerParameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().CodeBase.Substring(8));
var codeProvider = new CSharpCodeProvider();
var result = codeProvider.CompileAssemblyFromDom(compilerParameters, codeCompileUnit);
if (result.Errors.HasErrors)
{
foreach (var error in result.Errors)
{
Console.WriteLine(error);
}
return null;
}
return result.CompiledAssembly;
}
public void CanCreateDataTableAssignment()
{
CodeNamespace nsdecl = new CodeNamespace("My.Data");
CodeTypeDeclaration cdecl = new CodeTypeDeclaration("ResultSet");
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "GetData";
method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
method.ReturnType = new CodeTypeReference("System.Data.DataTable");
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "name"));
method.Statements.Add(new CodeVariableDeclarationStatement(
typeof(DataTable),
"result",
new CodeObjectCreateExpression(typeof(DataTable))));
cdecl.Members.Add(method);
method.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(DataColumnCollection),
"columns",
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("result"),
"Columns")));
method.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("columns"), "Add", new CodeTypeOfExpression(typeof(string)), new CodeSnippetExpression("name")));
nsdecl.Types.Add(cdecl);
CSharpCodeProvider provider = new CSharpCodeProvider();
provider.GenerateCodeFromNamespace(nsdecl, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions());
}
public string CreateExe(string exeName, string sourceString)
{
Directory.CreateDirectory(this.ExeDirectory);
var outputExePath = this.ExeDirectory + exeName;
if (File.Exists(outputExePath))
{
File.Delete(outputExePath);
}
var codeProvider = new CSharpCodeProvider();
var parameters = new CompilerParameters
{
GenerateExecutable = true,
OutputAssembly = outputExePath,
};
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
CompilerResults results = codeProvider.CompileAssemblyFromSource(parameters, sourceString);
foreach (var error in results.Errors)
{
Console.WriteLine(error.ToString());
}
Assert.IsFalse(results.Errors.HasErrors, "Code compilation contains errors!");
return outputExePath;
}
public IRazorHost CreateHost(string fullPath, string projectRelativePath)
{
using (var codeDomProvider = new CSharpCodeProvider())
{
return CreateHost(fullPath, projectRelativePath, codeDomProvider);
}
}
private static Assembly BuildAssembly(string code)
{
CSharpCodeProvider provider =
new CSharpCodeProvider();
ICodeCompiler compiler = provider.CreateCompiler();
CompilerParameters compilerparams = new CompilerParameters();
compilerparams.GenerateExecutable = false;
compilerparams.GenerateInMemory = true;
compilerparams.ReferencedAssemblies.Add("PageTypeBuilder.dll");
compilerparams.ReferencedAssemblies.Add("PageTypeBuilder.Migrations.dll");
CompilerResults results =
compiler.CompileAssemblyFromSource(compilerparams, code);
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
{
return results.CompiledAssembly;
}
}
public static void compileSource()
{
//UNDER CONSTRUCTION
string source = @"
namespace Foo
{
public class Bar
{
public void SayHello()
{
System.Console.WriteLine(""Hello World"");
}
}
}
";
Dictionary<string, string> providerOptions = new Dictionary<string, string>
{
{"CompilerVersion", "v4" }
};
CSharpCodeProvider provider = new CSharpCodeProvider(providerOptions);
CompilerParameters compilerParams = new CompilerParameters
{GenerateInMemory = true,
GenerateExecutable = false};
CompilerResults results = provider.CompileAssemblyFromSource(compilerParams, source);
if (results.Errors.Count != 0)
throw new Exception("Mission Failed");
object o = results.CompiledAssembly.CreateInstance("Foo.Bar");
MethodInfo mi = o.GetType().GetMethod("SayHello");
mi.Invoke(o, null);
}
static void Main(string[] args)
{
Uri wsdlLocation = new Uri(Directory.GetCurrentDirectory() + "\\..\\..\\..\\OrderService.wsdl");
Console.WriteLine("Beginning schema import.");
Console.WriteLine();
DiscoveryClientProtocol client = new DiscoveryClientProtocol();
client.AllowAutoRedirect = true;
DiscoveryDocument doc = client.DiscoverAny(wsdlLocation.ToString());
client.ResolveAll();
WebReferenceCollection references = new WebReferenceCollection();
//add 1st web reference document
WebReference wr = new WebReference(client.Documents, new CodeNamespace("Microsoft.Samples"));
references.Add(wr);
//add other web reference documents if needed
CodeDomProvider codeProvider = new
Microsoft.CSharp.CSharpCodeProvider();
CodeCompileUnit Ccu = new CodeCompileUnit();
Ccu.Namespaces.Add(wr.ProxyCode);
try
{
//This is the new API call
ServiceDescriptionImporter.GenerateWebReferences(
references,
codeProvider, Ccu, new WebReferenceOptions());
}
catch (Exception ex)
{
//do exception handling
Console.WriteLine("An exception occured during importation:\n {0}", ex.ToString());
}
StreamWriter writer = new StreamWriter("OrderProxy.cs", false,
new System.Text.UTF8Encoding(true));
codeProvider.GenerateCodeFromCompileUnit(Ccu, writer, new CodeGeneratorOptions());
writer.Close();
// importer.Import(new CodeNamespace("Microsoft.Samples"), compileUnit);
Console.WriteLine();
Console.WriteLine("Schema import completed.");
//reader.Close();
Console.WriteLine("Finished. Press any key to continue...");
Console.ReadLine();
System.Diagnostics.Process.Start("notepad", "OrderProxy.cs");
}
public static object WebserviceInvoke(string p_strUrl, string p_strNameSpace, string p_strClassName, string p_strMethodName, object[] p_objArgs)
{
object oReturnValue = null;
try
{
if (p_strNameSpace == "")
{
p_strNameSpace = "EnterpriseServerBase.WebService.DynamicWebCalling";
}
if (p_strClassName == "")
{
p_strClassName = WebServiceHelper.GetWsClassName(p_strUrl);
}
System.Net.WebClient wc = new System.Net.WebClient();
System.IO.Stream stream = wc.OpenRead(p_strUrl + "?wsdl");
System.Web.Services.Description.ServiceDescription sd = System.Web.Services.Description.ServiceDescription.Read(stream);
System.Web.Services.Description.ServiceDescriptionImporter sdi = new System.Web.Services.Description.ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
System.CodeDom.CodeNamespace cn = new System.CodeDom.CodeNamespace(p_strNameSpace);
System.CodeDom.CodeCompileUnit ccu = new System.CodeDom.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 (true == cr.Errors.HasErrors)
{
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(p_strNameSpace + "." + p_strClassName, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(p_strMethodName);
oReturnValue = mi.Invoke(obj, p_objArgs);
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
}
return(oReturnValue);
}
/// <summary>
/// Executes the processed code from Process() function.
/// </summary>
/// <param name="errors">If execution was not successful, returns CompilerErrorCollection or Exception</param>
/// <returns>Values to put in each code segment (output) or null if there were errors</returns>
public string[] Execute(out object errors)
{
errors = null;
segmentsOutput = new string[segmentNum];
for (int i = 0; i < segmentNum; i++)
{
segmentsOutput[i] = "";
}
segmentNum = -1;
CSHARP.CSharpCodeProvider provider = new CSHARP.CSharpCodeProvider();
CompilerParameters parms = new CompilerParameters();
parms.GenerateInMemory = true;
parms.TreatWarningsAsErrors = false;
parms.TempFiles = new TempFileCollection(Environment.GetEnvironmentVariable("TEMP"), true);
parms.IncludeDebugInformation = true;
parms.ReferencedAssemblies.Add(Assembly.GetEntryAssembly().Location);
try
{
string[] assms = File.ReadAllText(ConfigurationManager.SETTINGS["ASSEMBLIES"]).Split(new char[] { '\n' });
for (int i = 0; i < assms.Length; i++)
{
parms.ReferencedAssemblies.Add(assms[i].Trim());
}
}
catch { }
CompilerResults res = provider.CompileAssemblyFromSource(parms, FinalCode);
if (res.Errors.HasErrors) // Handling compiler errors
{
errors = res.Errors;
return(null);
}
Assembly ass = res.CompiledAssembly;
Type prog = ass.GetType("LWASP_Console.WebApp");
MethodInfo main = prog.GetMethod("Rain");
try
{
main.Invoke(null, new object[] { connection, connection.queryString, connection.formData, connection.PostData() });
}
catch (Exception exx)
{
errors = exx != null ? exx.InnerException ?? exx : new Exception("LWASP Error");
return(null);
}
return(segmentsOutput);
}
private String GenerateDll()
{
String csName = "ConfigCommon.cs";
if (!File.Exists(csName))
{
return(String.Empty);
}
String dllName = csName.Substring(0, csName.LastIndexOf(".")) + ".dll";
CodeDomProvider codeDomProvider = new Microsoft.CSharp.CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = false;
parameters.OutputAssembly = dllName;
parameters.GenerateExecutable = false;
parameters.GenerateInMemory = true;
parameters.ReferencedAssemblies.Add("mscorlib.dll");
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add("protobuf-net.dll");
try
{
CompilerResults results = codeDomProvider.CompileAssemblyFromFile(parameters, csName);
if (results.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
sb.AppendLine(String.Format("Error ({0}): {1}", error.ErrorNumber, error.ErrorText));
}
return(String.Empty);
}
}
catch (System.Exception)
{
return(String.Empty);
}
return(dllName);
}
void downloadJob_OnJobTransferredEvent(object sender, JobNotificationEventArgs e)
{
try {
// complete the job
_downloadJob.Complete();
CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider();
ICodeCompiler compiler = provider.CreateCompiler();
CompilerParameters cpar = new CompilerParameters();
cpar.GenerateInMemory = true;
cpar.GenerateExecutable = false;
cpar.ReferencedAssemblies.Add(
Process.GetCurrentProcess().MainModule.FileName
);
cpar.ReferencedAssemblies.Add("System.dll");
cpar.ReferencedAssemblies.Add("System.Drawing.dll");
cpar.ReferencedAssemblies.Add("System.Windows.Forms.dll");
cpar.ReferencedAssemblies.Add("RSIWarrior.Common.dll");
cpar.ReferencedAssemblies.Add("RSIWarrior.AutoUpdate.dll");
CompilerResults cres = compiler.CompileAssemblyFromFile(
cpar,
LocalPatchFile
);
foreach (CompilerError ce in cres.Errors)
{
throw new Exception(ce.ErrorText);
}
if (cres.Errors.Count == 0 && cres.CompiledAssembly != null)
{
Type[] exportedTypes = cres.CompiledAssembly.GetExportedTypes();
foreach (Type type in exportedTypes)
{
if (type.GetInterface("RSIWarrior.AutoUpdate.IPatch") != null &&
!type.IsAbstract)
{
IPatch patch = (IPatch)Activator.CreateInstance(type);
patch.Execute();
}
}
}
} catch (Exception ex) {
} finally {
try {
File.Delete(LocalPatchFile);
} catch {
}
}
}
public static object InvokeWebService(string url, string @namespace, string classname, string methodname, object[] args)
{
try
{
System.Net.WebClient wc = new System.Net.WebClient();
System.IO.Stream stream = wc.OpenRead(url + "?WSDL");
System.Web.Services.Description.ServiceDescription sd = System.Web.Services.Description.ServiceDescription.Read(stream);
System.Web.Services.Description.ServiceDescriptionImporter sdi = new System.Web.Services.Description.ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
System.CodeDom.CodeNamespace cn = new System.CodeDom.CodeNamespace(@namespace);
System.CodeDom.CodeCompileUnit ccu = new System.CodeDom.CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
Microsoft.CSharp.CSharpCodeProvider csc = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.ICodeCompiler icc = csc.CreateCompiler();
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 = icc.CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
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(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(methodname);
return(mi.Invoke(obj, args));
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
}
}
/// <summary>
/// Compile the sharp code in SourceString and link it with the assemblies
/// provided in the parameter LinkedAssemblies
/// </summary>
/// <param name="SourceString">the code to compile as string</param>
/// <param name="LinkedAssemblies">assemblies to link with separated by semi-column ';'</param>
/// <returns>true if success, else false and you can call GetLastError</returns>
public bool Compile(string SourceString, string LinkedAssemblies)
{
CodeDomProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = false;
// add the linked assemblies
foreach (string assembly in LinkedAssemblies.Split(';'))
{
parameters.ReferencedAssemblies.Add(assembly);
}
// compile
CompilerResults results = codeProvider.CompileAssemblyFromSource(parameters, SourceString);
//if errors
if (results.Errors.Count > 0)
{
_ErrorMsg = new StringBuilder();
// append all errors
foreach (CompilerError CompErr in results.Errors)
{
_ErrorMsg.AppendFormat("Line: {0} , Code: {1}, Msg: {2}",
CompErr.Line, CompErr.ErrorNumber, CompErr.ErrorText);
Tracer.Error("CSharpCodeCompiler", "Line: {0} , Code: {1}, Msg {2}", CompErr.Line, CompErr.ErrorNumber, CompErr.ErrorText);
//EventManager.Instance.SendMessage(SourceString);
}
}
if (results.Errors.Count == 0 && results.CompiledAssembly != null)
{
_assembly = results.CompiledAssembly;
return(true);
}
else
{
return(false);
}
}
protected virtual CodeDomProvider GetCodeProvider(string fileName)
{
CodeDomProvider provider = null;
string extension = Path.GetExtension(fileName);
if (String.Compare(extension, ".cs", true) == 0)
{
provider = new Microsoft.CSharp.CSharpCodeProvider();
}
else if (String.Compare(extension, ".vb", true) == 0)
{
provider = new Microsoft.VisualBasic.VBCodeProvider();
}
else
{
throw new InvalidOperationException("Programming language not supported for:" + fileName);
}
return(provider);
}
public void SaveDesignerClass(string outdir, string className, string ns)
{
var designerCsPath = Path.Combine(outdir, $"{className}.Designer.cs");
string[] errors;
var codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
var data = _data.ToDictionary(d => d.Key, d => d.Value.Value);
var code = StronglyTypedResourceBuilder.Create(data, className, ns, codeProvider, false, out errors);
if (errors.Length > 0)
{
foreach (var error in errors)
{
Console.WriteLine(error);
}
}
using (StreamWriter writer = new StreamWriter(designerCsPath, false, System.Text.Encoding.UTF8))
{
codeProvider.GenerateCodeFromCompileUnit(code, writer, new CodeGeneratorOptions());
}
}
private Type CreateType(string className, string codeFragment, string statement)
{
CompilerParameters compilerParameters = CreateCompilerParameters();
statement = String.Format("{0}{2}{1}", BuildNameSpaces(), statement, Environment.NewLine);
CodeDomProvider codeDomProvider = null;
switch (_language)
{
case ChoCodeProviderLanguage.VB:
codeDomProvider = new Microsoft.VisualBasic.VBCodeProvider();
break;
default:
codeDomProvider = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
using (codeDomProvider)
{
var res = codeDomProvider.CompileAssemblyFromSource(compilerParameters, statement);
if (res.Errors.Count > 0)
{
StringBuilder errors = new StringBuilder();
foreach (CompilerError CompErr in res.Errors)
{
errors.AppendFormat("Line number {0}, Error Number: {1}, {2}{3}", CompErr.Line, CompErr.ErrorNumber, CompErr.ErrorText, Environment.NewLine);
}
throw new ApplicationException("Exception compiling code fragment: {1}{1}{0}{1}{1}Exceptions:{1}{2}".FormatString(
codeFragment.Indent(1), Environment.NewLine, errors.ToString().Indent(1)));
}
return(res.CompiledAssembly.GetType(className));
}
}
public CodeCompileUnit ConvertToCodeComlieUnit(String strText)
{
TextReader inputstream = new StringReader(strText);
#region New
//CSharpParser parser=new CSharpParser();
//CompilationUnit compilationUnit=parser.Parse( inputstream , @"D:\bbb.cs" );
//IProjectContent project=new CSharpProjectContent();
//var parsedFile=compilationUnit.ToTypeSystem();
//project=project.UpdateProjectContent( null , parsedFile );
//project=project.AddAssemblyReferences( builtInLibs.Value );
//ICompilation compilation=project.CreateCompilation();
//CodeCompileUnit cUnit=new CodeDomConvertVisitor().Convert( compilation , compilationUnit , parsedFile );
////// Remove Unsed Namespaces
//for ( int i=cUnit.Namespaces.Count-1; i>=0; i-- )
//{
// if ( cUnit.Namespaces[i].Types.Count==0 )
// cUnit.Namespaces.RemoveAt( i );
//}
//return cUnit;
#endregion
#region Old
ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, inputstream);
parser.ParseMethodBodies = true;
parser.Lexer.SkipAllComments = false;
parser.Parse();
if (parser.Errors.Count > 0)
{
return(null);
}
//foreach ( var node in parser.CompilationUnit.Children )
//{
// // fix StartLocation / EndLocation
// node.AcceptVisitor( new ICSharpCode.NRefactory.Visitors.SetRegionInclusionVisitor() , null );
//}
CodeDomProvider codeDomProvider = new Microsoft.CSharp.CSharpCodeProvider();
CodeDomVisitor visit = new CodeDomVisitor();
visit.VisitCompilationUnit(parser.CompilationUnit, null);
// Remove Unsed Namespaces
for (int i = visit.codeCompileUnit.Namespaces.Count - 1; i >= 0; i--)
{
if (visit.codeCompileUnit.Namespaces[i].Types.Count == 0)
{
visit.codeCompileUnit.Namespaces.RemoveAt(i);
}
}
return(visit.codeCompileUnit);
#endregion
}
/// <summary>
/// Loads all content from a folder hierarchy (overlaying anything already existing)
/// </summary>
/// <param name="project"></param>
/// <param name="path"></param>
public static void LoadFolder(DocProject project, string path)
{
// get all files within folder hierarchy
string pathSchema = path + @"\schemas";
IEnumerable <string> en = System.IO.Directory.EnumerateFiles(pathSchema, "*.cs", System.IO.SearchOption.AllDirectories);
List <string> list = new List <string>();
foreach (string s in en)
{
list.Add(s);
}
string[] files = list.ToArray();
Dictionary <string, string> options = new Dictionary <string, string> {
{ "CompilerVersion", "v4.0" }
};
Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider(options);
System.CodeDom.Compiler.CompilerParameters parms = new System.CodeDom.Compiler.CompilerParameters();
parms.GenerateInMemory = true;
parms.GenerateExecutable = false;
parms.ReferencedAssemblies.Add("System.dll");
parms.ReferencedAssemblies.Add("System.Core.dll");
parms.ReferencedAssemblies.Add("System.ComponentModel.dll");
parms.ReferencedAssemblies.Add("System.ComponentModel.DataAnnotations.dll");
parms.ReferencedAssemblies.Add("System.Data.dll");
parms.ReferencedAssemblies.Add("System.Runtime.Serialization.dll");
parms.ReferencedAssemblies.Add("System.Xml.dll");
System.CodeDom.Compiler.CompilerResults results = prov.CompileAssemblyFromFile(parms, files);
System.Reflection.Assembly assem = results.CompiledAssembly;
LoadAssembly(project, assem);
// EXPRESS rules (eventually in C#, though .exp file snippets for now)
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.exp", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string name = Path.GetFileNameWithoutExtension(file);
string expr = null;
using (StreamReader readExpr = new StreamReader(file, Encoding.UTF8))
{
if (name.Contains('-'))
{
// where rule
expr = readExpr.ReadToEnd();
}
else
{
// function: skip first and last lines
readExpr.ReadLine();
StringBuilder sbExpr = new StringBuilder();
while (!readExpr.EndOfStream)
{
string line = readExpr.ReadLine();
if (!readExpr.EndOfStream)
{
sbExpr.AppendLine(line);
}
}
expr = sbExpr.ToString();
}
}
if (name.Contains('-'))
{
// where rule
string[] parts = name.Split('-');
if (parts.Length == 2)
{
DocWhereRule docWhere = new DocWhereRule();
docWhere.Name = parts[1];
docWhere.Expression = expr;
DocDefinition docDef = project.GetDefinition(parts[0]);
if (docDef is DocEntity)
{
DocEntity docEnt = (DocEntity)docDef;
docEnt.WhereRules.Add(docWhere);
}
else if (docDef is DocDefined)
{
DocDefined docEnt = (DocDefined)docDef;
docEnt.WhereRules.Add(docWhere);
}
else if (docDef == null)
{
//... global rule...
}
}
}
else
{
// function
string schema = Path.GetDirectoryName(file);
schema = Path.GetDirectoryName(schema);
schema = Path.GetFileName(schema);
DocSchema docSchema = project.GetSchema(schema);
if (docSchema != null)
{
DocFunction docFunction = new DocFunction();
docSchema.Functions.Add(docFunction);
docFunction.Name = name;
docFunction.Expression = expr;
}
}
}
// now, hook up html documentation
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.htm", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string name = Path.GetFileNameWithoutExtension(file);
DocObject docObj = null;
if (name == "schema")
{
string schema = Path.GetDirectoryName(file);
schema = Path.GetFileName(schema);
docObj = project.GetSchema(schema);
}
else if (name.Contains('-'))
{
// where rule
string[] parts = name.Split('-');
if (parts.Length == 2)
{
DocDefinition docDef = project.GetDefinition(parts[0]);
if (docDef is DocEntity)
{
DocEntity docEnt = (DocEntity)docDef;
foreach (DocWhereRule docWhereRule in docEnt.WhereRules)
{
if (docWhereRule.Name.Equals(parts[1]))
{
docObj = docWhereRule;
break;
}
}
}
else if (docDef is DocDefined)
{
DocDefined docEnt = (DocDefined)docDef;
foreach (DocWhereRule docWhereRule in docEnt.WhereRules)
{
if (docWhereRule.Name.Equals(parts[1]))
{
docObj = docWhereRule;
break;
}
}
}
}
}
else
{
docObj = project.GetDefinition(name);
if (docObj == null)
{
docObj = project.GetFunction(name);
}
}
if (docObj != null)
{
using (StreamReader readHtml = new StreamReader(file, Encoding.UTF8))
{
docObj.Documentation = readHtml.ReadToEnd();
}
}
}
// load schema diagrams
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.svg", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string schema = Path.GetDirectoryName(file);
schema = Path.GetFileName(schema);
DocSchema docSchema = project.GetSchema(schema);
if (docSchema != null)
{
using (IfcDoc.Schema.SVG.SchemaSVG schemaSVG = new IfcDoc.Schema.SVG.SchemaSVG(file, docSchema, project, DiagramFormat.UML))
{
schemaSVG.Load();
}
}
}
// psets, qsets
//...
// exchanges
en = System.IO.Directory.EnumerateFiles(path, "*.mvdxml", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
IfcDoc.Schema.MVD.SchemaMVD.Load(project, file);
}
// examples
string pathExamples = path + @"\examples";
if (Directory.Exists(pathExamples))
{
en = System.IO.Directory.EnumerateFiles(pathExamples, "*.htm", SearchOption.TopDirectoryOnly);
foreach (string file in en)
{
DocExample docExample = new DocExample();
docExample.Name = Path.GetFileNameWithoutExtension(file);
project.Examples.Add(docExample);
using (StreamReader reader = new StreamReader(file))
{
docExample.Documentation = reader.ReadToEnd();
}
string dirpath = file.Substring(0, file.Length - 4);
if (Directory.Exists(dirpath))
{
IEnumerable <string> suben = System.IO.Directory.EnumerateFiles(dirpath, "*.ifc", SearchOption.TopDirectoryOnly);
foreach (string ex in suben)
{
DocExample docEx = new DocExample();
docEx.Name = Path.GetFileNameWithoutExtension(ex);
docExample.Examples.Add(docEx);
// read the content of the file
using (FileStream fs = new FileStream(ex, FileMode.Open, FileAccess.Read))
{
docEx.File = new byte[fs.Length];
fs.Read(docEx.File, 0, docEx.File.Length);
}
// read documentation
string exdoc = ex.Substring(0, ex.Length - 4) + ".htm";
if (File.Exists(exdoc))
{
using (StreamReader reader = new StreamReader(exdoc))
{
docEx.Documentation = reader.ReadToEnd();
}
}
}
}
}
}
// localization
en = System.IO.Directory.EnumerateFiles(path, "*.txt", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
using (FormatCSV format = new FormatCSV(file))
{
try
{
format.Instance = project;
format.Load();
}
catch
{
}
}
}
}
private void btnCompileRun_Click(object sender, EventArgs e)
{
string code = null;
code += "using System;\r\n";
code += "using TextIndex;\r\n";
code += "using System.Collections;\r\n";
code += "using System.Data;\r\n";
code += "public class TestParser : SiteParser{ ";
code += " public override string Parse(HtmlDocument document) { ";
code += " " + textCode.Text;
code += " } ";
code += "}";
// CodeDOM'dan C# compiler'ı elde edelim
Microsoft.CSharp.CSharpCodeProvider cp = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.ICodeCompiler ic = cp.CreateCompiler();
// compiler parametrelerini ayarlayalım
System.CodeDom.Compiler.CompilerParameters cpar = new System.CodeDom.Compiler.CompilerParameters();
cpar.GenerateInMemory = true;
cpar.GenerateExecutable = false;
cpar.ReferencedAssemblies.Add("system.dll");
cpar.ReferencedAssemblies.Add("System.Drawing.dll");
cpar.ReferencedAssemblies.Add("System.Windows.Forms.dll");
cpar.ReferencedAssemblies.Add("System.Data.dll");
cpar.ReferencedAssemblies.Add(Application.ExecutablePath);
// kodu derletim ve sonuçları alalım
System.CodeDom.Compiler.CompilerResults cr = ic.CompileAssemblyFromSource(cpar, code);
// eğer derleme hatası varsa bu hataları bir bir gösterelim.
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
// hata mesajı, hatanın oluştuğu satır, önceki üç satır ve sonraki üç satırı içeren
// bir hata mesajı hazırlayalım.
string[] srcArr = code.Split('\n');
string errMessage = ce.ErrorText + " at line " + (ce.Line - 1) + "\n\n";
for (int i = ce.Line - 3; i < ce.Line + 3; i++)
{
if (i < 0 || i >= srcArr.Length)
{
continue;
}
errMessage += i + " " + srcArr[i] + "\n";
}
// hatayı gösterelim
MessageBox.Show(errMessage);
return;
}
// kod hatasız derlendiyse test işlemlerine başlayalım.
if (cr.Errors.Count == 0 && cr.CompiledAssembly != null)
{
// test edilecek iki koda (sınıfa) ait tipleri elde edelim.
Type type = cr.CompiledAssembly.GetType("TestParser");
try
{
SiteParser parser = (SiteParser)Activator.CreateInstance(type);
string result = parser.Parse(document);
textBox2.Text = result;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
public static void TestSpecific(string str, object[] result)
{
Protocol protocol = Protocol.Parse(str);
var codegen = new CodeGen();
codegen.AddProtocol(protocol);
var compileUnit = codegen.GenerateCode();
// add a constructor to the main class using the passed assignment statements
CodeTypeDeclaration ctd = compileUnit.Namespaces[0].Types[(int)result[0]];
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public;
CodeSnippetExpression snippet = new CodeSnippetExpression((string)result[2]);
constructor.Statements.Add(snippet);
ctd.Members.Add(constructor);
// compile
var comparam = new CompilerParameters(new string[] { "mscorlib.dll" });
comparam.ReferencedAssemblies.Add("System.dll");
comparam.ReferencedAssemblies.Add("System.Core.dll");
comparam.ReferencedAssemblies.Add(Type.GetType("Mono.Runtime") != null ? "Mono.CSharp.dll" : "Microsoft.CSharp.dll");
comparam.ReferencedAssemblies.Add("Avro.dll");
comparam.GenerateInMemory = true;
var ccp = new Microsoft.CSharp.CSharpCodeProvider();
var units = new CodeCompileUnit[] { compileUnit };
var compres = ccp.CompileAssemblyFromDom(comparam, units);
if (compres == null || compres.Errors.Count > 0)
{
for (int i = 0; i < compres.Errors.Count; i++)
{
Console.WriteLine(compres.Errors[i]);
}
}
if (null != compres)
{
Assert.IsTrue(compres.Errors.Count == 0);
}
// create record
ISpecificRecord rec = compres.CompiledAssembly.CreateInstance((string)result[1]) as ISpecificRecord;
Assert.IsFalse(rec == null);
// serialize
var stream = new MemoryStream();
var binEncoder = new BinaryEncoder(stream);
var writer = new SpecificDefaultWriter(rec.Schema);
writer.Write(rec.Schema, rec, binEncoder);
// deserialize
stream.Position = 0;
var decoder = new BinaryDecoder(stream);
var reader = new SpecificDefaultReader(rec.Schema, rec.Schema);
var rec2 = (ISpecificRecord)reader.Read(null, rec.Schema, rec.Schema, decoder);
Assert.IsFalse(rec2 == null);
}
public static object GetDbInfo(System.Data.DataSet ds)
{
// Get a code provider object.
System.CodeDom.Compiler.CodeDomProvider cdp = new Microsoft.CSharp.CSharpCodeProvider();
// Create the namespace and import the default "System" namespace.
System.CodeDom.CodeNamespace nmspc = new System.CodeDom.CodeNamespace("DataExplorer");
nmspc.Imports.Add(new System.CodeDom.CodeNamespaceImport("System"));
nmspc.Imports.Add(new System.CodeDom.CodeNamespaceImport("System.ComponentModel"));
// Create a class object.
System.CodeDom.CodeTypeDeclaration clsDbInfo = new System.CodeDom.CodeTypeDeclaration("DbInfo");
clsDbInfo.IsClass = true;
nmspc.Types.Add(clsDbInfo);
// Add fields to the class for each value returned.
List <string> fldNms = new List <string>();
for (int i = 0; i < ds.Tables.Count; i++)
{
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
{
string fldNm = "_" + ds.Tables[i].Columns[j].ColumnName.ToLower();
if (!fldNms.Contains(fldNm))
{
System.CodeDom.CodeMemberField fld = new System.CodeDom.CodeMemberField(typeof(System.String), fldNm);
fld.Attributes = System.CodeDom.MemberAttributes.Public;
clsDbInfo.Members.Add(fld);
fldNms.Add(fldNm);
}
}
}
// Add properties for the class to access each field.
List <string> propNms = new List <string>();
for (int i = 0; i < ds.Tables.Count; i++)
{
for (int j = 0; j < ds.Tables[i].Columns.Count; j++)
{
string
fldNm = "_" + ds.Tables[i].Columns[j].ColumnName.ToLower(),
propNm = ds.Tables[i].Columns[j].ColumnName;
if (!propNms.Contains(propNm))
{
System.CodeDom.CodeMemberProperty prop = new System.CodeDom.CodeMemberProperty();
prop.Attributes = System.CodeDom.MemberAttributes.Public;
prop.Name = propNm;
prop.Type = new System.CodeDom.CodeTypeReference(typeof(System.String));
System.CodeDom.CodeVariableReferenceExpression retExp = new System.CodeDom.CodeVariableReferenceExpression(fldNm);
System.CodeDom.CodeMethodReturnStatement getReturn = new System.CodeDom.CodeMethodReturnStatement(retExp);
prop.GetStatements.Add(getReturn);
prop.HasGet = true;
prop.HasSet = false;
string catName = (ds.Tables[i].TableName.EndsWith("1")) ? "File Group" : "Database";
System.CodeDom.CodeAttributeDeclaration attrCat = new System.CodeDom.CodeAttributeDeclaration("Category", new System.CodeDom.CodeAttributeArgument(new System.CodeDom.CodePrimitiveExpression(catName)));
prop.CustomAttributes.Add(attrCat);
// Add the property to our class.
clsDbInfo.Members.Add(prop);
propNms.Add(propNm);
}
}
}
// Add a constructor to the class
System.CodeDom.CodeConstructor clsDbInfoConstr = new System.CodeDom.CodeConstructor();
clsDbInfoConstr.Attributes = System.CodeDom.MemberAttributes.Public;
clsDbInfo.Members.Add(clsDbInfoConstr);
// Create a CompileUnit for this new type.
System.CodeDom.CodeCompileUnit cu = new System.CodeDom.CodeCompileUnit();
cu.ReferencedAssemblies.Add("system.dll");
cu.Namespaces.Add(nmspc);
// Now, we're ready to generate some code!
#if DEBUG
// If we're running in DEBUG mode, I want to see the generated code.
using (System.IO.FileStream fs = new System.IO.FileStream("dbinfo.cs", System.IO.FileMode.Create, System.IO.FileAccess.Write))
using (System.IO.StreamWriter sr = new System.IO.StreamWriter(fs))
cdp.GenerateCodeFromCompileUnit(cu, sr, null);
#endif
System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters();
cp.ReferencedAssemblies.Add("system.dll");
cp.GenerateExecutable = false;
cp.IncludeDebugInformation = false;
cp.GenerateInMemory = false;
//cp.OutputAssembly = _outputName;
System.CodeDom.Compiler.CompilerResults cr = cdp.CompileAssemblyFromDom(cp, cu);
if (!cr.Errors.HasErrors)
{
System.Reflection.Assembly asm = cr.CompiledAssembly;
object dbInfo = asm.CreateInstance("DataExplorer.DbInfo");
return(dbInfo);
}
else
{
return(null);
}
}
public static void TestSpecific(string str, object[] result)
{
Protocol protocol = Protocol.Parse(str);
var codegen = new CodeGen();
codegen.AddProtocol(protocol);
var compileUnit = codegen.GenerateCode();
// add a constructor to the main class using the passed assignment statements
CodeTypeDeclaration ctd = compileUnit.Namespaces[0].Types[(int)result[0]];
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public;
CodeSnippetExpression snippet = new CodeSnippetExpression((string)result[2]);
constructor.Statements.Add(snippet);
ctd.Members.Add(constructor);
// add a function to the main class to populate the data
// This has been moved from constructor, as it was causing some tests to pass that shouldn't when referencing a blank object on READ.
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public;
method.Name = "Populate";
CodeSnippetExpression snippet2 = new CodeSnippetExpression((string)result[3]);
method.Statements.Add(snippet2);
ctd.Members.Add(method);
// compile
var comparam = new CompilerParameters(new string[] { "mscorlib.dll" });
comparam.ReferencedAssemblies.Add("System.dll");
comparam.ReferencedAssemblies.Add("Avro.dll");
comparam.GenerateInMemory = true;
var ccp = new Microsoft.CSharp.CSharpCodeProvider();
var units = new CodeCompileUnit[] { compileUnit };
var compres = ccp.CompileAssemblyFromDom(comparam, units);
if (compres == null || compres.Errors.Count > 0)
{
for (int i = 0; i < compres.Errors.Count; i++)
{
Console.WriteLine(compres.Errors[i]);
}
}
if (null != compres)
{
Assert.IsTrue(compres.Errors.Count == 0);
}
// create record
ISpecificRecord rec = compres.CompiledAssembly.CreateInstance((string)result[1]) as ISpecificRecord;
// Call populate to put some data in it.
Type recType = rec.GetType();;
MethodInfo methodInfo = recType.GetMethod("Populate");
methodInfo.Invoke(rec, null);
var x1 = compres.CompiledAssembly.FullName;
Assert.IsFalse(rec == null);
// serialize
var stream = new MemoryStream();
var binEncoder = new BinaryEncoder(stream);
var writer = new SpecificDefaultWriter(rec.Schema);
writer.Write(rec.Schema, rec, binEncoder);
// deserialize
stream.Position = 0;
var decoder = new BinaryDecoder(stream);
var reader = new SpecificDefaultReader(rec.Schema, rec.Schema);
var rec2 = (ISpecificRecord)reader.Read(null, rec.Schema, rec.Schema, decoder);
Assert.IsFalse(rec2 == null);
}
/// <summary>
/// Loads all content from a folder hierarchy (overlaying anything already existing)
/// </summary>
/// <param name="project"></param>
/// <param name="path"></param>
public static void Load(DocProject project, string path)
{
// get all files within folder hierarchy
string pathSchema = path + @"\schemas";
IEnumerable <string> en = System.IO.Directory.EnumerateFiles(pathSchema, "*.cs", System.IO.SearchOption.AllDirectories);
List <string> list = new List <string>();
foreach (string s in en)
{
list.Add(s);
}
string[] files = list.ToArray();
Dictionary <string, string> options = new Dictionary <string, string> {
{ "CompilerVersion", "v4.0" }
};
Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider(options);
System.CodeDom.Compiler.CompilerParameters parms = new System.CodeDom.Compiler.CompilerParameters();
parms.GenerateInMemory = true;
parms.GenerateExecutable = false;
parms.ReferencedAssemblies.Add("System.dll");
parms.ReferencedAssemblies.Add("System.Core.dll");
parms.ReferencedAssemblies.Add("System.ComponentModel.dll");
parms.ReferencedAssemblies.Add("System.ComponentModel.DataAnnotations.dll");
parms.ReferencedAssemblies.Add("System.Data.dll");
parms.ReferencedAssemblies.Add("System.Runtime.Serialization.dll");
parms.ReferencedAssemblies.Add("System.Xml.dll");
System.CodeDom.Compiler.CompilerResults results = prov.CompileAssemblyFromFile(parms, files);
System.Reflection.Assembly assem = results.CompiledAssembly;
// look through classes of assembly
foreach (Type t in assem.GetTypes())
{
string[] namespaceparts = t.Namespace.Split('.');
string schema = namespaceparts[namespaceparts.Length - 1];
DocSection docSection = null;
if (t.Namespace.EndsWith("Resource"))
{
docSection = project.Sections[7];
}
else if (t.Namespace.EndsWith("Domain"))
{
docSection = project.Sections[6];
}
else if (t.Namespace.Contains("Shared"))
{
docSection = project.Sections[5];
}
else
{
docSection = project.Sections[4]; // kernel, extensions
}
// find schema
DocSchema docSchema = null;
foreach (DocSchema docEachSchema in docSection.Schemas)
{
if (docEachSchema.Name.Equals(schema))
{
docSchema = docEachSchema;
break;
}
}
if (docSchema == null)
{
docSchema = new DocSchema();
docSchema.Name = schema;
docSection.Schemas.Add(docSchema);
docSection.SortSchemas();
}
DocDefinition docDef = null;
if (t.IsEnum)
{
DocEnumeration docEnum = new DocEnumeration();
docSchema.Types.Add(docEnum);
docDef = docEnum;
System.Reflection.FieldInfo[] fields = t.GetFields(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
foreach (System.Reflection.FieldInfo field in fields)
{
DocConstant docConst = new DocConstant();
docEnum.Constants.Add(docConst);
docConst.Name = field.Name;
DescriptionAttribute[] attrs = (DescriptionAttribute[])field.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attrs.Length == 1)
{
docConst.Documentation = attrs[0].Description;
}
}
}
else if (t.IsValueType)
{
DocDefined docDefined = new DocDefined();
docSchema.Types.Add(docDefined);
docDef = docDefined;
PropertyInfo[] fields = t.GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
docDefined.DefinedType = fields[0].PropertyType.Name;
}
else if (t.IsInterface)
{
DocSelect docSelect = new DocSelect();
docSchema.Types.Add(docSelect);
docDef = docSelect;
}
else if (t.IsClass)
{
DocEntity docEntity = new DocEntity();
docSchema.Entities.Add(docEntity);
docDef = docEntity;
if (t.BaseType != typeof(object))
{
docEntity.BaseDefinition = t.BaseType.Name;
}
if (!t.IsAbstract)
{
docEntity.EntityFlags = 0x20;
}
Dictionary <int, DocAttribute> attrsDirect = new Dictionary <int, DocAttribute>();
List <DocAttribute> attrsInverse = new List <DocAttribute>();
PropertyInfo[] fields = t.GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
foreach (PropertyInfo field in fields)
{
DocAttribute docAttr = new DocAttribute();
docAttr.Name = field.Name.Substring(1);
Type typeField = field.PropertyType;
if (typeField.IsGenericType)
{
Type typeGeneric = typeField.GetGenericTypeDefinition();
typeField = typeField.GetGenericArguments()[0];
if (typeGeneric == typeof(Nullable <>))
{
docAttr.IsOptional = true;
}
else if (typeGeneric == typeof(ISet <>))
{
docAttr.AggregationType = (int)DocAggregationEnum.SET;
}
else if (typeGeneric == typeof(IList <>))
{
docAttr.AggregationType = (int)DocAggregationEnum.LIST;
}
}
docAttr.DefinedType = typeField.Name;
MinLengthAttribute mla = (MinLengthAttribute)field.GetCustomAttribute(typeof(MinLengthAttribute));
if (mla != null)
{
docAttr.AggregationLower = mla.Length.ToString();
}
MaxLengthAttribute mxa = (MaxLengthAttribute)field.GetCustomAttribute(typeof(MaxLengthAttribute));
if (mxa != null)
{
docAttr.AggregationUpper = mxa.Length.ToString();
}
PropertyInfo propinfo = t.GetProperty(docAttr.Name);
if (propinfo != null)
{
DescriptionAttribute da = (DescriptionAttribute)propinfo.GetCustomAttribute(typeof(DescriptionAttribute));
if (da != null)
{
docAttr.Documentation = da.Description;
}
}
DataMemberAttribute dma = (DataMemberAttribute)field.GetCustomAttribute(typeof(DataMemberAttribute));
if (dma != null)
{
attrsDirect.Add(dma.Order, docAttr);
RequiredAttribute rqa = (RequiredAttribute)field.GetCustomAttribute(typeof(RequiredAttribute));
if (rqa == null)
{
docAttr.IsOptional = true;
}
CustomValidationAttribute cva = (CustomValidationAttribute)field.GetCustomAttribute(typeof(CustomValidationAttribute));
if (cva != null)
{
docAttr.IsUnique = true;
}
}
else
{
InversePropertyAttribute ipa = (InversePropertyAttribute)field.GetCustomAttribute(typeof(InversePropertyAttribute));
if (ipa != null)
{
docAttr.Inverse = ipa.Property;
attrsInverse.Add(docAttr);
}
}
// xml
XmlIgnoreAttribute xia = (XmlIgnoreAttribute)field.GetCustomAttribute(typeof(XmlIgnoreAttribute));
if (xia != null)
{
docAttr.XsdFormat = DocXsdFormatEnum.Hidden;
}
else
{
XmlElementAttribute xea = (XmlElementAttribute)field.GetCustomAttribute(typeof(XmlElementAttribute));
if (xea != null)
{
if (!String.IsNullOrEmpty(xea.ElementName))
{
docAttr.XsdFormat = DocXsdFormatEnum.Element;
}
else
{
docAttr.XsdFormat = DocXsdFormatEnum.Attribute;
}
}
}
}
foreach (DocAttribute docAttr in attrsDirect.Values)
{
docEntity.Attributes.Add(docAttr);
}
foreach (DocAttribute docAttr in attrsInverse)
{
docEntity.Attributes.Add(docAttr);
}
// get derived attributes based on properties
PropertyInfo[] props = t.GetProperties(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public);
foreach (PropertyInfo prop in props)
{
// if no backing field, then derived
FieldInfo field = t.GetField("_" + prop.Name, BindingFlags.NonPublic | BindingFlags.Instance);
if (field == null)
{
DocAttribute docDerived = new DocAttribute();
docDerived.Name = prop.Name;
docEntity.Attributes.Add(docDerived);
}
}
}
if (docDef != null)
{
docDef.Name = t.Name;
docDef.Uuid = t.GUID;
}
docSchema.SortTypes();
docSchema.SortEntities();
}
// pass 2: hook up selects
foreach (Type t in assem.GetTypes())
{
Type[] typeInterfaces = t.GetInterfaces();
if (typeInterfaces.Length > 0)
{
foreach (Type typeI in typeInterfaces)
{
DocSelect docSelect = project.GetDefinition(typeI.Name) as DocSelect;
if (docSelect != null)
{
DocSelectItem docItem = new DocSelectItem();
docItem.Name = t.Name;
docSelect.Selects.Add(docItem);
}
}
}
}
// EXPRESS rules (eventually in C#, though .exp file snippets for now)
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.exp", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string name = Path.GetFileNameWithoutExtension(file);
string expr = null;
using (StreamReader readExpr = new StreamReader(file, Encoding.UTF8))
{
expr = readExpr.ReadToEnd();
}
if (name.Contains('-'))
{
// where rule
string[] parts = name.Split('-');
if (parts.Length == 2)
{
DocWhereRule docWhere = new DocWhereRule();
docWhere.Name = parts[1];
docWhere.Expression = expr;
DocDefinition docDef = project.GetDefinition(parts[0]);
if (docDef is DocEntity)
{
DocEntity docEnt = (DocEntity)docDef;
docEnt.WhereRules.Add(docWhere);
}
else if (docDef is DocDefined)
{
DocDefined docEnt = (DocDefined)docDef;
docEnt.WhereRules.Add(docWhere);
}
else if (docDef == null)
{
//... global rule...
}
}
}
else
{
// function
string schema = Path.GetDirectoryName(file);
schema = Path.GetDirectoryName(schema);
schema = Path.GetFileName(schema);
DocSchema docSchema = project.GetSchema(schema);
if (docSchema != null)
{
DocFunction docFunction = new DocFunction();
docSchema.Functions.Add(docFunction);
docFunction.Name = name;
docFunction.Expression = expr;
}
}
}
// now, hook up html documentation
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.htm", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string name = Path.GetFileNameWithoutExtension(file);
DocObject docObj = null;
if (name == "schema")
{
string schema = Path.GetDirectoryName(file);
schema = Path.GetFileName(schema);
docObj = project.GetSchema(schema);
}
else if (name.Contains('-'))
{
// where rule
string[] parts = name.Split('-');
if (parts.Length == 2)
{
DocDefinition docDef = project.GetDefinition(parts[0]);
if (docDef is DocEntity)
{
DocEntity docEnt = (DocEntity)docDef;
foreach (DocWhereRule docWhereRule in docEnt.WhereRules)
{
if (docWhereRule.Name.Equals(parts[1]))
{
docObj = docWhereRule;
break;
}
}
}
else if (docDef is DocDefined)
{
DocDefined docEnt = (DocDefined)docDef;
foreach (DocWhereRule docWhereRule in docEnt.WhereRules)
{
if (docWhereRule.Name.Equals(parts[1]))
{
docObj = docWhereRule;
break;
}
}
}
}
}
else
{
docObj = project.GetDefinition(name);
if (docObj == null)
{
docObj = project.GetFunction(name);
}
}
if (docObj != null)
{
using (StreamReader readHtml = new StreamReader(file, Encoding.UTF8))
{
docObj.Documentation = readHtml.ReadToEnd();
}
}
}
// load schema diagrams
en = System.IO.Directory.EnumerateFiles(pathSchema, "*.svg", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
string schema = Path.GetDirectoryName(file);
schema = Path.GetFileName(schema);
DocSchema docSchema = project.GetSchema(schema);
if (docSchema != null)
{
using (IfcDoc.Schema.SVG.SchemaSVG schemaSVG = new IfcDoc.Schema.SVG.SchemaSVG(file, docSchema, project))
{
schemaSVG.Load();
}
}
}
// psets, qsets
//...
// exchanges
en = System.IO.Directory.EnumerateFiles(path, "*.mvdxml", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
IfcDoc.Schema.MVD.SchemaMVD.Load(project, file);
}
// examples
string pathExamples = path + @"\examples";
if (Directory.Exists(pathExamples))
{
en = System.IO.Directory.EnumerateFiles(pathExamples, "*.htm", SearchOption.TopDirectoryOnly);
foreach (string file in en)
{
DocExample docExample = new DocExample();
docExample.Name = Path.GetFileNameWithoutExtension(file);
project.Examples.Add(docExample);
using (StreamReader reader = new StreamReader(file))
{
docExample.Documentation = reader.ReadToEnd();
}
string dirpath = file.Substring(0, file.Length - 4);
if (Directory.Exists(dirpath))
{
IEnumerable <string> suben = System.IO.Directory.EnumerateFiles(dirpath, "*.ifc", SearchOption.TopDirectoryOnly);
foreach (string ex in suben)
{
DocExample docEx = new DocExample();
docEx.Name = Path.GetFileNameWithoutExtension(ex);
docExample.Examples.Add(docEx);
// read the content of the file
using (FileStream fs = new FileStream(ex, FileMode.Open, FileAccess.Read))
{
docEx.File = new byte[fs.Length];
fs.Read(docEx.File, 0, docEx.File.Length);
}
// read documentation
string exdoc = ex.Substring(0, ex.Length - 4) + ".htm";
if (File.Exists(exdoc))
{
using (StreamReader reader = new StreamReader(exdoc))
{
docEx.Documentation = reader.ReadToEnd();
}
}
}
}
}
}
// localization
en = System.IO.Directory.EnumerateFiles(path, "*.txt", System.IO.SearchOption.AllDirectories);
foreach (string file in en)
{
using (FormatCSV format = new FormatCSV(file))
{
try
{
format.Instance = project;
format.Load();
}
catch
{
}
}
}
}
private static Assembly CompileStrings(
string[] src,
string[] referenceAssemblies,
bool toAssembly,
string outputAssemblyPath,
out string errors
)
{
var cpar = new System.CodeDom.Compiler.CompilerParameters()
{
GenerateInMemory = !toAssembly,
OutputAssembly = outputAssemblyPath,
};
// Add default references...
cpar.ReferencedAssemblies.Add(typeof(System.Activities.Activity).Assembly.Location);
cpar.ReferencedAssemblies.Add(typeof(System.CodeDom.Compiler.CodeCompiler).Assembly.Location);
cpar.ReferencedAssemblies.Add(typeof(PSObject).Assembly.Location);
cpar.ReferencedAssemblies.Add(typeof(Microsoft.PowerShell.Activities.PSActivity).Assembly.Location);
cpar.ReferencedAssemblies.Add(ResolveReferencedAssembly("Microsoft.Management.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"));
cpar.ReferencedAssemblies.Add(ResolveReferencedAssembly("Microsoft.PowerShell.Commands.Management, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"));
// Add user supplied references...
if (referenceAssemblies != null)
{
foreach (string asm in referenceAssemblies)
{
cpar.ReferencedAssemblies.Add(ResolveReferencedAssembly(asm));
}
}
var compiler = new Microsoft.CSharp.CSharpCodeProvider();
var cr = compiler.CompileAssemblyFromSource(cpar, src);
if (cr.Errors == null || cr.Errors.Count == 0)
{
errors = string.Empty;
}
else
{
StringBuilder errorBuilder = new StringBuilder();
foreach (var err in cr.Errors)
{
errorBuilder.Append(err.ToString());
errorBuilder.Append('\n');
}
errors = errorBuilder.ToString();
}
if (errors.Length > 0)
{
return(null);
}
// If the assembly was written to disk, return null
// since we don't want to load the assembly we've just created.
if (toAssembly)
{
return(null);
}
else
{
return(cr.CompiledAssembly);
}
}