3

我有一大群对象都来自单亲。对象都知道如何判断它们是否已被修改，但我还需要能够查看与内存中已有的对象相比是否已修改对象的新实例（测试以查看其他人是否更新了数据库在编辑对象时。）

结果是每个子类都必须包含相同的方法：

public new bool Changed()
{
    return Changed(this);
}

这确实困扰着我，但我认为没有办法解决它，因为真正的工作需要由一个函数完成，该函数接受与其所在类相同类型的参数——因此它不能是虚拟的。（当然，我可以将它定义为每次都接受父对象并强制转换它，但这使得比较函数接受树中的任何对象，而不仅仅是正确的对象，并且它在每个实例中都需要保护代码，这又是一件难看的事情。）

当然这可行，但我不喜欢丑陋的代码。

更新：至于Changed函数，每个对象在加载时都会保留其状态的副本。

4

3 回答 3

3

只要您的基类是abstract，您就可以执行以下操作：

abstract class Base
{
    public abstract bool Changed<T>(T obj) where T : Base;

    public bool Changed()
    {
        return Changed(this);
    }
}

class Subclass : Base
{
    public override bool Changed<Subclass>(Subclass obj)
    {
        // Do stuff here
    }
}
于 2012-05-23T22:56:00.957 回答
2

基本结构：

public abstract class Base<T> where T : Base<T>
{
    public T Original { get; private set; }

    public abstract bool Changed(T o);

    public bool Changed()
    {
        return this.Changed(Original);
    }
}

public class DerivedA : Base<DerivedA>
{
    public override bool Changed(DerivedA o)
    {
        throw new NotImplementedException();
    }
}

public class DerivedB : Base<DerivedB>
{
    public override bool Changed(DerivedB o)
    {
        throw new NotImplementedException();
    }
}

虽然它有其缺点（可读性），但在这种情况下它可能是正确的选择，因为您的问题不是经典动物/狗/猫意义上的类型保护，而是代码共享。

为了防止这种情况：

public class DerivedC : DerivedB
{
}
new DerivedB().Changed(new DerivedC()); // compiles

你可以密封DerivedB。

或者你可以继续疯狂（我不推荐这个。绝对不会超过这个水平）：

public abstract class DerivedE<T> : Base<DerivedE<T>> where T : DerivedE<T>
{
}

public class DerivedF : DerivedE<DerivedF>
{
}

public class DerivedG : DerivedE<DerivedG>
{
}

new DerivedF().Changed(new DerivedG()); // does not compile
new DerivedF().Changed(new DerivedF()); // does compile

请参阅此http://blogs.msdn.com/b/ericlippert/archive/2011/02/03/curiouser-and-curiouser.aspx。我从那篇文章中得到了灵感。他讨论了利弊。

编辑：清理，根据评论调整

于 2012-05-23T22:56:36.983 回答
0

与 minitech 的答案相同，因此他应该得到信任，但在此示例中，SubclassA 的 Changed 可以通过强制转换为完全命名的类来查看其属性。

namespace ConsoleApplication1
{

    abstract class Base 
    {     
        protected abstract bool Changed<T>(T obj) where T : Base;      
        public bool Changed()     
        {         
            return Changed(this);     
        }

        public String PropBase { get; set; }
    }  

    class SubclassA : Base 
    {
        public String PropA { get; set; }

        protected override bool Changed<SubclassA>(SubclassA obj)     
        {
            ConsoleApplication1.SubclassA myInstance = obj as ConsoleApplication1.SubclassA;
            // Now can see PropA
            myInstance.PropA = "A";
            return true;
        }


    }

    class SubclassB : Base
    {
        protected override bool Changed<SubclassB>(SubclassB obj)
        {
            // can't see prop B here 
            // obj.PropB = "B";
            return true;
        }

        public String PropB { get; set; }
    } 


    class Program
    {
        static void Main(string[] args)
        {

            SubclassB x = new SubclassB();

            x.Changed();

            Base y = new SubclassA();

            y.Changed();
        }
    }
}
于 2012-05-23T23:43:49.300 回答