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));
}
public static CodeMemberMethod CreateInterfaceImplMethod(string methodName, string interfaceName, CodeTypeReference returnType)
{
CodeMemberMethod interfaceMethod = CodeDomHelper.CreateMethod(methodName, MemberAttributes.Public, returnType);
interfaceMethod.PrivateImplementationType = new CodeTypeReference(interfaceName);
interfaceMethod.ImplementationTypes.Add(new CodeTypeReference(interfaceName));
return(interfaceMethod);
}
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);
}
}
private CodeMemberProperty BuildLocalElementDictionary()
{
CodeMemberProperty localDictionaryProperty = CodeDomHelper.CreateInterfaceImplProperty("LocalElementsDictionary", "IXMetaData", CodeDomHelper.CreateDictionaryType("XName", "System.Type"));
CodeMemberField localDictionaryField = CodeDomHelper.CreateDictionaryField("localElementDictionary", "XName", "System.Type");
CodeMemberMethod localDictionaryMethod = CodeDomHelper.CreateMethod("BuildElementDictionary", MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.Assembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Private, null);
localDictionaryMethod.Statements.AddRange(this.propertyDictionaryAddStatements);
this.decl.Members.Add(localDictionaryField);
this.decl.Members.Add(localDictionaryMethod);
localDictionaryProperty.GetStatements.Add(new CodeMethodReturnStatement(CodeDomHelper.CreateFieldReference(null, "localElementDictionary")));
CodeDomHelper.AddBrowseNever(localDictionaryProperty);
CodeDomHelper.AddBrowseNever(localDictionaryField);
return(localDictionaryProperty);
}
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);
}
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);
}
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);
}
