public MainForm()
{
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
CodeCompileUnit cu = GeneraCodigo();
CodeDomProvider dp = CodeDomProvider.CreateProvider("CSharp");
//Imprimir el código
StringWriter sw = new StringWriter();
System.CodeDom.Compiler.IndentedTextWriter itw = new IndentedTextWriter(sw);
CodeGeneratorOptions go = new CodeGeneratorOptions();
go.BlankLinesBetweenMembers = false;
dp.GenerateCodeFromCompileUnit(cu,sw,go);
this.tbFuenteGenerado.Text = sw.ToString();
//Compilar desde dom
CompilerParameters cp = new CompilerParameters(new string[]{},"borrame.dll");
CompilerResults cr = dp.CompileAssemblyFromDom(cp,cu);
tbErrores.Text = "";
foreach(CompilerError ce in cr.Errors){
tbErrores.Text += String.Format("{0}){1} in {2} at line {3} column {4} isWarning{5}",ce.ErrorNumber,ce.ErrorText,ce.FileName,ce.Line,ce.Column,ce.IsWarning);
}
}
public void Deny_Unrestricted ()
{
VBCodeProvider vbprov = new VBCodeProvider ();
Assert.AreEqual ("vb", vbprov.FileExtension, "FileExtension");
Assert.AreEqual (LanguageOptions.CaseInsensitive, vbprov.LanguageOptions, "LanguageOptions");
Assert.IsNotNull (vbprov.CreateCompiler (), "CreateCompiler");
Assert.IsNotNull (vbprov.CreateGenerator (), "CreateGenerator");
try {
Assert.IsNotNull (vbprov.GetConverter (typeof (string)), "GetConverter");
}
catch (NotImplementedException) {
// mono
}
#if NET_2_0
CodeTypeMember ctm = new CodeTypeMember ();
StringWriter sw = new StringWriter ();
CodeGeneratorOptions cgo = new CodeGeneratorOptions ();
try {
vbprov.GenerateCodeFromMember (ctm, sw, cgo);
}
catch (NotImplementedException) {
// mono
}
#endif
}
public void Build(DataStructure dataStructure, string rendererFilename = "")
{
if (string.IsNullOrEmpty(rendererFilename)) { rendererFilename = this.GetFilename(dataStructure); }
var rendererType = new CodeTypeDeclaration(dataStructure.RendererName);
rendererType.IsClass = true;
rendererType.IsPartial = true;
rendererType.BaseTypes.Add(typeof(Renderer));
rendererType.Comments.Add(new CodeCommentStatement("<summary>", true));
rendererType.Comments.Add(new CodeCommentStatement(string.Format("Renderer of {0}", dataStructure.TargetName), true));
rendererType.Comments.Add(new CodeCommentStatement("</summary>", true));
BuildCreate(rendererType, dataStructure);
BuildConstructor(rendererType, dataStructure);
BuildDoInitialize(rendererType, dataStructure);
BuildDoRender(rendererType, dataStructure);
var parserNamespace = new CodeNamespace("CSharpGL");
parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Object).Namespace));
parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Collections.Generic.List<int>).Namespace));
parserNamespace.Types.Add(rendererType);
//生成代码
using (var stream = new StreamWriter(rendererFilename, false))
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CodeGeneratorOptions opentions = new CodeGeneratorOptions();//代码生成选项
opentions.BlankLinesBetweenMembers = true;
opentions.BracingStyle = "C";
opentions.ElseOnClosing = false;
opentions.IndentString = " ";
opentions.VerbatimOrder = true;
codeProvider.GenerateCodeFromNamespace(parserNamespace, stream, opentions);
}
}
public TypescriptSnippetTypeMember(
CodeSnippetTypeMember member,
CodeGeneratorOptions options)
{
_member = member;
_options = options;
}
public void Nullify ()
{
CodeGeneratorOptions cgo = new CodeGeneratorOptions ();
cgo.BlankLinesBetweenMembers = false;
Assert.IsFalse (cgo.BlankLinesBetweenMembers, "BlankLinesBetweenMembers-1");
cgo["BlankLinesBetweenMembers"] = null;
Assert.IsTrue (cgo.BlankLinesBetweenMembers, "BlankLinesBetweenMembers-2");
cgo.BracingStyle = "C";
Assert.AreEqual ("C", cgo.BracingStyle, "BracingStyle-1");
cgo["BracingStyle"] = null;
Assert.AreEqual ("Block", cgo.BracingStyle, "BracingStyle-2");
cgo.ElseOnClosing = true;
Assert.IsTrue (cgo.ElseOnClosing, "ElseOnClosing-1");
cgo["ElseOnClosing"] = null;
Assert.IsFalse (cgo.ElseOnClosing, "ElseOnClosing-2");
cgo.IndentString = "\t";
Assert.AreEqual ("\t", cgo.IndentString, "IndentString-1");
cgo["IndentString"] = null;
Assert.AreEqual (" ", cgo.IndentString, "IndentString-2");
cgo.VerbatimOrder = true;
Assert.IsTrue (cgo.VerbatimOrder, "VerbatimOrder-1");
cgo["VerbatimOrder"] = null;
Assert.IsFalse (cgo.VerbatimOrder, "VerbatimOrder-2");
}
private void GenerateCS()
{
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringWriter sw = new StringWriter();
provider.GenerateCodeFromMember(_method, sw, opts);
StringReader sr = new StringReader(sw.GetStringBuilder().ToString());
string line = sr.ReadLine();
while (string.IsNullOrEmpty(line))
line = sr.ReadLine();
int idx = line.IndexOf(" " + _method.Name + "(");
idx = line.LastIndexOf(' ', idx - 1);
if (_method.Statements.Count > 0)
{
Text = "partial" + line.Remove(0, idx);
Text = sw.GetStringBuilder().Replace(line, Text).ToString();
}
else
{
line = "partial" + line.Remove(0, idx);
idx = line.LastIndexOf(')');
Text = line.Remove(idx + 1) + ";" + Environment.NewLine;
}
}
}
public GeneratorResults ParseToCode(string TemplateCode, string defaultnamespace, string defaultclassname, string baseClassFullName)
{
GeneratorResults razorResults;
var host = new RazorEngineHost(new CSharpRazorCodeLanguage());
host.DefaultBaseClass = baseClassFullName;//typeof(BulaqTemplateForRazorBase).FullName;
host.DefaultNamespace = defaultnamespace;
host.DefaultClassName = defaultclassname;
host.NamespaceImports.Add("System");
host.NamespaceImports.Add("BulaqCMS.Models");
host.GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral");
var engine = new RazorTemplateEngine(host);
using (var reader = new StringReader(TemplateCode))
{
razorResults = engine.GenerateCode(reader);
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
using (StringWriter writer = new StringWriter())
{
IndentedTextWriter indentwriter = new IndentedTextWriter(writer, " ");
codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, indentwriter, options);
indentwriter.Flush();
indentwriter.Close();
LastGeneratedCode = writer.GetStringBuilder().ToString();
string codePath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\code.cs";
File.WriteAllText(codePath, LastGeneratedCode, Encoding.UTF8);
}
}
return razorResults;
}
private void GenerateCS()
{
IMemberOperatorGenerator gen = null;
switch (Operator)
{
case OperatorType.Explicit:
gen = new ExplicitOperatorGeneratorCS();
break;
case OperatorType.Implicit:
gen = new ImplicitOperatorGeneratorCS();
break;
default:
throw new NotImplementedException(string.Format("Какая-то несанкционированная xуйня"));
}
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
gen.GenerateDeclaration(tw, provider, opts, ReturnType, Parameters);
tw.WriteLine("{");
tw.Indent++;
gen.GenerateStatemets(tw, provider, opts, Statements);
tw.Indent--;
tw.WriteLine("}");
Text = tw.InnerWriter.ToString();
}
}
}
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>
/// 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;
}
/// <summary>
/// Writes the code to the disk according to the given options.
/// </summary>
private void WriteCodeFiles()
{
// Ensure the output directory exist in the file system.
EnsureDirectoryExists(options.OutputLocation);
// Create the CodeGenerationOptions instance.
codeGenerationOptions = CodeWriter.CreateCodeGeneratorOptions();
// Do we have to generate separate files?
if (options.GenerateSeparateFiles)
{
// Write the code into separate files.
WriteSeparateCodeFiles();
}
else
{
// Write the code into a singl file.
WriteSingleCodeFile();
}
// Finally write the configuration file.
if (configuration != null)
{
WriteConfigurationFile();
}
WriteTextFiles();
}
public void CodeSnippetBlankLines ()
{
var opt = new CodeGeneratorOptions () {
BlankLinesBetweenMembers = false,
VerbatimOrder = false
};
var ccu = new CodeCompileUnit ();
var ns = new CodeNamespace ("Foo");
ccu.Namespaces.Add (ns);
var t = new CodeTypeDeclaration ("Bar");
ns.Types.Add (t);
t.Members.Add (new CodeSnippetTypeMember ("#line hidden"));
t.Members.Add (new CodeSnippetTypeMember ("#line hidden2"));
t.Members.Add (new CodeMemberMethod () { Name = "Foo" });
using (var sw = new StringWriter ()) {
new CSharpCodeProvider ().GenerateCodeFromCompileUnit (ccu, sw, opt);
var str = sw.ToString ();
Assert.IsFalse (str.Contains ("hidden2private"), "#0");
Assert.IsTrue (str.Contains( "#line hidden#line hidden2"), "#1");
}
}
public string CreateSpecs(out int specCount)
{
var files = FindSpecFiles().ToArray();
specCount = files.Length;
if (specCount < 1)
return string.Empty;
var compile = new CodeCompileUnit();
var globalns = new CodeNamespace();
globalns.Imports.Add(new CodeNamespaceImport("NUnit.Framework"));
globalns.Imports.Add(new CodeNamespaceImport(config.MyNamespace));
compile.Namespaces.Add(globalns);
var specNamespace = new CodeNamespace(config.TargetNamespace + ".ChutzpahSpecs");
compile.Namespaces.Add(specNamespace);
foreach (var fileInfo in files)
{
AddSpec(specNamespace, fileInfo);
}
//specNamespace.Types.AddRange(files.Select(CreateSpec).ToArray());
var provider = CreateProvider();
var options = new CodeGeneratorOptions { BracingStyle = "C", BlankLinesBetweenMembers = false };
var stringBuilder = new StringBuilder();
using (var writer = new StringWriter(stringBuilder))
{
provider.GenerateCodeFromCompileUnit(compile, writer, options);
writer.Flush();
writer.Close();
}
var result = stringBuilder.ToString();
return result;
}
public override void GenerateCodeFromStatement(CodeStatement statement,
TextWriter writer,
CodeGeneratorOptions options)
{
var codeExpressionStatement = statement as CodeExpressionStatement;
if (codeExpressionStatement != null)
{
var methodInvokeExpression =
codeExpressionStatement.Expression as CodeMethodInvokeExpression;
if (methodInvokeExpression != null)
{
if (methodInvokeExpression.Method.MethodName == "Write"
&& methodInvokeExpression.Parameters.Count == 1)
{
var parameter = methodInvokeExpression.Parameters[0] as CodeSnippetExpression;
if ((parameter != null) && (!string.IsNullOrEmpty(parameter.Value)))
{
// Appears to be a candidate for rewriting
string originalValue = parameter.Value;
var processor =
SnippetModifiers.OfType<ICodeSnippetTextModifier>()
.FirstOrDefault(m => m.CanProcessString(originalValue));
if (processor != null)
originalValue = processor.ProcessString(originalValue);
parameter.Value =
"global::" + GetType().FullName + ".PreProcessObject(this, "
+ originalValue + ")";
}
}
}
}
base.GenerateCodeFromStatement(statement, writer, options);
}
public override string CreateContent (Project project, Dictionary<string, string> tags, string language)
{
if (language == null || language == "")
throw new InvalidOperationException ("Language not defined in CodeDom based template.");
var binding = GetLanguageBinding (language);
CodeDomProvider provider = null;
if (binding != null)
provider = binding.GetCodeDomProvider ();
if (provider == null)
throw new InvalidOperationException ("The language '" + language + "' does not have support for CodeDom.");
var xcd = new XmlCodeDomReader ();
var cu = xcd.ReadCompileUnit (domContent);
foreach (CodeNamespace cns in cu.Namespaces)
cns.Name = StripImplicitNamespace (project, tags, cns.Name);
CodeGeneratorOptions options = new CodeGeneratorOptions ();
options.IndentString = "\t";
options.BracingStyle = "C";
StringWriter sw = new StringWriter ();
provider.GenerateCodeFromCompileUnit (cu, sw, options);
sw.Close ();
return StripHeaderAndBlankLines (sw.ToString (), provider);
}
public override SyntaxTree GetSyntaxTree(string sourcePath, Stream sourceStream)
{
try
{
var viewFullPath = sourcePath;
var viewVirtualPath = GetRelativeUri(sourcePath, Compilation.CurrentDirectory.FullName);
var viewConfig = WebConfigurationManager.OpenMappedWebConfiguration(_configMap, viewVirtualPath);
var razorConfig = viewConfig.GetSectionGroup("system.web.webPages.razor") as RazorWebSectionGroup;
var host = razorConfig == null
? WebRazorHostFactory.CreateDefaultHost(viewVirtualPath, viewFullPath)
: WebRazorHostFactory.CreateHostFromConfig(razorConfig, viewVirtualPath, viewFullPath);
using (var rdr = new StreamReader(sourceStream, Compilation.Encoding, detectEncodingFromByteOrderMarks: true))
using (var provider = CodeDomProvider.CreateProvider("csharp"))
using (var generatedStream = new MemoryStream())
using (var generatedWriter = new StreamWriter(generatedStream, Compilation.Encoding))
{
var engine = new RazorTemplateEngine(host);
var razorOut = engine.GenerateCode(rdr, null, null, viewFullPath);
var codeGenOptions = new CodeGeneratorOptions { VerbatimOrder = true, ElseOnClosing = false, BlankLinesBetweenMembers = false };
provider.GenerateCodeFromCompileUnit(razorOut.GeneratedCode, generatedWriter, codeGenOptions);
// rewind
generatedWriter.Flush();
generatedStream.Position = 0;
return base.GetSyntaxTree(sourcePath, generatedStream);
}
}
catch (Exception ex)
{
Compilation.Diagnostics.Add(Diagnostic.Create(Compilation.ViewGenerationFailed, Compilation.AsLocation(sourcePath), ex.ToString()));
return null;
}
}
public void Write(TranslateAttribute attr, string pathName)
{
using (var writer = new StreamWriter(pathName, false))
{
var options = new CodeGeneratorOptions {
BracingStyle = "C",
IndentString = "\t",
};
var codeNamespace = new CodeNamespace(attr.SourceType.Namespace);
codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
var declaration = DeclareType(attr.SourceType);
codeNamespace.Types.Add(declaration);
declaration.Members.Add(ConvertToTargetMethod(attr));
declaration.Members.Add(ConvertToTargetsMethod(attr));
declaration.Members.Add(UpdateTargetMethod(attr));
declaration.Members.Add(ConvertToSourceMethod(attr));
declaration.Members.Add(ConvertToSourcesMethod(attr));
generator.GenerateCodeFromNamespace(codeNamespace, writer, options);
}
}
/// <summary>
/// Generates code from the specified <paramref name="constructor"/>.
/// </summary>
/// <param name="constructor">Class constructor for which code needs to be generated.</param>
/// <param name="type">Type declaration.</param>
/// <param name="namespace">Namespace declaration.</param>
/// <param name="options">Code generation options.</param>
/// <remarks>
/// This method is a workaround for <see cref="CodeDomProvider.GenerateCodeFromMember"/>
/// not generating constructors properly.
/// </remarks>
private void GenerateCodeFromConstructor(
CodeConstructor constructor,
CodeTypeDeclaration type,
CodeNamespace @namespace,
CodeGeneratorOptions options)
{
const string StartMarker = "___startMarker___";
const string EndMarker = "___endMarker___";
// Insert marker fields around the target constructor
int indexOfMember = type.Members.IndexOf(constructor);
type.Members.Insert(indexOfMember + 1, new CodeMemberField(typeof(int), EndMarker));
type.Members.Insert(indexOfMember, new CodeMemberField(typeof(int), StartMarker));
using (StringWriter buffer = new StringWriter(CultureInfo.InvariantCulture))
{
// Generate type declaration in verbatim order to preserve placement of marker fields
options = options ?? new CodeGeneratorOptions();
options.VerbatimOrder = true;
this.LanguageProvider.GenerateCodeFromNamespace(@namespace, buffer, options);
// Extract constructor code from the generated type code
const string ConstructorCode = "constructor";
Regex regex = new Regex(
@"^[^\r\n]*" + StartMarker + @"[^\n]*$" +
@"(?<" + ConstructorCode + @">.*)" +
@"^[^\r\n]*" + EndMarker + @"[^\n]*$",
RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
string code = regex.Match(buffer.ToString()).Groups[ConstructorCode].Value;
// Write constructor code to the output buffer
this.ClassCode.Write(code);
}
}
public static string CreatePublicApiForAssembly(Assembly assembly)
{
var publicApiBuilder = new StringBuilder();
var cgo = new CodeGeneratorOptions
{
BracingStyle = "C",
BlankLinesBetweenMembers = false
};
using (var provider = new CSharpCodeProvider())
{
var publicTypes = assembly.GetTypes()
.Where(t => t.IsPublic && t.Name != "GeneratedInternalTypeHelper") //GeneratedInternalTypeHelper seems to be a r# runner side effect
.OrderBy(t => t.FullName);
foreach (var publicType in publicTypes)
{
var writer = new StringWriter();
var genClass = CreateClassDeclaration(publicType);
foreach (var memberInfo in publicType.GetMembers().Where(m => !IsDotNetTypeMember(m)).OrderBy(m => m.Name))
{
AddMemberToClassDefinition(genClass, memberInfo);
}
provider.GenerateCodeFromType(genClass, writer, cgo);
var gennedClass = GenerateClassCode(writer);
publicApiBuilder.AppendLine(gennedClass);
}
}
var publicApi = publicApiBuilder.ToString();
return publicApi.Trim();
}
/// <summary>
/// Generates CSharp text from a compile unit and writes it to a text writer with the given options.
/// </summary>
/// <param name="compileUnit">The compile unit to generate text from.</param>
/// <param name="writer">The text writer to write to.</param>
/// <param name="options">The generation options.</param>
public static void GenerateCSharpTo(this CodeCompileUnit compileUnit, TextWriter writer, CodeGeneratorOptions options)
{
using (var provider = new CSharpCodeProvider())
{
provider.GenerateCodeFromCompileUnit(compileUnit, writer, options);
}
}
static void Main(string[] args)
{
// 输出所有支持生成代码的语言
foreach (CompilerInfo ci in CodeDomProvider.GetAllCompilerInfo())
{
foreach (var language in ci.GetLanguages())
{
Console.Write("{0} ", language);
}
Console.WriteLine();
}
CodeNamespace prgNamespace = BuildProgram();
var compilerOptions = new CodeGeneratorOptions()
{
IndentString = " ",
BracingStyle = "C", // 花括号的风格
BlankLinesBetweenMembers = false
};
var codeText = new StringBuilder();
using (var codeWriter = new StringWriter(codeText))
{
CodeDomProvider.CreateProvider("c#").GenerateCodeFromNamespace(
prgNamespace, codeWriter, compilerOptions);
}
var script = codeText.ToString();
Console.WriteLine(script);
Console.Read();
}
static void DumpToFile(string enumName, IEnumerable<string> names, int first)
{
// TODO: Необходимо задавать провайдер из параметров командной строки
// по умолчанию брать Cpp провайдер
var @enum = new CodeTypeDeclaration(enumName) {
IsEnum = true,
};
foreach(var name in names) {
var field = new CodeMemberField(string.Empty, name) {
InitExpression = new CodePrimitiveExpression(first),
};
@enum.Members.Add(field);
first++;
}
var codeProvider = CodeDomProvider.CreateProvider("CSharp");
var options = new CodeGeneratorOptions {
BlankLinesBetweenMembers = false,
BracingStyle = "C",
};
using(var writer = new StreamWriter(enumName + "." + codeProvider.FileExtension)) {
codeProvider.GenerateCodeFromType(@enum, writer, options);
}
}
public void Build(DataStructure dataStructure, string modelFilename = "")
{
if (string.IsNullOrEmpty(modelFilename)) { modelFilename = this.GetFilename(dataStructure); }
// public class DemoModel : IBufferable { }
var modelType = new CodeTypeDeclaration(dataStructure.ModelName);
modelType.IsClass = true;
modelType.IsPartial = true;
modelType.BaseTypes.Add(typeof(IBufferable));
modelType.Comments.Add(new CodeCommentStatement("<summary>", true));
modelType.Comments.Add(new CodeCommentStatement(string.Format("Model of {0}", dataStructure.TargetName), true));
modelType.Comments.Add(new CodeCommentStatement("</summary>", true));
BuildFields(modelType, dataStructure);
BuildGetVertexAttributeBuffer(modelType, dataStructure);
BuildGetIndex(modelType, dataStructure);
var parserNamespace = new CodeNamespace("CSharpGL");
parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Object).Namespace));
parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Collections.Generic.List<int>).Namespace));
parserNamespace.Types.Add(modelType);
//生成代码
using (var stream = new StreamWriter(modelFilename, false))
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CodeGeneratorOptions opentions = new CodeGeneratorOptions();//代码生成选项
opentions.BlankLinesBetweenMembers = true;
opentions.BracingStyle = "C";
opentions.ElseOnClosing = false;
opentions.IndentString = " ";
opentions.VerbatimOrder = true;
codeProvider.GenerateCodeFromNamespace(parserNamespace, stream, opentions);
}
}
/// <summary>
/// Generate the actual code to the given writer.
/// </summary>
public void Generate(TextWriter writer)
{
var provider = CodeDomProvider.CreateProvider("CSharp");
var options = new CodeGeneratorOptions { BracingStyle = "C" };
provider.GenerateCodeFromCompileUnit(codeCompileUnit, writer, options);
writer.Flush();
}
private static void GenerateCSharpCode(Entity entity, string path)
{
var targetUnit = new CodeCompileUnit();
var targetNamespace = new CodeNamespace(entity.FullName.Substring(0, entity.FullName.LastIndexOf('.')));
targetNamespace.Imports.Add(new CodeNamespaceImport("System"));
var targetClass = new CodeTypeDeclaration(entity.FullName.Substring(entity.FullName.LastIndexOf('.') + 1))
{
IsClass = true,
IsPartial = true,
TypeAttributes = TypeAttributes.Public
};
targetNamespace.Types.Add(targetClass);
targetUnit.Namespaces.Add(targetNamespace);
foreach (var property in entity.Properties)
{
CodeTypeReference propertyType;
if (property.IsNavigable)
{
propertyType = new CodeTypeReference(typeof(List<>));
propertyType.TypeArguments.Add((string)RemapTypeForCSharp(property.Type));
}
else
{
propertyType = new CodeTypeReference(RemapTypeForCSharp(property.Type));
}
var backingField = new CodeMemberField(propertyType, "_" + property.Name) {Attributes = MemberAttributes.Private};
if (property.IsNavigable)
backingField.InitExpression = new CodeObjectCreateExpression(propertyType);
targetClass.Members.Add(backingField);
var codeProperty = new CodeMemberProperty
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = property.Name,
HasGet = true,
HasSet = true,
Type = propertyType,
};
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), backingField.Name)));
codeProperty.SetStatements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), backingField.Name),
new CodeVariableReferenceExpression("value")));
targetClass.Members.Add(codeProperty);
}
var provider = CodeDomProvider.CreateProvider("CSharp");
var options = new CodeGeneratorOptions {BracingStyle = "C"};
using (var writer = new StreamWriter(Path.Combine(path, entity.FullName + '.' + provider.FileExtension)))
{
provider.GenerateCodeFromCompileUnit(targetUnit, writer, options);
}
}
public IExpression GetExpression(CodeExpression expression, CodeGeneratorOptions options)
{
if (expression==null)
{
throw new ArgumentNullException("expression");
}
return _expressionMap[expression.GetType()](expression, options);
}
public override string GetClassCodeForProcessingRun ()
{
var options = new CodeGeneratorOptions ();
using (var sw = new StringWriter ()) {
GenerateCodeFromMembers (sw, options);
return Indent (sw.ToString (), " ");
}
}
private static void WriteCSharpCodeFile(CodeNamespace code, string outputFileName)
{
CSharpCodeProvider provider = new CSharpCodeProvider();
CodeGeneratorOptions options = new CodeGeneratorOptions();
using (StreamWriter writer = new StreamWriter(outputFileName, false))
provider.GenerateCodeFromNamespace(code, writer, options);
}
public TypescriptThisReferenceExpression(
CodeThisReferenceExpression codeExpression,
CodeGeneratorOptions options)
{
_codeExpression = codeExpression;
_options = options;
System.Diagnostics.Debug.WriteLine("TypescriptThisReferenceExpression Created");
}
private void GenerateCS()
{
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringWriter sw = new StringWriter();
List<CodeTypeReference> implTypes = new List<CodeTypeReference>();
if (_property.ImplementationTypes != null)
{
var arr = new CodeTypeReference[_property.ImplementationTypes.Count];
_property.ImplementationTypes.CopyTo(arr, 0);
_property.ImplementationTypes.Clear();
_property.PrivateImplementationType = null;
implTypes.AddRange(arr);
}
provider.GenerateCodeFromMember(_property, sw, opts);
foreach (CodeTypeReference tr in implTypes)
{
_property.ImplementationTypes.Add(tr);
}
//StringReader sr = new StringReader(sw.GetStringBuilder().ToString());
//string line = sr.ReadLine();
//while (string.IsNullOrEmpty(line) || line.StartsWith("/") || line.StartsWith("["))
// line = sr.ReadLine();
StringBuilder sb = new StringBuilder();
if (InterfaceProperties != null)
{
foreach (CodeTypeReference tr in implTypes)
{
string prop;
if (InterfaceProperties.TryGetValue(tr, out prop))
{
var newProp = Define.Property(_property.Type, MemberAttributes.Private, prop).Implements(tr);
if (_property.HasGet)
{
newProp.GetStatements.Add(Emit.@return(()=>[email protected](_property.Name)));
newProp.HasGet = true;
}
if (_property.HasSet)
{
newProp.SetStatements.Add(Emit.assignProperty(_property.Name, () => CodeDom.VarRef("value")));
newProp.HasSet = true;
}
StringWriter swNew = new StringWriter();
provider.GenerateCodeFromMember(CodeDomTreeProcessor.ProcessMember(newProp, CodeDomGenerator.Language.CSharp),
swNew, opts);
sb.Append(swNew.ToString());
}
}
if (sb.Length > 0)
sb.Insert(0, Environment.NewLine);
}
Text = sw.GetStringBuilder().ToString() + sb.ToString();
}
}
/// <summary>
/// Initialize the static members of the Middle Tier Compiler.
/// </summary>
static MiddleTierCompiler()
{
// Initialize the object
MiddleTierCompiler.codeProvider = CodeDomProvider.CreateProvider("C#");
MiddleTierCompiler.codeGeneratorOptions = new CodeGeneratorOptions();
MiddleTierCompiler.codeGeneratorOptions.BlankLinesBetweenMembers = true;
MiddleTierCompiler.codeGeneratorOptions.BracingStyle = "C";
MiddleTierCompiler.codeGeneratorOptions.IndentString = "\t";
}
public static CodeGeneratorOptions getCodeGeneratorOptions()
{
CodeGeneratorOptions genOptions = new CodeGeneratorOptions();
genOptions.BracingStyle = "C"; //Brackets start on the next line, set to "Block" for the same line
genOptions.BlankLinesBetweenMembers = true; //True by default but let's be certain...
genOptions.IndentString = " "; //The amount of indenting we want to apply to the code
genOptions.VerbatimOrder = true; //Output code in the order we've processed it
return genOptions;
}
private static void GenerateViaCodeDOM(string outputFileName, System.CodeDom.Compiler.CodeDomProvider provider, System.CodeDom.CodeCompileUnit compileUnit)
{
System.CodeDom.Compiler.ICodeGenerator gen = provider.CreateGenerator();
System.CodeDom.Compiler.IndentedTextWriter tw;
tw = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFileName, false), " ");
System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
options.BracingStyle = "C";
gen.GenerateCodeFromCompileUnit(compileUnit, tw, options);
tw.Flush();
tw.Close();
}
internal static void GenerateCode(ITextTemplatingEngineHost host, string content, string namespac, string name,
TextWriter writer)
{
ParsedTemplate pt = ParsedTemplate.FromText(content, host);
if (pt.Errors.HasErrors)
{
host.LogErrors(pt.Errors);
return;
}
TemplateSettings settings = TemplatingEngine.GetSettings(host, pt);
if (name != null)
{
settings.Name = name;
}
if (namespac != null)
{
settings.Namespace = namespac;
}
if (pt.Errors.HasErrors)
{
host.LogErrors(pt.Errors);
return;
}
var ccu = TemplatingEngine.GenerateCompileUnit(host, pt, settings);
if (pt.Errors.HasErrors)
{
host.LogErrors(pt.Errors);
return;
}
var opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
settings.Provider.GenerateCodeFromCompileUnit(ccu, writer, opts);
}
string GenerateCode(ITextTemplatingEngineHost host, string content, string name, string generatorNewline)
{
ParsedTemplate pt = ParsedTemplate.FromText(content, host);
if (pt.Errors.HasErrors)
{
host.LogErrors(pt.Errors);
return(null);
}
TemplateSettings settings = TemplatingEngine.GetSettings(host, pt);
if (name != null)
{
settings.Namespace = name;
}
if (pt.Errors.HasErrors)
{
host.LogErrors(pt.Errors);
return(null);
}
var ccu = TemplatingEngine.GenerateCompileUnit(host, content, pt, settings);
if (pt.Errors.HasErrors)
{
host.LogErrors(pt.Errors);
return(null);
}
var opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (var writer = new System.IO.StringWriter()) {
writer.NewLine = generatorNewline;
settings.Provider.GenerateCodeFromCompileUnit(ccu, writer, opts);
return(writer.ToString());
}
}
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromStatement(System.CodeDom.CodeStatement e, TextWriter w, CodeGeneratorOptions o)
{
}
/// <devdoc>
/// <para>
/// Outputs the language specific representaion of the CodeDom tree
/// refered to by codeNamespace, into writer.
/// </para>
/// </devdoc>
public virtual void GenerateCodeFromNamespace(CodeNamespace codeNamespace, TextWriter writer, CodeGeneratorOptions options)
{
CreateGeneratorHelper().GenerateCodeFromNamespace(codeNamespace, writer, options);
}
void ICodeGenerator.GenerateCodeFromCompileUnit(CodeCompileUnit e, TextWriter w, CodeGeneratorOptions o)
{
throw new NotImplementedException();
}
void ICodeGenerator.GenerateCodeFromType(CodeTypeDeclaration e, TextWriter w, CodeGeneratorOptions o)
{
throw new NotImplementedException();
}
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromExpression(System.CodeDom.CodeExpression e, TextWriter w, CodeGeneratorOptions o)
{
}
public virtual void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options)
{
// Documented to always throw an exception (if not overriden)
throw GetNotImplemented();
// Note: the pattern is different from other GenerateCodeFrom* because
// ICodeGenerator doesn't have a GenerateCodeFromMember member
}
public virtual void GenerateCodeFromNamespace(CodeNamespace codeNamespace, TextWriter writer, CodeGeneratorOptions options)
{
ICodeGenerator cg = CreateGenerator();
if (cg == null)
{
throw GetNotImplemented();
}
cg.GenerateCodeFromNamespace(codeNamespace, writer, options);
}
public virtual void GenerateCodeFromStatement(CodeStatement statement, TextWriter writer, CodeGeneratorOptions options)
{
ICodeGenerator cg = CreateGenerator();
if (cg == null)
{
throw GetNotImplemented();
}
cg.GenerateCodeFromStatement(statement, writer, options);
}
public virtual void GenerateCodeFromType(CodeTypeDeclaration codeType, TextWriter writer, CodeGeneratorOptions options)
{
ICodeGenerator cg = CreateGenerator();
if (cg == null)
{
throw GetNotImplemented();
}
cg.GenerateCodeFromType(codeType, writer, options);
}
/// <devdoc>
/// <para>
/// Generates code from the specified expression and
/// outputs it to the specified textwriter.
/// </para>
/// </devdoc>
public virtual void GenerateCodeFromExpression(CodeExpression expression, TextWriter writer, CodeGeneratorOptions options)
{
CreateGeneratorHelper().GenerateCodeFromExpression(expression, writer, options);
}
/// <devdoc>
/// <para>
/// Outputs the language specific representaion of the CodeDom tree
/// refered to by statement, into writer.
/// </para>
/// </devdoc>
public virtual void GenerateCodeFromStatement(CodeStatement statement, TextWriter writer, CodeGeneratorOptions options)
{
CreateGeneratorHelper().GenerateCodeFromStatement(statement, writer, options);
}
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromNamespace(System.CodeDom.CodeNamespace e, TextWriter w, CodeGeneratorOptions o)
{
}
private static void GenerateCode(Options options)
{
var packageTransform = new NMF.Models.Meta.Meta2ClassesTransformation();
var stopWatch = new Stopwatch();
packageTransform.ForceGeneration = options.Force;
packageTransform.CreateOperations = options.Operations;
packageTransform.DefaultNamespace = options.OverallNamespace;
Dictionary <Uri, string> mappings = null;
if (options.NamespaceMappings != null && options.NamespaceMappings.Count > 0)
{
mappings = new Dictionary <Uri, string>();
foreach (var mapping in options.NamespaceMappings)
{
if (string.IsNullOrEmpty(mapping))
{
continue;
}
var lastIdx = mapping.LastIndexOf('=');
if (lastIdx == -1)
{
Console.WriteLine("Namespace mapping {0} is missing required separator =", mapping);
continue;
}
Uri uri;
if (!Uri.TryCreate(mapping.Substring(0, lastIdx), UriKind.Absolute, out uri))
{
uri = new Uri(mapping.Substring(0, lastIdx), UriKind.Relative);
}
mappings.Add(uri, mapping.Substring(lastIdx + 1));
}
}
var metaPackage = LoadPackageFromFiles(options.InputFiles, options.OverallNamespace, mappings);
if (options.Uri != null)
{
Uri uri;
if (Uri.TryCreate(options.Uri, UriKind.Absolute, out uri))
{
metaPackage.Uri = uri;
}
else
{
Console.Error.WriteLine("The provided string {0} could not be parsed as an absolute URI.", options.Uri);
}
}
if (metaPackage.Uri == null)
{
Console.Error.WriteLine("Warning: There is no base Uri for the provided metamodels. Some features of the generated code will be disabled.");
}
var model = metaPackage.Model;
if (model == null)
{
model = new Model();
model.RootElements.Add(metaPackage);
}
model.ModelUri = metaPackage.Uri;
if (options.NMeta != null)
{
using (var fs = File.Create(options.NMeta))
{
MetaRepository.Instance.Serializer.Serialize(model, fs);
}
}
stopWatch.Start();
var compileUnit = TransformationEngine.Transform <INamespace, CodeCompileUnit>(metaPackage,
options.Parallel
? (ITransformationEngineContext) new ParallelTransformationContext(packageTransform)
: new TransformationContext(packageTransform));
stopWatch.Stop();
Console.WriteLine("Operation took {0}ms", stopWatch.Elapsed.TotalMilliseconds);
CodeDomProvider generator = null;
switch (options.Language)
{
case SupportedLanguage.CS:
generator = new Microsoft.CSharp.CSharpCodeProvider();
break;
case SupportedLanguage.VB:
generator = new Microsoft.VisualBasic.VBCodeProvider();
break;
case SupportedLanguage.CPP:
generator = new Microsoft.VisualC.CppCodeProvider();
break;
case SupportedLanguage.JS:
generator = new Microsoft.JScript.JScriptCodeProvider();
break;
default:
Console.WriteLine("Unknown language detected. Falling back to default C#");
generator = new Microsoft.CSharp.CSharpCodeProvider();
break;
}
var genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions()
{
BlankLinesBetweenMembers = true,
VerbatimOrder = false,
ElseOnClosing = false,
BracingStyle = "C",
IndentString = " "
};
if (options.UseFolders)
{
foreach (var file in MetaFacade.SplitCompileUnit(compileUnit))
{
var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension);
CheckDirectoryExists(fileInfo.Directory);
using (var fs = fileInfo.Create())
{
using (var sw = new StreamWriter(fs))
{
generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions);
}
}
}
}
else
{
using (var sw = new StreamWriter(options.OutputFile))
{
generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions);
}
}
Console.WriteLine("Code generated successfully!");
}
public virtual void GenerateCodeFromExpression(CodeExpression expression, TextWriter writer, CodeGeneratorOptions options)
{
ICodeGenerator cg = CreateGenerator();
if (cg == null)
{
throw GetNotImplemented();
}
cg.GenerateCodeFromExpression(expression, writer, options);
}
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromCompileUnit(System.CodeDom.CodeCompileUnit e, TextWriter w, CodeGeneratorOptions o)
{
}
public virtual new void GenerateCodeFromMember(System.CodeDom.CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options)
{
}
public virtual void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options)
{
throw new NotImplementedException();
}
/// <devdoc>
/// <para>
/// Outputs the language specific representaion of the CodeDom tree
/// refered to by codeType, into writer.
/// </para>
/// </devdoc>
public virtual void GenerateCodeFromType(CodeTypeDeclaration codeType, TextWriter writer, CodeGeneratorOptions options)
{
CreateGeneratorHelper().GenerateCodeFromType(codeType, writer, options);
}
public virtual void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options)
{
throw new NotImplementedException(SR.GetString(SR.NotSupported_CodeDomAPI));
}
void ICodeGenerator.GenerateCodeFromExpression(CodeExpression e, TextWriter w, CodeGeneratorOptions o)
{
throw new NotImplementedException();
}
void ICodeGenerator.GenerateCodeFromNamespace(CodeNamespace e, TextWriter w, CodeGeneratorOptions o)
{
throw new NotImplementedException();
}
public void GenerateProxyClass()
{
EndpointAddress metadataAddress = new EndpointAddress("http://localhost/Sofka.Automation.Dummy.Wcf/Loan.svc?wsdl");
//string = "http://localhost/Sofka.Automation.Dummy.Wcf/Loan.svc";
string outputFile = @"d:\dev\Sofka\Test\TempFiles";
MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress);
mexClient.ResolveMetadataReferences = false;
MetadataSet metaDocs = mexClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(metaDocs);
ServiceContractGenerator generator = new ServiceContractGenerator();
// Add our custom DCAnnotationSurrogate
// to write XSD annotations into the comments.
object dataContractImporter;
XsdDataContractImporter xsdDCImporter;
if (!importer.State.TryGetValue(typeof(XsdDataContractImporter), out dataContractImporter))
{
Console.WriteLine("Couldn't find the XsdDataContractImporter! Adding custom importer.");
xsdDCImporter = new XsdDataContractImporter();
xsdDCImporter.Options = new ImportOptions();
importer.State.Add(typeof(XsdDataContractImporter), xsdDCImporter);
}
else
{
xsdDCImporter = (XsdDataContractImporter)dataContractImporter;
if (xsdDCImporter.Options == null)
{
Console.WriteLine("There were no ImportOptions on the importer.");
xsdDCImporter.Options = new ImportOptions();
}
}
//xsdDCImporter.Options.DataContractSurrogate = new DCAnnotationSurrogate();
// Uncomment the following code if you are going to do your work programmatically rather than add
// the WsdlDocumentationImporters through a configuration file.
/*
* // The following code inserts a custom WsdlImporter without removing the other
* // importers already in the collection.
* System.Collections.Generic.IEnumerable<IWsdlImportExtension> exts = importer.WsdlImportExtensions;
* System.Collections.Generic.List<IWsdlImportExtension> newExts
* = new System.Collections.Generic.List<IWsdlImportExtension>();
* foreach (IWsdlImportExtension ext in exts)
* {
* Console.WriteLine("Default WSDL import extensions: {0}", ext.GetType().Name);
* newExts.Add(ext);
* }
* newExts.Add(new WsdlDocumentationImporter());
* System.Collections.Generic.IEnumerable<IPolicyImportExtension> polExts = importer.PolicyImportExtensions;
* importer = new WsdlImporter(metaDocs, polExts, newExts);
*/
System.Collections.ObjectModel.Collection <ContractDescription> contracts
= importer.ImportAllContracts();
importer.ImportAllEndpoints();
foreach (ContractDescription contract in contracts)
{
generator.GenerateServiceContractType(contract);
}
if (generator.Errors.Count != 0)
{
throw new Exception("There were errors during code compilation.");
}
// Write the code dom
System.CodeDom.Compiler.CodeGeneratorOptions options
= new System.CodeDom.Compiler.CodeGeneratorOptions();
options.BracingStyle = "C";
System.CodeDom.Compiler.CodeDomProvider codeDomProvider
= System.CodeDom.Compiler.CodeDomProvider.CreateProvider("C#");
System.CodeDom.Compiler.IndentedTextWriter textWriter
= new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFile));
codeDomProvider.GenerateCodeFromCompileUnit(
generator.TargetCompileUnit, textWriter, options
);
textWriter.Close();
}
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromType(System.CodeDom.CodeTypeDeclaration e, TextWriter w, CodeGeneratorOptions o)
{
}
/// <devdoc>
/// <para>
/// Outputs the language specific representaion of the CodeDom tree
/// refered to by compileUnit, into writer.
/// </para>
/// </devdoc>
public virtual void GenerateCodeFromCompileUnit(CodeCompileUnit compileUnit, TextWriter writer, CodeGeneratorOptions options)
{
CreateGeneratorHelper().GenerateCodeFromCompileUnit(compileUnit, writer, options);
}
