public void Add()
{
var collection = new CodeNamespaceImportCollection();
var value = new CodeNamespaceImport();
collection.Add(value);
Assert.Equal(1, collection.Count);
Assert.Same(value, collection[0]);
}
public void AddRange_CodeNamespaceArray_Works(CodeNamespaceImport[] value)
{
var collection = new CodeNamespaceImportCollection();
collection.AddRange(value);
Assert.Equal(value.Length, collection.Count);
for (int i = 0; i < value.Length; i++)
{
Assert.Same(value[i], collection[i]);
}
}
public void Add_SameNamespace_DoesntAdd()
{
var collection = new CodeNamespaceImportCollection();
var value1 = new CodeNamespaceImport("Namespace");
collection.Add(value1);
collection.Add(value1);
Assert.Equal(1, collection.Count);
var value2 = new CodeNamespaceImport("Namespace");
collection.Add(value2);
Assert.Equal(1, collection.Count);
}
private void ValidateNamespaceImports(CodeNamespace e)
{
IEnumerator en = e.Imports.GetEnumerator();
while (en.MoveNext())
{
CodeNamespaceImport imp = (CodeNamespaceImport)en.Current;
if (imp.LinePragma != null)
{
ValidateLinePragmaStart(imp.LinePragma);
}
ValidateNamespaceImport(imp);
}
}
public void Imports_AddMultiple_ReturnsExpected()
{
var codeNamespace = new CodeNamespace();
CodeNamespaceImport type1 = new CodeNamespaceImport("Namespace1");
codeNamespace.Imports.Add(type1);
Assert.Equal(new CodeNamespaceImport[] { type1 }, codeNamespace.Imports.Cast <CodeNamespaceImport>());
CodeNamespaceImport type2 = new CodeNamespaceImport("Namespace2");
codeNamespace.Imports.Add(type2);
Assert.Equal(new CodeNamespaceImport[] { type1, type2 }, codeNamespace.Imports.Cast <CodeNamespaceImport>());
}
private CodeGenUtil()
{
if (CodeGen.DoJava)
{
NamespaceImports = new CodeNamespaceImport[]
{
new CodeNamespaceImport("java.util"),
new CodeNamespaceImport("org.apache.avro"),
new CodeNamespaceImport("org.apache.avro.specific"),
};
}
else
{
NamespaceImports = new CodeNamespaceImport[]
{
new CodeNamespaceImport("System"),
new CodeNamespaceImport("System.Collections.Generic"),
new CodeNamespaceImport("System.Text"),
new CodeNamespaceImport("Avro"),
new CodeNamespaceImport("Avro.Specific")
};
}
FileComment = new CodeCommentStatement(
@"------------------------------------------------------------------------------
<auto-generated>
Generated by " + System.AppDomain.CurrentDomain.FriendlyName + ", version " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version + @"
Changes to this file may cause incorrect behavior and will be lost if code
is regenerated
</auto-generated>
------------------------------------------------------------------------------");
// Visual Studio 2010 http://msdn.microsoft.com/en-us/library/x53a06bb.aspx
ReservedKeywords = new HashSet <string>()
{
"abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char", "checked", "class",
"const", "continue", "decimal", "default", "delegate", "do", "double", "else", "enum", "event",
"explicit", "extern", "false", "finally", "fixed", "float", "for", "foreach", "goto", "if",
"implicit", "in", "int", "interface", "internal", "is", "lock", "long", "namespace", "new",
"null", "object", "operator", "out", "override", "params", "private", "protected", "public",
"readonly", "ref", "return", "sbyte", "sealed", "short", "sizeof", "stackalloc", "static",
"string", "struct", "switch", "this", "throw", "true", "try", "typeof", "uint", "ulong",
"unchecked", "unsafe", "ushort", "using", "virtual", "void", "volatile", "while", "value", "partial"
};
if (CodeGen.DoJava)
{
ReservedKeywords.Remove("long");
}
}
public void Add_SameNamespace_DoesntAdd()
{
var collection = new CodeNamespaceImportCollection();
var value1 = new CodeNamespaceImport("Namespace");
collection.Add(value1);
collection.Add(value1);
Assert.Equal(1, collection.Count);
var value2 = new CodeNamespaceImport("Namespace");
collection.Add(value2);
Assert.Equal(1, collection.Count);
}
public void Process()
{
CodeCompileUnit unit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace("MyTest");
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CodeNamespaceImport import = new CodeNamespaceImport("System");
codeNamespace.Imports.Add(import);
unit.Namespaces.Add(codeNamespace);
CodeTypeDeclaration myObject = new CodeTypeDeclaration("Headset");
codeNamespace.Types.Add(myObject);
CodeMemberField name = new CodeMemberField(typeof(String), "Name");
name.Attributes = MemberAttributes.Public;
myObject.Members.Add(name);
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public;
constructor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "name"));
myObject.Members.Add(constructor);
var codeExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("System.Console"),
"WriteLine",
new CodePrimitiveExpression("Let's get started")
);
var codeExpression2 = new CodeAssignStatement(
new CodeTypeReferenceExpression("Name"),
new CodeTypeReferenceExpression("name")
);
constructor.Statements.Add(codeExpression);
constructor.Statements.Add(codeExpression2);
using (var streamWriter = new StreamWriter("MyCode.cs"))
{
provider.GenerateCodeFromCompileUnit(unit, streamWriter, new CodeGeneratorOptions());
}
}
public sealed override void GenerateCode(DeclarationArray array, StreamWriter writer)
{
IDeclaration[] declarations = array.Declarations;
CodeCompileUnit unit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace();
codeNamespace.Comments.Add(new CodeCommentStatement("扩展类型请使用partial关键字在其他文件扩展，否则更改可能会丢失。", false));
List <IDeclaration> declarations1 = new List <IDeclaration>(Predefines);
declarations1.AddRange(declarations);
foreach (IDeclaration declaration in declarations1)
{
switch (declaration)
{
case PackageDeclaration packageDeclaration:
codeNamespace.Name = packageDeclaration.PackageName;
break;
case UsingDeclaration usingDeclaration:
CodeNamespaceImport import = new CodeNamespaceImport(usingDeclaration.PackageName);
codeNamespace.Imports.Add(import);
break;
case UsingAsDeclaration usingAsDeclaration:
CodeNamespaceImport alias = new CodeNamespaceImport($"{usingAsDeclaration.AliasName} = {usingAsDeclaration.TypeName.RawString}");
codeNamespace.Imports.Add(alias);
break;
case StructDeclaration structDeclaration:
CodeTypeDeclaration type = GetTypeDecalaration(structDeclaration);
codeNamespace.Types.Add(type);
break;
}
}
unit.Namespaces.Add(codeNamespace);
CodeDomProvider provider = CodeDomProvider.CreateProvider(LanguageName);
CodeGeneratorOptions options = new CodeGeneratorOptions
{
BracingStyle = "C",
BlankLinesBetweenMembers = true
};
provider.GenerateCodeFromCompileUnit(unit, writer, options);
}
private CodeNamespace GenerateNamespace()
{
CodeNamespace ns = new CodeNamespace(dynamicObject.Namespace);
// import system and SIM.Core
CodeNamespaceImport system = new CodeNamespaceImport("System");
CodeNamespaceImport simCore = new CodeNamespaceImport("SIM.Core.Objects");
CodeNamespaceImport dataAnnotation = new CodeNamespaceImport("System.ComponentModel.DataAnnotations");
ns.Imports.Add(system);
ns.Imports.Add(simCore);
ns.Imports.Add(dataAnnotation);
// Add new namespace
compileUnit.Namespaces.Add(ns);
return ns;
}
private void CreateTypeManager()
{
string rootClrNamespace = settings.GetClrNamespace(rootElementName.Namespace);
var typeVisibility = settings.NamespaceTypesVisibilityMap.ValueForKey(rootClrNamespace);
CodeNamespace rootCodeNamespace = null;
if (!codeNamespacesTable.TryGetValue(rootClrNamespace, out rootCodeNamespace))
{
//This might happen if the schema set has no global elements and only global types
rootCodeNamespace =
codeNamespacesTable.Values.FirstOrDefault(); //then you can create a root tag with xsi:type
}
if (rootCodeNamespace != null)
{
//It might be null if schema has only simple typed global elements or simple types which we are ignoring for now
var typeManagerDeclaration = TypeBuilder.CreateTypeManager(
rootElementName: rootElementName,
enableServiceReference: settings.EnableServiceReference,
typeDictionaryStatements: typeDictionaryAddStatements,
elementDictionaryStatements: elementDictionaryAddStatements,
wrapperDictionaryStatements: wrapperDictionaryAddStatements,
visibility: typeVisibility);
rootCodeNamespace.Types.Add(typeManagerDeclaration);
//Add using statements in the rest of the namespaces for the root namespace to avoid error on TypeManager reference
//Add using statements in the root namespace for the rest of the namespaces to avoid errors while building type dictionaries
CodeNamespaceImport rootImport = new CodeNamespaceImport(rootCodeNamespace.Name);
foreach (CodeNamespace cns in codeNamespacesTable.Values)
{
if (cns != rootCodeNamespace)
{
if (rootCodeNamespace.Name.Length > 0)
{
cns.Imports.Add(rootImport);
}
if (cns.Name.Length > 0)
{
rootCodeNamespace.Imports.Add(new CodeNamespaceImport(cns.Name));
}
}
}
}
}
public static void Main(string[] args)
{
var employeConstructor = new CodeConstructor();
var nameParameter = new CodeParameterDeclarationExpression(typeof(string), "name");
var salaryParameter = new CodeParameterDeclarationExpression(typeof(int), "salary");
var nameAssignStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("Name"), new CodeVariableReferenceExpression("name"));
var salaryAssingStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("Salary"), new CodeVariableReferenceExpression("salary"));
employeConstructor.Attributes = MemberAttributes.Public;
employeConstructor.Parameters.Add(nameParameter);
employeConstructor.Parameters.Add(salaryParameter);
employeConstructor.Statements.Add(nameAssignStatement);
employeConstructor.Statements.Add(salaryAssingStatement);
var employeClass = new CodeTypeDeclaration("Employe");
var nameMemberField = new CodeMemberField(typeof(string), "Name");
var salaryMemberField = new CodeMemberField(typeof(int), "Salary");
salaryMemberField.Attributes = MemberAttributes.Public;
nameMemberField.Attributes = MemberAttributes.Public;
employeClass.Members.Add(employeConstructor);
employeClass.Members.Add(nameMemberField);
employeClass.Members.Add(salaryMemberField);
var codeNamespace = new CodeNamespace("Section10.GeneratingCode");
var systemImport = new CodeNamespaceImport("System");
codeNamespace.Imports.Add(systemImport);
codeNamespace.Types.Add(employeClass);
var unit = new CodeCompileUnit();
unit.Namespaces.Add(codeNamespace);
using var codeDomProvider = CodeDomProvider.CreateProvider("CSharp");
using var file = new StreamWriter("Employe.cs");
codeDomProvider.GenerateCodeFromCompileUnit(unit, file, null);
Console.WriteLine("File was generated.");
var employe = new Employe("Fernando", 100000);
Console.WriteLine(employe.Name);
Console.WriteLine(employe.Salary);
}
public override string Build(IList <string> imports)
{
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
var compileUnit = new CodeCompileUnit();
// Declares a namespace named TestNamespace.
var testNamespace = new CodeNamespace();
//testNamespace.Name = "TempNHamlNamespace";
// Adds the namespace to the namespace collection of the compile unit.
compileUnit.Namespaces.Add(testNamespace);
foreach (var import in imports)
{
var namespaceImport = new CodeNamespaceImport(import);
testNamespace.Imports.Add(namespaceImport);
}
var generator = CodeDomProvider.CreateGenerator(writer);
var options = new CodeGeneratorOptions();
var declaration = new CodeTypeDeclaration
{
Name = ClassName, IsClass = true
};
declaration.BaseTypes.Add(BaseType);
declaration.Members.Add(RenderMethod);
declaration.Members.AddRange(Members.ToArray());
// var codeNamespace = new CodeNamespace();
testNamespace.Types.Add(declaration);
generator.GenerateCodeFromNamespace(testNamespace, writer, options);
//TODO: implement IDisposable
writer.Close();
}
return(builder.ToString());
}
public static void Run(string[] args)
{
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeNamespace codeNameSpace = new CodeNamespace("MyNamespace");
CodeNamespaceImport codeNamespaceImport = new CodeNamespaceImport("System");
CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration("MyClass");
CodeEntryPointMethod codeEntryPointMethod = new CodeEntryPointMethod();
CodeMethodInvokeExpression codeMethodInvokeExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("Console"),
"WriteLine",
new CodePrimitiveExpression("Test!")
);
codeCompileUnit.Namespaces.Add(codeNameSpace);
codeNameSpace.Imports.Add(codeNamespaceImport);
codeNameSpace.Types.Add(codeTypeDeclaration);
codeTypeDeclaration.Members.Add(codeEntryPointMethod);
codeEntryPointMethod.Statements.Add(codeMethodInvokeExpression);
}
private CodeNamespaceImport[] createUsingDependencies()
{
IList <CodeNamespaceImport> using_dependencies_list = new List <CodeNamespaceImport>();
IList <Slice> slice_list = BackEnd.sdao.listByInterface(id_abstract, id_interface);
foreach (Slice s in slice_list)
{
InnerComponent ic = BackEnd.icdao.retrieve(s.Id_abstract, s.Id_inner);
IList <string> package_list = fetchPackages(ic.Id_functor_app);
foreach (string package in package_list)
{
CodeNamespaceImport using_dependency = new CodeNamespaceImport(package);
using_dependencies_list.Add(using_dependency);
}
}
CodeNamespaceImport[] using_dependencies = new CodeNamespaceImport[using_dependencies_list.Count];
using_dependencies_list.CopyTo(using_dependencies, 0);
return(using_dependencies);
}
private void configurationGenerate(string configurationFilePath, string tableName, SqlConnection conn)
{
CodeNamespaceImport[] lcnmSpace = new CodeNamespaceImport[7];
lcnmSpace[0] = new CodeNamespaceImport("System");
lcnmSpace[1] = new CodeNamespaceImport("System.Collections.Generic");
lcnmSpace[2] = new CodeNamespaceImport("System.Linq");
lcnmSpace[3] = new CodeNamespaceImport("System.Text");
lcnmSpace[4] = new CodeNamespaceImport("System.Data.Entity.ModelConfiguration");
lcnmSpace[5] = new CodeNamespaceImport("DXInfo.Models");
lcnmSpace[6] = new CodeNamespaceImport("System.ComponentModel.DataAnnotations.Schema");
string nmSpace = "DXInfo.Data.Configuration";
CodeTypeReference[] baseClass = new CodeTypeReference[1];
baseClass[0] = new CodeTypeReference("EntityTypeConfiguration<" + tableName + ">");
ConfigurationGenerate cg = new ConfigurationGenerate(lcnmSpace, nmSpace, tableName, tableStructSql, conn, tableName + "Configuration", baseClass, configurationFilePath);
cg.AddConstructor();
cg.GenerateCSharpCode();
}
public static CodeNamespace GenerateFactoryClass(IClassMap classMap)
{
CodeNamespace domainNamespace = new CodeNamespace(classMap.DomainMap.RootNamespace + ".Factories");
CodeTypeDeclaration classDecl = new CodeTypeDeclaration(GetFactoryClassName(classMap));
CodeNamespaceImport import = new CodeNamespaceImport(classMap.GetFullNamespace());
CodeNamespaceImport importNPersist = new CodeNamespaceImport("Puzzle.NPersist.Framework");
domainNamespace.Imports.Add(import);
domainNamespace.Imports.Add(importNPersist);
classDecl.IsClass = true;
GenerateConstructor(classDecl);
GenerateContextField(classDecl);
GenerateFactoryMethods(classMap, classDecl);
domainNamespace.Types.Add(classDecl);
return(domainNamespace);
}
public void AddRange()
{
CodeNamespaceImport ni1 = new CodeNamespaceImport("A");
CodeNamespaceImport ni2 = new CodeNamespaceImport("B");
CodeNamespaceImport ni3 = new CodeNamespaceImport("b");
CodeNamespaceImport ni4 = new CodeNamespaceImport("B");
CodeNamespaceImport ni5 = new CodeNamespaceImport("C");
CodeNamespaceImportCollection coll = new CodeNamespaceImportCollection();
coll.AddRange(new CodeNamespaceImport[] { ni1, ni2 });
Assert.AreEqual(2, coll.Count, "#1");
Assert.AreEqual(0, ((IList)coll).IndexOf(ni1), "#2");
Assert.AreEqual(1, ((IList)coll).IndexOf(ni2), "#3");
coll.AddRange(new CodeNamespaceImport[] { ni3, ni4, ni5 });
Assert.AreEqual(3, coll.Count, "#4");
Assert.AreEqual(0, ((IList)coll).IndexOf(ni1), "#5");
Assert.AreEqual(1, ((IList)coll).IndexOf(ni2), "#6");
Assert.AreEqual(-1, ((IList)coll).IndexOf(ni3), "#7");
Assert.AreEqual(-1, ((IList)coll).IndexOf(ni4), "#8");
Assert.AreEqual(2, ((IList)coll).IndexOf(ni5), "#9");
}
protected virtual void BuildNamespace(CodeNamespace codeNamespace)
{
CodeTypeDeclaration codeType = new CodeTypeDeclaration {
Name = GeneratedTypeName,
IsClass = true
};
foreach (ParsedValue <string> item in this.parser.Namespaces)
{
var import = new CodeNamespaceImport(item.Value);
if (item.FileName != null)
{
import.LinePragma = new CodeLinePragma(item.FileName, item.LineNumber);
}
codeNamespace.Imports.Add(import);
}
BuildPageClass(codeType);
codeNamespace.Types.Add(codeType);
}
public CodeCompileUnit GenerateCompileUnit()
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
foreach (var reference in ReferencedAssemblies)
{
compileUnit.ReferencedAssemblies.Add(reference);
}
currentNamespace.Imports.Clear();
var imports = new List <CodeNamespaceImport>();
foreach (var ns in NamespaceImports)
{
var cuNamespace = new CodeNamespaceImport(ns);
imports.Add(cuNamespace);
currentNamespace.Imports.Add(cuNamespace);
}
compileUnit.Namespaces.Add(currentNamespace);
return(compileUnit);
}
private void UomGenerate()
{
string dbContextFilePath = ConfigurationManager.AppSettings["UowFilePath"];
SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings[this.ConnectiongStringName].ConnectionString);
conn.Open();
SqlCommand command = new SqlCommand(this.TableListSql, conn);
SqlDataAdapter ad = new SqlDataAdapter(command);
DataSet ds = new DataSet();
ad.Fill(ds);
CodeNamespaceImport[] lcnmSpace = new CodeNamespaceImport[6];
lcnmSpace[0] = new CodeNamespaceImport("System");
lcnmSpace[1] = new CodeNamespaceImport("System.Collections.Generic");
lcnmSpace[2] = new CodeNamespaceImport("System.Linq");
lcnmSpace[3] = new CodeNamespaceImport("System.Text");
lcnmSpace[4] = new CodeNamespaceImport("DXInfo.Data.Contracts");
lcnmSpace[5] = new CodeNamespaceImport("DXInfo.Models");
string nmSpace = "DXInfo.Data";
CodeTypeReference[] baseClass = new CodeTypeReference[2];
baseClass[0] = new CodeTypeReference("Uow<" + this.ConnectiongStringName + "DbContext>");
baseClass[1] = new CodeTypeReference("I" + this.ConnectiongStringName + "Uow");
UowGenerate ug = new UowGenerate(lcnmSpace, nmSpace, this.ConnectiongStringName, baseClass, dbContextFilePath);
ug.AddConstructor();
foreach (DataRow dr in ds.Tables[0].Rows)
{
string tableName = dr[0].ToString();
ug.AddProperty(tableName);
}
ug.GenerateCSharpCode();
}
/// <summary>
/// Prevents a default instance of the <see cref="CodeGenUtil"/> class from being created.
/// </summary>
private CodeGenUtil()
{
NamespaceImports = new CodeNamespaceImport[] {
new CodeNamespaceImport("System"),
new CodeNamespaceImport("System.Collections.Generic"),
new CodeNamespaceImport("System.Text"),
new CodeNamespaceImport("global::Avro"),
new CodeNamespaceImport("global::Avro.Specific")
};
FileComment = new CodeCommentStatement(
@"------------------------------------------------------------------------------
<auto-generated>
Generated by " + System.AppDomain.CurrentDomain.FriendlyName + ", version " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version + @"
Changes to this file may cause incorrect behavior and will be lost if code
is regenerated
</auto-generated>
------------------------------------------------------------------------------");
// Visual Studio 2010 https://msdn.microsoft.com/en-us/library/x53a06bb.aspx
// Note:
// 1. Contextual keywords are not reserved keywords e.g. value, partial
// 2. __arglist, __makeref, __reftype, __refvalue are undocumented keywords, but recognised by the C# compiler
ReservedKeywords = new HashSet <string>()
{
"abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char", "checked", "class",
"const", "continue", "decimal", "default", "delegate", "do", "double", "else", "enum", "event",
"explicit", "extern", "false", "finally", "fixed", "float", "for", "foreach", "goto", "if",
"implicit", "in", "int", "interface", "internal", "is", "lock", "long", "namespace", "new",
"null", "object", "operator", "out", "override", "params", "private", "protected", "public",
"readonly", "ref", "return", "sbyte", "sealed", "short", "sizeof", "stackalloc", "static",
"string", "struct", "switch", "this", "throw", "true", "try", "typeof", "uint", "ulong",
"unchecked", "unsafe", "ushort", "using", "virtual", "void", "volatile", "while",
"__arglist", "__makeref", "__reftype", "__refvalue"
};
}
static CodeCompileUnit _ParseCompileUnit(_PC pc)
{
var l = pc.Line;
var c = pc.Column;
var p = pc.Position;
var result = new CodeCompileUnit().Mark(l, c, p);
var ns = new CodeNamespace().Mark(l, c, p);
result.Namespaces.Add(ns);
while (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId)
{
switch (pc.SymbolId)
{
case ST.directive:
var d = _ParseDirective(pc) as CodeDirective;
if (null != d)
{
result.StartDirectives.Add(d);
}
break;
case ST.blockComment:
ns.Comments.Add(_ParseCommentStatement(pc));
break;
case ST.lineComment:
ns.Comments.Add(_ParseCommentStatement(pc, true));
break;
}
}
while (ST.usingKeyword == pc.SymbolId)
{
while (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId)
{
pc.Advance(false);
}
var l2 = pc.Line;
var c2 = pc.Column;
var p2 = pc.Position;
pc.Advance();
var nsi = new CodeNamespaceImport(_ParseNamespaceName(pc)).SetLoc(l2, c2, p2);
if (ST.semi != pc.SymbolId)
{
pc.Error("Expecting ; in using declaration");
}
pc.Advance(false);
ns.Imports.Add(nsi);
}
while (ST.lbracket == pc.SymbolId)
{
var pc2 = pc.GetLookAhead(true);
pc2.Advance();
if (ST.assemblyKeyword != pc2.SymbolId)
{
break;
}
result.AssemblyCustomAttributes.AddRange(_ParseAttributeGroup(pc, false).Value);
}
while (!pc.IsEnded)
{
var startDirs = new CodeDirectiveCollection();
var comments = new CodeCommentStatementCollection();
CodeLinePragma lp = null;
while (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId)
{
switch (pc.SymbolId)
{
case ST.directive:
var d = _ParseDirective(pc);
var llp = d as CodeLinePragma;
if (null != llp)
{
lp = llp;
}
else if (null != d)
{
startDirs.Add(d as CodeDirective);
}
break;
case ST.blockComment:
comments.Add(_ParseCommentStatement(pc));
break;
case ST.lineComment:
comments.Add(_ParseCommentStatement(pc, true));
break;
}
}
if (ST.namespaceKeyword == pc.SymbolId)
{
var nns = _ParseNamespace(pc);
nns.Comments.AddRange(comments);
result.Namespaces.Add(nns);
}
else
{
var t = _ParseTypeDecl(pc, false, pc.Line, pc.Column, pc.Position, null);
t.Comments.AddRange(comments);
t.StartDirectives.AddRange(startDirs);
t.LinePragma = lp;
ns.Types.Add(t);
}
}
return(result);
}
static CodeNamespace _ParseNamespace(_PC pc)
{
var l = pc.Line;
var c = pc.Column;
var p = pc.Position;
var result = new CodeNamespace().Mark(l, c, p);
while (ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId || ST.directive == pc.SymbolId)
{
if (ST.directive != pc.SymbolId)
{
result.Comments.Add(_ParseCommentStatement(pc, true));
}
}
if (ST.namespaceKeyword != pc.SymbolId)
{
pc.Error("Expecting namespace");
}
pc.Advance();
result.Name = _ParseNamespaceName(pc);
if (ST.lbrace != pc.SymbolId)
{
pc.Error("Expecing { in namespace declaration");
}
pc.Advance(false);
if (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId)
{
var pc2 = pc.GetLookAhead(true);
if (ST.usingKeyword == pc2.SymbolId)
{
pc.Advance();
}
}
while (ST.usingKeyword == pc.SymbolId)
{
while (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId)
{
pc.Advance(false);
}
var l2 = pc.Line;
var c2 = pc.Column;
var p2 = pc.Position;
pc.Advance();
var nsi = new CodeNamespaceImport(_ParseNamespaceName(pc)).SetLoc(l2, c2, p2);
if (ST.semi != pc.SymbolId)
{
pc.Error("Expecting ; in using declaration");
}
pc.Advance(false);
result.Imports.Add(nsi);
}
while (ST.rbrace != pc.SymbolId)
{
result.Types.Add(_ParseTypeDecl(pc, false, pc.Line, pc.Column, pc.Position, null));
}
if (ST.rbrace != pc.SymbolId)
{
pc.Error("Unterminated namespace declaration", l, c, p);
}
pc.Advance(false);
return(result);
}
private static void ValidateNamespaceImport(CodeNamespaceImport e)
{
ValidateTypeName(e, "Namespace", e.Namespace);
}
protected override void GenerateNamespaceImport(CodeNamespaceImport e)
{
}
internal static CodeNamespaceCollection GenerateCodeFromXomlDocument(Activity rootActivity, string filePath, string rootNamespace, SupportedLanguages language, IServiceProvider serviceProvider)
{
CodeNamespaceCollection codeNamespaces = new CodeNamespaceCollection();
CodeDomProvider codeDomProvider = CompilerHelpers.GetCodeDomProvider(language);
// generate activity class
string activityFullClassName = rootActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string;
CodeTypeDeclaration activityTypeDeclaration = null;
if (codeDomProvider != null && !string.IsNullOrEmpty(activityFullClassName))
{
// get class and namespace names
string activityNamespaceName, activityClassName;
Helpers.GetNamespaceAndClassName(activityFullClassName, out activityNamespaceName, out activityClassName);
if (codeDomProvider.IsValidIdentifier(activityClassName))
{
DesignerSerializationManager designerSerializationManager = new DesignerSerializationManager(serviceProvider);
using (designerSerializationManager.CreateSession())
{
ActivityCodeDomSerializationManager codeDomSerializationManager = new ActivityCodeDomSerializationManager(designerSerializationManager);
TypeCodeDomSerializer typeCodeDomSerializer = codeDomSerializationManager.GetSerializer(rootActivity.GetType(), typeof(TypeCodeDomSerializer)) as TypeCodeDomSerializer;
// get all activities
bool generateCode = true;
ArrayList allActivities = new ArrayList();
allActivities.Add(rootActivity);
if (rootActivity is CompositeActivity)
{
foreach (Activity activity in Helpers.GetNestedActivities((CompositeActivity)rootActivity))
{
if (Helpers.IsActivityLocked(activity))
{
continue;
}
if (codeDomProvider.IsValidIdentifier(codeDomSerializationManager.GetName(activity)))
{
// WinOE Bug 14561. This is to fix a performance problem. When an activity is added to the activity
// tree at the runtime, it's much faster if the ID of the activity is already set. The code that
// the CodeDomSerializer generates will add the activity first before it sets the ID for the child
// activity. We can change that order by always serializing the children first. Therefore, we
// construct a list where we guarantee that the child will be serialized before its parent.
allActivities.Insert(0, activity);
}
else
{
generateCode = false;
break;
}
}
}
if (generateCode)
{
// Work around!! TypeCodeDomSerializer checks that root component has a site or not, otherwise it
// does not serialize it look at ComponentTypeCodeDomSerializer.cs
DummySite dummySite = new DummySite();
foreach (Activity nestedActivity in allActivities)
{
((IComponent)nestedActivity).Site = dummySite;
}
((IComponent)rootActivity).Site = dummySite;
// create activity partial class
activityTypeDeclaration = typeCodeDomSerializer.Serialize(codeDomSerializationManager, rootActivity, allActivities);
activityTypeDeclaration.IsPartial = true;
// add checksum attribute
if (filePath != null && filePath.Length > 0)
{
MD5 md5 = new MD5CryptoServiceProvider();
byte[] checksumBytes = null;
using (StreamReader streamReader = new StreamReader(filePath))
checksumBytes = md5.ComputeHash(streamReader.BaseStream);
string checksum = string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}{14}{15}", new object[] { checksumBytes[0].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[1].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[2].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[3].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[4].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[5].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[6].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[7].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[8].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[9].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[10].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[11].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[12].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[13].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[14].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[15].ToString("X2", CultureInfo.InvariantCulture) });
CodeAttributeDeclaration xomlSourceAttribute = new CodeAttributeDeclaration(typeof(WorkflowMarkupSourceAttribute).FullName);
xomlSourceAttribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(filePath)));
xomlSourceAttribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(checksum)));
activityTypeDeclaration.CustomAttributes.Add(xomlSourceAttribute);
}
// create a new namespace and add activity class into that
CodeNamespace activityCodeNamespace = new CodeNamespace(activityNamespaceName);
activityCodeNamespace.Types.Add(activityTypeDeclaration);
codeNamespaces.Add(activityCodeNamespace);
}
}
}
}
// generate code for x:Code
if (activityTypeDeclaration != null)
{
Queue activitiesQueue = new Queue(new object[] { rootActivity });
while (activitiesQueue.Count > 0)
{
Activity activity = (Activity)activitiesQueue.Dequeue();
if (Helpers.IsActivityLocked(activity))
{
continue;
}
Queue childActivities = new Queue(new object[] { activity });
while (childActivities.Count > 0)
{
Activity childActivity = (Activity)childActivities.Dequeue();
if (childActivity is CompositeActivity)
{
foreach (Activity nestedChildActivity in ((CompositeActivity)childActivity).Activities)
{
childActivities.Enqueue(nestedChildActivity);
}
}
// generate x:Code
CodeTypeMemberCollection codeSegments = childActivity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
if (codeSegments != null)
{
foreach (CodeSnippetTypeMember codeSegmentMember in codeSegments)
{
activityTypeDeclaration.Members.Add(codeSegmentMember);
}
}
}
}
if (language == SupportedLanguages.CSharp)
{
activityTypeDeclaration.LinePragma = new CodeLinePragma((string)rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int)rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1));
}
//Now make sure we that we also emit line pragma around the constructor
CodeConstructor constructor = null;
CodeMemberMethod method = null;
foreach (CodeTypeMember typeMember in activityTypeDeclaration.Members)
{
if (constructor == null && typeMember is CodeConstructor)
{
constructor = typeMember as CodeConstructor;
}
if (method == null && typeMember is CodeMemberMethod && typeMember.Name.Equals("InitializeComponent", StringComparison.Ordinal))
{
method = typeMember as CodeMemberMethod;
}
if (constructor != null && method != null)
{
break;
}
}
if (constructor != null)
{
constructor.LinePragma = new CodeLinePragma((string)rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int)rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1));
}
if (method != null && language == SupportedLanguages.CSharp)
{
method.LinePragma = new CodeLinePragma((string)rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int)rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1));
}
}
// generate mappings
List <String> clrNamespaces = rootActivity.GetValue(WorkflowMarkupSerializer.ClrNamespacesProperty) as List <String>;
if (clrNamespaces != null)
{
// foreach namespace add these mappings
foreach (CodeNamespace codeNamespace in codeNamespaces)
{
foreach (string clrNamespace in clrNamespaces)
{
if (!String.IsNullOrEmpty(clrNamespace))
{
CodeNamespaceImport codeNamespaceImport = new CodeNamespaceImport(clrNamespace);
codeNamespaceImport.LinePragma = new CodeLinePragma((string)rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int)rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1));
codeNamespace.Imports.Add(codeNamespaceImport);
}
}
}
}
// return namespaces
return(codeNamespaces);
}
protected override void Visit(CodeNamespaceImport ns)
{
Enumerate(ns.LinePragma);
base.Visit(ns);
}
protected abstract void GenerateNamespaceImport(CodeNamespaceImport e);
private void CreateInteropFormProxiesForDocument(List <CodeClass> interopFormClasses, Project currentAssembly, ProjectItem interopFormDoc)
{
if (checkFileExists(currentAssembly, interopFormDoc))
{
return;
}
if (interopFormClasses.Count <= 0)
{
return;
}
CodeCompileUnit unit1 = new CodeCompileUnit();
CodeNamespaceImport import1 = new CodeNamespaceImport(this._attrTypeForm.Namespace);
System.CodeDom.CodeNamespace namespace1 = new System.CodeDom.CodeNamespace();
namespace1.Name = "Interop";
unit1.Namespaces.Add(namespace1);
namespace1.Imports.Add(import1);
namespace1.Imports.Add(new CodeNamespaceImport("System"));
foreach (CodeClass class1 in interopFormClasses)
{
string text2 = class1.FullName;
CodeTypeDeclaration declaration1 = new CodeTypeDeclaration(class1.Name);
namespace1.Types.Add(declaration1);
declaration1.IsClass = true;
declaration1.IsPartial = true;
CodePrimitiveExpression expression2 = new CodePrimitiveExpression(true);
CodeSnippetExpression expression1 = new CodeSnippetExpression("System.Runtime.InteropServices.ClassInterfaceType.AutoDual");
declaration1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.ClassInterface", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(expression1) }));
declaration1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.ComVisible", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(expression2) }));
declaration1.BaseTypes.Add(new CodeTypeReference(typeof(InteropFormProxyBase).Name));
CodeTypeDeclaration declaration2 = new CodeTypeDeclaration("I" + declaration1.Name + "EventSink");
declaration2.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.InterfaceTypeAttribute", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(new CodeSnippetExpression("System.Runtime.InteropServices.ComInterfaceType.InterfaceIsIDispatch")) }));
declaration2.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.ComVisible", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(expression2) }));
declaration2.IsInterface = true;
CodeConstructor constructor1 = new CodeConstructor();
CodeSnippetStatement statement1 = GetStatementInitializeForm(text2);
CodeSnippetStatement statement2 = GetStatementRegisterForm();
constructor1.Statements.Add(statement1);
constructor1.Statements.Add(statement2);
constructor1.Attributes = MemberAttributes.Public;
declaration1.Members.Add(constructor1);
if (class1.Members.Count > 0)
{
foreach (CodeElement element1 in class1.Members)
{
switch (element1.Kind)
{
case vsCMElement.vsCMElementFunction:
CodeFunction2 function1 = (CodeFunction2)element1;
if (function1.Access == vsCMAccess.vsCMAccessPublic)
{
foreach (CodeElement element2 in function1.Attributes)
{
if (this.AttributesMatch(element2, this._attrTypeInitializer))
{
this.AddInitializeMethodForConstructor(declaration1, class1, function1);
break;
}
if (this.AttributesMatch(element2, this._attrTypeMethod))
{
this.AddMethod(declaration1, class1, function1);
break;
}
}
}
break;
case vsCMElement.vsCMElementProperty:
CodeProperty property1 = (CodeProperty)element1;
if (property1.Access == vsCMAccess.vsCMAccessPublic)
{
foreach (CodeElement element3 in property1.Attributes)
{
if (this.AttributesMatch(element3, this._attrTypeProperty))
{
this.AddProperty(declaration1, class1, property1);
break;
}
}
}
break;
case vsCMElement.vsCMElementEvent:
CodeEvent event1 = (CodeEvent)element1;
if (event1.Access == vsCMAccess.vsCMAccessPublic)
{
foreach (CodeElement element3 in event1.Attributes)
{
if (this.AttributesMatch(element3, this._attrTypeEvent))
{
this.AddEvent(currentAssembly, declaration1, class1, event1, declaration2);
break;
}
}
}
break;
}
}
}
if (declaration2.Members.Count > 0)
{
namespace1.Types.Add(declaration2);
declaration1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.ComSourceInterfaces", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(new CodeTypeOfExpression(declaration2.Name)) }));
}
}
ProjectItem generatedFolderItem = GetGeneratedFolderItem(currentAssembly);
FileInfo generatedItemInfo = getGeneratedItem(currentAssembly, generatedFolderItem, interopFormDoc);
StreamWriter writer1 = new StreamWriter(generatedItemInfo.Create());
writer1.AutoFlush = true;
CodeDomProvider provider = GetProvider();
CodeGeneratorOptions options1 = new CodeGeneratorOptions();
provider.GenerateCodeFromCompileUnit(unit1, writer1, options1);
writer1.Close();
writer1.Dispose();
generatedFolderItem.ProjectItems.AddFromFile(generatedItemInfo.FullName);
}
private bool GenerateOutput()
{
string shortClassName, classNamespace;
int dot = className.LastIndexOf('.');
if (dot >= 0)
{
classNamespace = className.Substring(0, dot);
shortClassName = className.Substring(dot + 1);
}
else
{
classNamespace = null;
shortClassName = className;
}
bool isPrivate = false;
if (classModifier != null)
{
string publicModifier = null, privateModifier = null;
if (typeAttributesConverter != null && typeAttributesConverter.CanConvertTo(typeof(string)))
{
try {
publicModifier = typeAttributesConverter.ConvertTo(TypeAttributes.Public, typeof(string)) as string;
privateModifier = typeAttributesConverter.ConvertTo(TypeAttributes.NotPublic, typeof(string)) as string;
} catch (NotSupportedException) {
}
}
if (string.Equals(classModifier, privateModifier, StringComparison.OrdinalIgnoreCase))
{
isPrivate = true;
}
else if (!string.Equals(classModifier, publicModifier, StringComparison.OrdinalIgnoreCase))
{
LogError(classModifierLineNumber, 1503, "Language '" + Language + "' does not support x:ClassModifier '" + classModifier + "'.");
return(false);
}
}
var unit = new CodeCompileUnit();
var ns = new CodeNamespace(classNamespace);
unit.Namespaces.Add(ns);
foreach (string importName in importedNamespaces)
{
var import = new CodeNamespaceImport(importName);
if (importedNamespacesLineNumber != 0)
{
import.LinePragma = new CodeLinePragma(InputFileName.ItemSpec, importedNamespacesLineNumber);
}
ns.Imports.Add(import);
}
var type = new CodeTypeDeclaration {
Name = shortClassName,
IsPartial = true,
BaseTypes = { typeof(ILambdaConverterProvider) }
};
ns.Types.Add(type);
if (isPrivate)
{
type.TypeAttributes &= ~TypeAttributes.Public;
}
var method = new CodeMemberMethod {
Name = "GetConverterForLambda",
PrivateImplementationType = new CodeTypeReference(typeof(ILambdaConverterProvider)),
ReturnType = new CodeTypeReference(typeof(LambdaConverter)),
Parameters =
{
new CodeParameterDeclarationExpression
{
Name = "lambda__",
Type = new CodeTypeReference(typeof(string))
}
},
CustomAttributes =
{
new CodeAttributeDeclaration(new CodeTypeReference(typeof(GeneratedCodeAttribute)))
{
Arguments =
{
new CodeAttributeArgument(new CodePrimitiveExpression(ToolName)),
new CodeAttributeArgument(new CodePrimitiveExpression(typeof(ExtractLambdasFromXaml).Assembly.GetName().Version.ToString()))
}
}
}
};
type.Members.Add(method);
foreach (var lambda in lambdas)
{
var cond = new CodeConditionStatement {
Condition = new CodeBinaryOperatorExpression {
Operator = CodeBinaryOperatorType.ValueEquality,
Left = new CodeArgumentReferenceExpression("lambda__"),
Right = new CodePrimitiveExpression(lambda.Code)
},
TrueStatements =
{
new CodeMethodReturnStatement
{
Expression = new CodeMethodInvokeExpression
{
Method = new CodeMethodReferenceExpression
{
TargetObject = new CodeTypeReferenceExpression(typeof(LambdaConverter)),
MethodName = "Create"
},
Parameters =
{
new CodeSnippetExpression(lambda.Code)
}
},
LinePragma = new CodeLinePragma
{
FileName = InputFileName.ItemSpec,
LineNumber = lambda.LineNumber
}
}
}
};
method.Statements.Add(cond);
}
method.Statements.Add(
new CodeThrowExceptionStatement {
ToThrow = new CodeObjectCreateExpression {
CreateType = new CodeTypeReference(typeof(ArgumentOutOfRangeException)),
Parameters =
{
new CodePrimitiveExpression("lambda__")
}
}
});
try {
using (var writer = File.CreateText(OutputFileName.ItemSpec)) {
var options = new CodeGeneratorOptions();
codeDomProvider.GenerateCodeFromCompileUnit(unit, writer, options);
}
} catch (IOException ex) {
LogError(2002, ex.Message);
return(false);
}
return(true);
}
protected override void GenerateNamespaceImport(CodeNamespaceImport e)
{
Output.Write("namespaceImport");
}
public void AddRange(CodeNamespaceImport[] value) {}
protected virtual void Visit(CodeNamespaceImport ns)
{
}
// Methods
public void Add(CodeNamespaceImport value) {}
private void GenerateNamespaceImport(CodeNamespaceImport e)
{
Output.Write("import ");
OutputIdentifier(e.Namespace);
Output.WriteLine(";");
}
private static void ValidateNamespaceImport(CodeNamespaceImport e)
{
ValidateTypeName(e, nameof(e.Namespace), e.Namespace);
}
private bool BuildSourceDataTree()
{
this._compilParams = this.Parser.CompilParams;
this._codeCompileUnit = new CodeCompileUnit();
this._codeCompileUnit.UserData["AllowLateBound"] = !this.Parser.FStrict;
this._codeCompileUnit.UserData["RequireVariableDeclaration"] = this.Parser.FExplicit;
this._usingVJSCompiler = this._codeDomProvider.FileExtension == ".jsl";
this._sourceDataNamespace = new CodeNamespace(this.Parser.GeneratedNamespace);
string generatedClassName = this.GetGeneratedClassName();
if (this.Parser.BaseTypeName != null)
{
CodeNamespace namespace2 = new CodeNamespace(this.Parser.BaseTypeNamespace);
this._codeCompileUnit.Namespaces.Add(namespace2);
this._intermediateClass = new CodeTypeDeclaration(this.Parser.BaseTypeName);
if (this._designerMode)
{
this._intermediateClass.UserData["BaseClassDefinition"] = this.Parser.DefaultBaseType;
}
else
{
this._intermediateClass.UserData["BaseClassDefinition"] = this.Parser.BaseType;
}
namespace2.Types.Add(this._intermediateClass);
this._intermediateClass.IsPartial = true;
if (!this.PrecompilingForUpdatableDeployment)
{
this._sourceDataClass = new CodeTypeDeclaration(generatedClassName);
this._sourceDataClass.BaseTypes.Add(CodeDomUtility.BuildGlobalCodeTypeReference(Util.MakeFullTypeName(this.Parser.BaseTypeNamespace, this.Parser.BaseTypeName)));
this._sourceDataNamespace.Types.Add(this._sourceDataClass);
}
}
else
{
this._intermediateClass = new CodeTypeDeclaration(generatedClassName);
this._intermediateClass.BaseTypes.Add(CodeDomUtility.BuildGlobalCodeTypeReference(this.Parser.BaseType));
this._sourceDataNamespace.Types.Add(this._intermediateClass);
this._sourceDataClass = this._intermediateClass;
}
this._codeCompileUnit.Namespaces.Add(this._sourceDataNamespace);
if (this.PrecompilingForUpdatableDeployment && (this.Parser.CodeFileVirtualPath == null))
{
return(false);
}
this.GenerateClassAttributes();
if (this._codeDomProvider is VBCodeProvider)
{
this._sourceDataNamespace.Imports.Add(new CodeNamespaceImport("Microsoft.VisualBasic"));
}
if (this.Parser.NamespaceEntries != null)
{
foreach (NamespaceEntry entry in this.Parser.NamespaceEntries.Values)
{
CodeLinePragma pragma;
if (entry.VirtualPath != null)
{
pragma = this.CreateCodeLinePragma(entry.VirtualPath, entry.Line);
}
else
{
pragma = null;
}
CodeNamespaceImport import = new CodeNamespaceImport(entry.Namespace)
{
LinePragma = pragma
};
this._sourceDataNamespace.Imports.Add(import);
}
}
if (this._sourceDataClass != null)
{
CodeTypeReference type = CodeDomUtility.BuildGlobalCodeTypeReference(Util.MakeFullTypeName(this._sourceDataNamespace.Name, this._sourceDataClass.Name));
this._classTypeExpr = new CodeTypeReferenceExpression(type);
}
this.GenerateInterfaces();
this.BuildMiscClassMembers();
if (!this._designerMode && (this._sourceDataClass != null))
{
this._ctor = new CodeConstructor();
this.AddDebuggerNonUserCodeAttribute(this._ctor);
this._sourceDataClass.Members.Add(this._ctor);
this.BuildDefaultConstructor();
}
return(true);
}
protected override void GenerateNamespaceImport(CodeNamespaceImport e)
{
Output.Write("using ");
OutputIdentifier(e.Namespace);
Output.WriteLine(";");
}
