Compilation des connaissances de base en C# : classes et structures C# (4)

1. Qu'est-ce qu'une interface ? Caractéristiques? Implémenter le code ?
Une interface est définie à l'aide du mot-clé interface. Elle se compose d'une combinaison de membres de classe et est un ensemble de spécifications qui décrivent certaines fonctions. Comme vous pouvez le voir en C#, certaines interfaces du système sont nommées ainsi : IComparable (méthode de comparaison de types), ICloneable (prend en charge le clonage), IDisposable (libère des ressources), etc. I représente l'interface, et capable reflète les caractéristiques du interface. : "Can..." indique ce que cet ensemble de spécifications peut faire.
(1), Implémentation de l'interface

   public interface IPrintAble
    {
        void PrintString();

        void PrintInt();

        void PrintBool();
    }

    public interface IComputeAble
    {
        void HandlerString();

        void HandlerInt();

        void HandlerBool();
    }

    public class MyInplementInterface : IPrintAble, IComputeAble
    {
        //隐式实现
        public void PrintString()
        {
            Console.WriteLine(@"1");
        }

        public void PrintInt()
        {
            Console.WriteLine(1);
        }

        public void PrintBool()
        {
            Console.WriteLine(true);
        }

        public void HandlerString()
        {
            Console.WriteLine(@"1" + "1");
        }

        public void HandlerInt()
        {
            Console.WriteLine(1 + 1);
        }

        public void HandlerBool()
        {
            Console.WriteLine(true || false);
        }

        //显示实现
        //void IComputeAble.HandlerString()
        //{
        //    throw new NotImplementedException();
        //}

        //void IComputeAble.HandlerInt()
        //{
        //    throw new NotImplementedException();
        //}

        //void IComputeAble.HandlerBool()
        //{
        //    throw new NotImplementedException();
        //}
    }
      class Program
    {
        static void Main(string[] args)
        {
            MyInplementInterface imple = new MyInplementInterface();

            imple.PrintString();

            imple.PrintInt();

            imple.PrintBool();

            imple.HandlerString();

            imple.HandlerInt();

            imple.HandlerBool();

            Console.ReadLine();
        }
    }

Résultat :

(2) Implémentation d'une interface spéciale, c'est-à-dire une interface déjà définie par C#
Exemple :

    public class ImplementSysInterface : IComparable
    {
        public int CompareTo(object obj)
        {
            //可以根据需要实现自己的比较方法
            return 0;
        }

        private void UsingMenthod()
        {
            //报错，因为NoIDisposeableClass没有实现IDisposable接口，所以不支持using
            //using (NoIDisposeableClass my = new NoIDisposeableClass())
            //{

            //}
            //实现IDisposable接口后，可以使用using
            using (IDisposeableClass my = new IDisposeableClass())
            {

            }
        }
    }

    public class NoIDisposeableClass
    {

    }

    public class IDisposeableClass : IDisposable
    {
        #region IDisposable 成员

        public void Dispose()
        {
            
        }

        #endregion
    }

L'interface a les caractéristiques suivantes :
a. L'interface est similaire à une classe de base abstraite et ne peut pas instancier directement l'interface. Les méthodes de l'interface sont toutes des méthodes abstraites, et toutes les méthodes non ; -le type abstrait qui implémente l'interface doit implémenter l'interface Tous les membres de :
b. Lorsque les membres de l'interface sont explicitement implémentés, les membres implémentés ne sont pas accessibles via les instances de classe, mais ne sont accessibles que via les instances d'interface.
Par exemple :

   public class MyInplementInterface2 : IComputeAble
    {
        void IComputeAble.HandlerString()
        {
            Console.WriteLine(@"1" + "1");
        }

        void IComputeAble.HandlerInt()
        {
            Console.WriteLine(true || false);
        }

        void IComputeAble.HandlerBool()
        {
            Console.WriteLine(true || false);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IComputeAble imple2 = new MyInplementInterface2();

            imple2.HandlerString();

            Console.ReadLine();
        }
    }

c. Lorsque les membres de l'interface sont implicitement implémentés, les membres implémentés sont accessibles via des instances de classe ou des instances d'interface, mais les membres implémentés doivent être publics .
d. Les interfaces ne peuvent pas contenir de constantes, de champs, d'opérateurs, de constructeurs d'instances, de destructeurs ou de types, et ne peuvent pas contenir de membres statiques.
e. Les membres de l'interface sont automatiquement publics et ne peuvent contenir aucun modificateur d'accès.
f. L'interface elle-même peut hériter de plusieurs interfaces, et les classes et structures peuvent hériter de plusieurs interfaces, mais les interfaces ne peuvent pas hériter de classes.

2. Que sont les génériques ? Quels sont les avantages des génériques ?
Les soi-disant génériques introduisent le concept de paramètres de type dans .NET et réalisent le fonctionnement de plusieurs types de données sur le même code via des types paramétrés. C'est un type de référence et un objet tas.
En fait, j'ai découvert les génériques pour la première fois lorsque j'apprenais Java. Je ne les comprenais pas à l'époque. J'ai toujours pensé que les génériques étaient superflus et pouvaient être réalisés avec des objets. Par exemple, comme suit, par exemple, quelqu'un veut imprimer la valeur du type, donc l'objet est implémenté :

    public class Test
    {
        private object model;

        public object Model
        {
            get
            {
                return model;
            }

            set
            {
                model = value;
            }
        }

        public Test(object model)
        {
            this.Model = model;
        }

        public void ShowRecord()
        {
            Console.WriteLine(model);
        }
    }
   class Program
    {
        static void Main(string[] args)
        {
            int recordI = 2;

            bool recordB = true;

            Test testI = new Test(recordI);

            testI.ShowRecord();

            Test testB = new Test(recordB);

            testB.ShowRecord();

            Console.ReadLine();
        }
    }

Mais lorsque vous en apprendrez davantage, vous constaterez qu'il y a encore certains problèmes . Tout d'abord, il y a le problème de la boxe. Int est un type valeur. Lors de l'attribution d'une valeur au type d'objet, une opération de boxe doit être effectuée. Qu’est-ce que la mise en caisse ? Il s'agit de copier la valeur recordI dans l'espace alloué par le nouvel objet. Perte de temps et de performances. Les génériques ont donc toujours un rôle, alors utilisez des génériques pour implémenter :

  public class TestGeneric<T>
    {
        private T model;

        public T Model
        {
            get
            {
                return model;
            }

            set
            {
                model = value;
            }
        }

        public TestGeneric(T model)
        {
            this.Model = model;
        }

        public void ShowRecord()
        {
            Console.WriteLine(model);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            int recordI = 2;

            bool recordB = true;

            TestGeneric<int> testGI = new TestGeneric<int>(recordI);

            testGI.ShowRecord();

            TestGeneric<bool> testGB = new TestGeneric<bool>(recordB);

            testGB.ShowRecord();

            Console.ReadLine();
        }
    }

De cette façon, lorsque TestGeneric testGI = new TestGeneric(recordI), T est int, n'utilisez plus emballage.
Bien entendu, les génériques ne visent pas seulement à résoudre le problème du boxing. Les caractéristiques fonctionnelles sont les suivantes :
a. Éviter le boxing et le déballage, ce qui améliore les performances
b. , Type-safe, car il sera détecté lors de la compilation ;
d. Vous pouvez créer vos propres interfaces génériques, classes génériques, méthodes génériques, événements génériques et délégués génériques.
Ce qui précède est la compilation des connaissances de base en C# : classes et structures C# (4). Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !