public static CodeConstructor CreateXRootFunctionalConstructor(string typeName)
{
CodeConstructor constructor = CodeDomHelper.CreateConstructor(MemberAttributes.Public);
constructor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeName), "root"));
CodeStatementCollection statements = constructor.Statements;
CodeFieldReferenceExpression codeFieldReferenceExpression = new CodeFieldReferenceExpression(CodeDomHelper.This(), "doc");
CodeExpression[] codePropertyReferenceExpression = new CodeExpression[] { new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("root"), "Untyped") };
statements.Add(new CodeAssignStatement(codeFieldReferenceExpression, new CodeObjectCreateExpression("XDocument", codePropertyReferenceExpression)));
constructor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(CodeDomHelper.This(), "rootObject"), new CodeVariableReferenceExpression("root")));
return(constructor);
}
internal override CodeConstructor CreateFunctionalConstructor(List <ClrAnnotation> annotations)
{
string parameterName = "content";
CodeConstructor constructor = CodeDomHelper.CreateConstructor(MemberAttributes.Public);
CodeTypeReference returnType = null;
if (!this.isSchemaList)
{
returnType = new CodeTypeReference(this.simpleTypeName);
}
else
{
CodeTypeReference[] codeTypeReference = new CodeTypeReference[] { new CodeTypeReference(this.simpleTypeName) };
returnType = new CodeTypeReference("IList", codeTypeReference);
}
constructor.Parameters.Add(new CodeParameterDeclarationExpression(returnType, parameterName));
constructor.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(CodeDomHelper.This(), "TypedValue"), new CodeVariableReferenceExpression(parameterName)));
TypeBuilder.ApplyAnnotations(constructor, annotations, null);
this.decl.Members.Add(constructor);
return(constructor);
}
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 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);
}
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));
}
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);
}
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);
}
internal void AddTypeToTypeManager(CodeStatementCollection dictionaryStatements, string dictionaryName)
{
string typeRef = string.Concat("global::", this.clrTypeInfo.clrFullTypeName);
CodeExpression[] codeExpressionArray = new CodeExpression[] { CodeDomHelper.XNameGetExpression(this.clrTypeInfo.schemaName, this.clrTypeInfo.schemaNs), CodeDomHelper.Typeof(typeRef) };
dictionaryStatements.Add(CodeDomHelper.CreateMethodCallFromField(dictionaryName, "Add", codeExpressionArray));
}
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);
}
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);
}
}
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);
}
internal virtual void CreateDefaultConstructor(List <ClrAnnotation> annotations)
{
this.decl.Members.Add(TypeBuilder.ApplyAnnotations(CodeDomHelper.CreateConstructor(MemberAttributes.Public), annotations, null));
}
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);
}
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);
}
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);
}
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);
}
public static CodeMethodInvokeExpression XNameGetExpression(string name, string ns)
{
CodeMethodInvokeExpression codeMethodInvokeExpression = CodeDomHelper.XNameGetExpression(new CodePrimitiveExpression(name), new CodePrimitiveExpression(ns));
return(codeMethodInvokeExpression);
}
internal override void CreateProperty(ClrBasePropertyInfo propertyInfo, List <ClrAnnotation> annotations)
{
if ((!this.clrTypeInfo.InlineBaseType ? false : propertyInfo.FromBaseType))
{
propertyInfo.IsNew = true;
}
this.propertyBuilder.GenerateCode(propertyInfo, annotations);
if ((propertyInfo.ContentType != ContentType.Property ? false : !propertyInfo.IsDuplicate))
{
CodeStatementCollection codeStatementCollection = this.propertyDictionaryAddStatements;
CodeExpression[] codeExpressionArray = new CodeExpression[] { CodeDomHelper.XNameGetExpression(propertyInfo.SchemaName, propertyInfo.PropertyNs), CodeDomHelper.Typeof(propertyInfo.ClrTypeName) };
codeStatementCollection.Add(CodeDomHelper.CreateMethodCallFromField("localElementDictionary", "Add", codeExpressionArray));
}
}
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 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);
}
}
public static CodeMemberMethod CreateXRootMethod(string returnType, string methodName, string[][] paramList,
GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
CodeTypeReference xRootType = new CodeTypeReference(returnType);
CodeMemberMethod staticMethod = new CodeMemberMethod();
staticMethod.Name = methodName;
staticMethod.Attributes = visibility.ToMemberAttribute() | MemberAttributes.Static;
staticMethod.ReturnType = xRootType;
CodeExpression[] parameterExp = new CodeExpression[paramList.Length];
for (int i = 0; i < paramList.Length; i++)
{
string[] paramRef = paramList[i];
// index 0 is the type name and index 1 is the parameter name
staticMethod.Parameters.Add(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( //XRoot root = new XRoot;
new CodeVariableDeclarationStatement(xRootType, "root",
new CodeObjectCreateExpression(xRootType)));
staticMethod.Statements.Add( //root.doc = XDocument.Load(xmlFile);
new CodeAssignStatement(
doc,
CreateMethodCall(new CodeTypeReferenceExpression("XDocument"), methodName,
parameterExp)));
staticMethod.Statements.Add( //XTypedElement typedRoot = XTypedServices.ToXTypedElement(....)
new CodeVariableDeclarationStatement(
Constants.XTypedElement,
"typedRoot",
CreateMethodCall(
new CodeTypeReferenceExpression(Constants.XTypedServices),
Constants.ToXTypedElement,
new CodePropertyReferenceExpression(doc, "Root"),
CodeDomHelper.SingletonTypeManager())));
staticMethod.Statements.Add( //if(typedRoot == null)
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("typedRoot"),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)
),
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(Constants.LinqToXsdException,
new CodePrimitiveExpression("Invalid root element in xml document."))
)));
staticMethod.Statements.Add( //root.rootObject = typedRoot
new CodeAssignStatement(
new CodeFieldReferenceExpression(rootExp, "rootObject"),
new CodeVariableReferenceExpression("typedRoot")));
staticMethod.Statements.Add( //return root;
new CodeMethodReturnStatement(rootExp));
return(staticMethod);
}
public static CodeSnippetTypeMember CreateCast(string typeT, string typeT1, bool useAutoTyping)
{
string[] strArrays;
CodeSnippetTypeMember castMember = new CodeSnippetTypeMember();
if (!useAutoTyping)
{
strArrays = new string[] { " public static explicit operator ", typeT, "(XElement xe) { return ", "XTypedServices", ".ToXTypedElement<", CodeDomHelper.GetInnerType(typeT, typeT1), ">(xe,", NameGenerator.GetServicesClassName(), ".Instance as ILinqToXsdTypeManager); }" };
castMember.Text = string.Concat(strArrays);
}
else
{
strArrays = new string[] { " public static explicit operator ", typeT, "(XElement xe) { ", "return (", typeT, ")", "XTypedServices", ".ToXTypedElement(xe,", NameGenerator.GetServicesClassName(), ".Instance as ILinqToXsdTypeManager); }" };
castMember.Text = string.Concat(strArrays);
}
return(castMember);
}
protected override void ImplementCommonIXMetaData()
{
CodeMemberProperty localElementDictionary = CodeDomHelper.CreateInterfaceImplProperty("LocalElementsDictionary", "IXMetaData", CodeDomHelper.CreateDictionaryType("XName", "System.Type"));
localElementDictionary.GetStatements.Add(CodeDomHelper.CreateCastToInterface("IXMetaData", "schemaMetaData", "Content"));
localElementDictionary.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("schemaMetaData"), "LocalElementsDictionary")));
CodeMemberProperty contentProperty = CodeDomHelper.CreateInterfaceImplProperty("Content", "IXMetaData", new CodeTypeReference("XTypedElement"));
contentProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Content")));
this.decl.Members.Add(localElementDictionary);
this.decl.Members.Add(contentProperty);
}
public static CodeMethodInvokeExpression CreateMethodCallFromField(string fieldName, string methodName, params CodeExpression[] parameters)
{
CodeMethodInvokeExpression codeMethodInvokeExpression = new CodeMethodInvokeExpression(CodeDomHelper.CreateFieldReference(null, fieldName), methodName, parameters);
return(codeMethodInvokeExpression);
}
internal void AddTypeToTypeManager(CodeStatementCollection elementDictionaryStatements, CodeStatementCollection wrapperDictionaryStatements)
{
base.AddTypeToTypeManager(elementDictionaryStatements, "elementDictionary");
string innerTypeFullName = null;
if (!this.innerTypeName.Contains(this.innerTypeNs))
{
innerTypeFullName = string.Concat("global::", this.innerTypeNs, ".", this.innerTypeName);
}
CodeExpression[] codeExpressionArray = new CodeExpression[] { CodeDomHelper.Typeof(this.clrTypeInfo.clrFullTypeName), CodeDomHelper.Typeof(innerTypeFullName) };
wrapperDictionaryStatements.Add(CodeDomHelper.CreateMethodCallFromField("wrapperDictionary", "Add", codeExpressionArray));
}
private void AddSetStatements(CodeStatementCollection setStatements)
{
setStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), this.wrappedFieldName), this.propertyName), CodeDomHelper.SetValue()));
}