C# Design Pattern-Example Code Sharing for Derived Classes to Implement Non-Virtual Interface Traps

Understand the difference between interface methods and virtual methods

At first glance, there seems to be no difference between implementing an interface and overriding a virtual method. In fact, the difference between implementing an interface and overriding a virtual method is very different. big! ! !

Derived classes cannot override non-virtual members of the interface

The member methods declared in the interface are not virtual methods by default, so Derived classes cannot override the methods that implement the interface in the base class Non-virtual member.
Look at an example.
Define interface ITest:

    public interface ITest
    {        void Test();
    }

Base class and Derive class that implement the interface

    public class Base:ITest
    {        public Base()
        {
            Console.WriteLine("This is base constructor");
        }        //实现ITest接口
        public void Test()
        {
            Console.WriteLine("This is in base to ITest implement");
        }
    }    public class Derive :Base,ITest
    {        public Derive()
        {
            Console.WriteLine("This is derived constructor");

        }        //测试Derive类实现了ITest吗？？
        public void Test()
        {
            Console.WriteLine("This is in Derive to ITest implement");
        }
    }

Call ObjectBase and Derive:

            Base b = new Base();
            b.Test();

            Base d = new Derive();//将d声明为Base对象
            d.Test();
            Console.ReadLine();

Output results It is:

It can be seen that the behaviors implemented by the Test methods of instances b and d are all located in the base class! ! ! This shows that Derived classes cannot override members (non-virtual methods) that implement interfaces in the base class

However, please see the following call:

            Base b = new Base();
            b.Test();
            Derive d = new Derive(); //将d声明为Derive对象
            d.Test();
            Console.ReadLine();

The output result is :

Therefore, if you want an object that inherits to call the interface implementation method, you can only declare it as a Derive instance . This does not comply with the principle that variables in Effective C# are declared as base instances! ! !

Derived class method personality, convert base class method into virtual method

To avoid this confusion in usage, if it is true that the derived class implementation method is a personality behavior, then the implementation of the base class needs to be Add the virtual modifier before the interface method!
The code is modified as follows:

public class Base:ITest
    {        public Base()
        {
            Console.WriteLine("This is base constructor");
        }        public virtual void Test() //实现ITest接口的虚方法
        {
            Console.WriteLine("This is in base to ITest implemnt");
        }
    }    public class Derive :Base,ITest
    {        public Derive()
        {
            Console.WriteLine("This is derived constructor");

        }         public override void Test() //实现接口ITest的复写方法
        {
            Console.WriteLine("This is in Derive to ITest implemnt");
        }
    }

One implementation, multiple associated objects use

Observing the above code, we found that the interface implemented in the base class, if the derived class also wants to implement it If this interface is used, it inherits the interface implementation of the base class by default, so there is no need to repeatedly write code to implement the interface.

   public interface ITest
    {        void Test();
    }    public class Base:ITest
    {        public Base()
        {
            Console.WriteLine("This is base constructor");
        }        public void Test()
        {
            Console.WriteLine("This is in base to ITest implemnt");
        }
    }    public class Derive :Base,ITest
    {        public Derive()
        {
            Console.WriteLine("This is derived constructor");

        }
    }

Summary:
1. Derived cannot override non-virtual members of the interface;
2. If the derived class method is a personalized method, convert the base class method into a virtual method;
3 . If the base class implements the interface method, the derived class will also explicitly inherit this interface, but there is no need to implement it again! ! !

The above is the detailed content of C# Design Pattern-Example Code Sharing for Derived Classes to Implement Non-Virtual Interface Traps. For more information, please follow other related articles on the PHP Chinese website!