массивы сложных типов с наследованием protobuf-net - PullRequest
Новая
       15

массивы сложных типов с наследованием protobuf-net

1 голос
/ 15 августа 2011

У меня есть иерархия, скажем, BaseClass <- DerivedClass Я хочу сериализовать массив BaseClass [] со смешанными объектами DerivedClass и BaseClass <br>Я использую версию исходного кода V2 r438 (9 августа 2011 г.)

Псевдокод: myArray = new BaseClass [] {new BaseClass (), new DerivedClass ()};

Я пробовал несколько объявлений, но не получил желаемого результата: 

[ProtoMember(1, AsReference = true, DynamicType = true)]
private BaseClass[] myArray;

-> Не десериализовать все ссылки не установлены 

[ProtoMember(1, AsReference = true, DynamicType = true)]
private object[] myArray;

-> deserailze, но тип массива изменен с BaseClass [] на object []

Любые предложения, как я могу получить свой оригинальный BaseClass [] возвращать массив?

[Редактировать] Юнит-тесты: 

namespace TechnologyEvaluation.Protobuf.ArrayOfBaseClassTest
{
    using System;
    using NUnit.Framework;
    using ProtoBuf;
    using ProtoBuf.Meta;

    [ProtoContract]
    class BaseClassArrayContainerClass
    {
        [ProtoMember(1, DynamicType = true)]
        public Base[] BaseArray { get; set; }
    }

    [ProtoContract]
    class ObjectArrayContainerClass
    {
        [ProtoMember(1, DynamicType = true)]
        public object[] ObjectArray { get; set; }

    }
    [ProtoContract]
    class Base
    {
        [ProtoMember(1)]
        public string BaseClassText { get; set; }
    }

    [ProtoContract]
    class Derived: Base
    {
        [ProtoMember(1)]
        public string DerivedClassText { get; set; }
    }

    [TestFixture]
    class ArrayOfBaseClassTests : AssertionHelper
    {
        [Test]
        public void TestObjectArrayContainerClass()
        {
            var model = CreateModel();
            var container = new ObjectArrayContainerClass();
            container.ObjectArray = this.CreateArray();
            var cloned = (ObjectArrayContainerClass) model.DeepClone(container);
            Expect(cloned.ObjectArray, Is.Not.Null);

            foreach (var obj in cloned.ObjectArray )
            {
                Expect(obj as Base, Is.Not.Null);
            }

            Expect(cloned.ObjectArray[1] as Derived, Is.Not.Null);
            Expect(cloned.ObjectArray.GetType(), Is.EqualTo(typeof(Base[])));

        }

        [Test]
        public void TestBaseClassArrayContainerClass()
        {
            var model = CreateModel();
            var container = new BaseClassArrayContainerClass();
            container.BaseArray = this.CreateArray();
            var cloned = (BaseClassArrayContainerClass) model.DeepClone(container);
            Expect(cloned.BaseArray, Is.Not.Null);

            foreach (var obj in cloned.BaseArray)
            {
                Expect(obj as Base, Is.Not.Null);
            }
            Expect(cloned.BaseArray[1] as Derived, Is.Not.Null);
            Expect(cloned.BaseArray.GetType(), Is.EqualTo(typeof(Base[])));
        }

        RuntimeTypeModel CreateModel()
        {
            RuntimeTypeModel model = RuntimeTypeModel.Create();

            model.Add(typeof(ObjectArrayContainerClass), true);
            model.Add(typeof(BaseClassArrayContainerClass), true);
            model.Add(typeof(Base), true);
            model[typeof(Base)].AddSubType(100, typeof(Derived));

            return model;
        }

        Base[] CreateArray()
        {
            return new Base[] { new Base() { BaseClassText = "BaseClassText" }, new Derived() { BaseClassText = "BaseClassText", DerivedClassText = "DerivedClassText" } };
        }
    }
}
...