internal override void AddToConstructor(CodeConstructor functionalConstructor) { if (!this.IsList) { functionalConstructor.Parameters.Add(new CodeParameterDeclarationExpression(this.ReturnType, this.propertyName)); if (!this.FromBaseType) { functionalConstructor.Statements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference("this", this.propertyName), new CodeVariableReferenceExpression(this.propertyName))); } else { functionalConstructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(this.propertyName)); } } else { CodeParameterDeclarationExpressionCollection parameters = functionalConstructor.Parameters; CodeTypeReference[] codeTypeReference = new CodeTypeReference[] { new CodeTypeReference(this.clrTypeName) }; parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("IEnumerable", codeTypeReference), this.propertyName)); if (!this.FromBaseType) { CodeTypeReference listType = this.GetListType(); functionalConstructor.Statements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference("this", NameGenerator.ChangeClrName(this.propertyName, NameOptions.MakeField)), new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(listType), "Initialize", this.GetListParameters(true, true)))); } else { functionalConstructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(this.propertyName)); } } }
internal void AddGetStatements(CodeStatementCollection getStatements) { CodeThisReferenceExpression codeThisReferenceExpression = CodeDomHelper.This(); CodeExpression[] codeExpressionArray = new CodeExpression[] { CodeDomHelper.CreateFieldReference("WildCard", "DefaultWildCard") }; getStatements.Add(new CodeMethodReturnStatement(CodeDomHelper.CreateMethodCall(codeThisReferenceExpression, "GetWildCards", codeExpressionArray))); }
internal static CodeExpression CreateGetBuiltInSimpleType(XmlTypeCode typeCode) { return(CodeDomHelper.CreateMethodCall( new CodeTypeReferenceExpression("XmlSchemaType"), Constants.GetBuiltInSimpleType, CodeDomHelper.CreateFieldReference(Constants.XmlTypeCode, typeCode.ToString()))); }
internal static CodeExpression CreateGetBuiltInSimpleType(XmlTypeCode typeCode) { CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XmlSchemaType"); CodeExpression[] codeExpressionArray = new CodeExpression[] { CodeDomHelper.CreateFieldReference("XmlTypeCode", typeCode.ToString()) }; return(CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "GetBuiltInSimpleType", codeExpressionArray)); }
protected CodeExpression GetSchemaDatatypeExpression() { CodeTypeReferenceExpression codeTypeReferenceExpression = CodeDomHelper.CreateTypeReferenceExp("XmlSchemaType"); CodeExpression[] codeExpressionArray = new CodeExpression[] { CodeDomHelper.CreateFieldReference("XmlTypeCode", this.typeRef.TypeCodeString) }; CodeExpression codeFieldReferenceExpression = new CodeFieldReferenceExpression(CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "GetBuiltInSimpleType", codeExpressionArray), "Datatype"); return(codeFieldReferenceExpression); }
internal virtual void InsertDefaultFixedValueInDefaultCtor(CodeConstructor ctor) { if (this.FixedValue != null) { ctor.Statements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference(null, this.propertyName), CodeDomHelper.CreateFieldReference(null, NameGenerator.ChangeClrName(this.propertyName, NameOptions.MakeFixedValueField)))); } else if (this.DefaultValue != null) { ctor.Statements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference(null, this.propertyName), CodeDomHelper.CreateFieldReference(null, NameGenerator.ChangeClrName(this.propertyName, NameOptions.MakeDefaultValueField)))); } }
private CodeMemberProperty InnerTypeProperty() { CodeMemberProperty innerTypeProperty = CodeDomHelper.CreateProperty("Content", new CodeTypeReference(this.innerTypeName), MemberAttributes.Public); innerTypeProperty.HasSet = false; if (this.clrTypeInfo.IsSubstitutionMember()) { CodeMemberProperty attributes = innerTypeProperty; attributes.Attributes = attributes.Attributes | MemberAttributes.New; } innerTypeProperty.GetStatements.Add(new CodeMethodReturnStatement(CodeDomHelper.CreateFieldReference(null, this.memberName))); return(innerTypeProperty); }
private CodeMemberProperty BuildLocalElementDictionary() { CodeMemberProperty localDictionaryProperty = CodeDomHelper.CreateInterfaceImplProperty("LocalElementsDictionary", "IXMetaData", CodeDomHelper.CreateDictionaryType("XName", "System.Type")); CodeMemberField localDictionaryField = CodeDomHelper.CreateDictionaryField("localElementDictionary", "XName", "System.Type"); CodeMemberMethod localDictionaryMethod = CodeDomHelper.CreateMethod("BuildElementDictionary", MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.Assembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Private, null); localDictionaryMethod.Statements.AddRange(this.propertyDictionaryAddStatements); this.decl.Members.Add(localDictionaryField); this.decl.Members.Add(localDictionaryMethod); localDictionaryProperty.GetStatements.Add(new CodeMethodReturnStatement(CodeDomHelper.CreateFieldReference(null, "localElementDictionary"))); CodeDomHelper.AddBrowseNever(localDictionaryProperty); CodeDomHelper.AddBrowseNever(localDictionaryField); return(localDictionaryProperty); }
internal static CodeExpression CreateSimpleTypeDef(ClrSimpleTypeInfo typeInfo, Dictionary <XmlSchemaObject, string> nameMappings, LinqToXsdSettings settings, bool memberOrItemType) { CodeExpression codeExpression; if ((!memberOrItemType ? true : !typeInfo.IsGlobal)) { codeExpression = SimpleTypeCodeDomHelper.MaterializeSimpleTypeDef(typeInfo, nameMappings, settings); } else { typeInfo.UpdateClrTypeName(nameMappings, settings); codeExpression = CodeDomHelper.CreateFieldReference(typeInfo.clrtypeName, "TypeDefinition"); } return(codeExpression); }
internal static CodeExpression CreateSimpleTypeDef(ClrSimpleTypeInfo typeInfo, Dictionary <XmlSchemaObject, string> nameMappings, LinqToXsdSettings settings, bool memberOrItemType) { //If the enclosed member type or item type is a global named type, reuse the definition if (memberOrItemType && typeInfo.IsGlobal) { typeInfo.UpdateClrTypeName(nameMappings, settings); return(CodeDomHelper.CreateFieldReference(typeInfo.clrtypeName, Constants.SimpleTypeDefInnerType)); } else { return(MaterializeSimpleTypeDef(typeInfo, nameMappings, settings)); } }
private CodeMemberMethod SetSubstitutionMember() { CodeMemberMethod setSubstMember = CodeDomHelper.CreateMethod("SetSubstitutionMember", MemberAttributes.Family, null); setSubstMember.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(this.innerTypeName), this.memberName)); setSubstMember.Statements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference("this", this.memberName), new CodeVariableReferenceExpression(this.memberName))); if (this.clrTypeInfo.IsSubstitutionMember()) { CodeStatementCollection statements = setSubstMember.Statements; CodeBaseReferenceExpression codeBaseReferenceExpression = new CodeBaseReferenceExpression(); CodeExpression[] codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression(this.memberName) }; statements.Add(CodeDomHelper.CreateMethodCall(codeBaseReferenceExpression, "SetSubstitutionMember", codeVariableReferenceExpression)); } return(setSubstMember); }
internal override void CreateDefaultConstructor(List <ClrAnnotation> annotations) { CodeMemberField typeField = CodeDomHelper.CreateMemberField(this.memberName, this.innerTypeName, MemberAttributes.Private, false); CodeFieldReferenceExpression fieldRef = CodeDomHelper.CreateFieldReference("this", this.memberName); CodeConstructor emptyConstructor = CodeDomHelper.CreateConstructor(MemberAttributes.Public); if ((this.innerTypeAttributes & TypeAttributes.Abstract) != TypeAttributes.NotPublic) { emptyConstructor.Statements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression("InvalidOperationException", new CodeExpression[0]))); } else { CodeStatementCollection statements = emptyConstructor.Statements; CodeExpression[] codeObjectCreateExpression = new CodeExpression[] { new CodeObjectCreateExpression(typeField.Type, new CodeExpression[0]) }; statements.Add(CodeDomHelper.CreateMethodCall(null, "SetInnerType", codeObjectCreateExpression)); } CodeConstructor dummyConstructor = null; if (this.clrTypeInfo.IsSubstitutionHead) { dummyConstructor = CodeDomHelper.CreateConstructor(MemberAttributes.Family); dummyConstructor.Parameters.Add(new CodeParameterDeclarationExpression("System.Boolean", "setNull")); this.decl.Members.Add(dummyConstructor); } if (this.clrTypeInfo.IsSubstitutionMember()) { emptyConstructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(true)); if (dummyConstructor != null) { dummyConstructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(true)); } } TypeBuilder.ApplyAnnotations(emptyConstructor, annotations, null); this.decl.Members.Add(typeField); this.decl.Members.Add(emptyConstructor); this.decl.Members.Add(this.CreateUntypedProperty(fieldRef)); this.decl.Members.Add(this.InnerTypeProperty()); this.decl.Members.Add(this.SetInnerType()); if (this.clrTypeInfo.IsSubstitutionHead) { this.decl.Members.Add(this.SetSubstitutionMember()); } }
private CodeMemberMethod SetInnerType() { CodeMemberMethod setInnerType = CodeDomHelper.CreateMethod("SetInnerType", MemberAttributes.Private, null); setInnerType.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(this.innerTypeName), this.memberName)); CodeStatementCollection statements = setInnerType.Statements; CodeFieldReferenceExpression codeFieldReferenceExpression = CodeDomHelper.CreateFieldReference("this", this.memberName); string str = this.innerTypeName; CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XTypedServices"); CodeExpression[] codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression(this.memberName) }; statements.Add(new CodeAssignStatement(codeFieldReferenceExpression, new CodeCastExpression(str, new CodeMethodInvokeExpression(codeTypeReferenceExpression, "GetCloneIfRooted", codeVariableReferenceExpression)))); setInnerType.Statements.Add(this.SetNameMethodCall()); if (this.clrTypeInfo.IsSubstitutionMember()) { CodeStatementCollection codeStatementCollection = setInnerType.Statements; CodeBaseReferenceExpression codeBaseReferenceExpression = new CodeBaseReferenceExpression(); codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression(this.memberName) }; codeStatementCollection.Add(CodeDomHelper.CreateMethodCall(codeBaseReferenceExpression, "SetSubstitutionMember", codeVariableReferenceExpression)); } return(setInnerType); }
public static CodeMemberProperty CreateProperty(string propertyName, string propertyType, CodeMemberField field, MemberAttributes attributes, bool hasSet) { CodeTypeReference returnType = null; returnType = (propertyType == null ? field.Type : new CodeTypeReference(propertyType)); CodeMemberProperty valueProperty = CodeDomHelper.CreateProperty(propertyName, returnType, attributes); valueProperty.GetStatements.Add(new CodeMethodReturnStatement(CodeDomHelper.CreateFieldReference(null, field.Name))); if (hasSet) { CodeExpression rightExpression = null; if (!(field.Type.BaseType != returnType.BaseType)) { rightExpression = CodeDomHelper.SetValue(); } else { rightExpression = new CodeCastExpression(field.Type, CodeDomHelper.SetValue()); } valueProperty.SetStatements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference("this", field.Name), rightExpression)); } return(valueProperty); }
public static CodeExpression CreateFacets(ClrSimpleTypeInfo type) { CompiledFacets facets = type.RestrictionFacets; CodeObjectCreateExpression createFacets = new CodeObjectCreateExpression(); createFacets.CreateType = new CodeTypeReference(Constants.RestrictionFacets); RestrictionFlags flags = facets.Flags; if (flags == 0) { return(new CodePrimitiveExpression(null)); } else { CodeCastExpression cast = new CodeCastExpression(new CodeTypeReference(Constants.RestrictionFlags), new CodePrimitiveExpression( System.Convert.ToInt32(flags, CultureInfo.InvariantCulture.NumberFormat))); createFacets.Parameters.Add(cast); } if ((flags & RestrictionFlags.Enumeration) != 0) { CodeArrayCreateExpression enums = new CodeArrayCreateExpression(); enums.CreateType = new CodeTypeReference("System.Object"); foreach (object o in facets.Enumeration) { GetCreateValueExpression(o, type, enums.Initializers); } createFacets.Parameters.Add(enums); } else { createFacets.Parameters.Add(new CodePrimitiveExpression(null)); } int fractionDigits = default(int); if ((flags & RestrictionFlags.FractionDigits) != 0) { fractionDigits = facets.FractionDigits; } createFacets.Parameters.Add(new CodePrimitiveExpression(fractionDigits)); int length = default(int); if ((flags & RestrictionFlags.Length) != 0) { length = facets.Length; } createFacets.Parameters.Add(new CodePrimitiveExpression(length)); object maxExclusive = default(object); if ((flags & RestrictionFlags.MaxExclusive) != 0) { maxExclusive = facets.MaxExclusive; } GetCreateValueExpression(maxExclusive, type, createFacets.Parameters); object maxInclusive = default(object); if ((flags & RestrictionFlags.MaxInclusive) != 0) { maxInclusive = facets.MaxInclusive; } GetCreateValueExpression(maxInclusive, type, createFacets.Parameters); int maxLength = default(int); if ((flags & RestrictionFlags.MaxLength) != 0) { maxLength = facets.MaxLength; } createFacets.Parameters.Add(new CodePrimitiveExpression(maxLength)); object minExclusive = default(object); if ((flags & RestrictionFlags.MinExclusive) != 0) { minExclusive = facets.MinExclusive; } GetCreateValueExpression(minExclusive, type, createFacets.Parameters); object minInclusive = default(object); if ((flags & RestrictionFlags.MinInclusive) != 0) { minInclusive = facets.MinInclusive; } GetCreateValueExpression(minInclusive, type, createFacets.Parameters); int minLength = default(int); if ((flags & RestrictionFlags.MinLength) != 0) { minLength = facets.MinLength; } createFacets.Parameters.Add(new CodePrimitiveExpression(minLength)); if ((flags & RestrictionFlags.Pattern) != 0) { CodeArrayCreateExpression patternStrs = new CodeArrayCreateExpression(); patternStrs.CreateType = new CodeTypeReference(XTypedServices.typeOfString); foreach (object o in facets.Patterns) { string str = o.ToString(); patternStrs.Initializers.Add(new CodePrimitiveExpression(str)); } createFacets.Parameters.Add(patternStrs); } else { createFacets.Parameters.Add(new CodePrimitiveExpression(null)); } int totalDigits = default(int); if ((flags & RestrictionFlags.TotalDigits) != 0) { totalDigits = facets.TotalDigits; } createFacets.Parameters.Add(new CodePrimitiveExpression(totalDigits)); XmlSchemaWhiteSpace ws = facets.WhiteSpace; createFacets.Parameters.Add( CodeDomHelper.CreateFieldReference(Constants.XmlSchemaWhiteSpace, ws.ToString())); return(createFacets); }
public static CodeExpression CreateFacets(ClrSimpleTypeInfo type) { //object o = null; CodeExpression codePrimitiveExpression; CompiledFacets facets = type.RestrictionFacets; CodeObjectCreateExpression createFacets = new CodeObjectCreateExpression() { CreateType = new CodeTypeReference("Xml.Schema.Linq.RestrictionFacets") }; Xml.Schema.Linq.RestrictionFlags flags = facets.Flags; if ((int)flags != 0) { CodeCastExpression cast = new CodeCastExpression(new CodeTypeReference("Xml.Schema.Linq.RestrictionFlags"), new CodePrimitiveExpression((object)Convert.ToInt32(flags, CultureInfo.InvariantCulture.NumberFormat))); createFacets.Parameters.Add(cast); if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.Enumeration) == 0) { createFacets.Parameters.Add(new CodePrimitiveExpression(null)); } else { CodeArrayCreateExpression enums = new CodeArrayCreateExpression() { CreateType = new CodeTypeReference("System.Object") }; foreach (object o in facets.Enumeration) { SimpleTypeCodeDomHelper.GetCreateValueExpression(o, type, enums.Initializers); } createFacets.Parameters.Add(enums); } int fractionDigits = 0; if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.FractionDigits) != 0) { fractionDigits = facets.FractionDigits; } createFacets.Parameters.Add(new CodePrimitiveExpression((object)fractionDigits)); int length = 0; if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.Length) != 0) { length = facets.Length; } createFacets.Parameters.Add(new CodePrimitiveExpression((object)length)); object maxExclusive = null; if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MaxExclusive) != 0) { maxExclusive = facets.MaxExclusive; } SimpleTypeCodeDomHelper.GetCreateValueExpression(maxExclusive, type, createFacets.Parameters); object maxInclusive = null; if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MaxInclusive) != 0) { maxInclusive = facets.MaxInclusive; } SimpleTypeCodeDomHelper.GetCreateValueExpression(maxInclusive, type, createFacets.Parameters); int maxLength = 0; if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MaxLength) != 0) { maxLength = facets.MaxLength; } createFacets.Parameters.Add(new CodePrimitiveExpression((object)maxLength)); object minExclusive = null; if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MinExclusive) != 0) { minExclusive = facets.MinExclusive; } SimpleTypeCodeDomHelper.GetCreateValueExpression(minExclusive, type, createFacets.Parameters); object minInclusive = null; if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MinInclusive) != 0) { minInclusive = facets.MinInclusive; } SimpleTypeCodeDomHelper.GetCreateValueExpression(minInclusive, type, createFacets.Parameters); int minLength = 0; if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.MinLength) != 0) { minLength = facets.MinLength; } createFacets.Parameters.Add(new CodePrimitiveExpression((object)minLength)); if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.Pattern) == 0) { createFacets.Parameters.Add(new CodePrimitiveExpression(null)); } else { CodeArrayCreateExpression patternStrs = new CodeArrayCreateExpression() { CreateType = new CodeTypeReference(XTypedServices.typeOfString) }; foreach (object pattern in facets.Patterns) { string str = pattern.ToString(); patternStrs.Initializers.Add(new CodePrimitiveExpression(str)); } createFacets.Parameters.Add(patternStrs); } int totalDigits = 0; if ((int)(flags & Xml.Schema.Linq.RestrictionFlags.TotalDigits) != 0) { totalDigits = facets.TotalDigits; } createFacets.Parameters.Add(new CodePrimitiveExpression((object)totalDigits)); Xml.Schema.Linq.XmlSchemaWhiteSpace ws = facets.WhiteSpace; createFacets.Parameters.Add(CodeDomHelper.CreateFieldReference("XmlSchemaWhiteSpace", ws.ToString())); codePrimitiveExpression = createFacets; } else { codePrimitiveExpression = new CodePrimitiveExpression(null); } return(codePrimitiveExpression); }
internal static CodeTypeDeclaration CreateTypeManager(XmlQualifiedName rootElementName, bool enableServiceReference, CodeStatementCollection typeDictionaryStatements, CodeStatementCollection elementDictionaryStatements, CodeStatementCollection wrapperDictionaryStatements) { string servicesClassName = NameGenerator.GetServicesClassName(); CodeTypeDeclaration servicesTypeDecl = new CodeTypeDeclaration(servicesClassName) { Attributes = MemberAttributes.Public }; CodeMemberField singletonField = CodeDomHelper.CreateMemberField("typeManagerSingleton", servicesClassName, MemberAttributes.Static, true); CodeMemberProperty singletonProperty = CodeDomHelper.CreateProperty("Instance", null, singletonField, MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public, false); MemberAttributes privateStatic = MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.Assembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Private; CodeTypeConstructor staticServicesConstructor = new CodeTypeConstructor(); CodeTypeReference returnType = CodeDomHelper.CreateDictionaryType("XName", "System.Type"); CodeTypeReference wrapperReturnType = CodeDomHelper.CreateDictionaryType("System.Type", "System.Type"); CodeMemberProperty typeDictProperty = null; if (typeDictionaryStatements.Count <= 0) { typeDictProperty = CodeDomHelper.CreateInterfaceImplProperty("GlobalTypeDictionary", "ILinqToXsdTypeManager", returnType); typeDictProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("XTypedServices"), "EmptyDictionary"))); } else { typeDictProperty = CodeDomHelper.CreateInterfaceImplProperty("GlobalTypeDictionary", "ILinqToXsdTypeManager", returnType, "typeDictionary"); CodeMemberField staticTypeDictionary = CodeDomHelper.CreateDictionaryField("typeDictionary", "XName", "System.Type"); CodeMemberMethod buildTypeDictionary = CodeDomHelper.CreateMethod("BuildTypeDictionary", privateStatic, null); buildTypeDictionary.Statements.AddRange(typeDictionaryStatements); staticServicesConstructor.Statements.Add(CodeDomHelper.CreateMethodCall(null, "BuildTypeDictionary", new CodeExpression[0])); servicesTypeDecl.Members.Add(staticTypeDictionary); servicesTypeDecl.Members.Add(buildTypeDictionary); } CodeMemberProperty elementDictProperty = null; if (elementDictionaryStatements.Count <= 0) { elementDictProperty = CodeDomHelper.CreateInterfaceImplProperty("GlobalElementDictionary", "ILinqToXsdTypeManager", returnType); elementDictProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("XTypedServices"), "EmptyDictionary"))); } else { elementDictProperty = CodeDomHelper.CreateInterfaceImplProperty("GlobalElementDictionary", "ILinqToXsdTypeManager", returnType, "elementDictionary"); CodeMemberField staticElementDictionary = CodeDomHelper.CreateDictionaryField("elementDictionary", "XName", "System.Type"); CodeMemberMethod buildElementDictionary = CodeDomHelper.CreateMethod("BuildElementDictionary", privateStatic, null); buildElementDictionary.Statements.AddRange(elementDictionaryStatements); staticServicesConstructor.Statements.Add(CodeDomHelper.CreateMethodCall(null, "BuildElementDictionary", new CodeExpression[0])); servicesTypeDecl.Members.Add(staticElementDictionary); servicesTypeDecl.Members.Add(buildElementDictionary); } CodeMemberProperty wrapperDictProperty = null; if (wrapperDictionaryStatements.Count <= 0) { wrapperDictProperty = CodeDomHelper.CreateInterfaceImplProperty("RootContentTypeMapping", "ILinqToXsdTypeManager", wrapperReturnType); wrapperDictProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("XTypedServices"), "EmptyTypeMappingDictionary"))); } else { wrapperDictProperty = CodeDomHelper.CreateInterfaceImplProperty("RootContentTypeMapping", "ILinqToXsdTypeManager", wrapperReturnType, "wrapperDictionary"); CodeMemberField staticWrapperDictionary = CodeDomHelper.CreateDictionaryField("wrapperDictionary", "System.Type", "System.Type"); CodeMemberMethod buildWrapperDictionary = CodeDomHelper.CreateMethod("BuildWrapperDictionary", privateStatic, null); buildWrapperDictionary.Statements.AddRange(wrapperDictionaryStatements); staticServicesConstructor.Statements.Add(CodeDomHelper.CreateMethodCall(null, "BuildWrapperDictionary", new CodeExpression[0])); servicesTypeDecl.Members.Add(staticWrapperDictionary); servicesTypeDecl.Members.Add(buildWrapperDictionary); } string schemaSetFieldName = "schemaSet"; CodeTypeReference schemaSetType = new CodeTypeReference("XmlSchemaSet"); CodeMemberField schemaSetField = new CodeMemberField(schemaSetType, schemaSetFieldName) { Attributes = MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.Assembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Private }; CodeMemberMethod addSchemasMethod = CodeDomHelper.CreateMethod("AddSchemas", MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.FamilyOrAssembly, null); addSchemasMethod.Parameters.Add(new CodeParameterDeclarationExpression("XmlSchemaSet", "schemas")); CodeStatementCollection statements = addSchemasMethod.Statements; CodeVariableReferenceExpression codeVariableReferenceExpression = new CodeVariableReferenceExpression("schemas"); CodeExpression[] codeFieldReferenceExpression = new CodeExpression[] { new CodeFieldReferenceExpression(null, schemaSetFieldName) }; statements.Add(CodeDomHelper.CreateMethodCall(codeVariableReferenceExpression, "Add", codeFieldReferenceExpression)); CodeTypeReferenceExpression interLockedType = new CodeTypeReferenceExpression("System.Threading.Interlocked"); CodeMemberProperty schemaSetProperty = CodeDomHelper.CreateInterfaceImplProperty("Schemas", "ILinqToXsdTypeManager", schemaSetType); CodeFieldReferenceExpression schemaSetFieldRef = new CodeFieldReferenceExpression(null, schemaSetFieldName); CodeDirectionExpression schemaSetParam = new CodeDirectionExpression(FieldDirection.Ref, schemaSetFieldRef); CodeStatementCollection getStatements = schemaSetProperty.GetStatements; CodeBinaryOperatorExpression codeBinaryOperatorExpression = new CodeBinaryOperatorExpression(schemaSetFieldRef, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); CodeStatement[] codeVariableDeclarationStatement = new CodeStatement[] { new CodeVariableDeclarationStatement(schemaSetType, "tempSet", new CodeObjectCreateExpression(schemaSetType, new CodeExpression[0])), null }; codeFieldReferenceExpression = new CodeExpression[] { schemaSetParam, new CodeVariableReferenceExpression("tempSet"), new CodePrimitiveExpression(null) }; codeVariableDeclarationStatement[1] = new CodeExpressionStatement(CodeDomHelper.CreateMethodCall(interLockedType, "CompareExchange", codeFieldReferenceExpression)); getStatements.Add(new CodeConditionStatement(codeBinaryOperatorExpression, codeVariableDeclarationStatement)); schemaSetProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(schemaSetFieldName))); schemaSetProperty.SetStatements.Add(new CodeAssignStatement(schemaSetFieldRef, new CodePropertySetValueReferenceExpression())); servicesTypeDecl.Members.Add(schemaSetField); servicesTypeDecl.Members.Add(schemaSetProperty); servicesTypeDecl.Members.Add(addSchemasMethod); servicesTypeDecl.Members.Add(typeDictProperty); servicesTypeDecl.Members.Add(elementDictProperty); servicesTypeDecl.Members.Add(wrapperDictProperty); servicesTypeDecl.BaseTypes.Add("ILinqToXsdTypeManager"); CodeMemberMethod getRootType = new CodeMemberMethod() { Attributes = MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public, Name = "GetRootType", ReturnType = new CodeTypeReference("System.Type") }; if (!rootElementName.IsEmpty) { CodeStatementCollection codeStatementCollection = getRootType.Statements; CodeFieldReferenceExpression codeFieldReferenceExpression1 = CodeDomHelper.CreateFieldReference(null, "elementDictionary"); codeFieldReferenceExpression = new CodeExpression[] { CodeDomHelper.XNameGetExpression(rootElementName.Name, rootElementName.Namespace) }; codeStatementCollection.Add(new CodeMethodReturnStatement(new CodeIndexerExpression(codeFieldReferenceExpression1, codeFieldReferenceExpression))); } else { getRootType.Statements.Add(new CodeMethodReturnStatement(CodeDomHelper.Typeof("Xml.Schema.Linq.XTypedElement"))); } servicesTypeDecl.Members.Add(staticServicesConstructor); servicesTypeDecl.Members.Add(getRootType); servicesTypeDecl.Members.Add(singletonField); servicesTypeDecl.Members.Add(singletonProperty); return(servicesTypeDecl); }
protected CodeExpression GetSimpleTypeClassExpression() { Debug.Assert(this.simpleTypeClrTypeName != null); return(CodeDomHelper.CreateFieldReference(this.simpleTypeClrTypeName, "TypeDefinition")); }
public static CodeMethodInvokeExpression CreateMethodCallFromField(string fieldName, string methodName, params CodeExpression[] parameters) { CodeMethodInvokeExpression codeMethodInvokeExpression = new CodeMethodInvokeExpression(CodeDomHelper.CreateFieldReference(null, fieldName), methodName, parameters); return(codeMethodInvokeExpression); }
private CodeStatement CreateDefaultValueAssignStmt(object value) { CodeStatement codeAssignStatement = new CodeAssignStatement(CodeDomHelper.CreateFieldReference(null, this.propertyName), CodeDomHelper.CreateFieldReference(null, NameGenerator.ChangeClrName(this.propertyName, NameOptions.MakeDefaultValueField))); return(codeAssignStatement); }
public static CodeTypeMember AddBrowseNever(CodeTypeMember member) { CodeAttributeArgument[] codeAttributeArgument = new CodeAttributeArgument[] { new CodeAttributeArgument(CodeDomHelper.CreateFieldReference("DebuggerBrowsableState", "Never")) }; CodeAttributeDeclaration browsableNever = new CodeAttributeDeclaration("DebuggerBrowsable", codeAttributeArgument); if (member.CustomAttributes == null) { member.CustomAttributes = new CodeAttributeDeclarationCollection(); } member.CustomAttributes.Add(browsableNever); return(member); }
private CodeMethodInvokeExpression SetNameMethodCall() { CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XTypedServices"); CodeExpression[] codeExpressionArray = new CodeExpression[] { CodeDomHelper.This(), CodeDomHelper.CreateFieldReference("this", this.memberName) }; return(new CodeMethodInvokeExpression(codeTypeReferenceExpression, "SetName", codeExpressionArray)); }