C#-Grundwissenskompilierung: Grundwissensschnittstelle (8).

Wir haben bereits abstrakte Klassen angesprochen. Ihr Merkmal ist, dass Unterklassen abstrakte Modifikationsmethoden implementieren müssen. Es gibt auch virtuell modifizierte Methoden, die umgeschrieben oder direkt ohne Umschreiben verwendet werden können. Da C# jedoch auch einfach vererbt ist, kann es beim Definieren einer übergeordneten Klasse und der anschließenden Vererbung zum Erweitern einiger Klassen zu unangemessenen Situationen kommen. Da wir Programmierer Programmiersprachen verwenden, um die Welt zu beschreiben, ist es am besten, in unseren Projekten Klassen zu organisieren, Klassen zu benennen, Methoden zu schreiben usw., um der realen Welt ähnlich zu sein, damit die Entwicklung mühelos verläuft und Fehlerkorrekturen einfacher sind.
In einem Projekt werden beispielsweise viele Formulare verwendet. Einige Formulare müssen ihre Abschlussereignisse erneut verarbeiten, andere müssen ihre Größenänderungsereignisse verarbeiten. Aber es ist immer sehr ärgerlich, jedes Mal, wenn Sie ein Formular schreiben, die Methoden zum Schließen von Ereignissen oder zum Ändern der Größe von Ereignissen schreiben zu müssen. Kann die Vererbung zu diesem Zeitpunkt genutzt werden?

    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);
            }
        }
    }

Stellen Sie sich vor, jedes Mal, wenn Sie eine Formularklasse schreiben, fühlt es sich immer seltsam an, IControlAble1 oder IControlAble2 zu erben, da diese beiden Klassen keine Formularklassen sind. Zu diesem Zeitpunkt gibt es etwas, das implementiert werden kann, nämlich die Schnittstelle.
Schnittstelle ist, wie das Buch sagt, ein Verhaltenskodex. Und Schnittstellen sind im Leben auch sehr verbreitet. Wir sprechen beispielsweise oft von USB2.0-Schnittstellen. Alle Hersteller, die USB-Kabel herstellen, sind nicht direkt miteinander verbunden, aber alle halten sich an die USB2.0-Richtlinie . Der Verbindungspunkt der Drähte, die Länge, Breite und Höhe sowie die Anordnung der einzelnen Datenkabel müssen dieser Richtlinie entsprechen. Auf diese Weise sind die von jedermann hergestellten Linien universell einsetzbar.
Für ein Programm ist es so, als ob verschiedene Klassen dieselbe Superklasse hätten und alle die abstrakten Methoden der Superklasse implementieren. Auf diese Weise haben alle Klassen bestimmte Kriterien. Allerdings verfügt C# über eine Einzelvererbung, was die Implementierung erschwert. Es gibt also das Konzept der Schnittstelle in C#. Werfen Sie einen Blick auf die Standardform und die Eigenschaften von Schnittstellen:

    /// <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();
    }

Die Benennung von Schnittstellen in C# lautet im Allgemeinen: I***able, I bedeutet Schnittstelle, und das Suffix Able. Die Schnittstelle kann also so gesehen werden: sie verfügt über ... Fähigkeiten.
Dies kann das oben genannte Problem lösen. Ändern Sie einfach die beiden Klassen in Schnittstellen und implementieren Sie sie dann in anderen Formularklassen.

    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("重写大小改变事件。");
        }
    }

Auf diese Weise lässt sich der Code bequemer schreiben und es wird kein Schreibvorgang übersehen.

Das Obige ist die Zusammenstellung der Grundkenntnisse von C#: Grundkenntnisse (8) Schnittstelleninhalte. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn). )!