Enumerazioni in C# con esempio

Enumerazioni in C# con esempio

Enums sta per enumerazioni. È fondamentalmente un insieme di numeri interi. Gli enum sono tipi di valore. Le enumerazioni rendono il tuo programma più leggibile e più manutenibile.

So che dal momento che sei nuovo in C#, le righe precedenti non hanno affatto senso per te. Cerchiamo di capire le enumerazioni con un esempio molto semplice. Ogni volta che uno sviluppatore crea un programma, lo distribuisce con determinate restrizioni. Ci sono 3 modalità in quel programma (Trial, Active e Expired). Gli utenti di prova possono utilizzare il programma per un numero fisso di giorni. Gli utenti attivi possono utilizzare il programma senza alcuna restrizione. Gli utenti scaduti non possono più utilizzare il programma poiché il loro abbonamento è scaduto.

Ora possiamo creare una funzione personalizzata per conoscere l'abbonamento dell'utente ed eseguire il programma in quella modalità. Possiamo restituire valori interi dopo aver terminato i nostri controlli in questo modo:

  • Prova -> 0
  • Attivo -> 1
  • Scaduto -> 2

Quindi, in base a questi valori interi, decideremo in quale modalità deve essere eseguito il programma. So che sembra facile qui, ma c'è un problema. Possiamo aggiungere più modalità come Edizione Professionale, Edizione per sviluppatori, Edizione Standard ecc. Pensi che tu o i membri del tuo team possiate ricordare i valori integrali di numerose modalità durante lo sviluppo? Certo che no!

In tale situazione, le enumerazioni semplificano il lavoro per te e per i membri del tuo team. So che stai pensando perché non restituiamo semplicemente una stringa e la confrontiamo con un'altra? Spero che tu sappia che una leggera modifica nel caso di un carattere o qualsiasi tipo di spazio aggiuntivo nella stringa può dare un risultato errato. Per creare un enum, utilizziamo enum parola chiave. L'esempio è riportato di seguito:

using System;
using System.IO;


namespace Hello_World
{

    //Mode Enum
    public enum mode
    {
        Trial,
        Active,
        Expired
    }

    //Customer Class
    public class customer
    {
        public string name { get; set; }
        public mode acess { get; set; }

    }

    class Program
    {
        static void Main(string[] args)
        {
            customer[] custs = new customer [5];

            custs[0] = new customer { name = "Robert", acess = mode.Active };
            custs[1] = new customer { name = "Albert", acess = mode.Active };
            custs[2] = new customer { name = "Ronaldo", acess = mode.Trial };
            custs[3] = new customer { name = "Anita", acess = mode.Active };
            custs[4] = new customer { name = "Susan", acess = mode.Expired };

            foreach(customer c in custs)
            {
                Console.WriteLine("Name: {0}  Mode: {1}", c.name, GetMode(c.acess));
            }

        }

        //Method to return mode
        public static string GetMode(mode user)
        {
            switch(user)
            {
                case mode.Active:
                    return "Active";

                case mode.Trial:
                    return "Trial";

                case mode.Expired:
                    return "Expired";
                default:
                    return "Unknown";
            }
           
        }

    }
}


Le enum sono costanti fortemente tipizzate e il tipo di dati sottostante predefinito è intero. Non è possibile assegnare un valore intero direttamente a un'enumerazione senza eseguire il cast del tipo e viceversa. Se si dispone di 2 enum, non è possibile assegnare direttamente un'enumerazione di un tipo a un'enumerazione di un altro tipo anche se i valori sottostanti dei membri sono gli stessi. Questo è possibile solo con il cast di tipo esplicito. Di seguito è riportato un esempio.
using System;
using System.IO;


namespace Hello_World
{

    //Mode1 Enum
    public enum mode1
    {
        Trial,
        Active,
        Expired
    }

    //Mode2 Enum
    public enum mode2
    {
        Trial,
        Active,
        Expired
    }

    class Program
    {
        static void Main(string[] args)
        {

            //Type casting - int to enum
            mode1 mode = (mode1) 2;            
            Console.WriteLine(mode);

            //Type casting - enum to int
            int number = (int)mode;
            Console.WriteLine(number);

            //Type casting - mode2 to mode1
            mode1 custom = (mode1)mode2.Active;
            Console.WriteLine(custom);
        }

    }

}



Per ottenere valori integrali predefiniti, utilizziamo il metodo statico GetValues() che risiede nella classe Enum. A causa della natura fortemente tipizzata, è richiesto un cast esplicito di int. Allo stesso modo, per ottenere i nomi, utilizziamo GetNames(), ma in questo caso non è richiesto un cast esplicito di string. Il punto da ricordare qui è, enum in piccolo caso è una parola chiave per creare enumerazioni. Enum con E in maiuscolo è per la classe Enum. Di seguito è riportato un esempio
using System;
using System.IO;


namespace Hello_World
{

    //Mode Enum
    public enum mode
    {
        Trial,
        Active,
        Expired
    }


    class Program
    {
        static void Main(string[] args)
        {

            //Getting underlying int values
            int[] values = (int[])Enum.GetValues(typeof(mode));

            foreach (int value in values)
            {
                Console.WriteLine(value);
            }


            //Getting names
            string[] names = Enum.GetNames(typeof(mode));

            foreach (string name in names)
            {
                Console.WriteLine(name);
            }
        }

    }

}



Puoi anche modificare i valori interi predefiniti degli elementi in enum e puoi assegnare valori personalizzati a ciascuno di essi. I valori integrali degli elementi vengono incrementati di 1 automaticamente. Ciò significa che se il valore del primo elemento è 10, il valore dell'elemento successivo sarà 11. Tuttavia, per impostazione predefinita, il valore del primo elemento è sempre 0. L'esempio è riportato di seguito:
using System;
using System.IO;


namespace Hello_World
{

    //Mode Enum
    public enum mode
    {
        Trial = 5,
        Active = 8,
        Expired
    }


    class Program
    {
        static void Main(string[] args)
        {

            //Getting underlying int values
            int[] values = (int[])Enum.GetValues(typeof(mode));

            foreach (int value in values)
            {
                Console.WriteLine(value);
            }
        }

    }

}

Puoi anche modificare il tipo di dati sottostante predefinito di enum da int a qualsiasi altro tipo di dati come short, long ecc.  Di seguito è riportato un esempio:
using System;
using System.IO;


namespace Hello_World
{

    //Mode Enum of Short Datatype.
    public enum mode : short
    {
        Trial,
        Active,
        Expired
    }


    class Program
    {
        static void Main(string[] args)
        {

            //Getting underlying int values
            short[] values = (short[])Enum.GetValues(typeof(mode));

            foreach (short value in values)
            {
                Console.WriteLine(value);
            }
        }

    }

}