Home	»	C#	»	Structures and Enumerations

A Structure is such a group of basic data type variables, which behaves as a unit. Moreover, it resembles another construct - class - a very important data type in object oriented programming.

Enumeration is yet another type of data structure that assigns integer values to string type data values. Both the data types are extensively used in C#.

Structure

     A Structure is a collection various variables with different variables like Int ,Float Char etc .The C# Language also provides us to create a data type which includes all the other data types of int , float and character The Main user defines data type is Structure Which Provides us the facility to make a data types which hold either the int value, float value of character values. Structure is the user defined data type which is used for creating a single Variable which makes us possible to declare a value either a int, float or character A user First Make a Structure of different data types with their respective variables A structures is like container which hold all the different variables with their different values and their different length.

Always Remember that the member of the Structure is always Accessed with the help of the (dot) . Operator or if we wants to access a variable of the structure then we must use the. (dot) Operator. The Member of the Structure are always Accessed through the Structure variables or For Accessing the Elements of the Structure First you have to create the instance of the Structure then with the help of the name of instance and dot Operator we can Access any variables from Structures for declaring the structure we can use this

struct stu
{
  char name[10],lastname[10];
  int age;
  float height;
}
Structure is also user defined data type but the Main difference between the Arrays and Structure is that All the Elements of An Array are of Same type but in Structure all the Elements of a Structure are of different data type.

A Structure May be Nested Means we can also define a Structure inside another Structure and Structure is a container of various Elements which have a different name and different data type.

What is Enumeration ?

     Enumerated data type is user defined data type and This is a Special data type which provides a user to opportunity to invent your own data type and define what values the variables of this data type can take Enumerated data type is used for crating a set of values of a date type and all the values of data type are start from 0 by default but a user and can change the value For Making this data type First we can declare the data type and specifies its possible values All the values are increment by 1 its previous value.

using System;
public class enumvariables
{
  public enum values
  {
    a,b,c,d;
  }
  public static void Main()
  {
    Console.WriteLine("Value of D: " +values.d);
  }
}

Output
Value of D: 3

Enumeration are a collection of item (variables). It holds by default values if we not assign a value variable hold 0 value second 1 value third 2 and so on. If we assign the third variables 10 values. It show the fourth variable by default 11 value assign.

Difference Between the Structure and Class

All the Variables in the Structure are value type so that they are stored on the Stack in Memory and in Class Variables are of reference type so that they are stored on the heap of the Memory.
Classes Support Inheritance but a Structure can't be inherited.
Classes have both default and Parameters Constructor but a Structure have not a default Constructor.
When we Assign the Class Variable then the Original Values are Copied but in the Structure only the Values are Copied it doesn't Passes the Original Reference for that Variables.

Structs with Methods

A C# Struct can also contain methods. The methods can be either static or non-static. But static methods can access only other static members and they can't invoke by using an object of the structure. They can invoke only by using the struct name.

/*Structs with Methods/Function*/
using System;
struct str
{
  int a,b;
  public void get()
  {
    Console.WriteLIne("Enter a No.");
    a = Int32.Parse(Console.ReadLine());
    b = Int32.Parse(Console.ReadLine());
  }
  public void show()
  {
    int c = a + b;
    Console.WriteLine("Sum = " + c);
  }
}

class abc
{
  public static void Main()
  {
    str obj = new str();
    obj.get();
    obj.show();
  }
}

Output

Structs and Constructors

A C# struct can declare constructor, but they must take parameters. A default constructor (constructor without any parameters) is always provided to initialize the struct fields to their default values. The parameterized constructors inside a struct can also be overload.

/*Structs and Constructors */
using System;
struct str
{
  int a,b;
  public str()  //Error, we can't used default structure of constructor
    a = 100;
    b = 200;
  }
  publid void show()
  {
    int c = a + b;
    Console.WriteLine("Sum="+c);
  }
}
class student
{
  public static void Main()
  {
    str obj = new str();
    obj.show();
  }
}

Output

Structs with Arguments

/*Structs with arguments */
using System;
struct str
{
  int a,b;
  public str(int x, int y)
    a = x;
    b = y;
  }
  publid int sum()
  {
    return(a + b);
  }
}
class student
{
  public static void Main()
  {
    str obj = new str();
    int c = obj.show();
    Console.WriteLine("Sum = "+c);
  }
}

Output

Nested Structs

We can declare nested structures i.e. structs inside other structs. Following code snippet illustrates this:

/* Nested Structure */
using System;
struct student
{
  public String name,last;
}
struct Marks     //Nested Structure
{
  public student s;
  public int math, sci;
}

class nest
{
  public static void Main()
  {
    Marks m;
    m.s.name = "Pardeep";
    m.s.last = "Kumar";
    m.math = 75;
    m.sci = 70;

    Console.WriteLine("Name = "+m.s.name);
    Console.WriteLine("Last Name = "+m.s.last);
    Console.WriteLine("Math Marks = "+m.math);
    Console.WriteLine("Science = "+m.sci);
  }
}