XmlSerialization e xsi: SchemaLocation (xsd.exe)
https://stackoverflow.com/questions/1408336
-
05-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu costumava xsd.exe para gerar uma classe C # para a leitura / escrita de arquivos GPX. Como faço para obter o arquivo XML resultante para incluir o atributo xsi: schemaLocation por exemplo.
Eu quero o seguinte, mas xsi: schemaLocation está sempre faltando
<?xml version="1.0"?>
<gpx
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
version="1.1"
xmlns="http://www.topografix.com/GPX/1/1"
creator="ExpertGPS 1.1 - http://www.topografix.com"
xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd">
</gpx>
Solução
Adicione isto a sua classe gerada C #:
[XmlAttribute("schemaLocation", Namespace = XmlSchema.InstanceNamespace)]
public string xsiSchemaLocation = "http://www.topografix.com/GPX/1/1 " +
"http://www.topografix.com/GPX/1/1/gpx.xsd";
Aparentemente, a ferramenta xsd.exe não gera o atributo schemaLocation.
Outras dicas
Você vai ter que fazer isso em seu próprio país. Não há nenhuma maneira para XML de serialização para saber onde você quer que seu esquema para ir em qualquer caso.
Tente isto, embora eu não testei ainda:
[XmlRoot(ElementName = "gpx", Namespace = GPX_NAMESPACE)]
public class WhateverAGpxIs
{
private const string GPX_NAMESPACE = "http://www.topografix.com/GPX/1/1";
private const string XSI_NAMESPACE =
"http://www.w3.org/2001/XMLSchema-instance";
[XmlAttribute(AttributeName = "creator")]
public string Creator = "ExpertGPS 1.1 - http://www.topografix.com";
[XmlNamespaceDeclarations]
public XmlSerializerNamespaces Namespaces =
new XmlSerializerNamespaces(
new[]
{
new XmlQualifiedName("xsi", XSI_NAMESPACE),
new XmlQualifiedName(string.Empty, GPX_NAMESPACE)
});
[XmlAttribute(AttributeName = "schemaLocation",
Namespace = XSI_NAMESPACE)]
public string SchemaLocation = GPX_NAMESPACE + " " +
"http://www.topografix.com/GPX/1/1/gpx.xsd";
[XmlAttribute(AttributeName = "version")]
public string Version = "1.1";
}
É claro que esta resposta é tarde demais! Mas talvez útil para outros desenvolvedores ;-). Eu costumava relfection para resolver este problema, porque tinha que ser automatizado.
O CreateMessageType método estático deve ser chamado. deve ser a classe serializada NÃO contendo a propriedade schemaLocation. Este método retorna um novo tipo usando o como pai (chamado Dynamic), mas adicionar as propriedades schemaLocation e conjuntos ElementName propriedade para do XmlRootAttribute.
Depois de criar o tipo, a reflexão deve ser novamente usado para criar o objeto e definir as propriedades.
Os olhares de código, como uma dor no xxx, mas funciona como um encanto!
Veja a codificação abaixo:
/// <summary>Copying the attributes of a type to a new type</summary>
private static void copyAttributes<TMessage>(TypeBuilder dynamictype)
{
try
{
//Iterate over all attributes of the TMessage class and copy these to the new type
IList<CustomAttributeData> attributes = CustomAttributeData.GetCustomAttributes(typeof(TMessage));
if (attributes != null)
{
foreach (CustomAttributeData attribute in attributes)
{
List<object> constructorarguments = new List<object>();
if (attribute.ConstructorArguments != null)
{
foreach (CustomAttributeTypedArgument argument in attribute.ConstructorArguments)
{
constructorarguments.Add(argument.Value);
}
}
List<FieldInfo> namedfields = new List<FieldInfo>();
List<object> namedfieldarguments = new List<object>();
List<PropertyInfo> namedproperties = new List<PropertyInfo>();
List<object> namedpropertyarguments = new List<object>();
if (attribute.NamedArguments != null)
{
//Iterate over all named arguments
foreach (CustomAttributeNamedArgument argument in attribute.NamedArguments)
{
//Check which type of argument is found
if (argument.MemberInfo is FieldInfo)
{
FieldInfo field = argument.MemberInfo as FieldInfo;
namedfields.Add(field);
namedfieldarguments.Add(argument.TypedValue.Value);
}
else if (argument.MemberInfo is PropertyInfo)
{
PropertyInfo property = argument.MemberInfo as PropertyInfo;
namedproperties.Add(property);
namedpropertyarguments.Add(argument.TypedValue.Value);
}
}
}
//Check if the current attribute is of type XmlRoot.
//In this case the ElementName or TypeName property must also be set
if (attribute.Constructor.DeclaringType.Equals(typeof(XmlRootAttribute)))
{
namedproperties.Add(typeof(XmlRootAttribute).GetProperty("ElementName"));
namedpropertyarguments.Add(typeof(TMessage).Name);
}
//Build the copy of the parent attribute
CustomAttributeBuilder copyattributebuilder = new CustomAttributeBuilder(
attribute.Constructor,
constructorarguments.ToArray(),
namedproperties.ToArray(),
namedpropertyarguments.ToArray(),
namedfields.ToArray(),
namedfieldarguments.ToArray());
//Add the attribute to the dynamic type
dynamictype.SetCustomAttribute(copyattributebuilder);
}
}
}
catch (Exception exception)
{
throw new ApplicationException("Unable to copy attribute from parent type", exception);
}
}
/// <summary>Create dynamic type for an operation message which includes the types for serialization</summary>
/// <returns>Returns dynamic type</returns>
public static Type CreateMessageType<TMessage>()
{
try
{
AssemblyBuilder assemblybuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(Guid.NewGuid().ToString()), AssemblyBuilderAccess.Run);
ModuleBuilder modulebuilder = assemblybuilder.DefineDynamicModule(Guid.NewGuid().ToString(), false);
//Create type based on an unique so that it does not conflict with the OperationMessage classname
TypeBuilder typebuilder = modulebuilder.DefineType(typeof(TMessage).Name + "Dynamic", TypeAttributes.Public | TypeAttributes.Class);
//Set original message type as parent of the new dynamic type
typebuilder.SetParent(typeof(TMessage));
//Copy attributes from TMessage paren type to the dynamic type
WMQXMLMessageTypeFactory.copyAttributes<TMessage>(typebuilder);
//Create the xsi:schemaLocation property
CustomAttributeBuilder attributebuilder = new CustomAttributeBuilder(
typeof(XmlAttributeAttribute).GetConstructor(new Type[] { typeof(string) }),
new object[] { "schemaLocation" },
new PropertyInfo[] { typeof(XmlAttributeAttribute).GetProperty("Namespace") },
new object[] { XmlSchema.InstanceNamespace });
FieldBuilder schemalocationfieldbuilder = typebuilder.DefineField("SchemaLocation", typeof(string), FieldAttributes.Public);
schemalocationfieldbuilder.SetCustomAttribute(attributebuilder);
return typebuilder.CreateType();
}
catch (Exception exception)
{
throw new ApplicationException("Unable to create XML message type", exception);
}
}
O seguinte código que eu usei para criar o objeto
Type type = WMQXMLMessageTypeFactory.CreateMessageType<TenantRequest>();
MetaData metadata = new MetaData();
metadata.ID = Guid.NewGuid().ToString();
metadata.Created = DateTime.Now;
metadata.Application = new schemasdev.local.tenant.Application();
metadata.Application.Name = "Publish Tenant";
metadata.Application.Core = ApplicationCore.PropertySystem;
NewOperation newoperation = new NewOperation();
newoperation.Tenant = new Tenant();
newoperation.Tenant.Code = "001";
newoperation.Tenant.Name = "Mister X";
object request = type.GetConstructor(new Type[0]).Invoke(new object[0]);
(request as TenantRequest).MetaData = metadata;
(request as TenantRequest).New = newoperation;
//Setting the schema location property
type.InvokeMember("SchemaLocation", System.Reflection.BindingFlags.SetField, null, request, new object[] { "http://schemasdev.local/2012-01/Tenant/1.0/Tenant.xsd" });
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(type);
stream = new System.IO.MemoryStream();
serializer.Serialize(stream, request);
Console.WriteLine(UTF8Encoding.UTF8.GetString(stream.ToArray()));
E, eventualmente, a saída perfeita:
<?xml version="1.0"?>
<TenantRequest xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xsi:schemaLocation="http://schemasdev.local/2012-01/Tenant/1.0/Tenant.xsd" xmlns="http://schemasdev.local/2012-01/Tenant/1.0">
<MetaData xmlns="http://schemasdev.local/2012-01/Messaging/1.0">
<ID>b59938fd-8e68-4927-87da-6d92c609f159</ID>
<Application>
<Name>Publish Tenant</Name>
<Core>PropertySystem</Core>
</Application>
<Created>2012-02-20T10:07:54.645424+01:00</Created>
</MetaData>
<New>
<Tenant>
<Code>001</Code>
<Name>Mister X</Name>
</Tenant>
</New>
</TenantRequest>
Em vez de modificar a classe gerada por xsd.exe para adicionar o atributo schemaLocation você pode estender a classe e adicioná-lo em sua classe estendida.
Vamos dizer que o esquema original é chamado Myschema.xsd eo nome do arquivo gerado é MySchema.cs eo nome da classe é MySchema. Aqui está o que a classe gerada pode parecer:
[MySchema.cs]
namespace MyProgram.MySchemas {
using System.Xml.Serialization;
/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.17929")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
...
public partial class MySchema {
private string someField;
...
...
}
}
(Note que a classe é parcial. Isto significa que podemos estendê-lo.)
O que você precisa fazer é criar um outro arquivo, neste exemplo, vamos chamá-lo MySchemaExtender.cs. Este arquivo irá conter uma outra definição de classe parcial com o mesmo nome da classe MySchema:
[MySchemaExtender.cs]
namespace MyProgram.MySchemas {
using System.Xml.Serialization;
public partial class MySchema {
}
}
Agora tudo que você precisa fazer é colocar o atributo schemaLocation na classe estendida. Aqui está o que a sua classe estendida final será parecido com:
[MySchemaExtender.cs]
namespace MyProgram.MySchemas {
using System.Xml.Serialization;
public partial class MySchema {
[XmlAttribute("schemaLocation", Namespace = System.Xml.Schema.XmlSchema.InstanceNamespace)]
public string xsiSchemaLocation = @"http://someurl/myprogram http://someurl/myprogram/MySchema.xsd";
}
}
Agora, se você regenerar a classe usando xsd.exe você não terá que modificar nada.
