.net XML serialização - Armazenamento de referência em vez de Objeto Copiar

Question

• Em .Net / C # Aplicação, tenho estruturas de dados que têm referências para o outro.
• Quando eu serializar-los, .Net Serializa todas as referências com as cópias de objetos separados.
• Na sequência exemplo, eu estou tentando serializar a matriz de 'Pessoa'

• A 'Pessoa' pode ter referência a uma outra pessoa.

  public class Person
  {
      public string Name;
      public Person Friend;
  }
  
  Person p1 = new Person();
  p1.Name = "John";
  
  Person p2 = new Person();
  p2.Name = "Mike";
  
  p1.Friend = p2;
  
  Person[] group = new Person[] { p1, p2 };
  XmlSerializer ser = new XmlSerializer(typeof(Person[]));
  using (TextWriter tw = new StreamWriter("test.xml"))
      ser.Serialize(tw,group );
  
  //above code generates following xml
  
  <ArrayOfPerson>
    <Person>
      <Name>John</Name>
      <Friend>
        <Name>Mike</Name>
      </Friend>
    </Person>
    <Person>
      <Name>Mike</Name>
    </Person>
  </ArrayOfPerson>
  

• No código acima, objeto da mesma 'Mike' estão lá em dois lugares, uma vez que existem duas referências para o mesmo objeto.

• Enquanto desserialização, tornam-se dois objetos diferentes, o que não é o estado exato em que eles são serializados.
• Eu quero evitar isso e ter apenas copiar do objeto em XML serializado, e todas as referências devem referir-se a esta cópia. Depois de desserialização, eu quero voltar, mesma estrutura de dados de idade.
• É possível?

Answer 1

Não é possível com XmlSerializer . Você poderia conseguir isso com DataContractSerializer usando o < a href = "http://msdn.microsoft.com/en-us/library/system.runtime.serialization.datacontractserializer.preserveobjectreferences.aspx" rel = "noreferrer"> PreserveObjectReferences propriedade. Você pode dar uma olhada neste pós que explica a detalhes.

Aqui está um código de exemplo:

public class Person
{
    public string Name;
    public Person Friend;
}

class Program
{
    static void Main(string[] args)
    {
        Person p1 = new Person();
        p1.Name = "John";

        Person p2 = new Person();
        p2.Name = "Mike";
        p1.Friend = p2;
        Person[] group = new Person[] { p1, p2 };

        var serializer = new DataContractSerializer(group.GetType(), null, 
            0x7FFF /*maxItemsInObjectGraph*/, 
            false /*ignoreExtensionDataObject*/, 
            true /*preserveObjectReferences : this is where the magic happens */, 
            null /*dataContractSurrogate*/);
        serializer.WriteObject(Console.OpenStandardOutput(), group);
    }
}

Isso produz o seguinte XML:

<ArrayOfPerson z:Id="1" z:Size="2" xmlns="http://schemas.datacontract.org/2004/07/ToDelete" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
    <Person z:Id="2">
        <Friend z:Id="3">
            <Friend i:nil="true"/>
            <Name z:Id="4">Mike</Name>
        </Friend>
        <Name z:Id="5">John</Name>
    </Person>
    <Person z:Ref="3" i:nil="true"/>
</ArrayOfPerson>

Agora definir PreserveObjectReferences para false no construtor, e você obterá o seguinte:

<ArrayOfPerson xmlns="http://schemas.datacontract.org/2004/07/ToDelete" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
    <Person>
        <Friend>
            <Friend i:nil="true"/>
            <Name>Mike</Name>
        </Friend>
        <Name>John</Name>
    </Person>
    <Person>
        <Friend i:nil="true"/>
        <Name>Mike</Name>
    </Person>
</ArrayOfPerson>

Vale a pena mencionar que o XML produzido desta forma não é interoperável e só pode ser desserializado com um DataContractSerializer (mesma observação como com o BinaryFormatter ).

Answer 2

Você pode usar ExtendedXmlSerializer. Aqui é um exemplo de serialização referência de objecto e de referência circular

Se você tem uma classe:

public class Person
{
    public int Id { get; set; }

    public string Name { get; set; }

    public Person Boss { get; set; }
}

public class Company
{
    public List<Person> Employees { get; set; }
}

então você criar o objeto com referência circular, como este:

var boss = new Person {Id = 1, Name = "John"};
boss.Boss = boss; //himself boss
var worker = new Person {Id = 2, Name = "Oliver"};
worker.Boss = boss;
var obj = new Company
{
    Employees = new List<Person>
    {
        worker,
        boss
    }
};

Você deve configurar classe Person como objeto de referência:

var serializer = new ConfigurationContainer().ConfigureType<Person>()
                                             .EnableReferences(p => p.Id)
                                             .Create();

No final, você pode serializar seu objeto:

var xml = serializer.Serialize(obj);

xml saída será parecido com este:

<?xml version="1.0" encoding="utf-8"?>
<Company xmlns="clr-namespace:ExtendedXmlSerializer.Samples.ObjectReference;assembly=ExtendedXmlSerializer.Samples">
  <Employees>
    <Capacity>4</Capacity>
    <Person Id="2">
      <Name>Oliver</Name>
      <Boss Id="1">
        <Name>John</Name>
        <Boss xmlns:exs="https://extendedxmlserializer.github.io/v2" exs:entity="1" />
      </Boss>
    </Person>
    <Person xmlns:exs="https://extendedxmlserializer.github.io/v2" exs:entity="1" />
  </Employees>
</Company>

Suporte ExtendedXmlSerializer .net 4,5 e .net Core.