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);
}
