是否可以在 Silverlight 中使用 protobuf-net 来（反）序列化私有财产？

Question

众所周知，Silverlight 不允许私有反射。尽管如此，我还是有一个带有私有设置器的公共财产，我需要能够对其进行序列化（这里没有问题）和反序列化（令人沮丧）。

我知道世界上没有任何东西可以使 protobuf-net 写入 Silverlight 中的此属性，这必须在客户端类型（或程序集，如果属性是内部的）内完成。

Silverlight 的 protobuf-net 中是否有一个使之成为可能的方案？我可以使该类型实现一些专门的 protobuf-net 接口（例如 IProtoSerialized）。

谢谢。

编辑

我可以提出这样的方案：

[ProtoMember(N, SetterMethod = "DeserializePropValue")]
public string property Prop
{
  get { return m_prop; }
  private set { m_prop = value; }
}

public void DeserializePropValue(ProtoValue<string> value)
{
  m_prop = value.Value;
}

其中类型 ProtoValue 是公共的，但其构造函数是内部的，因此只有 protobuf-net 程序集可以创建该类型的实例。当然，protobuf-net 不会公开任何公共 API 来创建 ProtoValue 对象。

该方案仅支持 Silverlight 平台，其他平台只会调用私有 setter。

你怎么认为？

EDIT2

我想指出的是，人们肯定仍然可以获得对任意 PropValue的引用。例如，但这不会是偶然的，这些是我希望消除的属性的意外覆盖。另外，我想让 setter 保持非公开状态，这样它就不会出现在 UI 中使用的各种基于反射的绑定机制中。

EDIT3

PropValue实例可能不适合存储，这意味着在 DeserializePropValue 方法返回后，相应的 PropValue 实例将失效。这就只剩下一种滥用它的方式，就像这样：

[ProtoContract]
public class Abusee
{
    [ProtoMember(1, SetterMethod = "DeserializePropValue")]
    public string property Prop { get; private set; }

    public void DeserializePropValue(ProtoValue<string> value)
    {
      m_prop = value.Value;
    }
}

[ProtoContract]
public class Abuser
{
  private Abusee m_abusee;

  public Abuser(Abusee abusee, string newPropValue)
  {
    m_abusee = abusee;
    Dummy = newPropValue;
    Serializer.DeepClone(this);
  }

  [ProtoMember(1, SetterMethod = "DeserializeDummyValue")]
  public string property Dummy
  {
    get;
    private set;
  }

  public void DeserializeDummyValue(ProtoValue<string> value)
  {
    m_abusee.DeserializePropValue(value);
  }
}

相当多的努力是偶然发生的。至于故意虐待——这里没有回归。人们总是可以序列化一个对象，操作二进制序列化数据，然后将其反序列化回来。回归仅在于滥用的容易程度。然而，我的目标是：

• 防止意外错误
• 保持 setter 不公开
• 避免与代理相关的维护噩梦。

Answer 1

有趣的问题。 v2 中有一个“代理”的概念，它是为不可变对象（和结构）设计的，这可能有用 - 这取决于对象的复杂程度以及选项的吸引力。第二种选择可能是使属性表现出冰棒不变性。我将说明两者，但是：

• 在这种情况下，冰棒不变性只是半冰棒，并且很容易被回避；这个选项很方便，如果你只是想防止意外损坏，可能会很有用，
• 真正的不变性为你提供了更强的保护；本质上，代理充当“构建者”，但这永远不允许您改变现有实例。

请注意，目前无法在属性上指定代理（我可能会稍后添加；p） - 所以我使用了运行时模型来演示这一点：

class Program
{
    static void Main()
    {
        var obj = new Popsicle(3, 4);
        var clone = Serializer.DeepClone(obj);
        Debug.Assert(clone.Foo == obj.Foo);
        Debug.Assert(clone.Bar == obj.Bar);

        var model = TypeModel.Create();
        model.Add(typeof(MutableSurrogate), false).Add("Foo", "Bar");
        model.Add(typeof(ImmutableType), false).SetSurrogate(typeof(MutableSurrogate));
        // note you should re-use models (cache them) - or better: pre-generate a serializer dll
        var obj2 = new ImmutableType(5, 6);
        var clone2 = (ImmutableType)model.DeepClone(obj2);
        Debug.Assert(clone2.Foo == obj2.Foo);
        Debug.Assert(clone2.Bar == obj2.Bar);
    }
}

[ProtoContract] // should also work with DataContract etc
public class Popsicle
{
    public Popsicle() { }
    public Popsicle(int foo, int bar)
    {
        Foo = foo;
        this.bar = bar;
    }
    private int isBeingDeserialized;

    [ProtoBeforeDeserialization]
    public void BeforeDeserialization()
    {
        isBeingDeserialized++;
    }
    [ProtoAfterDeserialization]
    public void AfterDeserialization()
    {
        isBeingDeserialized--;
    }
    [ProtoMember(1)]
    public int Foo { get; set; } //  fully mutable

    private int bar;
    [ProtoMember(2)]
    public int Bar
    {
        get { return bar; }
        set
        {
            if (bar == value) return;
            if (isBeingDeserialized <= 0) throw new InvalidOperationException();
            bar = value;
        }
    }
}

public class ImmutableType
{
    private readonly int foo, bar;
    public ImmutableType(int foo, int bar)
    {
        this.foo = foo;
        this.bar = bar;
    }
    public int Foo { get { return foo; } }
    public int Bar { get { return bar; } }
}
public class MutableSurrogate
{
    public static implicit operator ImmutableType(MutableSurrogate surrogate)
    {            
        return surrogate == null ? null
            : new ImmutableType(surrogate.Foo, surrogate.Bar);
    }
    public static implicit operator MutableSurrogate(ImmutableType surrogate)
    {
        return surrogate == null ? null
            : new MutableSurrogate { Foo = surrogate.Foo, Bar = surrogate.Bar };
    }
    public int Foo { get; set; }
    public int Bar { get; set; }
}

我目前没有类似 IProtoSerialized 的东西。我仍在等待找到真正需要它的一件事......我不确定就是这个。

Answer 2

看起来 Jackson - Java Json 序列化器很好地解决了不可变类问题： http ://www.cowtowncoder.com/blog/archives/2010/08/entry_409.html

基本上注释工厂/构造函数方法并将其输入参数映射到不可变/只读属性。