Compilation des connaissances de base C# : interface des connaissances de base (8)

Nous avons évoqué plus haut les classes abstraites. Sa caractéristique est que les sous-classes doivent implémenter des méthodes de modification abstraites. Il existe également des méthodes virtuelles modifiées. Les sous-classes de méthodes virtuelles modifiées peuvent être réécrites ou utilisées directement sans réécriture. Cependant, comme C# utilise également l'héritage unique, lorsque vous définissez une classe parent puis héritez pour étendre certaines classes, vous rencontrerez des situations inappropriées. Parce que nous, les programmeurs, utilisons un langage de programmation pour décrire le monde, il est préférable d'organiser les classes, de nommer les classes, d'écrire des méthodes, etc. dans nos projets pour qu'ils soient similaires au monde réel, afin que le développement se fasse sans effort et que la correction des bugs soit plus facile.
Par exemple, dans un projet, de nombreux formulaires sont utilisés. Certains formulaires doivent retraiter leurs événements de fermeture, et d'autres doivent traiter leurs événements de redimensionnement. Cependant, il est toujours très ennuyeux de devoir écrire des méthodes pour fermer des événements ou modifier la taille des événements à chaque fois que vous écrivez un formulaire. L'héritage peut-il être utilisé à ce moment-là ?

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

Imaginez, chaque fois que vous écrivez une classe de formulaire, cela semble toujours étrange d'hériter de IControlAble1 ou IControlAble2, car ces deux classes ne sont pas des classes de formulaire. À l’heure actuelle, il y a quelque chose qui peut être implémenté, c’est l’interface.
L'interface, comme le dit le livre, l'interface est un code de conduite. Et les interfaces sont également très courantes dans la vie. Par exemple, nous parlons souvent des interfaces USB2.0. Tous les fabricants qui produisent des câbles USB ne sont pas directement liés, mais tout le monde respecte la directive USB2.0 pour produire. .Chaque Le point de connexion des fils racine, quelle est la longueur, la largeur et la hauteur, comment disposer chaque fil de données... doit être conforme à cette directive. De cette manière, les lignes produites par chacun peuvent être utilisées universellement.
Pour un programme, c'est comme si différentes classes avaient la même super classe, et qu'elles implémentaient toutes les méthodes abstraites de la super classe. De cette façon, toutes les classes ont une sorte de critères. Cependant, C# a un héritage unique, ce qui rend sa mise en œuvre difficile. Il y a donc la notion d’interface en C#. Jetez un œil à la forme standard et aux caractéristiques des 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();
    }

La dénomination des interfaces en C# est généralement : I***able, I signifie interface, et le suffixe Able. L'interface peut donc être vue comme : ayant... des capacités.
Cela peut résoudre le problème ci-dessus. Modifiez les deux classes en interfaces, puis implémentez-les dans d'autres classes de formulaire.

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

De cette façon, le code sera plus pratique à écrire et aucune écriture ne sera manquée.

Ce qui précède est la compilation des connaissances de base de C# : connaissances de base (8) du contenu de l'interface. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn). )!