public void GenerateProperties()
{
List<CodeMemberMethod> methods = type.Members.OfType<CodeMemberMethod>().ToList();
this.GenerateProperties(methods, this.setters, false);
this.GenerateProperties(methods, this.setMethods, true);
foreach (CodeMemberMethod getter in from getter in this.getters
where this.type.Members.Contains(getter) &&
!this.type.Members.OfType<CodeMemberMethod>().Any(m => m != getter && m.Name == getter.Name)
select getter)
{
// Make it a read-only property
if (this.type.IsInterface)
{
CodeSnippetTypeMember property = new CodeSnippetTypeMember();
property.Name = getter.Name;
property.Text = string.Format(" {0} {1} {{ get; }}", getter.ReturnType.BaseType, getter.Name);
property.Comments.AddRange(getter.Comments);
this.type.Members.Add(property);
this.type.Members.Remove(getter);
}
else
{
this.GenerateProperty(getter);
}
}
}
/// <summary>生成成员代码块</summary>
/// <param name="block"></param>
/// <param name="generatorType"></param>
/// <param name="lineNumbers"></param>
/// <param name="provider"></param>
/// <param name="options"></param>
/// <param name="firstMemberFound"></param>
/// <returns></returns>
private static Boolean GenerateMemberForBlock(Block block, CodeTypeDeclaration generatorType, Boolean lineNumbers, CodeDomProvider provider, CodeGeneratorOptions options, Boolean firstMemberFound)
{
CodeSnippetTypeMember member = null;
if (!firstMemberFound)
{
// 发现第一个<#!后，认为是类成员代码的开始，直到下一个<#!作为结束
if (block.Type == BlockType.Member)
{
firstMemberFound = true;
if (!String.IsNullOrEmpty(block.Text))
{
member = new CodeSnippetTypeMember(block.Text);
}
}
}
else
{
// 再次遇到<#!，此时，成员代码准备结束
if (block.Type == BlockType.Member)
{
firstMemberFound = false;
if (!String.IsNullOrEmpty(block.Text))
{
member = new CodeSnippetTypeMember(block.Text);
}
}
else if (block.Type == BlockType.Text)
{
var expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Write", new CodeExpression[] { new CodePrimitiveExpression(block.Text) });
var statement = new CodeExpressionStatement(expression);
using (var writer = new StringWriter())
{
provider.GenerateCodeFromStatement(statement, writer, options);
member = new CodeSnippetTypeMember(writer.ToString());
}
}
else if (block.Type == BlockType.Expression)
{
var expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Write", new CodeExpression[] { new CodeArgumentReferenceExpression(block.Text.Trim()) });
var statement = new CodeExpressionStatement(expression);
using (var writer = new StringWriter())
{
provider.GenerateCodeFromStatement(statement, writer, options);
member = new CodeSnippetTypeMember(writer.ToString());
}
}
else if (block.Type == BlockType.Statement)
{
member = new CodeSnippetTypeMember(block.Text);
}
}
if (member != null)
{
if (lineNumbers)
{
var flag = String.IsNullOrEmpty(block.Name);
var lineNumber = (block.StartLine > 0) ? block.StartLine : 1;
if (flag)
{
generatorType.Members.Add(new CodeSnippetTypeMember("#line " + lineNumber));
}
else
{
member.LinePragma = new CodeLinePragma(block.Name, lineNumber);
}
generatorType.Members.Add(member);
if (flag)
{
generatorType.Members.Add(new CodeSnippetTypeMember("#line default"));
}
}
else
{
generatorType.Members.Add(member);
}
}
return(firstMemberFound);
}
public void RegionsSnippetsAndLinePragmas()
{
var cu = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace("Namespace1");
cu.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Compile Unit Region"));
cu.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cu.Namespaces.Add(ns);
var cd = new CodeTypeDeclaration("Class1");
ns.Types.Add(cd);
cd.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Outer Type Region"));
cd.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cd.Comments.Add(new CodeCommentStatement("Outer Type Comment"));
CodeMemberField field1 = new CodeMemberField(typeof(String), "field1");
CodeMemberField field2 = new CodeMemberField(typeof(String), "field2");
field1.Comments.Add(new CodeCommentStatement("Field 1 Comment"));
field2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Field Region"));
field2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberEvent evt1 = new CodeMemberEvent();
evt1.Name = "Event1";
evt1.Type = new CodeTypeReference(typeof(System.EventHandler));
evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberEvent evt2 = new CodeMemberEvent();
evt2.Name = "Event2";
evt2.Type = new CodeTypeReference(typeof(System.EventHandler));
evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
evt2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Event Region"));
evt2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method1.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event1"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method2.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event2"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
method2.LinePragma = new CodeLinePragma("MethodLinePragma.txt", 500);
method2.Comments.Add(new CodeCommentStatement("Method 2 Comment"));
method2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Method Region"));
method2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberProperty property1 = new CodeMemberProperty();
property1.Name = "Property1";
property1.Type = new CodeTypeReference(typeof(string));
property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property1.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1")));
CodeMemberProperty property2 = new CodeMemberProperty();
property2.Name = "Property2";
property2.Type = new CodeTypeReference(typeof(string));
property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property2.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2")));
property2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Property Region"));
property2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeConstructor constructor1 = new CodeConstructor();
constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeStatement conState1 = new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1"),
new CodePrimitiveExpression("value1"));
conState1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Statements Region"));
constructor1.Statements.Add(conState1);
CodeStatement conState2 = new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2"),
new CodePrimitiveExpression("value2"));
conState2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
constructor1.Statements.Add(conState2);
constructor1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Constructor Region"));
constructor1.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeConstructor constructor2 = new CodeConstructor();
constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value1"));
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value2"));
CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor();
typeConstructor2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Type Constructor Region"));
typeConstructor2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeEntryPointMethod methodMain = new CodeEntryPointMethod();
CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration("NestedClass1");
CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration("NestedClass2");
nestedClass2.LinePragma = new CodeLinePragma("NestedTypeLinePragma.txt", 400);
nestedClass2.Comments.Add(new CodeCommentStatement("Nested Type Comment"));
nestedClass2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Nested Type Region"));
nestedClass2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeTypeDelegate delegate1 = new CodeTypeDelegate();
delegate1.Name = "nestedDelegate1";
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
CodeTypeDelegate delegate2 = new CodeTypeDelegate();
delegate2.Name = "nestedDelegate2";
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
delegate2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Delegate Region"));
delegate2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
var snippet1 = new CodeSnippetTypeMember();
var snippet2 = new CodeSnippetTypeMember();
CodeRegionDirective regionStart = new CodeRegionDirective(CodeRegionMode.End, "");
regionStart.RegionText = "Snippet Region";
regionStart.RegionMode = CodeRegionMode.Start;
snippet2.StartDirectives.Add(regionStart);
snippet2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cd.Members.Add(field1);
cd.Members.Add(method1);
cd.Members.Add(constructor1);
cd.Members.Add(property1);
cd.Members.Add(methodMain);
cd.Members.Add(evt1);
cd.Members.Add(nestedClass1);
cd.Members.Add(delegate1);
cd.Members.Add(snippet1);
cd.Members.Add(field2);
cd.Members.Add(method2);
cd.Members.Add(constructor2);
cd.Members.Add(property2);
cd.Members.Add(typeConstructor2);
cd.Members.Add(evt2);
cd.Members.Add(nestedClass2);
cd.Members.Add(delegate2);
cd.Members.Add(snippet2);
AssertEqual(cu,
@"#region Compile Unit Region
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace Namespace1 {
#region Outer Type Region
// Outer Type Comment
public class Class1 {
// Field 1 Comment
private string field1;
#region Field Region
private string field2;
#endregion
#region Snippet Region
#endregion
#region Type Constructor Region
static Class1() {
}
#endregion
#region Constructor Region
public Class1() {
#region Statements Region
this.field1 = ""value1"";
this.field2 = ""value2"";
#endregion
}
#endregion
public Class1(string value1, string value2)
{
}
public string Property1
{
get
{
return this.field1;
}
}
#region Property Region
public string Property2
{
get
{
return this.field2;
}
}
#endregion
public event System.EventHandler Event1;
#region Event Region
public event System.EventHandler Event2;
#endregion
public void Method1()
{
this.Event1(this, System.EventArgs.Empty);
}
public static void Main()
{
}
#region Method Region
// Method 2 Comment
#line 500 ""MethodLinePragma.txt""
public void Method2()
{
this.Event2(this, System.EventArgs.Empty);
}
#line default
#line hidden
#endregion
public class NestedClass1
{
}
public delegate void nestedDelegate1(object sender, System.EventArgs e);
#region Nested Type Region
// Nested Type Comment
#line 400 ""NestedTypeLinePragma.txt""
public class NestedClass2
{
}
#line default
#line hidden
#endregion
#region Delegate Region
public delegate void nestedDelegate2(object sender, System.EventArgs e);
#endregion
}
#endregion
}
#endregion");
}
public void PostMembersHook(Smoke* smoke, Smoke.Class* klass, CodeTypeDeclaration type)
{
if (Util.IsQObject(klass))
{
CodeMemberProperty emit = new CodeMemberProperty();
emit.Name = "Emit";
emit.Attributes = MemberAttributes.Family | MemberAttributes.New | MemberAttributes.Final;
emit.HasGet = true;
emit.HasSet = false;
string signalsIfaceName = "I" + type.Name + "Signals";
CodeTypeReference returnType = new CodeTypeReference(signalsIfaceName);
emit.Type = returnType;
emit.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(
returnType,
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Q_EMIT")
)));
type.Members.Add(emit);
string className = ByteArrayManager.GetString(klass->className);
int colon = className.LastIndexOf("::", StringComparison.Ordinal);
string prefix = (colon != -1) ? className.Substring(0, colon) : string.Empty;
IList typeCollection = Data.GetTypeCollection(prefix);
CodeTypeDeclaration ifaceDecl = new CodeTypeDeclaration(signalsIfaceName);
ifaceDecl.IsInterface = true;
if (className != "QObject")
{
string parentClassName = ByteArrayManager.GetString(smoke->classes[smoke->inheritanceList[klass->parents]].className);
colon = parentClassName.LastIndexOf("::", StringComparison.Ordinal);
prefix = (colon != -1) ? parentClassName.Substring(0, colon) : string.Empty;
if (colon != -1)
{
parentClassName = parentClassName.Substring(colon + 2);
}
string parentInterface = (prefix != string.Empty) ? prefix.Replace("::", ".") + "." : string.Empty;
parentInterface += "I" + parentClassName + "Signals";
ifaceDecl.BaseTypes.Add(new CodeTypeReference(parentInterface));
}
Dictionary<CodeSnippetTypeMember, CodeMemberMethod> signalEvents = new Dictionary<CodeSnippetTypeMember, CodeMemberMethod>();
GetSignals(smoke, klass, delegate(string signature, string name, string typeName, IntPtr metaMethod)
{
CodeMemberMethod signal = new CodeMemberMethod();
signal.Attributes = MemberAttributes.Abstract;
// capitalize the first letter
StringBuilder builder = new StringBuilder(name);
builder[0] = char.ToUpper(builder[0]);
string tmp = builder.ToString();
signal.Name = tmp;
bool isRef;
try
{
if (typeName == string.Empty)
signal.ReturnType = new CodeTypeReference(typeof(void));
else
signal.ReturnType = Translator.CppToCSharp(typeName, out isRef);
}
catch (NotSupportedException)
{
Debug.Print(" |--Won't wrap signal {0}::{1}", className, signature);
return;
}
CodeAttributeDeclaration attr = new CodeAttributeDeclaration("Q_SIGNAL",
new CodeAttributeArgument(new CodePrimitiveExpression(signature)));
signal.CustomAttributes.Add(attr);
int argNum = 1;
StringBuilder fullNameBuilder = new StringBuilder("Slot");
GetMetaMethodParameters(metaMethod, delegate(string paramType, string paramName)
{
if (paramName == string.Empty)
{
paramName = "arg" + argNum.ToString();
}
argNum++;
CodeParameterDeclarationExpression param;
try
{
short id = smoke->IDType(paramType);
CodeTypeReference paramTypeRef;
if (id > 0)
{
paramTypeRef = Translator.CppToCSharp(smoke->types + id, out isRef);
}
else
{
if (!paramType.Contains("::"))
{
id = smoke->IDType(className + "::" + paramType);
if (id > 0)
{
paramTypeRef = Translator.CppToCSharp(smoke->types + id, out isRef);
}
else
{
paramTypeRef = Translator.CppToCSharp(paramType, out isRef);
}
}
else
{
paramTypeRef = Translator.CppToCSharp(paramType, out isRef);
}
}
param = new CodeParameterDeclarationExpression(paramTypeRef, paramName);
}
catch (NotSupportedException)
{
Debug.Print(" |--Won't wrap signal {0}::{1}", className, signature);
return;
}
if (isRef)
{
param.Direction = FieldDirection.Ref;
}
signal.Parameters.Add(param);
if (argNum == 2)
{
fullNameBuilder.Append('<');
}
fullNameBuilder.Append(param.Type.BaseType);
fullNameBuilder.Append(',');
});
if (fullNameBuilder[fullNameBuilder.Length - 1] == ',')
{
fullNameBuilder[fullNameBuilder.Length - 1] = '>';
}
ifaceDecl.Members.Add(signal);
CodeSnippetTypeMember signalEvent = new CodeSnippetTypeMember();
signalEvent.Name = signal.Name;
CodeSnippetTypeMember existing = signalEvents.Keys.FirstOrDefault(m => m.Name == signal.Name);
if (existing != null)
{
CodeSnippetTypeMember signalEventToUse;
CodeMemberMethod signalToUse;
if (signal.Parameters.Count == 0)
{
signalEventToUse = existing;
signalToUse = signalEvents[existing];
}
else
{
signalEventToUse = signalEvent;
signalToUse = signal;
}
string suffix = signalToUse.Parameters.Cast<CodeParameterDeclarationExpression>().Last().Name;
if (suffix.StartsWith("arg") && suffix.Length > 3 && char.IsDigit(suffix[3]))
{
string lastType = signalToUse.Parameters.Cast<CodeParameterDeclarationExpression>().Last().Type.BaseType;
suffix = lastType.Substring(lastType.LastIndexOf('.') + 1);
}
else
{
StringBuilder lastParamBuilder = new StringBuilder(suffix);
lastParamBuilder[0] = char.ToUpper(lastParamBuilder[0]);
suffix = lastParamBuilder.ToString();
}
signalEventToUse.Text = signalEventToUse.Text.Replace(signalEventToUse.Name, signalEventToUse.Name += suffix);
}
signalEvent.Text = string.Format(@"
public event {0} {1}
{{
add
{{
QObject.Connect(this, Qt.SIGNAL(""{2}""), (QObject) value.Target, Qt.SLOT(value.Method.Name + ""{3}""));
}}
remove
{{
QObject.Disconnect(this, Qt.SIGNAL(""{2}""), (QObject) value.Target, Qt.SLOT(value.Method.Name + ""{3}""));
}}
}}", fullNameBuilder, signalEvent.Name, signature, signature.Substring(signature.IndexOf('(')));
signalEvents.Add(signalEvent, signal);
});
typeCollection.Add(ifaceDecl);
foreach (KeyValuePair<CodeSnippetTypeMember, CodeMemberMethod> signalEvent in signalEvents)
{
CodeSnippetTypeMember implementation = signalEvent.Key;
CodeCommentStatementCollection comments = new CodeCommentStatementCollection();
foreach (CodeTypeMember current in from CodeTypeMember member in type.Members
where member.Name == implementation.Name
select member)
{
if (comments.Count == 0)
{
comments.AddRange(current.Comments);
}
current.Name = "On" + current.Name;
}
signalEvent.Value.Comments.AddRange(comments);
signalEvent.Key.Comments.AddRange(comments);
type.Members.Add(signalEvent.Key);
}
}
}
public void RegionsSnippetsAndLinePragmas()
{
CodeCompileUnit cu = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace("Namespace1");
cu.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Compile Unit Region"));
cu.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cu.Namespaces.Add(ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration("Class1");
ns.Types.Add(cd);
cd.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Outer Type Region"));
cd.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cd.Comments.Add(new CodeCommentStatement("Outer Type Comment"));
CodeMemberField field1 = new CodeMemberField(typeof(String), "field1");
CodeMemberField field2 = new CodeMemberField(typeof(String), "field2");
field1.Comments.Add(new CodeCommentStatement("Field 1 Comment"));
field2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Field Region"));
field2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberEvent evt1 = new CodeMemberEvent();
evt1.Name = "Event1";
evt1.Type = new CodeTypeReference(typeof(System.EventHandler));
evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberEvent evt2 = new CodeMemberEvent();
evt2.Name = "Event2";
evt2.Type = new CodeTypeReference(typeof(System.EventHandler));
evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
evt2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Event Region"));
evt2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method1.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event1"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method2.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event2"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
method2.LinePragma = new CodeLinePragma("MethodLinePragma.txt", 500);
method2.Comments.Add(new CodeCommentStatement("Method 2 Comment"));
method2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Method Region"));
method2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberProperty property1 = new CodeMemberProperty();
property1.Name = "Property1";
property1.Type = new CodeTypeReference(typeof(string));
property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property1.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1")));
CodeMemberProperty property2 = new CodeMemberProperty();
property2.Name = "Property2";
property2.Type = new CodeTypeReference(typeof(string));
property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property2.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2")));
property2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Property Region"));
property2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeConstructor constructor1 = new CodeConstructor();
constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeStatement conState1 = new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1"),
new CodePrimitiveExpression("value1"));
conState1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Statements Region"));
constructor1.Statements.Add(conState1);
CodeStatement conState2 = new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2"),
new CodePrimitiveExpression("value2"));
conState2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
constructor1.Statements.Add(conState2);
constructor1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Constructor Region"));
constructor1.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeConstructor constructor2 = new CodeConstructor();
constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value1"));
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value2"));
CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor();
typeConstructor2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Type Constructor Region"));
typeConstructor2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeEntryPointMethod methodMain = new CodeEntryPointMethod();
CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration("NestedClass1");
CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration("NestedClass2");
nestedClass2.LinePragma = new CodeLinePragma("NestedTypeLinePragma.txt", 400);
nestedClass2.Comments.Add(new CodeCommentStatement("Nested Type Comment"));
nestedClass2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Nested Type Region"));
nestedClass2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeTypeDelegate delegate1 = new CodeTypeDelegate();
delegate1.Name = "nestedDelegate1";
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
CodeTypeDelegate delegate2 = new CodeTypeDelegate();
delegate2.Name = "nestedDelegate2";
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
delegate2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Delegate Region"));
delegate2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
var snippet1 = new CodeSnippetTypeMember();
var snippet2 = new CodeSnippetTypeMember();
CodeRegionDirective regionStart = new CodeRegionDirective(CodeRegionMode.End, "");
regionStart.RegionText = "Snippet Region";
regionStart.RegionMode = CodeRegionMode.Start;
snippet2.StartDirectives.Add(regionStart);
snippet2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cd.Members.Add(field1);
cd.Members.Add(method1);
cd.Members.Add(constructor1);
cd.Members.Add(property1);
cd.Members.Add(methodMain);
cd.Members.Add(evt1);
cd.Members.Add(nestedClass1);
cd.Members.Add(delegate1);
cd.Members.Add(snippet1);
cd.Members.Add(field2);
cd.Members.Add(method2);
cd.Members.Add(constructor2);
cd.Members.Add(property2);
cd.Members.Add(typeConstructor2);
cd.Members.Add(evt2);
cd.Members.Add(nestedClass2);
cd.Members.Add(delegate2);
cd.Members.Add(snippet2);
AssertEqual(cu,
@"#Region ""Compile Unit Region""
'------------------------------------------------------------------------------
' <auto-generated>
' This code was generated by a tool.
' Runtime Version:4.0.30319.42000
'
' Changes to this file may cause incorrect behavior and will be lost if
' the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------
Option Strict Off
Option Explicit On
Namespace Namespace1
#Region ""Outer Type Region""
'Outer Type Comment
Public Class Class1
'Field 1 Comment
Private field1 As String
#Region ""Field Region""
Private field2 As String
#End Region
#Region ""Snippet Region""
#End Region
#Region ""Type Constructor Region""
Shared Sub New()
End Sub
#End Region
#Region ""Constructor Region""
Public Sub New()
MyBase.New
Me.field1 = ""value1""
Me.field2 = ""value2""
End Sub
#End Region
Public Sub New(ByVal value1 As String, ByVal value2 As String)
MyBase.New
End Sub
Public ReadOnly Property Property1() As String
Get
Return Me.field1
End Get
End Property
#Region ""Property Region""
Public ReadOnly Property Property2() As String
Get
Return Me.field2
End Get
End Property
#End Region
Public Event Event1 As System.EventHandler
#Region ""Event Region""
Public Event Event2 As System.EventHandler
#End Region
Public Sub Method1()
RaiseEvent Event1(Me, System.EventArgs.Empty)
End Sub
Public Shared Sub Main()
End Sub
#Region ""Method Region""
'Method 2 Comment
#ExternalSource(""MethodLinePragma.txt"",500)
Public Sub Method2()
RaiseEvent Event2(Me, System.EventArgs.Empty)
End Sub
#End ExternalSource
#End Region
Public Class NestedClass1
End Class
Public Delegate Sub nestedDelegate1(ByVal sender As Object, ByVal e As System.EventArgs)
#Region ""Nested Type Region""
'Nested Type Comment
#ExternalSource(""NestedTypeLinePragma.txt"",400)
Public Class NestedClass2
End Class
#End ExternalSource
#End Region
#Region ""Delegate Region""
Public Delegate Sub nestedDelegate2(ByVal sender As Object, ByVal e As System.EventArgs)
#End Region
End Class
#End Region
End Namespace
#End Region");
}
private void GenerateProperties(ICollection<CodeMemberMethod> methods, IEnumerable<CodeMemberMethod> settersToUse, bool readOnly)
{
foreach (CodeMemberMethod setter in settersToUse)
{
if (!this.type.Members.Contains(setter))
{
continue;
}
string afterSet = setter.Name.Substring(3);
for (int i = this.nonSetters.Count - 1; i >= 0; i--)
{
CodeMemberMethod getter = this.nonSetters[i];
if (!this.type.Members.Contains(getter))
{
continue;
}
if (string.Compare(getter.Name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 &&
getter.ReturnType.BaseType == setter.Parameters[0].Type.BaseType &&
!methods.Any(m => m != getter && string.Compare(getter.Name, m.Name, StringComparison.OrdinalIgnoreCase) == 0))
{
methods.Remove(getter);
if (this.type.IsInterface)
{
CodeSnippetTypeMember property = new CodeSnippetTypeMember();
property.Name = getter.Name;
string template = readOnly ? " {0} {1} {{ get; }}" : " {0} {1} {{ get; set; }}";
property.Text = string.Format(template, getter.ReturnType.BaseType, getter.Name);
CodeCommentStatementCollection comments = new CodeCommentStatementCollection(getter.Comments);
if (!readOnly)
{
comments.AddRange(setter.Comments);
}
AddComments(property, comments, readOnly);
this.type.Members.Add(property);
this.type.Members.Remove(getter);
if (!readOnly)
{
this.type.Members.Remove(setter);
}
}
else
{
this.GenerateProperty(getter, readOnly ? null : setter);
}
goto next;
}
}
CodeTypeMember baseVirtualProperty = this.GetBaseVirtualProperty(this.type, afterSet);
if (!this.type.IsInterface && baseVirtualProperty != null)
{
CodeMemberMethod getter = new CodeMemberMethod { Name = baseVirtualProperty.Name };
getter.ReturnType = setter.Parameters[0].Type;
getter.Statements.Add(new CodeSnippetStatement(string.Format(" return base.{0};", afterSet)));
this.GenerateProperty(getter, readOnly ? null : setter);
}
next:
;
}
foreach (CodeMemberMethod nonSetter in this.nonSetters)
{
CodeTypeMember baseVirtualProperty = this.GetBaseVirtualProperty(this.type, nonSetter.Name);
if (!this.type.IsInterface && baseVirtualProperty != null)
{
bool isReadOnly = (baseVirtualProperty is CodeMemberProperty && !((CodeMemberProperty) baseVirtualProperty).HasSet) ||
!regexPropertySetter.IsMatch(((CodeSnippetTypeMember) baseVirtualProperty).Text);
if (readOnly == isReadOnly)
{
CodeMemberMethod setter = new CodeMemberMethod { Name = baseVirtualProperty.Name };
setter.Statements.Add(new CodeSnippetStatement(string.Format(" base.{0} = value;", nonSetter.Name)));
this.GenerateProperty(nonSetter, readOnly ? null : setter);
}
}
}
}
protected override void GenerateSnippetMember
(CodeSnippetTypeMember e)
{
Output.Write(e.Text);
}
public static CodeTypeDeclaration AddMethod(this CodeTypeDeclaration classCode, CodeSnippetTypeMember methodBody)
{
classCode.Members.Add(methodBody);
return(classCode);
}
protected override void GenerateSnippetMember(CodeSnippetTypeMember e)
{
}
/// <summary>
/// Generates the GetEntityState helper method that allows POCO types to retrieve their
/// entity state from the contect. It is not available on the POCO types directly.
/// </summary>
/// <param name="codeGenContext">The context in which we are generating code.</param>
/// <param name="businessLogicClass">The class we are generating.</param>
/// <returns>The <see cref="CodeTypeMember"/> containing the helper method.</returns>
private static CodeTypeMember GenerateGetEntityState(ICodeGenContext codeGenContext, CodeTypeDeclaration businessLogicClass)
{
// Add an import for System.Data.Objects
CodeNamespace codeNamespace = codeGenContext.GetNamespace(businessLogicClass);
if (codeNamespace != null)
{
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Data.Objects"));
}
//private EntityState GetEntityState(object entity)
//{
// ObjectStateEntry stateEntry = null;
// if (!this.ObjectContext.ObjectStateManager.TryGetObjectStateEntry(entity, out stateEntry))
// {
// return EntityState.Detached;
// }
// return stateEntry.State;
//}
// Declaration
CodeMemberMethod method = new CodeMemberMethod();
method.Name = LinqToEntitiesContext.GetEntityStateHelperMethodName;
method.ReturnType = new CodeTypeReference(typeof(EntityState).Name);
method.Attributes = MemberAttributes.Private;
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "entity"));
// ObjectStateEntry stateEntry = null;
method.Statements.Add(new CodeVariableDeclarationStatement("ObjectStateEntry", "stateEntry", new CodePrimitiveExpression(null)));
CodeArgumentReferenceExpression entityArgRef = new CodeArgumentReferenceExpression("entity");
CodeExpression contextRef = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "ObjectContext");
CodeFieldReferenceExpression detachedStateRef = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EntityState).Name), Enum.GetName(typeof(EntityState), EntityState.Detached));
CodePropertyReferenceExpression objectStateMgrRef = new CodePropertyReferenceExpression(contextRef, "ObjectStateManager");
CodeVariableReferenceExpression entityStateRef = new CodeVariableReferenceExpression("stateEntry");
// The "_out_" prefix will be replaced below with the language-appropriate modifier to make an out param.
// CodeDom does not support this, so we must do some string manipulation
CodeVariableReferenceExpression outEntityStateRef = new CodeVariableReferenceExpression("_out_stateEntry");
// this.ObjectContext.ObjectStateManager.TryGetObjectStateEntry(entity, out stateEntry)
CodeMethodInvokeExpression getObjectStateEntryCall = new CodeMethodInvokeExpression(objectStateMgrRef, "TryGetObjectStateEntry", entityArgRef, outEntityStateRef);
// if (...TryGet())
CodeExpression tryGetTest = CodeGenUtilities.MakeEqual(typeof(bool), getObjectStateEntryCall, new CodePrimitiveExpression(false), codeGenContext.IsCSharp);
// if (...TryGet..) { return EntityState.Detached; }
CodeMethodReturnStatement returnDetached = new CodeMethodReturnStatement(detachedStateRef);
CodeConditionStatement ifTryGet = new CodeConditionStatement(tryGetTest, returnDetached);
method.Statements.Add(ifTryGet);
// Return entityState.State;
method.Statements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(entityStateRef, "State")));
// CodeDom does not support specifying 'out' parameters at the method call site.
// So convert the entire method into a snippet of text
StringBuilder snippet = null;
CodeDomProvider provider = codeGenContext.Provider;
using (StringWriter snippetWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture))
{
provider.GenerateCodeFromMember(method, snippetWriter, codeGenContext.CodeGeneratorOptions);
snippet = snippetWriter.GetStringBuilder();
}
// Our convention above is that "_out_" will be replaced by the language-appropriate "out" parameter modifier.
// In the case of VB, it is the default
snippet.Replace("_out_", codeGenContext.IsCSharp ? "out " : string.Empty);
// We need to indent the entire snippet 2 levels
string indent = codeGenContext.CodeGeneratorOptions.IndentString;
indent += indent;
string snippetText = indent + snippet.ToString().Replace(Environment.NewLine, Environment.NewLine + indent).TrimEnd(' ');
CodeSnippetTypeMember methodAsText = new CodeSnippetTypeMember(snippetText);
return(methodAsText);
}
internal static void ProcessDefTag(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, Activity activity, bool newSegment, string fileName)
{
ResourceManager manager = new ResourceManager("System.Workflow.ComponentModel.StringResources", typeof(ActivityBind).Assembly);
if (reader.NodeType == XmlNodeType.Attribute)
{
string str;
if (((str = reader.LocalName) != null) && (str == "Class"))
{
activity.SetValue(WorkflowMarkupSerializer.XClassProperty, reader.Value);
}
else
{
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1));
}
}
else
{
bool flag = false;
bool isEmptyElement = reader.IsEmptyElement;
int depth = reader.Depth;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
string localName = reader.LocalName;
if (localName != null)
{
if (localName == "Code")
{
if (isEmptyElement)
{
flag = true;
}
break;
}
bool flag1 = localName == "Constructor";
}
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1));
return;
}
case XmlNodeType.Text:
case XmlNodeType.CDATA:
{
int num2 = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1;
int num3 = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1;
CodeSnippetTypeMember member = new CodeSnippetTypeMember(reader.Value)
{
LinePragma = new CodeLinePragma(fileName, Math.Max(num2 - 1, 1))
};
member.UserData[UserDataKeys.CodeSegment_New] = newSegment;
member.UserData[UserDataKeys.CodeSegment_ColumnNumber] = (num3 + reader.Name.Length) - 1;
CodeTypeMemberCollection members = activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
if (members == null)
{
members = new CodeTypeMemberCollection();
activity.SetValue(WorkflowMarkupSerializer.XCodeProperty, members);
}
members.Add(member);
break;
}
case XmlNodeType.EndElement:
if (reader.Depth == depth)
{
flag = true;
}
break;
}
}while (!flag && reader.Read());
}
}
/// <summary>
/// Generates the binding path.
/// </summary>
/// <param name="propertyPath">The property path.</param>
/// <param name="mode">The mode.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">Namespace is empty.</exception>
public bool GenerateBindingPath(PropertyPath propertyPath, GeneratedBindingsMode mode)
{
if (ActiveDataType == null || !IsEnabled)
{
return(false);
}
if (ns == null)
{
throw new ArgumentNullException("Namespace is empty.");
}
Type dataType = ActiveDataType;
if (dataType.IsPrimitive)
{
return(false);
}
string path = propertyPath.Path;
string[] pathParts = path.Split(partSeparator, StringSplitOptions.RemoveEmptyEntries);
bool isCollectionProperty = false;
for (int i = 0; i < pathParts.Length; i++)
{
string propertyName = pathParts[i];
int indexStart = propertyName.IndexOfAny(indexStartChars);
if (indexStart != -1)
{
propertyName = propertyName.Substring(0, indexStart);
}
PropertyInfo propertyInfo = dataType.GetRuntimeProperty(propertyName);
int paramStart = propertyName.IndexOfAny(paramStartChars);
if (paramStart != -1)
{
int paramEnd = propertyName.IndexOfAny(paramEndChars);
string paramIndexString = propertyName.Substring(paramStart + 1, paramEnd - paramStart - 1).Trim();
int paramIndex = Convert.ToInt32(paramIndexString);
propertyInfo = propertyPath.PathParameters[paramIndex] as PropertyInfo;
if (propertyInfo != null)
{
propertyName = propertyInfo.Name;
dataType = propertyInfo.ReflectedType;
}
}
string className = string.Format("{0}_{1}_PropertyInfo", dataType.Name, propertyName);
className = Regex.Replace(className, "[`|<|>]", "");
CodeTypeDeclaration classType = CreateClass(className);
if (propertyInfo == null)
{
// if mixed mode return with false (binding was not generated) but don't generate error so reflection can be used
if (mode == GeneratedBindingsMode.Mixed)
{
return(false);
}
CodeSnippetTypeMember error = new CodeSnippetTypeMember(string.Format("#error {0} type does not have property {1}", dataType, propertyName));
classType.Members.Add(error);
ns.Types.Add(classType);
return(false);
}
isCollectionProperty = propertyInfo.PropertyType.IsArray ||
(typeof(IEnumerable).IsAssignableFrom(propertyInfo.PropertyType) && propertyInfo.PropertyType != typeof(string));
Type elementType = propertyInfo.PropertyType.GetElementType();
if (elementType == null && propertyInfo.PropertyType.IsGenericType)
{
elementType = propertyInfo.PropertyType.GetGenericArguments()[0];
}
int key = propertyName.GetHashCode() ^ dataType.GetHashCode();
if (!generated.Contains(key))
{
generated.Add(key);
ns.Types.Add(classType);
GenerateProperties(classType, propertyInfo);
GenerateMethods(dataType, isCollectionProperty, propertyName, classType, propertyInfo, elementType);
propertyInfos.Add(new Tuple <Type, string, string>(dataType, propertyName, ns.Name + "." + className));
}
if (isCollectionProperty)
{
dataType = elementType;
}
else
{
dataType = propertyInfo.PropertyType;
}
}
return(true);
}
/// <summary>
/// Create the code as codedom structure.
/// </summary>
private CodeCompileUnit CreateCompileUnit(string packageName, string generatedCodeNamespace)
{
if (string.IsNullOrEmpty(generatedCodeNamespace))
generatedCodeNamespace = packageName;
var compileUnit = new CodeCompileUnit();
var pkgNamespace = new CodeNamespace(generatedCodeNamespace);
compileUnit.Namespaces.Add(pkgNamespace);
pkgNamespace.Imports.Add(new CodeNamespaceImport("System"));
var rType = new CodeTypeDeclaration("R");
rType.IsClass = true;
rType.TypeAttributes = TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Sealed |
TypeAttributes.Public;
pkgNamespace.Types.Add(rType);
if (resourceTable != null)
{
foreach (var typeSpec in resourceTable.Packages[0].TypeSpecs)
{
if (typeSpec.EntryCount == 0)
continue;
var typeDef = new CodeTypeDeclaration(CreateTypeSpecName(typeSpec));
typeDef.IsClass = true;
typeDef.TypeAttributes = TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Sealed |
TypeAttributes.NestedPublic;
rType.Members.Add(typeDef);
var index = 0;
foreach (var entry in typeSpec.Entries)
{
// Skip code generation for system ID's
if (!SystemIdConstants.Ids.Contains(entry.Key))
{
var resId = 0x7F000000 | ((typeSpec.Id) << 16) | index;
var field = new CodeMemberField(typeof (int), MakeValueNetIdentifier(UnfixResourceName(entry.Key)));
field.Attributes = MemberAttributes.Public | MemberAttributes.Const;
field.InitExpression = new CodeSnippetExpression(string.Format("0x{0:x8}", resId));
typeDef.Members.Add(field);
}
index++;
}
}
if (styleableDeclarations.Any())
{
var styleableTypeDef = new CodeTypeDeclaration("Styleables");
styleableTypeDef.IsClass = true;
styleableTypeDef.TypeAttributes = TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.NestedPublic;
rType.Members.Add(styleableTypeDef);
foreach (var declaration in styleableDeclarations)
{
// Type
var typeDef = new CodeTypeDeclaration(declaration.Name);
typeDef.IsClass = true;
typeDef.TypeAttributes = TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.NestedPublic;
styleableTypeDef.Members.Add(typeDef);
// Array
var list = string.Join(", ", declaration.AttributeNames.Select(x => FormatAttributeName(x, null)));
var arrayField = new CodeSnippetTypeMember("public static readonly int[] AllIds = new[] { " + list + " };");
typeDef.Members.Add(arrayField);
foreach (var attr in declaration.AttributeNames)
{
var field = new CodeMemberField(typeof(int), UnfixResourceName(attr));
field.Attributes = MemberAttributes.Public | MemberAttributes.Const;
field.InitExpression = new CodeSnippetExpression(FormatAttributeName(attr, 0xFFFF));
typeDef.Members.Add(field);
}
}
}
}
return compileUnit;
}
/// <summary>
/// Generates the automatic properties.
/// </summary>
/// <param name="type">Represents a type declaration for a class, structure, interface, or enumeration.</param>
private void GenerateAutomaticProperties(CodeTypeDeclaration type)
{
if (Equals(GeneratorContext.GeneratorParams.Language, GenerationLanguage.CSharp))
{
// If databinding is disable, use automatic property
if (GeneratorContext.GeneratorParams.PropertyParams.AutomaticProperties)
{
foreach (var item in this.autoPropertyListField)
{
var cm = new CodeSnippetTypeMember();
bool transformToAutomaticproperty = true;
var attributesString = new List <string>();
foreach (var attribute in item.CustomAttributes)
{
var attrib = attribute as CodeAttributeDeclaration;
if (attrib != null)
{
// Don't transform property with default value.
if (attrib.Name == "System.ComponentModel.DefaultValueAttribute")
{
transformToAutomaticproperty = false;
}
else
{
string attributesArguments = string.Empty;
foreach (var arg in attrib.Arguments)
{
var argument = arg as CodeAttributeArgument;
if (argument != null)
{
attributesArguments += AttributeArgumentToString(argument) + ",";
}
}
// Remove last ","
if (attributesArguments.Length > 0)
{
attributesArguments = attributesArguments.Remove(attributesArguments.Length - 1);
}
attributesString.Add(string.Format("[{0}({1})]", attrib.Name, attributesArguments));
}
}
}
if (transformToAutomaticproperty)
{
foreach (var attribute in attributesString)
{
cm.Text += " " + attribute + "\n";
}
var ct = new CodeTypeReferenceExpression(item.Type);
var prop = ExpressionToString(ct);
var text = string.Format(" public {0} {1} ", prop, item.Name);
cm.Text += string.Concat(text, "{get; set;}\n");
cm.Comments.AddRange(item.Comments);
type.Members.Add(cm);
type.Members.Remove(item);
}
}
// Now remove all private fileds
foreach (var item in this.fieldListToRemoveField)
{
if (item.Name == "mailClassField" && type.Name == "uspsSummaryType")
{
;
}
type.Members.Remove(item);
}
}
}
}
private static CodeSnippetTypeMember AddAttributes(CodeTypeMember getter, CodeTypeMember setter, CodeMemberProperty property)
{
CodeSnippetTypeMember propertySnippet = new CodeSnippetTypeMember();
AddAttributes(getter, property, propertySnippet, @"{(\s*)get", @"{{$1{0}$1get");
if (setter != null)
{
AddAttributes(setter, property, propertySnippet, @"}(\s*)set", @"}}$1{0}$1set");
}
propertySnippet.UserData["interface"] = property.PrivateImplementationType;
return propertySnippet;
}
/// <summary>
/// Create the body of the task's code by simply using the taskCode as a snippet for the CodeDom
/// </summary>
private static void CreateTaskBody(CodeTypeDeclaration codeTypeDeclaration, string taskCode)
{
CodeSnippetTypeMember snippet = new CodeSnippetTypeMember(taskCode);
codeTypeDeclaration.Members.Add(snippet);
}
private static void AddAttributes(CodeTypeMember method, CodeTypeMember property, CodeSnippetTypeMember propertySnippet,
string findRegex, string replaceRegex)
{
if (method.CustomAttributes.Count > 0)
{
using (StringWriter writer = new StringWriter())
{
string propertyCode = string.IsNullOrEmpty(propertySnippet.Name)
? GetMemberCode(property, writer)
: propertySnippet.Text;
writer.GetStringBuilder().Length = 0;
for (int i = method.CustomAttributes.Count - 1; i >= 0; i--)
{
CodeAttributeDeclaration attributeDeclaration = method.CustomAttributes[i];
if (attributeDeclaration.AttributeType.BaseType != "SmokeMethod")
{
propertySnippet.CustomAttributes.Insert(0, attributeDeclaration);
method.CustomAttributes.RemoveAt(i);
}
}
string getterCode = GetMemberCode(method, writer);
string attribute = string.Format(replaceRegex, regexAttribute.Match(getterCode).Groups[1].Value);
string propertyWithAttribute = Regex.Replace(propertyCode, findRegex, attribute);
propertySnippet.Name = property.Name;
propertySnippet.Attributes = property.Attributes;
propertySnippet.Text = propertyWithAttribute;
}
}
}
/// <summary>
/// Main driving routine for building a class
/// </summary>
public static void BuildClass(string expression)
{
// need a string to put the code into
_source = new StringBuilder();
StringWriter sw = new StringWriter(_source);
//Declare your provider and generator
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
ICodeGenerator generator = codeProvider.CreateGenerator(sw);
CodeGeneratorOptions codeOpts = new CodeGeneratorOptions();
CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator");
myNamespace.Imports.Add(new CodeNamespaceImport("System"));
//myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
//myNamespace.Imports.Add(new CodeNamespaceImport("MissionPlanner.Utilities"));
//myNamespace.Imports.Add(new CodeNamespaceImport("MissionPlanner"));
//Build the class declaration and member variables
CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration();
classDeclaration.IsClass = true;
classDeclaration.Name = "Calculator";
classDeclaration.Attributes = MemberAttributes.Public;
classDeclaration.Members.Add(FieldVariable("answer", typeof(object), MemberAttributes.Private));
//default constructor
CodeConstructor defaultConstructor = new CodeConstructor();
defaultConstructor.Attributes = MemberAttributes.Public;
defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true));
defaultConstructor.Statements.Add(new CodeSnippetStatement("//TODO: implement default constructor"));
classDeclaration.Members.Add(defaultConstructor);
//property
classDeclaration.Members.Add(MakeProperty("Answer", "answer", typeof(object)));
//Our Calculate Method
/*
* CodeMemberMethod myMethod = new CodeMemberMethod();
* myMethod.Name = "Calculate";
* myMethod.ReturnType = new CodeTypeReference(typeof(object));
* myMethod.Comments.Add(new CodeCommentStatement("Calculate an expression", true));
* myMethod.Attributes = MemberAttributes.Public;
* myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Object obj"), new CodeSnippetExpression(expression)));
* //myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Answer"), new CodeSnippetExpression("obj.ToString()")));
* myMethod.Statements.Add(
* new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Answer")));
* classDeclaration.Members.Add(myMethod);
*/
classDeclaration.Members.Add(FieldVariable("customforusenumber", typeof(double), MemberAttributes.Public));
classDeclaration.Members.Add(FieldVariable("customforuseobject", typeof(object), MemberAttributes.Public));
CodeSnippetTypeMember myMethod = new CodeSnippetTypeMember();
myMethod.Text = expression;
classDeclaration.Members.Add(myMethod);
//write code
myNamespace.Types.Add(classDeclaration);
generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts);
sw.Flush();
sw.Close();
Console.Write(sw.ToString());
}
/*
* Adds complementing operators if necessary.
*/
private void AddMissingOperators()
{
for (short i = 1; i <= this.data.Smoke->numClasses; i++)
{
Smoke.Class* klass = this.data.Smoke->classes + i;
// skip external classes and namespaces
if (klass->external || klass->size == 0)
continue;
CodeTypeDeclaration typeDecl = this.data.SmokeTypeMap[(IntPtr) klass];
var lessThanOperators = new List<CodeMemberMethod>();
var greaterThanOperators = new List<CodeMemberMethod>();
var lessThanOrEqualOperators = new List<CodeMemberMethod>();
var greaterThanOrEqualOperators = new List<CodeMemberMethod>();
var equalOperators = new List<CodeMemberMethod>();
var inequalOperators = new List<CodeMemberMethod>();
foreach (CodeMemberMethod method in typeDecl.Members.OfType<CodeMemberMethod>())
{
switch (method.Name)
{
case "operator<":
lessThanOperators.Add(method);
break;
case "operator>":
greaterThanOperators.Add(method);
break;
case "operator<=":
lessThanOrEqualOperators.Add(method);
break;
case "operator>=":
greaterThanOrEqualOperators.Add(method);
break;
case "operator==":
equalOperators.Add(method);
break;
case "operator!=":
inequalOperators.Add(method);
break;
}
}
AddComplementingOperatorsFn checkAndAdd =
delegate(IList<CodeMemberMethod> ops, IList<CodeMemberMethod> otherOps, string opName, string expr)
{
foreach (CodeMemberMethod op in ops)
{
if (otherOps.Any(otherOp => op.ParametersEqual(otherOp)))
continue;
CodeMemberMethod complement = new CodeMemberMethod();
complement.Name = opName;
complement.Attributes = op.Attributes;
complement.ReturnType = op.ReturnType;
complement.Parameters.AddRange(op.Parameters);
complement.Statements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression(expr)));
typeDecl.Members.Add(complement);
}
};
checkAndAdd(lessThanOperators, greaterThanOperators, "operator>", "!(arg1 < arg2) && arg1 != arg2");
checkAndAdd(greaterThanOperators, lessThanOperators, "operator<", "!(arg1 > arg2) && arg1 != arg2");
checkAndAdd(lessThanOrEqualOperators, greaterThanOrEqualOperators, "operator>=", "!(arg1 < arg2)");
checkAndAdd(greaterThanOrEqualOperators, lessThanOrEqualOperators, "operator<=", "!(arg1 > arg2)");
checkAndAdd(equalOperators, inequalOperators, "operator!=", "!(arg1 == arg2)");
checkAndAdd(inequalOperators, equalOperators, "operator==", "!(arg1 != arg2)");
if (equalOperators.Count == 0 && inequalOperators.Count == 0)
continue; // then we're done
// add Equals(object) and GetHashCode() overrides
CodeSnippetTypeMember equals = new CodeSnippetTypeMember(string.Format(EqualsCode, typeDecl.Name));
typeDecl.Members.Add(equals);
typeDecl.Members.Add(getHashCode);
}
}
private static void Json2Class(string fileName, string json, List <object> statements)
{
string structName = "";
structName = Path.GetFileName(fileName).ToLower().Replace(".xlsx", "");
//首字母大写
structName = structName.Substring(0, 1).ToUpper() + structName.Substring(1);
//输出目录控制
string outputFile = Path.Combine(Application.dataPath, "Code/Game@hotfix/Table");
if (Directory.Exists(outputFile) == false)
{
Directory.CreateDirectory(outputFile);
}
//输出目录
outputFile = Path.Combine(outputFile, Path.GetFileName(fileName).Replace(".xlsx", ".cs"));
//生成类服务
CodeCompileUnit compunit = new CodeCompileUnit();
CodeNamespace sample = new CodeNamespace("Game.Data");
compunit.Namespaces.Add(sample);
//引用命名空间
sample.Imports.Add(new CodeNamespaceImport("System"));
sample.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
sample.Imports.Add(new CodeNamespaceImport("Game.Data"));
sample.Imports.Add(new CodeNamespaceImport("SQLite4Unity3d"));
//在命名空间下添加一个类
CodeTypeDeclaration wrapProxyClass = new CodeTypeDeclaration(structName);
wrapProxyClass.IsClass = true;
wrapProxyClass.IsEnum = false;
wrapProxyClass.IsInterface = false;
wrapProxyClass.IsPartial = false;
wrapProxyClass.IsStruct = false;
//把这个类添加到命名空间
sample.Types.Add(wrapProxyClass);
CodeAttributeDeclaration attr = new CodeAttributeDeclaration("Serializable");
wrapProxyClass.CustomAttributes.Add(attr);
//
var jsonData = JsonMapper.ToObject(json)[0];
int i = 0;
foreach (var key in jsonData.Keys)
{
//字段
string memberContent =
@" public [type] [Name] {get;set;}";
CodeSnippetTypeMember member = new CodeSnippetTypeMember();
if (key.ToLower() == "id" && key != "Id")
{
Debug.LogErrorFormat("<color=yellow>表格{0}字段必须为Id[大小写],请修改后生成</color>", structName);
break;
}
else if (key == "Id")
{
//增加一个sqlite主键
//member.CustomAttributes.Add(new CodeAttributeDeclaration("PrimaryKey"));
memberContent =
@" [PrimaryKey]
public [type] [Name] {get;set;}";
}
var value = jsonData[key];
string type = null;
if (value.IsArray)
{
var str = value.ToJson();
if (str.IndexOf("\"") > 0)
{
type = "List<string>";
}
else
{
type = "List<double>";
}
}
else if (value.IsInt)
{
type = "int";
}
else if (value.IsDouble || value.IsLong)
{
type = "double";
}
else if (value.IsBoolean)
{
type = "bool";
}
else if (value.IsString)
{
type = "string";
}
//注释
member.Comments.Add(new CodeCommentStatement(statements[i].ToString()));
member.Text = memberContent.Replace("[type]", type).Replace("[Name]", key);
wrapProxyClass.Members.Add(member);
i++;
}
//生成代码
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
options.BlankLinesBetweenMembers = true;
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(outputFile))
{
provider.GenerateCodeFromCompileUnit(compunit, sw, options);
}
}
private void GenerateEvent(CodeMemberMethod cmm, string name, CodeTypeDeclaration type, bool isVirtual)
{
if (!name.EndsWith("Event") ||
(type.Name == "QCoreApplication" && (name == "PostEvent" || name == "SendEvent")))
{
return;
}
string paramType;
// TODO: add support for IQGraphicsItem
if (cmm.Parameters.Count == 1 && (paramType = cmm.Parameters[0].Type.BaseType).EndsWith("Event") &&
(cmm.Attributes & MemberAttributes.Override) == 0 &&
!new[]
{
"QGraphicsItem", "QGraphicsObject", "QGraphicsTextItem",
"QGraphicsProxyWidget", "QGraphicsWidget", "QGraphicsLayout",
"QGraphicsScene"
}.Contains(type.Name))
{
if (!this.HasField(type, "eventFilters"))
{
CodeSnippetTypeMember eventFilters = new CodeSnippetTypeMember();
eventFilters.Name = "eventFilters";
eventFilters.Text = "protected readonly List<QEventHandler> eventFilters = new List<QEventHandler>();";
type.Members.Add(eventFilters);
}
CodeSnippetTypeMember codeMemberEvent = new CodeSnippetTypeMember();
codeMemberEvent.Name = name;
codeMemberEvent.Text =
string.Format(
@"
public {0} event EventHandler<QEventArgs<{1}>> {2}
{{
add
{{
QEventArgs<{1}> qEventArgs = new QEventArgs<{1}>({3});
QEventHandler<{1}> qEventHandler = new QEventHandler<{1}>(this{4}, qEventArgs, value);
foreach (QEventHandler eventFilter in eventFilters)
{{
this{4}.RemoveEventFilter(eventFilter);
}}
eventFilters.Add(qEventHandler);
for (int i = eventFilters.Count - 1; i >= 0; i--)
{{
this{4}.InstallEventFilter(eventFilters[i]);
}}
}}
remove
{{
for (int i = eventFilters.Count - 1; i >= 0; i--)
{{
QEventHandler eventFilter = eventFilters[i];
if (eventFilter.Handler == value)
{{
this{4}.RemoveEventFilter(eventFilter);
eventFilters.RemoveAt(i);
break;
}}
}}
}}
}}
",
isVirtual ? "virtual" : "override", paramType, codeMemberEvent.Name, GetEventTypes(name), isVirtual ? string.Empty : ".Viewport");
codeMemberEvent.Attributes = (codeMemberEvent.Attributes & ~MemberAttributes.AccessMask) |
MemberAttributes.Public;
codeMemberEvent.Comments.AddRange(cmm.Comments);
type.Members.Add(codeMemberEvent);
if (isVirtual && InheritsQWidget(type))
{
eventMethods[cmm.Name] = cmm;
}
}
if (isVirtual && !cmm.Name.StartsWith("~"))
{
cmm.Name = "On" + cmm.Name;
}
}
private void ValidateSnippetMember(CodeSnippetTypeMember e)
{
}
protected abstract void GenerateSnippetMember(CodeSnippetTypeMember e);
private void GenerateSnippetMember(CodeSnippetTypeMember e)
{
Output.Write(e.Text);
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
#if WHIDBEY
if (!(provider is JScriptCodeProvider)) {
// GENERATES (C#):
//
// #region Compile Unit Region
//
// namespace Namespace1 {
//
//
// #region Outer Type Region
// // Outer Type Comment
// public class Class1 {
//
// // Field 1 Comment
// private string field1;
//
// public void Method1() {
// this.Event1(this, System.EventArgs.Empty);
// }
//
// #region Constructor Region
// public Class1() {
// #region Statements Region
// this.field1 = "value1";
// this.field2 = "value2";
// #endregion
// }
// #endregion
//
// public string Property1 {
// get {
// return this.field1;
// }
// }
//
// public static void Main() {
// }
//
// public event System.EventHandler Event1;
//
// public class NestedClass1 {
// }
//
// public delegate void nestedDelegate1(object sender, System.EventArgs e);
//
//
//
// #region Field Region
// private string field2;
// #endregion
//
// #region Method Region
// // Method 2 Comment
//
// #line 500 "MethodLinePragma.txt"
// public void Method2() {
// this.Event2(this, System.EventArgs.Empty);
// }
//
// #line default
// #line hidden
// #endregion
//
// public Class1(string value1, string value2) {
// }
//
// #region Property Region
// public string Property2 {
// get {
// return this.field2;
// }
// }
// #endregion
//
// #region Type Constructor Region
// static Class1() {
// }
// #endregion
//
// #region Event Region
// public event System.EventHandler Event2;
// #endregion
//
// #region Nested Type Region
// // Nested Type Comment
//
// #line 400 "NestedTypeLinePragma.txt"
// public class NestedClass2 {
// }
//
// #line default
// #line hidden
// #endregion
//
// #region Delegate Region
// public delegate void nestedDelegate2(object sender, System.EventArgs e);
// #endregion
//
// #region Snippet Region
//
// #endregion
// }
// #endregion
// }
// #endregion
CodeNamespace ns = new CodeNamespace ("Namespace1");
cu.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Compile Unit Region"));
cu.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
cu.Namespaces.Add (ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("Class1");
ns.Types.Add (cd);
cd.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Outer Type Region"));
cd.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
cd.Comments.Add (new CodeCommentStatement ("Outer Type Comment"));
CodeMemberField field1 = new CodeMemberField (typeof (String), "field1");
CodeMemberField field2 = new CodeMemberField (typeof (String), "field2");
field1.Comments.Add (new CodeCommentStatement ("Field 1 Comment"));
field2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Field Region"));
field2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeMemberEvent evt1 = new CodeMemberEvent ();
evt1.Name = "Event1";
evt1.Type = new CodeTypeReference (typeof (System.EventHandler));
evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberEvent evt2 = new CodeMemberEvent ();
evt2.Name = "Event2";
evt2.Type = new CodeTypeReference (typeof (System.EventHandler));
evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
evt2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Event Region"));
evt2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeMemberMethod method1 = new CodeMemberMethod ();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
if (provider.Supports (GeneratorSupport.DeclareEvents)) {
method1.Statements.Add (
new CodeDelegateInvokeExpression (
new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Event1"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
}
CodeMemberMethod method2 = new CodeMemberMethod ();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
if (provider.Supports (GeneratorSupport.DeclareEvents)) {
method2.Statements.Add (
new CodeDelegateInvokeExpression (
new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Event2"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
}
method2.LinePragma = new CodeLinePragma ("MethodLinePragma.txt", 500);
method2.Comments.Add (new CodeCommentStatement ("Method 2 Comment"));
method2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Method Region"));
method2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeMemberProperty property1 = new CodeMemberProperty ();
property1.Name = "Property1";
property1.Type = new CodeTypeReference (typeof (string));
property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property1.GetStatements.Add (
new CodeMethodReturnStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field1")));
CodeMemberProperty property2 = new CodeMemberProperty ();
property2.Name = "Property2";
property2.Type = new CodeTypeReference (typeof (string));
property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property2.GetStatements.Add (
new CodeMethodReturnStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field2")));
property2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Property Region"));
property2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeConstructor constructor1 = new CodeConstructor ();
constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeStatement conState1 = new CodeAssignStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field1"),
new CodePrimitiveExpression ("value1"));
conState1.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Statements Region"));
constructor1.Statements.Add (conState1);
CodeStatement conState2 = new CodeAssignStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field2"),
new CodePrimitiveExpression ("value2"));
conState2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
constructor1.Statements.Add (conState2);
constructor1.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Constructor Region"));
constructor1.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeConstructor constructor2 = new CodeConstructor ();
constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
constructor2.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "value1"));
constructor2.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "value2"));
CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor ();
typeConstructor2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Type Constructor Region"));
typeConstructor2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeEntryPointMethod methodMain = new CodeEntryPointMethod ();
CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration ("NestedClass1");
CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration ("NestedClass2");
nestedClass2.LinePragma = new CodeLinePragma ("NestedTypeLinePragma.txt", 400);
nestedClass2.Comments.Add (new CodeCommentStatement ("Nested Type Comment"));
nestedClass2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Nested Type Region"));
nestedClass2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeTypeDelegate delegate1 = new CodeTypeDelegate ();
delegate1.Name = "nestedDelegate1";
delegate1.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.Object"), "sender"));
delegate1.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.EventArgs"), "e"));
CodeTypeDelegate delegate2 = new CodeTypeDelegate ();
delegate2.Name = "nestedDelegate2";
delegate2.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.Object"), "sender"));
delegate2.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.EventArgs"), "e"));
delegate2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Delegate Region"));
delegate2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeSnippetTypeMember snippet1 = new CodeSnippetTypeMember ();
CodeSnippetTypeMember snippet2 = new CodeSnippetTypeMember ();
CodeRegionDirective regionStart = new CodeRegionDirective (CodeRegionMode.End, "");
regionStart.RegionText = "Snippet Region";
regionStart.RegionMode = CodeRegionMode.Start;
snippet2.StartDirectives.Add (regionStart);
snippet2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
cd.Members.Add (field1);
cd.Members.Add (method1);
cd.Members.Add (constructor1);
cd.Members.Add (property1);
cd.Members.Add (methodMain);
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
cd.Members.Add (evt1);
}
if (Supports (provider, GeneratorSupport.NestedTypes)) {
cd.Members.Add (nestedClass1);
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
cd.Members.Add (delegate1);
}
}
cd.Members.Add (snippet1);
cd.Members.Add (field2);
cd.Members.Add (method2);
cd.Members.Add (constructor2);
cd.Members.Add (property2);
if (Supports (provider, GeneratorSupport.StaticConstructors)) {
cd.Members.Add (typeConstructor2);
}
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
cd.Members.Add (evt2);
}
if (Supports (provider, GeneratorSupport.NestedTypes)) {
cd.Members.Add (nestedClass2);
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
cd.Members.Add (delegate2);
}
}
cd.Members.Add (snippet2);
}
#endif
}
//construct, given the code provider being used.
public CompileDirectives(CodeDomProvider codeProvider)
{
this.codeProvider = codeProvider;
if (codeProvider.FileExtension == "cs")
{
readonlySnip = new CodeSnippetTypeMember("readonly ");
isCSharp = true;
}
if (codeProvider.FileExtension == "vb")
{
readonlySnip = new CodeSnippetTypeMember("ReadOnly ");
}
//try and load the directives from the user config.
try
{
//GenericType
string defaultDiretive = Properties.Settings.Default.DefaultCompilerDirectives.Trim();
if (defaultDiretive.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Length == 3)
{
directives = defaultDiretive.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
}
System.Reflection.PropertyInfo[] properties = Properties.Settings.Default.GetType().GetProperties();
foreach (System.Reflection.PropertyInfo property in properties)
{
if (property.PropertyType == typeof(string) && property.Name.EndsWith("CompilerDirectives", StringComparison.InvariantCultureIgnoreCase))
{
string directive = property.GetValue(Properties.Settings.Default, null) as string;
if (directive != null)
{
string[] lines = directive.Trim().Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
if (lines.Length == 4)
{
if (("*." + codeProvider.FileExtension).Equals(lines[0].Trim(), StringComparison.InvariantCultureIgnoreCase))
{
for (int i = 0; i < 3; i++)
{
directives[i] = lines[i + 1];
}
}
}
}
}
}
for (int i = 0; i < directives.Length; i++)
{
directives[i] = directives[i].Trim();
}
if (directives[0].Contains("{0}") == false)
{
throw new Exception("Could not find {0} in directive 0");
}
}
catch (Exception e)
{
throw new Exception("Error in user.config file", e);
}
}
