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