C#: визуализация объекта в формате XML

Я ищу способ преобразования дерева объектов в XML. Было бы интересно написать, но я уверен, что кто-то уже написал это. Вот мой список пожеланий:

  • он не должен заботиться о конструкторах
  • он должен идеально обрабатывать круговые ссылки (не слишком суетился, как)
  • он не должен требовать изменений объектов-например, никаких пользовательских атрибутов
  • Он не должен заботиться или требовать известных типов (например,, XmlInclude)
  • XML должен быть очень простым - он должен быть удобочитаемым для людей членами оперативной группы
  • Если свойство не может быть сериализовано, оно должно просто подавить ошибку и продолжить
  • может обрабатывать списки и словари

Мне не нужно реконструировать объектную модель, поэтому решение только для записи отлично (вероятно, ожидается).

Я думаю, что со скидками:

  • XmlSerializer не нуждается конструкторы без параметров, без круговой опорной поддержки
  • DataContractSerializer-нужны атрибуты (opt in)
6
c# serialization xml

3 ответов

это похоже на то, что было бы просто написать с помощью отражения: учитывая экземпляр объекта, создайте элемент XML с его именем класса, а затем повторите все его свойства.

для каждого свойства создайте элемент с его именем:

  • если это тип значения, установите его текст в текст схемы XML его значения;
  • если он реализует IEnumerable, повторите его и создайте элемент для каждого элемента;
  • если это другой ссылочный тип, установите содержимое элемента в XML-представление свойства.

отслеживать циклические / множественные ссылки с хэш-набором, содержащим хэш-коды каждого объекта, который вы сериализовали; если вы найдете хэш-код объекта в хэш-наборе, вы уже сериализовали его. (Я не знаю, что вы хотите поместить в XML, если это произойдет.)

но нет, у меня нет кода, который делает это.

4

сообщение Роберта Россни заставило меня думать, что это, вероятно, меньше работы, чем я думал. Итак, вот очень грубая попытка. Он обрабатывает следующее:

  • если он не может прочитать свойство, он печатает исключение как значение
  • циклические ссылки и несколько экземпляров. Он связывает идентификатор с каждым элементом; если элемент появляется дважды,он просто указывает идентификатор ref. Идентификатор Ref уникален для графа объектов (вероятно, я должен использовать GUID, но это подходит моему нужда.)
  • у него нет проблем с производными типами
  • он не требует никаких атрибутов или конкретных конструкторов или другой ерунды
  • он может обрабатывать только для чтения свойства

вот пример вывода (в моих тестовых объектах продукт "валюта" в заказе выдает исключение). 

<Customer Ref="1">
  <FirstName>Paul</FirstName>
  <LastName>Stovell</LastName>
  <FullName>Paul Stovell</FullName>
  <Orders>
    <Order Ref="2">
      <SKU>Apples</SKU>
      <Price>27.30</Price>
      <Currency>Something bad happened</Currency>
      <Customer Ref="1" />
    </Order>
    <Order Ref="3">
      <SKU>Pears</SKU>
      <Price>17.85</Price>
      <Currency>Something bad happened</Currency>
      <Customer Ref="1" />
    </Order>
    <Order Ref="2" />
  </Orders>
</Customer>

вот пример объектной модели и использование:

static void Main(string[] args)
{
    var customer = new Customer();
    customer.FirstName = "Paul";
    customer.LastName = "Stovell";
    customer.Orders.Add(new Order(customer) { Price = 27.30M, SKU = "Apples"});
    customer.Orders.Add(new Order(customer) { Price = 17.85M, SKU = "Pears"});
    customer.Orders.Add(customer.Orders[0]);

    var output = new StringWriter();
    var writer = new XmlTextWriter(output);
    writer.Formatting = Formatting.Indented;
    WriteComplexObject("Customer", customer, writer);
    Console.WriteLine(output.ToString());
    Console.ReadKey();
}

class Customer
{
    private readonly List<Order> _orders = new List<Order>();

    public Customer()
    {
    }

    public string FirstName { get; set; }
    public string LastName { get; set; }

    public string FullName
    {
        // Read-only property test
        get { return FirstName + " " + LastName; }
    }

    public List<Order> Orders
    {
        // Collections test
        get { return _orders; }
    }
}

class Order
{
    private readonly Customer _customer;

    public Order(Customer customer)
    {
        _customer = customer;
    }

    public string SKU { get; set; }
    public decimal Price { get; set; }
    public string Currency
    {
        // A proprty that, for some reason, can't be read
        get
        {
            throw new Exception("Something bad happened");
        }
    }

    public Customer Customer
    {
        get { return _customer; }
    }
}

вот реализация:

public static void WriteObject(string name, object target, XmlWriter writer)
{
    WriteObject(name, target, writer, new List<object>(), 0, 10, -1);
}

private static void WriteObject(string name, object target, XmlWriter writer, List<object> recurringObjects, int depth, int maxDepth, int maxListLength)
{
    var formatted = TryToFormatPropertyValueAsString(target);
    if (formatted != null)
    {
        WriteSimpleProperty(name, formatted, writer);
    }
    else if (target is IEnumerable)
    {
        WriteCollectionProperty(name, (IEnumerable)target, writer, depth, maxDepth, recurringObjects, maxListLength);
    }
    else
    {
        WriteComplexObject(name, target, writer, recurringObjects, depth, maxDepth, maxListLength);
    }
}

private static void WriteComplexObject(string name, object target, XmlWriter writer, List<object> recurringObjects, int depth, int maxDepth, int maxListLength)
{
    if (target == null || depth >= maxDepth) return;
    if (recurringObjects.Contains(target))
    {
        writer.WriteStartElement(name);
        writer.WriteAttributeString("Ref", (recurringObjects.IndexOf(target) + 1).ToString());
        writer.WriteEndElement();
        return;
    }
    recurringObjects.Add(target);

    writer.WriteStartElement(name);
    writer.WriteAttributeString("Ref", (recurringObjects.IndexOf(target) + 1).ToString());
    foreach (var property in target.GetType().GetProperties())
    {
        var propertyValue = ReadPropertyValue(target, property);
        WriteObject(property.Name, propertyValue, writer, recurringObjects, depth + 1, maxDepth, maxListLength);
    }
    writer.WriteEndElement();
}

private static object ReadPropertyValue(object target, PropertyInfo property)
{
    try { return property.GetValue(target, null); }
    catch (Exception ex) { return ReadExceptionMessage(ex); }
}

private static string ReadExceptionMessage(Exception ex)
{
    if (ex is TargetInvocationException && ex.InnerException != null)
        return ReadExceptionMessage(ex.InnerException);
    return ex.Message;
}

private static string TryToFormatPropertyValueAsString(object propertyValue)
{
    var formattedPropertyValue = null as string;
    if (propertyValue == null)
    {
        formattedPropertyValue = string.Empty;
    }
    else if (propertyValue is string || propertyValue is IFormattable || propertyValue.GetType().IsPrimitive)
    {
        formattedPropertyValue = propertyValue.ToString();
    }
    return formattedPropertyValue;
}

private static void WriteSimpleProperty(string name, string formattedPropertyValue, XmlWriter writer)
{
    writer.WriteStartElement(name);
    writer.WriteValue(formattedPropertyValue);
    writer.WriteEndElement();
}

private static void WriteCollectionProperty(string name, IEnumerable collection, XmlWriter writer, int depth, int maxDepth, List<object> recurringObjects, int maxListLength)
{
    writer.WriteStartElement(name);
    var enumerator = null as IEnumerator;
    try
    {
        enumerator = collection.GetEnumerator();
        for (var i = 0; enumerator.MoveNext() && (i < maxListLength || maxListLength == -1); i++)
        {
            if (enumerator.Current == null) continue;
            WriteComplexObject(enumerator.Current.GetType().Name, enumerator.Current, writer, recurringObjects, depth + 1, maxDepth, maxListLength);
        }
    }
    catch (Exception ex)
    {
        writer.WriteElementString(ex.GetType().Name, ReadExceptionMessage(ex));
    }
    finally
    {
        var disposable = enumerator as IDisposable;
        if (disposable != null)
        {
            disposable.Dispose();
        }
        writer.WriteEndElement();
    }
}

Я бы по-прежнему интересно узнать, есть ли более проверенные и проверенные решения.

6

Я сомневаюсь, что вы найдете что-нибудь, что работает особенно хорошо во всех классах. Как вы указали, XmlSerializer-это лучшее усилие Microsoft в общем конце вещей до сих пор.

на другом конце визуализаторы, которые уникальны для определенного класса. Я не думаю, что есть еще много счастливой среды.

1