A structure in C# is simply a composite data type consisting of a number elements of other types. A C# structure is a value type and the instances or objects of a structure are created in stack. The structure in C# can contain fields, methods, constants, constructors, properties, operators and even other structure types.
Structure Declaration & Object Creation
The keyword struct can be used to declare a structure. The general form of a structure declaration in C# is as follows.
<modifiers> struct <struct_name>
{
//Structure members
}
Where the modifier can be private, public, internal or public. The struct is the required keyword.
For example
struct MyStruct
{
public int x;
public int y;
}
The objects of a strcut can be created by using the new operator as follows.
MyStruct ms = new MyStruct();
The individual members of a struct can be accessed by using the dot (.) operator as showing below.
ms.x = 10;
ms.y = 20;
Remember that unlike classes, the strcut object can also be created without using the new operator.
MyStruct ms;
But in this case all fields of the struct will remain unassigned and the object can't be used until all of the fields are initialized.
Structs & Fields
A struct in C# can contain fields. These fields can be declared as private, public, internal. Remember that inside a struct, we can only declare a field. We can't initialize a field inside a struct. However we can use constructor to initialize the structure fields.
The following is not a valid C# struct and the code will not compile, since the fields inside the structure are trying to initialize.
struct MyStruct
{
int x = 20; // Error its not possible to initialize
int y = 20; // Error its not possible to initialize
}
A valid C# structure is showing below.
using System;
struct MyStruct
{
public int x;
public int y;
}
class MyClient
{
public static void Main()
{
MyStruct ms = new MyStruct();
ms.x = 10;
ms.y = 20;
int sum = ms.x + ms.y;
Console.WriteLine("The sum is {0}",sum);
}
}
However a struct can contain static fields, which can be initialized inside the struct. The following example shows the use of static fields inside a struct.
using System;
struct MyStruct
{
public static int x = 25;
public static int y = 50;
}
class MyClient
{
public static void Main()
{
int sum = MyStruct.x + MyStruct.y;
Console.WriteLine("The sum is {0}",sum);
}
}
Remember that static fields can't be accessed by an instance of a struct. We can access them only by using the struct names.
Struct & 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.
An example is shown below.
using System;
struct MyStruct
{
static int x = 25;
static int y = 50;
public void SetXY(int i, int j)
{
x = i;
y = j;
}
public static void ShowSum()
{
int sum = x + y;
Console.WriteLine("The sum is {0}",sum);
}
}
class MyClient
{
public static void Main()
{
MyStruct ms = new MyStruct();
ms.SetXY(100,200);
MyStruct.ShowSum();
}
}
The methods inside a struct can also be overloaded as like inside a class. For example
using System;
struct MyStruct
{
static int x = 25;
static int y = 50;
public void SetXY(int i, int j)
{
x = i;
y = j;
}
public void SetXY(int i)
{
x = i;
y = i;
}
}
class MyClient
{
public static void Main()
{
MyStruct ms1 = new MyStruct();
MyStruct ms2 = new MyStruct();
ms1.SetXY(100,200);
ms2.SetXY(500);
}
}
Structs & Constructors
A C# struct can declare constructor, but they must take parameters. A default constructor (constructor without any parameters) are always provided to initialize the struct fields to their default values. The parameterized constructors inside a struct can also be overloaded.
using System;
struct MyStruct
{
int x ;
int y ;
public MyStruct(int i,int j)
{ x = i; y = j;}
public MyStruct(int i)
{ x = y = i; }
public void ShowXY()
{ Console.WriteLine("The field values are {0} & {1}",x,y); }
}
class MyClient
{
public static void Main()
{
MyStruct ms1 = new MyStruct(10,20);
MyStruct ms2 = new MyStruct(30);
ms1.ShowXY();
ms2.ShowXY();
}
}
Finally remember that C# struct do not support destructors.
Structs & Properties
The properties can be declared inside a struct as shown below.
//C#: Property
using System;
class MyStruct
private int x;
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
}
class MyClient
public static void Main()
{
MyStruct ms = new MyStruct();
ms.X = 10;
int xVal = ms.X;
Console.WriteLine(xVal);//Displays 10
}
}
Structs & Inheritance
There is no inheritance for structs as there is for classes.
.jpg)
No comments:
Post a Comment