public static void GenerateInsertMethod(CodeStringBuilder code, TableInfo tableInfo)
{
String entityTypeName = tableInfo.ClassName;
String target = String.Format("[{0}].[{1}]", tableInfo.Schema, tableInfo.Name);
String methodName = String.Format("Insert{0}", entityTypeName);
List <ColumnInfo> editableColumns = tableInfo.GetEditableColumns();
List <ColumnInfo> computedColumns = tableInfo.GetComputedColumns();
List <ColumnInfo> identityColumns = tableInfo.GetIdentityColumns();
List <ColumnInfo> key = tableInfo.GetKey();
List <ColumnInfo> readBackColumns = new List <ColumnInfo>();
readBackColumns.AddRange(identityColumns);
readBackColumns.AddRange(computedColumns);
if (editableColumns.Count == 0)
{
return;
}
// generate sql script
StringBuilder script = new StringBuilder();
SQLTextGenerator.GenerateInsertStatement(script, target, editableColumns, readBackColumns);
// generate code for script
CSharpTextGenerator.GenerateInsertMethod(code, methodName, entityTypeName, script.ToString(), editableColumns, readBackColumns);
}
public EventDetail(RootDetail parent, EventInfo ei)
: base(parent, ei)
{
_name = ei.Name;
_visibility = VisibilityUtil.GetVisibilityFor(ei.GetAddMethod(true));
_category = "event";
CodeStringBuilder csb = new CodeStringBuilder();
AppendAttributesDeclaration(csb);
csb.Mode = AppendMode.NonText;
csb.AppendVisibility(_visibility);
csb.AppendText(" ");
csb.Mode = AppendMode.All;
csb.AppendKeyword("event ");
csb.AppendType(ei.EventHandlerType);
csb.AppendText(" ");
csb.AppendText(ei.Name);
_declaration = csb.ToString();
_declarationHtml = csb.ToHtmlString();
_declarationMarkdown = csb.ToMarkdownString();
}
public static void GenerateUpdateMethod(CodeStringBuilder code, TableInfo tableInfo)
{
String entityTypeName = tableInfo.ClassName;
String target = String.Format("[{0}].[{1}]", tableInfo.Schema, tableInfo.Name);
String methodName = String.Format("Update{0}", entityTypeName);
List <ColumnInfo> editableColumns = tableInfo.GetEditableColumns();
List <ColumnInfo> computedColumns = tableInfo.GetComputedColumns();
List <ColumnInfo> key = tableInfo.GetKey();
if (editableColumns.Count == 0)
{
return;
}
if (key.SequenceEqual(editableColumns))
{
return;
}
// generate sql script
StringBuilder script = new StringBuilder();
SQLTextGenerator.GenerateUpdateStatement(script, target, key, editableColumns, computedColumns);
// generate code for script
CSharpTextGenerator.GenerateUpdateMethod(code, methodName, entityTypeName, script.ToString(), key, editableColumns, computedColumns);
}
public static void GenerateSelectMethod(CodeStringBuilder code, TableInfo tableInfo, List <ColumnInfo> key, bool singleResult, String mappingMethodName)
{
String entityTypeName = tableInfo.ClassName;
String target = String.Format("[{0}].[{1}]", tableInfo.Schema, tableInfo.Name);
StringBuilder methodName = new StringBuilder();
methodName.Append("Select");
methodName.Append(entityTypeName);
if (key != null && key.Count > 0)
{
methodName.Append("By");
foreach (var k in key)
{
methodName.Append(k.PropertyName);
}
}
// generate sql script
StringBuilder script = new StringBuilder();
SQLTextGenerator.GenerateSelectStatement(script, target, tableInfo.Columns, key);
// generate code for script
CSharpTextGenerator.GenerateSelectMethod(code, methodName.ToString(), entityTypeName, script.ToString(), key, singleResult, mappingMethodName);
}
public static void GenerateSelectPagedMethod(CodeStringBuilder code, TableInfo tableInfo, String mappingMethodName)
{
String entityTypeName = tableInfo.ClassName;
String target = String.Format("[{0}].[{1}]", tableInfo.Schema, tableInfo.Name);
List <ColumnInfo> key = tableInfo.GetKey();
StringBuilder methodName = new StringBuilder();
methodName.Append("Select");
methodName.Append(entityTypeName);
methodName.Append("Paged");
if (key == null || key.Count == 0)
{
return;
}
// generate sql script
StringBuilder script = new StringBuilder();
SQLTextGenerator.GenerateSelectStatementPaged(script, target, tableInfo.Columns, "@__FirstIndex", "@__LastIndex", key, null);
// generate code for script
CSharpTextGenerator.GenerateSelectPagedMethod(code, methodName.ToString(), entityTypeName, mappingMethodName, script.ToString(), key);
}
public CompilationUnit(ClassDeclarationSyntax node)
{
Output = new CodeStringBuilder();
_indentation = new List <IDisposable>();
DeclareClass(node);
}
public static void GenerateDeleteMethod(CodeStringBuilder code, TableInfo tableInfo, List <ColumnInfo> key)
{
if (key == null || key.Count == 0)
{
return;
}
String entityTypeName = tableInfo.ClassName;
String target = String.Format("[{0}].[{1}]", tableInfo.Schema, tableInfo.Name);
StringBuilder methodName = new StringBuilder();
methodName.Append("Delete");
methodName.Append(entityTypeName);
methodName.Append("By");
foreach (var k in key)
{
methodName.Append(k.PropertyName);
}
// generate sql script
StringBuilder script = new StringBuilder();
SQLTextGenerator.GenerateDeleteStatement(script, target, key);
// generate code for script
CSharpTextGenerator.GenerateDeleteMethod(code, methodName.ToString(), script.ToString(), key);
}
public static void GenerateSelectCountMethod(CodeStringBuilder code, String methodName, String script)
{
code.CodeBlockBegin("public int {0}()", methodName);
code.CodeBlockBegin("using (System.Data.SqlClient.SqlCommand command = new System.Data.SqlClient.SqlCommand(\"{0}\"))", script);
code.CodeBlockBegin("try");
code.AppendLine("PopConnection(command);");
code.AppendLine();
code.CodeBlockBegin("using (System.Data.SqlClient.SqlDataReader reader = command.ExecuteReader())");
code.CodeBlockBegin("if (reader.Read())");
code.Append("return reader.GetInt32(0);");
code.CodeBlockEnd();
code.CodeBlockBegin("else");
code.Append("throw new InvalidOperationException(\"Select count failed.\");");
code.CodeBlockEnd();
code.CodeBlockEnd(); // using
code.CodeBlockEnd(); // try
code.CodeBlockBegin("finally");
code.Append("PushConnection(command);");
code.CodeBlockEnd();
code.CodeBlockEnd(); // using
code.CodeBlockEnd(); // method
}
public TypeDetail(RootDetail parent, Type type)
: base(parent, type)
{
CodeStringBuilder csb = new CodeStringBuilder(AppendMode.Text);
csb.AppendType(type, false);
_name = csb.ToString();
}
private static void AddUsing(CodeStringBuilder output)
{
output.AppendLine("using System;");
output.AppendLine("using System.Collections.Generic;");
output.AppendLine("using System.Threading;");
output.AppendLine("using System.Threading.Tasks;");
output.AppendLine();
}
public CompilationUnit(ClassDeclarationSyntax node)
{
Output = new CodeStringBuilder();
AddComment(Output);
AddUsing(Output);
_indentation = DeclareClass(node, Output);
}
public static void GenerateModel(CodeStringBuilder code, TableInfo tableInfo)
{
code.CodeBlockBegin("public partial class {0}", tableInfo.ClassName);
foreach (var c in tableInfo.Columns)
{
code.AppendLine(ToAutomaticProperty(c.PropertyName, c.FullTypeName));
}
code.CodeBlockEnd();
}
public EnumDetail(RootDetail parent, Type type)
: base(parent, type)
{
_visibility = VisibilityUtil.GetVisibilityFor(type);
_category = "enum";
foreach (string name in Enum.GetNames(type))
{
_children.Add(
new EnumItemDetail(
this,
name,
Convert.ToInt64(
type.GetField(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)
.GetRawConstantValue()),
_visibility));
}
CodeStringBuilder csb = new CodeStringBuilder();
AppendAttributesDeclaration(csb);
csb.Mode = AppendMode.NonText;
csb.AppendVisibility(_visibility);
csb.AppendText(" ");
csb.Mode = AppendMode.All;
csb.AppendKeyword("enum ");
csb.AppendText(type.Name);
csb.Mode = AppendMode.NonText;
csb.AppendNewline();
csb.AppendText("{");
csb.AppendNewline();
foreach (EnumItemDetail eid in FilterChildren <EnumItemDetail>())
{
csb.AppendIndent();
csb.AppendText(eid.GetHtmlDeclaration());
csb.AppendText(",");
csb.AppendNewline();
}
csb.RemoveCharsFromEnd("<br>".Length);
csb.RemoveCharsFromEnd(",".Length);
csb.AppendNewline();
csb.AppendText("}");
csb.Mode = AppendMode.All;
_declaration = csb.ToString();
_declarationHtml = csb.ToHtmlString();
_declarationMarkdown = csb.ToMarkdownString();
}
public static void GenerateMapping(CodeStringBuilder code, String methodName, String entityTypeName, List <ColumnInfo> columns)
{
code.CodeBlockBegin("public static {0} {1}(System.Data.SqlClient.SqlDataReader reader)", entityTypeName, methodName);
code.AppendLineFormat("{0} entity = new {0}();", entityTypeName);
foreach (var columnInfo in columns)
{
GenerateColumnMapperFromSqlDataReader(code, columnInfo);
}
code.CodeBlockEnd("return entity;");
}
public static void GenerateDeleteMethod(CodeStringBuilder code, String methodName, String script, List <ColumnInfo> key)
{
StringBuilder parameters = new StringBuilder();
for (int a = 0; a < key.Count; ++a)
{
if (a > 0)
{
parameters.Append(", ");
}
parameters.AppendFormat("{0} {1}", key[a].FullTypeName, key[a].LocalVariableName);
}
code.CodeBlockBegin("public void {0}({1})", methodName, parameters.ToString());
code.CodeBlockBegin("using (System.Data.SqlClient.SqlCommand command = new System.Data.SqlClient.SqlCommand(\"{0}\"))", script);
code.CodeBlockBegin("try");
code.AppendLine("PopConnection(command);");
code.AppendLine();
foreach (ColumnInfo columnInfo in key)
{
code.AppendLineFormat("// Parameter settings: {0}", columnInfo.ParameterName);
GenerateSqlParameter(
code,
columnInfo.LocalVariableName,
columnInfo.LocalParameterVariableName,
columnInfo.ParameterName,
columnInfo.DbType,
columnInfo.IsNullable,
System.Data.ParameterDirection.Input,
columnInfo.MaxLength);
code.AppendLine();
}
code.Append("command.ExecuteNonQuery();");
code.CodeBlockEnd(); // try
code.CodeBlockBegin("finally");
code.Append("PushConnection(command);");
code.CodeBlockEnd();
code.CodeBlockEnd(); // using command
code.CodeBlockEnd(); // method
}
protected virtual void AppendAttributesDeclaration(CodeStringBuilder csb)
{
AppendMode oldMode = csb.Mode;
csb.Mode = AppendMode.Html;
foreach (AttributeDetail ad in FilterChildren <AttributeDetail>())
{
csb.AppendText("[");
csb.AppendRawHtml(ad.GetHtmlDeclaration());
csb.AppendText("]");
csb.AppendNewline();
}
csb.Mode = oldMode;
}
private Assembly CompileMessage(string assemblyName, string ns, int propertiesCount)
{
var output = new CodeStringBuilder();
output.Append("namespace ").Append(ns).AppendLine(";");
new CSharpMessageBuilder(propertiesCount).GenerateMemberDeclaration(output);
var syntaxTree = SyntaxFactory.ParseSyntaxTree(
output.AsStringBuilder().ToString(),
CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp10));
var compilation = CSharpCompilation.Create(
assemblyName,
syntaxTrees: new[] { syntaxTree },
references: new[]
public void CodeStringBuilderWorks()
{
string source = @"
public class MyAltClass
{
public void MyAltMethod()
{
}
}
public class MyOtherClass
{
public void MyAltMethod(int myAltN)
{
int x = myAltN + 1;
int y = x + 1;
}
}
";
//string source = @"if (x == 2) {y=3; z= 2;}";
string expected = @"
public class MyAltClass
{
public void MyAltMethod()
{
}
}
public class MyOtherClass
{
public void MyAltMethod(int myAltN)
{
int x = myAltN + 1;
int y = x + 1;
}
}
";
var builder = new CodeStringBuilder();
builder.Append(source);
var result = builder.ToString();
if (result != expected)
{
IdentifyStringDifferencePoint(expected, result);
}
result.Should().Be(expected);
}
private static void AddComment(CodeStringBuilder output)
{
var comment = @"// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
"
.Replace("\r\n", "\n")
.Replace("\n", Environment.NewLine);
output.Append(comment);
}
public AttributeDetail(RootDetail parent, CustomAttributeData cad)
: base(parent, cad.Constructor.DeclaringType.FullName)
{
_declaration = cad.ToString();
CodeStringBuilder csb = new CodeStringBuilder();
AppendAttributesDeclaration(csb);
csb.AppendType(cad.Constructor.DeclaringType);
using (var e = cad.ConstructorArguments.GetEnumerator())
{
if (e.MoveNext())
{
csb.AppendText("(");
csb.AppendQuotedValue(e.Current.Value);
while (e.MoveNext())
{
csb.AppendText(", ");
csb.AppendQuotedValue(e.Current.Value);
}
csb.AppendText(")");
}
}
_declaration = csb.ToString();
_declarationHtml = csb.ToHtmlString();
_declarationMarkdown = csb.ToMarkdownString();
if (cad.AttributeType.IsAssignableFrom(typeof(ExtensionAttribute)))
{
AttributeType = AttributeType.Extension;
AppendInCode = false;
}
else if (cad.AttributeType.IsAssignableFrom(typeof(ObsoleteAttribute)))
{
AttributeType = AttributeType.Obsolete;
}
else if (cad.AttributeType.IsAssignableFrom(typeof(CompilerGeneratedAttribute)))
{
AttributeType = AttributeType.CompilerGenerated;
AppendInCode = false;
}
}
public static void GenerateSelectPagedMethod(CodeStringBuilder code, String methodName, String entityTypeName, String mappingMethodName, String script, List <ColumnInfo> key)
{
if (key == null || key.Count == 0)
{
return;
}
String firstIndexParameterName = "@__FirstIndex", firstIndexLocalVariableName = "pFirstIndex", firstIndex = "firstIndex";
String lastIndexParameterName = "@__LastIndex", lastIndexLocalVariableName = "pLastIndex", lastIndex = "lastIndex";
code.CodeBlockBegin("public List<{1}> {0}(int {2}, int {3})", methodName, entityTypeName, firstIndex, lastIndex);
code.CodeBlockBegin("using (System.Data.SqlClient.SqlCommand command = new System.Data.SqlClient.SqlCommand(\"{0}\"))", script);
code.CodeBlockBegin("try");
code.AppendLine("PopConnection(command);");
code.AppendLine();
GenerateSqlParameter(code, firstIndex, firstIndexLocalVariableName, firstIndexParameterName, System.Data.SqlDbType.Int, false, System.Data.ParameterDirection.Input, -1);
code.AppendLine();
GenerateSqlParameter(code, lastIndex, lastIndexLocalVariableName, lastIndexParameterName, System.Data.SqlDbType.Int, false, System.Data.ParameterDirection.Input, -1);
code.AppendLine();
code.CodeBlockBegin("using (System.Data.SqlClient.SqlDataReader reader = command.ExecuteReader())");
code.AppendLineFormat("List<{0}> result = new List<{0}>();", entityTypeName);
code.CodeBlockBegin("while (reader.Read())");
code.AppendFormat("result.Add({0}(reader));", mappingMethodName);
code.CodeBlockEnd();
code.Append("return result;");
code.CodeBlockEnd(); // using
code.CodeBlockEnd(); // try
code.CodeBlockBegin("finally");
code.Append("PushConnection(command);");
code.CodeBlockEnd();
code.CodeBlockEnd(); // using
code.CodeBlockEnd(); // method
}
protected virtual void AppendAttributesDeclaration(CodeStringBuilder csb)
{
AppendMode oldMode = csb.Mode;
csb.Mode = AppendMode.NonText;
foreach (AttributeDetail ad in FilterChildren <AttributeDetail>())
{
if (ad.AppendInCode)
{
csb.AppendText("[");
csb.AppendRaw(html: ad.GetHtmlDeclaration(), markdown: ad.GetMarkdownDeclaration());
csb.AppendText("]");
csb.AppendNewline();
}
}
csb.Mode = oldMode;
}
public EnumItemDetail(RootDetail parent, string name, long value, Visibility visibility)
{
_name = name;
_parent = parent;
_value = value;
_visibility = visibility;
_category = "enum value";
CodeStringBuilder csb = new CodeStringBuilder();
AppendAttributesDeclaration(csb);
csb.AppendText(name);
csb.AppendText(" = ");
csb.AppendText(value.ToString());
_declaration = csb.ToString();
_declarationHtml = csb.ToHtmlString();
}
public FieldDetail(RootDetail parent, FieldInfo fi)
: base(parent, fi)
{
_name = fi.Name;
_visibility = VisibilityUtil.GetVisibilityFor(fi);
_category = "field";
CodeStringBuilder csb = new CodeStringBuilder();
AppendAttributesDeclaration(csb);
csb.Mode = AppendMode.NonText;
csb.AppendVisibility(_visibility);
csb.AppendText(" ");
csb.Mode = AppendMode.All;
if (fi.IsLiteral)
{
csb.AppendKeyword("const ");
}
else if (fi.IsStatic)
{
csb.AppendKeyword("static ");
}
if (fi.IsInitOnly)
{
csb.AppendKeyword("readonly ");
}
csb.AppendType(fi.FieldType);
csb.AppendText(" ");
csb.AppendText(fi.Name);
if (fi.IsLiteral)
{
csb.AppendParameterValue(fi.GetRawConstantValue());
}
_declaration = csb.ToString();
_declarationHtml = csb.ToHtmlString();
_declarationMarkdown = csb.ToMarkdownString();
}
public static void GenerateSelectCountMethod(CodeStringBuilder code, TableInfo tableInfo)
{
String entityTypeName = tableInfo.ClassName;
String target = String.Format("[{0}].[{1}]", tableInfo.Schema, tableInfo.Name);
StringBuilder methodName = new StringBuilder();
methodName.Append("Select");
methodName.Append(entityTypeName);
methodName.Append("Count");
// generate sql script
StringBuilder script = new StringBuilder();
SQLTextGenerator.GenerateSelectStatementCount(script, target, null);
// generate code for script
CSharpTextGenerator.GenerateSelectCountMethod(code, methodName.ToString(), script.ToString());
}
public AttributeDetail(RootDetail parent, CustomAttributeData cad)
: base(parent, cad.Constructor.DeclaringType.FullName)
{
_declaration = cad.ToString();
CodeStringBuilder csb = new CodeStringBuilder();
AppendAttributesDeclaration(csb);
csb.AppendType(cad.Constructor.DeclaringType);
if (cad.ConstructorArguments.Count > 0)
{
csb.AppendText("(");
csb.AppendQuotedValue(cad.ConstructorArguments[0].Value);
csb.AppendText(")");
}
_declaration = csb.ToString();
_declarationHtml = csb.ToHtmlString();
}
private static void GenerateSqlParameter(CodeStringBuilder code, String valueExpression, String localParameterName, String sqlParameterName, System.Data.SqlDbType sqlDbType, bool is_nullable, System.Data.ParameterDirection parameterDirection, long max_length)
{
if (IsVariableLength(sqlDbType))
{
code.AppendLineFormat("System.Data.SqlClient.SqlParameter {0} = command.Parameters.Add(\"{1}\", System.Data.SqlDbType.{2}, {3});", localParameterName, sqlParameterName, sqlDbType.ToString(), max_length);
}
else
{
code.AppendLineFormat("System.Data.SqlClient.SqlParameter {0} = command.Parameters.Add(\"{1}\", System.Data.SqlDbType.{2});", localParameterName, sqlParameterName, sqlDbType.ToString(), max_length);
}
if (parameterDirection == System.Data.ParameterDirection.Output)
{
code.AppendLineFormat("{0}.Direction = System.Data.ParameterDirection.Output;", localParameterName);
}
else
{
if (parameterDirection == System.Data.ParameterDirection.InputOutput)
{
code.AppendLineFormat("{0}.Direction = System.Data.ParameterDirection.InputOutput;", localParameterName);
}
if (is_nullable)
{
code.CodeBlockBegin("if ({0} == null)", valueExpression);
code.AppendLineFormat("{0}.Value = System.DBNull.Value;", localParameterName);
code.CodeBlockEnd();
code.CodeBlockBegin("else");
code.AppendLineFormat("{0}.Value = {1};", localParameterName, valueExpression);
code.CodeBlockEnd();
}
else
{
code.AppendLineFormat("{0}.Value = {1};", localParameterName, valueExpression);
}
}
}
private static void GenerateColumnMapperFromSqlParameter(CodeStringBuilder code, ColumnInfo columnInfo, bool throwIfNullAtNotNullable)
{
if (columnInfo.IsNullable)
{
code.CodeBlockBegin("if ({0}.Value == System.DBNull.Value)", columnInfo.LocalParameterVariableName);
code.AppendLineFormat("entity.{0} = null;", columnInfo.PropertyName);
code.CodeBlockEnd();
code.CodeBlockBegin("else");
code.AppendLineFormat("entity.{0} = ({1}){2}.Value;", columnInfo.PropertyName, columnInfo.FullTypeName, columnInfo.LocalParameterVariableName);
code.CodeBlockEnd();
}
else
{
if (throwIfNullAtNotNullable)
{
code.CodeBlockBegin("if ({0}.Value == System.DBNull.Value)", columnInfo.LocalParameterVariableName);
code.Append("throw new InvalidOperationException(\"Invalid output value: " + columnInfo.LocalParameterVariableName + "\");");
code.CodeBlockEnd();
}
code.AppendLineFormat("entity.{0} = ({1}){2}.Value;", columnInfo.PropertyName, columnInfo.FullTypeName, columnInfo.LocalParameterVariableName);
}
}
private static void GenerateColumnMapperFromSqlDataReader(CodeStringBuilder code, ColumnInfo columnInfo, int?ordinalOverride = null)
{
int ordinal = columnInfo.Ordinal;
if (ordinalOverride.HasValue)
{
ordinal = ordinalOverride.Value;
}
if (columnInfo.IsNullable && columnInfo.Type.IsValueType)
{
code.CodeBlockBegin("if (reader.IsDBNull({0}))", ordinal);
code.AppendLineFormat("entity.{0} = null;", columnInfo.PropertyName, columnInfo.MappingMethodName, ordinal);
code.CodeBlockEnd();
code.CodeBlockBegin("else");
code.AppendLineFormat("entity.{0} = reader.{1}({2});", columnInfo.PropertyName, columnInfo.MappingMethodName, ordinal);
code.CodeBlockEnd();
}
else
{
code.AppendLineFormat("entity.{0} = reader.{1}({2});", columnInfo.PropertyName, columnInfo.MappingMethodName, ordinal);
}
}
public PropertyDetail(RootDetail parent, PropertyInfo pi)
: base(parent, pi)
{
_name = pi.Name;
_category = "property";
MethodInfo[] methods = pi.GetAccessors(true);
foreach (MethodInfo mi in methods)
{
MethodDetail m = new MethodDetail(this, mi);
if ((m.Name.Length > 3) && (mi.IsSpecialName))
{
m.Name = m.Name.Substring(0, 3);
}
m.Declaration = null;
_children.Add(m);
}
if (pi.GetIndexParameters().Length > 0)
{
CodeStringBuilder csbParameters = new CodeStringBuilder(AppendMode.Text);
foreach (ParameterInfo ip in pi.GetIndexParameters())
{
csbParameters.AppendParameterType(ip);
csbParameters.AppendText(", ");
_parameterCount++;
}
csbParameters.RemoveCharsFromEnd(2);
_parameterTypesList = csbParameters.ToString();
}
_visibility = VisibilityUtil.GetMostVisible(FilterChildren <MethodDetail>());
CodeStringBuilder csb = new CodeStringBuilder();
AppendAttributesDeclaration(csb);
csb.Mode = AppendMode.Html;
csb.AppendVisibility(_visibility);
csb.AppendText(" ");
csb.Mode = AppendMode.Both;
csb.AppendType(pi.PropertyType);
csb.AppendText(" ");
csb.AppendText(pi.Name);
if (this.ParameterCount > 0)
{
csb.AppendText("[");
csb.AppendText(this.ParameterTypesList);
csb.AppendText("]");
}
csb.Mode = AppendMode.Html;
csb.AppendNewline();
csb.AppendText("{");
csb.AppendNewline();
csb.AppendIndent();
foreach (MethodDetail mi in FilterChildren <MethodDetail>())
{
if (mi.Visibility != _visibility)
{
csb.AppendVisibility(mi.Visibility);
csb.AppendText(" ");
}
csb.AppendText(mi.Name);
csb.AppendText("; ");
}
csb.AppendNewline();
csb.AppendText("}");
_declaration = csb.ToString();
_declarationHtml = csb.ToHtmlString();
}
