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(); } }
internal static Assembly GenerateAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Evidence evidence, CompilerParameters parameters, Assembly assembly, Hashtable assemblies) { FileIOPermission.Assert(); for (int i = 0; i < xmlMappings.Length; i++) { xmlMappings[i].CheckShallow(); } 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("#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(); } }
ArrayMapping ImportArrayMapping(XmlSchemaType type, string ns) { if (!(type.DerivedFrom.Name == Soap.Array && type.DerivedFrom.Namespace == Soap.Encoding)) { return(null); } // the type should be a XmlSchemaComplexType XmlSchemaContentModel model = ((XmlSchemaComplexType)type).ContentModel; // the Content should be an restriction if (!(model.Content is XmlSchemaComplexContentRestriction)) { return(null); } ArrayMapping arrayMapping = new ArrayMapping(); XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction)model.Content; for (int i = 0; i < restriction.Attributes.Count; i++) { XmlSchemaAttribute attribute = restriction.Attributes[i] as XmlSchemaAttribute; if (attribute != null && attribute.RefName.Name == Soap.ArrayType && attribute.RefName.Namespace == Soap.Encoding) { // read the value of the wsdl:arrayType attribute string arrayType = null; if (attribute.UnhandledAttributes != null) { foreach (XmlAttribute a in attribute.UnhandledAttributes) { if (a.LocalName == Wsdl.ArrayType && a.NamespaceURI == Wsdl.Namespace) { arrayType = a.Value; break; } } } if (arrayType != null) { string dims; XmlQualifiedName typeName = TypeScope.ParseWsdlArrayType(arrayType, out dims, attribute); TypeMapping mapping; TypeDesc td = scope.GetTypeDesc(typeName); if (td != null && td.IsPrimitive) { mapping = new PrimitiveMapping(); mapping.TypeDesc = td; mapping.TypeName = td.DataType.Name; } else { mapping = ImportType(typeName, false); } ElementAccessor itemAccessor = new ElementAccessor(); itemAccessor.IsSoap = true; itemAccessor.Name = typeName.Name; itemAccessor.Namespace = ns; itemAccessor.Mapping = mapping; itemAccessor.IsNullable = true; itemAccessor.Form = XmlSchemaForm.None; arrayMapping.Elements = new ElementAccessor[] { itemAccessor }; arrayMapping.TypeDesc = itemAccessor.Mapping.TypeDesc.CreateArrayTypeDesc(); arrayMapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(itemAccessor.Mapping.TypeName); return(arrayMapping); } } } XmlSchemaParticle particle = restriction.Particle; if (particle is XmlSchemaAll || particle is XmlSchemaSequence) { XmlSchemaGroupBase group = (XmlSchemaGroupBase)particle; if (group.Items.Count != 1 || !(group.Items[0] is XmlSchemaElement)) { return(null); } XmlSchemaElement itemElement = (XmlSchemaElement)group.Items[0]; if (!itemElement.IsMultipleOccurrence) { return(null); } ElementAccessor itemAccessor = ImportElement(itemElement, ns); arrayMapping.Elements = new ElementAccessor[] { itemAccessor }; arrayMapping.TypeDesc = ((TypeMapping)itemAccessor.Mapping).TypeDesc.CreateArrayTypeDesc(); } else { return(null); } return(arrayMapping); }
internal static string MakeFieldName(string name) { return(CodeIdentifier.MakeCamel(name) + "Field"); }
internal string GenerateUniqueTypeName(string typeName) { typeName = CodeIdentifier.MakeValid(typeName); return(TypeIdentifiers.AddUnique(typeName, typeName)); }
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; }
internal string GenerateTypedSerializer(string readMethod, string writeMethod, XmlMapping mapping, CodeIdentifiers classes, string baseSerializer, string readerClass, string writerClass) { string name = CodeIdentifier.MakeValid(Accessor.UnescapeName(mapping.Accessor.Mapping.TypeDesc.Name)); name = classes.AddUnique(name + "Serializer", mapping); this.writer.WriteLine(); this.writer.Write("public sealed class "); this.writer.Write(CodeIdentifier.GetCSharpName(name)); this.writer.Write(" : "); this.writer.Write(baseSerializer); this.writer.WriteLine(" {"); this.writer.Indent++; this.writer.WriteLine(); this.writer.Write("public override "); this.writer.Write(typeof(bool).FullName); this.writer.Write(" CanDeserialize("); this.writer.Write(typeof(XmlReader).FullName); this.writer.WriteLine(" xmlReader) {"); this.writer.Indent++; if (mapping.Accessor.Any) { this.writer.WriteLine("return true;"); } else { this.writer.Write("return xmlReader.IsStartElement("); this.WriteQuotedCSharpString(mapping.Accessor.Name); this.writer.Write(", "); this.WriteQuotedCSharpString(mapping.Accessor.Namespace); this.writer.WriteLine(");"); } this.writer.Indent--; this.writer.WriteLine("}"); if (writeMethod != null) { this.writer.WriteLine(); this.writer.Write("protected override void Serialize(object objectToSerialize, "); this.writer.Write(typeof(XmlSerializationWriter).FullName); this.writer.WriteLine(" writer) {"); this.writer.Indent++; this.writer.Write("(("); this.writer.Write(writerClass); this.writer.Write(")writer)."); this.writer.Write(writeMethod); this.writer.Write("("); if (mapping is XmlMembersMapping) { this.writer.Write("(object[])"); } this.writer.WriteLine("objectToSerialize);"); this.writer.Indent--; this.writer.WriteLine("}"); } if (readMethod != null) { this.writer.WriteLine(); this.writer.Write("protected override object Deserialize("); this.writer.Write(typeof(XmlSerializationReader).FullName); this.writer.WriteLine(" reader) {"); this.writer.Indent++; this.writer.Write("return (("); this.writer.Write(readerClass); this.writer.Write(")reader)."); this.writer.Write(readMethod); this.writer.WriteLine("();"); this.writer.Indent--; this.writer.WriteLine("}"); } this.writer.Indent--; this.writer.WriteLine("}"); return(name); }
public static TypeData GetTypeData(Type runtimeType, string xmlDataType) { Type type = runtimeType; bool nullableOverride = false; #if NET_2_0 // Nullable<T> is serialized as T if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>)) { nullableOverride = true; type = type.GetGenericArguments() [0]; TypeData pt = GetTypeData(type); // beware this recursive call btw ... if (pt != null) { TypeData tt = (TypeData)nullableTypes [pt.XmlType]; #if TARGET_JVM if (tt == null) { tt = (TypeData)AppDomain_nullableTypes [pt.XmlType]; } #endif if (tt == null) { tt = new TypeData(type, pt.XmlType, false); tt.IsNullable = true; #if TARGET_JVM AppDomain_nullableTypes [pt.XmlType] = tt; #else nullableTypes [pt.XmlType] = tt; #endif } return(tt); } } #endif if ((xmlDataType != null) && (xmlDataType.Length != 0)) { // If the type is an array, xmlDataType specifies the type for the array elements, // not for the whole array. The exception is base64Binary, since it is a byte[], // that's why the following check is needed. TypeData at = GetPrimitiveTypeData(xmlDataType); if (type.IsArray && type != at.Type) { TypeData tt = (TypeData)primitiveArrayTypes [xmlDataType]; if (tt != null) { return(tt); } if (at.Type == type.GetElementType()) { tt = new TypeData(type, GetArrayName(at.XmlType), false); primitiveArrayTypes [xmlDataType] = tt; return(tt); } else { throw new InvalidOperationException("Cannot convert values of type '" + type.GetElementType() + "' to '" + xmlDataType + "'"); } } return(at); } TypeData typeData = nameCache[runtimeType] as TypeData; if (typeData != null) { return(typeData); } #if TARGET_JVM Hashtable dynamicCache = AppDomain_nameCache; typeData = dynamicCache[runtimeType] as TypeData; if (typeData != null) { return(typeData); } #endif string name; if (type.IsArray) { string sufix = GetTypeData(type.GetElementType()).XmlType; name = GetArrayName(sufix); } #if NET_2_0 else if (type.IsGenericType && !type.IsGenericTypeDefinition) { name = XmlConvert.EncodeLocalName(type.Name.Substring(0, type.Name.IndexOf('`'))) + "Of"; foreach (Type garg in type.GetGenericArguments()) { name += garg.IsArray || garg.IsGenericType ? GetTypeData(garg).XmlType : CodeIdentifier.MakePascal(XmlConvert.EncodeLocalName(garg.Name)); } } #endif else { name = XmlConvert.EncodeLocalName(type.Name); } typeData = new TypeData(type, name, false); if (nullableOverride) { typeData.IsNullable = true; } #if TARGET_JVM dynamicCache[runtimeType] = typeData; #else nameCache[runtimeType] = typeData; #endif return(typeData); }
void AddDefaultValueAttribute(CodeMemberField field, CodeAttributeDeclarationCollection metadata, object value, TypeMapping mapping) { #if DEBUG // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe if (!(mapping is PrimitiveMapping)) { throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Default value is invalid for " + mapping.GetType().Name)); } else if (mapping.IsList) { throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Default value is invalid for " + mapping.GetType().Name)); } #endif if (value == null) { return; } CodeExpression valueExpression = null; CodeExpression initExpression = null; CodeExpression typeofValue = null; string typeName = mapping.TypeDesc.FullName; Type type = value.GetType(); CodeAttributeArgument[] arguments = null; if (mapping is EnumMapping) { #if DEBUG // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe if (value.GetType() != typeof(string)) { throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Invalid enumeration type " + value.GetType().Name)); } #endif if (((EnumMapping)mapping).IsFlags) { string[] values = ((string)value).Split(null); for (int i = 0; i < values.Length; i++) { if (values[i].Length == 0) { continue; } CodeExpression enumRef = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeName), values[i]); if (valueExpression != null) { valueExpression = new CodeBinaryOperatorExpression(valueExpression, CodeBinaryOperatorType.BitwiseOr, enumRef); } else { valueExpression = enumRef; } } } else { valueExpression = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeName), (string)value); } initExpression = valueExpression; arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(valueExpression) }; } else if (type == typeof(bool) || type == typeof(Int32) || type == typeof(string) || type == typeof(double)) { initExpression = valueExpression = new CodePrimitiveExpression(value); arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(valueExpression) }; } else if (type == typeof(Int16) || type == typeof(Int64) || type == typeof(float) || type == typeof(byte) || type == typeof(decimal)) { valueExpression = new CodePrimitiveExpression(value.ToString()); typeofValue = new CodeTypeOfExpression(CodeIdentifier.EscapeKeywords(type.FullName)); arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) }; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (type == typeof(sbyte) || type == typeof(UInt16) || type == typeof(UInt32) || type == typeof(UInt64)) { // need to promote the non-CLS complient types value = PromoteType(type, value); valueExpression = new CodePrimitiveExpression(value.ToString()); typeofValue = new CodeTypeOfExpression(CodeIdentifier.EscapeKeywords(type.FullName)); arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) }; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (type == typeof(DateTime)) { DateTime dt = (DateTime)value; string dtString; long ticks; if (mapping.TypeDesc.FormatterName == "Date") { dtString = XmlCustomFormatter.FromDate(dt); ticks = (new DateTime(dt.Year, dt.Month, dt.Day)).Ticks; } else if (mapping.TypeDesc.FormatterName == "Time") { dtString = XmlCustomFormatter.FromDateTime(dt); ticks = dt.Ticks; } else { dtString = XmlCustomFormatter.FromDateTime(dt); ticks = dt.Ticks; } valueExpression = new CodePrimitiveExpression(dtString); typeofValue = new CodeTypeOfExpression(CodeIdentifier.EscapeKeywords(type.FullName)); arguments = new CodeAttributeArgument[] { new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression) }; initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(DateTime)), new CodeExpression[] { new CodePrimitiveExpression(ticks) }); } if (arguments != null) { if (field != null) { field.InitExpression = initExpression; } AddCustomAttribute(metadata, typeof(DefaultValueAttribute), arguments); } }
private void InternalLoad(Type elementType, bool asAddress = false) { Match match = s_regex.Match(Arg); if (match.Success) { object varA = ILG.GetVariable(match.Groups["a"].Value); Type varType = ILG.GetVariableType(varA); object varIA = ILG.GetVariable(match.Groups["ia"].Value); if (varType.IsArray) { ILG.Load(varA); ILG.Load(varIA); Type eType = varType.GetElementType(); if (CodeGenerator.IsNullableGenericType(eType)) { ILG.Ldelema(eType); ConvertNullableValue(eType, elementType); } else { if (eType.GetTypeInfo().IsValueType) { ILG.Ldelema(eType); if (!asAddress) { ILG.Ldobj(eType); } } else { ILG.Ldelem(eType); } if (elementType != null) { ILG.ConvertValue(eType, elementType); } } } else { ILG.Load(varA); ILG.Load(varIA); MethodInfo get_Item = varType.GetMethod( "get_Item", CodeGenerator.InstanceBindingFlags, new Type[] { typeof(Int32) } ); Debug.Assert(get_Item != null); ILG.Call(get_Item); Type eType = get_Item.ReturnType; if (CodeGenerator.IsNullableGenericType(eType)) { LocalBuilder localTmp = ILG.GetTempLocal(eType); ILG.Stloc(localTmp); ILG.Ldloca(localTmp); ConvertNullableValue(eType, elementType); } else if ((elementType != null) && !(eType.IsAssignableFrom(elementType) || elementType.IsAssignableFrom(eType))) { throw new InvalidOperationException(SR.Format(SR.IsNotAssignableFrom, eType.GetTypeInfo().AssemblyQualifiedName, elementType.GetTypeInfo().AssemblyQualifiedName)); } else { Convert(eType, elementType, asAddress); } } } else if (Source == "null") { ILG.Load(null); } else { object var; Type varType; if (Arg.StartsWith("o.@", StringComparison.Ordinal) || MemberInfo != null) { var = ILG.GetVariable(Arg.StartsWith("o.@", StringComparison.Ordinal) ? "o" : Arg); varType = ILG.GetVariableType(var); if (varType.GetTypeInfo().IsValueType) { ILG.LoadAddress(var); } else { ILG.Load(var); } } else { var = ILG.GetVariable(Arg); varType = ILG.GetVariableType(var); if (CodeGenerator.IsNullableGenericType(varType) && varType.GetGenericArguments()[0] == elementType) { ILG.LoadAddress(var); ConvertNullableValue(varType, elementType); } else { if (asAddress) { ILG.LoadAddress(var); } else { ILG.Load(var); } } } if (MemberInfo != null) { Type memberType = (MemberInfo is FieldInfo) ? ((FieldInfo)MemberInfo).FieldType : ((PropertyInfo)MemberInfo).PropertyType; if (CodeGenerator.IsNullableGenericType(memberType)) { ILG.LoadMemberAddress(MemberInfo); ConvertNullableValue(memberType, elementType); } else { ILG.LoadMember(MemberInfo); Convert(memberType, elementType, asAddress); } } else { match = s_regex2.Match(Source); if (match.Success) { Debug.Assert(match.Groups["arg"].Value == Arg); Debug.Assert(match.Groups["cast"].Value == CodeIdentifier.GetCSharpName(Type)); if (asAddress) { ILG.ConvertAddress(varType, Type); } else { ILG.ConvertValue(varType, Type); } varType = Type; } Convert(varType, elementType, asAddress); } } }
private TypeDesc ImportTypeDesc(Type type, MemberInfo memberInfo, bool directReference) { TypeDesc typeDesc = null; TypeKind kind; Type arrayElementType = null; Type baseType = null; TypeFlags flags = 0; Exception exception = null; if (!type.GetTypeInfo().IsVisible) { flags |= TypeFlags.Unsupported; exception = new InvalidOperationException(SR.Format(SR.XmlTypeInaccessible, type.FullName)); } else if (directReference && (type.GetTypeInfo().IsAbstract&& type.GetTypeInfo().IsSealed)) { flags |= TypeFlags.Unsupported; exception = new InvalidOperationException(SR.Format(SR.XmlTypeStatic, type.FullName)); } if (!type.GetTypeInfo().IsValueType) { flags |= TypeFlags.Reference; } if (type == typeof(object)) { kind = TypeKind.Root; flags |= TypeFlags.HasDefaultConstructor; } else if (type == typeof(ValueType)) { kind = TypeKind.Enum; flags |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(SR.Format(SR.XmlSerializerUnsupportedType, type.FullName)); } } else if (type == typeof(void)) { kind = TypeKind.Void; } else if (typeof(IXmlSerializable).IsAssignableFrom(type)) { kind = TypeKind.Serializable; flags |= TypeFlags.Special | TypeFlags.CanBeElementValue; flags |= GetConstructorFlags(type, ref exception); } else if (type.IsArray) { kind = TypeKind.Array; if (type.GetArrayRank() > 1) { flags |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(SR.Format(SR.XmlUnsupportedRank, type.FullName)); } } arrayElementType = type.GetElementType(); flags |= TypeFlags.HasDefaultConstructor; } else if (typeof(ICollection).IsAssignableFrom(type)) { kind = TypeKind.Collection; arrayElementType = GetCollectionElementType(type, memberInfo == null ? null : memberInfo.DeclaringType.FullName + "." + memberInfo.Name); flags |= GetConstructorFlags(type, ref exception); } else if (type == typeof(XmlQualifiedName)) { kind = TypeKind.Primitive; } else if (type.GetTypeInfo().IsPrimitive) { kind = TypeKind.Primitive; flags |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(SR.Format(SR.XmlSerializerUnsupportedType, type.FullName)); } } else if (type.GetTypeInfo().IsEnum) { kind = TypeKind.Enum; } else if (type.GetTypeInfo().IsValueType) { kind = TypeKind.Struct; if (IsOptionalValue(type)) { baseType = type.GetGenericArguments()[0]; flags |= TypeFlags.OptionalValue; } else { baseType = type.GetTypeInfo().BaseType; } if (type.GetTypeInfo().IsAbstract) { flags |= TypeFlags.Abstract; } } else if (type.GetTypeInfo().IsClass) { { kind = TypeKind.Class; baseType = type.GetTypeInfo().BaseType; if (type.GetTypeInfo().IsAbstract) { flags |= TypeFlags.Abstract; } } } else if (type.GetTypeInfo().IsInterface) { kind = TypeKind.Void; flags |= TypeFlags.Unsupported; if (exception == null) { if (memberInfo == null) { exception = new NotSupportedException(SR.Format(SR.XmlUnsupportedInterface, type.FullName)); } else { exception = new NotSupportedException(SR.Format(SR.XmlUnsupportedInterfaceDetails, memberInfo.DeclaringType.FullName + "." + memberInfo.Name, type.FullName)); } } } else { kind = TypeKind.Void; flags |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(SR.Format(SR.XmlSerializerUnsupportedType, type.FullName)); } } // check to see if the type has public default constructor for classes if (kind == TypeKind.Class && !type.GetTypeInfo().IsAbstract) { flags |= GetConstructorFlags(type, ref exception); } // check if a struct-like type is enumerable if (kind == TypeKind.Struct || kind == TypeKind.Class) { if (typeof(IEnumerable).IsAssignableFrom(type)) { arrayElementType = GetEnumeratorElementType(type, ref flags); kind = TypeKind.Enumerable; // GetEnumeratorElementType checks for the security attributes on the GetEnumerator(), Add() methods and Current property, // we need to check the MoveNext() and ctor methods for the security attribues flags |= GetConstructorFlags(type, ref exception); } } typeDesc = new TypeDesc(type, CodeIdentifier.MakeValid(TypeName(type)), type.ToString(), kind, null, flags, null); typeDesc.Exception = exception; if (directReference && (typeDesc.IsClass || kind == TypeKind.Serializable)) { typeDesc.CheckNeedConstructor(); } if (typeDesc.IsUnsupported) { // return right away, do not check anything else return(typeDesc); } _typeDescs.Add(type, typeDesc); if (arrayElementType != null) { TypeDesc td = GetTypeDesc(arrayElementType, memberInfo, true, false); // explicitly disallow read-only elements, even if they are collections if (directReference && (td.IsCollection || td.IsEnumerable) && !td.IsPrimitive) { td.CheckNeedConstructor(); } typeDesc.ArrayElementTypeDesc = td; } if (baseType != null && baseType != typeof(object) && baseType != typeof(ValueType)) { typeDesc.BaseTypeDesc = GetTypeDesc(baseType, memberInfo, false, false); } return(typeDesc); }
private TypeDesc ImportTypeDesc(Type type, MemberInfo memberInfo, bool directReference) { TypeDesc desc = null; TypeKind root; Type elementType = null; Type baseType = null; TypeFlags none = TypeFlags.None; Exception exception = null; if (!type.IsPublic && !type.IsNestedPublic) { none |= TypeFlags.Unsupported; exception = new InvalidOperationException(Res.GetString("XmlTypeInaccessible", new object[] { type.FullName })); } else if (type.IsAbstract && type.IsSealed) { none |= TypeFlags.Unsupported; exception = new InvalidOperationException(Res.GetString("XmlTypeStatic", new object[] { type.FullName })); } if (DynamicAssemblies.IsTypeDynamic(type)) { none |= TypeFlags.UseReflection; } if (!type.IsValueType) { none |= TypeFlags.Reference; } if (type == typeof(object)) { root = TypeKind.Root; none |= TypeFlags.HasDefaultConstructor; } else if (type == typeof(ValueType)) { root = TypeKind.Enum; none |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(Res.GetString("XmlSerializerUnsupportedType", new object[] { type.FullName })); } } else if (type == typeof(void)) { root = TypeKind.Void; } else if (typeof(IXmlSerializable).IsAssignableFrom(type)) { root = TypeKind.Serializable; none |= TypeFlags.CanBeElementValue | TypeFlags.Special; none |= GetConstructorFlags(type, ref exception); } else if (type.IsArray) { root = TypeKind.Array; if (type.GetArrayRank() > 1) { none |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(Res.GetString("XmlUnsupportedRank", new object[] { type.FullName })); } } elementType = type.GetElementType(); none |= TypeFlags.HasDefaultConstructor; } else if (typeof(ICollection).IsAssignableFrom(type)) { root = TypeKind.Collection; elementType = GetCollectionElementType(type, (memberInfo == null) ? null : (memberInfo.DeclaringType.FullName + "." + memberInfo.Name)); none |= GetConstructorFlags(type, ref exception); } else if (type == typeof(XmlQualifiedName)) { root = TypeKind.Primitive; } else if (type.IsPrimitive) { root = TypeKind.Primitive; none |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(Res.GetString("XmlSerializerUnsupportedType", new object[] { type.FullName })); } } else if (type.IsEnum) { root = TypeKind.Enum; } else if (type.IsValueType) { root = TypeKind.Struct; if (IsOptionalValue(type)) { baseType = type.GetGenericArguments()[0]; none |= TypeFlags.OptionalValue; } else { baseType = type.BaseType; } if (type.IsAbstract) { none |= TypeFlags.Abstract; } } else if (type.IsClass) { if (type == typeof(XmlAttribute)) { root = TypeKind.Attribute; none |= TypeFlags.CanBeAttributeValue | TypeFlags.Special; } else if (typeof(XmlNode).IsAssignableFrom(type)) { root = TypeKind.Node; baseType = type.BaseType; none |= TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.Special; if (typeof(XmlText).IsAssignableFrom(type)) { none &= ~TypeFlags.CanBeElementValue; } else if (typeof(XmlElement).IsAssignableFrom(type)) { none &= ~TypeFlags.CanBeTextValue; } else if (type.IsAssignableFrom(typeof(XmlAttribute))) { none |= TypeFlags.CanBeAttributeValue; } } else { root = TypeKind.Class; baseType = type.BaseType; if (type.IsAbstract) { none |= TypeFlags.Abstract; } } } else if (type.IsInterface) { root = TypeKind.Void; none |= TypeFlags.Unsupported; if (exception == null) { if (memberInfo == null) { exception = new NotSupportedException(Res.GetString("XmlUnsupportedInterface", new object[] { type.FullName })); } else { exception = new NotSupportedException(Res.GetString("XmlUnsupportedInterfaceDetails", new object[] { memberInfo.DeclaringType.FullName + "." + memberInfo.Name, type.FullName })); } } } else { root = TypeKind.Void; none |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(Res.GetString("XmlSerializerUnsupportedType", new object[] { type.FullName })); } } if ((root == TypeKind.Class) && !type.IsAbstract) { none |= GetConstructorFlags(type, ref exception); } if (((root == TypeKind.Struct) || (root == TypeKind.Class)) && typeof(IEnumerable).IsAssignableFrom(type)) { elementType = GetEnumeratorElementType(type, ref none); root = TypeKind.Enumerable; none |= GetConstructorFlags(type, ref exception); } desc = new TypeDesc(type, CodeIdentifier.MakeValid(TypeName(type)), type.ToString(), root, null, none, null) { Exception = exception }; if (directReference && (desc.IsClass || (root == TypeKind.Serializable))) { desc.CheckNeedConstructor(); } if (!desc.IsUnsupported) { this.typeDescs.Add(type, desc); if (elementType != null) { TypeDesc desc2 = this.GetTypeDesc(elementType, memberInfo, true, false); if ((directReference && (desc2.IsCollection || desc2.IsEnumerable)) && !desc2.IsPrimitive) { desc2.CheckNeedConstructor(); } desc.ArrayElementTypeDesc = desc2; } if (((baseType != null) && (baseType != typeof(object))) && (baseType != typeof(ValueType))) { desc.BaseTypeDesc = this.GetTypeDesc(baseType, memberInfo, false, false); } if (type.IsNestedPublic) { for (Type type4 = type.DeclaringType; (type4 != null) && !type4.ContainsGenericParameters; type4 = type4.DeclaringType) { this.GetTypeDesc(type4, null, false); } } } return(desc); }
/// <summary>Produces a Pascal-case string from an input string. </summary> /// <returns>A Pascal-case version of the parameter string.</returns> /// <param name="identifier">The name of a code entity, such as a method parameter, typically taken from an XML element or attribute name.</param> public static string MakePascal(string identifier) { string text = CodeIdentifier.MakeValid(identifier); return(char.ToUpper(text[0], CultureInfo.InvariantCulture) + text.Substring(1)); }
private ArrayMapping ImportArrayMapping(XmlSchemaType type, string ns) { ArrayMapping mapping; if ((type.Name == "Array") && (ns == "http://schemas.xmlsoap.org/soap/encoding/")) { mapping = new ArrayMapping(); TypeMapping rootMapping = base.GetRootMapping(); ElementAccessor accessor = new ElementAccessor { IsSoap = true, Name = "anyType", Namespace = ns, Mapping = rootMapping, IsNullable = true, Form = XmlSchemaForm.None }; mapping.Elements = new ElementAccessor[] { accessor }; mapping.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc(); mapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(accessor.Mapping.TypeName); return(mapping); } if ((type.DerivedFrom.Name != "Array") || (type.DerivedFrom.Namespace != "http://schemas.xmlsoap.org/soap/encoding/")) { return(null); } XmlSchemaContentModel contentModel = ((XmlSchemaComplexType)type).ContentModel; if (!(contentModel.Content is XmlSchemaComplexContentRestriction)) { return(null); } mapping = new ArrayMapping(); XmlSchemaComplexContentRestriction content = (XmlSchemaComplexContentRestriction)contentModel.Content; for (int i = 0; i < content.Attributes.Count; i++) { XmlSchemaAttribute parent = content.Attributes[i] as XmlSchemaAttribute; if (((parent != null) && (parent.RefName.Name == "arrayType")) && (parent.RefName.Namespace == "http://schemas.xmlsoap.org/soap/encoding/")) { string str = null; if (parent.UnhandledAttributes != null) { foreach (XmlAttribute attribute2 in parent.UnhandledAttributes) { if ((attribute2.LocalName == "arrayType") && (attribute2.NamespaceURI == "http://schemas.xmlsoap.org/wsdl/")) { str = attribute2.Value; break; } } } if (str != null) { string str2; TypeMapping mapping3; XmlQualifiedName name = TypeScope.ParseWsdlArrayType(str, out str2, parent); TypeDesc typeDesc = base.Scope.GetTypeDesc(name.Name, name.Namespace); if ((typeDesc != null) && typeDesc.IsPrimitive) { mapping3 = new PrimitiveMapping { TypeDesc = typeDesc, TypeName = typeDesc.DataType.Name }; } else { mapping3 = this.ImportType(name, false); } ElementAccessor accessor2 = new ElementAccessor { IsSoap = true, Name = name.Name, Namespace = ns, Mapping = mapping3, IsNullable = true, Form = XmlSchemaForm.None }; mapping.Elements = new ElementAccessor[] { accessor2 }; mapping.TypeDesc = accessor2.Mapping.TypeDesc.CreateArrayTypeDesc(); mapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(accessor2.Mapping.TypeName); return(mapping); } } } XmlSchemaParticle particle = content.Particle; if (!(particle is XmlSchemaAll) && !(particle is XmlSchemaSequence)) { return(null); } XmlSchemaGroupBase base2 = (XmlSchemaGroupBase)particle; if ((base2.Items.Count != 1) || !(base2.Items[0] is XmlSchemaElement)) { return(null); } XmlSchemaElement element = (XmlSchemaElement)base2.Items[0]; if (!element.IsMultipleOccurrence) { return(null); } ElementAccessor accessor3 = this.ImportElement(element, ns); mapping.Elements = new ElementAccessor[] { accessor3 }; mapping.TypeDesc = accessor3.Mapping.TypeDesc.CreateArrayTypeDesc(); return(mapping); }
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); }
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 void SetArrayMappingType(ArrayMapping mapping) { string typeName; string str2; TypeMapping mapping2; bool flag = false; if (mapping.Elements.Length == 1) { mapping2 = mapping.Elements[0].Mapping; } else { mapping2 = null; } if (mapping2 is EnumMapping) { str2 = mapping2.Namespace; typeName = mapping2.TypeName; } else if (mapping2 is PrimitiveMapping) { str2 = mapping2.TypeDesc.IsXsdType ? "http://www.w3.org/2001/XMLSchema" : "http://microsoft.com/wsdl/types/"; typeName = mapping2.TypeDesc.DataType.Name; flag = true; } else if (mapping2 is StructMapping) { if (mapping2.TypeDesc.IsRoot) { str2 = "http://www.w3.org/2001/XMLSchema"; typeName = "anyType"; flag = true; } else { str2 = mapping2.Namespace; typeName = mapping2.TypeName; } } else { if (!(mapping2 is ArrayMapping)) { throw new InvalidOperationException(Res.GetString("XmlInvalidSoapArray", new object[] { mapping.TypeDesc.FullName })); } str2 = mapping2.Namespace; typeName = mapping2.TypeName; } typeName = CodeIdentifier.MakePascal(typeName); string str3 = "ArrayOf" + typeName; string str4 = flag ? this.defaultNs : str2; int num = 1; TypeMapping mapping3 = (TypeMapping)this.types[str3, str4]; while (mapping3 != null) { if (mapping3 is ArrayMapping) { ArrayMapping mapping4 = (ArrayMapping)mapping3; if (AccessorMapping.ElementsMatch(mapping4.Elements, mapping.Elements)) { break; } } str3 = typeName + num.ToString(CultureInfo.InvariantCulture); mapping3 = (TypeMapping)this.types[str3, str4]; num++; } mapping.Namespace = str4; mapping.TypeName = str3; }
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 accembly 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 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); }
// UNDONE Nullable private void SetArrayMappingType(ArrayMapping mapping) { bool useDefaultNs = false; string itemTypeName; string itemTypeNamespace; TypeMapping itemTypeMapping; if (mapping.Elements.Length == 1) { itemTypeMapping = mapping.Elements[0].Mapping; } else { itemTypeMapping = null; } if (itemTypeMapping is EnumMapping) { itemTypeNamespace = itemTypeMapping.Namespace; itemTypeName = itemTypeMapping.TypeName; } else if (itemTypeMapping is PrimitiveMapping) { itemTypeNamespace = itemTypeMapping.TypeDesc.IsXsdType ? XmlSchema.Namespace : UrtTypes.Namespace; itemTypeName = itemTypeMapping.TypeDesc.DataType.Name; useDefaultNs = true; } else if (itemTypeMapping is StructMapping) { if (itemTypeMapping.TypeDesc.IsRoot) { itemTypeNamespace = XmlSchema.Namespace; itemTypeName = Soap.UrType; useDefaultNs = true; } else { itemTypeNamespace = itemTypeMapping.Namespace; itemTypeName = itemTypeMapping.TypeName; } } else if (itemTypeMapping is ArrayMapping) { itemTypeNamespace = itemTypeMapping.Namespace; itemTypeName = itemTypeMapping.TypeName; } else { throw new InvalidOperationException(SR.Format(SR.XmlInvalidSoapArray, mapping.TypeDesc.FullName)); } itemTypeName = CodeIdentifier.MakePascal(itemTypeName); string uniqueName = "ArrayOf" + itemTypeName; string ns = useDefaultNs ? _defaultNs : itemTypeNamespace; int i = 1; TypeMapping existingMapping = (TypeMapping)_types[uniqueName, ns]; while (existingMapping != null) { if (existingMapping is ArrayMapping) { ArrayMapping arrayMapping = (ArrayMapping)existingMapping; if (AccessorMapping.ElementsMatch(arrayMapping.Elements, mapping.Elements)) { break; } } // need to re-name the mapping uniqueName = itemTypeName + i.ToString(CultureInfo.InvariantCulture); existingMapping = (TypeMapping)_types[uniqueName, ns]; i++; } mapping.Namespace = ns; mapping.TypeName = uniqueName; }
private string GenerateVariableName(string prefix, string fullName) { this.nextReflectionVariableNumber++; return(string.Concat(new object[] { prefix, this.nextReflectionVariableNumber, "_", CodeIdentifier.MakeValidInternal(fullName.Replace('.', '_')) })); }