private void ExportProperty(CodeTypeDeclaration codeClass, MemberMapping member, string ns, CodeIdentifiers memberScope, CodeConstructor ctor) { string name = memberScope.AddUnique(CodeExporter.MakeFieldName(member.Name), member); string typeName = member.GetTypeName(base.CodeProvider); CodeMemberField field = new CodeMemberField(typeName, name) { Attributes = MemberAttributes.Private }; codeClass.Members.Add(field); CodeMemberProperty property = base.CreatePropertyDeclaration(field, member.Name, typeName); property.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true)); this.AddMemberMetadata(field, property.CustomAttributes, member, ns, false, property.Comments, ctor); codeClass.Members.Add(property); if (member.CheckSpecified != SpecifiedAccessor.None) { field = new CodeMemberField(typeof(bool).FullName, name + "Specified") { Attributes = MemberAttributes.Private }; codeClass.Members.Add(field); property = base.CreatePropertyDeclaration(field, member.Name + "Specified", typeof(bool).FullName); property.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true)); CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(typeof(XmlIgnoreAttribute).FullName); property.CustomAttributes.Add(declaration); codeClass.Members.Add(property); } }
void ExportProperty(CodeTypeDeclaration codeClass, MemberMapping member, CodeIdentifiers memberScope) { string fieldName = memberScope.AddUnique(CodeExporter.MakeFieldName(member.Name), member); string fieldType = member.GetTypeName(CodeProvider); // need to create a private field CodeMemberField field = new CodeMemberField(fieldType, fieldName); field.Attributes = MemberAttributes.Private; codeClass.Members.Add(field); CodeMemberProperty prop = CreatePropertyDeclaration(field, member.Name, fieldType); prop.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true)); AddMemberMetadata(prop.CustomAttributes, member, false); codeClass.Members.Add(prop); if (member.CheckSpecified != SpecifiedAccessor.None) { field = new CodeMemberField(typeof(bool).FullName, fieldName + "Specified"); field.Attributes = MemberAttributes.Private; codeClass.Members.Add(field); prop = CreatePropertyDeclaration(field, member.Name + "Specified", typeof(bool).FullName); prop.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true)); CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(typeof(SoapIgnoreAttribute).FullName); prop.CustomAttributes.Add(attribute); codeClass.Members.Add(prop); } }
private static void DropDefaultAttribute(Accessor accessor, CodeCommentStatementCollection comments, string type) { if (!accessor.IsFixed && accessor.IsOptional) { CodeExporter.AddWarningComment(comments, Res.GetString("XmlDropDefaultAttribute", new object[] { type })); } }
private CodeTypeDeclaration ExportStruct(StructMapping mapping) { if (mapping.TypeDesc.IsRoot) { base.ExportRoot(mapping, typeof(SoapIncludeAttribute)); return(null); } if (!mapping.IncludeInSchema) { return(null); } string name = mapping.TypeDesc.Name; string str2 = (mapping.TypeDesc.BaseTypeDesc == null) ? string.Empty : mapping.TypeDesc.BaseTypeDesc.Name; CodeTypeDeclaration declaration = new CodeTypeDeclaration(name) { IsPartial = base.CodeProvider.Supports(GeneratorSupport.PartialTypes) }; declaration.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true)); base.CodeNamespace.Types.Add(declaration); if ((str2 != null) && (str2.Length > 0)) { declaration.BaseTypes.Add(str2); } else { base.AddPropertyChangedNotifier(declaration); } declaration.TypeAttributes |= TypeAttributes.Public; if (mapping.TypeDesc.IsAbstract) { declaration.TypeAttributes |= TypeAttributes.Abstract; } CodeExporter.AddIncludeMetadata(declaration.CustomAttributes, mapping, typeof(SoapIncludeAttribute)); if (base.GenerateProperties) { for (int j = 0; j < mapping.Members.Length; j++) { this.ExportProperty(declaration, mapping.Members[j], mapping.Scope); } } else { for (int k = 0; k < mapping.Members.Length; k++) { this.ExportMember(declaration, mapping.Members[k]); } } for (int i = 0; i < mapping.Members.Length; i++) { this.EnsureTypesExported(mapping.Members[i].Elements, null); } if (mapping.BaseMapping != null) { this.ExportType(mapping.BaseMapping); } this.ExportDerivedStructs(mapping); CodeGenerator.ValidateIdentifiers(declaration); return(declaration); }
private void ExportType(TypeMapping mapping, string name, string ns, ElementAccessor rootElement, bool checkReference) { if ((!mapping.IsReference || (mapping.Namespace == "http://schemas.xmlsoap.org/soap/encoding/")) && ((!(mapping is StructMapping) || !checkReference) || (!((StructMapping)mapping).ReferencedByTopLevelElement || (rootElement != null)))) { if (((mapping is ArrayMapping) && (rootElement != null)) && (rootElement.IsTopLevelInSchema && (((ArrayMapping)mapping).TopLevelMapping != null))) { mapping = ((ArrayMapping)mapping).TopLevelMapping; } CodeTypeDeclaration declaration = null; if (base.ExportedMappings[mapping] == null) { base.ExportedMappings.Add(mapping, mapping); if (mapping.TypeDesc.IsMappedType) { declaration = mapping.TypeDesc.ExtendedType.ExportTypeDefinition(base.CodeNamespace, base.CodeCompileUnit); } else if (mapping is EnumMapping) { declaration = base.ExportEnum((EnumMapping)mapping, typeof(XmlEnumAttribute)); } else if (mapping is StructMapping) { declaration = this.ExportStruct((StructMapping)mapping); } else if (mapping is ArrayMapping) { this.EnsureTypesExported(((ArrayMapping)mapping).Elements, ns); } if (declaration != null) { if (!mapping.TypeDesc.IsMappedType) { declaration.CustomAttributes.Add(base.GeneratedCodeAttribute); declaration.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(SerializableAttribute).FullName)); if (!declaration.IsEnum) { declaration.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(DebuggerStepThroughAttribute).FullName)); declaration.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(DesignerCategoryAttribute).FullName, new CodeAttributeArgument[] { new CodeAttributeArgument(new CodePrimitiveExpression("code")) })); } base.AddTypeMetadata(declaration.CustomAttributes, typeof(XmlTypeAttribute), mapping.TypeDesc.Name, Accessor.UnescapeName(mapping.TypeName), mapping.Namespace, mapping.IncludeInSchema); } else if (CodeExporter.FindAttributeDeclaration(typeof(GeneratedCodeAttribute), declaration.CustomAttributes) == null) { declaration.CustomAttributes.Add(base.GeneratedCodeAttribute); } base.ExportedClasses.Add(mapping, declaration); } } else { declaration = (CodeTypeDeclaration)base.ExportedClasses[mapping]; } if ((declaration != null) && (rootElement != null)) { this.AddRootMetadata(declaration.CustomAttributes, mapping, name, ns, rootElement); } } }
CodeTypeDeclaration ExportStruct(StructMapping mapping) { if (mapping.TypeDesc.IsRoot) { ExportRoot(mapping, typeof(SoapIncludeAttribute)); return(null); } if (!mapping.IncludeInSchema) { return(null); } string className = mapping.TypeDesc.Name; string baseName = mapping.TypeDesc.BaseTypeDesc == null ? string.Empty : mapping.TypeDesc.BaseTypeDesc.Name; CodeTypeDeclaration codeClass = new CodeTypeDeclaration(className); codeClass.IsPartial = CodeProvider.Supports(GeneratorSupport.PartialTypes); codeClass.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true)); CodeNamespace.Types.Add(codeClass); if (baseName != null && baseName.Length > 0) { codeClass.BaseTypes.Add(baseName); } else { AddPropertyChangedNotifier(codeClass); } codeClass.TypeAttributes |= TypeAttributes.Public; if (mapping.TypeDesc.IsAbstract) { codeClass.TypeAttributes |= TypeAttributes.Abstract; } CodeExporter.AddIncludeMetadata(codeClass.CustomAttributes, mapping, typeof(SoapIncludeAttribute)); if (GenerateProperties) { for (int i = 0; i < mapping.Members.Length; i++) { ExportProperty(codeClass, mapping.Members[i], mapping.Scope); } } else { for (int i = 0; i < mapping.Members.Length; i++) { ExportMember(codeClass, mapping.Members[i]); } } for (int i = 0; i < mapping.Members.Length; i++) { EnsureTypesExported(mapping.Members[i].Elements, null); } if (mapping.BaseMapping != null) { ExportType(mapping.BaseMapping); } ExportDerivedStructs(mapping); CodeGenerator.ValidateIdentifiers(codeClass); return(codeClass); }
private CodeAttributeArgument[] GetDefaultValueArguments(PrimitiveMapping mapping, object value, out CodeExpression initExpression) { initExpression = null; if (value == null) { return(null); } CodeExpression left = null; CodeExpression expression2 = null; Type type = value.GetType(); CodeAttributeArgument[] argumentArray = null; if (mapping is EnumMapping) { if (((EnumMapping)mapping).IsFlags) { string[] strArray = ((string)value).Split(null); for (int i = 0; i < strArray.Length; i++) { if (strArray[i].Length != 0) { CodeExpression right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), strArray[i]); if (left != null) { left = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.BitwiseOr, right); } else { left = right; } } } } else { left = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), (string)value); } initExpression = left; argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(left) }; } else if (((type == typeof(bool)) || (type == typeof(int))) || ((type == typeof(string)) || (type == typeof(double)))) { initExpression = left = new CodePrimitiveExpression(value); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(left) }; } else if (((type == typeof(short)) || (type == typeof(long))) || (((type == typeof(float)) || (type == typeof(byte))) || (type == typeof(decimal)))) { left = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (((type == typeof(sbyte)) || (type == typeof(ushort))) || ((type == typeof(uint)) || (type == typeof(ulong)))) { value = CodeExporter.PromoteType(type, value); left = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (type == typeof(DateTime)) { string str; long ticks; DateTime time = (DateTime)value; if (mapping.TypeDesc.FormatterName == "Date") { str = XmlCustomFormatter.FromDate(time); DateTime time2 = new DateTime(time.Year, time.Month, time.Day); ticks = time2.Ticks; } else if (mapping.TypeDesc.FormatterName == "Time") { str = XmlCustomFormatter.FromDateTime(time); ticks = time.Ticks; } else { str = XmlCustomFormatter.FromDateTime(time); ticks = time.Ticks; } left = new CodePrimitiveExpression(str); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(DateTime)), new CodeExpression[] { new CodePrimitiveExpression(ticks) }); } else if (type == typeof(Guid)) { left = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(Guid)), new CodeExpression[] { left }); } if ((mapping.TypeDesc.FullName != type.ToString()) && !(mapping is EnumMapping)) { initExpression = new CodeCastExpression(mapping.TypeDesc.FullName, initExpression); } return(argumentArray); }
private CodeTypeDeclaration ExportStruct(StructMapping mapping) { CodeConstructor constructor; if (mapping.TypeDesc.IsRoot) { base.ExportRoot(mapping, typeof(XmlIncludeAttribute)); return(null); } string name = mapping.TypeDesc.Name; string str2 = ((mapping.TypeDesc.BaseTypeDesc == null) || mapping.TypeDesc.BaseTypeDesc.IsRoot) ? string.Empty : mapping.TypeDesc.BaseTypeDesc.FullName; CodeTypeDeclaration declaration = new CodeTypeDeclaration(name) { IsPartial = base.CodeProvider.Supports(GeneratorSupport.PartialTypes) }; declaration.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true)); base.CodeNamespace.Types.Add(declaration); constructor = new CodeConstructor { Attributes = (constructor.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public }; declaration.Members.Add(constructor); if (mapping.TypeDesc.IsAbstract) { constructor.Attributes |= MemberAttributes.Abstract; } if ((str2 != null) && (str2.Length > 0)) { declaration.BaseTypes.Add(str2); } else { base.AddPropertyChangedNotifier(declaration); } declaration.TypeAttributes |= TypeAttributes.Public; if (mapping.TypeDesc.IsAbstract) { declaration.TypeAttributes |= TypeAttributes.Abstract; } CodeExporter.AddIncludeMetadata(declaration.CustomAttributes, mapping, typeof(XmlIncludeAttribute)); if (mapping.IsSequence) { int num = 0; for (int j = 0; j < mapping.Members.Length; j++) { MemberMapping mapping2 = mapping.Members[j]; if (mapping2.IsParticle && (mapping2.SequenceId < 0)) { mapping2.SequenceId = num++; } } } if (base.GenerateProperties) { for (int k = 0; k < mapping.Members.Length; k++) { this.ExportProperty(declaration, mapping.Members[k], mapping.Namespace, mapping.Scope, constructor); } } else { for (int m = 0; m < mapping.Members.Length; m++) { this.ExportMember(declaration, mapping.Members[m], mapping.Namespace, constructor); } } for (int i = 0; i < mapping.Members.Length; i++) { if (mapping.Members[i].Xmlns == null) { this.EnsureTypesExported(mapping.Members[i].Elements, mapping.Namespace); this.EnsureTypesExported(mapping.Members[i].Attribute, mapping.Namespace); this.EnsureTypesExported(mapping.Members[i].Text, mapping.Namespace); } } if (mapping.BaseMapping != null) { this.ExportType(mapping.BaseMapping, null, mapping.Namespace, null, false); } this.ExportDerivedStructs(mapping); CodeGenerator.ValidateIdentifiers(declaration); if (constructor.Statements.Count == 0) { declaration.Members.Remove(constructor); } return(declaration); }
private void AddDefaultValueAttribute(CodeMemberField field, CodeAttributeDeclarationCollection metadata, object defaultValue, TypeMapping mapping, CodeCommentStatementCollection comments, TypeDesc memberTypeDesc, Accessor accessor, CodeConstructor ctor) { string str = accessor.IsFixed ? "fixed" : "default"; if (!memberTypeDesc.HasDefaultSupport) { if ((comments != null) && (defaultValue is string)) { DropDefaultAttribute(accessor, comments, memberTypeDesc.FullName); CodeExporter.AddWarningComment(comments, Res.GetString("XmlDropAttributeValue", new object[] { str, mapping.TypeName, defaultValue.ToString() })); } } else if (memberTypeDesc.IsArrayLike && (accessor is ElementAccessor)) { if ((comments != null) && (defaultValue is string)) { DropDefaultAttribute(accessor, comments, memberTypeDesc.FullName); CodeExporter.AddWarningComment(comments, Res.GetString("XmlDropArrayAttributeValue", new object[] { str, defaultValue.ToString(), ((ElementAccessor)accessor).Name })); } } else if ((mapping.TypeDesc.IsMappedType && (field != null)) && (defaultValue is string)) { SchemaImporterExtension extension = mapping.TypeDesc.ExtendedType.Extension; CodeExpression init = extension.ImportDefaultValue((string)defaultValue, mapping.TypeDesc.FullName); if (init != null) { if (ctor != null) { AddInitializationStatement(ctor, field, init); } else { field.InitExpression = extension.ImportDefaultValue((string)defaultValue, mapping.TypeDesc.FullName); } } if (comments != null) { DropDefaultAttribute(accessor, comments, mapping.TypeDesc.FullName); if (init == null) { CodeExporter.AddWarningComment(comments, Res.GetString("XmlNotKnownDefaultValue", new object[] { extension.GetType().FullName, str, (string)defaultValue, mapping.TypeName, mapping.Namespace })); } } } else { object obj2 = null; if ((defaultValue is string) || (defaultValue == null)) { obj2 = this.ImportDefault(mapping, (string)defaultValue); } if (obj2 != null) { if (!(mapping is PrimitiveMapping)) { DropDefaultAttribute(accessor, comments, memberTypeDesc.FullName); CodeExporter.AddWarningComment(comments, Res.GetString("XmlDropNonPrimitiveAttributeValue", new object[] { str, defaultValue.ToString() })); } else { PrimitiveMapping mapping2 = (PrimitiveMapping)mapping; if (((comments != null) && !mapping2.TypeDesc.HasDefaultSupport) && mapping2.TypeDesc.IsMappedType) { DropDefaultAttribute(accessor, comments, mapping2.TypeDesc.FullName); } else if (obj2 == DBNull.Value) { if (comments != null) { CodeExporter.AddWarningComment(comments, Res.GetString("XmlDropAttributeValue", new object[] { str, mapping2.TypeName, defaultValue.ToString() })); } } else { CodeAttributeArgument[] arguments = null; CodeExpression initExpression = null; if (mapping2.IsList) { object[] objArray = (object[])obj2; CodeExpression[] initializers = new CodeExpression[objArray.Length]; for (int i = 0; i < objArray.Length; i++) { this.GetDefaultValueArguments(mapping2, objArray[i], out initializers[i]); } initExpression = new CodeArrayCreateExpression(field.Type, initializers); } else { arguments = this.GetDefaultValueArguments(mapping2, obj2, out initExpression); } if (field != null) { if (ctor != null) { AddInitializationStatement(ctor, field, initExpression); } else { field.InitExpression = initExpression; } } if (((arguments != null) && mapping2.TypeDesc.HasDefaultSupport) && (accessor.IsOptional && !accessor.IsFixed)) { CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(typeof(DefaultValueAttribute).FullName, arguments); metadata.Add(declaration); } else if (comments != null) { DropDefaultAttribute(accessor, comments, memberTypeDesc.FullName); } } } } } }