Enums and Structs in C# [Author:Nishant Sivakumar]

柔情只为你懂 2021-11-22 06:44 191阅读 0赞

## [http://www.codeproject.com/KB/cs/csenums01.aspx][http_www.codeproject.com_KB_cs_csenums01.aspx] ##

## Introduction ##

Just about everything is a heap object when you are using C\#. Only elementary  native types like `int` are treated as value types. But there are two value types  in C\# that are pretty much more useful that first glances would tell you. They  are the `enum` and `struct` types. Very few tutorials even cover these topics, but  they have their own uses. And both of them are a lot more efficient than **class**es  and you can use them in place of **class**es when they meet your requirements to  improve performance.

## Enums ##

**Enum**s are basically a set of named constants. They are declared in C\# using  the `enum` keyword. Every `enum` type  automatically derives from `System.Enum` and thus we can use `System.Enum` methods on our **Enum**s. **Enum**s are value types and are created  on the stack and not on the heap. You don't have to use `new`  to create an `enum` type. Declaring an `enum`  is a little like setting the members of an array as shown below.

![minus.gif][]  Collapse | [Copy Code][]

Rating {Poor, Average, Okay, Good, Excellent}

You can pass **enum**s to member functions just as if they were normal objects.  And you can perform arithmetic on **enum**s too. For example we can write two  functions, one to increment our  `enum` and the other to  decrement our `enum`.

![minus.gif][]  Collapse | [Copy Code][]

Rating IncrementRating(Rating r)
    {
        (r == Rating.Excellent)
             r;
        
             r+1;
    }
    Rating DecrementRating(Rating r)
    {
        (r == Rating.Poor)
             r;
        
             r-1;
    }

Both functions take a `Rating` object as argument and return back a `Rating`  object. Now we can simply call these functions from elsewhere.

![minus.gif][]  Collapse | [Copy Code][]

(Rating r1 = Rating.Poor; 
        r1 < Rating.Excellent ; 
        r1 = IncrementRating(r1))
    {           
        Console.WriteLine(r1);
    }
    
    Console.WriteLine();
    
     (Rating r2 = Rating.Excellent; 
        r2 > Rating.Poor; 
        r2 = DecrementRating(r2))
    {
        Console.WriteLine(r2);          
    }

And here is a sample code snippet showing how you can call `System.Enum` methods on our **Enum** object. We call the `GetNames` method which retrieves an array of the names of the constants in  the **enum**eration.

![minus.gif][]  Collapse | [Copy Code][]

( s  Rating.GetNames((Rating)))
        Console.WriteLine(s);

#### Where to use enums ####

Quite often we have situations where a **class** method takes as an argument a  custom option. Let's say we have some kind of file access **class** and there is a  file open method that has a parameter that might be one of read-mode,  write-mode, read-write-mode, create-mode and append-mode. Now you might think of  adding five static member fields to your **class** for these modes. Wrong approach!  Declare and use an **enum**eration which is a whole lot more efficient and is better  programming practice in my opinion.

## Structs ##

In C++ a `struct` is just about the same as a **class** for  all purposes except in the default access modifier for methods. In C\# a `struct` are a pale puny version of a `class`. I am not  sure why this was done so, but perhaps they decided to have a clear distinction  between **struct**s and **class**es. Here are some of the drastic areas where **class**es  and **struct**s differ in functionality.

*  **struct**s are stack objects and however much you try you cannot create them   on the heap
 *  **struct**s cannot inherit from other **struct**s though they can derive from   interfaces
 *  You cannot declare a default con**struct**or for a `struct`,   your con**struct**ors must have parameters
 *  The con**struct**or is called only if you create your `struct`   using `new`, if you simply declare the `struct`   just as in  declaring a native type like `int`, you   must explicitly set each member's value before you can use the `struct`

**![minus.gif][]**  Collapse | [Copy Code][]

Student : IGrade
    {   
          maths;
          english;
          csharp;
    
        
          GetTot()
        {
             maths+english+csharp;
        }
    
        
         Student( y)
        {
            maths = english = csharp = y;
        }
    
        
        
          GetGrade()
        {
            (GetTot() >  )
                 ;
            (GetTot() >  )
                 ;
             ;
        }
    }
    
     IGrade
    {
         GetGrade();
    }

Well, now let's take a look at how we can use our `struct`.

![minus.gif][]  Collapse | [Copy Code][]

Student s1 =  Student();
    Console.WriteLine(s1.GetTot());
    Console.WriteLine(s1.GetGrade());
    
    
    
    Failed

Here the default con**struct**or gets called. This is automatically implemented  for us and we cannot have our own default parameter-less con**struct**or. The  default parameter-less con**struct**or simply initializes all values to their  zero-equivalents. This is why we get a 0 as the total.

![minus.gif][]  Collapse | [Copy Code][]

Student s2;
    s2.maths = s2.english = s2.csharp = ;
    Console.WriteLine(s2.GetTot());
    Console.WriteLine(s2.GetGrade());
    
    
    
    Passed

Because we haven't used new, the con**struct**or does not get called. Of all the  silly features this one must win the annual contest by a long way. I see no sane  reason why this must be so. Anyway you have to initialize all the member fields.  If you comment out the line that does the initialization you will get a compiler  error :- *Use of unassigned local variable 's2'*

![minus.gif][]  Collapse | [Copy Code][]

Student s3 =  Student();
    Console.WriteLine(s3.GetTot());
    Console.WriteLine(s3.GetGrade());
    
    
    
    Brilliant

This time we use our custom con**struct**or that takes an `int`  as argument.

#### When to use structs ####

Because **struct**s are value types they would be easier to handle and more  efficient that **class**es. When you find that you are using a **class** mostly for  storing a set of values, you must replace those **class**es with **struct**s. When you  declare arrays of **struct**s because they are created on the heap, efficiency again  improves. Because if they were **class**es each **class** object would need to have  memory allocated on the heap and their references would be stored. In fact lots  of **class**es within the .NET framework are actually **struct**s. For example `System.Drawing.Point` is actually a `struct` and not a `class`.

转载于:https://www.cnblogs.com/anorthwolf/archive/2011/11/16/2251532.html

[http_www.codeproject.com_KB_cs_csenums01.aspx]: http://www.codeproject.com/KB/cs/csenums01.aspx
[minus.gif]: /images/20211122/ebd605f520d0420ab1b1b9090343dfe5.png
[Copy Code]: http://www.codeproject.com/KB/cs/csenums01.aspx#