Блог

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

 public class Type
{
    private List<Slow> slowField;

    private List<Fast> FastField;
    
    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute("SLOW", Order=1)]
    public List<Slow> SLOW
    {
        get
        {
            return this.slowField;
        }
        set
        {
            this.slowField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute("FAST", Order=2)]
    public List<Fast> FAST
    {
        get
        {
            return this.FastField;
        }
        set
        {
            this.FastField = value;
        }
    }
}
 

Выходной ток :

 <Type>
<SLOW>S1</SLOW>
<SLOW>S2</SLOW>
<SLOW>S3</SLOW>
<FAST>F1</FAST>
<FAST>F2</FAST>
<FAST>F3</FAST>
</Type>
 

Мне нужен этот вывод:

 <Type>
<SLOW>S1</SLOW>
<FAST>F1</FAST>
<SLOW>S2</SLOW>
<FAST>F2</FAST>
<SLOW>S3</SLOW>
<FAST>F3</FAST>
</Type>
 

Один из подходов состоял бы в том, чтобы ввести третью коллекцию, которая объединила бы две существующие коллекции в желаемом порядке. Например,

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

 public class Fast
{
    public int Value{get;set;}
}

public class Slow
{
    public int Value{get;set;}
}
 

Теперь вы можете ввести базовый класс (или использовать System.Объект как общая база) для обоих типов. Например,

 public class Base{}

public class Fast:Base
{
    public int Value{get;set;}
}

public class Slow:Base
{
    public int Value{get;set;}
}
 

Теперь вы можете добавить третью коллекцию в свой класс типа следующим образом

 [XmlElement("SLOW", Type = typeof(Slow))]
[XmlElement("FAST", Type = typeof(Fast))]
public List<Base> Complete => GetMergedList();

private List<Base> GetMergedList()
{
  int minLen = Math.Min(SLOW.Count, FAST.Count);

  var list = SLOW.Take(minLen)
            .Zip(FAST.Take(minLen), (a, b) => new Base[] { a, b })
            .SelectMany(array => array)
            .Concat(SLOW.Skip(minLen))
            .Concat(FAST.Skip(minLen));
  return list.ToList();
}
 

Обратите внимание, что код предполагает, что быстрые и медленные коллекции уже отсортированы по отдельности, но если нет, необходимо добавить логическую сортировку.

Вам также потребуется пометить существующие свойства, XmlIgnoreAttribute чтобы пропустить их во время сериализации.

 [XmlIgnore]
public List<Slow> SLOW
{
....
}

[XmlIgnore]
public List<Fast> SLOW
{
....
}
 

Теперь вы можете сериализовать экземпляр типа, чтобы получить желаемый результат.

Демонстрационный код

Просто чередуйте выходные данные, если итерация нечетная, распечатайте первый список, если четный, распечатайте второй. Сделайте что-нибудь подобное :

 for( int i = 1; i < ListLength; i  ) 
{
if( i%2 == 0)
{
// put here your second list dont forget to put i-1 since we started with 1 in for
print(" The value is even");
}
else 
{
//put here your first list
print("the value is odd");
}
}
 

Вот комплексное решение с использованием IXmlSerialize. Я не знаю подробностей Быстрых и Медленных занятий. Поэтому я просто сортирую внутренний текст xml — элемента

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;
using System.Xml.Linq;
using System.IO;
using System.Text.RegularExpressions;

namespace ConsoleApplication2
{
    class Program
    {
        const string FILENAME = @"c:temptest.xml";
        static void Main(string[] args)
        {
            Type test = new Type()
            {
                FAST = new List<Fast>() { new Fast() { value = "F1" }, new Fast() { value = "F2" }, new Fast() { value = "F3" } },
                SLOW = new List<Slow>() { new Slow() { value = "S1" }, new Slow() { value = "S2" }, new Slow() { value = "S3" } }
            };

            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            XmlWriter writer = XmlWriter.Create(FILENAME, settings);
            XmlSerializer serializer = new XmlSerializer(typeof(Type));
            serializer.Serialize(writer, test);

        }
    }
    public class Fast
    {
        public string value { get; set; }
    }
    public class Slow
    {
        public string value { get; set; }
    }

    public class Type : IXmlSerializable
    {
        private List<Slow> slowField;
        private List<Fast> FastField;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("SLOW", Order = 1)]
        public List<Slow> SLOW
        {
            get
            {
                return this.slowField;
            }
            set
            {
                this.slowField = value;
            }
        }
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("FAST", Order = 2)]
        public List<Fast> FAST
        {
            get
            {
                return this.FastField;
            }
            set
            {
                this.FastField = value;
            }
        }
        public void WriteXml(XmlWriter writer)
        {
            string pattern = @"(?'prefix'.*)(?'suffix'd )";

            XmlSerializer fastSerializer = new XmlSerializer(typeof(Fast));
            XmlSerializer slowSerializer = new XmlSerializer(typeof(Slow));
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.OmitXmlDeclaration = true;
            settings.ConformanceLevel = ConformanceLevel.Fragment;
            settings.Indent = true;
            MemoryStream ms = new MemoryStream();
            XmlWriter childWriter = XmlWriter.Create(ms,settings);
            childWriter.WriteRaw("<Root>");
            foreach(Slow slow in slowField)
            {
                slowSerializer.Serialize(childWriter,slow);
                //childWriter.WriteRaw("n");
            }
            foreach (Fast fast in FastField)
            {
                fastSerializer.Serialize(childWriter, fast);
                //childWriter.WriteRaw("n");
            }
            childWriter.WriteRaw("</Root>");
            childWriter.Flush();
            ms.Position = 0; ;
            string text = Encoding.UTF8.GetString(ms.GetBuffer()); 
            XElement rootElement = XElement.Load(ms);
            var orderChildren = rootElement.Elements()
                .Select(x => new { match = Regex.Match((string)x, pattern), element = x })
                .Select(x => new { prefix = x.match.Groups["prefix"].Value, suffix = x.match.Groups["suffix"].Value, element = x.element })
                .OrderBy(x => x.suffix)
                .ThenBy(x => x.prefix)
                .ToList();

            foreach(var orderChild in orderChildren)
            {
                orderChild.element.WriteTo(writer);
            }
        }
        public void ReadXml(XmlReader reader)
        {
            XmlSerializer fastSerializer = new XmlSerializer(typeof(Fast));
            XmlSerializer slowSerializer = new XmlSerializer(typeof(Slow));
            while (!reader.EOF)
            {
                if (reader.Name == "SLOW")
                {
                    if (slowField == null) slowField = new List<Slow>();
                    slowField.Add((Slow)slowSerializer.Deserialize(reader));
                }
                if (reader.Name == "FAST")
                {
                    if (FastField == null) FastField = new List<Fast>();
                    FastField.Add((Fast)slowSerializer.Deserialize(reader));
                }
            }

        }
        public XmlSchema GetSchema()
        {
            return (null);
        }
    }
}