Question

我正在试图序列化这个数据结构：

protected string EngineQualifiedName
{
    get { return Engine == null ? null : Engine.AssemblyQualifiedName; }
    set { Engine = value == null? null : Type.GetType(value); }
}

public Type Engine { get; protected set; }

public string Method { get; protected set; }

public Type[] ParameterTypes { get; protected set; }

显然，问题与ParameterTypes的序列化有关。在堆栈溢出中阅读其他类似问题，我写了一个像这样的格式化程序：

public static IFormatter Formatter(IEnumerable<Type> paramTypes)
{
    RuntimeTypeModel.Default.Add(typeof(ProtoBufRequest), true).Add(1, "ParameterCompositeValues").Add(2, "EngineQualifiedName").Add(3, "Method");
    var ct = RuntimeTypeModel.Default.Add(typeof(CompositeType), true);         
    var ctType = typeof (CompositeType<>);

    var j = 0;
    foreach (var paramType in paramTypes)
    {
        try
        {
            RuntimeTypeModel.Default.Add(paramType, true);
        }
        catch
        { }

        ct.AddSubType(j + 4, ctType.MakeGenericType(paramType));

        j++;
    }

    return RuntimeTypeModel.Default.CreateFormatter(typeof (ProtoBufRequest));
}

我已经使用这些属性和类来掩盖Type：

的数组

private CompositeType[] ParameterCompositeValues
{
    get
    {
        if (ParameterValues == null)
            return null;

        var create = typeof (CompositeType).GetMethod("Create");
        return
            ParameterValues.Select(
                    (t, i) => (CompositeType) create.MakeGenericMethod(ParameterTypes[i]).Invoke(null, new[] {t})).ToArray();
    }
    set
    {
        ParameterValues = value == null ? null : value.Select(v => v.Value).ToArray();
    }
}

[ProtoContract(UseProtoMembersOnly = true)]
internal abstract class CompositeType
{
    protected abstract object ValueImpl { get; set; }

    public object Value
    {
        get { return ValueImpl; }
        set { ValueImpl = value; }
    }


    public static CompositeType<T> Create<T>(T value)
    {
        return new CompositeType<T> {Value = value};
    }
}


[ProtoContract(UseProtoMembersOnly = true)]
internal class CompositeType<T> : CompositeType
{
    [ProtoMember(1)]
    public new T Value { get; set; }

    protected override object ValueImpl
    {
        get { return Value; }
        set { Value = (T) value; }
    }
}

我的问题实际上是，当我尝试序列化泛型类（例如，扬声器，其中T未知）时，格式化程序面临一些问题，并且在反序列化中我获得一个空类，其所有值都是空值。难道我做错了什么？通用类以正确的方式序列化，但如果我尝试以这种方式设置它们，则此消息系统无法正确序列化和反序列化：\

任何帮助将不胜感激！

使用Protobuf .Net序列化未知类型的数组

0 个答案: