Como estructura de clases para implementar IEquatable y ISerializable

Question

estado golpeando mi cabeza en esto por un tiempo ahora

El problema que tengo está tratando de añadir el comportamiento IEquatable así que mis clases derivadas pueden utilizar operaciones de conjuntos de intersección de ILink etc.

En el momento en que he ...

public interface ILink
{
    int Linkid { get; set; }
    bool IsActive { get; set; }
}

y un montón de clases derivadas como

public class Domain : ILink
{
     public Domain(){}
}


public class User : ILink 
{
      public User (){}
}

lo que a fin de hacer intersección de la lista Pensé en crear una clase abstracta como tal ...

public abstract class AbstractLink : IEquatable<ILink>, ISerializable, ILink
{

    public AbstractLink(){}

    public AbstractLink(SerializationInfo info, StreamingContext ctxt)
    {}
    public virtual void GetObjectData(SerializationInfo info, StreamingContext ctxt)
    {}

}

Sin embargo, cuando me cambio los tipos derivados de

 public class DomainLink : ILink
 {

 }

a

 public class DomainLink : AbstractLink
 {

 }

consigo un SerializationException "Miembro 'linkid' no ha sido encontrado." que es la primera miembro intenta deserializar

Por cierto: se trata de interacción remota de ahí la necesidad de que la serialización personalizada - ¿hay alguna manera de componer estos comportamientos juntos

?

Muchas gracias!

M

Answer 1

Su código de ejemplo no compila. No se implementan los elementos de interfaz iLink.

El siguiente código funciona.

Cada objeto que anula AbstractLink requiere un constructor serialización. Cada subclase de AbstractLink también debe ser anotado con [Serializable]. Si se agrega propiedades adicionales a los objetos de dominio que también tendrá que aplicar GetObjectData () para las propiedades adicionales.

using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public interface ILink
{
    int Linkid { get; set; }
    bool IsActive { get; set; }
}

[Serializable]
public class Domain : AbstractLink
{
    public Domain()
    {
    }

    public Domain(SerializationInfo info, StreamingContext ctx) 
        : base(info, ctx)
    {
    }
}

[Serializable]
public class User : AbstractLink
{
    public string UserName { get; set; }

    public User()
    {
    }

    public User(SerializationInfo info, StreamingContext ctx) 
        : base(info, ctx)
    {
        UserName = info.GetString("UserName");
    }

    public override void GetObjectData(SerializationInfo info, StreamingContext ctx)
    {
        base.GetObjectData(info, ctx);
        info.AddValue("UserName", UserName);
    }
}

public abstract class AbstractLink : ISerializable, ILink, IEquatable<ILink>
{
    public AbstractLink() { }

    public AbstractLink(SerializationInfo info, StreamingContext ctx)
    {
        Linkid = info.GetInt32("Linkid");
        IsActive = info.GetBoolean("IsActive");
    }

    public virtual void GetObjectData(SerializationInfo info, StreamingContext ctx)
    {
        info.AddValue("Linkid", Linkid);
        info.AddValue("IsActive", IsActive);
    }

    public bool Equals(ILink other)
    {
        if (ReferenceEquals(null, other))
            return false;

        if (ReferenceEquals(this, other))
            return true;

        return other.Linkid == Linkid && other.IsActive.Equals(IsActive);
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj))
            return false;

        if (ReferenceEquals(this, obj))
            return true;

        return obj.GetType() == typeof(AbstractLink) && Equals((AbstractLink) obj);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            return (Linkid * 397) ^ IsActive.GetHashCode();
        }
    }

    public int Linkid { get; set; }
    public bool IsActive { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var user = new User { UserName = "user", IsActive = true, Linkid = 1 };
        User user2;

        using (var ms = new MemoryStream())
        {
            var bf = new BinaryFormatter();
            bf.Serialize(ms, user);
            ms.Flush();

            ms.Seek(0, SeekOrigin.Begin);
            user2 = bf.Deserialize(ms) as User;
        }

        Debug.Assert(user2 != null);
        Debug.Assert(ReferenceEquals(user, user2) == false);
        Debug.Assert(Equals(user.Linkid, user2.Linkid));
        Debug.Assert(Equals(user.IsActive, user2.IsActive));
        Debug.Assert(Equals(user.UserName, user2.UserName));
    }
}