Question

在此代码中：

using System;

namespace ConsoleApp1
{
    public class TextInput
    {
        protected string _text = "";

        public void Add(char c)
        {
            _text += c;
        }

        public string GetValue()
        {
            return _text;
        }
    }


    public class NumericInput : TextInput
    {
        public new void Add(char c)
        {
            if (!char.IsDigit(c)) return;
            _text += c;
        }
    }


    public class Program
    {
        public static void Main(string[] args)
        {
            TextInput input = new NumericInput();
            input.Add('1');
            input.Add('a');
            input.Add('0');
            Console.WriteLine(input.GetValue());

            Console.WriteLine(char.IsDigit('1'));
            Console.WriteLine(char.IsDigit('a'));
            Console.WriteLine(char.IsDigit('0'));
        }
    }
}

...调用Console.WriteLine(char.IsDigit('a'));会正确返回False，但是在覆盖的Add方法中，它总是返回True。

很明显，它调用TextInput.Add()而不是NumericInput.Add()。可以在覆盖的Add()方法中更正此问题吗？ Main中的代码可能不会更改！

Answer 1

检查c＃中new和override之间的区别。另外，请看一下虚拟密钥。

我现在不解释。这里和网络上都有很多有关此的信息。

MS文档：https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/knowing-when-to-use-override-and-new-keywords

此处有更多信息：Difference between new and override

总结起来，在这种情况下使用替代。同时尝试它们，您将意识到它们是如何工作的。

Answer 2

如果要实现方法重写，请在基类中使用virtual关键字，在派生类中使用override关键字。

namespace ConsoleApp1
{
    public class TextInput
    {
        protected string _text = "";
        //Virtual allows derived class to enhance its functionality.
        public virtual void Add(char c)
        {
            _text += c;
        }
        ....
    }


    public class NumericInput : TextInput
    {
        //Override function will add more functionality to base class function
        public override void Add(char c)
        {
            if (!char.IsDigit(c)) return;
            _text += c;
        }
    }

现在new关键字不会覆盖基类功能，它将隐藏基类功能。

如果要覆盖派生类中的函数，请使用override而不是new关键字

有关更多参考，请访问：Stackoverflow thread

Answer 3

为什么不使用抽象类：

因为我们有多个add实现，而且不能在T上使用运算符，所以将其声明为抽象并在派生类上实现

public abstract class Input<T>
    {
        protected T __input;
        public abstract void Add(T c);
        public T GetValue()
        {
            return __input;
        }
    }
    public class NumericInput : Input<int>
    {
        public override void Add(int c)
        {
            __input += c;
        }
    }
    public class TextInput : Input<string>
    {
        public override void Add(string c)
        {
            __input += c;
        }
    }

static void Main(string[] args)
        {
            var input = new NumericInput();
            input.Add(1);
            input.Add(2);
            Console.WriteLine(input.GetValue());

            var text = new TextInput();
            text.Add("a");
            text.Add("a");
            text.Add("a");
            Console.WriteLine(text.GetValue());

            Console.ReadLine();
        }

调用用于基本类型的重写方法

3 个答案: