public static void WriteCode(this CodeNamespace @namespace, CodeDomProvider provider, TextWriter textWriter, CodeGeneratorOptions options)
{
if (@namespace == null)
{
throw new ArgumentNullException("namespace");
}
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (textWriter == null)
{
throw new ArgumentNullException("textWriter");
}
CodeGenerator.ValidateIdentifiers(@namespace);
if (textWriter is IndentedTextWriter)
{
provider.GenerateCodeFromNamespace(@namespace, textWriter, options);
}
else
{
using (IndentedTextWriter indentedWriter = new IndentedTextWriter(textWriter))
{
provider.GenerateCodeFromNamespace(@namespace, indentedWriter, options);
indentedWriter.Flush();
}
}
}
public void Build()
{
//ext
OnBuildStarting();
xmlModel = new StateMachineXmlModel(InputFileName);
model = xmlModel.Build();
//ext
OnModelRead(model);
StreamWriter streamWriter = new StreamWriter(OutputFileName);
CodeCompileUnit code = new CodeCompileUnit();
CodeNamespace codeNamespace = CreateNameSpace(code);
WriteHeader(codeNamespace);
coder = new CoderStateMachine(model, Options, codeNamespace);
coder.WriteCode();
OnBuildWriteCompleted(coder, codeNamespace, code, model);
codeDomProvider.GenerateCodeFromNamespace(codeNamespace, streamWriter, null);
streamWriter.Close();
OnBuildCompleted(coder, codeNamespace, code, model, OutputFileName, OutputDirectory);
}
/// <summary>Generates the output.</summary>
/// <param name="inputFileName">Name of file to generate input from</param>
/// <param name="inputFileContent">Content of file to generate input from</param>
protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
{
string code = "";
try {
// Process the file.
CodeDomProvider Provider = CodeProvider;
CodeNamespace ns = Processor.Process(inputFileName, FileNamespace, Provider);
// Generate code for it.
CodeGeneratorOptions opt = new CodeGeneratorOptions();
opt.BracingStyle = "C";
StringWriter sw = new StringWriter();
Provider.GenerateCodeFromNamespace(ns, sw, opt);
// Finaly assign it to the result to return.
code = sw.ToString();
Processor.PostProcess(inputFileName, ref code, Provider);
} catch (Exception e) {
code = String.Format(Resources.err_CouldNotGenerateCode, e);
}
// Convert to bytes.
return(System.Text.Encoding.UTF8.GetBytes(code));
}
static void Main(string[] args)
{
CodeNamespace mynamespace = new CodeNamespace("myapplication");
Console.Out.WriteLine("\n--------- 以下是C#代码 ------------");
CodeDomProvider csp = CodeDomProvider.CreateProvider("C#");
csp.GenerateCodeFromNamespace(mynamespace, Console.Out, new CodeGeneratorOptions {
BracingStyle = "C"
});
Console.Out.WriteLine("\n\n------ - 以下是VB.NET代码---------- -");
CodeDomProvider vbp = CodeDomProvider.CreateProvider("VB");
vbp.GenerateCodeFromNamespace(mynamespace, Console.Out, new CodeGeneratorOptions());
Console.ReadKey();
DateTime dt = new DateTime();
var intArray = new int[] {
1, 2, 3, 4
};
Array.Sort(intArray, (a, b) =>
{
return(a >= b?1:0);
});
}
/// <summary>
/// Generates source code from given namespace.
/// </summary>
private static string GenerateFromNamespace(CodeDomProvider codeProvider, System.CodeDom.CodeNamespace codeNamespace, bool blankLinesBetweenMembers, bool isCSharp)
{
var result = new StringBuilder();
using (var writer = new StringWriter(result))
{
var options = new CodeGeneratorOptions
{
BlankLinesBetweenMembers = blankLinesBetweenMembers,
ElseOnClosing = true,
VerbatimOrder = true,
BracingStyle = "C",
};
// generate the code:
codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options);
// send it to the StringBuilder object:
writer.Flush();
}
if (isCSharp)
{
result.Replace(" class ", " static class ");
result.Replace(" partial static ", " static partial ");
result.Replace(" static System.Guid ", " static readonly System.Guid ");
}
return(result.ToString());
}
public string GenerateClass(XmlNode node, TypeTable typeTable)
{
InitializeCodeGenerator();
// Get the namespace and class type from the XML.
XmlNode platformNode = node.SelectSingleNode("platform");
XmlNode nameNode = node.SelectSingleNode("name");
XmlNode mainNode = node.SelectSingleNode("//struct");
string className = typeTable.LocateEntryByFourCC(nameNode.Attributes["type"].InnerText).FullName;
string friendlyClassName = nameNode.InnerText;
string parentType = null;
try
{
string fourCC = nameNode.Attributes["parenttype"].InnerText;
if (fourCC != "????")
{
parentType = typeTable.LocateEntryByFourCC(fourCC).FullName;
}
}
catch { parentType = null; }
string mainBlockName = mainNode.Attributes["name"].InnerText + "Block";
//generate root level code
ns = GenerateNamespaceAndImports(platformNode.InnerText, className, parentType);
rootClassDeclaration = GenerateRootClass(className, friendlyClassName, mainBlockName, parentType, className /*typeTable.GetExtended(nameNode.Attributes["type"].InnerText)*/);
// Generate all of the component block classes.
List <string> structs = new List <string>();
XmlNodeList structsList = node.SelectNodes("//struct");
foreach (XmlNode structNode in structsList)
{
string nameOfClass = structNode.Attributes["name"].InnerText;
// If the class already exists, don't generate it again.
if (!structs.Contains(nameOfClass))
{
CodeTypeDeclaration ct = GenerateBlockClass(structNode, false);
rootClassDeclaration.Members.Add(ct);
structs.Add(nameOfClass);
}
}
ns.Types.Add(rootClassDeclaration);
// Generate the code and return it as a string.
StreamWriter writer = new StreamWriter(new MemoryStream());
provider.GenerateCodeFromNamespace(ns, writer, codeGenOptions);
writer.Flush();
StreamReader reader = new StreamReader(writer.BaseStream);
reader.BaseStream.Position = 0;
string code = reader.ReadToEnd();
reader.Close();
writer.Close();
return(code);
}
/// <summary>
/// This method writes the generated code into a single file.
/// </summary>
private void WriteSingleCodeFile()
{
// Some assertions to make debugging easier.
Debug.Assert(!string.IsNullOrEmpty(options.OutputLocation), "This action cannot be performed when output location is null or an empty string.");
Debug.Assert(!string.IsNullOrEmpty(options.OutputFileName), "This action cannot be performed when output file name is null or an empty string");
// Get the destination file name.
string fileName = CodeWriter.GetUniqueFileName(options.OutputLocation, options.OutputFileName, options.Language, options.OverwriteExistingFiles);
// Create a StreamWriter for writing to the destination file.
StreamWriter writer = new StreamWriter(fileName);
try
{
// Write out the code to the destination file.
provider.GenerateCodeFromNamespace(codeNamespace, writer, codeGenerationOptions);
// Flush all buffers in the writer.
writer.Flush();
codeFilesCount = 1;
// Initialize generatedFileNames array to hold the one and only one
// file we just generated.
generatedCodeFileNames = new string[codeFilesCount + textFiles.Count];
// Finally add the file name to the generatedFileNames array.
generatedCodeFileNames[0] = fileName;
}
catch (IOException e)
{
// Wrap the IOException in a CodeWriterException with little bit
// more information.
throw new CodeWriterException(
string.Format("An error occurred while trying write to file {0}: {1}", fileName, e.Message), e);
}
finally
{
// No matter what happens, dispose the stream writer and release the unmanaged
// resources.
writer.Dispose();
}
}
/// <summary>
/// Generates class from the CodeCompileUnit and Language specified
/// </summary>
public override void Execute()
{
CodeDomProvider provider = ProviderFactory.CreateProvider(this.language);
CodeGeneratorOptions options = new CodeGeneratorOptions();
using (StringWriter tw = new StringWriter())
{
if (this.compileUnit.Namespaces.Count == 1)
{
provider.GenerateCodeFromNamespace(this.compileUnit.Namespaces[0], tw, options);
this._class = tw.ToString();
}
}
}
public void GenerateTestFile(FeatureFileInput featureFile, CodeDomProvider codeProvider, TextReader inputReader, TextWriter outputWriter)
{
outputWriter = new IndentProcessingWriter(outputWriter);
CodeDomHelper codeDomHelper = new CodeDomHelper(codeProvider);
var codeNamespace = GenerateTestFileCode(featureFile, inputReader, codeProvider, codeDomHelper);
var options = new CodeGeneratorOptions
{
BracingStyle = "C"
};
AddSpecFlowHeader(codeProvider, outputWriter, codeDomHelper);
codeProvider.GenerateCodeFromNamespace(codeNamespace, outputWriter, options);
AddSpecFlowFooter(codeProvider, outputWriter, codeDomHelper);
outputWriter.Flush();
}
/// <summary>
/// Generate the WMI output file
/// </summary>
public void GenerateFile(ManagementObject mgo, string name, string outfile)
{
var imports = new string[] { "System", "System.Linq", "LinqToWmi.Core.WMI" };
var generatedNamespace = new CodeNamespace(_namespace);
Assembly generatorAssembly = GetType().Assembly;
string versionNumber = generatorAssembly.GetName().Version.ToString();
generatedNamespace.Comments.Add(new CodeCommentStatement(String.Format("<auto-generated>\n This code was generated by a tool.\n LinqToWmi.ClassGenerator Version: {0}\n\n Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.\n </auto-generated>", versionNumber)));
var generatedClass = new CodeTypeDeclaration(name);
generatedClass.CustomAttributes.Add(new CodeAttributeDeclaration("System.CodeDom.Compiler.GeneratedCodeAttribute",
CreateAttributeArgument(generatorAssembly.GetName().Name),
CreateAttributeArgument(versionNumber)
));
generatedNamespace.Imports.AddRange((from import in imports
select new CodeNamespaceImport(import)).ToArray());
IEnumerable <CodeMemberField> wmiProperties = from property in Wrap(mgo.Properties)
select new CodeMemberField(
new CodeTypeReference(CimTypeConverter.Convert(property)),
GetFieldName(property.Name)
);
generatedClass.Members.AddRange(wmiProperties.ToArray());
generatedClass.Members.AddRange((from property in Wrap(mgo.Properties)
select CreateProperty(property)).ToArray());
generatedNamespace.Types.Add(generatedClass);
//Write the file using the given code provider
CodeDomProvider provider = CodeDomProvider.CreateProvider(_outputLanguage);
string output = (outfile != null ? outfile :
String.Format("{0}.{1}", name, provider.FileExtension));
using (TextWriter writer = new StreamWriter(File.OpenWrite(output)))
{
provider.GenerateCodeFromNamespace(generatedNamespace, writer, null);
}
}
public void Generate(TextWriter w, Database database,
CodeDomProvider provider, String ns)
{
CodeCommentStatement c = new CodeCommentStatement(
String.Format("Enum for {0}", database.DisplayName.Replace("DataSet", "")));
provider.GenerateCodeFromStatement(c, w, null);
//Gen: namespace <NAMESPACE> {
// using System;
CodeNamespace cnamespace = new CodeNamespace(ns);
cnamespace.Imports.Add(new CodeNamespaceImport("System"));
string databaseName = database.DisplayName.Replace("DataSet", "").Replace(' ', '_');
//Gen: public enum <typeName>
CodeTypeDeclaration enumViewsType =
new CodeTypeDeclaration(databaseName + "Views");
enumViewsType.IsEnum = true;
//Add this so that VB does not Inherit either interface
enumViewsType.TypeAttributes = TypeAttributes.Public;
cnamespace.Types.Add(enumViewsType);
foreach (View view in database.Views.Values)
{
enumViewsType.Members.Add(new CodeMemberField(typeof(int), view.Name));
//Gen: public enum <typeName>
CodeTypeDeclaration enumViewType =
new CodeTypeDeclaration(view.Name);
enumViewType.IsEnum = true;
//Add this so that VB does not Inherit either interface
enumViewType.TypeAttributes = TypeAttributes.Public;
cnamespace.Types.Add(enumViewType);
foreach (Field field in view.Fields.Values)
{
enumViewType.Members.Add(new CodeMemberField(typeof(int), field.Name));
}
}
provider.GenerateCodeFromNamespace(cnamespace, w, null);
}
/// <summary>
/// Writes each types in each namespaces into individual files
/// </summary>
/// <param name="outputdir">name of directory to write to</param>
public virtual void WriteTypes(string outputdir)
{
CodeDomProvider cscp = DoJava
? (CodeDomProvider)
Type.GetType("Microsoft.VJSharp.VJSharpCodeProvider").GetConstructor(
new Type[0]).Invoke(new object[0])
: new CSharpCodeProvider();
var opts = new CodeGeneratorOptions();
opts.BracingStyle = "C";
opts.IndentString = "\t";
opts.BlankLinesBetweenMembers = false;
CodeNamespaceCollection nsc = CompileUnit.Namespaces;
for (int i = 0; i < nsc.Count; i++)
{
var ns = nsc[i];
string dir = outputdir + "\\" + CodeGenUtil.Instance.UnMangle(ns.Name).Replace('.', '\\');
Directory.CreateDirectory(dir);
var new_ns = new CodeNamespace(ns.Name);
new_ns.Comments.Add(CodeGenUtil.Instance.FileComment);
foreach (CodeNamespaceImport nci in CodeGenUtil.Instance.NamespaceImports)
{
new_ns.Imports.Add(nci);
}
var types = ns.Types;
for (int j = 0; j < types.Count; j++)
{
var ctd = types[j];
string file = dir + "\\" + CodeGenUtil.Instance.UnMangle(ctd.Name) + (DoJava ? ".java" : ".cs");
using (var writer = new StreamWriter(file, false))
{
new_ns.Types.Add(ctd);
cscp.GenerateCodeFromNamespace(new_ns, writer, opts);
new_ns.Types.Remove(ctd);
}
}
}
}
public void GenerateCode(
string outputPath,
NamespaceDeclaration ns
)
{
if (ns == null)
{
throw new ArgumentNullException("ns");
}
foreach (DictionaryEntry de in ns.ToCodeDom())
{
FileName key = (FileName)de.Key;
CodeNamespace nms = (CodeNamespace)de.Value;
// creating directory
string path;
if (createFolders)
{
path = PathFromNamespace(outputPath, key.Namespace);
}
else
{
path = outputPath;
}
string filePath = Path.Combine(path, key.Name + "." + this.Provider.FileExtension);
using (StreamWriter writer = new StreamWriter(filePath))
{
// add copyright
nms.Comments.Add(new CodeCommentStatement(copyright));
// Create a TextWriter to a StreamWriter to an output file.
IndentedTextWriter tw = new IndentedTextWriter(writer, this.tab);
// Generate source code using the code generator.
provider.GenerateCodeFromNamespace(nms, tw, options);
// log
this.OnFileCreated(new StringEventArgs(filePath));
}
}
}
public void Build()
{
xmlModel = new StateMachineXmlModel(InputFileName);
model = xmlModel.Build();
StreamWriter streamWriter = new StreamWriter(OutputFileName);
CodeCompileUnit code = new CodeCompileUnit();
CodeNamespace codeNamespace = CreateNameSpace(code);
WriteHeader(codeNamespace);
coder = new CoderStateMachine(model, Options, codeNamespace);
coder.WriteCode();
codeDomProvider.GenerateCodeFromNamespace(codeNamespace, streamWriter, null);
streamWriter.Close();
}
/// <summary>
/// Generates source code from given namespace.
/// </summary>
private static string GenerateFromNamespace(CodeDomProvider codeProvider, System.CodeDom.CodeNamespace codeNamespace, bool blankLinesBetweenMembers)
{
var result = new StringBuilder();
var writer = new StringWriter(result);
var options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = blankLinesBetweenMembers;
options.ElseOnClosing = true;
options.VerbatimOrder = true;
options.BracingStyle = "C";
// generate the code:
codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options);
// send it to the StringBuilder object:
writer.Flush();
return(result.ToString());
}
/// <summary>
/// Generates a value type implementation for forValueType in
/// targetWriter
/// </summary>
private void GenerateValueTypeImplToFile(Type forValueType,
TextWriter targetWriter)
{
CodeNamespace targetNamespace =
new CodeNamespace(forValueType.Namespace);
CodeTypeDeclaration valTypeImpl =
new CodeTypeDeclaration(forValueType.Name + "Impl");
targetNamespace.Types.Add(valTypeImpl);
valTypeImpl.TypeAttributes = TypeAttributes.Class |
TypeAttributes.Public;
valTypeImpl.BaseTypes.Add(forValueType.Name);
valTypeImpl.CustomAttributes.Add(
new CodeAttributeDeclaration("Serializable"));
AddNamespaceImport(targetNamespace, "System");
AddMembers(forValueType, valTypeImpl, targetNamespace);
m_codeDomProvider.GenerateCodeFromNamespace(targetNamespace,
targetWriter,
new CodeGeneratorOptions());
}
private static string GenerateCode(CodeObject c, CodeDomProvider provider)
{
var sb = new StringBuilder();
var writer = new StringWriter(sb);
var options = new CodeGeneratorOptions();
if (c is CodeStatement)
{
provider.GenerateCodeFromStatement((CodeStatement)c, writer, options);
}
else if (c is CodeCompileUnit)
{
provider.GenerateCodeFromCompileUnit((CodeCompileUnit)c, writer, options);
}
else if (c is CodeExpression)
{
provider.GenerateCodeFromExpression((CodeExpression)c, writer, options);
}
else if (c is CodeTypeMember)
{
provider.GenerateCodeFromMember((CodeTypeMember)c, writer, options);
}
else if (c is CodeTypeDeclaration)
{
provider.GenerateCodeFromType((CodeTypeDeclaration)c, writer, options);
}
else if (c is CodeNamespace)
{
provider.GenerateCodeFromNamespace((CodeNamespace)c, writer, options);
}
else
{
throw new ArgumentException($"Tests not set up for unexpected type: {c.GetType()}");
}
return(sb.ToString());
}
private static string GenerateCode(CodeObject c, CodeDomProvider provider)
{
var sb = new StringBuilder();
var writer = new StringWriter(sb);
var options = new CodeGeneratorOptions();
if (c is CodeStatement)
{
provider.GenerateCodeFromStatement((CodeStatement)c, writer, options);
}
else if (c is CodeCompileUnit)
{
provider.GenerateCodeFromCompileUnit((CodeCompileUnit)c, writer, options);
}
else if (c is CodeExpression)
{
provider.GenerateCodeFromExpression((CodeExpression)c, writer, options);
}
else if (c is CodeTypeMember)
{
provider.GenerateCodeFromMember((CodeTypeMember)c, writer, options);
}
else if (c is CodeTypeDeclaration)
{
provider.GenerateCodeFromType((CodeTypeDeclaration)c, writer, options);
}
else if (c is CodeNamespace)
{
provider.GenerateCodeFromNamespace((CodeNamespace)c, writer, options);
}
else
{
Assert.False(true, $"Unknown type: {c.GetType()}");
}
return(sb.ToString());
}
/// <summary>
/// Serializes a component to a source code in the language specified in the <see cref="LiteDevelop.Essentials.FormsDesigner.DesignerCodeWriter.Language"/> property.
/// </summary>
/// <param name="namespace">The namespace to create the code in.</param>
/// <param name="instance">The object to be serialized.</param>
/// <param name="container">The container object.</param>
/// <param name="includeBaseType">Include the base type of the instance in the to be generated source.</param>
/// <returns></returns>
public string SerializeCode(string @namespace, Component instance, IContainer container, bool includeBaseType)
{
// Create new namespace
CodeNamespace codeNamespace = new CodeNamespace(@namespace);
// Create new class.
CodeTypeDeclaration controlType = new CodeTypeDeclaration(instance.Site.Name)
{
Attributes = MemberAttributes.Public,
IsClass = true,
IsPartial = true,
};
if (includeBaseType)
{
controlType.BaseTypes.Add(new CodeTypeReference(instance.GetType()));
}
// generate fields for members.
controlType.Members.AddRange(GenerateMembers(container));
// generate initializecomponent().
controlType.Members.Add(GenerateInitializeComponentMethod(instance, container));
// add class to namespace.
codeNamespace.Types.Add(controlType);
string code = string.Empty;
using (MemoryStream stream = new MemoryStream())
{
using (StreamWriter writer = new StreamWriter(stream))
{
using (IndentedTextWriter codeWriter = new IndentedTextWriter(writer, " "))
{
CodeDomProvider provider = Language.CodeProvider;
using (provider)
{
// generate source code.
provider.GenerateCodeFromNamespace(codeNamespace, codeWriter,
new CodeGeneratorOptions()
{
BlankLinesBetweenMembers = true,
BracingStyle = "C", // use new lines on brackets.
});
}
}
// write data to stream.
writer.Flush();
// read stream contents to get code.
stream.Position = 0;
using (StreamReader reader = new StreamReader(stream))
{
code = reader.ReadToEnd();
}
}
}
propertySerializer.TemporaryVariables.Clear();
return(code);
}
protected override void ProcessRecord()
{
if (CompileUnit != null && CompileUnit.Length > 0)
{
foreach (CodeCompileUnit compileUnit in CompileUnit)
{
if (compileUnit != null)
{
_provider.GenerateCodeFromCompileUnit(compileUnit, _indentedWriter, Options);
}
}
}
else if (Expression != null && Expression.Length > 0)
{
foreach (CodeExpression expr in Expression)
{
if (expr != null)
{
_provider.GenerateCodeFromExpression(expr, _indentedWriter, Options);
}
}
}
else if (Member != null && Member.Length > 0)
{
foreach (CodeTypeMember member in Member)
{
if (member != null)
{
_provider.GenerateCodeFromMember(member, _indentedWriter, Options);
}
}
}
else if (NS != null && NS.Length > 0)
{
foreach (CodeNamespace ns in NS)
{
if (ns != null)
{
_provider.GenerateCodeFromNamespace(ns, _indentedWriter, Options);
}
}
}
else if (Statement != null && Statement.Length > 0)
{
foreach (CodeStatement st in Statement)
{
if (st != null)
{
_provider.GenerateCodeFromStatement(st, _indentedWriter, Options);
}
}
}
else if (Type != null && Type.Length > 0)
{
foreach (CodeTypeDeclaration t in Type)
{
if (t != null)
{
_provider.GenerateCodeFromType(t, _indentedWriter, Options);
}
}
}
}
private Type CompileTypeFromFile(OpenedFile file)
{
string sourceCode = file.GetContentsAsString();
var projectFile = _extensionHost.CurrentSolution.FindProjectFile(file.FilePath);
if (projectFile == null)
{
throw new FileNotFoundException("Cannot find project file " + file.FilePath.FullPath);
}
CompilerParameters parameters = new CompilerParameters()
{
GenerateInMemory = true,
GenerateExecutable = false,
};
// standard references.
parameters.ReferencedAssemblies.AddRange(new string[] { "mscorlib.dll", "System.dll", "System.Drawing.dll", "System.Windows.Forms.dll" });
CodeDomProvider provider = Language.CodeProvider;
// validate source
var sourceSnapshot = Language.CreateSourceSnapshot(sourceCode) as NetSourceSnapshot;
if (sourceSnapshot.Types.Length != 1)
{
throw new ArgumentException("Source must contain exactly one type.");
}
string @namespace;
if (sourceSnapshot.Namespaces.Length == 0)
{
// TODO: add temp namespace ....
throw new NotImplementedException("Cannot handle classes without a namespace yet.");
}
else
{
@namespace = sourceSnapshot.Namespaces[0].Name;
}
// create stub class
var writer = new StringWriter();
var stubClass = new CodeTypeDeclaration(sourceSnapshot.Types[0].Name)
{
IsPartial = true
};
stubClass.Members.Add(GenerateConstructor());
// check if snapshot class doesn't have a base type.
if (string.IsNullOrEmpty(sourceSnapshot.Types[0].ValueType))
{
// try to find in dependencies
foreach (var dependency in file.Dependencies)
{
if (Path.GetExtension(dependency) == file.FilePath.Extension)
{
var dependentFile = _extensionHost.FileService.OpenFile(projectFile.FilePath.ParentDirectory.Combine(dependency));
var dependencySnapshot = Language.CreateSourceSnapshot(dependentFile.GetContentsAsString()) as NetSourceSnapshot;
if (dependencySnapshot.Types[0].Name == sourceSnapshot.Types[0].Name && !string.IsNullOrEmpty(dependencySnapshot.Types[0].ValueType))
{
var baseType = dependencySnapshot.GetTypeByName(dependencySnapshot.Types[0].ValueType);
if (baseType != null)
{
stubClass.BaseTypes.Add(baseType);
break;
}
}
}
}
}
// write stub class
var stubNamespace = new CodeNamespace(@namespace);
stubNamespace.Types.Add(stubClass);
provider.GenerateCodeFromNamespace(stubNamespace, writer, new CodeGeneratorOptions());
// compile.
CompilerResults results = provider.CompileAssemblyFromSource(parameters, sourceCode, writer.GetStringBuilder().ToString());
if (results.Errors.Count == 0)
{
// find target type.
foreach (Type type in results.CompiledAssembly.GetTypes())
{
if (type.IsBasedOn(typeof(Component)))
{
return(type);
}
}
throw new Exception("The type based on " + typeof(Component).FullName + " was not found.");
}
else
{
throw new BuildException("The compiler did not succeed in compiling the source.", BuildResult.FromCompilerResults(results));
}
}
public string GenerateCodeString()
{
CodeGeneratorOptions gen = new CodeGeneratorOptions();
gen.BracingStyle = "C";
gen.IndentString = "\t";
gen.VerbatimOrder = true;
gen.BlankLinesBetweenMembers = false;
StringBuilder sb = new StringBuilder();
using (TextWriter writer = new StringWriter(sb))
{
//a header is written to the file.
//this embeds some information about how the file was compiled
CodeCommentStatementCollection headerCommentes = new CodeCommentStatementCollection();
GenerateHeader(headerCommentes);
for (int i = 0; i < headerCommentes.Count; i++)
{
codeProvider.GenerateCodeFromStatement(headerCommentes[i], writer, gen);
}
sb.AppendLine();
//generate shader byte pool first, if needed
if (source.PoolShaderBytes)
{
//add the shader pools
sb.AppendLine(directives.IfXboxStatement.Text);
CodeNamespace space = new CodeNamespace(this.outputNamespace);
source.BytePoolXbox.GeneratePool(space.Types, directives);
codeProvider.GenerateCodeFromNamespace(space, writer, gen);
sb.AppendLine(directives.ElseStatement.Text);
space = new CodeNamespace(this.outputNamespace);
source.BytePoolPC.GeneratePool(space.Types, directives);
codeProvider.GenerateCodeFromNamespace(space, writer, gen);
sb.AppendLine(directives.EndifStatement.Text);
}
if (!source.DefinePlatform)
{
//geneate the single root namespace
codeProvider.GenerateCodeFromNamespace(rootNamespace, writer, gen);
}
else
{
//generate the two namespaces, broken up by #if block
//#if
sb.AppendLine(directives.IfXboxStatement.Text);
//xbox code
codeProvider.GenerateCodeFromNamespace(rootXboxNamespace, writer, gen);
//#else
sb.AppendLine(directives.ElseStatement.Text);
//pc code
codeProvider.GenerateCodeFromNamespace(rootPcNamespace, writer, gen);
//#endif
sb.AppendLine(directives.EndifStatement.Text);
}
}
return(sb.ToString());
}
private static String ConstructGeneratorCode(TemplateItem item, Boolean lineNumbers, String namespaceName, CodeDomProvider provider)
{
// 准备类名和命名空间
CodeNamespace codeNamespace = new CodeNamespace(namespaceName);
// 加入引用的命名空间
foreach (String str in item.Imports)
{
if (!String.IsNullOrEmpty(str))
{
codeNamespace.Imports.Add(new CodeNamespaceImport(str));
}
}
CodeTypeDeclaration typeDec = new CodeTypeDeclaration(item.ClassName);
typeDec.IsClass = true;
codeNamespace.Types.Add(typeDec);
// 基类
if (!String.IsNullOrEmpty(item.BaseClassName))
{
typeDec.BaseTypes.Add(new CodeTypeReference(item.BaseClassName));
}
else if (!String.IsNullOrEmpty(BaseClassName))
{
typeDec.BaseTypes.Add(new CodeTypeReference(BaseClassName));
}
else
{
typeDec.BaseTypes.Add(new CodeTypeReference(typeof(TemplateBase)));
}
if (!String.IsNullOrEmpty(item.Name))
{
typeDec.LinePragma = new CodeLinePragma(item.Name, 1);
}
// Render方法
CreateRenderMethod(item.Blocks, lineNumbers, typeDec);
// 代码生成选项
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.VerbatimOrder = true;
options.BlankLinesBetweenMembers = false;
options.BracingStyle = "C";
// 其它类成员代码块
Boolean firstMemberFound = false;
foreach (Block block in item.Blocks)
{
firstMemberFound = GenerateMemberForBlock(block, typeDec, lineNumbers, provider, options, firstMemberFound);
}
// 模版变量
if (item.Vars != null && item.Vars.Count > 0)
{
// 构建静态构造函数，初始化静态属性Vars
CreateCctorMethod(typeDec, item.Vars);
//public Int32 VarName
//{
// get { return (Int32)GetData("VarName"); }
// set { Data["VarName"] = value; }
//}
foreach (String v in item.Vars.Keys)
{
TypeX vtype = TypeX.Create(item.Vars[v]);
String codeName = vtype.FullName;
StringBuilder sb = new StringBuilder();
sb.AppendLine();
sb.AppendFormat("public {0} {1}", codeName, v);
sb.AppendLine("{");
sb.AppendFormat(" get {{ return GetData<{0}>(\"{1}\"); }}", codeName, v);
sb.AppendLine();
sb.AppendFormat(" set {{ Data[\"{0}\"] = value; }}", v);
sb.AppendLine();
sb.AppendLine("}");
CodeSnippetTypeMember member = new CodeSnippetTypeMember(sb.ToString());
typeDec.Members.Add(member);
}
}
// 输出
using (StringWriter writer = new StringWriter())
{
provider.GenerateCodeFromNamespace(codeNamespace, new IndentedTextWriter(writer), options);
return(writer.ToString());
}
}
//Generate code for class Node
private void GenerateNode()
{
CodeNamespace ns = new CodeNamespace("GenericList");
compileUnit.Namespaces.Add(ns);
//Create class Node
CodeTypeDeclaration nodeClass = new CodeTypeDeclaration("Node");
//Add types to generic class
nodeClass.TypeParameters.Add(keyTypeParameter);
nodeClass.TypeParameters.Add(itemTypeParameter);
//Add class to namespace
ns.Types.Add(nodeClass);
//Add field
//public K Key;
CodeMemberField keyField = GeneratePublicField("Key", keyType);
//Add start region directive
//#region Public Fields
keyField.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Public Fields"));
nodeClass.Members.Add(keyField);
//Add field
//public T item;
CodeMemberField itemField = GeneratePublicField("Item", itemType);
nodeClass.Members.Add(itemField);
//Add field
//public Node<K,T> NextNode
CodeMemberField nextNodeField = GeneratePublicField("NextNode", nodeType);
//Add end region directive
//#endregion
nextNodeField.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "End"));
nodeClass.Members.Add(nextNodeField);
//Add default constructor
#region C# code
//Node()
//{
// Key = K.default;
// Item = new T();
// NextNode = null;
//}
#endregion
CodeStatementCollection defConstructorColl = new CodeStatementCollection();
//this.Key = K.default
defConstructorColl.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"Key"),
new CodeDefaultValueExpression(keyType)));
//this.item = new T()
defConstructorColl.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"Item"),
new CodeObjectCreateExpression(itemType, new CodeExpression[] {}))
);
//this.NextNode = null
defConstructorColl.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"NextNode"),
new CodePrimitiveExpression(null))
);
CodeConstructor defConstructor = GeneratePublicConstructor("Node", new CodeTypeReference[] {}, new string[] {}, defConstructorColl);
nodeClass.Members.Add(defConstructor);
//Add parameterized constructor
#region C# code
//Node(K keyPar, T itemPar, Node<K,T> nextNodePar)
//{
// Key = keyPar;
// Item = itemPar;
// NextNode = nextNodePar;
//}
#endregion
CodeStatementCollection parmConstructorColl = new CodeStatementCollection();
//this.Key = keyPar
parmConstructorColl.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"Key"),
new CodeArgumentReferenceExpression("keyPar"))
);
//this.Item = itemPar
parmConstructorColl.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"Item"),
new CodeArgumentReferenceExpression("itemPar"))
);
//this.NextNode = nextNodePar
parmConstructorColl.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"NextNode"),
new CodeArgumentReferenceExpression("nextNodePar"))
);
CodeConstructor parmConstructor = GeneratePublicConstructor("Node", new CodeTypeReference[] { keyType, itemType, nodeType }, new string[] { "keyPar", "itemPar", "nextNodePar" }, parmConstructorColl);
nodeClass.Members.Add(parmConstructor);
TextWriter t = new StreamWriter(path + @"\Node." + provider.FileExtension, false);
provider.GenerateCodeFromNamespace(ns, t, options);
t.Close();
}
/// <summary>
/// Gera o código do mapeamento.
/// </summary>
/// <param name="map">Dados do mapeamento.</param>
/// <param name="baseTypeName">Tipo base da model a ser criada.</param>
/// <param name="outStream">Sream onde sera salvo o codigo gerado.</param>
public void Generate(TableMap map, string baseTypeName, Stream outStream)
{
if (map == null)
{
throw new ArgumentNullException("map");
}
CodeCompileUnit codeCU = new CodeCompileUnit();
codeCU.StartDirectives.Clear();
CodeNamespace codeNsp = new CodeNamespace(_namespaceName);
codeNsp.Imports.Add(new CodeNamespaceImport("System"));
codeNsp.Imports.Add(new CodeNamespaceImport("GDA"));
if (UsingWCFPattern)
{
codeNsp.Imports.Add(new CodeNamespaceImport("System.Runtime.Serialization"));
}
foreach (CodeNamespaceImport cni in _imports)
{
codeNsp.Imports.Add(cni);
}
codeCU.Namespaces.Add(codeNsp);
CodeTypeDeclaration codeType = new CodeTypeDeclaration(StandartName(map.TableName, true));
codeType.Comments.Add(new CodeCommentStatement("<summary>", true));
codeType.Comments.Add(new CodeCommentStatement(string.Format("This class represent the {0} {1}.", (map.IsView ? "view" : "table"), map.TableName), true));
if (!string.IsNullOrEmpty(map.Comment))
{
codeType.Comments.Add(new CodeCommentStatement(map.Comment, true));
}
codeType.Comments.Add(new CodeCommentStatement("</summary>", true));
if (!string.IsNullOrEmpty(baseTypeName))
{
codeType.BaseTypes.Add(new CodeTypeReference(baseTypeName));
}
codeType.CustomAttributes.Add(new CodeAttributeDeclaration("PersistenceClass", new CodeAttributeArgument(new CodeTypeReferenceExpression("\"" + StandartName(map.TableName, false) + "\""))));
if (UsingWCFPattern)
{
CodeAttributeDeclaration codeAD = new CodeAttributeDeclaration("DataContract");
codeAD.Arguments.Add(new CodeAttributeArgument("Name", new CodeTypeReferenceExpression("\"" + StandartName(map.TableName, false) + "\"")));
codeAD.Arguments.Add(new CodeAttributeArgument("Namespace", new CodeTypeReferenceExpression("\"\"")));
codeType.CustomAttributes.Add(codeAD);
}
foreach (CodeAttributeDeclaration attr in _classCustomAttributes)
{
codeType.CustomAttributes.Add(attr);
}
for (int i = 0; i < map.Fields.Count; i++)
{
FieldMap fm = map.Fields[i];
if (string.IsNullOrEmpty(fm.ColumnName))
{
continue;
}
string fieldName = StandartName(fm.ColumnName, true);
if (fieldName.Length > 1)
{
fieldName = "_" + char.ToLower(fieldName[0]) + fieldName.Substring(1);
}
else
{
fieldName = "_" + fieldName.ToUpper();
}
CodeMemberField field = new CodeMemberField(fm.MemberType, fieldName);
codeType.Members.Add(field);
if (i == 0)
{
CodeRegionDirective startlocalVariablesRegion = new CodeRegionDirective(CodeRegionMode.Start, "Local Variables\r\n");
field.StartDirectives.Add(startlocalVariablesRegion);
}
if (i + 1 == map.Fields.Count || map.Fields.Count == 1)
{
CodeRegionDirective endlocalVariablesRegion = new CodeRegionDirective(CodeRegionMode.End, "Local Variables");
field.EndDirectives.Add(endlocalVariablesRegion);
}
}
for (int i = 0; i < map.Fields.Count; i++)
{
FieldMap fm = map.Fields[i];
if (string.IsNullOrEmpty(fm.ColumnName))
{
continue;
}
string fieldName = StandartName(fm.ColumnName, true);
if (fieldName.Length > 1)
{
fieldName = "_" + char.ToLower(fieldName[0]) + fieldName.Substring(1);
}
else
{
fieldName = "_" + fieldName.ToUpper();
}
string propertyName = StandartName(fm.ColumnName, true);
Type pType = fm.MemberType;
CodeMemberProperty property = new CodeMemberProperty();
property.Name = propertyName;
property.Type = new CodeTypeReference(pType);
property.Attributes = MemberAttributes.Public | MemberAttributes.Final;
if (!string.IsNullOrEmpty(fm.Comment))
{
property.Comments.Add(new CodeCommentStatement("<summary>", true));
property.Comments.Add(new CodeCommentStatement(fm.Comment, true));
property.Comments.Add(new CodeCommentStatement("</summary>", true));
}
CodeAttributeDeclaration cadPP = new CodeAttributeDeclaration("PersistenceProperty");
cadPP.Arguments.Add(new CodeAttributeArgument(new CodeTypeReferenceExpression("\"" + fm.ColumnName + "\"")));
if (fm.IsAutoGenerated)
{
cadPP.Arguments.Add(new CodeAttributeArgument(new CodeTypeReferenceExpression("PersistenceParameterType.IdentityKey")));
}
else if (fm.IsPrimaryKey)
{
cadPP.Arguments.Add(new CodeAttributeArgument(new CodeTypeReferenceExpression("PersistenceParameterType.Key")));
}
if (!pType.IsValueType && fm.Size > 0)
{
cadPP.Arguments.Add(new CodeAttributeArgument(new CodeTypeReferenceExpression(fm.Size.ToString())));
}
property.CustomAttributes.Add(cadPP);
if (!pType.IsValueType && !fm.IsNullable)
{
CodeAttributeDeclaration cadReq = new CodeAttributeDeclaration("RequiredValidator");
property.CustomAttributes.Add(cadReq);
}
if (!string.IsNullOrEmpty(fm.ForeignKeyTableName))
{
property.CustomAttributes.Add(new CodeAttributeDeclaration("PersistenceForeignKey", new CodeAttributeArgument(new CodeTypeReferenceExpression("typeof(" + StandartName(fm.ForeignKeyTableName, true) + ")")), new CodeAttributeArgument(new CodeTypeReferenceExpression("\"" + StandartName(fm.ForeignKeyColumnName, true) + "\""))));
}
if (UsingWCFPattern)
{
CodeAttributeDeclaration codeAD = new CodeAttributeDeclaration("DataMember");
codeAD.Arguments.Add(new CodeAttributeArgument("Name", new CodeTypeReferenceExpression("\"" + property.Name + "\"")));
if (!fm.IsNullable)
{
codeAD.Arguments.Add(new CodeAttributeArgument("IsRequired", new CodePrimitiveExpression(true)));
}
property.CustomAttributes.Add(codeAD);
}
foreach (CodeAttributeDeclaration attr in _propertyCustomAttributes)
{
property.CustomAttributes.Add(attr);
}
property.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(null, fieldName)));
property.SetStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(null, fieldName), new CodePropertySetValueReferenceExpression()));
codeType.Members.Add(property);
if (i == 0)
{
CodeRegionDirective startlocalVariablesRegion = new CodeRegionDirective(CodeRegionMode.Start, "Properties\r\n");
property.StartDirectives.Add(startlocalVariablesRegion);
}
if (i + 1 == map.Fields.Count || map.Fields.Count == 1)
{
CodeRegionDirective endlocalVariablesRegion = new CodeRegionDirective(CodeRegionMode.End, "Properties");
property.EndDirectives.Add(endlocalVariablesRegion);
}
}
codeNsp.Types.Add(codeType);
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
options.ElseOnClosing = true;
CodeDomProvider provider = CodeDomProvider.CreateProvider(_codeLanguage);
provider.GenerateCodeFromNamespace(codeNsp, sw, options);
string code = sb.ToString();
code = code.Replace("System.DateTime", "DateTime");
int pos1 = 0, pos2 = 0, pos3 = 0;
do
{
pos1 = code.IndexOf("System.Nullable<", pos1);
if (pos1 >= 0)
{
pos2 = code.IndexOf('>', pos1);
pos3 = pos1 + "System.Nullable<".Length;
code = code.Substring(0, pos1) + code.Substring(pos3, pos2 - pos3) + "?" + code.Substring(pos2 + 1);
}
}while (pos1 >= 0);
outStream.Write(System.Text.Encoding.Default.GetBytes(code), 0, code.Length);
}
/// <summary>
/// Create a new Alpaca client executable using the supplied parameters
/// </summary>
/// <param name="DeviceType">The ASCOM device type to create</param>
/// <param name="DeviceNumber">The number of this device type to create</param>
/// <param name="OutputDirectory">The directory in which to place the compiled assembly</param>
/// <remarks>
/// This subroutine creates compiler source line definitions (not source code as such) and stores them in memory
/// When complete, the compiler is called and the resultant assembly is stored in the specified output directory.
/// The code created has no function as such it is just a shell with all of the heavy lifting undertaken by an inherited base class that is supplied pre-compiled
/// The resultant assembly for Camera device 1 has this form:
///
/// using System;
/// using System.Runtime.InteropServices;
/// namespace ASCOM.DynamicRemoteClients
/// {
/// [Guid("70495DF9-C01E-4987-AE49-E12967202C7F")] <====> The GUID is dynamically created on the user's machine so that it is unique for every driver
/// [ProgId(DRIVER_PROGID)]
/// [ServedClassName(DRIVER_DISPLAY_NAME)]
/// [ClassInterface(ClassInterfaceType.None)]
/// public class Camera : CameraBaseClass <====> Created from supplied parameters - all executable code is in the base class
/// {
/// private const string DRIVER_NUMBER = "1"; <====> Created from supplied parameters
/// private const string DEVICE_TYPE = "Camera"; <====> Created from supplied parameters
/// private const string DRIVER_DISPLAY_NAME = SharedConstants.DRIVER_DISPLAY_NAME + " " + DRIVER_NUMBER;
/// private const string DRIVER_PROGID = SharedConstants.DRIVER_PROGID_BASE + DRIVER_NUMBER + "." + DEVICE_TYPE;
/// public Camera() : base(DRIVER_NUMBER, DRIVER_DISPLAY_NAME, DRIVER_PROGID)
/// {
/// }
/// }
/// }
/// </remarks>
internal static void CreateAlpacaClient(string DeviceType, int DeviceNumber, string ProgId, string DisplayName, string localServerPath)
{
TL.LogMessage("CreateAlpacaClient", $"Creating new ProgID: for {DeviceType} device {DeviceNumber} with ProgID: {ProgId} and display name: {DisplayName}");
try
{
// Generate the container unit
CodeCompileUnit program = new CodeCompileUnit();
// Generate the namespace
CodeNamespace ns = new CodeNamespace("ASCOM.DynamicRemoteClients");
// Add required imports
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices"));
// Declare the device class
CodeTypeDeclaration deviceClass = new CodeTypeDeclaration()
{
Name = DeviceType,
IsClass = true
};
// Add the class base type
deviceClass.BaseTypes.Add(new CodeTypeReference {
BaseType = DeviceType + BASE_CLASS_POSTFIX
});
TL.LogMessage("CreateAlpacaClient", "Created base type");
// Create custom attributes to decorate the class
CodeAttributeDeclaration guidAttribute = new CodeAttributeDeclaration("Guid", new CodeAttributeArgument(new CodePrimitiveExpression(Guid.NewGuid().ToString())));
CodeAttributeDeclaration progIdAttribute = new CodeAttributeDeclaration("ProgId", new CodeAttributeArgument(new CodeArgumentReferenceExpression("DRIVER_PROGID")));
CodeAttributeDeclaration servedClassNameAttribute = new CodeAttributeDeclaration("ServedClassName", new CodeAttributeArgument(new CodeArgumentReferenceExpression("DRIVER_DISPLAY_NAME")));
CodeAttributeDeclaration classInterfaceAttribute = new CodeAttributeDeclaration("ClassInterface", new CodeAttributeArgument(new CodeArgumentReferenceExpression("ClassInterfaceType.None")));
CodeAttributeDeclarationCollection customAttributes = new CodeAttributeDeclarationCollection()
{
guidAttribute, progIdAttribute, servedClassNameAttribute, classInterfaceAttribute
};
TL.LogMessage("CreateAlpacaClient", "Created custom attributes");
// Add the custom attributes to the class
deviceClass.CustomAttributes = customAttributes;
// Create some class level private constants
CodeMemberField driverNumberConst = new CodeMemberField(typeof(string), "DRIVER_NUMBER");
driverNumberConst.Attributes = MemberAttributes.Private | MemberAttributes.Const;
driverNumberConst.InitExpression = new CodePrimitiveExpression(DeviceNumber.ToString());
CodeMemberField deviceTypeConst = new CodeMemberField(typeof(string), "DEVICE_TYPE");
deviceTypeConst.Attributes = MemberAttributes.Private | MemberAttributes.Const;
deviceTypeConst.InitExpression = new CodePrimitiveExpression(DeviceType);
CodeMemberField driverDisplayNameConst = new CodeMemberField(typeof(string), "DRIVER_DISPLAY_NAME");
driverDisplayNameConst.Attributes = (MemberAttributes.Private | MemberAttributes.Const);
driverDisplayNameConst.InitExpression = new CodePrimitiveExpression(DisplayName);
CodeMemberField driverProgIDConst = new CodeMemberField(typeof(string), "DRIVER_PROGID");
driverProgIDConst.Attributes = MemberAttributes.Private | MemberAttributes.Const;
driverProgIDConst.InitExpression = new CodePrimitiveExpression(ProgId);
// Add the constants to the class
deviceClass.Members.AddRange(new CodeMemberField[] { driverNumberConst, deviceTypeConst, driverDisplayNameConst, driverProgIDConst });
TL.LogMessage("CreateAlpacaClient", "Added constants to class");
// Declare the class constructor
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public | MemberAttributes.Final;
// Add a call to the base class with required parameters
constructor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("DRIVER_NUMBER"));
constructor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("DRIVER_DISPLAY_NAME"));
constructor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("DRIVER_PROGID"));
deviceClass.Members.Add(constructor);
TL.LogMessage("CreateAlpacaClient", "Added base constructor");
// Add the class to the namespace
ns.Types.Add(deviceClass);
TL.LogMessage("CreateAlpacaClient", "Added class to name space");
// Add the namespace to the program, which is now complete
program.Namespaces.Add(ns);
TL.LogMessage("CreateAlpacaClient", "Added name space to program");
// Construct the path to the output DLL
String dllName = $"{localServerPath.TrimEnd('\\')}\\{SharedConstants.DRIVER_PROGID_BASE}{DeviceNumber}.{DeviceType}.dll";
TL.LogMessage("CreateAlpacaClient", string.Format("Output file name: {0}", dllName));
// Create relevant compiler options to shape the compilation
CompilerParameters cp = new CompilerParameters()
{
GenerateExecutable = false, // Specify output of a DLL
OutputAssembly = dllName, // Specify the assembly file name to generate
GenerateInMemory = false, // Save the assembly as a physical file.
TreatWarningsAsErrors = false, // Don't treat warnings as errors.
IncludeDebugInformation = true // Include debug information
};
TL.LogMessage("CreateAlpacaClient", "Created compiler parameters");
// Add required assembly references to make sure the compilation succeeds
cp.ReferencedAssemblies.Add(@"ASCOM.Attributes.dll"); // Must be present in the current directory because the compiler doesn't use the GAC
cp.ReferencedAssemblies.Add(@"ASCOM.DeviceInterfaces.dll"); // Must be present in the current directory because the compiler doesn't use the GAC
cp.ReferencedAssemblies.Add(@"ASCOM.Newtonsoft.Json.dll"); // Must be present in the current directory because the compiler doesn't use the GAC
cp.ReferencedAssemblies.Add(@"RestSharp.dll"); // Must be present in the current directory
cp.ReferencedAssemblies.Add(@"ASCOM.AlpacaClientDeviceBaseClasses.dll"); // Must be present in the current directory
cp.ReferencedAssemblies.Add(SharedConstants.ALPACA_CLIENT_LOCAL_SERVER); // Must be present in the current directory
Assembly executingAssembly = Assembly.GetExecutingAssembly();
cp.ReferencedAssemblies.Add(executingAssembly.Location);
foreach (AssemblyName assemblyName in executingAssembly.GetReferencedAssemblies())
{
cp.ReferencedAssemblies.Add(Assembly.Load(assemblyName).Location);
}
TL.LogMessage("CreateAlpacaClient", "Added assembly references");
// Create formatting options for the generated code that will be logged into the trace logger
CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions()
{
BracingStyle = "C",
IndentString = " ",
VerbatimOrder = true,
BlankLinesBetweenMembers = false
};
// Get a code provider so that we can compile the program
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
TL.LogMessage("CreateAlpacaClient", "Created CSharp provider");
// Write the generated code to the trace logger
using (MemoryStream outputStream = new MemoryStream())
{
using (StreamWriter writer = new StreamWriter(outputStream))
{
provider.GenerateCodeFromNamespace(ns, writer, codeGeneratorOptions);
}
MemoryStream actualStream = new MemoryStream(outputStream.ToArray());
using (StreamReader reader = new StreamReader(actualStream))
{
do
{
TL.LogMessage("GeneratedCode", reader.ReadLine());
} while (!reader.EndOfStream);
}
}
provider.Dispose();
// Compile the source contained in the "program" variable
CompilerResults cr = provider.CompileAssemblyFromDom(cp, program);
TL.LogMessage("CreateAlpacaClient", string.Format("Compiled assembly - {0} errors", cr.Errors.Count));
// Report success or errors
if (cr.Errors.Count > 0)
{
// Display compilation errors.
foreach (CompilerError ce in cr.Errors)
{
TL.LogMessage("CreateAlpacaClient", string.Format("Compiler error: {0}", ce.ToString()));
}
}
else
{
// Display a successful compilation message.
TL.LogMessage("CreateAlpacaClient", "Assembly compiled OK!");
}
TL.BlankLine();
}
catch (Exception ex)
{
TL.LogMessageCrLf("CreateAlpacaClient", ex.ToString());
}
}
public void GenerateCodeFromNamespace(CodeNamespace e, TextWriter w, CodeGeneratorOptions o)
{
provider.GenerateCodeFromNamespace(e, w, o);
}
