December 31, 2013

Advanced CSharp Part 2 : Structs and Interfaces

We shall continue on more advanced features on CSharp. We have already seen how to use classes on different circumstances and how to modify its behavior under certain restraints; in this post we shall see two more data types that provide "class" type facilities, yet very different in nature and usages.

Struct: We start with structs. If you are familiar with C or C++, you are already acquainted with structs. Structs are similar to classes, but comes with some important differences.
  • Classes are reference types, while structs are value types.
  • They do not support inheritance. They do not derive (subclass) other struct types.
  • It is not possible to initiate a variable inside the struct definition. You have to do the initialization outside.
 The essential theme of using either of the class or a struct is the same: you want to keep logically relevant data together. So how do we understand when to use class or struct? We use struct when we have a small and simple data to handle. You just really don't need to mess up with classes when you need to handle just two or three variables and member fields. structs also allow properties and constructors like classes do. Let's see a working example.

using System;

namespace Spells
{
    public struct MyPoint
    {
        int x;
        int y;
        public MyPoint(int _x, int _y)
        {
            x = _x;
            y = _y;
        }
        public int Xcord 
        { 
            get { return x; }
            set { x = value; }
        }
        public int Ycord 
        {
            get { return y; }
            set { y = value; }
        }
    }
    class Program
    {
        public static void Main(string[] args)
        {
            MyPoint point = new MyPoint(4, -7);
            Console.WriteLine("point X = {0}, Y = {1}", point.Xcord, point.Ycord);

            MyPoint npoint = new MyPoint();
            npoint.Xcord = 64;
            npoint.Ycord = 45;
            Console.WriteLine("npoint X = {0}, Y = {1}", npoint.Xcord, npoint.Ycord);

            Console.Read();
        }
    }
}
Line 5 is no different than what you used to do while using classes. The only thing different is the keyword struct instead of class. I have used two variables of int types to indicate the x and y coordinates. Line 9 is a constructor that takes two arguments. Line 14 and 19 are two properties with getter and setter fields. I have created two instances of this struct inside the Main method. Consider line 29 and 32. You will see two different ways of instantiating struct type variables. Note that I have provided only a constructor that takes two arguments (see line 9). But still I am able to instantiate npoint at line 32 that takes no arguments. You can't really do that with classes.

You could still use a class instead of struct. But you use a struct when you see that you have lesser data to handle and you do not need additional methods to handle logic inside your program.

Interface: An interface is essentially a class. It's a close cousin of abstract class. Interfaces provide a way of grouping a set of common behaviors in a single place. They provide a specification rather than an implementation. If you are not familiar with abstract classes, you can get an idea in the last post. Consider the building codes class that we used earlier. If it happens that there are certain more regulations that builders must follow, then it will create a problem in your program because you cannot inherit more than one abstract class. But classes can in fact inherit multiple interfaces. Interfaces are more like behaviors. You implement these behaviors to the classes whoever wish to implement your interface.

using System;

namespace Spells
{
    interface IUtilities /* it is a convention to start interface name with 'I' */
    {
        bool Gas();         /* no method implementation logic here */
        bool Water();
        bool Electricity();
    }
    interface ICommercial
    {
        void Commercial();
    }
    interface IHousehold
    {
        bool Housing();
    }
    public class Hotel : IUtilities, ICommercial  /* multiple interfaces */
    {
        public bool Gas()
        { //codes here
            return true;
        }
        public bool Water()
        { //codes here
            return true;
        }
        public bool Electricity()
        { //codes here
            return true;
        }
        public void Commercial() { /*codes*/ }
        // other methods and members
    }
    public class MyHome : IUtilities, IHousehold
    {
        public bool Gas()
        { //codes here
            return true;
        }
        public bool Water()
        { //codes here
            return true;
        }
        public bool Electricity()
        { //codes here
            return true;
        }
        public bool Housing()
        {
            return true;
        }
    }
    class Program
    {
        public static void Main(string[] args)
        {
            
            Console.Read();
        }
    }
}
Build this code (F6). You will get a successful build. Line 5, 11 and 15 shows interface definition. It is a convention to name an interface with an uppercase 'I'. You may choose not to do so. Inside the interfaces definition, observe that there is no logic implementation here. You just specify which methods the implementing classes must implement. 

Line 19 and 36 shows how to implement interfaces in a class. The most important point is that you are able to implement multiple interfaces separated by comma. Also observe that you have to use the keyword public in front of the implementing methods. Go ahead and erase one of the methods from Hotel class. Your code will fail to build with an error.

To sum up, interfaces are nice way to force you to implement certain functionalities inside your code. An alternative is abstract class. But if you have multiple classes to inherit, you better make them interfaces and implement them as you can see above.