0

私は単純なオブジェクトを持っています

[ProtoContract]
public class DataChangedEventArgs<T> : EventArgs
{
    private readonly object key;
    private readonly T data;
    private readonly DataChangeType changeType;

    ///<summary>
    /// Key to identify the data item
    ///</summary>
    public object Key
    {
        get { return key; }
    }

    [ProtoMember(2, IsRequired = true)]
    public T Data
    {
        get { return data; }
    }

    [ProtoMember(3, IsRequired = true)]
    public DataChangeType ChangeType
    {
        get { return changeType; }
    }

そしてキーに問題があります。その型は object ですが、int、long、または string のいずれかです。私は直感的に ProtoInclude 属性を使用して「これらの型を期待する」と言いますが、残念ながらそれらはクラスのみの属性です。これを回避する方法を知っている人はいますか? 背景として、公開オブジェクト Key は歴史的な理由から (そしてあちこちに) ここにあるので、すべてのリファクタリングの母を避けたいと思います ;-) これをシリアル化する可​​能性があれば、強制的にシリアル化することさえできます。文字列 ？

4

1 に答える 1

2

実際、うまくいくかもしれないいくつかのトリックがあります。あなたが言及したstringものは非常に単純です（ でマークされたプライベートプロパティを使用することにより[ProtoMember]）が、どのタイプに変換して戻すかをどのように知るかはわかりません。

ただし、有限数の型 (事前にわかっている) を処理する継承ベース ( [ProtoInclude]) の方法があります。ここに関連する例がありますが、このケースにより具体的にできることがわかります...

文字列ベースのアプローチに関しては、プレフィックスを使用できますか? つまり、次のようなものです:

public object Key {get;set;}

[ProtoMember(1)]
private object KeyString {
    get {
        if(Key == null) return null;
        if(Key is string) return "s:"+(string)Key;
        if(Key is int) return "i:"+Key.ToString();
        // etc
    }
    set {
        if(value == null) { Key = null; }
        else if(value.StartsWith("s:")) {...}
        // etc
    }
}

わかった; これが例です。固定キーを使用する方がはるかに優れていることを強調します。以下は少し見にくいですが、ほとんどのコードは隠して再利用できるので、それほど悪くはないかもしれません。ただし、より厳密に型指定されたキーを使用したいと思います。私はそれについて言及したかもしれません;-p

using System;
using ProtoBuf;
static class Program
{
    static void Main()
    {
        var message1 = new SomeMessageWithVariableKey<string>(123456, "abcdef");
        var clone1 = Serializer.DeepClone(message1);
        Console.WriteLine(clone1.Key);
        Console.WriteLine(clone1.SomeOtherValue);

        var message2 = new SomeMessageWithVariableKey<int>("abcdef", 123456);
        var clone2 = Serializer.DeepClone(message2);
        Console.WriteLine(clone2.Key);
        Console.WriteLine(clone2.SomeOtherValue);
    }
}

[ProtoContract]
[ProtoInclude(1, typeof(ProtoKey<int>))]
[ProtoInclude(2, typeof(ProtoKey<string>))]
abstract class ProtoKey
{
    public static ProtoKey Create(object key)
    {
        if (key == null) return null;
        if (key is string) return new ProtoKey<string> { Value = key };
        if (key is int) return new ProtoKey<int> { Value = key };
        throw new ArgumentException("Unexpected key type: " + key.GetType().Name);
    }

    public abstract object Value { get; protected set;}
    public override string ToString()
    {
        return Convert.ToString(Value);
    }
    public override bool Equals(object obj)
    {
        ProtoKey other = obj as ProtoKey;
        if (other == null) return false;
        return object.Equals(Value, other.Value);
    }
    public override int GetHashCode()
    {
        object val = Value;
        return val == null ? 0 : val.GetHashCode();
    }
}
[ProtoContract]
sealed class ProtoKey<T> : ProtoKey
{
    [ProtoMember(1)]
    public T TypedValue { get; set; }
    public override object Value
    {
        get { return TypedValue; }
        protected set { TypedValue = (T)value; }
    }
}

[ProtoContract]
public class SomeMessageWithVariableKey<T>
{
    private SomeMessageWithVariableKey() { }
    public SomeMessageWithVariableKey(object key, T someOtherValue) {
        Key = key;
        SomeOtherValue = someOtherValue;
    }
    public object Key { get; private set; }

    [ProtoMember(1)]
    private ProtoKey SerializationKey
    {
        get { return ProtoKey.Create(Key); }
        set { Key = value == null ? null : value.Value; }
    }
    [ProtoMember(2)]
    public T SomeOtherValue { get; set; }
}
于 2009-09-24T15:52:29.333 に答える