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