/// <summary>
/// Generates the comments for the parameters of the constructor
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="properties">
/// Properties of the info class
/// </param>
protected static void DoConstructorParamComments(StringBuilder sb, PropertyInfoBase[] properties)
{
foreach (PropertyInfoBase pi in properties)
{
sb.AppendLine(
" /// <param name=\"" + Helpers.GetVariableName(pi.Name) + "\">" + pi.Description + "</param>");
}
}
/// <summary>
/// Generate the unit test code for the constructor that takes parameters
/// </summary>
/// <param name="sb">string build to append the code to</param>
/// <param name="className">name of the class</param>
/// <param name="properties">collection of properties</param>
/// <param name="baseClassName">name of the base class</param>
/// <param name="baseClassProperties">collection of base class properties</param>
protected override void DoConstructorWithParameters(
StringBuilder sb,
string className,
PropertyInfoBase[] properties,
string baseClassName,
PropertyInfoBase[] baseClassProperties)
{
}
/// <summary>
/// Produces code for class specific methods
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="mainNamespaceName">
/// The main namespace
/// </param>
/// <param name="subNamespace">
/// The sub namespace, if any
/// </param>
/// <param name="className">
/// The class name
/// </param>
/// <param name="properties">
/// Properties of the info class
/// </param>
/// <param name="baseClassName">
/// The name of the base class
/// </param>
/// <param name="baseClassProperties">
/// The properties of the base class
/// </param>
protected override void DoClassSpecificMethods(
StringBuilder sb,
string mainNamespaceName,
string subNamespace,
string className,
PropertyInfoBase[] properties,
string baseClassName,
PropertyInfoBase[] baseClassProperties)
{
}
/// <summary>
/// Produces code for class specific methods
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="mainNamespaceName">
/// The main namespace
/// </param>
/// <param name="subNamespace">
/// The sub namespace, if any
/// </param>
/// <param name="className">
/// The class name
/// </param>
/// <param name="properties">
/// Properties of the info class
/// </param>
/// <param name="baseClassName">
/// The name of the base class
/// </param>
/// <param name="baseClassProperties">
/// The properties of the base class
/// </param>
protected override void DoClassSpecificMethods(
StringBuilder sb,
string mainNamespaceName,
string subNamespace,
string className,
PropertyInfoBase[] properties,
string baseClassName,
PropertyInfoBase[] baseClassProperties)
{
DoGetDifferencesMethod(sb, mainNamespaceName, subNamespace, className, properties, baseClassProperties);
}
/// <summary>
/// Gets the type for a property
/// </summary>
/// <param name="pi">
/// The property to generate a type for
/// </param>
/// <returns>
/// .NET data type
/// </returns>
private string GetPropertyType(PropertyInfoBase pi)
{
if (pi == null)
{
throw new ArgumentNullException("pi");
}
string optional = (pi.Optional && !pi.NetDataType.Equals("string", StringComparison.Ordinal))
? "?"
: string.Empty;
return pi.GetCSharpDataTypeDeclaration() + optional;
}
/// <summary>
/// Initializes a new instance of the <see cref="MockClassGenerationParameters"/> class.
/// </summary>
/// <param name="mainNamespaceName">
/// The main namespace name.
/// </param>
/// <param name="subNamespace">
/// The sub namespace.
/// </param>
/// <param name="className">
/// The class name.
/// </param>
/// <param name="properties">
/// The properties.
/// </param>
/// <param name="baseClassProperties">
/// The base class properties.
/// </param>
/// <param name="companyName">
/// The company name.
/// </param>
/// <param name="copyrightBanner">
/// The copyright banner.
/// </param>
/// <param name="copyrightStartYear">
/// The copyright start year.
/// </param>
/// <param name="baseClassName">
/// The base class name.
/// </param>
/// <param name="classRemarks">
/// The class remarks.
/// </param>
public MockClassGenerationParameters(string mainNamespaceName, string subNamespace, string className, PropertyInfoBase[] properties, PropertyInfoBase[] baseClassProperties, string companyName, string[] copyrightBanner, int copyrightStartYear, string baseClassName, string classRemarks)
{
this.MainNamespaceName = mainNamespaceName;
this.SubNamespace = subNamespace;
this.ClassName = className;
this.Properties = properties;
this.BaseClassProperties = baseClassProperties;
this.CompanyName = companyName;
this.CopyrightBanner = copyrightBanner;
this.CopyrightStartYear = copyrightStartYear;
this.BaseClassName = baseClassName;
this.ClassRemarks = classRemarks;
}
/// <summary>
/// Generates code for the properties.
/// </summary>
/// <param name="sb">The string builder to append code to</param>
/// <param name="tabCount">The depth count of the tabs</param>
/// <param name="properties">collection of properties to generate code for</param>
/// <param name="isBaseInterface">Whether this is the base interface</param>
protected override void DoProperties(StringBuilder sb, int tabCount, PropertyInfoBase[] properties, bool isBaseInterface)
{
var position = 0;
while (position < properties.Length)
{
var property = properties[position];
sb.AppendLine("{0}/// <summary>Gets a value indicating whether there is a difference for {1}</summary>", Helpers.GetTabs(tabCount), property.Description);
sb.AppendLine("{0}bool {1} {{ get; }}", Helpers.GetTabs(tabCount), property.Name);
if (position <= properties.Length)
{
sb.AppendLine(string.Empty);
}
position++;
}
}
/// <summary>
/// Generates code for the properties.
/// </summary>
/// <param name="sb">The string builder to append code to</param>
/// <param name="tabCount">The depth count of the tabs</param>
/// <param name="properties">collection of properties to generate code for</param>
/// <param name="isBaseInterface">Whether this is the base interface</param>
protected override void DoProperties(StringBuilder sb, int tabCount, PropertyInfoBase[] properties, bool isBaseInterface)
{
var position = 0;
while (position < properties.Length)
{
var property = properties[position];
sb.AppendLine("{0}/// <summary>Gets {1}</summary>", Helpers.GetTabs(tabCount), property.Description);
sb.AppendLine("{0}{1} {2} {{ get; }}", Helpers.GetTabs(tabCount), this.GetPropertyType(property), property.Name);
if (position <= properties.Length)
{
sb.AppendLine(string.Empty);
}
position++;
}
}
/// <summary>
/// Generates the code that gets the row data for reading a data reader into a strongly typed class
/// </summary>
/// <param name="generatedCode">
/// The String Builder to add the code to
/// </param>
/// <param name="properties">
/// The collection of properties for the class
/// </param>
protected static void DoDifferenceGetRowData(StringBuilder generatedCode, PropertyInfoBase[] properties)
{
if (generatedCode == null)
{
throw new ArgumentNullException(nameof(generatedCode));
}
if (properties == null)
{
throw new ArgumentNullException(nameof(properties));
}
foreach (var pi in properties.Where(pi => pi.SqlDataReaderType != null))
{
generatedCode.AppendLine(" bool " + Helpers.GetVariableName("row" + pi.Name) + " = false;");
generatedCode.AppendLine(" if (" + Helpers.GetVariableName(pi.Name) + "Ordinal > -1)");
generatedCode.AppendLine(" {");
generatedCode.AppendLine(
" " + Helpers.GetVariableName("row" + pi.Name) + " = dataReader.GetBoolean("
+ Helpers.GetVariableName(pi.Name) + "Ordinal);");
generatedCode.AppendLine(" }");
generatedCode.AppendLine(string.Empty);
}
}
/// <summary> /// Gets the type to be used for a parameter in the constructor /// </summary> /// <param name="propertyInfo"> /// the property /// </param> /// <returns> /// the constructor parameter type /// </returns> protected abstract string GetConstructorParameterType(PropertyInfoBase propertyInfo);
/// <summary>
/// Builds the Properties Region
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="properties">
/// The collection of properties for the class
/// </param>
/// <param name="baseClassProperties">
/// The properties of the base class
/// </param>
protected virtual void DoPropertiesRegion(StringBuilder sb, PropertyInfoBase[] properties, PropertyInfoBase[] baseClassProperties)
{
sb.AppendLine(" #region properties");
int i = 1;
foreach (PropertyInfoBase pi in properties)
{
sb.AppendLine(" /// <summary>");
sb.AppendLine(" /// Gets or sets " + pi.Description);
sb.AppendLine(" /// </summary>");
sb.AppendLine(
" [System.Diagnostics.CodeAnalysis.SuppressMessage(\"StyleCop.CSharp.ReadabilityRules\", \"SA1121:UseBuiltInTypeAlias\", Justification = \"Reviewed. Suppression is OK here.\")]");
// WCF Data Member Information
string required = "IsRequired = " + (!pi.Optional).ToString().ToLower(CultureInfo.InvariantCulture);
string order = ", Order = " + i++;
string dataMemberAttributes = "(" + required + order + ")";
sb.AppendLine(" [System.Runtime.Serialization.DataMember" + dataMemberAttributes + "]");
// Data Annotation Information
if (!pi.Optional)
{
sb.AppendLine(" [System.ComponentModel.DataAnnotations.Required]");
}
var propertySpecificAnnotations = pi.GetDataAnnotations();
if (!string.IsNullOrWhiteSpace(propertySpecificAnnotations))
{
sb.AppendLine(propertySpecificAnnotations);
}
sb.AppendLine(" public " + this.GetPropertyType(pi) + " " + pi.Name);
sb.AppendLine(" {");
if (pi.GenerateAutoProperty)
{
sb.AppendLine(" get;");
sb.AppendLine(" set;");
}
else
{
sb.AppendLine(" get");
sb.AppendLine(" {");
sb.AppendLine(" return this." + Helpers.GetVariableName(pi.Name) + ";");
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
this.OnDoPropertyMutator(sb, pi);
}
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
}
this.OnDoClassSpecificProperties(sb, properties);
sb.AppendLine(" #endregion");
sb.AppendLine(string.Empty);
}
/// <summary>
/// Builds the methods required by the IComparable interface
/// </summary>
/// <param name="sb">
/// StringBuilder to add the code to
/// </param>
/// <param name="className">
/// Name of the class
/// </param>
/// <param name="properties">
/// Collection of properties in the class
/// </param>
/// <param name="baseClassName">
/// Base class name, if not using the default
/// </param>
/// <param name="baseClassProperties">
/// Properties in the base class, if any
/// </param>
protected virtual void DoIComparableRegion(
StringBuilder sb, string className, PropertyInfoBase[] properties, string baseClassName, PropertyInfoBase[] baseClassProperties)
{
sb.AppendLine(" #region IComparable methods");
sb.AppendLine(string.Empty);
sb.AppendLine(Helpers.GetAutoGeneratedWarning());
sb.AppendLine(" /// <summary>");
sb.AppendLine(" /// Compares the current instance with another object of the same type.");
sb.AppendLine(" /// </summary>");
sb.AppendLine(" /// <param name=\"other\">");
sb.AppendLine(" /// The instance to compare to");
sb.AppendLine(" /// </param>");
sb.AppendLine(" /// <returns>");
sb.AppendLine(" /// 0 if equal, otherwise non zero");
sb.AppendLine(" /// </returns>");
string modifier = (!string.IsNullOrWhiteSpace(baseClassName) && baseClassProperties != null
&& baseClassProperties.Length > 0)
? null
: "override ";
sb.AppendLine(
" public " + modifier + "int CompareTo(" + className + this.GetClassSuffix() + " other)");
sb.AppendLine(" {");
sb.AppendLine(" if (other == null)");
sb.AppendLine(" {");
sb.AppendLine(" throw new System.ArgumentNullException(\"other\");");
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
bool checkResultDeclared = false;
if (!string.IsNullOrWhiteSpace(baseClassName) && baseClassProperties != null
&& baseClassProperties.Length > 0)
{
sb.AppendLine(string.Empty);
sb.AppendLine(" var checkResult = base.CompareTo(other);");
sb.AppendLine(" if (checkResult != 0)");
sb.AppendLine(" {");
sb.AppendLine(" return checkResult;");
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
checkResultDeclared = true;
}
this.OnDoCompareToProperties(sb, properties, baseClassProperties, checkResultDeclared);
sb.AppendLine(" return 0;");
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
sb.AppendLine(" #endregion");
}
/// <summary>
/// Builds the Fields Region
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="properties">
/// The collection of properties for the class
/// </param>
protected virtual void DoFieldsRegion(StringBuilder sb, PropertyInfoBase[] properties)
{
sb.AppendLine(" #region fields");
foreach (PropertyInfoBase pi in properties.Where(pi => !pi.GenerateAutoProperty))
{
sb.AppendLine(" /// <summary>");
sb.AppendLine(" /// " + pi.Description);
sb.AppendLine(" /// </summary>");
sb.AppendLine(
" [System.Diagnostics.CodeAnalysis.SuppressMessage(\"StyleCop.CSharp.ReadabilityRules\", \"SA1121:UseBuiltInTypeAlias\", Justification = \"Reviewed. Suppression is OK here.\")]");
this.OnDoFieldItem(sb, pi);
sb.AppendLine(string.Empty);
}
sb.AppendLine(" #endregion");
sb.AppendLine(string.Empty);
}
/// <summary>
/// Generates the parameters for the constructor
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="properties">
/// Properties of the info class
/// </param>
/// <param name="baseClassName">
/// The name of the base class
/// </param>
/// <param name="baseClassProperties">
/// The properties of the base class
/// </param>
protected void DoConstructorParameters(
StringBuilder sb, PropertyInfoBase[] properties, string baseClassName, PropertyInfoBase[] baseClassProperties)
{
int counter = 0;
if (string.IsNullOrWhiteSpace(baseClassName) == false && baseClassProperties != null
&& baseClassProperties.Length > 0)
{
while (counter < baseClassProperties.Length)
{
sb.Append(
" " + this.GetConstructorParameterType(baseClassProperties[counter]) + " "
+ Helpers.GetVariableName(baseClassProperties[counter].Name) + ",");
counter++;
}
counter = 0;
}
while (counter < properties.Length)
{
sb.Append(
" " + this.GetConstructorParameterType(properties[counter]) + " "
+ Helpers.GetVariableName(properties[counter].Name));
counter++;
sb.AppendLine(counter < properties.Length ? "," : ")");
}
}
/// <summary>
/// Gets the value of the property when converting to a string array.
/// </summary>
/// <param name="pi">
/// property information
/// </param>
/// <returns>
/// the value of the property when converting to a string array
/// </returns>
protected override string GetValueForToStringArray(PropertyInfoBase pi)
{
if (pi == null)
{
throw new ArgumentNullException("pi");
}
return pi.Name + " ? \"1\" : \"0\"";
}
/// <summary>
/// Generates the code for comparing properties in the CompareTo method
/// </summary>
/// <param name="sb">
/// StringBuilder to add the code to
/// </param>
/// <param name="properties">
/// The property to generate code for
/// </param>
/// <param name="baseClassProperties">
/// Properties in the base class, if any
/// </param>
/// <param name="checkResultDeclared">
/// Whether the check result variable has been declared yet
/// </param>
protected override void OnDoCompareToProperties(
StringBuilder sb, PropertyInfoBase[] properties, PropertyInfoBase[] baseClassProperties, bool checkResultDeclared)
{
int returnResultCounter = (baseClassProperties == null) ? 1 : baseClassProperties.Length + 1;
foreach (PropertyInfoBase pi in properties)
{
sb.Append(" ");
if (!checkResultDeclared)
{
sb.Append("int ");
}
sb.AppendLine(" checkResult = " + pi.Name + ".CompareTo(other." + pi.Name + ");");
sb.AppendLine(" if(checkResult != 0)");
sb.AppendLine(" {");
sb.AppendLine(
" return (checkResult > 0) ? " + returnResultCounter + " : -" + returnResultCounter
+ ";");
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
if (!checkResultDeclared)
{
checkResultDeclared = true;
}
returnResultCounter++;
}
}
/// <summary> /// Gets the value of the property when converting to a string array. /// </summary> /// <param name="pi"> /// property information /// </param> /// <returns> /// the value of the property when converting to a string array /// </returns> protected abstract string GetValueForToStringArray(PropertyInfoBase pi);
/// <summary>
/// Builds the Fields Region
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="properties">
/// The collection of properties for the class
/// </param>
protected override void DoFieldsRegion(StringBuilder sb, PropertyInfoBase[] properties)
{
// no op
}
/// <summary>
/// Generates the mutator for the property
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="pi">
/// The property to generate the mutator for
/// </param>
protected override void OnDoPropertyMutator(StringBuilder sb, PropertyInfoBase pi)
{
if (sb == null)
{
throw new ArgumentNullException("sb");
}
if (pi == null)
{
throw new ArgumentNullException("pi");
}
sb.AppendLine(" set");
sb.AppendLine(" {");
sb.AppendLine(" _" + Helpers.GetVariableName(pi.Name) + " = value;");
sb.AppendLine(" }");
}
/// <summary>
/// Generates the field code for a property member
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="pi">
/// The property to generate a field for
/// </param>
protected override void OnDoFieldItem(StringBuilder sb, PropertyInfoBase pi)
{
if (sb == null)
{
throw new ArgumentNullException("sb");
}
if (pi == null)
{
throw new ArgumentNullException("pi");
}
sb.AppendLine(" bool _" + Helpers.GetVariableName(pi.Name) + ";");
}
/// <summary> /// Gets the type for a property /// </summary> /// <param name="pi"> /// The property to generate a type for /// </param> /// <returns> /// .NET data type /// </returns> protected abstract string GetPropertyType(PropertyInfoBase pi);
/// <summary>
/// Generates the code for comparing properties in the CompareTo method
/// </summary>
/// <param name="sb">
/// StringBuilder to add the code to
/// </param>
/// <param name="properties">
/// The properties to generate code for
/// </param>
/// <param name="baseClassProperties">
/// Properties in the base class, if any
/// </param>
/// <param name="checkResultDeclared">
/// Whether the check result variable has been declared yet
/// </param>
protected abstract void OnDoCompareToProperties(
StringBuilder sb, PropertyInfoBase[] properties, PropertyInfoBase[] baseClassProperties, bool checkResultDeclared);
/// <summary> /// Generates the setter for the property /// </summary> /// <param name="sb"> /// The String Builder to add the code to /// </param> /// <param name="pi"> /// The property to generate the setter for /// </param> protected abstract void OnDoPropertyMutator(StringBuilder sb, PropertyInfoBase pi);
/// <summary>
/// Does any class specific properties. For example the count property on the difference class
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="properties">
/// The collection of properties for the class
/// </param>
protected override void OnDoClassSpecificProperties(StringBuilder sb, PropertyInfoBase[] properties)
{
if (sb == null)
{
throw new ArgumentNullException("sb");
}
if (properties == null)
{
throw new ArgumentNullException("properties");
}
sb.AppendLine(" /// <summary>");
sb.AppendLine(" /// Gets the number of properties that are different");
sb.AppendLine(" /// </summary>");
sb.AppendLine(" /// <return>");
sb.AppendLine(" /// the number of properties that are different");
sb.AppendLine(" /// </return>");
sb.AppendLine(" public override int Count");
sb.AppendLine(" {");
sb.AppendLine(" get");
sb.AppendLine(" {");
sb.AppendLine(" return");
sb.AppendLine(" (" + properties[0].Name + " ? 1 : 0)");
for (int i = 1; i < properties.Length; i++)
{
sb.AppendLine(" + (" + properties[i].Name + " ? 1 : 0)");
}
sb.AppendLine(" ;");
sb.AppendLine(" }");
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
}
/// <summary> /// Does any class specific properties. For example the count property on the difference class /// </summary> /// <param name="sb"> /// The String Builder to add the code to /// </param> /// <param name="properties"> /// The collection of properties for the class /// </param> protected abstract void OnDoClassSpecificProperties(StringBuilder sb, PropertyInfoBase[] properties);
/// <summary>
/// The do constructor method.
/// </summary>
/// <param name="sb">
/// The String Builder to add the code to
/// </param>
/// <param name="className">
/// The class name
/// </param>
/// <param name="properties">
/// Properties of the info class
/// </param>
/// <param name="baseClassName">
/// The name of the base class
/// </param>
/// <param name="baseClassProperties">
/// The properties of the base class
/// </param>
protected virtual void DoConstructorMethod(
StringBuilder sb, string className, PropertyInfoBase[] properties, string baseClassName, PropertyInfoBase[] baseClassProperties)
{
// Default Constructor
sb.AppendLine(Helpers.GetAutoGeneratedWarning());
sb.AppendLine(" /// <summary>");
sb.AppendLine(
" /// Initializes a new instance of the <see cref=\"" + className + this.GetClassSuffix()
+ "\"/> class.");
sb.AppendLine(" /// </summary>");
sb.AppendLine(" public " + className + this.GetClassSuffix() + "()");
sb.AppendLine(" {");
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
// Copy Constructor
sb.AppendLine(" /// <summary>");
sb.AppendLine(
" /// Initializes a new instance of the <see cref=\"" + className + this.GetClassSuffix()
+ "\"/> class.");
sb.AppendLine(" /// </summary>");
sb.AppendLine(" /// <param name=\"other\">");
sb.AppendLine(" /// Object to copy");
sb.AppendLine(" /// </param>");
sb.AppendLine(
" public " + className + this.GetClassSuffix() + "(" + className + this.GetClassSuffix()
+ " other)");
sb.AppendLine(" {");
sb.AppendLine(" if (other == null)");
sb.AppendLine(" {");
sb.AppendLine(" throw new System.ArgumentNullException(\"other\");");
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
foreach (PropertyInfoBase pi in properties)
{
sb.AppendLine(" this." + pi.Name + " = other." + pi.Name + ";");
}
sb.AppendLine(" }");
// Constructor
sb.AppendLine(string.Empty);
sb.AppendLine(Helpers.GetAutoGeneratedWarning());
sb.AppendLine(" /// <summary>");
sb.AppendLine(
" /// Initializes a new instance of the <see cref=\"" + className + this.GetClassSuffix()
+ "\"/> class.");
sb.AppendLine(" /// </summary>");
if (string.IsNullOrWhiteSpace(baseClassName) == false && baseClassProperties != null
&& baseClassProperties.Length > 0)
{
DoConstructorParamComments(sb, baseClassProperties);
}
DoConstructorParamComments(sb, properties);
sb.AppendLine(" public " + className + this.GetClassSuffix() + "(");
this.DoConstructorParameters(sb, properties, baseClassName, baseClassProperties);
if (string.IsNullOrWhiteSpace(baseClassName) == false && baseClassProperties != null
&& baseClassProperties.Length > 0)
{
sb.AppendLine(" : base(");
int counter = 0;
while (counter < baseClassProperties.Length)
{
sb.Append(" " + Helpers.GetVariableName(baseClassProperties[counter].Name));
counter++;
sb.AppendLine(counter < baseClassProperties.Length ? "," : ")");
}
}
sb.AppendLine(" {");
foreach (PropertyInfoBase pi in properties)
{
sb.AppendLine(" this." + pi.Name + " = " + Helpers.GetVariableName(pi.Name) + ";");
}
sb.AppendLine(" }");
sb.AppendLine(string.Empty);
}
/// <summary> /// Generates the field code for a property member /// </summary> /// <param name="sb"> /// The String Builder to add the code to /// </param> /// <param name="pi"> /// The property to generate a field for /// </param> protected abstract void OnDoFieldItem(StringBuilder sb, PropertyInfoBase pi);
/// <summary>
/// Gets the type for a property
/// </summary>
/// <param name="pi">
/// The property to generate a type for
/// </param>
/// <returns>
/// .NET data type
/// </returns>
protected override string GetPropertyType(PropertyInfoBase pi)
{
return "bool";
}
/// <summary>
/// Generates the code for the our methods region
/// </summary>
/// <param name="sb">
/// StringBuilder to add the code to
/// </param>
/// <param name="mainNamespaceName">
/// The main namespace
/// </param>
/// <param name="subNamespace">
/// The sub namespace, if any
/// </param>
/// <param name="className">
/// The class name
/// </param>
/// <param name="properties">
/// Properties of the info class
/// </param>
/// <param name="baseClassName">
/// The name of the base class
/// </param>
/// <param name="baseClassProperties">
/// The properties of the base class
/// </param>
private void DoOurMethodsRegion(
StringBuilder sb,
string mainNamespaceName,
string subNamespace,
string className,
PropertyInfoBase[] properties,
string baseClassName,
PropertyInfoBase[] baseClassProperties)
{
sb.AppendLine(" #region our methods");
sb.AppendLine(string.Empty);
this.DoGetHashCodeMethod(sb, properties, baseClassProperties);
sb.AppendLine(string.Empty);
sb.AppendLine(string.Empty);
sb.AppendLine(string.Empty);
this.DoClassSpecificMethods(
sb, mainNamespaceName, subNamespace, className, properties, baseClassName, baseClassProperties);
sb.AppendLine(" #endregion");
}
protected static void DoOdataVocabulariesMethod(
StringBuilder sb,
string mainNamespaceName,
string subNamespace,
string className,
PropertyInfoBase[] properties,
PropertyInfoBase[] baseClassProperties)
{
sb.AppendLine(" /// <summary>");
sb.AppendLine(" /// Gets the CDSL that defines the OData Vocabularies for this class");
sb.AppendLine(" /// </summary>");
sb.AppendLine(
" public static " + (baseClassProperties != null ? "new " : string.Empty)
+ "System.Xml.XmlReader GetOdataVocabularies()");
sb.AppendLine(" {");
string fullNamespace = mainNamespaceName
+ (!string.IsNullOrWhiteSpace(subNamespace) ? "." + subNamespace : null);
foreach (PropertyInfoBase property in properties)
{
sb.AppendLine(" // " + property.Name);
sb.AppendLine(string.Empty);
}
sb.AppendLine(" var schema = new XElement(");
sb.AppendLine(" \"Schema\",");
sb.AppendLine(" new XAttribute(\"Namespace\", \"" + fullNamespace + "\"),");
sb.AppendLine(" new XAttribute(\"xmlns\", \"http://schemas.microsoft.com/ado/2009/11/edm\"),");
sb.AppendLine(" // using directive");
sb.AppendLine(" new XElement(");
sb.AppendLine(" \"Using\",");
sb.AppendLine(" new XAttribute(\"Namespace\", \"Org.OData.Validation.V1\"),");
sb.AppendLine(" new XAttribute(\"Alias\", \"Validation\"),");
string fullClassName = fullNamespace + "." + className;
if (baseClassProperties != null && baseClassProperties.Any())
{
for (int position = 0; position < baseClassProperties.Count() - 1; position++)
{
sb.AppendLine(" new XElement(\"Annotations\",");
sb.AppendLine(
" new XAttribute(\"Target\", \"" + fullClassName + "/"
+ baseClassProperties[position].Name + "\")),");
}
sb.AppendLine(" new XElement(");
sb.AppendLine(" \"Annotations\",");
sb.AppendLine(
" new XAttribute(\"Target\", \"" + fullClassName + "/"
+ baseClassProperties[baseClassProperties.Count() - 1].Name + "\")),");
}
for (int position = 0; position < properties.Count() - 1; position++)
{
sb.AppendLine(" new XElement(");
sb.AppendLine(" \"Annotations\",");
sb.AppendLine(
" new XAttribute(\"Target\", \"" + fullClassName + "/"
+ properties[position].Name + "\")),");
}
sb.AppendLine(" new XElement(");
sb.AppendLine(" \"Annotations\",");
sb.AppendLine(
" new XAttribute(\"Target\", \"" + fullClassName + "/"
+ properties[properties.Count() - 1].Name + "\"))));");
sb.AppendLine(string.Empty);
sb.AppendLine(" Debug.Assert(schema.Document != null, \"schema.Document != null\");");
sb.AppendLine(" return schema.Document.CreateReader();");
sb.AppendLine(" }");
}