C# basic knowledge compilation: basic knowledge (8) interface

We have come across abstract classes before. Its characteristic is that subclasses must implement abstract modification methods. There are also virtual modified methods. Subclasses of virtual modified methods can be rewritten or used directly without rewriting. However, since C# is also single-inherited, when you define a parent class and then inherit to extend some classes, you will encounter inappropriate situations. Because we programmers use programming language to describe the world, it is best to organize classes, name classes, write methods, etc. in our projects to be similar to the real world, so that development will be effortless and bug fixes will be easier.
For example, in a project, many forms are used. Some forms need to reprocess their closing events, and some need to process their resize events. But it is always very annoying to have to write the methods of closing events or changing size events every time you write a form. Can inheritance be used at this time?

    public class IControlAble1
    {
        public event EventHandler OnCloseEvent;//关闭

        public void Control_Close(object sender, EventArgs e)
        {
            if (OnCloseEvent != null)
            {
                OnCloseEvent(sender, e);
            }
        }
    }

    public class IControlAble2
    {
        public event EventHandler OnSizeChangeEvent;//改变大小

        public void Control_SizeChange(object sender, EventArgs e)
        {
            if (OnSizeChangeEvent != null)
            {
                OnSizeChangeEvent(sender, e);
            }
        }
    }

Think about it, every time you write a form class, it always feels strange to inherit IControlAble1 or IControlAble2, because these two classes are not form classes. At this time, there is something that can be implemented, which is the interface.
Interface, this is what the book says, interface is a code of conduct. And interfaces are also very common in life. For example, we often talk about USB2.0 interfaces. USB2.0 is a guideline. All manufacturers that produce USB cables are not directly related, but everyone abides by the USB2.0 guideline to produce. The connection point of the wires, what is the length, width and height, and how to arrange each data wire... must comply with this guideline. In this way, the lines produced by everyone can be used universally.
For the program, it is like different classes have the same super class, and they all implement the abstract method of the super class. This way all classes have some sort of criteria. However, C# has single inheritance, which makes it difficult to implement. So there is the concept of interface in C#. Take a look at the standard form and characteristics of interfaces:

    /// <summary>
    /// 1、接口不允许public，private，interna、protected修饰，因为所有的接口都是公用的；
    /// 2、成员不带代码体；
    /// 3、接口不能定义字段成员；
    /// 4、不能用关键字static，virtual，abstract、sealed修饰
    /// 5、一个类可以实现多个接口
    /// </summary>
    interface  IMyInterfaceAble
    {
        //方法、字段
        int MyValue
        {
            get;

            set;
        }

        void Method1();

        void Method2();
    }

The naming of interfaces in C# is generally: I***able, I means interface, and the suffix Able. So the interface can be seen as: having... capabilities.
This can solve the above problem. Modify the two classes into interfaces, and then implement them in other form classes.

    interface IControlAble1
    {
        //没有代码体，并且不修饰
         event EventHandler OnCloseEvent;//关闭

         void Control_Close(object sender, EventArgs e);
    }

    interface IControlAble2
    {
         event EventHandler OnSizeChangeEvent;

         void Control_SizeChange(object sender, EventArgs e);
    }

    public class MainForm : IControlAble1,IControlAble2//可以实现多个接口
    {
        /*
         窗体代码
         */
        
        public event EventHandler OnCloseEvent;

        public void Control_Close(object sender, EventArgs e)
        {
            Console.WriteLine("重写关闭事件。");
        }

        public event EventHandler OnSizeChangeEvent;

        public void Control_SizeChange(object sender, EventArgs e)
        {
            Console.WriteLine("重写大小改变事件。");
        }
    }

    public class ChildForm1 : IControlAble1
    {
        /*
         * 窗体代码
         */

        public event EventHandler OnCloseEvent;

        public void Control_Close(object sender, EventArgs e)
        {
            Console.WriteLine("重写关闭事件。");
        }
    }

    public class ChildForm2 : IControlAble2
    {
        /*
         窗体代码
         */
        public event EventHandler OnSizeChangeEvent;

        public void Control_SizeChange(object sender, EventArgs e)
        {
            Console.WriteLine("重写大小改变事件。");
        }
    }

In this way, the code is more convenient to write, and no writing is missed.

The above is the compilation of basic knowledge of C#: basic knowledge (8) interface content. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!