Reproduire l'énumération Java en C #

Cet article est l'article du 11ème jour du Calendrier de l'avent StudioZ Tech 2019.

introduction

J'ai commencé à utiliser Unity il y a environ 5 ans et je suis passé de Java à C #. Comme c'est un langage avec de nombreuses similitudes, j'ai pu l'utiliser presque sans gêne, mais le seul problème était les spécifications d'énumération. Je me suis donc demandé si l'énumération Java pouvait être reproduite en C #.

Caractéristiques de l'énumération Java et méthode d'implémentation

--L'énumérateur a une instance du type d'énumération ――Vous pouvez le rencontrer en utilisant la classe normalement

• Impossible de créer une instance de l'extérieur --Il peut être géré en rendant le constructeur privé.
• Type d'énumération. Accessible par l'énumérateur --Si vous gérez l'instance de l'énumérateur dans le champ statique, elle sera accessible.
• Vous ne pouvez pas définir un énumérateur avec le même nom --Un champ avec le même nom ne peut pas être défini, il sera donc satisfait lorsqu'il est géré par un champ statique.

Si vous codez les conditions jusqu'à présent, cela ressemblera à ceci

    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();
        //Impossible de générer une instance de l'extérieur
        private EnumSample() {}
    }

• L'énumérateur peut avoir des valeurs uniques --Recevoir la valeur dans le constructeur et l'avoir dans le champ
• Cependant, vous ne pouvez pas vérifier statiquement les doublons (vous pouvez vérifier au moment de l'exécution).

    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;
        //Impossible de générer une instance de l'extérieur
        private EnumSample2( int num ) {
            Num = num;
            //Si vous voulez vérifier les doublons, faites-le ici
            //Il semble facile de le mettre dans un dictionnaire et de le vérifier avec la clé Contient
        }
    }

• Des méthodes peuvent être implémentées pour chaque instance
• Faites de la classe de l'énumérateur une classe abstraite et héritez de la classe de chaque énumérateur pour implémenter la méthode --Résumé si vous voulez le rendre obligatoire pour chaque énumérateur, virtuel si vous voulez définir le comportement par défaut
• Le traitement en double peut être éliminé en implémentant le traitement que vous souhaitez standardiser entre les énumérateurs du côté de la classe parente et le traitement que vous souhaitez différencier du côté de la classe enfant. --L'énumération peut implémenter l'interface
• Il suffit de déclarer l'interface à implémenter dans le type d'énumération

    //Interface d'élément de dépôt
    public interface IDropItem {
        string Name { get; }
        int Price { get; }
        string Description { get; }
    }
    
    //Type d'énumération des armes pouvant être traitées comme des objets de largage
    public abstract class Weapon : IDropItem {
        public static Weapon Sword = new WeaponSword();
        private class WeaponSword : Weapon {
            //Même si le constructeur est public, la classe elle-même est privée, il n'est donc pas possible de créer une instance de l'extérieur.
            public WeaponSword() {}
            public override string Name { get { return "épée"; } }
            public override int Price { get { return 100; } }
            public override string Description { get { return "Une belle explication"; } }
            public override void Attack() {
                base.Slash();
            }
        }

        public static Weapon Spear = new WeaponSpear();
        private class WeaponSpear : Weapon {
            public WeaponSpear() {}
            public override string Name { get { return "lance"; } }
            public override int Price { get { return 50; } }
            public override string Description { get { return "Explication comme ça"; } }
            public override void Attack() {
                base.Pierce();
            }
        }

        public static Weapon Club = new WeaponClub();
        private class WeaponClub : Weapon {
            public WeaponClub() {}
            public override string Name { get { return "club"; } }
            public override int Price { get { return 10; } }
            public override string Description { get { return "Explication très étrange"; } }
            // Attack()La mise en œuvre est facultative
        }

        protected Weapon() {}
    
        //Assurez-vous de définir le nom, le prix et la description avec un énumérateur
        public abstract string Name { get; }
        public abstract int Price { get; }
        public abstract string Description { get; }

        //La mise en œuvre du traitement des attaques peut être omise
        public virtual void Attack() {
            //S'il n'est pas remplacé, cliquez par défaut
            Strike();
        }

        //Les propriétés et méthodes déclarées comme protégées sont accessibles du côté de l'énumérateur
        protected void Slash() {
            //Traitement des armes à couper
        }

        protected void Pierce() {
            //Manipulation des armes blanches
        }

        protected void Strike() {
            //Manipulation des armes à battre
        }

    }

Ce que vous ne pouvez pas faire avec C

--Utiliser l'énumérateur comme condition de commutation

• Vous ne pouvez pas utiliser d'énumérateurs qui sont en fait des classes, car vous ne pouvez utiliser des constantes que dans les cas Cependant, puisque vous pouvez implémenter le processus du côté de l'énumérateur, je pense que vous n'avez fondamentalement pas besoin d'utiliser switch.

en conclusion

Cela peut sembler gênant à première vue, mais l'utilisation d'énumérations de style Java facilite la réalisation du polymorphisme. Si vous avez une chance, essayez-la

référence

Les constantes Java sont Enum! Je vais vous dire comment utiliser Enum et comment penser