Understanding Structures in C#

// Author: [email protected]   
using System;  
struct MyStruct {  
    int x;  
    int y; {  
        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();  
    }  
}

The 'this' operator can also be used in constructors and parameterized constructors can be chained inside a C# constructor. An example is given below.

// Author: [email protected]  
using System;  
struct MyStruct {  
    int x;  
    int y;  
    public MyStruct(int i, int j): this(i + 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);  
        ms1.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  
// Author: [email protected]  
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 & Indexers

The indexers can also be used with a C# struct. An example is shown below.

// Author: [email protected]   
using System;  
using System.Collections;  
struct MyStruct {  
    public string[] data;  
    public string this[int index] {  
        get {  
            return data[index];  
        }  
        set {  
            data[index] = value;  
        }  
    }  
}  
class MyClient {  
    public static void Main() {  
        MyStruct ms = new MyStruct();  
        ms.data = new string[5];  
        ms[0] = "Rajesh";  
        ms[1] = "A3-126";  
        ms[2] = "Snehadara";  
        ms[3] = "Irla";  
        ms[4] = "Mumbai";  
        Console.WriteLine("{0},{1},{2},{3},{4}", ms[0], ms[1], ms[2], ms[3], ms[4]);  
    }  
}

Structs & Operator Overloading

The operators can be overloaded inside a C# structure also. The same rules applicable with respect to a C# class is also applicable here. Both unary and binary operators can be overloaded.

// Author: [email protected]   
using System;  
struct Complex {  
    private int x;  
    private int y;  
    public Complex(int i, int j) {  
        x = i;  
        y = j;  
    }  
    public void ShowXY() {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
    public static Complex operator - (Complex c) {  
        Complex temp = new Complex();  
        temp.x = -c.x;  
        temp.y = -c.y;  
        return temp;  
    }  
}  
class MyClient {  
    public static void Main() {  
        Complex c1 = new Complex(10, 20);  
        c1.ShowXY(); // displays 10 & 20  
        Complex c2 = new Complex();  
        c2.ShowXY(); // displays 0 & 0  
        c2 = -c1;  
        c2.ShowXY(); // diapls -10 & -20  
    }  
}

Structs & Inheritance

There is no inheritance for structs as there is for classes. A struct can't inherit from another struct or class and it can't be the base class for a class. But remember that in C# all types are directly or indirectly inheriting from the super base class object and hence the structure also. Since structs doesn't support inheritance, we can't use the keywords virtual, override, new, abstract etc with a struct methods. C# struct types are never abstract and are always implicitly sealed. The abstract or sealed modifiers are not permitted in a struct declaration.

Since inheritance is not supported for structs, the declared accessibility of a struct member can't be protected or protected internal. Since all struct types are implicitly inherit from object class, it is possible to override the methods of the object class inside a struct by using the keyword override. Remember that this is special case in C# structs.

Structs & Interfaces

Just like classes, a C# struct can also implement from an interface. For example

// Author:[email protected]    
using System;  
interface IInterface {  
    void Method();  
}  
struct Complex: IInterface {  
    public void Method() {  
        Console.WriteLine("Struct Method");  
    }  
}  
class MyClient {  
    public static void Main() {  
        Complex c1 = new Complex();  
        c1.Method();  
    }  
} // This is just a sample script. Paste your real code (javascript or HTML) here.  
if ('this_is' == /an_example/) {  
    of_beautifier();  
} else {  
    var a = b ? (c % d) : e[f];  
}

Structs & Classes

The structs in C# seems to similar to classes. But they are two entirely different aspects of the language. The classes are reference types while a struct is a value type in C#. The objects of class types are always created on heal while the objects of struct types are always created on the stack. But C# structs are useful for small data structures that have value semantics. Complex numbers, points in a co-ordinate systems, etc are good examples for struct types.