Zusammenstellung von C#-Grundkenntnissen: C#-Klassen und -Strukturen (4)

1. Was ist eine Schnittstelle? Merkmale? Code implementieren?
Eine Schnittstelle wird mit dem Schlüsselwort interface definiert. Sie besteht aus einer Kombination von Klassenmitgliedern und ist eine Reihe von Spezifikationen, die einige Funktionen beschreiben. Wie Sie in C# sehen können, werden einige Schnittstellen des Systems wie folgt benannt: IComparable (Typvergleichsmethode), ICloneable (unterstützt das Klonen), IDisposable (gibt Ressourcen frei) usw. I stellt die Schnittstelle dar und able spiegelt die Eigenschaften der wider Schnittstelle. : „Kann…“ gibt an, was diese Spezifikation leisten kann.
(1), Schnittstellenimplementierung

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

Ergebnis:

(2) Implementierung einer speziellen Schnittstelle, d. h. einer bereits durch C# definierten Schnittstelle
Beispiel:

    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
    }

Die Schnittstelle weist die folgenden Eigenschaften auf:
a Die Schnittstelle ähnelt einer abstrakten Basisklasse und kann die Schnittstelle nicht direkt instanziieren -abstrakter Typ, der die Schnittstelle implementiert, muss die Schnittstelle implementieren Alle Mitglieder von:
b Wenn Mitglieder der Schnittstelle explizit implementiert werden, kann auf die implementierten Mitglieder nicht über Klasseninstanzen zugegriffen werden, sondern nur über Schnittstelleninstanzen.
Zum Beispiel:

   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 Wenn die Mitglieder der Schnittstelle implizit implementiert sind, kann auf die implementierten Mitglieder über Klasseninstanzen oder Schnittstelleninstanzen zugegriffen werden, die implementierten Mitglieder müssen jedoch öffentlich sein.
d. Schnittstellen dürfen keine Konstanten, Felder, Operatoren, Instanzkonstruktoren, Destruktoren oder Typen enthalten und keine statischen Mitglieder enthalten.
e. Schnittstellenmitglieder sind automatisch öffentlich und dürfen keine Zugriffsmodifikatoren enthalten.
f. Die Schnittstelle selbst kann von mehreren Schnittstellen erben, und Klassen und Strukturen können von mehreren Schnittstellen erben, Schnittstellen können jedoch nicht von Klassen erben.

2. Was sind Generika? Was sind die Vorteile von Generika?
Die sogenannten Generika führen das Konzept der Typparameter in .NET ein und realisieren die Operation mehrerer Datentypen im selben Code durch parametrisierte Typen. Es ist ein Referenztyp und ein Heap-Objekt.
Eigentlich habe ich zum ersten Mal etwas über Generika gelernt, als ich Java lernte. Ich hatte damals immer das Gefühl, dass Generika unnötig sind und mit Objekten durchgeführt werden können. Zum Beispiel wie folgt: Jemand möchte beispielsweise den Wert des Typs ausdrucken, damit das Objekt implementiert wird:

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

Aber wenn Sie mehr erfahren, werden Sie feststellen, dass es immer noch bestimmte Probleme gibt . Erstens gibt es das Problem, dass Int ein Werttyp ist. Beim Zuweisen eines Werts zum Objekttyp muss eine Boxoperation durchgeführt werden. Was ist Kiste? Dabei wird der Wert von recordI in den vom neuen Objekt zugewiesenen Speicherplatz kopiert. Verschwendete Zeit und Leistung. Generika spielen also immer noch eine Rolle. Verwenden Sie daher Generika zur Implementierung:

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

Wenn TestGeneric testGI = new TestGeneric(recordI), T int ist, verwenden Sie nicht mehr Verpackung.
Natürlich geht es bei Generika nicht nur um die Lösung des Boxproblems:
Vermeiden Sie das Einpacken und Auspacken, was die Wiederverwendbarkeit des Codes verbessert , Typsicher, da es während der Kompilierung erkannt wird; d. Sie können Ihre eigenen generischen Schnittstellen, generischen Klassen, generischen Methoden, generischen Ereignisse und Delegaten erstellen.
Das Obige ist eine Zusammenfassung der C#-Grundkenntnisse: C#-Klassen und -Strukturen (4). Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).