dcsimg

WEBINAR:
On-Demand

Desktop-as-a-Service Designed for Any Cloud ? Nutanix Frame


Introduction

Enum is a strongly typed constant and keyword defined for the Enumeration new data type. A Typesafe enumeration provides an efficient way to define a set of named integral constants that may be assigned to a variable. Using enums makes the code more readable and less prone to errors. Enums are useful to developers when you have a set of values that are functionally significant and unchanged. The main advantage of Enums is to make it easy to change values in the future. Enums are a robust alternative to the simple String or Int constants used in much older APIs to represent sets of related items.

Using Enums in C#

Enums written by developers are used to create numeric constants in the .NET framework. All members of the enum must be assigned a numeric value. Following are the key points about Enums:

  • Keyword Enums create enumerated data types in C#
  • Enums are for developers
  • As mentioned above, Enums are strongly typed constants
  • An enum of one type can't be implicitly assigned to another enum type
  • Enumerations make code much more readable, reusable, and understandable
  • Enum values are fixed
  • The default enum type is int
  • Every enum type automatically derives from System.Enum
  • Enums are value types and are created on the stack, not on the heap

C# Enum is an abstract class; it has static helper methods to work with. Following is the list of helper methods:

  • Format: This function converts the specified value of enum type to the specified string format
  • GetName: This function returns the name of the constant or value of the specified enum type
  • GetNames: It returns an array of string name of all the constant of the specified enum
  • GetValues: An array of the values of all the constants of the specified enum
  • Parse: The function converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object
  • TryParse: Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object

In the following C# program, I have created two Enum types, named DefectPrioriy and DefectSeverity. Both DefectPrioriy and DefectSeverity enumerations have four values. In the main program, I have printed values and names of both the enumerations using the console.write and console.writeline functions.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EnumProject
{
   enum DefectPrioriy
   {
      Immediate = 1,
      High,
      Medium,
      Low
   }
   enum DefectSeverity
   {
      Critical = 1,
      Major,
      Minor,
      Low
   }
   class Program
   {
      static void Main(string[] args)
      {
         Console.Write("Defect Prioriy: ");
         Console.WriteLine((int)DefectPrioriy.Immediate);
         Console.Write("Defect Severity: ");
         Console.WriteLine((int)DefectSeverity.Minor);

         string sDefectPrioriy = Enum.GetName(typeof
            (DefectPrioriy), 4);
         Console.WriteLine(sDefectPrioriy);

         Console.WriteLine("The values of the DefectPrioriy Enum
            are:");
         foreach (int i in Enum.GetValues(typeof(DefectPrioriy)))
            Console.WriteLine(i);

         Console.WriteLine("The names of the DefectPrioriy Enum
            are:");
         foreach (string str in Enum.GetNames(typeof
               (DefectPrioriy)))
            Console.WriteLine(str);
            PrintEnumWithoutLoop();
            DisplayEnumSwitchCase();
            Console.Read();

      }
   }
}

The following two functions, PrintEnumWithoutLoop and DisplayEnumSwitchCase, are called from the main method to display a defect priority inside a switch case and without a loop.

static void PrintEnumWithoutLoop ()

{
   Console.WriteLine("Defect Prioriy {0} {1}",
      (int)DefectPrioriy.Immediate, DefectPrioriy.Immediate);
   Console.WriteLine("Defect Prioriy {0} {1}",
      (int)DefectPrioriy.High, DefectPrioriy.High);
   Console.WriteLine("Defect Prioriy {0} {1}",
      (int)DefectPrioriy.Medium, DefectPrioriy.Medium);
   Console.WriteLine("Defect Prioriy {0} {1}",
      (int)DefectPrioriy.Low, DefectPrioriy.Low);
   Console.ReadLine();
}
static
void DisplayEnumSwitchCase()
{
   DefectPrioriy value = DefectPrioriy.Medium;
   switch (value)
   {
      case DefectPrioriy.Immediate:
         Console.WriteLine("Defect Priority Immediate");
         break;
      case DefectPrioriy.High:
         Console.WriteLine("Defect Priority High");
         break;
      case DefectPrioriy.Medium:
         Console.WriteLine("Defect Priority Medium");
         break;
      case DefectPrioriy.Low:
         Console.WriteLine("Defect Priority Low");
         break;
   }
}

Conclusion

I hope this article has helped you understand enums, and their usage in C# and .NET applications. Please provide your valuable feedback for improvement. That's all for today; happy reading!



Related Articles

Comments

  • There are no comments yet. Be the first to comment!

  • You must have javascript enabled in order to post comments.

Leave a Comment
  • Your email address will not be published. All fields are required.

Most Popular Programming Stories

More for Developers

RSS Feeds

Thanks for your registration, follow us on our social networks to keep up-to-date