3

我正在尝试在 C# 中自学 OOP，但我有一个关于何时使用base. 我了解一般原则，但我不确定下面的示例中什么是最好的。这个简单的测试包括：

  • 具有interface两个string属性的
  • abstract实现此接口并添加更多string属性的类
  • 实现抽象类的两个类。一个使用base而另一个不使用，但它们在程序执行时都产生相同的输出。

我的问题是：在这个例子中，一种实现比另一种更可取吗？我不确定 和 之间是否有任何有意义的差异TranslationStyleA，TranslationStyleB或者是否只是个人喜好？

非常感谢您的时间和想法！

using System;

namespace Test
{
    interface ITranslation
    {
        string English { get; set; }
        string French { get; set; }
    }

    public abstract class Translation : ITranslation
    {
        public virtual string English { get; set; }
        public virtual string French { get; set; }

        public string EnglishToFrench { get { return English + " is " + French + " in French"; } }
        public string FrenchToEnglish { get { return French + " is " + English + " in English"; } }

        public Translation(string e, string f)
        {
            English = e;
            French = f;
        }
    }

    public class TranslationStyleA : Translation
    {
        public override string English
        {
            get { return base.English; }
            set { base.English = value; }
        }

        public override string French
        {
          get { return base.French; }
          set { base.French = value; }
        }

        public TranslationStyleA(string e, string f) : base(e, f)
        {
        }
    }

    public class TranslationStyleB : Translation
    {
        private string english;
        public override string English
        {
            get { return english; }
            set { english = value; }
        }

        private string french;
        public override string French
        {
            get { return french; }
            set { french = value; }
        }

        public TranslationStyleB(string e, string f) : base(e, f)
        {
            this.English = e;
            this.French = f;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            TranslationStyleA a = new TranslationStyleA("cheese", "fromage");
            Console.WriteLine("Test A:");
            Console.WriteLine(a.EnglishToFrench);
            Console.WriteLine(a.FrenchToEnglish);

            TranslationStyleB b = new TranslationStyleB("cheese", "fromage");
            Console.WriteLine("Test B:");
            Console.WriteLine(b.EnglishToFrench);
            Console.WriteLine(b.FrenchToEnglish);

            Console.ReadKey();
        }
    }
}
4

5 回答 5

5

您需要了解的第一件事是当您拥有自动属性时会发生什么：

public virtual string English { get; set; }

在幕后，编译器正在生成一个私有字段，并在您访问该属性时获取/设置该私有字段。相当于这个

private string _english;
public virtual string English { get { return _english; } set { _english = value; } }

除了您不知道私有字段的名称，因此您无法访问它。

因此，在您的TranslationStyleA课程中，您实际上并没有对 English 属性做任何事情，因为它只是直接访问基类的属性并且不会改变它的行为。 

    // None of this is even needed- we are just delegating to the base class
    public override string English
    {
        get { return base.English; }
        set { base.English = value; }
    }

现在在TranslationStyleB课堂上，您实际上正在更改属性的行为（尽管以一种相当无用的方式）。不是将 English 属性的值存储在基类的自动实现的私有变量中，而是将其存储在派生类级别定义的私有变量中：

    private string english;
    public override string English
    {
        get { return english; }
        set { english = value; }
    }

当然，这些实现都没有做任何事情，并且在实现时都不需要，因为基类本身完美地实现了属性。因此，鉴于您描述的代码，我对您最初问题的回答是两者都不是首选。

现在，让我们看一个与您的问题相关的示例。例如，如果你想改变它们的行为，你只需要覆盖它们。

    // We don't want any leading or trailing whitespace, so we remove it here.
    public override string English
    {
        get { return base.English; }
        set { base.English = value.Trim(); }
    }

我们想在这里委托给基类，因为首先这些是属性。从语义上讲，属性与字段相同：

public String Foo;
public String Foo { get; set; } // <-- why bother with all this extra { get; set; } stuff?

原因是从编译器的角度来看，从属性到字段的接口是一个重大变化。所以如果我改变

public String Foo;

到

public String Foo { get; set; }

然后任何依赖于我的代码的代码都需要重新编译。但是，如果我改变

public String Foo { get; set; }

到

private string _foo;
public String Foo { get { return _foo; } set { _foo = value.Trim(); } }

那么依赖代码仍然只看到公共属性，不需要重新编译（因为我的类的接口没有改变）。

如果此处的基类 ( Translation) 要更改其属性的行为，则English如下：

private string _english;
public String English { get { return _english; } set { _english = value.ToUpper(); } }

你会想在你的派生类中选择它！

因此，考虑到属性具有与之关联的行为，您应该始终委托给父类实现，除非该实现在您的派生类中产生不良影响。

于 2012-04-16T02:30:00.120 回答
4

第一种风格绝对是可取的，除非你有充分的理由选择另一种。

每个自动实现的属性Translation都添加了一个字段，样式 B 添加了更多而不是使用编译器添加的属性。样式 A 重用了编译器添加的样式，节省了一些存储空间。

此外，如果您不打算更改超类的功能，则无需覆盖超类的属性。你甚至可以像这样写另一种风格：

public class TranslationStyleC : Translation {
    public TranslationStyleC(string e, string f) : base(e, f) {
    }
}
于 2012-04-16T02:26:23.880 回答
3

您实际上不需要重写任何超类属性来实现您想要的效果，因为您不会以任何方式增强超类行为。

如果abstract从 base 中删除修饰符Translation，则不再需要子类，因为它在功能上等同于两者。

现在，至于何时使用base; 当您想要访问在子类中被覆盖的超类中的功能时，您应该使用它。base调用总是在编译时静态绑定到超类方法；即使超类方法是virtual（如您的情况）。对于base呼叫可能发生的奇怪事情，请查看此处。

于 2012-04-16T02:27:34.863 回答
2

如前所述，样式 A重用已声明的字段，而样式 B声明新字段。关于何时使用base的问题，经验法则是“只要您想重用父类中定义的逻辑/代码”。

于 2012-04-16T02:35:34.637 回答
1

它确实归结为您打算如何利用您的构造。

在实现时，TranslationStyleA 上的覆盖成员有点多余，因为消费者可以轻松访问基本成员，而无需在基本派生中提供覆盖。在这种情况下，如果这样做不会为设计增加任何价值，我个人根本不会费心重写基本成员。

当您真正想要覆盖基类成员的设置和访问时，第二种实现很常见，例如，如果基类成员的设置是启动另一个操作的催化剂，那么派生上的覆盖成员将是一个合适的地方发生这种情况。

于 2012-04-16T02:43:42.137 回答