我想只有从基抽象类强制C＃吸气的实施在给定的属性。 派生类可能，如果他们愿意，也供公众使用的静态绑定类型提供该属性的设置。
考虑下面的抽象类：
public abstract class Base
{
public abstract int Property { get; }
}
如果我想要一个派生类还实现了一个二传手，我天真地尝试：
public class Derived : Base
{
public override int Property
{
get { return field; }
set { field = value; } // Error : Nothing to override.
}
private int field;
}
但后来我得到一个语法错误，因为我试图重写不存在的二传手。 我尝试了一些其他的方式，例如，宣布基地二传手私人和这样的，我还是偶然发现所有样的错误阻止我这样做的。 必须有一个办法做到这一点，因为它不会破坏任何基类合同。
Incidentaly，它可以用接口来完成，但我真的需要一个默认的实现。
我偶然到这种情况所以很多时候，我在想，如果有一个隐藏的C＃语法伎俩要做到这一点，否则我将只是生活并实现手动的SetProperty（）方法。
你不能直接这样做，因为你不能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; }
}
}
什么是这样的：
public abstract class Base
{
public virtual int Property
{
get { return this.GetProperty(); }
set { }
}
protected abstract int GetProperty();
}
这会满足您的需求？
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
我有地方，我需要的接口，以便能够在两个松散的相关类之间有着共同的排序功能类似的要求。 其中一人有一个只读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;
}
}
