/// <summary>
/// Adds code for the property.
/// </summary>
/// <param name="element">The element from which to build the property.</param>
/// <param name="type">The type of the property to generate.</param>
private void AddPropertyCode(BaseLeafSchemaElement element, Type type)
{
CodeMemberProperty prop = null;
foreach (CodeTypeMember member in CurrentType.Members)
{
if (member is CodeMemberProperty && member.Name == element.Name)
{
prop = member as CodeMemberProperty;
break;
}
}
if (prop == null)
{
throw new InvalidOperationException("Property " + element.Name + " wasn't found in the generated code.");
}
//try
//{
// return (string) GetValue("country");
//}
//catch (InvalidCastException e)
//{
// throw new StrongTypingException("Cannot get value because it is DBNull.", e);
//}
prop.GetStatements.Add(
new CodeTryCatchFinallyStatement(
new CodeStatement[] {
new CodeMethodReturnStatement(
new CodeCastExpression(type,
new CodeMethodInvokeExpression(null, "GetValue",
new CodeExpression[] { new CodePrimitiveExpression(element.Name) })))
},
new CodeCatchClause[] {
new CodeCatchClause("e", new CodeTypeReference(typeof(InvalidCastException)),
new CodeStatement[] {
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
typeof(StrongTypingException),
new CodeExpression[] {
new CodePrimitiveExpression("Cannot get value because it is DBNull."),
new CodeVariableReferenceExpression("e")
}))
})
},
new CodeStatement[0]));
// SetValue("country", value);
prop.SetStatements.Add(
new CodeMethodInvokeExpression(null, "SetValue",
new CodeExpression[] {
new CodePrimitiveExpression(element.Name),
new CodeVariableReferenceExpression("value")
}));
}
/// <summary>
/// Adds private fields and getter/setter statements pointing to it to empty properties.
/// </summary>
/// <remarks>
/// Naming convention is "_" + lowercase property name.
/// </remarks>
private void CheckProperty(BaseLeafSchemaElement element, Type type)
{
if (CurrentType == null)
{
return;
}
CodeMemberProperty prop = null;
// Locate the property declaration
foreach (CodeTypeMember member in CurrentType.Members)
{
if (member is CodeMemberProperty && member.Name == element.Name)
{
prop = (CodeMemberProperty)member;
break;
}
}
if (prop == null)
{
return;
}
// If there are no get/set statements, add field declarations and
// fill getter/setters
if (prop.GetStatements.Count == 0 && prop.SetStatements.Count == 0)
{
CodeMemberField fld = new CodeMemberField(type, "_" + element.Name.ToLower());
CurrentType.Members.Add(fld);
prop.GetStatements.Add(new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), fld.Name)));
prop.SetStatements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), fld.Name),
new CodePropertySetValueReferenceExpression()));
}
}
/// <summary>
/// If no customization files are defined, add an empty read/write property.
/// </summary>
/// <remarks>
/// Beware that with this configuration code may not compile because of the
/// warnings about the properties not returning any value.
/// </remarks>
private void AddProperty(BaseLeafSchemaElement element, Type type)
{
ArrayList nodes = Retriever.RetrieveCustomization(element);
if (nodes.Count != 0)
{
// Original type name is the current type name without the
// type naming convention appended during tree parsing.
string name = (Configuration.TypeNaming != String.Empty) ?
CurrentType.Name.Replace(Configuration.TypeNaming, "") :
CurrentType.Name;
CodeMemberProperty prop = CodeDomHelper.BuildProperty(
name, element.Name, Configuration.TypeNaming,
Configuration.CollectionNaming,
type, nodes, CurrentNamespace);
XmlAttribute[] attributes = ((XmlSchemaAnnotated)element.SchemaObject).UnhandledAttributes;
if (attributes != null)
{
foreach (XmlAttribute attr in attributes)
{
prop.UserData.Add(attr.LocalName, attr);
}
}
CurrentType.Members.Add(prop);
}
else if (Retriever.Files.Count == 0)
{
CodeMemberProperty prop = new CodeMemberProperty();
prop.Attributes = MemberAttributes.Public;
prop.Name = element.Name;
prop.Type = new CodeTypeReference(type);
prop.HasGet = true;
prop.HasSet = true;
CurrentType.Members.Add(prop);
}
}
private void DebugProperty(BaseLeafSchemaElement element)
{
CodeMemberProperty prop = null;
// Locate the property declaration
foreach (CodeTypeMember member in CurrentType.Members)
{
if (member is CodeMemberProperty && member.Name == element.Name)
{
prop = (CodeMemberProperty)member;
break;
}
}
if (prop == null)
{
return;
}
// Add the debugging statements
prop.GetStatements.Insert(0,
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(
typeof(System.Diagnostics.Debug)),
"WriteLine", new CodeExpression[] { new CodePrimitiveExpression(
"Getting property " + element.Name) })));
prop.SetStatements.Insert(0,
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(
typeof(System.Diagnostics.Debug)),
"WriteLine", new CodeExpression[] { new CodePrimitiveExpression(
"Setting property " + element.Name) })));
System.Diagnostics.Debug.WriteLine("");
}
/// <summary>
/// Adds code statements to InitClass and InitVars methods.
/// </summary>
/// <param name="currentType">The type whose property we will add.</param>
/// <param name="element">The current property element.</param>
/// <param name="propertyType">The property type.</param>
/// <param name="currentNamespace">Current namespace type declaration.</param>
/// <param name="initClass">InitClass method declaration.</param>
/// <param name="initVars">InitVars method declaration.</param>
public static void AddProperty(CodeTypeDeclaration currentType,
BaseLeafSchemaElement element, Type propertyType, CodeNamespace currentNamespace,
CodeMemberMethod initClass, CodeMemberMethod initVars)
{
if (currentType == null)
{
return;
}
//private DataColumn columntitle
currentType.Members.Add(
new CodeMemberField(typeof(DataColumn), "column" + element.Name));
//internal DataColumn titleColumn
//{
// get { return this.columntitle; }
//}
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = element.Name + "Column";
prop.Type = new CodeTypeReference(typeof(DataColumn));
prop.Attributes = MemberAttributes.Final | MemberAttributes.Assembly;
prop.HasGet = true;
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "column" + element.Name)));
currentType.Members.Add(prop);
#region Null-related methods at the DataRow level
CodeTypeDeclaration row = null;
foreach (CodeTypeDeclaration type in currentNamespace.Types)
{
if (type.Name == element.Parent.TypeName)
{
row = type;
break;
}
}
if (row != null)
{
//public bool IstitleNull() {
// return this.IsNull(this.tabletitles.titleColumn);
//}
CodeMemberMethod nullmethod = new CodeMemberMethod();
nullmethod.Name = "Is" + element.Name + "Null";
nullmethod.ReturnType = new CodeTypeReference(typeof(bool));
nullmethod.Statements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(), "IsNull",
new CodeExpression[] {
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(),
"table" + element.Parent.Name),
element.Name + "Column")
})));
row.Members.Add(nullmethod);
//public void SettitleNull() {
// this[this.tabletitles.titleColumn] = System.Convert.DBNull;
//}
nullmethod = new CodeMemberMethod();
nullmethod.Name = "Set" + element.Name + "Null";
nullmethod.Statements.Add(
new CodeAssignStatement(
new CodeIndexerExpression(
new CodeThisReferenceExpression(),
new CodeExpression[] {
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(),
"table" + element.Parent.Name),
element.Name + "Column")
}),
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(typeof(Convert)), "DBNull")));
row.Members.Add(nullmethod);
}
#endregion
// this.columntitle = new DataColumn("title",
// typeof(string), null, System.Data.MappingType.Element);
CodeExpression[] prm = new CodeExpression[4];
prm[0] = new CodePrimitiveExpression(element.Name);
prm[1] = new CodeTypeOfExpression(propertyType);
prm[2] = new CodePrimitiveExpression(null);
prm[3] = new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(typeof(System.Data.MappingType)), "Element");
initClass.Statements.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "column" + element.Name),
new CodeObjectCreateExpression(typeof(DataColumn), prm)));
// this.Columns.Add(this.columntitle);
prm = new CodeExpression[1];
prm[0] = new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "column" + element.Name);
initClass.Statements.Add(
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "Columns"),
"Add", prm));
// this.columntitle_id = this.Columns["title_id"];
initVars.Statements.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "column" + element.Name),
new CodeIndexerExpression(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "Columns"),
new CodeExpression[] { new CodePrimitiveExpression(element.Name) })));
}
/// <summary>
/// Retrieves a list containing XmlNode objects with the configurations that apply to
/// a property (Attribute or Element with a SimpleType or intrinsic XSD type.
/// </summary>
/// <param name="element">The XmlSchemaElement to filter by.</param>
/// <param name="files">The list of XmlDocuments to use for retrieval.</param>
/// <returns>ArrayList with the XmlNode objects matching the criteria.</returns>
private ArrayList GetPropertyConfiguration(BaseLeafSchemaElement element, ArrayList files)
{
// Retrieve the parent configuration, to load results from them.
ArrayList parentconfig = GetTypeConfiguration(element.Parent as VisitableElementComplexType, NodeType.Type, files);
ArrayList results = new ArrayList();
// If no configuration applies to the parent element, exit the method.
if (parentconfig.Count == 0)
{
return(results);
}
XmlAttribute[] attributes = ((XmlSchemaAnnotated)element.SchemaObject).UnhandledAttributes;
StringWriter w = new StringWriter();
//Open the query
w.Write("//xgf:Property[");
//---- ApplyTo section ----//
//Check for /Name
w.Write("(not(boolean(xgf:ApplyTo/xgf:Name)) or xgf:ApplyTo/xgf:Name=\"{0}\")", element.Name);
//Check for /Attribute
if (attributes != null)
{
foreach (XmlAttribute attr in attributes)
{
w.Write(" and (not(boolean(xgf:ApplyTo/xgf:Attribute/@Name=\"{0}\"))", attr.Name);
w.Write(" or (xgf:ApplyTo/xgf:Attribute/@Name=\"{0}\" and xgf:ApplyTo/xgf:Attribute/@Value=\"{1}\"))", attr.Name, attr.Value);
}
}
//------------------------//
//---- ExceptOf section ----//
//Check for /Name
w.Write(" and not(xgf:ExceptOf/xgf:Name=\"{0}\")", element.Name);
//Check for /Attribute
if (attributes != null)
{
foreach (XmlAttribute attr in attributes)
{
w.Write(" and (not(xgf:ExceptOf/xgf:Attribute/@Name=\"{0}\" and xgf:ExceptOf/xgf:Attribute/@Value=\"{1}\"))", attr.Name, attr.Value);
}
}
//------------------------//
//Close the query
w.Write("]");
string xpath = w.ToString();
// Traverse the parent nodes and select the nodes matching the query.
foreach (XmlNode conf in parentconfig)
{
XmlNodeList nodes = conf.SelectNodes(xpath, GetManager(conf.OwnerDocument));
foreach (XmlNode node in nodes)
{
results.Add(node);
}
}
return(results);
}
