/// <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); }