public MapCodeGenerator (CodeNamespace codeNamespace, CodeCompileUnit codeCompileUnit, CodeGenerationOptions options)
{
// this.codeCompileUnit = codeCompileUnit;
this.codeNamespace = codeNamespace;
this.options = options;
this.identifiers = new CodeIdentifiers ();
}
internal string GenerateBaseSerializer(string baseSerializer, string readerClass, string writerClass, CodeIdentifiers classes)
{
baseSerializer = CodeIdentifier.MakeValid(baseSerializer);
baseSerializer = classes.AddUnique(baseSerializer, baseSerializer);
this.writer.WriteLine();
this.writer.Write("public abstract class ");
this.writer.Write(CodeIdentifier.GetCSharpName(baseSerializer));
this.writer.Write(" : ");
this.writer.Write(typeof(XmlSerializer).FullName);
this.writer.WriteLine(" {");
this.writer.Indent++;
this.writer.Write("protected override ");
this.writer.Write(typeof(XmlSerializationReader).FullName);
this.writer.WriteLine(" CreateReader() {");
this.writer.Indent++;
this.writer.Write("return new ");
this.writer.Write(readerClass);
this.writer.WriteLine("();");
this.writer.Indent--;
this.writer.WriteLine("}");
this.writer.Write("protected override ");
this.writer.Write(typeof(XmlSerializationWriter).FullName);
this.writer.WriteLine(" CreateWriter() {");
this.writer.Indent++;
this.writer.Write("return new ");
this.writer.Write(writerClass);
this.writer.WriteLine("();");
this.writer.Indent--;
this.writer.WriteLine("}");
this.writer.Indent--;
this.writer.WriteLine("}");
return baseSerializer;
}
internal void AddReservedIdentifiersForDataBinding(CodeIdentifiers scope)
{
if ((this.options & CodeGenerationOptions.EnableDataBinding) != CodeGenerationOptions.None)
{
scope.AddReserved(CodeExporter.PropertyChangedEvent.Name);
scope.AddReserved(CodeExporter.RaisePropertyChangedEventMethod.Name);
}
}
public void IgnoreCase ()
{
CodeIdentifiers c = new CodeIdentifiers (false);
c.Add ("test", "x");
c.Add ("Test", "y");
Assert.IsTrue ("test" != c.AddUnique ("Test", "z"), "#1");
Assert.IsTrue (c.IsInUse ("tEsT"), "#2");
Assert.AreEqual ("camelCase", c.MakeRightCase ("CAMELCASE"), "#3");
}
public MapCodeGenerator (CodeNamespace codeNamespace, CodeCompileUnit codeCompileUnit, CodeDomProvider codeProvider, CodeGenerationOptions options, Hashtable mappings)
{
// this.codeCompileUnit = codeCompileUnit;
this.codeNamespace = codeNamespace;
this.options = options;
this.codeProvider = codeProvider;
this.identifiers = new CodeIdentifiers ((codeProvider.LanguageOptions & LanguageOptions.CaseInsensitive) == 0);
// this.mappings = mappings;
}
internal SoapParameters(XmlMembersMapping request, XmlMembersMapping response, string[] parameterOrder, CodeIdentifiers identifiers) {
ArrayList requestList = new ArrayList();
ArrayList responseList = new ArrayList();
AddMappings(requestList, request);
if (response != null) AddMappings(responseList, response);
if (parameterOrder != null) {
for (int i = 0; i < parameterOrder.Length; i++) {
string elementName = parameterOrder[i];
XmlMemberMapping requestMapping = FindMapping(requestList, elementName);
SoapParameter parameter = new SoapParameter();
if (requestMapping != null) {
if (RemoveByRefMapping(responseList, requestMapping))
parameter.codeFlags = CodeFlags.IsByRef;
parameter.mapping = requestMapping;
requestList.Remove(requestMapping);
AddParameter(parameter);
}
else {
XmlMemberMapping responseMapping = FindMapping(responseList, elementName);
if (responseMapping != null) {
parameter.codeFlags = CodeFlags.IsOut;
parameter.mapping = responseMapping;
responseList.Remove(responseMapping);
AddParameter(parameter);
}
}
}
}
foreach (XmlMemberMapping requestMapping in requestList) {
SoapParameter parameter = new SoapParameter();
if (RemoveByRefMapping(responseList, requestMapping))
parameter.codeFlags = CodeFlags.IsByRef;
parameter.mapping = requestMapping;
AddParameter(parameter);
}
if (responseList.Count > 0) {
if (!((XmlMemberMapping) responseList[0]).CheckSpecified) {
ret = (XmlMemberMapping)responseList[0];
responseList.RemoveAt(0);
}
foreach (XmlMemberMapping responseMapping in responseList) {
SoapParameter parameter = new SoapParameter();
parameter.mapping = responseMapping;
parameter.codeFlags = CodeFlags.IsOut;
AddParameter(parameter);
}
}
foreach (SoapParameter parameter in parameters) {
parameter.name = identifiers.MakeUnique(CodeIdentifier.MakeValid(parameter.mapping.MemberName));
}
}
public ImportContext (CodeIdentifiers identifiers, bool shareTypes)
{
_typeIdentifiers = identifiers;
this._shareTypes = shareTypes;
if (shareTypes) {
MappedTypes = new Hashtable ();
DataMappedTypes = new Hashtable ();
SharedAnonymousTypes = new Hashtable ();
}
}
protected override CodeTypeDeclaration BeginClass ()
{
httpBinding = (HttpBinding) Binding.Extensions.Find (typeof(HttpBinding));
CodeTypeDeclaration codeClass = new CodeTypeDeclaration (ClassName);
string location = null;
if (Port != null) {
HttpAddressBinding sab = (HttpAddressBinding) Port.Extensions.Find (typeof(HttpAddressBinding));
if (sab != null) location = sab.Location;
}
CodeConstructor cc = new CodeConstructor ();
cc.Attributes = MemberAttributes.Public;
GenerateServiceUrl (location, cc.Statements);
codeClass.Members.Add (cc);
memberIds = new CodeIdentifiers ();
return codeClass;
}
public XmlMembersMapping ImportAnyType (XmlQualifiedName typeName, string elementName)
{
if (typeName == XmlQualifiedName.Empty)
{
XmlTypeMapMemberAnyElement mapMem = new XmlTypeMapMemberAnyElement ();
mapMem.Name = typeName.Name;
mapMem.TypeData = TypeTranslator.GetTypeData(typeof(XmlNode));
mapMem.ElementInfo.Add (CreateElementInfo (typeName.Namespace, mapMem, typeName.Name, mapMem.TypeData, true, XmlSchemaForm.None, -1));
XmlMemberMapping[] mm = new XmlMemberMapping [1];
mm[0] = new XmlMemberMapping (typeName.Name, typeName.Namespace, mapMem, encodedFormat);
return new XmlMembersMapping (mm);
}
else
{
XmlSchemaComplexType stype = (XmlSchemaComplexType) schemas.Find (typeName, typeof (XmlSchemaComplexType));
if (stype == null)
throw new InvalidOperationException ("Referenced type '" + typeName + "' not found");
if (!CanBeAnyElement (stype))
throw new InvalidOperationException ("The type '" + typeName + "' is not valid for a collection of any elements");
ClassMap cmap = new ClassMap ();
CodeIdentifiers classIds = new CodeIdentifiers ();
bool isMixed = stype.IsMixed;
ImportSequenceContent (typeName, cmap, ((XmlSchemaSequence) stype.Particle).Items, classIds, false, ref isMixed);
XmlTypeMapMemberAnyElement mapMem = (XmlTypeMapMemberAnyElement) cmap.AllMembers[0];
mapMem.Name = typeName.Name;
XmlMemberMapping[] mm = new XmlMemberMapping [1];
mm[0] = new XmlMemberMapping (typeName.Name, typeName.Namespace, mapMem, encodedFormat);
return new XmlMembersMapping (mm);
}
}
XmlTypeMapping ImportClassSimpleType (XmlQualifiedName typeQName, XmlSchemaSimpleType stype, XmlQualifiedName root)
{
if (CanBeEnum (stype))
{
// Create an enum map
CodeIdentifiers codeIdents = new CodeIdentifiers ();
XmlTypeMapping enumMap = CreateTypeMapping (typeQName, SchemaTypes.Enum, root);
enumMap.Documentation = GetDocumentation (stype);
bool isFlags = false;
if (stype.Content is XmlSchemaSimpleTypeList) {
stype = ((XmlSchemaSimpleTypeList)stype.Content).ItemType;
isFlags = true;
}
XmlSchemaSimpleTypeRestriction rest = (XmlSchemaSimpleTypeRestriction)stype.Content;
codeIdents.AddReserved (enumMap.TypeData.TypeName);
EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember [rest.Facets.Count];
for (int n=0; n<rest.Facets.Count; n++)
{
XmlSchemaEnumerationFacet enu = (XmlSchemaEnumerationFacet) rest.Facets[n];
string enumName = codeIdents.AddUnique(CodeIdentifier.MakeValid (enu.Value), enu);
members [n] = new EnumMap.EnumMapMember (enu.Value, enumName);
members [n].Documentation = GetDocumentation (enu);
}
enumMap.ObjectMap = new EnumMap (members, isFlags);
enumMap.IsSimpleType = true;
return enumMap;
}
if (stype.Content is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList slist = (XmlSchemaSimpleTypeList)stype.Content;
TypeData arrayTypeData = FindBuiltInType (slist.ItemTypeName, stype);
ListMap listMap = new ListMap ();
listMap.ItemInfo = new XmlTypeMapElementInfoList ();
listMap.ItemInfo.Add (CreateElementInfo (typeQName.Namespace, null, "Item", arrayTypeData.ListItemTypeData, false, XmlSchemaForm.None, -1));
XmlTypeMapping map = CreateArrayTypeMapping (typeQName, arrayTypeData);
map.ObjectMap = listMap;
map.IsSimpleType = true;
return map;
}
// It is an extension of a primitive or known type
TypeData typeData = FindBuiltInType (typeQName, stype);
XmlTypeMapping rmap = GetTypeMapping (typeData);
// The resulting map must be a simple type. It needs to be explicitely set for arrays
rmap.IsSimpleType = true;
return rmap;
}
public XmlSchemaImporter (XmlSchemas schemas, CodeGenerationOptions options, ImportContext context)
{
this.schemas = schemas;
this.options = options;
if (context != null) {
typeIdentifiers = context.TypeIdentifiers;
InitSharedData (context);
}
else
typeIdentifiers = new CodeIdentifiers ();
InitializeExtensions ();
}
void ImportChoiceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaChoice choice, CodeIdentifiers classIds, bool multiValue)
{
XmlTypeMapElementInfoList choices = new XmlTypeMapElementInfoList ();
multiValue = ImportChoices (typeQName, null, choices, choice.Items) || multiValue;
if (choices.Count == 0) return;
if (choice.MaxOccurs > 1) multiValue = true;
XmlTypeMapMemberElement member;
if (multiValue)
{
member = new XmlTypeMapMemberFlatList ();
member.Name = classIds.AddUnique ("Items", member);
ListMap listMap = new ListMap ();
listMap.ItemInfo = choices;
((XmlTypeMapMemberFlatList)member).ListMap = listMap;
}
else
{
member = new XmlTypeMapMemberElement ();
member.Name = classIds.AddUnique ("Item", member);
}
// If all choices have the same type, use that type for the member.
// If not use System.Object.
// If there are at least two choices with the same type, use a choice
// identifier attribute
TypeData typeData = null;
bool twoEqual = false;
bool allEqual = true;
Hashtable types = new Hashtable ();
for (int n = choices.Count - 1; n >= 0; n--)
{
XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) choices [n];
// In some complex schemas, we may end up with several options
// with the same name. It is better to ignore the extra options
// than to crash. It's the best we can do, and btw it works
// better than in MS.NET.
if (cmap.GetElement (einfo.ElementName, einfo.Namespace, einfo.ExplicitOrder) != null ||
choices.IndexOfElement (einfo.ElementName, einfo.Namespace) != n)
{
choices.RemoveAt (n);
continue;
}
if (types.ContainsKey (einfo.TypeData)) twoEqual = true;
else types.Add (einfo.TypeData, einfo);
TypeData choiceType = einfo.TypeData;
if (choiceType.SchemaType == SchemaTypes.Class)
{
// When comparing class types, use the most generic class in the
// inheritance hierarchy
XmlTypeMapping choiceMap = GetTypeMapping (choiceType);
BuildPendingMap (choiceMap);
while (choiceMap.BaseMap != null) {
choiceMap = choiceMap.BaseMap;
BuildPendingMap (choiceMap);
choiceType = choiceMap.TypeData;
}
}
if (typeData == null) typeData = choiceType;
else if (typeData != choiceType) allEqual = false;
}
if (!allEqual)
typeData = TypeTranslator.GetTypeData (typeof(object));
if (twoEqual)
{
// Create the choice member
XmlTypeMapMemberElement choiceMember = new XmlTypeMapMemberElement ();
choiceMember.Ignore = true;
choiceMember.Name = classIds.AddUnique (member.Name + "ElementName", choiceMember);
member.ChoiceMember = choiceMember.Name;
// Create the choice enum
XmlTypeMapping enumMap = CreateTypeMapping (new XmlQualifiedName (member.Name + "ChoiceType", typeQName.Namespace), SchemaTypes.Enum, null);
enumMap.IncludeInSchema = false;
CodeIdentifiers codeIdents = new CodeIdentifiers ();
EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember [choices.Count];
for (int n=0; n<choices.Count; n++)
{
XmlTypeMapElementInfo it =(XmlTypeMapElementInfo) choices[n];
bool extraNs = (it.Namespace != null && it.Namespace != "" && it.Namespace != typeQName.Namespace);
string xmlName = extraNs ? it.Namespace + ":" + it.ElementName : it.ElementName;
string enumName = codeIdents.AddUnique (CodeIdentifier.MakeValid (it.ElementName), it);
members [n] = new EnumMap.EnumMapMember (xmlName, enumName);
}
enumMap.ObjectMap = new EnumMap (members, false);
choiceMember.TypeData = multiValue ? enumMap.TypeData.ListTypeData : enumMap.TypeData;
choiceMember.ElementInfo.Add (CreateElementInfo (typeQName.Namespace, choiceMember, choiceMember.Name, choiceMember.TypeData, false, XmlSchemaForm.None, -1));
cmap.AddMember (choiceMember);
}
if (typeData == null)
return;
if (multiValue)
typeData = typeData.ListTypeData;
member.ElementInfo = choices;
member.Documentation = GetDocumentation (choice);
member.TypeData = typeData;
cmap.AddMember (member);
}
void CreateHeaderMessages(string methodName, SoapBindingUse use, XmlMembersMapping inHeaderMappings, XmlMembersMapping outHeaderMappings, SoapReflectedHeader[] headers, bool rpc) {
//
if (use == SoapBindingUse.Encoded) {
SoapExporter.ExportMembersMapping(inHeaderMappings, false);
if (outHeaderMappings != null)
SoapExporter.ExportMembersMapping(outHeaderMappings, false);
}
else {
SchemaExporter.ExportMembersMapping(inHeaderMappings);
if (outHeaderMappings != null)
SchemaExporter.ExportMembersMapping(outHeaderMappings);
}
CodeIdentifiers identifiers = new CodeIdentifiers();
int inCount = 0, outCount = 0;
for (int i = 0; i < headers.Length; i++) {
SoapReflectedHeader soapHeader = headers[i];
if (!soapHeader.custom) continue;
XmlMemberMapping member;
if ((soapHeader.direction & SoapHeaderDirection.In) != 0) {
member = inHeaderMappings[inCount++];
if (soapHeader.direction != SoapHeaderDirection.In)
outCount++;
}
else {
member = outHeaderMappings[outCount++];
}
MessagePart part = new MessagePart();
part.Name = member.XsdElementName;
if (use == SoapBindingUse.Encoded)
part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace);
else
part.Element = new XmlQualifiedName(member.XsdElementName, member.Namespace);
Message message = new Message();
message.Name = identifiers.AddUnique(methodName + part.Name, message);
message.Parts.Add(part);
HeaderMessages.Add(message);
ServiceDescriptionFormatExtension soapHeaderBinding = CreateSoapHeaderBinding(new XmlQualifiedName(message.Name, Binding.ServiceDescription.TargetNamespace), part.Name, rpc ? member.Namespace : null, use);
if ((soapHeader.direction & SoapHeaderDirection.In) != 0)
OperationBinding.Input.Extensions.Add(soapHeaderBinding);
if ((soapHeader.direction & SoapHeaderDirection.Out) != 0)
OperationBinding.Output.Extensions.Add(soapHeaderBinding);
if ((soapHeader.direction & SoapHeaderDirection.Fault) != 0) {
if (soapMethod.IsClaimsConformance) {
throw new InvalidOperationException(Res.GetString(Res.BPConformanceHeaderFault, soapMethod.methodInfo.ToString(), soapMethod.methodInfo.DeclaringType.FullName, "Direction", typeof(SoapHeaderDirection).Name, SoapHeaderDirection.Fault.ToString()));
}
OperationBinding.Output.Extensions.Add(soapHeaderBinding);
}
}
}
void ImportSequenceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaObjectCollection items, CodeIdentifiers classIds, bool multiValue, ref bool isMixed)
{
foreach (XmlSchemaObject item in items)
{
if (item is XmlSchemaElement)
{
string ns;
XmlSchemaElement elem = (XmlSchemaElement) item;
XmlTypeMapping emap;
TypeData typeData = GetElementTypeData (typeQName, elem, null, out emap);
XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);
if (elem.MaxOccurs == 1 && !multiValue)
{
XmlTypeMapMemberElement member = null;
if (typeData.SchemaType != SchemaTypes.Array)
{
member = new XmlTypeMapMemberElement ();
if (refElem.DefaultValue != null) member.DefaultValue = ImportDefaultValue (typeData, refElem.DefaultValue);
}
else if (GetTypeMapping (typeData).IsSimpleType)
{
// It is a simple list (space separated list).
// Since this is not supported, map as a single item value
member = new XmlTypeMapMemberElement ();
#if NET_2_0
// In MS.NET those types are mapped to a string
typeData = TypeTranslator.GetTypeData(typeof(string));
#else
typeData = typeData.ListItemTypeData;
#endif
}
else
member = new XmlTypeMapMemberList ();
if (elem.MinOccurs == 0 && typeData.IsValueType)
member.IsOptionalValueType = true;
member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);
member.Documentation = GetDocumentation (elem);
member.TypeData = typeData;
member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, items.IndexOf (item)));
cmap.AddMember (member);
}
else
{
XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList ();
member.ListMap = new ListMap ();
member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);
member.Documentation = GetDocumentation (elem);
member.TypeData = typeData.ListTypeData;
member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, items.IndexOf (item)));
member.ListMap.ItemInfo = member.ElementInfo;
cmap.AddMember (member);
}
}
else if (item is XmlSchemaAny)
{
XmlSchemaAny elem = (XmlSchemaAny) item;
XmlTypeMapMemberAnyElement member = new XmlTypeMapMemberAnyElement ();
member.Name = classIds.AddUnique ("Any", member);
member.Documentation = GetDocumentation (elem);
Type ctype;
if (elem.MaxOccurs != 1 || multiValue)
ctype = isMixed ? typeof(XmlNode[]) : typeof(XmlElement[]);
else
ctype = isMixed ? typeof(XmlNode) : typeof(XmlElement);
member.TypeData = TypeTranslator.GetTypeData (ctype);
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, member.TypeData);
einfo.IsUnnamedAnyElement = true;
member.ElementInfo.Add (einfo);
if (isMixed)
{
einfo = CreateTextElementInfo (typeQName.Namespace, member, member.TypeData);
member.ElementInfo.Add (einfo);
member.IsXmlTextCollector = true;
isMixed = false; //Allow only one XmlTextAttribute
}
cmap.AddMember (member);
}
else if (item is XmlSchemaParticle) {
ImportParticleContent (typeQName, cmap, (XmlSchemaParticle)item, classIds, multiValue, ref isMixed);
}
}
}
public XmlSchemaImporter (XmlSchemas schemas)
{
this.schemas = schemas;
typeIdentifiers = new CodeIdentifiers ();
InitializeExtensions ();
}
internal static Assembly GenerateRefEmitAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace)
{
var scopeTable = new Dictionary <TypeScope, XmlMapping>();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
TypeScope[] scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
string assemblyName = "Microsoft.GeneratedCode";
AssemblyBuilder assemblyBuilder = CodeGenerator.CreateAssemblyBuilder(assemblyName);
// Add AssemblyVersion attribute to match parent assembly version
if (types != null && types.Length > 0 && types[0] != null)
{
ConstructorInfo AssemblyVersionAttribute_ctor = typeof(AssemblyVersionAttribute).GetConstructor(
new Type[] { typeof(string) }
);
string assemblyVersion = types[0].Assembly.GetName().Version.ToString();
assemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(AssemblyVersionAttribute_ctor, new object[] { assemblyVersion }));
}
CodeIdentifiers classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
ModuleBuilder moduleBuilder = CodeGenerator.CreateModuleBuilder(assemblyBuilder, assemblyName);
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
XmlSerializationWriterILGen writerCodeGen = new XmlSerializationWriterILGen(scopes, "public", writerClass);
writerCodeGen.ModuleBuilder = moduleBuilder;
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
Type writerType = writerCodeGen.GenerateEnd();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
XmlSerializationReaderILGen readerCodeGen = new XmlSerializationReaderILGen(scopes, "public", readerClass);
readerCodeGen.ModuleBuilder = moduleBuilder;
readerCodeGen.CreatedTypes.Add(writerType.Name, writerType);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
var serializers = new Dictionary <string, string>();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (!serializers.ContainsKey(xmlMappings[i].Key))
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
return(writerType.Assembly);
}
internal static bool GenerateSerializerToStream(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Assembly assembly, Hashtable assemblies, Stream stream)
{
var compiler = new Compiler();
try
{
var scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
var scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
assemblies.Clear();
var importedTypes = new Hashtable();
foreach (TypeScope scope in scopes)
{
foreach (Type t in scope.Types)
{
compiler.AddImport(t, importedTypes);
Assembly a = t.Assembly;
string name = a.FullName;
if (assemblies[name] != null)
{
continue;
}
if (!a.GlobalAssemblyCache)
{
assemblies[name] = a;
}
}
}
for (int i = 0; i < types.Length; i++)
{
compiler.AddImport(types[i], importedTypes);
}
compiler.AddImport(typeof(object).Assembly);
compiler.AddImport(typeof(System.Xml.Serialization.XmlSerializer).Assembly);
var writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("[assembly:System.Security.SecurityTransparent()]");
writer.WriteLine("[assembly:System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]");
if (assembly != null && types.Length > 0)
{
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type == null)
{
continue;
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
throw new InvalidOperationException(SR.Format(SR.XmlPregenTypeDynamic, types[i].FullName));
}
}
writer.Write("[assembly:");
writer.Write(typeof(XmlSerializerVersionAttribute).FullName);
writer.Write("(");
writer.Write("ParentAssemblyId=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, GenerateAssemblyId(types[0]));
writer.Write(", Version=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, ThisAssembly.Version);
if (defaultNamespace != null)
{
writer.Write(", Namespace=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, defaultNamespace);
}
writer.WriteLine(")]");
}
var classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
writer.WriteLine("namespace " + GeneratedAssemblyNamespace + " {");
writer.Indent++;
writer.WriteLine();
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
var writerCodeGen = new XmlSerializationWriterCodeGen(writer, scopes, "public", writerClass);
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
writerCodeGen.GenerateEnd();
writer.WriteLine();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
var readerCodeGen = new XmlSerializationReaderCodeGen(writer, scopes, "public", readerClass);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
var serializers = new Hashtable();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (serializers[xmlMappings[i].Key] == null)
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
writer.Indent--;
writer.WriteLine("}");
string codecontent = compiler.Source.ToString();
byte[] info = new UTF8Encoding(true).GetBytes(codecontent);
stream.Write(info, 0, info.Length);
stream.Flush();
return(true);
}
finally
{
compiler.Close();
}
}
private void ExportProperty(CodeTypeDeclaration codeClass, MemberMapping member, CodeIdentifiers memberScope)
{
string fieldName = memberScope.AddUnique(CodeExporter.MakeFieldName(member.Name), member);
string fieldType = member.GetTypeName(CodeProvider);
// need to create a private field
CodeMemberField field = new CodeMemberField(fieldType, fieldName);
field.Attributes = MemberAttributes.Private;
codeClass.Members.Add(field);
CodeMemberProperty prop = CreatePropertyDeclaration(field, member.Name, fieldType);
prop.Comments.Add(new CodeCommentStatement(SR.XmlRemarks, true));
AddMemberMetadata(prop.CustomAttributes, member, false);
codeClass.Members.Add(prop);
if (member.CheckSpecified != SpecifiedAccessor.None)
{
field = new CodeMemberField(typeof(bool).FullName, fieldName + "Specified");
field.Attributes = MemberAttributes.Private;
codeClass.Members.Add(field);
prop = CreatePropertyDeclaration(field, member.Name + "Specified", typeof(bool).FullName);
prop.Comments.Add(new CodeCommentStatement(SR.XmlRemarks, true));
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(typeof(SoapIgnoreAttribute).FullName);
prop.CustomAttributes.Add(attribute);
codeClass.Members.Add(prop);
}
}
/// <include file='doc\SoapSchemaImporter.uex' path='docs/doc[@for="SoapSchemaImporter.SoapSchemaImporter1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public SoapSchemaImporter(XmlSchemas schemas, CodeIdentifiers typeIdentifiers)
{
this.schemas = schemas;
this.typeIdentifiers = typeIdentifiers;
}
/// <include file='doc\SoapSchemaImporter.uex' path='docs/doc[@for="SoapSchemaImporter.SoapSchemaImporter"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public SoapSchemaImporter(XmlSchemas schemas)
{
this.schemas = schemas;
this.typeIdentifiers = new CodeIdentifiers();
}
/// <include file='doc\ImportContext.uex' path='docs/doc[@for="ImportContext.ImportContext"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public ImportContext(CodeIdentifiers identifiers, bool shareTypes)
{
this.typeIdentifiers = identifiers;
this.shareTypes = shareTypes;
}
XmlMemberMapping[] ImportMembersMappingComposite (XmlSchemaComplexType stype, XmlQualifiedName refer)
{
if (stype.Particle == null)
return new XmlMemberMapping [0];
ClassMap cmap = new ClassMap ();
XmlSchemaSequence seq = stype.Particle as XmlSchemaSequence;
if (seq == null) throw new InvalidOperationException ("Schema element '" + refer + "' cannot be imported as XmlMembersMapping");
CodeIdentifiers classIds = new CodeIdentifiers ();
ImportParticleComplexContent (refer, cmap, seq, classIds, false);
ImportAttributes (refer, cmap, stype.Attributes, stype.AnyAttribute, classIds);
BuildPendingMaps ();
int n = 0;
XmlMemberMapping[] mapping = new XmlMemberMapping [cmap.AllMembers.Count];
foreach (XmlTypeMapMember mapMem in cmap.AllMembers)
mapping[n++] = new XmlMemberMapping (mapMem.Name, refer.Namespace, mapMem, encodedFormat);
return mapping;
}
void ImportAttributes (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaObjectCollection atts, XmlSchemaAnyAttribute anyat, CodeIdentifiers classIds)
{
atts = CollectAttributeUsesNonOverlap (atts, cmap);
if (anyat != null)
{
XmlTypeMapMemberAnyAttribute member = new XmlTypeMapMemberAnyAttribute ();
member.Name = classIds.AddUnique ("AnyAttribute", member);
member.TypeData = TypeTranslator.GetTypeData (typeof(XmlAttribute[]));
cmap.AddMember (member);
}
foreach (XmlSchemaObject at in atts)
{
if (at is XmlSchemaAttribute)
{
string ns;
XmlSchemaAttribute attr = (XmlSchemaAttribute)at;
XmlSchemaAttribute refAttr = GetRefAttribute (typeQName, attr, out ns);
XmlTypeMapMemberAttribute member = new XmlTypeMapMemberAttribute ();
member.Name = classIds.AddUnique (CodeIdentifier.MakeValid (refAttr.Name), member);
member.Documentation = GetDocumentation (attr);
member.AttributeName = refAttr.Name;
member.Namespace = ns;
member.Form = refAttr.Form;
member.TypeData = GetAttributeTypeData (typeQName, attr);
if (refAttr.DefaultValue != null)
member.DefaultValue = ImportDefaultValue (member.TypeData, refAttr.DefaultValue);
else if (member.TypeData.IsValueType)
member.IsOptionalValueType = (refAttr.ValidatedUse != XmlSchemaUse.Required);
if (member.TypeData.IsComplexType)
member.MappedType = GetTypeMapping (member.TypeData);
cmap.AddMember (member);
}
else if (at is XmlSchemaAttributeGroupRef)
{
XmlSchemaAttributeGroupRef gref = (XmlSchemaAttributeGroupRef)at;
XmlSchemaAttributeGroup grp = FindRefAttributeGroup (gref.RefName);
ImportAttributes (typeQName, cmap, grp.Attributes, grp.AnyAttribute, classIds);
}
}
}
internal static Assembly GenerateRefEmitAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Evidence evidence)
{
Hashtable scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
TypeScope[] scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
string assemblyName = "Microsoft.GeneratedCode";
AssemblyBuilder assemblyBuilder = CodeGenerator.CreateAssemblyBuilder(assemblyName);
ConstructorInfo SecurityTransparentAttribute_ctor = typeof(SecurityTransparentAttribute).GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty <Type>()
);
assemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(SecurityTransparentAttribute_ctor, Array.Empty <Object>()));
CodeIdentifiers classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
ModuleBuilder moduleBuilder = CodeGenerator.CreateModuleBuilder(assemblyBuilder, assemblyName);
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
XmlSerializationWriterILGen writerCodeGen = new XmlSerializationWriterILGen(scopes, "public", writerClass);
writerCodeGen.ModuleBuilder = moduleBuilder;
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
Type writerType = writerCodeGen.GenerateEnd();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
XmlSerializationReaderILGen readerCodeGen = new XmlSerializationReaderILGen(scopes, "public", readerClass);
readerCodeGen.ModuleBuilder = moduleBuilder;
readerCodeGen.CreatedTypes.Add(writerType.Name, writerType);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
Hashtable serializers = new Hashtable();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (serializers[xmlMappings[i].Key] == null)
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
return(writerType.GetTypeInfo().Assembly);
}
void AddTextMember (XmlQualifiedName typeQName, ClassMap cmap, CodeIdentifiers classIds)
{
if (cmap.XmlTextCollector == null)
{
XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList ();
member.Name = classIds.AddUnique ("Text", member);
member.TypeData = TypeTranslator.GetTypeData (typeof(string[]));
member.ElementInfo.Add (CreateTextElementInfo (typeQName.Namespace, member, member.TypeData.ListItemTypeData));
member.IsXmlTextCollector = true;
member.ListMap = new ListMap ();
member.ListMap.ItemInfo = member.ElementInfo;
cmap.AddMember (member);
}
}
public ImportContext(CodeIdentifiers identifiers, bool shareTypes)
{
_typeIdentifiers = identifiers;
_shareTypes = shareTypes;
}
CodeMemberMethod GenerateMethod (CodeIdentifiers memberIds, HttpOperationBinding httpOper, XmlMembersMapping inputMembers, XmlTypeMapping outputMember)
{
CodeIdentifiers pids = new CodeIdentifiers ();
CodeMemberMethod method = new CodeMemberMethod ();
CodeMemberMethod methodBegin = new CodeMemberMethod ();
CodeMemberMethod methodEnd = new CodeMemberMethod ();
method.Attributes = MemberAttributes.Public;
methodBegin.Attributes = MemberAttributes.Public;
methodEnd.Attributes = MemberAttributes.Public;
// Find unique names for temporary variables
for (int n=0; n<inputMembers.Count; n++)
pids.AddUnique (inputMembers[n].MemberName, inputMembers[n]);
string varAsyncResult = pids.AddUnique ("asyncResult","asyncResult");
string varCallback = pids.AddUnique ("callback","callback");
string varAsyncState = pids.AddUnique ("asyncState","asyncState");
string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name),method);
method.Name = Operation.Name;
methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + Operation.Name),method);
methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + Operation.Name),method);
method.ReturnType = new CodeTypeReference (typeof(void));
methodEnd.ReturnType = new CodeTypeReference (typeof(void));
methodEnd.Parameters.Add (new CodeParameterDeclarationExpression (typeof (IAsyncResult),varAsyncResult));
CodeExpression[] paramArray = new CodeExpression [inputMembers.Count];
for (int n=0; n<inputMembers.Count; n++)
{
string ptype = GetSimpleType (inputMembers[n]);
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (ptype, inputMembers[n].MemberName);
param.Direction = FieldDirection.In;
method.Parameters.Add (param);
methodBegin.Parameters.Add (param);
paramArray [n] = new CodeVariableReferenceExpression (param.Name);
}
bool isVoid = true;
if (outputMember != null)
{
method.ReturnType = new CodeTypeReference (outputMember.TypeFullName);
methodEnd.ReturnType = new CodeTypeReference (outputMember.TypeFullName);
xmlExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, outputMember, "");
isVoid = false;
}
methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (AsyncCallback),varCallback));
methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object),varAsyncState));
methodBegin.ReturnType = new CodeTypeReference (typeof(IAsyncResult));
// Array of input parameters
CodeArrayCreateExpression methodParams;
if (paramArray.Length > 0)
methodParams = new CodeArrayCreateExpression (typeof(object), paramArray);
else
methodParams = new CodeArrayCreateExpression (typeof(object), 0);
// Generate method url
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodeExpression thisURlExp = new CodeFieldReferenceExpression (ethis, "Url");
CodePrimitiveExpression metUrl = new CodePrimitiveExpression (httpOper.Location);
CodeBinaryOperatorExpression expMethodLocation = new CodeBinaryOperatorExpression (thisURlExp, CodeBinaryOperatorType.Add, metUrl);
// Invoke call
CodePrimitiveExpression varMsgName = new CodePrimitiveExpression (messageName);
CodeMethodInvokeExpression inv;
inv = new CodeMethodInvokeExpression (ethis, "Invoke", varMsgName, expMethodLocation, methodParams);
if (!isVoid)
method.Statements.Add (new CodeMethodReturnStatement (new CodeCastExpression (method.ReturnType, inv)));
else
method.Statements.Add (inv);
// Begin Invoke Call
CodeExpression expCallb = new CodeVariableReferenceExpression (varCallback);
CodeExpression expAsyncs = new CodeVariableReferenceExpression (varAsyncState);
inv = new CodeMethodInvokeExpression (ethis, "BeginInvoke", varMsgName, expMethodLocation, methodParams, expCallb, expAsyncs);
methodBegin.Statements.Add (new CodeMethodReturnStatement (inv));
// End Invoke call
CodeExpression varAsyncr = new CodeVariableReferenceExpression (varAsyncResult);
inv = new CodeMethodInvokeExpression (ethis, "EndInvoke", varAsyncr);
if (!isVoid)
methodEnd.Statements.Add (new CodeMethodReturnStatement (new CodeCastExpression (methodEnd.ReturnType, inv)));
else
methodEnd.Statements.Add (inv);
// Attributes
CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.HttpMethodAttribute");
att.Arguments.Add (new CodeAttributeArgument (new CodeTypeOfExpression(GetOutMimeFormatter ())));
att.Arguments.Add (new CodeAttributeArgument (new CodeTypeOfExpression(GetInMimeFormatter ())));
AddCustomAttribute (method, att, true);
CodeTypeDeclaration.Members.Add (method);
CodeTypeDeclaration.Members.Add (methodBegin);
CodeTypeDeclaration.Members.Add (methodEnd);
return method;
}
public SoapSchemaImporter(XmlSchemas schemas, CodeIdentifiers typeIdentifiers, CodeGenerationOptions options)
{
_importer = new XmlSchemaImporter(schemas, typeIdentifiers, options);
_importer.UseEncodedFormat = true;
}
private MemberMapping[] ImportTypeMembers(XmlSchemaComplexType type, string typeNs, CodeIdentifiers members)
{
if (type.AnyAttribute != null)
{
throw new InvalidOperationException(Res.GetString("XmlInvalidAnyAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
XmlSchemaObjectCollection attributes = type.Attributes;
for (int i = 0; i < attributes.Count; i++)
{
object obj2 = attributes[i];
if (obj2 is XmlSchemaAttributeGroup)
{
throw new InvalidOperationException(Res.GetString("XmlSoapInvalidAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
if (obj2 is XmlSchemaAttribute)
{
XmlSchemaAttribute attribute = (XmlSchemaAttribute)obj2;
if (attribute.Use != XmlSchemaUse.Prohibited)
{
throw new InvalidOperationException(Res.GetString("XmlSoapInvalidAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
}
}
if (type.Particle != null)
{
this.ImportGroup(type.Particle, members, typeNs);
}
else if ((type.ContentModel != null) && (type.ContentModel is XmlSchemaComplexContent))
{
XmlSchemaComplexContent contentModel = (XmlSchemaComplexContent)type.ContentModel;
if (contentModel.Content is XmlSchemaComplexContentExtension)
{
if (((XmlSchemaComplexContentExtension)contentModel.Content).Particle != null)
{
this.ImportGroup(((XmlSchemaComplexContentExtension)contentModel.Content).Particle, members, typeNs);
}
}
else if ((contentModel.Content is XmlSchemaComplexContentRestriction) && (((XmlSchemaComplexContentRestriction)contentModel.Content).Particle != null))
{
this.ImportGroup(((XmlSchemaComplexContentRestriction)contentModel.Content).Particle, members, typeNs);
}
}
return((MemberMapping[])members.ToArray(typeof(MemberMapping)));
}
internal string GenerateBaseSerializer(string baseSerializer, string readerClass, string writerClass, CodeIdentifiers classes)
{
baseSerializer = CodeIdentifier.MakeValid(baseSerializer);
baseSerializer = classes.AddUnique(baseSerializer, baseSerializer);
_writer.WriteLine();
_writer.Write("public abstract class ");
_writer.Write(CodeIdentifier.GetCSharpName(baseSerializer));
_writer.Write(" : ");
_writer.Write(typeof(XmlSerializer).FullName);
_writer.WriteLine(" {");
_writer.Indent++;
_writer.Write("protected override ");
_writer.Write(typeof(XmlSerializationReader).FullName);
_writer.WriteLine(" CreateReader() {");
_writer.Indent++;
_writer.Write("return new ");
_writer.Write(readerClass);
_writer.WriteLine("();");
_writer.Indent--;
_writer.WriteLine("}");
_writer.Write("protected override ");
_writer.Write(typeof(XmlSerializationWriter).FullName);
_writer.WriteLine(" CreateWriter() {");
_writer.Indent++;
_writer.Write("return new ");
_writer.Write(writerClass);
_writer.WriteLine("();");
_writer.Indent--;
_writer.WriteLine("}");
_writer.Indent--;
_writer.WriteLine("}");
return(baseSerializer);
}
void ImportSimpleContent (XmlQualifiedName typeQName, XmlTypeMapping map, XmlSchemaSimpleContent content, CodeIdentifiers classIds, bool isMixed)
{
XmlSchemaSimpleContentExtension ext = content.Content as XmlSchemaSimpleContentExtension;
ClassMap cmap = (ClassMap)map.ObjectMap;
XmlQualifiedName qname = GetContentBaseType (content.Content);
TypeData simpleType = null;
if (!IsPrimitiveTypeNamespace (qname.Namespace))
{
// Add base map members to this map
XmlTypeMapping baseMap = ImportType (qname, null, true);
BuildPendingMap (baseMap);
if (baseMap.IsSimpleType) {
simpleType = baseMap.TypeData;
} else {
ClassMap baseClassMap = (ClassMap)baseMap.ObjectMap;
foreach (XmlTypeMapMember member in baseClassMap.AllMembers)
cmap.AddMember (member);
map.BaseMap = baseMap;
baseMap.DerivedTypes.Add (map);
}
}
else
simpleType = FindBuiltInType (qname);
if (simpleType != null) {
XmlTypeMapMemberElement member = new XmlTypeMapMemberElement ();
member.Name = classIds.AddUnique("Value", member);
member.TypeData = simpleType;
member.ElementInfo.Add (CreateTextElementInfo (typeQName.Namespace, member, member.TypeData));
member.IsXmlTextCollector = true;
cmap.AddMember (member);
}
if (ext != null)
ImportAttributes (typeQName, cmap, ext.Attributes, ext.AnyAttribute, classIds);
}
internal string GenerateTypedSerializer(string readMethod, string writeMethod, XmlMapping mapping, CodeIdentifiers classes, string baseSerializer, string readerClass, string writerClass)
{
string serializerName = CodeIdentifier.MakeValid(Accessor.UnescapeName(mapping.Accessor.Mapping.TypeDesc.Name));
serializerName = classes.AddUnique(serializerName + "Serializer", mapping);
_writer.WriteLine();
_writer.Write("public sealed class ");
_writer.Write(CodeIdentifier.GetCSharpName(serializerName));
_writer.Write(" : ");
_writer.Write(baseSerializer);
_writer.WriteLine(" {");
_writer.Indent++;
_writer.WriteLine();
_writer.Write("public override ");
_writer.Write(typeof(bool).FullName);
_writer.Write(" CanDeserialize(");
_writer.Write(typeof(XmlReader).FullName);
_writer.WriteLine(" xmlReader) {");
_writer.Indent++;
if (mapping.Accessor.Any)
{
_writer.WriteLine("return true;");
}
else
{
_writer.Write("return xmlReader.IsStartElement(");
WriteQuotedCSharpString(mapping.Accessor.Name);
_writer.Write(", ");
WriteQuotedCSharpString(mapping.Accessor.Namespace);
_writer.WriteLine(");");
}
_writer.Indent--;
_writer.WriteLine("}");
if (writeMethod != null)
{
_writer.WriteLine();
_writer.Write("protected override void Serialize(object objectToSerialize, ");
_writer.Write(typeof(XmlSerializationWriter).FullName);
_writer.WriteLine(" writer) {");
_writer.Indent++;
_writer.Write("((");
_writer.Write(writerClass);
_writer.Write(")writer).");
_writer.Write(writeMethod);
_writer.Write("(");
if (mapping is XmlMembersMapping)
{
_writer.Write("(object[])");
}
_writer.WriteLine("objectToSerialize);");
_writer.Indent--;
_writer.WriteLine("}");
}
if (readMethod != null)
{
_writer.WriteLine();
_writer.Write("protected override object Deserialize(");
_writer.Write(typeof(XmlSerializationReader).FullName);
_writer.WriteLine(" reader) {");
_writer.Indent++;
_writer.Write("return ((");
_writer.Write(readerClass);
_writer.Write(")reader).");
_writer.Write(readMethod);
_writer.WriteLine("();");
_writer.Indent--;
_writer.WriteLine("}");
}
_writer.Indent--;
_writer.WriteLine("}");
return(serializerName);
}
void ImportComplexContent (XmlQualifiedName typeQName, XmlTypeMapping map, XmlSchemaComplexContent content, CodeIdentifiers classIds, bool isMixed)
{
ClassMap cmap = (ClassMap)map.ObjectMap;
XmlQualifiedName qname;
XmlSchemaComplexContentExtension ext = content.Content as XmlSchemaComplexContentExtension;
if (ext != null) qname = ext.BaseTypeName;
else qname = ((XmlSchemaComplexContentRestriction)content.Content).BaseTypeName;
if (qname == typeQName)
throw new InvalidOperationException ("Cannot import schema for type '" + typeQName.Name + "' from namespace '" + typeQName.Namespace + "'. Redefine not supported");
// Add base map members to this map
XmlTypeMapping baseMap = ImportClass (qname);
BuildPendingMap (baseMap);
ClassMap baseClassMap = (ClassMap)baseMap.ObjectMap;
foreach (XmlTypeMapMember member in baseClassMap.AllMembers)
cmap.AddMember (member);
if (baseClassMap.XmlTextCollector != null) isMixed = false;
else if (content.IsMixed) isMixed = true;
map.BaseMap = baseMap;
baseMap.DerivedTypes.Add (map);
if (ext != null) {
// Add the members of this map
ImportParticleComplexContent (typeQName, cmap, ext.Particle, classIds, isMixed);
ImportAttributes (typeQName, cmap, ext.Attributes, ext.AnyAttribute, classIds);
}
else {
if (isMixed) ImportParticleComplexContent (typeQName, cmap, null, classIds, true);
}
}
internal static Assembly GenerateAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Evidence evidence, XmlSerializerCompilerParameters parameters, Assembly assembly, Hashtable assemblies)
{
FileIOPermission.Assert();
Compiler compiler = new Compiler();
try {
Hashtable scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
TypeScope[] scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
assemblies.Clear();
Hashtable importedTypes = new Hashtable();
foreach (TypeScope scope in scopes)
{
foreach (Type t in scope.Types)
{
compiler.AddImport(t, importedTypes);
Assembly a = t.Assembly;
string name = a.FullName;
if (assemblies[name] != null)
{
continue;
}
if (!a.GlobalAssemblyCache)
{
assemblies[name] = a;
}
}
}
for (int i = 0; i < types.Length; i++)
{
compiler.AddImport(types[i], importedTypes);
}
compiler.AddImport(typeof(object).Assembly);
compiler.AddImport(typeof(XmlSerializer).Assembly);
IndentedWriter writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("#if _DYNAMIC_XMLSERIALIZER_COMPILATION");
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("[assembly:System.Security.SecurityTransparent()]");
writer.WriteLine("[assembly:System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]");
writer.WriteLine("#endif");
// Add AssemblyVersion attribute to match parent accembly version
if (types != null && types.Length > 0 && types[0] != null)
{
writer.WriteLine("[assembly:System.Reflection.AssemblyVersionAttribute(\"" + types[0].Assembly.GetName().Version.ToString() + "\")]");
}
if (assembly != null && types.Length > 0)
{
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type == null)
{
continue;
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
throw new InvalidOperationException(Res.GetString(Res.XmlPregenTypeDynamic, types[i].FullName));
}
}
writer.Write("[assembly:");
writer.Write(typeof(XmlSerializerVersionAttribute).FullName);
writer.Write("(");
writer.Write("ParentAssemblyId=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, GenerateAssemblyId(types[0]));
writer.Write(", Version=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, ThisAssembly.Version);
if (defaultNamespace != null)
{
writer.Write(", Namespace=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, defaultNamespace);
}
writer.WriteLine(")]");
}
CodeIdentifiers classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
writer.WriteLine("namespace " + GeneratedAssemblyNamespace + " {");
writer.Indent++;
writer.WriteLine();
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
XmlSerializationWriterCodeGen writerCodeGen = new XmlSerializationWriterCodeGen(writer, scopes, "public", writerClass);
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
writerCodeGen.GenerateEnd();
writer.WriteLine();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
XmlSerializationReaderCodeGen readerCodeGen = new XmlSerializationReaderCodeGen(writer, scopes, "public", readerClass);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
Hashtable serializers = new Hashtable();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (serializers[xmlMappings[i].Key] == null)
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
writer.Indent--;
writer.WriteLine("}");
return(compiler.Compile(assembly, defaultNamespace, parameters, evidence));
}
finally {
compiler.Close();
}
}
public XmlSchemaImporter (XmlSchemas schemas, CodeIdentifiers typeIdentifiers, CodeGenerationOptions options)
{
this.typeIdentifiers = typeIdentifiers;
this.schemas = schemas;
this.options = options;
InitializeExtensions ();
}
internal static Assembly GenerateRefEmitAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Evidence evidence)
{
Hashtable scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
TypeScope[] scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
string assemblyName = "Microsoft.GeneratedCode";
AssemblyBuilder assemblyBuilder = CodeGenerator.CreateAssemblyBuilder(AppDomain.CurrentDomain, assemblyName);
ConstructorInfo SecurityTransparentAttribute_ctor = typeof(SecurityTransparentAttribute).GetConstructor(
CodeGenerator.InstanceBindingFlags,
null,
CodeGenerator.EmptyTypeArray,
null
);
assemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(SecurityTransparentAttribute_ctor, new Object[0]));
ConstructorInfo AllowPartiallyTrustedCallersAttribute_ctor = typeof(AllowPartiallyTrustedCallersAttribute).GetConstructor(
CodeGenerator.InstanceBindingFlags,
null,
CodeGenerator.EmptyTypeArray,
null
);
assemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(AllowPartiallyTrustedCallersAttribute_ctor, new Object[0]));
ConstructorInfo SecurityRulesAttribute_ctor = typeof(SecurityRulesAttribute).GetConstructor(
CodeGenerator.InstanceBindingFlags,
null,
new Type[] { typeof(SecurityRuleSet) },
null
);
assemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(SecurityRulesAttribute_ctor, new Object[] { SecurityRuleSet.Level1 }));
// Add AssemblyVersion attribute to match parent accembly version
if (types != null && types.Length > 0 && types[0] != null)
{
ConstructorInfo AssemblyVersionAttribute_ctor = typeof(AssemblyVersionAttribute).GetConstructor(
CodeGenerator.InstanceBindingFlags,
null,
new Type[] { typeof(String) },
null
);
FileIOPermission.Assert();
string assemblyVersion = types[0].Assembly.GetName().Version.ToString();
FileIOPermission.RevertAssert();
assemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(AssemblyVersionAttribute_ctor, new Object[] { assemblyVersion }));
}
CodeIdentifiers classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
ModuleBuilder moduleBuilder = CodeGenerator.CreateModuleBuilder(assemblyBuilder, assemblyName);
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
XmlSerializationWriterILGen writerCodeGen = new XmlSerializationWriterILGen(scopes, "public", writerClass);
writerCodeGen.ModuleBuilder = moduleBuilder;
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
Type writerType = writerCodeGen.GenerateEnd();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
XmlSerializationReaderILGen readerCodeGen = new XmlSerializationReaderILGen(scopes, "public", readerClass);
readerCodeGen.ModuleBuilder = moduleBuilder;
readerCodeGen.CreatedTypes.Add(writerType.Name, writerType);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
Hashtable serializers = new Hashtable();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (serializers[xmlMappings[i].Key] == null)
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
if (DiagnosticsSwitches.KeepTempFiles.Enabled)
{
FileIOPermission.Assert();
assemblyBuilder.Save(assemblyName + ".dll");
}
return(writerType.Assembly);
}
public XmlTypeMapping ImportDerivedTypeMapping (XmlQualifiedName name, Type baseType, bool baseTypeCanBeIndirect)
{
XmlQualifiedName qname;
XmlSchemaType stype;
if (encodedFormat)
{
qname = name;
stype = schemas.Find (name, typeof (XmlSchemaComplexType)) as XmlSchemaComplexType;
if (stype == null) throw new InvalidOperationException ("Schema type '" + name + "' not found or not valid");
}
else
{
if (!LocateElement (name, out qname, out stype))
return null;
}
XmlTypeMapping map = GetRegisteredTypeMapping (qname, baseType);
if (map != null)
{
// If the type has already been imported, make sure that the map
// has the requested base type
SetMapBaseType (map, baseType);
map.UpdateRoot (name);
return map;
}
map = CreateTypeMapping (qname, SchemaTypes.Class, name);
if (stype != null) {
map.Documentation = GetDocumentation (stype);
RegisterMapFixup (map, qname, (XmlSchemaComplexType)stype);
} else {
ClassMap cmap = new ClassMap ();
CodeIdentifiers classIds = new CodeIdentifiers ();
map.ObjectMap = cmap;
AddTextMember (qname, cmap, classIds);
}
BuildPendingMaps ();
SetMapBaseType (map, baseType);
return map;
}
StructMapping ImportStructType(XmlSchemaComplexType type, string typeNs, bool excludeFromImport)
{
if (type.Name == null)
{
XmlSchemaElement element = (XmlSchemaElement)type.Parent;
XmlQualifiedName parentType = XmlSchemas.GetParentName(element);
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidSchemaElementType, parentType.Name, parentType.Namespace, element.Name));
}
TypeDesc baseTypeDesc = null;
Mapping baseMapping = null;
if (!type.DerivedFrom.IsEmpty)
{
baseMapping = ImportType(type.DerivedFrom, excludeFromImport);
if (baseMapping is StructMapping)
{
baseTypeDesc = ((StructMapping)baseMapping).TypeDesc;
}
else
{
baseMapping = null;
}
}
if (baseMapping == null)
{
baseMapping = GetRootMapping();
}
Mapping previousMapping = (Mapping)ImportedMappings[type];
if (previousMapping != null)
{
return((StructMapping)previousMapping);
}
string typeName = GenerateUniqueTypeName(Accessor.UnescapeName(type.Name));
StructMapping structMapping = new StructMapping();
structMapping.IsReference = Schemas.IsReference(type);
TypeFlags flags = TypeFlags.Reference;
if (type.IsAbstract)
{
flags |= TypeFlags.Abstract;
}
structMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Struct, baseTypeDesc, flags);
structMapping.Namespace = typeNs;
structMapping.TypeName = type.Name;
structMapping.BaseMapping = (StructMapping)baseMapping;
ImportedMappings.Add(type, structMapping);
if (excludeFromImport)
{
structMapping.IncludeInSchema = false;
}
CodeIdentifiers members = new CodeIdentifiers();
members.AddReserved(typeName);
AddReservedIdentifiersForDataBinding(members);
structMapping.Members = ImportTypeMembers(type, typeNs, members);
Scope.AddTypeMapping(structMapping);
ImportDerivedTypes(new XmlQualifiedName(type.Name, typeNs));
return(structMapping);
}
void BuildClassMap (XmlTypeMapping map, XmlQualifiedName typeQName, XmlSchemaComplexType stype)
{
CodeIdentifiers classIds = new CodeIdentifiers();
classIds.AddReserved (map.TypeData.TypeName);
ClassMap cmap = new ClassMap ();
map.ObjectMap = cmap;
bool isMixed = stype.IsMixed;
if (stype.Particle != null)
ImportParticleComplexContent (typeQName, cmap, stype.Particle, classIds, isMixed);
else
{
if (stype.ContentModel is XmlSchemaSimpleContent) {
ImportSimpleContent (typeQName, map, (XmlSchemaSimpleContent)stype.ContentModel, classIds, isMixed);
}
else if (stype.ContentModel is XmlSchemaComplexContent) {
ImportComplexContent (typeQName, map, (XmlSchemaComplexContent)stype.ContentModel, classIds, isMixed);
}
}
ImportAttributes (typeQName, cmap, stype.Attributes, stype.AnyAttribute, classIds);
ImportExtensionTypes (typeQName);
if (isMixed) AddTextMember (typeQName, cmap, classIds);
AddObjectDerivedMap (map);
}
/// <include file='doc\SoapSchemaImporter.uex' path='docs/doc[@for="SoapSchemaImporter.SoapSchemaImporter2"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public SoapSchemaImporter(XmlSchemas schemas, CodeIdentifiers typeIdentifiers, CodeGenerationOptions options) : base(schemas, options, null, new ImportContext(typeIdentifiers, false))
{
}
ListMap BuildArrayMap (XmlQualifiedName typeQName, XmlSchemaComplexType stype, out TypeData arrayTypeData)
{
if (encodedFormat)
{
XmlSchemaComplexContent content = stype.ContentModel as XmlSchemaComplexContent;
XmlSchemaComplexContentRestriction rest = content.Content as XmlSchemaComplexContentRestriction;
XmlSchemaAttribute arrayTypeAt = FindArrayAttribute (rest.Attributes);
if (arrayTypeAt != null)
{
XmlAttribute[] uatts = arrayTypeAt.UnhandledAttributes;
if (uatts == null || uatts.Length == 0) throw new InvalidOperationException ("arrayType attribute not specified in array declaration: " + typeQName);
XmlAttribute xat = null;
foreach (XmlAttribute at in uatts)
if (at.LocalName == "arrayType" && at.NamespaceURI == XmlSerializer.WsdlNamespace)
{ xat = at; break; }
if (xat == null)
throw new InvalidOperationException ("arrayType attribute not specified in array declaration: " + typeQName);
string name, ns, dims;
TypeTranslator.ParseArrayType (xat.Value, out name, out ns, out dims);
return BuildEncodedArrayMap (name + dims, ns, out arrayTypeData);
}
else
{
XmlSchemaElement elem = null;
XmlSchemaSequence seq = rest.Particle as XmlSchemaSequence;
if (seq != null && seq.Items.Count == 1)
elem = seq.Items[0] as XmlSchemaElement;
else {
XmlSchemaAll all = rest.Particle as XmlSchemaAll;
if (all != null && all.Items.Count == 1)
elem = all.Items[0] as XmlSchemaElement;
}
if (elem == null)
throw new InvalidOperationException ("Unknown array format");
return BuildEncodedArrayMap (elem.SchemaTypeName.Name + "[]", elem.SchemaTypeName.Namespace, out arrayTypeData);
}
}
else
{
ClassMap cmap = new ClassMap ();
CodeIdentifiers classIds = new CodeIdentifiers();
ImportParticleComplexContent (typeQName, cmap, stype.Particle, classIds, stype.IsMixed);
XmlTypeMapMemberFlatList list = (cmap.AllMembers.Count == 1) ? cmap.AllMembers[0] as XmlTypeMapMemberFlatList : null;
if (list != null && list.ChoiceMember == null)
{
arrayTypeData = list.TypeData;
return list.ListMap;
}
else
{
arrayTypeData = null;
return null;
}
}
}
TypeMapping ImportEnumeratedDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, bool isList)
{
TypeMapping mapping = (TypeMapping)ImportedMappings[dataType];
if (mapping != null)
{
return(mapping);
}
XmlSchemaSimpleType sourceDataType = FindDataType(dataType.DerivedFrom);
TypeDesc sourceTypeDesc = Scope.GetTypeDesc(sourceDataType);
if (sourceTypeDesc != null && sourceTypeDesc != Scope.GetTypeDesc(typeof(string)))
{
return(ImportPrimitiveDataType(dataType));
}
identifier = Accessor.UnescapeName(identifier);
string typeName = GenerateUniqueTypeName(identifier);
EnumMapping enumMapping = new EnumMapping();
enumMapping.IsReference = Schemas.IsReference(dataType);
enumMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Enum, null, 0);
enumMapping.TypeName = identifier;
enumMapping.Namespace = typeNs;
enumMapping.IsFlags = isList;
CodeIdentifiers constants = new CodeIdentifiers();
if (!(dataType.Content is XmlSchemaSimpleTypeRestriction))
{
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidEnumContent, dataType.Content.GetType().Name, identifier));
}
XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)dataType.Content;
for (int i = 0; i < restriction.Facets.Count; i++)
{
object facet = restriction.Facets[i];
if (!(facet is XmlSchemaEnumerationFacet))
{
continue;
}
XmlSchemaEnumerationFacet enumeration = (XmlSchemaEnumerationFacet)facet;
ConstantMapping constant = new ConstantMapping();
string constantName = CodeIdentifier.MakeValid(enumeration.Value);
constant.Name = constants.AddUnique(constantName, constant);
constant.XmlName = enumeration.Value;
constant.Value = i;
}
enumMapping.Constants = (ConstantMapping[])constants.ToArray(typeof(ConstantMapping));
if (isList && enumMapping.Constants.Length > 63)
{
// if we have 64+ flag constants we cannot map the type to long enum, we will use string mapping instead.
mapping = new PrimitiveMapping();
mapping.TypeDesc = Scope.GetTypeDesc(typeof(string));
mapping.TypeName = mapping.TypeDesc.DataType.Name;
ImportedMappings.Add(dataType, mapping);
return(mapping);
}
ImportedMappings.Add(dataType, enumMapping);
Scope.AddTypeMapping(enumMapping);
return(enumMapping);
}
void ImportParticleComplexContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaParticle particle, CodeIdentifiers classIds, bool isMixed)
{
ImportParticleContent (typeQName, cmap, particle, classIds, false, ref isMixed);
if (isMixed) AddTextMember (typeQName, cmap, classIds);
}
internal string GenerateBaseSerializer(string baseSerializer, string readerClass, string writerClass, CodeIdentifiers classes)
{
baseSerializer = CodeIdentifier.MakeValid(baseSerializer);
baseSerializer = classes.AddUnique(baseSerializer, baseSerializer);
TypeBuilder baseSerializerTypeBuilder = CodeGenerator.CreateTypeBuilder(
_moduleBuilder,
CodeIdentifier.GetCSharpName(baseSerializer),
TypeAttributes.Public | TypeAttributes.Abstract | TypeAttributes.BeforeFieldInit,
typeof(XmlSerializer),
Array.Empty <Type>());
ConstructorInfo readerCtor = CreatedTypes[readerClass].GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty <Type>()
);
ilg = new CodeGenerator(baseSerializerTypeBuilder);
ilg.BeginMethod(typeof(XmlSerializationReader),
"CreateReader",
Array.Empty <Type>(),
Array.Empty <string>(),
CodeGenerator.ProtectedOverrideMethodAttributes);
ilg.New(readerCtor);
ilg.EndMethod();
ConstructorInfo writerCtor = CreatedTypes[writerClass].GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty <Type>()
);
ilg.BeginMethod(typeof(XmlSerializationWriter),
"CreateWriter",
Array.Empty <Type>(),
Array.Empty <string>(),
CodeGenerator.ProtectedOverrideMethodAttributes);
ilg.New(writerCtor);
ilg.EndMethod();
baseSerializerTypeBuilder.DefineDefaultConstructor(
MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
Type baseSerializerType = baseSerializerTypeBuilder.CreateTypeInfo().AsType();
CreatedTypes.Add(baseSerializerType.Name, baseSerializerType);
return(baseSerializer);
}
void ImportParticleContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaParticle particle, CodeIdentifiers classIds, bool multiValue, ref bool isMixed)
{
if (particle == null) return;
if (particle is XmlSchemaGroupRef)
particle = GetRefGroupParticle ((XmlSchemaGroupRef)particle);
if (particle.MaxOccurs > 1) multiValue = true;
if (particle is XmlSchemaSequence) {
ImportSequenceContent (typeQName, cmap, ((XmlSchemaSequence)particle).Items, classIds, multiValue, ref isMixed);
}
else if (particle is XmlSchemaChoice) {
if (((XmlSchemaChoice)particle).Items.Count == 1)
ImportSequenceContent (typeQName, cmap, ((XmlSchemaChoice)particle).Items, classIds, multiValue, ref isMixed);
else
ImportChoiceContent (typeQName, cmap, (XmlSchemaChoice)particle, classIds, multiValue);
}
else if (particle is XmlSchemaAll) {
ImportSequenceContent (typeQName, cmap, ((XmlSchemaAll)particle).Items, classIds, multiValue, ref isMixed);
}
}
internal void Reflect (ServiceDescriptionReflector serviceReflector, Type type, string url, XmlSchemaExporter xxporter, SoapSchemaExporter sxporter)
{
portNames = new CodeIdentifiers ();
this.serviceReflector = serviceReflector;
serviceUrl = url;
serviceType = type;
schemaExporter = xxporter;
soapSchemaExporter = sxporter;
typeInfo = TypeStubManager.GetTypeStub (type, ProtocolName);
ServiceDescription desc = ServiceDescriptions [typeInfo.LogicalType.WebServiceNamespace];
if (desc == null)
{
desc = new ServiceDescription ();
desc.TargetNamespace = typeInfo.LogicalType.WebServiceNamespace;
desc.Name = typeInfo.LogicalType.WebServiceName;
ServiceDescriptions.Add (desc);
}
ImportService (desc, typeInfo, url);
}
public XmlSchemaImporter (XmlSchemas schemas, CodeIdentifiers typeIdentifiers)
: this (schemas)
{
this.typeIdentifiers = typeIdentifiers;
}
public SoapSchemaImporter(XmlSchemas schemas, CodeIdentifiers typeIdentifiers) : base(schemas, CodeGenerationOptions.GenerateProperties, null, new System.Xml.Serialization.ImportContext(typeIdentifiers, false))
{
}
private void ExportProperty(CodeTypeDeclaration codeClass, MemberMapping member, string ns, CodeIdentifiers memberScope, CodeConstructor ctor)
{
string name = memberScope.AddUnique(CodeExporter.MakeFieldName(member.Name), member);
string typeName = member.GetTypeName(base.CodeProvider);
CodeMemberField field = new CodeMemberField(typeName, name)
{
Attributes = MemberAttributes.Private
};
codeClass.Members.Add(field);
CodeMemberProperty property = base.CreatePropertyDeclaration(field, member.Name, typeName);
property.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true));
this.AddMemberMetadata(field, property.CustomAttributes, member, ns, false, property.Comments, ctor);
codeClass.Members.Add(property);
if (member.CheckSpecified != SpecifiedAccessor.None)
{
field = new CodeMemberField(typeof(bool).FullName, name + "Specified")
{
Attributes = MemberAttributes.Private
};
codeClass.Members.Add(field);
property = base.CreatePropertyDeclaration(field, member.Name + "Specified", typeof(bool).FullName);
property.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true));
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(typeof(XmlIgnoreAttribute).FullName);
property.CustomAttributes.Add(declaration);
codeClass.Members.Add(property);
}
}
StructMapping ImportStructType(XmlSchemaComplexType type, string typeNs, bool excludeFromImport)
{
if (type.Name == null)
{
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidSchemaType));
}
TypeDesc baseTypeDesc = null;
Mapping baseMapping = null;
if (!type.DerivedFrom.IsEmpty)
{
baseMapping = ImportType(type.DerivedFrom, excludeFromImport);
if (baseMapping is StructMapping)
{
baseTypeDesc = ((StructMapping)baseMapping).TypeDesc;
}
else
{
baseMapping = null;
}
}
if (baseMapping == null)
{
baseMapping = GetRootMapping();
}
Mapping previousMapping = (Mapping)mappings[type];
if (previousMapping != null)
{
return((StructMapping)previousMapping);
}
string typeName = GenerateUniqueTypeName(type.Name);
StructMapping structMapping = new StructMapping();
TypeFlags flags = TypeFlags.Reference;
if (type.IsAbstract)
{
flags |= TypeFlags.Abstract;
}
structMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Struct, baseTypeDesc, flags);
structMapping.Namespace = typeNs;
structMapping.TypeName = type.Name;
if (!excludeFromImport)
{
structMapping.BaseMapping = (StructMapping)baseMapping;
mappings.Add(type, structMapping);
}
CodeIdentifiers members = new CodeIdentifiers();
members.AddReserved(typeName);
structMapping.Members = ImportTypeMembers(type, typeNs, members);
if (!excludeFromImport)
{
scope.AddTypeMapping(structMapping);
}
ImportDerivedTypes(new XmlQualifiedName(type.Name, typeNs));
return(structMapping);
}
internal string GenerateTypedSerializer(string readMethod, string writeMethod, XmlMapping mapping, CodeIdentifiers classes, string baseSerializer, string readerClass, string writerClass)
{
string serializerName = CodeIdentifier.MakeValid(Accessor.UnescapeName(mapping.Accessor.Mapping.TypeDesc.Name));
serializerName = classes.AddUnique(serializerName + "Serializer", mapping);
TypeBuilder typedSerializerTypeBuilder = CodeGenerator.CreateTypeBuilder(
_moduleBuilder,
CodeIdentifier.GetCSharpName(serializerName),
TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit,
CreatedTypes[baseSerializer],
Array.Empty <Type>()
);
ilg = new CodeGenerator(typedSerializerTypeBuilder);
ilg.BeginMethod(
typeof(Boolean),
"CanDeserialize",
new Type[] { typeof(XmlReader) },
new string[] { "xmlReader" },
CodeGenerator.PublicOverrideMethodAttributes
);
if (mapping.Accessor.Any)
{
ilg.Ldc(true);
ilg.Stloc(ilg.ReturnLocal);
ilg.Br(ilg.ReturnLabel);
}
else
{
MethodInfo XmlReader_IsStartElement = typeof(XmlReader).GetMethod(
"IsStartElement",
CodeGenerator.InstanceBindingFlags,
new Type[] { typeof(String), typeof(String) }
);
ilg.Ldarg(ilg.GetArg("xmlReader"));
ilg.Ldstr(GetCSharpString(mapping.Accessor.Name));
ilg.Ldstr(GetCSharpString(mapping.Accessor.Namespace));
ilg.Call(XmlReader_IsStartElement);
ilg.Stloc(ilg.ReturnLocal);
ilg.Br(ilg.ReturnLabel);
}
ilg.MarkLabel(ilg.ReturnLabel);
ilg.Ldloc(ilg.ReturnLocal);
ilg.EndMethod();
if (writeMethod != null)
{
ilg = new CodeGenerator(typedSerializerTypeBuilder);
ilg.BeginMethod(
typeof(void),
"Serialize",
new Type[] { typeof(object), typeof(XmlSerializationWriter) },
new string[] { "objectToSerialize", "writer" },
CodeGenerator.ProtectedOverrideMethodAttributes);
MethodInfo writerType_writeMethod = CreatedTypes[writerClass].GetMethod(
writeMethod,
CodeGenerator.InstanceBindingFlags,
new Type[] { (mapping is XmlMembersMapping) ? typeof(object[]) : typeof(object) }
);
ilg.Ldarg("writer");
ilg.Castclass(CreatedTypes[writerClass]);
ilg.Ldarg("objectToSerialize");
if (mapping is XmlMembersMapping)
{
ilg.ConvertValue(typeof(object), typeof(object[]));
}
ilg.Call(writerType_writeMethod);
ilg.EndMethod();
}
if (readMethod != null)
{
ilg = new CodeGenerator(typedSerializerTypeBuilder);
ilg.BeginMethod(
typeof(object),
"Deserialize",
new Type[] { typeof(XmlSerializationReader) },
new string[] { "reader" },
CodeGenerator.ProtectedOverrideMethodAttributes);
MethodInfo readerType_readMethod = CreatedTypes[readerClass].GetMethod(
readMethod,
CodeGenerator.InstanceBindingFlags,
Array.Empty <Type>()
);
ilg.Ldarg("reader");
ilg.Castclass(CreatedTypes[readerClass]);
ilg.Call(readerType_readMethod);
ilg.EndMethod();
}
typedSerializerTypeBuilder.DefineDefaultConstructor(CodeGenerator.PublicMethodAttributes);
Type typedSerializerType = typedSerializerTypeBuilder.CreateTypeInfo().AsType();
CreatedTypes.Add(typedSerializerType.Name, typedSerializerType);
return(typedSerializerType.Name);
}
private StructMapping ImportStructType(XmlSchemaComplexType type, string typeNs, bool excludeFromImport)
{
if (type.Name == null)
{
XmlSchemaElement parent = (XmlSchemaElement)type.Parent;
XmlQualifiedName parentName = XmlSchemas.GetParentName(parent);
throw new InvalidOperationException(Res.GetString("XmlInvalidSchemaElementType", new object[] { parentName.Name, parentName.Namespace, parent.Name }));
}
TypeDesc baseTypeDesc = null;
Mapping rootMapping = null;
if (!type.DerivedFrom.IsEmpty)
{
rootMapping = this.ImportType(type.DerivedFrom, excludeFromImport);
if (rootMapping is StructMapping)
{
baseTypeDesc = ((StructMapping)rootMapping).TypeDesc;
}
else
{
rootMapping = null;
}
}
if (rootMapping == null)
{
rootMapping = base.GetRootMapping();
}
Mapping mapping2 = (Mapping)base.ImportedMappings[type];
if (mapping2 != null)
{
return((StructMapping)mapping2);
}
string str = base.GenerateUniqueTypeName(Accessor.UnescapeName(type.Name));
StructMapping mapping3 = new StructMapping {
IsReference = base.Schemas.IsReference(type)
};
TypeFlags reference = TypeFlags.Reference;
if (type.IsAbstract)
{
reference |= TypeFlags.Abstract;
}
mapping3.TypeDesc = new TypeDesc(str, str, TypeKind.Struct, baseTypeDesc, reference);
mapping3.Namespace = typeNs;
mapping3.TypeName = type.Name;
mapping3.BaseMapping = (StructMapping)rootMapping;
base.ImportedMappings.Add(type, mapping3);
if (excludeFromImport)
{
mapping3.IncludeInSchema = false;
}
CodeIdentifiers scope = new CodeIdentifiers();
scope.AddReserved(str);
base.AddReservedIdentifiersForDataBinding(scope);
mapping3.Members = this.ImportTypeMembers(type, typeNs, scope);
base.Scope.AddTypeMapping(mapping3);
this.ImportDerivedTypes(new XmlQualifiedName(type.Name, typeNs));
return(mapping3);
}
internal string GenerateTypedSerializer(string readMethod, string writeMethod, XmlMapping mapping, CodeIdentifiers classes, string baseSerializer, string readerClass, string writerClass) {
string serializerName = CodeIdentifier.MakeValid(Accessor.UnescapeName(mapping.Accessor.Mapping.TypeDesc.Name));
serializerName = classes.AddUnique(serializerName + "Serializer", mapping);
writer.WriteLine();
writer.Write("public sealed class ");
writer.Write(CodeIdentifier.GetCSharpName(serializerName));
writer.Write(" : ");
writer.Write(baseSerializer);
writer.WriteLine(" {");
writer.Indent++;
writer.WriteLine();
writer.Write("public override ");
writer.Write(typeof(bool).FullName);
writer.Write(" CanDeserialize(");
writer.Write(typeof(XmlReader).FullName);
writer.WriteLine(" xmlReader) {");
writer.Indent++;
if (mapping.Accessor.Any) {
writer.WriteLine("return true;");
}
else {
writer.Write("return xmlReader.IsStartElement(");
WriteQuotedCSharpString(mapping.Accessor.Name);
writer.Write(", ");
WriteQuotedCSharpString(mapping.Accessor.Namespace);
writer.WriteLine(");");
}
writer.Indent--;
writer.WriteLine("}");
if (writeMethod != null) {
writer.WriteLine();
writer.Write("protected override void Serialize(object objectToSerialize, ");
writer.Write(typeof(XmlSerializationWriter).FullName);
writer.WriteLine(" writer) {");
writer.Indent++;
writer.Write("((");
writer.Write(writerClass);
writer.Write(")writer).");
writer.Write(writeMethod);
writer.Write("(");
if (mapping is XmlMembersMapping) {
writer.Write("(object[])");
}
writer.WriteLine("objectToSerialize);");
writer.Indent--;
writer.WriteLine("}");
}
if (readMethod != null) {
writer.WriteLine();
writer.Write("protected override object Deserialize(");
writer.Write(typeof(XmlSerializationReader).FullName);
writer.WriteLine(" reader) {");
writer.Indent++;
writer.Write("return ((");
writer.Write(readerClass);
writer.Write(")reader).");
writer.Write(readMethod);
writer.WriteLine("();");
writer.Indent--;
writer.WriteLine("}");
}
writer.Indent--;
writer.WriteLine("}");
return serializerName;
}
internal static Assembly GenerateAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Evidence evidence, XmlSerializerCompilerParameters parameters, Assembly assembly, Hashtable assemblies)
{
Assembly assembly3;
FileIOPermission.Assert();
for (int i = 0; i < xmlMappings.Length; i++)
{
xmlMappings[i].CheckShallow();
}
Compiler compiler = new Compiler();
try
{
Hashtable hashtable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
hashtable[mapping.Scope] = mapping;
}
TypeScope[] array = new TypeScope[hashtable.Keys.Count];
hashtable.Keys.CopyTo(array, 0);
assemblies.Clear();
Hashtable hashtable2 = new Hashtable();
foreach (TypeScope scope in array)
{
foreach (Type type in scope.Types)
{
compiler.AddImport(type, hashtable2);
Assembly assembly2 = type.Assembly;
string fullName = assembly2.FullName;
if ((assemblies[fullName] == null) && !assembly2.GlobalAssemblyCache)
{
assemblies[fullName] = assembly2;
}
}
}
for (int j = 0; j < types.Length; j++)
{
compiler.AddImport(types[j], hashtable2);
}
compiler.AddImport(typeof(object).Assembly);
compiler.AddImport(typeof(XmlSerializer).Assembly);
IndentedWriter writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("#if _DYNAMIC_XMLSERIALIZER_COMPILATION");
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("[assembly:System.Security.SecurityTransparent()]");
writer.WriteLine("[assembly:System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]");
writer.WriteLine("#endif");
if (((types != null) && (types.Length > 0)) && (types[0] != null))
{
writer.WriteLine("[assembly:System.Reflection.AssemblyVersionAttribute(\"" + types[0].Assembly.GetName().Version.ToString() + "\")]");
}
if ((assembly != null) && (types.Length > 0))
{
for (int num3 = 0; num3 < types.Length; num3++)
{
Type type2 = types[num3];
if ((type2 != null) && DynamicAssemblies.IsTypeDynamic(type2))
{
throw new InvalidOperationException(Res.GetString("XmlPregenTypeDynamic", new object[] { types[num3].FullName }));
}
}
writer.Write("[assembly:");
writer.Write(typeof(XmlSerializerVersionAttribute).FullName);
writer.Write("(");
writer.Write("ParentAssemblyId=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, GenerateAssemblyId(types[0]));
writer.Write(", Version=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, "4.0.0.0");
if (defaultNamespace != null)
{
writer.Write(", Namespace=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, defaultNamespace);
}
writer.WriteLine(")]");
}
CodeIdentifiers classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string str2 = null;
if (((types != null) && (types.Length == 1)) && (types[0] != null))
{
str2 = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
str2 = str2 + "Array";
}
}
writer.WriteLine("namespace Microsoft.Xml.Serialization.GeneratedAssembly {");
writer.Indent++;
writer.WriteLine();
string identifier = "XmlSerializationWriter" + str2;
identifier = classes.AddUnique(identifier, identifier);
XmlSerializationWriterCodeGen gen = new XmlSerializationWriterCodeGen(writer, array, "public", identifier);
gen.GenerateBegin();
string[] writerMethods = new string[xmlMappings.Length];
for (int k = 0; k < xmlMappings.Length; k++)
{
writerMethods[k] = gen.GenerateElement(xmlMappings[k]);
}
gen.GenerateEnd();
writer.WriteLine();
string str4 = "XmlSerializationReader" + str2;
str4 = classes.AddUnique(str4, str4);
XmlSerializationReaderCodeGen gen2 = new XmlSerializationReaderCodeGen(writer, array, "public", str4);
gen2.GenerateBegin();
string[] methods = new string[xmlMappings.Length];
for (int m = 0; m < xmlMappings.Length; m++)
{
methods[m] = gen2.GenerateElement(xmlMappings[m]);
}
gen2.GenerateEnd(methods, xmlMappings, types);
string baseSerializer = gen2.GenerateBaseSerializer("XmlSerializer1", str4, identifier, classes);
Hashtable serializers = new Hashtable();
for (int n = 0; n < xmlMappings.Length; n++)
{
if (serializers[xmlMappings[n].Key] == null)
{
serializers[xmlMappings[n].Key] = gen2.GenerateTypedSerializer(methods[n], writerMethods[n], xmlMappings[n], classes, baseSerializer, str4, identifier);
}
}
gen2.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, str4, methods, identifier, writerMethods, serializers);
writer.Indent--;
writer.WriteLine("}");
assembly3 = compiler.Compile(assembly, defaultNamespace, parameters, evidence);
}
finally
{
compiler.Close();
}
return assembly3;
}
