Question

https://stackoverflow.com/questions/1833216/why-does-this-work-method-overloading-method-overriding-poly吗?” 问题似乎与你一样,可以采用这种方法。我想知道的是,在我尝试使用财产时,为什么不工作。

public class Foo
{
    public virtual object Value
    {
        get;
        set;
    }
}

public class Foo<T> : Foo
{
    public override object Value
    {
        get
        {
            return base.Value;
        }
        set
        {
            base.Value = (T)value; //inject type-checking on sets
        }
    }

    public new T Value
    {
        get { return (T)base.Value; }
        set { base.Value = value; }
    }
}

C#4.0RC1的错误信息

Error 1 The type ClassLibrary1.Foo already contains a definition for Value ClassLibrary1Class1.cs 31 22 ClassLibrary1

Answer 1

你用同一名称拥有两个财产。 C#不允许这样做。唯一的例外是索引编制,因为就索引编制而言,签名按指数类别变更。

不能超负荷使用一种只能因返回类型而有所不同的方法。单一名称的财产基本上受到同一规则的禁止,因为它是内部的一种方法,没有向进入者提出理由。

Answer 2

如果你做以下事情的话,你可以这样做。

public interface IFoo<T>
{
    T Value { get; set; }
}

public class Foo<T> : Foo, IFoo<T>
{
    T IFoo.Value
    {
        get { return (T)base.Value; }
        set { base.Value = value; }
    }
}

唯一一件事是,当你提到时,你必须使用接口类型......。

   IFoo<int> myfoo = new Foo<int>();
   int result = myFoo.Value;    //This will give you the typed version

   Foo<int> myfoo = new Foo<int>();
   int result = myFoo.Value;    //This will give throw an exception

Answer 3

C++/CLI能够做到这一点,即使C#能够发挥作用。在C++/CLI中,你可以明确说,哪些方法是压倒一切的,因此名字不必相应。

Answer 4

你们可以带着一种灵感。

public interface IFoo
{
    object Value { get; set; }
}

public class Foo<T> : IFoo
{
    object _value = null;
    object IFoo.Value
    {
        get { return _value; }
        set { _value = value; }
    }

    public T Value
    {
        get;
        set;
    }
}

Answer 5

根本问题是,永远无法知道哪一种财产可以使用。

例如,

Foo<int> s = new Foo<int>();

s.Value = "hmmm";

因此应当使用哪些财产? 不动产也来自物品,也符合一般财产版本的限制。

Answer 6

您对同一财产有两种定义:<代码>Value,一种由上下定义,另一种是新定义。返回类型在方法签名中并不区分特征,即如果签名在返回类型上仅有所不同,则该签名被视为相同。因此,使用压倒性或新的。

在你看来,你可以使用新的而不是压倒目标。然而,在使用新办法时,你必须始终认为执行取决于要求执行方法的类型。页: 1

var foo = new Foo();
var foo_ = new Foo<string>();

foo.Value            // calls the implementation on Foo 
foo_.Value           // calls the implementation on Foo<T>
((Foo) foo).Value    // calls the implementation on Foo

友情链接