static void Main () { XmlReflectionImporter importer = new XmlReflectionImporter (); XmlTypeMapping map = importer.ImportTypeMapping (typeof (MyList)); XmlSerializer xs = new XmlSerializer (map); xs.Serialize (Console.Out, new MyList (null)); }
static void Main () { XmlReflectionImporter importer = new XmlReflectionImporter (); XmlTypeMapping map = importer.ImportTypeMapping (typeof (ArrayType)); XmlSerializer xs = new XmlSerializer (map); xs.Serialize (Console.Out, new ArrayType ()); }
public static void Xml_ConstructorWithTypeMapping() { XmlTypeMapping mapping = null; XmlSerializer serializer = null; Assert.Throws<ArgumentNullException>(() => { new XmlSerializer(mapping); }); mapping = new XmlReflectionImporter(null, null).ImportTypeMapping(typeof(List<string>)); serializer = new XmlSerializer(mapping); Xml_ListGenericRoot(serializer); }
static int Main () { XmlReflectionImporter importer = new XmlReflectionImporter (); try { importer.ImportTypeMapping (typeof (SimpleClass)); return 1; } catch (InvalidOperationException) { return 0; } }
public static void Xml_FromMappings() { var types = new[] { typeof(Guid), typeof(List<string>) }; XmlReflectionImporter importer = new XmlReflectionImporter(); XmlTypeMapping[] mappings = new XmlTypeMapping[types.Length]; for (int i = 0; i < types.Length; i++) { mappings[i] = importer.ImportTypeMapping(types[i]); } var serializers = XmlSerializer.FromMappings(mappings, typeof(object)); Xml_GuidAsRoot(serializers[0]); Xml_ListGenericRoot(serializers[1]); }
static int Main () { XmlReflectionImporter ri = new XmlReflectionImporter ("NSPrimitive"); XmlSchemas schemas = new XmlSchemas (); XmlSchemaExporter sx = new XmlSchemaExporter (schemas); XmlTypeMapping tm = ri.ImportTypeMapping (typeof (int)); sx.ExportTypeMapping (tm); StringWriter sw = new StringWriter (); schemas[0].Write (sw); int exitCode = 0; exitCode += Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" + "<xs:schema xmlns:tns=\"NSPrimitive\" elementFormDefault=\"qualified\" targetNamespace=\"NSPrimitive\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" + " <xs:element name=\"int\" type=\"xs:int\" />{0}" + "</xs:schema>", Environment.NewLine), sw.ToString (), "#1"); ri = new XmlReflectionImporter ("NSString"); schemas = new XmlSchemas (); sx = new XmlSchemaExporter (schemas); tm = ri.ImportTypeMapping (typeof (string)); sx.ExportTypeMapping (tm); sw = new StringWriter (); schemas[0].Write (sw); exitCode += Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" + "<xs:schema xmlns:tns=\"NSString\" elementFormDefault=\"qualified\" targetNamespace=\"NSString\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" + " <xs:element name=\"string\" nillable=\"true\" type=\"xs:string\" />{0}" + "</xs:schema>", Environment.NewLine), sw.ToString (), "#2"); ri = new XmlReflectionImporter ("NSQName"); schemas = new XmlSchemas (); sx = new XmlSchemaExporter (schemas); tm = ri.ImportTypeMapping (typeof (XmlQualifiedName)); sx.ExportTypeMapping (tm); sw = new StringWriter (); schemas[0].Write (sw); exitCode += Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" + "<xs:schema xmlns:tns=\"NSQName\" elementFormDefault=\"qualified\" targetNamespace=\"NSQName\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" + #if NET_2_0 " <xs:element name=\"QName\" nillable=\"true\" type=\"xs:QName\" />{0}" + #else " <xs:element name=\"QName\" type=\"xs:QName\" />{0}" + #endif "</xs:schema>", Environment.NewLine), sw.ToString (), "#3"); ri = new XmlReflectionImporter ("NSDateTime"); schemas = new XmlSchemas (); sx = new XmlSchemaExporter (schemas); tm = ri.ImportTypeMapping (typeof (DateTime)); sx.ExportTypeMapping (tm); sw = new StringWriter (); schemas[0].Write (sw); exitCode += Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" + "<xs:schema xmlns:tns=\"NSDateTime\" elementFormDefault=\"qualified\" targetNamespace=\"NSDateTime\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" + " <xs:element name=\"dateTime\" type=\"xs:dateTime\" />{0}" + "</xs:schema>", Environment.NewLine), sw.ToString (), "#4"); ri = new XmlReflectionImporter ("NSByteArray"); schemas = new XmlSchemas (); sx = new XmlSchemaExporter (schemas); tm = ri.ImportTypeMapping (typeof (byte[])); sx.ExportTypeMapping (tm); sw = new StringWriter (); schemas[0].Write (sw); exitCode += Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" + "<xs:schema xmlns:tns=\"NSByteArray\" elementFormDefault=\"qualified\" targetNamespace=\"NSByteArray\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" + " <xs:element name=\"base64Binary\" nillable=\"true\" type=\"xs:base64Binary\" />{0}" + "</xs:schema>", Environment.NewLine), sw.ToString (), "#5"); ri = new XmlReflectionImporter ("NSInt32Array"); schemas = new XmlSchemas (); sx = new XmlSchemaExporter (schemas); tm = ri.ImportTypeMapping (typeof (int[])); sx.ExportTypeMapping (tm); sw = new StringWriter (); schemas[0].Write (sw); exitCode += Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" + "<xs:schema xmlns:tns=\"NSInt32Array\" elementFormDefault=\"qualified\" targetNamespace=\"NSInt32Array\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" + " <xs:element name=\"ArrayOfInt\" nillable=\"true\" type=\"tns:ArrayOfInt\" />{0}" + " <xs:complexType name=\"ArrayOfInt\">{0}" + " <xs:sequence>{0}" + " <xs:element minOccurs=\"0\" maxOccurs=\"unbounded\" name=\"int\" type=\"xs:int\" />{0}" + " </xs:sequence>{0}" + " </xs:complexType>{0}" + "</xs:schema>", Environment.NewLine), sw.ToString (), "#6"); ri = new XmlReflectionImporter ("NSSimpleClassArray"); schemas = new XmlSchemas (); sx = new XmlSchemaExporter (schemas); tm = ri.ImportTypeMapping (typeof (SimpleClass[])); sx.ExportTypeMapping (tm); sw = new StringWriter (); schemas[0].Write (sw); exitCode += Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" + "<xs:schema xmlns:tns=\"NSSimpleClassArray\" elementFormDefault=\"qualified\" targetNamespace=\"NSSimpleClassArray\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" + " <xs:element name=\"ArrayOfSimpleClass\" nillable=\"true\" type=\"tns:ArrayOfSimpleClass\" />{0}" + " <xs:complexType name=\"ArrayOfSimpleClass\">{0}" + " <xs:sequence>{0}" + " <xs:element minOccurs=\"0\" maxOccurs=\"unbounded\" name=\"SimpleClass\" nillable=\"true\" type=\"tns:SimpleClass\" />{0}" + " </xs:sequence>{0}" + " </xs:complexType>{0}" + " <xs:complexType name=\"SimpleClass\" />{0}" + "</xs:schema>", Environment.NewLine), sw.ToString (), "#7"); return exitCode; }
public int Run (string[] args) { ParseArgs (args); if (!nologo) { Console.WriteLine ("Mono Xml Serializer Generator Tool"); Console.WriteLine ("Mono version " + Environment.Version); Console.WriteLine (); } if (unknownArg != null) { Console.WriteLine ("Unknown option: " + unknownArg); Console.WriteLine (); return 1; } if (help) { Console.WriteLine ("Usage: sgen [options]"); Console.WriteLine (); return 0; } if (assembly == null) { Console.WriteLine ("Assembly name not provided"); Console.WriteLine (); return 1; } Assembly asm = null; try { asm = Assembly.Load (assembly); } catch {} if (asm == null) { try { asm = Assembly.LoadFrom (assembly); } catch { Console.WriteLine ("Specified assembly cannot be loaded."); Console.WriteLine (); return 1; } } ArrayList userTypes = new ArrayList (); ArrayList maps = new ArrayList (); XmlReflectionImporter imp = new XmlReflectionImporter (); if (verbose) Console.WriteLine ("Generating serializer for the following types:"); if (types == null) { foreach (Type t in asm.GetTypes ()) { try { maps.Add (imp.ImportTypeMapping (t)); userTypes.Add (t); if (verbose) Console.WriteLine( " - " + t ); } catch (InvalidOperationException ex) { if (verbose) Console.WriteLine (" - Warning: " + ex.Message); } catch (NotImplementedException ex) { if (verbose) { Console.WriteLine (" - Warning: ignoring '" + t + "'"); Console.WriteLine (" " + ex.Message); } } catch (NotSupportedException ex) { if (verbose) Console.WriteLine (" - Warning: " + ex.Message); } } } else { foreach (string type in types) { try { Type t = asm.GetType (type); maps.Add (imp.ImportTypeMapping (t)); userTypes.Add (t); if (verbose) Console.WriteLine (" - " + t); } catch (InvalidOperationException ex) { if (verbose) Console.WriteLine (" - Warning: " + ex.Message); } catch (NotImplementedException ex) { if (verbose) { Console.WriteLine (" - Warning: ignoring '" + type + "'"); Console.WriteLine (" " + ex.Message); } } catch (NotSupportedException ex) { if (verbose) Console.WriteLine (" - Warning: " + ex.Message); } } } if (verbose) Console.WriteLine (); CompilerParameters parameters = new CompilerParameters (); parameters.GenerateInMemory = false; parameters.IncludeDebugInformation = debug; parameters.ReferencedAssemblies.AddRange ((string[])references.ToArray(typeof(string))); parameters.TempFiles = new TempFileCollection (Environment.CurrentDirectory, keep); parameters.CompilerOptions = compilerOptions; string file = Path.GetFileNameWithoutExtension (asm.Location) + ".XmlSerializers.dll"; if (outDir == null) outDir = Path.GetDirectoryName (asm.Location); parameters.OutputAssembly = Path.Combine (outDir, file); if (File.Exists (parameters.OutputAssembly) && !force) { Console.WriteLine ("Cannot generate assembly '" + parameters.OutputAssembly + "' because it already exist. Use /force option to overwrite the existing assembly"); Console.WriteLine (); return 1; } XmlSerializer.GenerateSerializer ( (Type[]) userTypes.ToArray (typeof(Type)), (XmlTypeMapping[]) maps.ToArray (typeof(XmlTypeMapping)), parameters); if (!silent) { Console.WriteLine ("Generated assembly: " + file); Console.WriteLine (); } return 0; }
private void ImportType(Type type, ArrayList mappings, ArrayList importedTypes, bool verbose, XmlReflectionImporter importer, bool parsableerrors) { XmlTypeMapping xmlTypeMapping = null; var localImporter = new XmlReflectionImporter(); try { xmlTypeMapping = localImporter.ImportTypeMapping(type); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } if (verbose) { Console.Out.WriteLine(FormatMessage(parsableerrors, true, SR.Format(SR.InfoIgnoreType, type.FullName))); WriteWarning(e, parsableerrors); } return; } if (xmlTypeMapping != null) { xmlTypeMapping = importer.ImportTypeMapping(type); mappings.Add(xmlTypeMapping); importedTypes.Add(type); } }
private void GenerateFile(List <string> typeNames, string assemblyName, bool proxyOnly, bool silent, bool warnings, bool force, string outputDirectory, bool parsableerrors) { Assembly assembly = LoadAssembly(assemblyName, true); Type[] types; if (typeNames == null || typeNames.Count == 0) { try { types = assembly.GetTypes(); } catch (ReflectionTypeLoadException typeException) { List <Type> loadedTypes = new List <Type>(); foreach (Type type in typeException.Types) { if (type != null) { loadedTypes.Add(type); } } types = loadedTypes.ToArray(); } } else { types = new Type[typeNames.Count]; int typeIndex = 0; foreach (string typeName in typeNames) { Type type = assembly.GetType(typeName); if (type == null) { Console.Error.WriteLine(FormatMessage(parsableerrors, false, SR.Format(SR.ErrorDetails, SR.Format(SR.ErrLoadType, typeName, assemblyName)))); } types[typeIndex++] = type; } } var mappings = new ArrayList(); var importedTypes = new ArrayList(); var importer = new XmlReflectionImporter(); for (int i = 0; i < types.Length; i++) { Type type = types[i]; try { if (type != null) { bool isObsolete = false; object[] obsoleteAttributes = type.GetCustomAttributes(typeof(ObsoleteAttribute), false); foreach (object attribute in obsoleteAttributes) { if (((ObsoleteAttribute)attribute).IsError) { isObsolete = true; break; } } if (isObsolete) { continue; } } } //Ignore the FileNotFoundException when call GetCustomAttributes e.g. if the type uses the attributes defined in a different assembly catch (FileNotFoundException e) { if (warnings) { Console.Out.WriteLine(FormatMessage(parsableerrors, true, SR.Format(SR.InfoIgnoreType, type.FullName))); WriteWarning(e, parsableerrors); } continue; } if (!proxyOnly) { ImportType(type, mappings, importedTypes, warnings, importer, parsableerrors); } } if (importedTypes.Count > 0) { var serializableTypes = (Type[])importedTypes.ToArray(typeof(Type)); var allMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping)); bool gac = assembly.GlobalAssemblyCache; outputDirectory = outputDirectory == null ? (gac ? Environment.CurrentDirectory : Path.GetDirectoryName(assembly.Location)) : outputDirectory; if (!Directory.Exists(outputDirectory)) { //We need double quote the path to escpate the space in the path. //However when a path ending with backslash, if followed by double quote, it becomes an escapte sequence //e.g. "obj\Debug\netcoreapp2.0\", it will be converted as obj\Debug\netcoreapp2.0", which is not valid and not exist //We need remove the ending quote for this situation if (!outputDirectory.EndsWith("\"") || !Directory.Exists(outputDirectory.Remove(outputDirectory.Length - 1))) { throw new ArgumentException(SR.Format(SR.ErrDirectoryNotExists, outputDirectory)); } } string serializerName = GetXmlSerializerAssemblyName(serializableTypes[0], null); string codePath = Path.Combine(outputDirectory, serializerName + ".cs"); if (!force) { if (File.Exists(codePath)) { throw new InvalidOperationException(SR.Format(SR.ErrSerializerExists, codePath, "force")); } } if (Directory.Exists(codePath)) { throw new InvalidOperationException(SR.Format(SR.ErrDirectoryExists, codePath)); } bool success = false; bool toDeleteFile = true; try { if (File.Exists(codePath)) { File.Delete(codePath); } using (FileStream fs = File.Create(codePath)) { MethodInfo method = typeof(System.Xml.Serialization.XmlSerializer).GetMethod("GenerateSerializer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (method == null) { Console.Error.WriteLine(FormatMessage(parsableerrors: false, warning: false, message: SR.GenerateSerializerNotFound)); } else { success = (bool)method.Invoke(null, new object[] { serializableTypes, allMappings, fs }); } } } catch (UnauthorizedAccessException) { toDeleteFile = false; throw new UnauthorizedAccessException(SR.Format(SR.DirectoryAccessDenied, outputDirectory)); } finally { if (!success && toDeleteFile && File.Exists(codePath)) { File.Delete(codePath); } } if (success) { if (!silent) { Console.Out.WriteLine(SR.Format(SR.InfoFileName, codePath)); Console.Out.WriteLine(SR.Format(SR.InfoGeneratedFile, assembly.Location, codePath)); } } else { Console.Out.WriteLine(FormatMessage(parsableerrors, false, SR.Format(SR.ErrGenerationFailed, assembly.Location))); } } else { Console.Out.WriteLine(FormatMessage(parsableerrors, true, SR.Format(SR.InfoNoSerializableTypes, assembly.Location))); } }
internal XmlSerializerImporter(string defaultNs) { _defaultNs = defaultNs; _xmlImporter = null; }
private void GenerateFile(List <string> typeNames, string assemblyName, bool proxyOnly, bool silent, bool warnings, bool force, string outputDirectory, bool parsableerrors) { Assembly assembly = LoadAssembly(assemblyName, true); Type[] types; if (typeNames == null || typeNames.Count == 0) { try { types = assembly.GetTypes(); } catch (ReflectionTypeLoadException typeException) { List <Type> loadedTypes = new List <Type>(); foreach (Type type in typeException.Types) { if (type != null) { loadedTypes.Add(type); } } types = loadedTypes.ToArray(); } } else { types = new Type[typeNames.Count]; int typeIndex = 0; foreach (string typeName in typeNames) { Type type = assembly.GetType(typeName); if (type == null) { Console.Error.WriteLine(FormatMessage(parsableerrors, false, SR.Format(SR.ErrorDetails, SR.Format(SR.ErrLoadType, typeName, assemblyName)))); } types[typeIndex++] = type; } } var mappings = new ArrayList(); var importedTypes = new ArrayList(); var importer = new XmlReflectionImporter(); for (int i = 0; i < types.Length; i++) { Type type = types[i]; if (type != null) { bool isObsolete = false; object[] obsoleteAttributes = type.GetCustomAttributes(typeof(ObsoleteAttribute), false); foreach (object attribute in obsoleteAttributes) { if (((ObsoleteAttribute)attribute).IsError) { isObsolete = true; break; } } if (isObsolete) { continue; } } if (!proxyOnly) { ImportType(type, mappings, importedTypes, warnings, importer, parsableerrors); } } if (importedTypes.Count > 0) { var serializableTypes = (Type[])importedTypes.ToArray(typeof(Type)); var allMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping)); bool gac = assembly.GlobalAssemblyCache; outputDirectory = outputDirectory == null ? (gac ? Environment.CurrentDirectory : Path.GetDirectoryName(assembly.Location)) : outputDirectory; string serializerName = XmlSerializer.GetXmlSerializerAssemblyName(serializableTypes[0], null); string codePath = Path.Combine(outputDirectory, serializerName + ".cs"); if (!force) { if (File.Exists(codePath)) { throw new InvalidOperationException(SR.Format(SR.ErrSerializerExists, codePath, "force")); } } if (Directory.Exists(codePath)) { throw new InvalidOperationException(SR.Format(SR.ErrDirectoryExists, codePath)); } if (!Directory.Exists(outputDirectory)) { throw new ArgumentException(SR.Format(SR.ErrDirectoryNotExists, codePath, outputDirectory)); } bool success = false; bool toDeleteFile = true; try { if (File.Exists(codePath)) { File.Delete(codePath); } using (FileStream fs = File.Create(codePath)) { success = XmlSerializer.GenerateSerializer(serializableTypes, allMappings, fs); } } catch (UnauthorizedAccessException) { toDeleteFile = false; throw new UnauthorizedAccessException(SR.Format(SR.DirectoryAccessDenied, outputDirectory)); } finally { if (!success && toDeleteFile && File.Exists(codePath)) { File.Delete(codePath); } } if (success) { if (!silent) { Console.Out.WriteLine(SR.Format(SR.InfoFileName, codePath)); Console.Out.WriteLine(SR.Format(SR.InfoGeneratedFile, assembly.Location, codePath)); } } else { Console.Out.WriteLine(FormatMessage(parsableerrors, false, SR.Format(SR.ErrGenerationFailed, assembly.Location))); } } else { Console.Out.WriteLine(FormatMessage(parsableerrors, true, SR.Format(SR.InfoNoSerializableTypes, assembly.Location))); } }
Message CreateExample(Type type, OperationDescription od, bool generateJson) { bool usesXmlSerializer = od.Behaviors.Contains(typeof(XmlSerializerOperationBehavior)); XmlQualifiedName name; XmlSchemaSet schemaSet = new XmlSchemaSet(); IDictionary <XmlQualifiedName, Type> knownTypes = new Dictionary <XmlQualifiedName, Type>(); if (usesXmlSerializer) { XmlReflectionImporter importer = new XmlReflectionImporter(); XmlTypeMapping typeMapping = importer.ImportTypeMapping(type); name = new XmlQualifiedName(typeMapping.ElementName, typeMapping.Namespace); XmlSchemas schemas = new XmlSchemas(); XmlSchemaExporter exporter = new XmlSchemaExporter(schemas); exporter.ExportTypeMapping(typeMapping); foreach (XmlSchema schema in schemas) { schemaSet.Add(schema); } } else { XsdDataContractExporter exporter = new XsdDataContractExporter(); List <Type> listTypes = new List <Type>(od.KnownTypes); listTypes.Add(type); exporter.Export(listTypes); if (!exporter.CanExport(type)) { throw new NotSupportedException(String.Format("Example generation is not supported for type '{0}'", type)); } name = exporter.GetRootElementName(type); foreach (Type knownType in od.KnownTypes) { XmlQualifiedName knownTypeName = exporter.GetSchemaTypeName(knownType); if (!knownTypes.ContainsKey(knownTypeName)) { knownTypes.Add(knownTypeName, knownType); } } foreach (XmlSchema schema in exporter.Schemas.Schemas()) { schemaSet.Add(schema); } } schemaSet.Compile(); XmlWriterSettings settings = new XmlWriterSettings { CloseOutput = false, Indent = true, }; if (generateJson) { var jsonExample = new XDocument(); using (XmlWriter writer = XmlWriter.Create(jsonExample.CreateWriter(), settings)) { HelpExampleGenerator.GenerateJsonSample(schemaSet, name, writer, knownTypes); } var reader = jsonExample.CreateReader(); reader.MoveToContent(); var message = Message.CreateMessage(MessageVersion.None, (string)null, reader); WebOperationContext.Current.OutgoingResponse.ContentType = "text/plain"; message.Properties[WebBodyFormatMessageProperty.Name] = new WebBodyFormatMessageProperty(WebContentFormat.Json); return(message); } else { var xmlExample = new XDocument(); using (XmlWriter writer = XmlWriter.Create(xmlExample.CreateWriter(), settings)) { HelpExampleGenerator.GenerateXmlSample(schemaSet, name, writer); } var reader = xmlExample.CreateReader(); reader.MoveToContent(); var message = Message.CreateMessage(MessageVersion.None, (string)null, reader); message.Properties[WebBodyFormatMessageProperty.Name] = new WebBodyFormatMessageProperty(WebContentFormat.Xml); WebOperationContext.Current.OutgoingResponse.ContentType = "text/xml"; return(message); } }
private void ImportType(Type type, ArrayList mappings, ArrayList importedTypes, XmlReflectionImporter importer) { XmlTypeMapping xmlTypeMapping = null; var localImporter = new XmlReflectionImporter(); try { xmlTypeMapping = localImporter.ImportTypeMapping(type); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } return; } if (xmlTypeMapping != null) { xmlTypeMapping = importer.ImportTypeMapping(type); mappings.Add(xmlTypeMapping); importedTypes.Add(type); } }
/// <summary> /// Imports the XML types. /// </summary> /// <param name="type">The type.</param> /// <param name="mappings">The mappings.</param> /// <param name="importedTypes">The imported types.</param> /// <param name="importer">The importer.</param> private static void ImportXmlTypes(Type type, List <XmlMapping> mappings, List <Type> importedTypes, XmlReflectionImporter importer) { XmlTypeMapping mapping = null; var importer2 = new XmlReflectionImporter(); try { mapping = importer2.ImportTypeMapping(type); } catch (Exception exception) { if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException)) { throw; } return; } if (mapping != null) { mapping = importer.ImportTypeMapping(type); mappings.Add(mapping); importedTypes.Add(type); } }
internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs) { try { string methodId = methodInfo.GetKey(); SoapReflectedMethod soapMethod = new SoapReflectedMethod(); MethodAttribute methodAttribute = new MethodAttribute(); object serviceAttr = GetSoapServiceAttribute(methodInfo.DeclaringType); bool serviceDefaultIsEncoded = ServiceDefaultIsEncoded(serviceAttr); object methodAttr = GetSoapMethodAttribute(methodInfo); if (methodAttr == null) { if (client) { return(null); // method attribute required on the client } if (serviceAttr is SoapRpcServiceAttribute) { SoapRpcMethodAttribute method = new SoapRpcMethodAttribute(); method.Use = ((SoapRpcServiceAttribute)serviceAttr).Use; methodAttr = method; } else if (serviceAttr is SoapDocumentServiceAttribute) { SoapDocumentMethodAttribute method = new SoapDocumentMethodAttribute(); method.Use = ((SoapDocumentServiceAttribute)serviceAttr).Use; methodAttr = method; } else { methodAttr = new SoapDocumentMethodAttribute(); } } if (methodAttr is SoapRpcMethodAttribute) { SoapRpcMethodAttribute attr = (SoapRpcMethodAttribute)methodAttr; soapMethod.rpc = true; soapMethod.use = attr.Use; soapMethod.oneWay = attr.OneWay; methodAttribute.action = attr.Action; methodAttribute.binding = attr.Binding; methodAttribute.requestName = attr.RequestElementName; methodAttribute.requestNs = attr.RequestNamespace; methodAttribute.responseName = attr.ResponseElementName; methodAttribute.responseNs = attr.ResponseNamespace; } else { SoapDocumentMethodAttribute attr = (SoapDocumentMethodAttribute)methodAttr; soapMethod.rpc = false; soapMethod.use = attr.Use; soapMethod.paramStyle = attr.ParameterStyle; soapMethod.oneWay = attr.OneWay; methodAttribute.action = attr.Action; methodAttribute.binding = attr.Binding; methodAttribute.requestName = attr.RequestElementName; methodAttribute.requestNs = attr.RequestNamespace; methodAttribute.responseName = attr.ResponseElementName; methodAttribute.responseNs = attr.ResponseNamespace; if (soapMethod.use == SoapBindingUse.Default) { if (serviceAttr is SoapDocumentServiceAttribute) { soapMethod.use = ((SoapDocumentServiceAttribute)serviceAttr).Use; } if (soapMethod.use == SoapBindingUse.Default) { soapMethod.use = SoapBindingUse.Literal; } } if (soapMethod.paramStyle == SoapParameterStyle.Default) { if (serviceAttr is SoapDocumentServiceAttribute) { soapMethod.paramStyle = ((SoapDocumentServiceAttribute)serviceAttr).ParameterStyle; } if (soapMethod.paramStyle == SoapParameterStyle.Default) { soapMethod.paramStyle = SoapParameterStyle.Wrapped; } } } if (methodAttribute.binding.Length > 0) { if (client) { throw new InvalidOperationException(Res.GetString(Res.WebInvalidBindingPlacement, methodAttr.GetType().Name)); } soapMethod.binding = WebServiceBindingReflector.GetAttribute(methodInfo, methodAttribute.binding); } WebMethodAttribute webMethodAttribute = methodInfo.MethodAttribute; // soapMethod.name = webMethodAttribute.MessageName; if (soapMethod.name.Length == 0) { soapMethod.name = methodInfo.Name; } string requestElementName; if (soapMethod.rpc) { // in the case when we interop with non .net we might need to chnage the method name. requestElementName = methodAttribute.requestName.Length == 0 || !client ? methodInfo.Name : methodAttribute.requestName; } else { requestElementName = methodAttribute.requestName.Length == 0 ? soapMethod.name : methodAttribute.requestName; } string requestNamespace = methodAttribute.requestNs; if (requestNamespace == null) { if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0) { requestNamespace = soapMethod.binding.Namespace; } else { requestNamespace = defaultNs; } } string responseElementName; if (soapMethod.rpc && soapMethod.use != SoapBindingUse.Encoded) { // NOTE: this rule should apply equally to rpc/lit and rpc/enc, but to reduce risk, i'm only applying it to rpc/lit responseElementName = methodInfo.Name + "Response"; } else { responseElementName = methodAttribute.responseName.Length == 0 ? soapMethod.name + "Response" : methodAttribute.responseName; } string responseNamespace = methodAttribute.responseNs; if (responseNamespace == null) { if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0) { responseNamespace = soapMethod.binding.Namespace; } else { responseNamespace = defaultNs; } } SoapParameterInfo[] inParameters = ReflectParameters(methodInfo.InParameters, requestNamespace); SoapParameterInfo[] outParameters = ReflectParameters(methodInfo.OutParameters, responseNamespace); soapMethod.action = methodAttribute.action; if (soapMethod.action == null) { soapMethod.action = GetDefaultAction(defaultNs, methodInfo); } soapMethod.methodInfo = methodInfo; if (soapMethod.oneWay) { if (outParameters.Length > 0) { throw new ArgumentException(Res.GetString(Res.WebOneWayOutParameters), "methodInfo"); } if (methodInfo.ReturnType != typeof(void)) { throw new ArgumentException(Res.GetString(Res.WebOneWayReturnValue), "methodInfo"); } } XmlReflectionMember[] members = new XmlReflectionMember[inParameters.Length]; for (int i = 0; i < members.Length; i++) { SoapParameterInfo soapParamInfo = inParameters[i]; XmlReflectionMember member = new XmlReflectionMember(); member.MemberName = soapParamInfo.parameterInfo.Name; member.MemberType = soapParamInfo.parameterInfo.ParameterType; if (member.MemberType.IsByRef) { member.MemberType = member.MemberType.GetElementType(); } member.XmlAttributes = soapParamInfo.xmlAttributes; member.SoapAttributes = soapParamInfo.soapAttributes; members[i] = member; } soapMethod.requestMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, requestElementName, requestNamespace, methodAttribute.requestNs == null, members, true, false, methodId, client); if (GetSoapServiceRoutingStyle(serviceAttr) == SoapServiceRoutingStyle.RequestElement && soapMethod.paramStyle == SoapParameterStyle.Bare && soapMethod.requestMappings.Count != 1) { throw new ArgumentException(Res.GetString(Res.WhenUsingAMessageStyleOfParametersAsDocument0), "methodInfo"); } string elementName = ""; string elementNamespace = ""; if (soapMethod.paramStyle == SoapParameterStyle.Bare) { if (soapMethod.requestMappings.Count == 1) { elementName = soapMethod.requestMappings[0].XsdElementName; elementNamespace = soapMethod.requestMappings[0].Namespace; } // else: can't route on request element -- we match on an empty qname, // normal rules apply for duplicates } else { elementName = soapMethod.requestMappings.XsdElementName; elementNamespace = soapMethod.requestMappings.Namespace; } soapMethod.requestElementName = new XmlQualifiedName(elementName, elementNamespace); if (!soapMethod.oneWay) { int numOutParams = outParameters.Length; int count = 0; CodeIdentifiers identifiers = null; if (methodInfo.ReturnType != typeof(void)) { numOutParams++; count = 1; identifiers = new CodeIdentifiers(); } members = new XmlReflectionMember[numOutParams]; for (int i = 0; i < outParameters.Length; i++) { SoapParameterInfo soapParamInfo = outParameters[i]; XmlReflectionMember member = new XmlReflectionMember(); member.MemberName = soapParamInfo.parameterInfo.Name; member.MemberType = soapParamInfo.parameterInfo.ParameterType; if (member.MemberType.IsByRef) { member.MemberType = member.MemberType.GetElementType(); } member.XmlAttributes = soapParamInfo.xmlAttributes; member.SoapAttributes = soapParamInfo.soapAttributes; members[count++] = member; if (identifiers != null) { identifiers.Add(member.MemberName, null); } } if (methodInfo.ReturnType != typeof(void)) { XmlReflectionMember member = new XmlReflectionMember(); member.MemberName = identifiers.MakeUnique(soapMethod.name + "Result"); member.MemberType = methodInfo.ReturnType; member.IsReturnValue = true; member.XmlAttributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider); member.XmlAttributes.XmlRoot = null; // Ignore XmlRoot attribute used by get/post member.SoapAttributes = new SoapAttributes(methodInfo.ReturnTypeCustomAttributeProvider); members[0] = member; } soapMethod.responseMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, responseElementName, responseNamespace, methodAttribute.responseNs == null, members, false, false, methodId + ":Response", !client); } SoapExtensionAttribute[] extensionAttributes = (SoapExtensionAttribute[])methodInfo.GetCustomAttributes(typeof(SoapExtensionAttribute)); soapMethod.extensions = new SoapReflectedExtension[extensionAttributes.Length]; for (int i = 0; i < extensionAttributes.Length; i++) { soapMethod.extensions[i] = new SoapReflectedExtension(extensionAttributes[i].ExtensionType, extensionAttributes[i]); } Array.Sort(soapMethod.extensions); SoapHeaderAttribute[] headerAttributes = (SoapHeaderAttribute[])methodInfo.GetCustomAttributes(typeof(SoapHeaderAttribute)); Array.Sort(headerAttributes, new SoapHeaderAttributeComparer()); Hashtable headerTypes = new Hashtable(); soapMethod.headers = new SoapReflectedHeader[headerAttributes.Length]; int front = 0; int back = soapMethod.headers.Length; ArrayList inHeaders = new ArrayList(); ArrayList outHeaders = new ArrayList(); for (int i = 0; i < soapMethod.headers.Length; i++) { SoapHeaderAttribute headerAttribute = headerAttributes[i]; SoapReflectedHeader soapHeader = new SoapReflectedHeader(); Type declaringType = methodInfo.DeclaringType; if ((soapHeader.memberInfo = declaringType.GetField(headerAttribute.MemberName)) != null) { soapHeader.headerType = ((FieldInfo)soapHeader.memberInfo).FieldType; } else if ((soapHeader.memberInfo = declaringType.GetProperty(headerAttribute.MemberName)) != null) { soapHeader.headerType = ((PropertyInfo)soapHeader.memberInfo).PropertyType; } else { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderMissing); } if (soapHeader.headerType.IsArray) { soapHeader.headerType = soapHeader.headerType.GetElementType(); soapHeader.repeats = true; if (soapHeader.headerType != typeof(SoapUnknownHeader) && soapHeader.headerType != typeof(SoapHeader)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType); } } if (MemberHelper.IsStatic(soapHeader.memberInfo)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderStatic); } if (!MemberHelper.CanRead(soapHeader.memberInfo)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderRead); } if (!MemberHelper.CanWrite(soapHeader.memberInfo)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderWrite); } if (!typeof(SoapHeader).IsAssignableFrom(soapHeader.headerType)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType); } SoapHeaderDirection direction = headerAttribute.Direction; if (soapMethod.oneWay && (direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderOneWayOut); } if (headerTypes.Contains(soapHeader.headerType)) { SoapHeaderDirection prevDirection = (SoapHeaderDirection)headerTypes[soapHeader.headerType]; if ((prevDirection & direction) != 0) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebMultiplyDeclaredHeaderTypes); } headerTypes[soapHeader.headerType] = direction | prevDirection; } else { headerTypes[soapHeader.headerType] = direction; } if (soapHeader.headerType != typeof(SoapHeader) && soapHeader.headerType != typeof(SoapUnknownHeader)) { XmlReflectionMember member = new XmlReflectionMember(); member.MemberName = soapHeader.headerType.Name; member.MemberType = soapHeader.headerType; XmlAttributes a = new XmlAttributes(soapHeader.headerType); if (a.XmlRoot != null) { member.XmlAttributes = new XmlAttributes(); XmlElementAttribute attr = new XmlElementAttribute(); attr.ElementName = a.XmlRoot.ElementName; attr.Namespace = a.XmlRoot.Namespace; member.XmlAttributes.XmlElements.Add(attr); } member.OverrideIsNullable = true; if ((direction & SoapHeaderDirection.In) != 0) { inHeaders.Add(member); } if ((direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0) { outHeaders.Add(member); } soapHeader.custom = true; } soapHeader.direction = direction; // Put generic header mappings at the end of the list so they are found last during header processing if (!soapHeader.custom) { soapMethod.headers[--back] = soapHeader; } else { soapMethod.headers[front++] = soapHeader; } } soapMethod.inHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, requestElementName + "InHeaders", defaultNs, true, (XmlReflectionMember[])inHeaders.ToArray(typeof(XmlReflectionMember)), false, true, methodId + ":InHeaders", client); if (!soapMethod.oneWay) { soapMethod.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, responseElementName + "OutHeaders", defaultNs, true, (XmlReflectionMember[])outHeaders.ToArray(typeof(XmlReflectionMember)), false, true, methodId + ":OutHeaders", !client); } return(soapMethod); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } throw new InvalidOperationException(Res.GetString(Res.WebReflectionErrorMethod, methodInfo.DeclaringType.Name, methodInfo.Name), e); } }
public static bool TryAddSchemaTypeFromXmlSchemaProviderAttribute(this XmlDictionaryWriter writer, Type type, string name, SoapSerializer serializer, XmlNamespaceManager xmlNamespaceManager = null, bool isUnqualified = false) { if (!UseXmlSchemaProvider && !UseXmlReflectionImporter) { return(false); } if (UseXmlReflectionImporter) { var schemas = new XmlSchemas(); var xmlImporter = new XmlReflectionImporter(); var exporter = new XmlSchemaExporter(schemas); var xmlTypeMapping = xmlImporter.ImportTypeMapping(type, new XmlRootAttribute() { ElementName = name }); exporter.ExportTypeMapping(xmlTypeMapping); schemas.Compile(null, true); var memoryStream = new MemoryStream(); foreach (XmlSchema schema in schemas) { schema.Write(memoryStream); } memoryStream.Position = 0; var streamReader = new StreamReader(memoryStream); var result = streamReader.ReadToEnd(); var doc = new XmlDocument(); doc.LoadXml(result); doc.DocumentElement.WriteContentTo(writer); return(true); } var xmlSchemaSet = xmlNamespaceManager == null ? new XmlSchemaSet() : new XmlSchemaSet(xmlNamespaceManager.NameTable); var xmlSchemaProviderAttribute = type.GetCustomAttribute <XmlSchemaProviderAttribute>(true); if (xmlSchemaProviderAttribute != null && true) { XmlSchema schema = new XmlSchema(); if (xmlNamespaceManager != null) { schema.Namespaces = xmlNamespaceManager.Convert(); } if (xmlSchemaProviderAttribute.IsAny) { //MetaWCFBodyWriter usage.... //writer.WriteAttributeString("name", name); //writer.WriteAttributeString("nillable", "true"); //writer.WriteStartElement("xs", "complexType", Namespaces.XMLNS_XSD); //writer.WriteStartElement("xs", "sequence", Namespaces.XMLNS_XSD); //writer.WriteStartElement("xs", "any", Namespaces.XMLNS_XSD); //writer.WriteAttributeString("minOccurs", "0"); //writer.WriteAttributeString("processContents", "lax"); //writer.WriteEndElement(); //writer.WriteEndElement(); //writer.WriteEndElement(); var sequence = new XmlSchemaSequence(); sequence.Items.Add(new XmlSchemaAny() { ProcessContents = XmlSchemaContentProcessing.Lax }); var complex = new XmlSchemaComplexType() { Particle = sequence }; var element = new XmlSchemaElement() { MinOccurs = 0, MaxOccurs = 1, Name = name, IsNillable = serializer == SoapSerializer.DataContractSerializer, SchemaType = complex }; if (isUnqualified) { element.Form = XmlSchemaForm.Unqualified; } schema.Items.Add(element); } else { var methodInfo = type.GetMethod(xmlSchemaProviderAttribute.MethodName, BindingFlags.Static | BindingFlags.Public); var xmlSchemaInfoObject = methodInfo.Invoke(null, new object[] { xmlSchemaSet }); var element = new XmlSchemaElement() { MinOccurs = 0, MaxOccurs = 1, Name = name, }; if (xmlSchemaInfoObject is XmlQualifiedName xmlQualifiedName) { element.SchemaTypeName = xmlQualifiedName; } else if (xmlSchemaInfoObject is XmlSchemaType xmlSchemaType) { element.SchemaType = xmlSchemaType; } else { throw new InvalidOperationException($"Invalid {nameof(xmlSchemaInfoObject)} type: {xmlSchemaInfoObject.GetType()}"); } if (isUnqualified) { element.Form = XmlSchemaForm.Unqualified; } schema.Items.Add(element); } var memoryStream = new MemoryStream(); schema.Write(memoryStream); memoryStream.Position = 0; var streamReader = new StreamReader(memoryStream); var result = streamReader.ReadToEnd(); var doc = new XmlDocument(); doc.LoadXml(result); doc.DocumentElement.WriteContentTo(writer); return(true); } return(false); }