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)); }
internal static CodeExpression CreateGetBuiltInSimpleType(XmlTypeCode typeCode) { return(CodeDomHelper.CreateMethodCall( new CodeTypeReferenceExpression("XmlSchemaType"), Constants.GetBuiltInSimpleType, CodeDomHelper.CreateFieldReference(Constants.XmlTypeCode, typeCode.ToString()))); }
internal static CodeExpression CreateXNameExpr(XName name) { CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XName"); CodeExpression[] codePrimitiveExpression = new CodeExpression[] { new CodePrimitiveExpression(name.LocalName), new CodePrimitiveExpression(name.Namespace.NamespaceName) }; return(CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "Get", codePrimitiveExpression)); }
private static CodeExpression CreateTypeConversionExpr(string typeName, object value) { return(CodeDomHelper.CreateMethodCall( new CodeTypeReferenceExpression(typeof(XmlConvert)), "To" + typeName, new CodePrimitiveExpression(value.ToString()))); }
protected override void ImplementFSMMetaData() { Debug.Assert(this.clrTypeInfo.HasElementWildCard); if (this.fsmNameSource != null) { this.fsmNameSource.Reset(); } else { this.fsmNameSource = new StateNameSource(); } FSM fsm = this.clrTypeInfo.CreateFSM(this.fsmNameSource); this.decl.Members.Add(CodeDomHelper.CreateMemberField("validationStates", "FSM", MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.Assembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Private, false)); CodeMemberMethod getFSM = CodeDomHelper.CreateInterfaceImplMethod("GetValidationStates", "IXMetaData", new CodeTypeReference("FSM")); getFSM.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, "validationStates"))); this.decl.Members.Add(getFSM); CodeMemberMethod initFSM = CodeDomHelper.CreateMethod("InitFSM", MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.Assembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Private, new CodeTypeReference()); FSMCodeDomHelper.CreateFSMStmt(fsm, initFSM.Statements); this.decl.Members.Add(initFSM); this.CreateStaticConstructor(); this.declItemsInfo.staticConstructor.Statements.Add(CodeDomHelper.CreateMethodCall(null, "InitFSM", null)); }
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))); }
private static CodeExpression CreateTypeConversionExpr(string typeName, object value) { CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression(typeof(XmlConvert)); string str = string.Concat("To", typeName); CodeExpression[] codePrimitiveExpression = new CodeExpression[] { new CodePrimitiveExpression(value.ToString()) }; return(CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, str, codePrimitiveExpression)); }
internal static CodeExpression CreateXNameExpr(XName name) { return(CodeDomHelper.CreateMethodCall(new CodeTypeReferenceExpression(Constants.XNameType), "Get", new CodeExpression[] { new CodePrimitiveExpression(name.LocalName), new CodePrimitiveExpression(name.Namespace.NamespaceName) })); }
internal void CreateServicesMembers() { CodeMethodInvokeExpression callClone; CodeExpression[] codeCastExpression; string innerType = this.InnerType; string clrTypeName = this.clrTypeInfo.clrtypeName; bool useAutoTyping = (this.clrTypeInfo.IsAbstract ? true : this.clrTypeInfo.IsSubstitutionHead); if (this.clrTypeInfo.typeOrigin == SchemaOrigin.Element) { CodeTypeMember load = CodeDomHelper.CreateStaticMethod("Load", clrTypeName, innerType, "xmlFile", "System.String", useAutoTyping); CodeTypeMember loadReader = CodeDomHelper.CreateStaticMethod("Load", clrTypeName, innerType, "xmlFile", "System.IO.TextReader", useAutoTyping); CodeTypeMember parse = CodeDomHelper.CreateStaticMethod("Parse", clrTypeName, innerType, "xml", "System.String", useAutoTyping); if (!this.clrTypeInfo.IsDerived) { this.decl.Members.Add(CodeDomHelper.CreateSave("xmlFile", "System.String")); this.decl.Members.Add(CodeDomHelper.CreateSave("tw", "System.IO.TextWriter")); this.decl.Members.Add(CodeDomHelper.CreateSave("xmlWriter", "System.Xml.XmlWriter")); } else { CodeTypeMember attributes = load; attributes.Attributes = attributes.Attributes | MemberAttributes.New; CodeTypeMember codeTypeMember = parse; codeTypeMember.Attributes = codeTypeMember.Attributes | MemberAttributes.New; } this.decl.Members.Add(load); this.decl.Members.Add(loadReader); this.decl.Members.Add(parse); } CodeTypeMember cast = CodeDomHelper.CreateCast(clrTypeName, innerType, useAutoTyping); this.decl.Members.Add(cast); if (!this.clrTypeInfo.IsAbstract) { CodeMemberMethod clone = CodeDomHelper.CreateMethod("Clone", MemberAttributes.Override | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public, new CodeTypeReference("XTypedElement")); if (innerType != null) { callClone = CodeDomHelper.CreateMethodCall(new CodePropertyReferenceExpression(CodeDomHelper.This(), "Content"), "Clone", new CodeExpression[0]); CodeStatementCollection statements = clone.Statements; codeCastExpression = new CodeExpression[] { new CodeCastExpression(new CodeTypeReference(innerType), callClone) }; statements.Add(new CodeMethodReturnStatement(new CodeObjectCreateExpression(clrTypeName, codeCastExpression))); } else { CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XTypedServices"); string str = string.Concat("CloneXTypedElement<", clrTypeName, ">"); codeCastExpression = new CodeExpression[] { new CodeThisReferenceExpression() }; callClone = CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, str, codeCastExpression); clone.Statements.Add(new CodeMethodReturnStatement(callClone)); } this.decl.Members.Add(clone); } }
protected override void ImplementCommonIXMetaData() { CodeMemberProperty localElementDictionary = null; if (this.HasElementProperties) { this.CreateStaticConstructor(); localElementDictionary = this.BuildLocalElementDictionary(); this.declItemsInfo.staticConstructor.Statements.Add(CodeDomHelper.CreateMethodCall(null, "BuildElementDictionary", new CodeExpression[0])); this.decl.Members.Add(localElementDictionary); } }
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); }
protected void AddFixedValueChecking(CodeStatementCollection setStatements) { if (this.FixedValue != null) { CodeExpression fixedValueExpr = new CodeFieldReferenceExpression(null, NameGenerator.ChangeClrName(this.propertyName, NameOptions.MakeFixedValueField)); CodePropertySetValueReferenceExpression codePropertySetValueReferenceExpression = new CodePropertySetValueReferenceExpression(); CodeExpression[] codeExpressionArray = new CodeExpression[] { fixedValueExpr }; CodeMethodInvokeExpression codeMethodInvokeExpression = CodeDomHelper.CreateMethodCall(codePropertySetValueReferenceExpression, "Equals", codeExpressionArray); CodeStatement[] codeStatementArray = new CodeStatement[0]; CodeStatement[] codeThrowExceptionStatement = new CodeStatement[1]; Type type = typeof(LinqToXsdFixedValueException); codeExpressionArray = new CodeExpression[] { new CodePropertySetValueReferenceExpression(), fixedValueExpr }; codeThrowExceptionStatement[0] = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(type, codeExpressionArray)); setStatements.Add(new CodeConditionStatement(codeMethodInvokeExpression, codeStatementArray, codeThrowExceptionStatement)); } }
public static CodeTypeMember CreateSave(string paramName, string paramType) { CodeMemberMethod saveMethod = new CodeMemberMethod() { Name = "Save", Attributes = (MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.Override | MemberAttributes.Const | MemberAttributes.New | MemberAttributes.Overloaded | MemberAttributes.ScopeMask | MemberAttributes.VTableMask) | MemberAttributes.Public }; saveMethod.Parameters.Add(CodeDomHelper.CreateParameter(paramName, paramType)); CodeStatementCollection statements = saveMethod.Statements; CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XTypedServices"); CodeExpression[] codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression(paramName), new CodePropertyReferenceExpression(null, "Untyped") }; statements.Add(CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "Save", codeVariableReferenceExpression)); return(saveMethod); }
internal override CodeConstructor CreateFunctionalConstructor(List <ClrAnnotation> annotations) { CodeConstructor constructor = CodeDomHelper.CreateConstructor(MemberAttributes.Public); if (this.clrTypeInfo.IsSubstitutionMember()) { constructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(true)); } constructor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(this.innerTypeName), "content")); CodeStatementCollection statements = constructor.Statements; CodeExpression[] codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression("content") }; statements.Add(CodeDomHelper.CreateMethodCall(null, "SetInnerType", codeVariableReferenceExpression)); TypeBuilder.ApplyAnnotations(constructor, annotations, null); this.decl.Members.Add(constructor); return(constructor); }
internal static void CreateAddTransitionStmts(FSM fsm, CodeStatementCollection stmts, int state, Transitions currTrans, Set <int> visited) { Set <int> subStates = new Set <int>(); CodeExpression[] initializers = new CodeExpression[currTrans.Count]; int index = 0; if (currTrans.nameTransitions != null) { foreach (KeyValuePair <XName, int> s1Trans in currTrans.nameTransitions) { initializers[index++] = CreateSingleTransitionExpr(CreateXNameExpr(s1Trans.Key), s1Trans.Value); subStates.Add(s1Trans.Value); } } if (currTrans.wildCardTransitions != null) { foreach (KeyValuePair <WildCard, int> s1Trans in currTrans.wildCardTransitions) { initializers[index++] = CreateSingleTransitionExpr(CreateWildCardExpr(s1Trans.Key), s1Trans.Value); subStates.Add(s1Trans.Value); } } stmts.Add(CodeDomHelper.CreateMethodCall(new CodeVariableReferenceExpression(Constants.TransitionsVar), "Add", new CodeExpression[] { new CodePrimitiveExpression(state), new CodeObjectCreateExpression("Transitions", initializers) })); //Recursively call AddTransitions on subsequent states foreach (int s in subStates) { AddTransitions(fsm, s, stmts, visited); } }
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()); } }
public static CodeMemberMethod CreateXRootSave(string[][] paramList) { CodeMemberMethod staticMethod = new CodeMemberMethod() { Name = "Save", Attributes = MemberAttributes.Public }; CodeExpression[] parameterExp = new CodeExpression[(int)paramList.Length]; for (int i = 0; i < (int)paramList.Length; i++) { string[] paramRef = paramList[i]; staticMethod.Parameters.Add(CodeDomHelper.CreateParameter(paramRef[1], paramRef[0])); parameterExp[i] = new CodeVariableReferenceExpression(paramRef[1]); } CodeExpression doc = new CodeVariableReferenceExpression("doc"); staticMethod.Statements.Add(CodeDomHelper.CreateMethodCall(doc, "Save", parameterExp)); return(staticMethod); }
public static CodeTypeMember CreateStaticMethod(string methodName, string typeT, string typeT1, string parameterName, string parameterType, bool useAutoTyping) { CodeExpression[] codeExpressionArray; CodeMemberMethod staticMethod = new CodeMemberMethod() { Name = methodName, Attributes = MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public, ReturnType = new CodeTypeReference(typeT) }; staticMethod.Parameters.Add(CodeDomHelper.CreateParameter(parameterName, parameterType)); CodeExpression parameterExp = new CodeVariableReferenceExpression(parameterName); if (!useAutoTyping) { CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XTypedServices"); string str = string.Concat(methodName, "<", CodeDomHelper.GetInnerType(typeT, typeT1), ">"); codeExpressionArray = new CodeExpression[] { parameterExp }; CodeMethodInvokeExpression methodCall = CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, str, codeExpressionArray); if (typeT1 != null) { methodCall.Parameters.Add(CodeDomHelper.SingletonTypeManager()); } staticMethod.Statements.Add(new CodeMethodReturnStatement(methodCall)); } else { CodeStatementCollection statements = staticMethod.Statements; CodeTypeReference returnType = staticMethod.ReturnType; CodeTypeReferenceExpression codeTypeReferenceExpression1 = new CodeTypeReferenceExpression("XTypedServices"); codeExpressionArray = new CodeExpression[2]; CodeTypeReferenceExpression codeTypeReferenceExpression2 = new CodeTypeReferenceExpression("XElement"); CodeExpression[] codeExpressionArray1 = new CodeExpression[] { parameterExp }; codeExpressionArray[0] = CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression2, methodName, codeExpressionArray1); codeExpressionArray[1] = CodeDomHelper.SingletonTypeManager(); statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(returnType, CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression1, "ToXTypedElement", codeExpressionArray)))); } return(staticMethod); }
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); }
private void ImplementIXmlSerializable() { string interfaceName = "IXmlSerializable"; string typeManagerName = NameGenerator.GetServicesClassName(); string methodName = string.Concat(this.clrTypeInfo.clrtypeName, "SchemaProvider"); CodeMemberMethod schemaProviderMethod = CodeDomHelper.CreateMethod(methodName, MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public, null); schemaProviderMethod.Parameters.Add(new CodeParameterDeclarationExpression("XmlSchemaSet", "schemas")); CodeStatementCollection statements = schemaProviderMethod.Statements; CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression(typeManagerName); CodeExpression[] codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression("schemas") }; statements.Add(CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "AddSchemas", codeVariableReferenceExpression)); codeVariableReferenceExpression = new CodeExpression[] { new CodePrimitiveExpression(this.clrTypeInfo.schemaName), new CodePrimitiveExpression(this.clrTypeInfo.schemaNs) }; CodeExpression qNameExp = new CodeObjectCreateExpression("XmlQualifiedName", codeVariableReferenceExpression); if (this.clrTypeInfo.typeOrigin != SchemaOrigin.Element) { schemaProviderMethod.ReturnType = new CodeTypeReference("XmlQualifiedName"); schemaProviderMethod.Statements.Add(new CodeMethodReturnStatement(qNameExp)); } else { CodeStatementCollection codeStatementCollection = schemaProviderMethod.Statements; CodePropertyReferenceExpression codePropertyReferenceExpression = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("schemas"), "GlobalElements"); codeVariableReferenceExpression = new CodeExpression[] { qNameExp }; codeStatementCollection.Add(new CodeVariableDeclarationStatement("XmlSchemaElement", "element", new CodeCastExpression("XmlSchemaElement", new CodeIndexerExpression(codePropertyReferenceExpression, codeVariableReferenceExpression)))); CodeStatementCollection statements1 = schemaProviderMethod.Statements; CodeBinaryOperatorExpression codeBinaryOperatorExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("element"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); CodeStatement[] codeMethodReturnStatement = new CodeStatement[] { new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("element"), "ElementSchemaType")) }; statements1.Add(new CodeConditionStatement(codeBinaryOperatorExpression, codeMethodReturnStatement)); schemaProviderMethod.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); schemaProviderMethod.ReturnType = new CodeTypeReference("XmlSchemaType"); } this.decl.CustomAttributes.Add(CodeDomHelper.SchemaProviderAttribute(this.clrTypeInfo.clrtypeName)); this.decl.BaseTypes.Add(interfaceName); this.decl.Members.Add(schemaProviderMethod); }
public static CodeMemberMethod CreateXRootMethod(string returnType, string methodName, string[][] paramList) { CodeTypeReference xRootType = new CodeTypeReference(returnType); CodeMemberMethod staticMethod = new CodeMemberMethod() { Name = methodName, Attributes = MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public, ReturnType = xRootType }; CodeExpression[] parameterExp = new CodeExpression[(int)paramList.Length]; for (int i = 0; i < (int)paramList.Length; i++) { string[] paramRef = paramList[i]; staticMethod.Parameters.Add(CodeDomHelper.CreateParameter(paramRef[1], paramRef[0])); parameterExp[i] = new CodeVariableReferenceExpression(paramRef[1]); } CodeExpression rootExp = new CodeVariableReferenceExpression("root"); CodeExpression doc = new CodeFieldReferenceExpression(rootExp, "doc"); staticMethod.Statements.Add(new CodeVariableDeclarationStatement(xRootType, "root", new CodeObjectCreateExpression(xRootType, new CodeExpression[0]))); staticMethod.Statements.Add(new CodeAssignStatement(doc, CodeDomHelper.CreateMethodCall(new CodeTypeReferenceExpression("XDocument"), methodName, parameterExp))); CodeStatementCollection statements = staticMethod.Statements; CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XTypedServices"); CodeExpression[] codePropertyReferenceExpression = new CodeExpression[] { new CodePropertyReferenceExpression(doc, "Root"), CodeDomHelper.SingletonTypeManager() }; statements.Add(new CodeVariableDeclarationStatement("XTypedElement", "typedRoot", CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "ToXTypedElement", codePropertyReferenceExpression))); CodeStatementCollection codeStatementCollection = staticMethod.Statements; CodeBinaryOperatorExpression codeBinaryOperatorExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("typedRoot"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); CodeStatement[] codeThrowExceptionStatement = new CodeStatement[1]; codePropertyReferenceExpression = new CodeExpression[] { new CodePrimitiveExpression("Invalid root element in xml document.") }; codeThrowExceptionStatement[0] = new CodeThrowExceptionStatement(new CodeObjectCreateExpression("LinqToXsdException", codePropertyReferenceExpression)); codeStatementCollection.Add(new CodeConditionStatement(codeBinaryOperatorExpression, codeThrowExceptionStatement)); staticMethod.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(rootExp, "rootObject"), new CodeVariableReferenceExpression("typedRoot"))); staticMethod.Statements.Add(new CodeMethodReturnStatement(rootExp)); return(staticMethod); }
internal static void CreateAddTransitionStmts(FSM fsm, CodeStatementCollection stmts, int state, Transitions currTrans, Set <int> visited) { Set <int> subStates = new Set <int>(); CodeExpression[] initializers = new CodeExpression[currTrans.Count]; int index = 0; if (currTrans.nameTransitions != null) { foreach (KeyValuePair <XName, int> s1Trans in currTrans.nameTransitions) { int num = index; index = num + 1; initializers[num] = FSMCodeDomHelper.CreateSingleTransitionExpr(FSMCodeDomHelper.CreateXNameExpr(s1Trans.Key), s1Trans.Value); subStates.Add(s1Trans.Value); } } if (currTrans.wildCardTransitions != null) { foreach (KeyValuePair <WildCard, int> s1Trans in currTrans.wildCardTransitions) { int num1 = index; index = num1 + 1; initializers[num1] = FSMCodeDomHelper.CreateSingleTransitionExpr(FSMCodeDomHelper.CreateWildCardExpr(s1Trans.Key), s1Trans.Value); subStates.Add(s1Trans.Value); } } CodeVariableReferenceExpression codeVariableReferenceExpression = new CodeVariableReferenceExpression("transitions"); CodeExpression[] codePrimitiveExpression = new CodeExpression[] { new CodePrimitiveExpression((object)state), new CodeObjectCreateExpression("Transitions", initializers) }; stmts.Add(CodeDomHelper.CreateMethodCall(codeVariableReferenceExpression, "Add", codePrimitiveExpression)); foreach (int s in subStates) { FSMCodeDomHelper.AddTransitions(fsm, s, stmts, visited); } }
private static CodeExpression CreateTypedValueExpression(XmlSchemaDatatype dataType, object value) { XmlTypeCode typeCode = dataType.TypeCode; switch (typeCode) { case XmlTypeCode.String: case XmlTypeCode.Notation: case XmlTypeCode.NormalizedString: case XmlTypeCode.Token: case XmlTypeCode.Language: case XmlTypeCode.Id: string str = value as string; Debug.Assert(str != null); return(new CodePrimitiveExpression(str)); case XmlTypeCode.AnyUri: Debug.Assert(value is Uri); return(new CodeObjectCreateExpression(typeof(Uri), new CodePrimitiveExpression(((Uri)value).OriginalString))); case XmlTypeCode.QName: XmlQualifiedName qname = value as XmlQualifiedName; return(new CodeObjectCreateExpression(typeof(XmlQualifiedName), new CodePrimitiveExpression(qname.Name), new CodePrimitiveExpression(qname.Namespace))); case XmlTypeCode.NmToken: case XmlTypeCode.Name: case XmlTypeCode.NCName: return(CodeDomHelper.CreateMethodCall( new CodeTypeReferenceExpression(typeof(XmlConvert)), "EncodeName", new CodePrimitiveExpression(value.ToString()))); case XmlTypeCode.Boolean: Debug.Assert(value is bool); return(new CodePrimitiveExpression(value)); case XmlTypeCode.Float: case XmlTypeCode.Double: Debug.Assert(value is double || value is float); return(new CodePrimitiveExpression(value)); case XmlTypeCode.Duration: Debug.Assert(value is TimeSpan); TimeSpan ts = (TimeSpan)value; return(new CodeObjectCreateExpression(typeof(TimeSpan), new CodePrimitiveExpression(ts.Ticks))); case XmlTypeCode.Time: case XmlTypeCode.Date: case XmlTypeCode.GYearMonth: case XmlTypeCode.GYear: case XmlTypeCode.GMonthDay: case XmlTypeCode.GDay: case XmlTypeCode.GMonth: case XmlTypeCode.DateTime: Debug.Assert(value is DateTime); DateTime dt = (DateTime)value; return(new CodeObjectCreateExpression(typeof(DateTime), new CodePrimitiveExpression(dt.Ticks))); case XmlTypeCode.Integer: case XmlTypeCode.NonPositiveInteger: case XmlTypeCode.NegativeInteger: case XmlTypeCode.Long: case XmlTypeCode.Int: case XmlTypeCode.Short: case XmlTypeCode.NonNegativeInteger: case XmlTypeCode.UnsignedLong: case XmlTypeCode.UnsignedInt: case XmlTypeCode.UnsignedShort: case XmlTypeCode.PositiveInteger: case XmlTypeCode.Decimal: case XmlTypeCode.Byte: case XmlTypeCode.UnsignedByte: return(new CodePrimitiveExpression(value)); case XmlTypeCode.HexBinary: case XmlTypeCode.Base64Binary: return(CreateByteArrayExpression(value)); case XmlTypeCode.None: case XmlTypeCode.Item: case XmlTypeCode.AnyAtomicType: case XmlTypeCode.Idref: case XmlTypeCode.Entity: throw new InvalidOperationException(); default: throw new InvalidOperationException(); } }
private CodeMethodInvokeExpression SetValueMethodCall() { CodeExpression[] codeExpressionArray; CodeMethodInvokeExpression methodCall = null; string setMethodName = "Set"; bool isUnion = (!this.IsUnion ? false : this.propertyOrigin != SchemaOrigin.Element); if (!(this.IsRef ? true : !this.IsSchemaList)) { setMethodName = string.Concat(setMethodName, "List"); } else if (isUnion) { setMethodName = string.Concat(setMethodName, "Union"); } bool validation = this.Validation; bool xNameParm = true; switch (this.propertyOrigin) { case SchemaOrigin.None: case SchemaOrigin.Fragment: { throw new InvalidOperationException(); } case SchemaOrigin.Element: { setMethodName = string.Concat(setMethodName, "Element"); break; } case SchemaOrigin.Attribute: { validation = false; setMethodName = string.Concat(setMethodName, "Attribute"); break; } case SchemaOrigin.Text: { setMethodName = string.Concat(setMethodName, "Value"); xNameParm = false; break; } default: { throw new InvalidOperationException(); } } if (isUnion) { if (!xNameParm) { CodeThisReferenceExpression codeThisReferenceExpression = CodeDomHelper.This(); codeExpressionArray = new CodeExpression[] { CodeDomHelper.SetValue(), new CodePrimitiveExpression(this.propertyName), CodeDomHelper.This(), this.GetSimpleTypeClassExpression() }; methodCall = CodeDomHelper.CreateMethodCall(codeThisReferenceExpression, setMethodName, codeExpressionArray); } else { CodeThisReferenceExpression codeThisReferenceExpression1 = CodeDomHelper.This(); codeExpressionArray = new CodeExpression[] { CodeDomHelper.SetValue(), new CodePrimitiveExpression(this.propertyName), CodeDomHelper.This(), this.xNameGetExpression, this.GetSimpleTypeClassExpression() }; methodCall = CodeDomHelper.CreateMethodCall(codeThisReferenceExpression1, setMethodName, codeExpressionArray); } } else if (validation) { setMethodName = string.Concat(setMethodName, "WithValidation"); if (!xNameParm) { CodeThisReferenceExpression codeThisReferenceExpression2 = CodeDomHelper.This(); codeExpressionArray = new CodeExpression[] { CodeDomHelper.SetValue(), new CodePrimitiveExpression(base.PropertyName), this.GetSimpleTypeClassExpression() }; methodCall = CodeDomHelper.CreateMethodCall(codeThisReferenceExpression2, setMethodName, codeExpressionArray); } else { CodeThisReferenceExpression codeThisReferenceExpression3 = CodeDomHelper.This(); codeExpressionArray = new CodeExpression[] { this.xNameGetExpression, CodeDomHelper.SetValue(), new CodePrimitiveExpression(base.PropertyName), this.GetSimpleTypeClassExpression() }; methodCall = CodeDomHelper.CreateMethodCall(codeThisReferenceExpression3, setMethodName, codeExpressionArray); } } else if (!xNameParm) { CodeThisReferenceExpression codeThisReferenceExpression4 = CodeDomHelper.This(); codeExpressionArray = new CodeExpression[] { CodeDomHelper.SetValue(), this.GetSchemaDatatypeExpression() }; methodCall = CodeDomHelper.CreateMethodCall(codeThisReferenceExpression4, setMethodName, codeExpressionArray); } else { CodeThisReferenceExpression codeThisReferenceExpression5 = CodeDomHelper.This(); codeExpressionArray = new CodeExpression[] { this.xNameGetExpression, CodeDomHelper.SetValue() }; methodCall = CodeDomHelper.CreateMethodCall(codeThisReferenceExpression5, setMethodName, codeExpressionArray); if ((this.IsRef ? false : this.typeRef.IsSimpleType)) { methodCall.Parameters.Add(this.GetSchemaDatatypeExpression()); } } return(methodCall); }
private CodeVariableDeclarationStatement GetValueMethodCall() { CodeVariableDeclarationStatement codeVariableDeclarationStatement; CodeExpression[] codeExpressionArray; switch (this.propertyOrigin) { case SchemaOrigin.None: case SchemaOrigin.Fragment: { throw new InvalidOperationException(); } case SchemaOrigin.Element: { CodeThisReferenceExpression codeThisReferenceExpression = CodeDomHelper.This(); codeExpressionArray = new CodeExpression[] { this.xNameGetExpression }; codeVariableDeclarationStatement = new CodeVariableDeclarationStatement("XElement", "x", CodeDomHelper.CreateMethodCall(codeThisReferenceExpression, "GetElement", codeExpressionArray)); break; } case SchemaOrigin.Attribute: { CodeThisReferenceExpression codeThisReferenceExpression1 = CodeDomHelper.This(); codeExpressionArray = new CodeExpression[] { this.xNameGetExpression }; codeVariableDeclarationStatement = new CodeVariableDeclarationStatement("XAttribute", "x", CodeDomHelper.CreateMethodCall(codeThisReferenceExpression1, "Attribute", codeExpressionArray)); break; } case SchemaOrigin.Text: { codeVariableDeclarationStatement = new CodeVariableDeclarationStatement("XElement", "x", new CodePropertyReferenceExpression(CodeDomHelper.This(), "Untyped")); break; } default: { throw new InvalidOperationException(); } } return(codeVariableDeclarationStatement); }
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); }
private void AddSubstGetStatements(CodeStatementCollection getStatements) { Debug.Assert(this.propertyOrigin == SchemaOrigin.Element); CodeExpression[] substParams = new CodeExpression[this.substitutionMembers.Count + 2]; substParams[0] = CodeDomHelper.This(); substParams[1] = CodeDomHelper.SingletonTypeManager(); int i = 2; foreach (XmlSchemaElement elem in this.substitutionMembers) { int num = i; i = num + 1; substParams[num] = CodeDomHelper.XNameGetExpression(elem.QualifiedName.Name, elem.QualifiedName.Namespace); } getStatements.Add(new CodeVariableDeclarationStatement("XTypedElement", "x", CodeDomHelper.CreateMethodCall(new CodeTypeReferenceExpression("XTypedServices"), "ToSubstitutedXTypedElement", substParams))); this.CheckOccurrence(getStatements); getStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(this.ReturnType, new CodeVariableReferenceExpression("x")))); }
private void AddGetStatements(CodeStatementCollection getStatements) { CodeExpression[] simpleTypeClassExpression; if (!this.IsSubstitutionHead) { CodeExpression returnExp = null; if (this.FixedValue == null) { getStatements.Add(this.GetValueMethodCall()); this.CheckOccurrence(getStatements); CodeVariableReferenceExpression returnValueExp = new CodeVariableReferenceExpression("x"); if ((this.IsRef ? true : !this.typeRef.IsSimpleType)) { returnExp = new CodeCastExpression(this.ReturnType, returnValueExp); } else { CodeTypeReference parseType = this.ReturnType; if ((!this.typeRef.IsValueType ? false : this.IsNullable)) { parseType = new CodeTypeReference(this.clrTypeName); } if (!this.IsUnion) { string parseMethodName = null; CodeExpression simpleTypeExpression = this.GetSchemaDatatypeExpression(); if (!this.IsSchemaList) { parseMethodName = "ParseValue"; } else { parseMethodName = "ParseListValue"; parseType = new CodeTypeReference(this.clrTypeName); } CodeTypeReferenceExpression codeTypeReferenceExpression = CodeDomHelper.CreateTypeReferenceExp("XTypedServices"); simpleTypeClassExpression = new CodeExpression[] { returnValueExp, simpleTypeExpression }; returnExp = CodeDomHelper.CreateGenericMethodCall(codeTypeReferenceExpression, parseMethodName, parseType, simpleTypeClassExpression); if (this.DefaultValue != null) { ((CodeMethodInvokeExpression)returnExp).Parameters.Add(new CodeFieldReferenceExpression(null, NameGenerator.ChangeClrName(this.propertyName, NameOptions.MakeDefaultValueField))); } } else { CodeTypeReferenceExpression codeTypeReferenceExpression1 = CodeDomHelper.CreateTypeReferenceExp("XTypedServices"); simpleTypeClassExpression = new CodeExpression[] { returnValueExp, this.GetSimpleTypeClassExpression() }; returnExp = CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression1, "ParseUnionValue", simpleTypeClassExpression); } } getStatements.Add(new CodeMethodReturnStatement(returnExp)); } else { getStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, NameGenerator.ChangeClrName(this.propertyName, NameOptions.MakeFixedValueField)))); } } else { this.AddSubstGetStatements(getStatements); } }
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); }
private static CodeExpression CreateTypedValueExpression(XmlSchemaDatatype dataType, object value) { CodeExpression codePrimitiveExpression; CodeExpression[] codeExpressionArray; switch (dataType.TypeCode) { case XmlTypeCode.None: case XmlTypeCode.Item: case XmlTypeCode.AnyAtomicType: case XmlTypeCode.Idref: case XmlTypeCode.Entity: { throw new InvalidOperationException(); } case XmlTypeCode.Node: case XmlTypeCode.Document: case XmlTypeCode.Element: case XmlTypeCode.Attribute: case XmlTypeCode.Namespace: case XmlTypeCode.ProcessingInstruction: case XmlTypeCode.Comment: case XmlTypeCode.Text: case XmlTypeCode.UntypedAtomic: { throw new InvalidOperationException(); } case XmlTypeCode.String: case XmlTypeCode.Notation: case XmlTypeCode.NormalizedString: case XmlTypeCode.Token: case XmlTypeCode.Language: case XmlTypeCode.Id: { string str = value as string; Debug.Assert(str != null); codePrimitiveExpression = new CodePrimitiveExpression(str); break; } case XmlTypeCode.Boolean: { Debug.Assert(value is bool); codePrimitiveExpression = new CodePrimitiveExpression(value); break; } case XmlTypeCode.Decimal: case XmlTypeCode.Integer: case XmlTypeCode.NonPositiveInteger: case XmlTypeCode.NegativeInteger: case XmlTypeCode.Long: case XmlTypeCode.Int: case XmlTypeCode.Short: case XmlTypeCode.Byte: case XmlTypeCode.NonNegativeInteger: case XmlTypeCode.UnsignedLong: case XmlTypeCode.UnsignedInt: case XmlTypeCode.UnsignedShort: case XmlTypeCode.UnsignedByte: case XmlTypeCode.PositiveInteger: { codePrimitiveExpression = new CodePrimitiveExpression(value); break; } case XmlTypeCode.Float: case XmlTypeCode.Double: { Debug.Assert((value is double?true: value is float)); codePrimitiveExpression = new CodePrimitiveExpression(value); break; } case XmlTypeCode.Duration: { Debug.Assert(value is TimeSpan); TimeSpan ts = (TimeSpan)value; Type type = typeof(TimeSpan); codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression((object)ts.Ticks) }; codePrimitiveExpression = new CodeObjectCreateExpression(type, codeExpressionArray); break; } case XmlTypeCode.DateTime: case XmlTypeCode.Time: case XmlTypeCode.Date: case XmlTypeCode.GYearMonth: case XmlTypeCode.GYear: case XmlTypeCode.GMonthDay: case XmlTypeCode.GDay: case XmlTypeCode.GMonth: { Debug.Assert(value is DateTime); DateTime dt = (DateTime)value; Type type1 = typeof(DateTime); codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression((object)dt.Ticks) }; codePrimitiveExpression = new CodeObjectCreateExpression(type1, codeExpressionArray); break; } case XmlTypeCode.HexBinary: case XmlTypeCode.Base64Binary: { codePrimitiveExpression = SimpleTypeCodeDomHelper.CreateByteArrayExpression(value); break; } case XmlTypeCode.AnyUri: { Debug.Assert(value is Uri); Type type2 = typeof(Uri); codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression(((Uri)value).OriginalString) }; codePrimitiveExpression = new CodeObjectCreateExpression(type2, codeExpressionArray); break; } case XmlTypeCode.QName: { XmlQualifiedName qname = value as XmlQualifiedName; Type type3 = typeof(XmlQualifiedName); codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression(qname.Name), new CodePrimitiveExpression(qname.Namespace) }; codePrimitiveExpression = new CodeObjectCreateExpression(type3, codeExpressionArray); break; } case XmlTypeCode.NmToken: case XmlTypeCode.Name: case XmlTypeCode.NCName: { CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression(typeof(XmlConvert)); codeExpressionArray = new CodeExpression[] { new CodePrimitiveExpression(value.ToString()) }; codePrimitiveExpression = CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "EncodeName", codeExpressionArray); break; } default: { throw new InvalidOperationException(); } } return(codePrimitiveExpression); }