public static CodeMemberProperty CreateInterfaceImplProperty(string propertyName, string interfaceName, CodeTypeReference returnType)
{
CodeMemberProperty interfaceProperty = CodeDomHelper.CreateProperty(propertyName, returnType, MemberAttributes.Public);
interfaceProperty.PrivateImplementationType = new CodeTypeReference(interfaceName);
interfaceProperty.ImplementationTypes.Add(new CodeTypeReference(interfaceName));
return(interfaceProperty);
}
internal override CodeMemberProperty AddToType(CodeTypeDeclaration parentTypeDecl, List <ClrAnnotation> annotations)
{
CodeMemberProperty codeMemberProperty;
bool flag;
if (this.IsDuplicate)
{
flag = false;
}
else
{
flag = (!this.FromBaseType ? true : this.IsNew);
}
if (flag)
{
this.CreateFixedDefaultValue(parentTypeDecl);
CodeMemberProperty clrProperty = CodeDomHelper.CreateProperty(this.ReturnType, this.hasSet);
clrProperty.Name = this.propertyName;
this.SetPropertyAttributes(clrProperty);
if (this.IsNew)
{
CodeMemberProperty attributes = clrProperty;
attributes.Attributes = attributes.Attributes | MemberAttributes.New;
}
if (!this.IsList)
{
this.AddGetStatements(clrProperty.GetStatements);
if (this.hasSet)
{
this.AddSetStatements(clrProperty.SetStatements);
}
}
else
{
CodeTypeReference listType = this.GetListType();
string listName = NameGenerator.ChangeClrName(this.propertyName, NameOptions.MakeField);
this.AddMemberField(listName, listType, parentTypeDecl);
this.AddListGetStatements(clrProperty.GetStatements, listType, listName);
if (this.hasSet)
{
this.AddListSetStatements(clrProperty.SetStatements, listType, listName);
}
}
this.ApplyAnnotations(clrProperty, annotations);
parentTypeDecl.Members.Add(clrProperty);
codeMemberProperty = clrProperty;
}
else
{
codeMemberProperty = null;
}
return(codeMemberProperty);
}
private CodeMemberProperty InnerTypeProperty()
{
CodeMemberProperty innerTypeProperty = CodeDomHelper.CreateProperty("Content", new CodeTypeReference(this.innerTypeName), MemberAttributes.Public);
innerTypeProperty.HasSet = false;
if (this.clrTypeInfo.IsSubstitutionMember())
{
CodeMemberProperty attributes = innerTypeProperty;
attributes.Attributes = attributes.Attributes | MemberAttributes.New;
}
innerTypeProperty.GetStatements.Add(new CodeMethodReturnStatement(CodeDomHelper.CreateFieldReference(null, this.memberName)));
return(innerTypeProperty);
}
internal override CodeMemberProperty AddToType(CodeTypeDeclaration typeDecl, List <ClrAnnotation> annotations)
{
CodeMemberProperty wrapperProperty = CodeDomHelper.CreateProperty(this.returnType, this.hasSet);
wrapperProperty.Name = this.CheckPropertyName(typeDecl.Name);
wrapperProperty.Attributes = this.wrappedPropertyAttributes;
this.AddGetStatements(wrapperProperty.GetStatements);
if (this.hasSet)
{
this.AddSetStatements(wrapperProperty.SetStatements);
}
this.ApplyAnnotations(wrapperProperty, annotations);
typeDecl.Members.Add(wrapperProperty);
return(wrapperProperty);
}
internal override CodeMemberProperty AddToType(CodeTypeDeclaration decl, List <ClrAnnotation> annotations)
{
CodeMemberProperty codeMemberProperty;
if (this.addToTypeDef)
{
CodeMemberProperty property = CodeDomHelper.CreateProperty(this.ReturnType, false);
property.Name = base.PropertyName;
property.Attributes = property.Attributes & (MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.Override | MemberAttributes.Const | MemberAttributes.New | MemberAttributes.Overloaded | MemberAttributes.ScopeMask | MemberAttributes.VTableMask) | MemberAttributes.Public;
this.AddGetStatements(property.GetStatements);
this.ApplyAnnotations(property, annotations);
decl.Members.Add(property);
codeMemberProperty = property;
}
else
{
codeMemberProperty = null;
}
return(codeMemberProperty);
}
private CodeMemberProperty CreateUntypedProperty(CodeFieldReferenceExpression fieldRef)
{
CodeMemberProperty xElementProperty = CodeDomHelper.CreateProperty(new CodeTypeReference("XElement"), true);
xElementProperty.Name = "Untyped";
xElementProperty.Attributes = MemberAttributes.Override | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public;
CodePropertyReferenceExpression baseUntyped = new CodePropertyReferenceExpression(new CodeBaseReferenceExpression(), "Untyped");
xElementProperty.GetStatements.Add(new CodeMethodReturnStatement(baseUntyped));
xElementProperty.SetStatements.Add(new CodeAssignStatement(baseUntyped, CodeDomHelper.SetValue()));
if (!this.clrTypeInfo.IsSubstitutionHead)
{
xElementProperty.SetStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(fieldRef, "Untyped"), CodeDomHelper.SetValue()));
}
else
{
CodeStatementCollection setStatements = xElementProperty.SetStatements;
CodeBinaryOperatorExpression codeBinaryOperatorExpression = new CodeBinaryOperatorExpression(fieldRef, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
CodeStatement[] codeAssignStatement = new CodeStatement[] { new CodeAssignStatement(new CodePropertyReferenceExpression(fieldRef, "Untyped"), CodeDomHelper.SetValue()) };
setStatements.Add(new CodeConditionStatement(codeBinaryOperatorExpression, codeAssignStatement));
}
return(xElementProperty);
}
public static CodeMemberProperty CreateProperty(string propertyName, string propertyType, CodeMemberField field, MemberAttributes attributes, bool hasSet)
{
CodeTypeReference returnType = null;
returnType = (propertyType == null ? field.Type : new CodeTypeReference(propertyType));
CodeMemberProperty valueProperty = CodeDomHelper.CreateProperty(propertyName, returnType, attributes);
valueProperty.GetStatements.Add(new CodeMethodReturnStatement(CodeDomHelper.CreateFieldReference(null, field.Name)));
if (hasSet)
{
CodeExpression rightExpression = null;
if (!(field.Type.BaseType != returnType.BaseType))
{
rightExpression = CodeDomHelper.SetValue();
}
else
{
rightExpression = new CodeCastExpression(field.Type, CodeDomHelper.SetValue());
}
valueProperty.SetStatements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference("this", field.Name), rightExpression));
}
return(valueProperty);
}
private void CreateXRoot(CodeNamespace codeNamespace, string rootName, List <CodeTypeDeclaration> elements,
List <CodeNamespace> namespaces, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
LocalSymbolTable lst = new LocalSymbolTable();
CodeTypeDeclaration xroot = CodeDomHelper.CreateTypeDeclaration(rootName, null, visibility);
//Create Methods
CodeMemberField docField = CodeDomHelper.CreateMemberField("doc",
"XDocument",
false, MemberAttributes.Private);
CodeMemberField rootField = CodeDomHelper.CreateMemberField("rootObject",
Constants.XTypedElement,
false, MemberAttributes.Private);
xroot.Members.Add(docField);
xroot.Members.Add(rootField);
lst.Init(rootName);
lst.RegisterMember("doc");
lst.RegisterMember("rootObject");
lst.RegisterMember("Load");
lst.RegisterMember("Parse");
lst.RegisterMember("Save");
lst.RegisterMember("XDocument");
lst.RegisterMember("Root");
// Constructor
xroot.Members.Add(CodeDomHelper.CreateConstructor(MemberAttributes.Private));
//Load Methods
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load",
new string[][] { new string[] { "System.String", "xmlFile" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", new string[][]
{
new string[] { "System.String", "xmlFile" },
new string[] { "LoadOptions", "options" }
}, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load",
new string[][] { new string[] { "TextReader", "textReader" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", new string[][]
{
new string[] { "TextReader", "textReader" },
new string[] { "LoadOptions", "options" }
}, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load",
new string[][] { new string[] { "XmlReader", "xmlReader" } }, visibility));
//Parse Methods
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Parse",
new string[][] { new string[] { "System.String", "text" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Parse", new string[][]
{
new string[] { "System.String", "text" },
new string[] { "LoadOptions", "options" }
}, visibility));
//Save Methods
xroot.Members.Add(
CodeDomHelper.CreateXRootSave(new string[][] { new string[] { "System.String", "fileName" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][]
{ new string[] { "TextWriter", "textWriter" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][] { new string[] { "XmlWriter", "writer" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][]
{
new string[] { "TextWriter", "textWriter" },
new string[] { "SaveOptions", "options" }
}, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][]
{
new string[] { "System.String", "fileName" },
new string[] { "SaveOptions", "options" }
}, visibility));
CodeMemberProperty docProp = CodeDomHelper.CreateProperty("XDocument",
"XDocument",
docField,
visibility.ToMemberAttribute(),
false);
xroot.Members.Add(docProp);
CodeMemberProperty rootProp = CodeDomHelper.CreateProperty("Root",
"XTypedElement",
rootField,
visibility.ToMemberAttribute(),
false);
xroot.Members.Add(rootProp);
for (int i = 0; i < elements.Count; i++)
{
string typeName = elements[i].Name;
string fqTypeName = (namespaces == null || namespaces[i].Name == String.Empty)
? typeName
: "global::" + namespaces[i].Name + "." + typeName;
xroot.Members.Add(CodeDomHelper.CreateXRootFunctionalConstructor(fqTypeName, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootGetter(typeName, fqTypeName, lst, visibility));
}
codeNamespace.Types.Add(xroot);
}
private void CreateXRoot(CodeNamespace codeNamespace, string rootName, List <CodeTypeDeclaration> elements, List <CodeNamespace> namespaces)
{
if (codeNamespace != null)
{
LocalSymbolTable lst = new LocalSymbolTable(this.settings);
CodeTypeDeclaration xroot = CodeDomHelper.CreateTypeDeclaration(rootName, null);
CodeMemberField docField = CodeDomHelper.CreateMemberField("doc", "XDocument", MemberAttributes.Private, false);
CodeMemberField rootField = CodeDomHelper.CreateMemberField("rootObject", "XTypedElement", MemberAttributes.Private, false);
xroot.Members.Add(docField);
xroot.Members.Add(rootField);
lst.Init(rootName);
lst.RegisterMember("doc");
lst.RegisterMember("rootObject");
lst.RegisterMember("Load");
lst.RegisterMember("Parse");
lst.RegisterMember("Save");
lst.RegisterMember("XDocument");
xroot.Members.Add(CodeDomHelper.CreateConstructor(MemberAttributes.Private));
CodeTypeMemberCollection members = xroot.Members;
string[][] strArrays = new string[1][];
string[] strArrays1 = new string[] { "System.String", "xmlFile" };
strArrays[0] = strArrays1;
members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", strArrays));
CodeTypeMemberCollection codeTypeMemberCollection = xroot.Members;
strArrays = new string[2][];
strArrays1 = new string[] { "System.String", "xmlFile" };
strArrays[0] = strArrays1;
strArrays1 = new string[] { "LoadOptions", "options" };
strArrays[1] = strArrays1;
codeTypeMemberCollection.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", strArrays));
CodeTypeMemberCollection members1 = xroot.Members;
strArrays = new string[1][];
strArrays1 = new string[] { "TextReader", "textReader" };
strArrays[0] = strArrays1;
members1.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", strArrays));
CodeTypeMemberCollection codeTypeMemberCollection1 = xroot.Members;
strArrays = new string[2][];
strArrays1 = new string[] { "TextReader", "textReader" };
strArrays[0] = strArrays1;
strArrays1 = new string[] { "LoadOptions", "options" };
strArrays[1] = strArrays1;
codeTypeMemberCollection1.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", strArrays));
CodeTypeMemberCollection members2 = xroot.Members;
strArrays = new string[1][];
strArrays1 = new string[] { "XmlReader", "xmlReader" };
strArrays[0] = strArrays1;
members2.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", strArrays));
CodeTypeMemberCollection codeTypeMemberCollection2 = xroot.Members;
strArrays = new string[1][];
strArrays1 = new string[] { "System.String", "text" };
strArrays[0] = strArrays1;
codeTypeMemberCollection2.Add(CodeDomHelper.CreateXRootMethod(rootName, "Parse", strArrays));
CodeTypeMemberCollection members3 = xroot.Members;
strArrays = new string[2][];
strArrays1 = new string[] { "System.String", "text" };
strArrays[0] = strArrays1;
strArrays1 = new string[] { "LoadOptions", "options" };
strArrays[1] = strArrays1;
members3.Add(CodeDomHelper.CreateXRootMethod(rootName, "Parse", strArrays));
CodeTypeMemberCollection codeTypeMemberCollection3 = xroot.Members;
strArrays = new string[1][];
strArrays1 = new string[] { "System.String", "fileName" };
strArrays[0] = strArrays1;
codeTypeMemberCollection3.Add(CodeDomHelper.CreateXRootSave(strArrays));
CodeTypeMemberCollection members4 = xroot.Members;
strArrays = new string[1][];
strArrays1 = new string[] { "TextWriter", "textWriter" };
strArrays[0] = strArrays1;
members4.Add(CodeDomHelper.CreateXRootSave(strArrays));
CodeTypeMemberCollection codeTypeMemberCollection4 = xroot.Members;
strArrays = new string[1][];
strArrays1 = new string[] { "XmlWriter", "writer" };
strArrays[0] = strArrays1;
codeTypeMemberCollection4.Add(CodeDomHelper.CreateXRootSave(strArrays));
CodeTypeMemberCollection members5 = xroot.Members;
strArrays = new string[2][];
strArrays1 = new string[] { "TextWriter", "textWriter" };
strArrays[0] = strArrays1;
strArrays1 = new string[] { "SaveOptions", "options" };
strArrays[1] = strArrays1;
members5.Add(CodeDomHelper.CreateXRootSave(strArrays));
CodeTypeMemberCollection codeTypeMemberCollection5 = xroot.Members;
strArrays = new string[2][];
strArrays1 = new string[] { "System.String", "fileName" };
strArrays[0] = strArrays1;
strArrays1 = new string[] { "SaveOptions", "options" };
strArrays[1] = strArrays1;
codeTypeMemberCollection5.Add(CodeDomHelper.CreateXRootSave(strArrays));
CodeMemberProperty prop = CodeDomHelper.CreateProperty("XDocument", "XDocument", docField, MemberAttributes.Public, false);
xroot.Members.Add(prop);
for (int i = 0; i < elements.Count; i++)
{
string typeName = elements[i].Name;
string fqTypeName = (namespaces == null || namespaces[i].Name == string.Empty ? typeName : string.Concat("global::", namespaces[i].Name, ".", typeName));
xroot.Members.Add(CodeDomHelper.CreateXRootFunctionalConstructor(fqTypeName));
xroot.Members.Add(CodeDomHelper.CreateXRootGetter(typeName, fqTypeName, lst));
}
codeNamespace.Types.Add(xroot);
}
}
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);
}
