Question

我想只强制在基本抽象类的给定属性上实现C＃getter。如果需要，派生类也可以为该属性提供一个setter，以供公共使用静态绑定类型。

给出以下抽象类：

public abstract class Base
{
    public abstract int Property { get; }
}

如果我想要一个也实现了setter的派生类，我可以天真地尝试：

public class Derived : Base
{
    public override int Property
    {
        get { return field; }
        set { field = value; } // Error : Nothing to override.
    } 

    private int field;
}

但是我遇到语法错误，因为我试图覆盖不存在的setter。我尝试了其他方式，例如声明基本setter私有等等，我仍然偶然发现所有类型的错误阻止我这样做。必须有办法做到这一点，因为它不会破坏任何基类合同。

事件上，可以使用接口完成，但我确实需要默认实现。

我经常偶然发现这种情况，我想知道是否有隐藏的C＃语法技巧，否则我将使用它并实现手动SetProperty（）方法。

Answer 1

您不能直接执行此操作，因为您不能在同一类型上使用相同签名new和override;有两个选项 - 如果您控制基类，则添加第二个属性：

public abstract class Base
{
    public int Property { get { return PropertyImpl; } }
    protected abstract int PropertyImpl {get;}
}
public class Derived : Base
{
    public new int Property {get;set;}
    protected override int PropertyImpl
    {
        get { return Property; }
    }
}

否则，您可以在类层次结构中引入额外的级别：

public abstract class Base
{
    public abstract int Property { get; }
}
public abstract class SecondBase : Base
{
    public sealed override int Property
    {
        get { return PropertyImpl; }
    }
    protected abstract int PropertyImpl { get; }
}
public class Derived : SecondBase
{
    public new int Property { get; set; }

    protected override int PropertyImpl
    {
        get { return Property; }
    }
}

Answer 2

如下：

public abstract class Base
{
    public virtual int Property
    {
        get { return this.GetProperty(); }
        set { }
    }

    protected abstract int GetProperty();
}

Answer 3

这会满足您的需求吗？

public abstract class TheBase
{
    public int Value
    {
        get;
        protected set;
    }
}
public class TheDerived : TheBase
{
    public new int Value
    {
        get { return base.Value; }
        set { base.Value = value; }
    }
}

virtual已被删除，但基值仍然是该值的唯一存储空间。所以这应该显示'5'。编译器应该对b.Value = 4;

大惊小怪

TheDerived d = new TheDerived();
d.Value = 5;
TheBase b = d;
//b.Value = 4;    // uncomment for compiler error
cout << "b.Value == " << b.Value << endl;

-Jesse

Answer 4

我有一个类似的要求，我需要一个接口，以便能够在两个松散相关的类之间共享通用的排序功能。其中一个具有只读Order属性，另一个具有读写Order属性，但我需要一种方法从两个类中以相同的方式读取属性。

事实证明，这可以通过在派生接口中隐藏只读值来完成。我就是这样做的。

interface ISortable
{
    int Order { get; }
}

interface ISortableClass2
    : ISortable
{
    // This hides the read-only member of ISortable but still satisfies the contract
    new int Order { get; set; }
}

class SortableClass1
    : ISortable
{
    private readonly int order;

    public SortableClass1(int order)
    {
        this.order = order;
    }

    #region ISortable Members

    public int Order
    {
        get { return this.order; }
    }

    #endregion
}

class SortableClass2
    : ISortableClass2
{
    #region ISortableClass2 Members

        public int Order { get; set; } 

    #endregion
}

class RunSorting
{
    public static void Run()
    {
        // Test SortableClass1
        var list1 = new List<SortableClass1>();

        list1.Add(new SortableClass1(6));
        list1.Add(new SortableClass1(1));
        list1.Add(new SortableClass1(5));
        list1.Add(new SortableClass1(2));
        list1.Add(new SortableClass1(4));
        list1.Add(new SortableClass1(3));

        var sorted1 = SortObjects(list1);

        foreach (var item in sorted1)
        {
            Console.WriteLine("SortableClass1 order " + item.Order);
        }

        // Test SortableClass2
        var list2 = new List<SortableClass2>();

        list2.Add(new SortableClass2() { Order = 6 });
        list2.Add(new SortableClass2() { Order = 2 });
        list2.Add(new SortableClass2() { Order = 5 });
        list2.Add(new SortableClass2() { Order = 1 });
        list2.Add(new SortableClass2() { Order = 4 });
        list2.Add(new SortableClass2() { Order = 3 });

        var sorted2 = SortObjects(list2);

        foreach (var item in sorted2)
        {
            Console.WriteLine("SortableClass2 order " + item.Order);
        }
    }

    private static IEnumerable<T> SortObjects<T>(IList<T> objectsToSort) where T : ISortable
    {
        if (objectsToSort.Any(x => x.Order != 0))
        {
            return objectsToSort.OrderBy(x => x.Order);
        }

        return objectsToSort;
    }
}

Answer 5

您可以使用以下构造函数来做到这一点；

public abstract class Base
{
    public abstract int Property { get; }
}


public class Derived : Base
{
    public Derived(string Property) : base(Property)
    {

    }
}

将抽象readonly属性覆盖为读/写属性

5 个答案: