Reproduzieren Sie die Java-Enumeration in C #

Dieser Artikel ist der Artikel zum 11. Tag von StudioZ Tech Adventskalender 2019.

Einführung

Ich habe vor ungefähr 5 Jahren angefangen, Unity zu verwenden und bin von Java zu C # gewechselt. Da es sich um eine Sprache mit vielen Ähnlichkeiten handelt, konnte ich sie fast ohne Unbehagen verwenden, aber das einzige Problem waren die Aufzählungsspezifikationen. Also habe ich mich gefragt, ob Java-Enumeration in C # reproduziert werden kann.

Java-Enum-Eigenschaften und Implementierungsmethode

• Der Enumerator verfügt über eine Instanz des Aufzählungstyps ――Sie können es erreichen, indem Sie die Klasse normal verwenden --Kann keine Instanz von außen erstellen
• Es kann behandelt werden, indem der Konstruktor privat gemacht wird.
• Aufzählungstyp. Kann vom Enumerator aufgerufen werden
• Wenn Sie die Enumerator-Instanz im statischen Feld verwalten, kann darauf zugegriffen werden.
• Sie können keinen Enumerator mit demselben Namen definieren
• Ein Feld mit demselben Namen kann nicht definiert werden, sodass es erfüllt ist, wenn es von einem statischen Feld verwaltet wird.

Wenn Sie die bisherigen Bedingungen codieren, sieht dies folgendermaßen aus

    public class EnumSample {
        public static EnumSample Enum1 = new EnumSample();
        public static EnumSample Enum2 = new EnumSample();
        public static EnumSample Enum3 = new EnumSample();
        public static EnumSample Enum4 = new EnumSample();
        //Es kann keine Instanz von außen generiert werden
        private EnumSample() {}
    }

• Der Enumerator kann eindeutige Werte haben
• Empfangen Sie den Wert im Konstruktor und haben Sie ihn im Feld
• Sie können jedoch nicht statisch nach Duplikaten suchen (Sie können zur Laufzeit prüfen).

    public class EnumSample2 {
        public static EnumSample2 Enum1 = new EnumSample2( 1 );
        public static EnumSample2 Enum2 = new EnumSample2( 2 );
        public static EnumSample2 Enum3 = new EnumSample2( 3 );
        public static EnumSample2 Enum4 = new EnumSample2( 4 );
    
        public int Num;
        //Es kann keine Instanz von außen generiert werden
        private EnumSample2( int num ) {
            Num = num;
            //Wenn Sie nach Duplikaten suchen möchten, tun Sie dies hier
            //Es scheint einfach zu sein, es in ein Wörterbuch zu packen und es mit dem Contains Key zu überprüfen
        }
    }

--Methoden können für jede Instanz implementiert werden

• Machen Sie die Enumerator-Klasse zu einer abstrakten Klasse und erben Sie die Klasse für jeden Enumerator, um die Methode zu implementieren --Abstraktieren Sie, wenn Sie es für jeden Enumerator obligatorisch machen möchten, virtuell, wenn Sie das Standardverhalten definieren möchten
• Doppelte Verarbeitung kann vermieden werden, indem Sie die Verarbeitung implementieren, die Sie für Enumeratoren auf der Seite der übergeordneten Klasse verwenden möchten, und die Verarbeitung, die Sie zwischen den Enumeratoren auf der Seite der untergeordneten Klasse unterscheiden möchten.
• Die Aufzählung kann die Schnittstelle implementieren
• Deklarieren Sie einfach die Schnittstelle, die im Aufzählungstyp implementiert werden soll

    //Elementschnittstelle löschen
    public interface IDropItem {
        string Name { get; }
        int Price { get; }
        string Description { get; }
    }
    
    //Aufzählungstyp von Waffen, die als Drop-Items behandelt werden können
    public abstract class Weapon : IDropItem {
        public static Weapon Sword = new WeaponSword();
        private class WeaponSword : Weapon {
            //Selbst wenn der Konstruktor öffentlich ist, ist die Klasse selbst privat, sodass es nicht möglich ist, eine Instanz von außen zu erstellen.
            public WeaponSword() {}
            public override string Name { get { return "Schwert"; } }
            public override int Price { get { return 100; } }
            public override string Description { get { return "Eine schöne Erklärung"; } }
            public override void Attack() {
                base.Slash();
            }
        }

        public static Weapon Spear = new WeaponSpear();
        private class WeaponSpear : Weapon {
            public WeaponSpear() {}
            public override string Name { get { return "Speer"; } }
            public override int Price { get { return 50; } }
            public override string Description { get { return "Erklärung wie diese"; } }
            public override void Attack() {
                base.Pierce();
            }
        }

        public static Weapon Club = new WeaponClub();
        private class WeaponClub : Weapon {
            public WeaponClub() {}
            public override string Name { get { return "Verein"; } }
            public override int Price { get { return 10; } }
            public override string Description { get { return "Sehr seltsame Erklärung"; } }
            // Attack()Die Implementierung ist optional
        }

        protected Weapon() {}
    
        //Stellen Sie sicher, dass Sie den Namen, den Preis und die Beschreibung mit einem Enumerator definieren
        public abstract string Name { get; }
        public abstract int Price { get; }
        public abstract string Description { get; }

        //Die Implementierung der Angriffsverarbeitung kann weggelassen werden
        public virtual void Attack() {
            //Wenn nicht überschrieben, drücken Sie als Standard
            Strike();
        }

        //Auf Eigenschaften und Methoden, die als geschützt deklariert sind, kann von der Enumeratorseite aus zugegriffen werden
        protected void Slash() {
            //Waffen zum Schneiden verarbeiten
        }

        protected void Pierce() {
            //Umgang mit Stichwaffen
        }

        protected void Strike() {
            //Umgang mit schlagenden Waffen
        }

    }

Was Sie mit C # nicht machen können

--Verwenden Sie den Enumerator als Schalterbedingung

• Sie können keine Enumeratoren verwenden, die tatsächlich Klassen sind, da Sie Konstanten nur in Fällen verwenden können ――Jedoch, da Sie den Prozess auf der Enumeratorseite implementieren können, denke ich, dass Sie im Grunde keinen Schalter verwenden müssen.

abschließend

Auf den ersten Blick mag es unangenehm erscheinen, aber die Verwendung von Enum im Java-Stil erleichtert das Erreichen von Polymorphismus. Wenn Sie eine Chance haben, probieren Sie es bitte aus

Referenz

Java-Konstanten sind Enum! Ich werde Ihnen sagen, wie man Enum verwendet und wie man denkt