Ebooks

C# object-oriented programming II

In this chapter of the C# tutorial, we continue description of the OOP. We cover interfaces,polymorphism, deep and shallow copy, sealed classes and exceptions.

C# interfaces

A remote control is an interface between the viewer and the TV. It is an interface to this electronic device. Diplomatic protocol guides all activities in the diplomatic field. Rules of the road are rules that motorists, cyclists and pedestrians must follow. Interfaces in programming are analogous to the previous examples.

Interfaces are:

Objects interact with the outside world with the methods they expose. The actual implementation is not important to the programmer, or it also might be secret. A company might sell a library and it does not want to disclose the actual implementation. A programmer might call a Maximize() method on a window of a GUI toolkit but knows nothing about how this method is implemented. From this point of view, interfaces are ways through which objects interact with the outside world, without exposing too much about their inner workings.

From the second point of view, interfaces are contracts. If agreed upon, they must be followed. They are used to design an architecture of an application. They help organize the code.

Interfaces are fully abstract types. They are declared using the interface keyword. Interfaces can only have signatures of methods, properties, events, or indexers. All interface members implicitly have public access. Interface members cannot have access modifiers specified. Interfaces cannot have fully implemented methods, nor member fields. A C# class may implement any number of interfaces. An interface can also extend any number of interfaces. A class that implements an interface must implement all method signatures of an interface.

Interfaces are used to simulate multiple inheritance. A C# class can inherit only from one class but it can implement multiple interfaces. Multiple inheritance using the interfaces is not about inheriting methods and variables. It is about inheriting ideas or contracts, which are described by the interfaces.

There is one important distinction between interfaces and abstract classes. Abstract classes provide partial implementation for classes that are related in the inheritance hierarchy. Interfaces on the other hand can be implemented by classes that are not related to each other. For example, we have two buttons. A classic button and a round button. Both inherit from an abstract button class that provides some common functionality to all buttons. Implementing classes are related, since all are buttons. Another example might have classes Database and SignIn. They are not related to each other. We can apply an ILoggable interface that would force them to create a method to do logging.

C# simple interface

The following program uses a simple interface.

Program.cs
using System;

namespace SimpleInterface
{
    interface IInfo
    {
        void DoInform();
    }

    class Some : IInfo
    {
        public void DoInform()
        {
            Console.WriteLine("This is Some Class");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var some = new Some();
            some.DoInform();
        }
    }
}

This is a simple C# program demonstrating an interface.

interface IInfo
{
    void DoInform();   
}

This is an interface IInfo. It has the DoInform() method signature.

class Some : IInfo

We implement the IInfo interface. To implement a specific interface, we use the colon (:) operator.

public void DoInform()
{
    Console.WriteLine("This is Some Class");
}

The class provides an implementation for the DoInform() method.

C# multiple interfaces

The next example shows how a class can implement multiple interfaces.

Program.cs
using System;

namespace MultipleInterfaces
{
    interface Device
    {
        void SwitchOn();
        void SwitchOff();
    }

    interface Volume
    {
        void VolumeUp();
        void VolumeDown();
    }

    interface Pluggable
    {
        void PlugIn();
        void PlugOff();
    }

    class CellPhone : Device, Volume, Pluggable
    {
        public void SwitchOn()
        {
            Console.WriteLine("Switching on");
        }

        public void SwitchOff()
        {
            Console.WriteLine("Switching on");
        }

        public void VolumeUp()
        {
            Console.WriteLine("Volume up");
        }

        public void VolumeDown()
        {
            Console.WriteLine("Volume down");
        }

        public void PlugIn()
        {
            Console.WriteLine("Plugging In");
        }

        public void PlugOff()
        {
            Console.WriteLine("Plugging Off");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var cellPhone = new CellPhone();

            cellPhone.SwitchOn();
            cellPhone.VolumeUp();
            cellPhone.PlugIn();
        }
    }
}

We have a CellPhone class that inherits from three interfaces.

class CellPhone : Device, Volume, Pluggable

The class implements all three interfaces, which are divided by a comma. The CellPhone class must implement all method signatures from all three interfaces.

$ dotnet run
Switching on
Volume up
Plugging In

Running the program we get this output.

C# multiple interface inheritance

The next example shows how interfaces can inherit from multiple other interfaces.

Program.cs
using System;

namespace InterfaceInheritance
{
    interface IInfo
    {
        void DoInform();
    }

    interface IVersion
    {
        void GetVersion();
    }

    interface ILog : IInfo, IVersion
    {
        void DoLog();
    }

    class DBConnect : ILog
    {

        public void DoInform()
        {
            Console.WriteLine("This is DBConnect class");
        }

        public void GetVersion()
        {
            Console.WriteLine("Version 1.02");
        }

        public void DoLog()
        {
            Console.WriteLine("Logging");
        }

        public void Connect()
        {
            Console.WriteLine("Connecting to the database");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var db = new DBConnect();

            db.DoInform();
            db.GetVersion();
            db.DoLog();
            db.Connect();
        }
    }
}

We define three interfaces. We can organize interfaces in a hierarchy.

interface ILog : IInfo, IVersion

The ILog interface inherits from two other interfaces.

public void DoInform() 
{
    Console.WriteLine("This is DBConnect class");
}

The DBConnect class implements the DoInform() method. This method was inherited by the ILog interface, which the class implements.

$ dotnet run
This is DBConnect class
Version 1.02
Logging
Connecting to the database

This is the output.

C# polymorphism

The polymorphism is the process of using an operator or function in different ways for different data input. In practical terms, polymorphism means that if class B inherits from class A, it does not have to inherit everything about class A; it can do some of the things that class A does differently.

In general, polymorphism is the ability to appear in different forms. Technically, it is the ability to redefine methods for derived classes. Polymorphism is concerned with the application of specific implementations to an interface or a more generic base class.

Polymorphism is the ability to redefine methods for derived classes.

Program.cs
using System;

namespace Polymorphism
{
    abstract class Shape
    {
        protected int x;
        protected int y;

        public abstract int Area();
    }

    class Rectangle : Shape
    {
        public Rectangle(int x, int y)
        {
            this.x = x;
            this.y = y;
        }

        public override int Area()
        {
            return this.x * this.y;
        }
    }

    class Square : Shape
    {
        public Square(int x)
        {
            this.x = x;
        }

        public override int Area()
        {
            return this.x * this.x;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Shape[] shapes = { new Square(5), new Rectangle(9, 4), new Square(12) };

            foreach (Shape shape in shapes)
            {
                Console.WriteLine(shape.Area());
            }
        }
    }
}

In the above program, we have an abstract Shape class. This class morphs into two descendant classes: Rectangle and Square. Both provide their own implementation of the Area() method. Polymorphism brings flexibility and scalability to the OOP systems.

public override int Area()
{
    return this.x * this.y;
}
...
public override int Area()
{
    return this.x * this.x;
}

The Rectangle and the Square classes have their own implementations of the Area() method.

Shape[] shapes = { new Square(5), new Rectangle(9, 4), new Square(12) };

We create an array of three Shapes.

foreach (Shape shape in shapes)
{
    Console.WriteLine(shape.Area());
}

We go through each shape and call the Area() method on it. The compiler calls the correct method for each shape. This is the essence of polymorphism.

C# sealed classes

The sealed keyword is used to prevent unintended derivation from a class. A sealed class cannot be an abstract class.

Program.cs
using System;

namespace DerivedMath
{
    sealed class Math
    {
        public static double GetPI()
        {
            return 3.141592;
        }
    }

    class Derived : Math
    {
        public void Say()
        {
            Console.WriteLine("Derived class");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var dm = new Derived();
            dm.Say();
        }
    }
}

In the above program, we have a base Math class. The sole purpose of this class is to provide some helpful methods and constants to the programmer. (In our case we have only one method for simplicity reasons.) It is not created to be inherited from. To prevent uninformed other programmers to derive from this class, the creators made the class sealed. If you try to compile this program, you get the following error: 'Derived' cannot derive from sealed class `Math'.

C# deep copy vs shallow copy

Copying of data is an important task in programming. Object is a composite data type in OOP. Member field in an object may be stored by value or by reference. Copying may be performed in two ways.

The shallow copy copies all values and references into a new instance. The data to which a reference is pointing is not copied; only the pointer is copied. The new references are pointing to the original objects. Any changes to the reference members affect both objects.

The deep copy copies all values into a new instance. In case of members that are stored as references, a deep copy performs a deep copy of data that is being referenced. A new copy of a referenced object is created. And the pointer to the newly created object is stored. Any changes to those referenced objects will not affect other copies of the object. Deep copies are fully replicated objects.

If a member field is a value type, a bit-by-bit copy of the field is performed. If the field is a reference type, the reference is copied but the referred object is not; therefore, the reference in the original object and the reference in the clone point to the same object. (a clear explanation from programmingcorner.blogspot.com)

C# Shallow copy

The following program performs shallow copy.

Program.cs
using System;

namespace ShallowCopy
{
    class Color
    {
        public int red;
        public int green;
        public int blue;

        public Color(int red, int green, int blue)
        {
            this.red = red;
            this.green = green;
            this.blue = blue;
        }
    }

    class MyObject : ICloneable
    {
        public int id;
        public string size;
        public Color col;

        public MyObject(int id, string size, Color col)
        {
            this.id = id;
            this.size = size;
            this.col = col;
        }

        public object Clone()
        {
            return new MyObject(this.id, this.size, this.col);
        }

        public override string ToString()
        {
            var s = String.Format("id: {0}, size: {1}, color:({2}, {3}, {4})",
                this.id, this.size, this.col.red, this.col.green, this.col.blue);
            return s;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var col = new Color(23, 42, 223);
            var obj1 = new MyObject(23, "small", col);

            var obj2 = (MyObject) obj1.Clone();

            obj2.id += 1;
            obj2.size = "big";
            obj2.col.red = 255;

            Console.WriteLine(obj1);
            Console.WriteLine(obj2);
        }
    }
}

This is an example of a shallow copy. We define two custom objects: MyObject and Color. The MyObject object will have a reference to the Color object.

class MyObject : ICloneable

We should implement ICloneable interface for objects which we are going to clone.

public object Clone()
{
    return new MyObject(this.id, this.size, this.col);
}

The ICloneable interface forces us to create a Clone() method. This method returns a new object with copied values.

var col = new Color(23, 42, 223);  

We create an instance of the Color object.

var obj1 = new MyObject(23, "small", col);

An instance of the MyObject class is created. The instance of the Color object is passed to the constructor.

var obj2 = (MyObject) obj1.Clone();

We create a shallow copy of the obj1 object and assign it to the obj2 variable. The Clone() method returns an Object and we expect MyObject. This is why we do explicit casting.

obj2.id += 1;
obj2.size = "big";         
obj2.col.red = 255;

Here we modify the member fields of the copied object. We increment the id, change the size to "big" and change the red part of the color object.

Console.WriteLine(obj1);
Console.WriteLine(obj2);

The Console.WriteLine() method calls the ToString() method of the obj2 object which returns the string representation of the object.

$ dotnet run
id: 23, size: small, color:(255, 42, 223)
id: 24, size: big, color:(255, 42, 223)

We can see that the ids are different (23 vs 24). The size is different ("small" vs "big"). But the red part of the color object is same for both instances (255). Changing member values of the cloned object (id, size) did not affect the original object. Changing members of the referenced object (col) has affected the original object too. In other words, both objects refer to the same color object in memory.

C# Deep copy

To change this behaviour, we will do a deep copy next.

Program.cs
using System;

namespace DeepCopy
{
    class Color : ICloneable
    {
        public int red;
        public int green;
        public int blue;

        public Color(int red, int green, int blue)
        {
            this.red = red;
            this.green = green;
            this.blue = blue;
        }

        public object Clone()
        {
            return new Color(this.red, this.green, this.blue);
        }
    }

    class MyObject : ICloneable
    {
        public int id;
        public string size;
        public Color col;

        public MyObject(int id, string size, Color col)
        {
            this.id = id;
            this.size = size;
            this.col = col;
        }

        public object Clone()
        {
            return new MyObject(this.id, this.size,
                (Color)this.col.Clone());
        }

        public override string ToString()
        {
            var s = String.Format("id: {0}, size: {1}, color:({2}, {3}, {4})",
                this.id, this.size, this.col.red, this.col.green, this.col.blue);
            return s;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var col = new Color(23, 42, 223);
            var obj1 = new MyObject(23, "small", col);

            var obj2 = (MyObject) obj1.Clone();

            obj2.id += 1;
            obj2.size = "big";
            obj2.col.red = 255;

            Console.WriteLine(obj1);
            Console.WriteLine(obj2);
        }
    }
}

In this program, we perform a deep copy on an object.

class Color : ICloneable

Now the Color class implements the ICloneable interface.

public object Clone()
{
    return new Color(this.red, this.green, this.blue);
}

We have a Clone() method for the Color class too. This helps to create a copy of a referenced object.

public object Clone()
{
    return new MyObject(this.id, this.size, 
        (Color) this.col.Clone());
}

When we clone the MyObject, we call the Clone() method upon the col reference type. This way we have a copy of a color value too.

$ dotnet run
id: 23, size: small, color:(23, 42, 223)
id: 24, size: big, color:(255, 42, 223)

Now the red part of the referenced Color object is not the same. The original object has retained its previous value (23).

C# exceptions

Exceptions are designed to handle the occurrence of exceptions, special conditions that change the normal flow of program execution. Exceptions are raised or thrown.

During the execution of our application many things might go wrong. A disk might get full and we cannot save our file. An Internet connection might go down while our application tries to connect to a site. All these might result in a crash of our application. It is a responsibility of a programmer to handle errors that can be anticipated.

The try, catch and finally keywords are used to work with exceptions.

Program.cs
using System;

namespace DivisionByZero
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 100;
            int y = 0;
            int z;

            try
            {
                z = x / y;
            } 
             catch (ArithmeticException e)
            {
                Console.WriteLine("An exception occurred");
                Console.WriteLine(e.Message);
            }
        }
    }
}

In the above program, we intentionally divide a number by zero. This leads to an error.

try
{
    z = x / y;
}

Statements that are error prone are placed in the try block.

 catch (ArithmeticException e)
{
    Console.WriteLine("An exception occurred");
    Console.WriteLine(e.Message);
}

Exception types follow the catch keyword. In our case we have an ArithmeticException. This exception is thrown for errors in an arithmetic, casting, or conversion operation. Statements that follow the catch keyword are executed when an error occurs. When an exception occurs, an exception object is created. From this object we get the Message property and print it to the console.

$ dotnet run
An exception occurred
Attempted to divide by zero.

Output of the code example.

C# uncaught exception

Any uncaught exception in the current context propagates to a higher context and looks for an appropriate catch block to handle it. If it can't find any suitable catch blocks, the default mechanism of the .NET runtime will terminate the execution of the entire program.

Program.cs
using System;

namespace UcaughtException
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 100;
            int y = 0;

            int z = x / y;

            Console.WriteLine(z);
        }
    }
}

In this program, we divide by zero. There is no no custom exception handling.

$ dotnet run

Unhandled Exception: System.DivideByZeroException: Division by zero
  at UncaughtException.Main () [0x00000]

The C# compiler gives the above error message.

C# IOException

The IOException is thrown when an I/O error occurs. In the following example we read the contents of a file.

Program.cs
using System;
using System.IO;

namespace ReadFile
{
    class Program
    {
        static void Main(string[] args)
        {
            var fs = new FileStream("langs.txt", FileMode.OpenOrCreate);

            try
            {
                var sr = new StreamReader(fs);
                string line;

                while ((line = sr.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                }

            }
            catch (IOException e)
            {
                Console.WriteLine("IO Error");
                Console.WriteLine(e.Message);
            }
            finally
            {
                Console.WriteLine("Inside finally block");

                if (fs != null)
                {
                    fs.Close();
                }
            }
        }
    }
}

The statements following the finally keyword are always executed. It is often used for clean-up tasks, such as closing files or clearing buffers.

} catch (IOException e)
{
    Console.WriteLine("IO Error");
    Console.WriteLine(e.Message);
} 

In this case, we catch for a specific IOException exception.

} finally
{
    Console.WriteLine("Inside finally block");

    if (fs != null)  
    {
        fs.Close();
    }
}

These lines guarantee that the file handler is closed.

$ cat langs.txt
C#
Java
Python
Ruby
PHP
JavaScript

These are the contents of the langs.txt file.

$ dotnet run
C#
Java
Python
Ruby
PHP
JavaScript
Inside finally block

This is the output of the program.

We show the contents of the langs file with the cat command and output of the program.

C# Multiple exceptions

We often need to deal with multiple exceptions.

Program.cs
using System;
using System.IO;

namespace MultipleExceptions
{
    class Program
    {
        static void Main(string[] args)
        {
            int x;
            int y;
            double z;

            try
            {
                Console.Write("Enter first number: ");
                x = Convert.ToInt32(Console.ReadLine());

                Console.Write("Enter second number: ");
                y = Convert.ToInt32(Console.ReadLine());

                z = x / y;
                Console.WriteLine("Result: {0:N} / {1:N} = {2:N}", x, y, z);

            }
            catch (DivideByZeroException e)
            {
                Console.WriteLine("Cannot divide by zero");
                Console.WriteLine(e.Message);

            }
            catch (FormatException e)
            {
                Console.WriteLine("Wrong format of number.");
                Console.WriteLine(e.Message);
            }
        }
    }
}

In this example, we catch for various exceptions. Note that more specific exceptions should precede the generic ones. We read two numbers from the console and check for zero division error and for wrong format of number.

$ dotnet run
Enter first number: we
Wrong format of number.
Input string was not in a correct format.

Running the example we get this outcome.

C# custom exceptions

Custom exceptions are user defined exception classes that derive from the System.Exception class.

Program.cs
using System;

namespace CustomException
{
    class BigValueException : Exception
    {
        public BigValueException(string msg) : base(msg) { }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int x = 340004;
            const int LIMIT = 333;

            try
            {
                if (x > LIMIT)
                {
                    throw new BigValueException("Exceeded the maximum value");
                }

            }
            catch (BigValueException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

We assume that we have a situation in which we cannot deal with big numbers.

class BigValueException : Exception

We have a BigValueException class. This class derives from the built-in Exception class.

const int LIMIT = 333;

Numbers bigger than this constant are considered to be "big" by our program.

public BigValueException(string msg) : base(msg) {}

Inside the constructor, we call the parent's constructor. We pass the message to the parent.

if (x > LIMIT)
{
    throw new BigValueException("Exceeded the maximum value");
}

If the value is bigger than the limit, we throw our custom exception. We give the exception a message "Exceeded the maximum value".

} catch (BigValueException e)
{
    Console.WriteLine(e.Message);
}

We catch the exception and print its message to the console.

$ dotnet run
Exceeded the maximum value

This is the output of the program.

In this part of the C# tutorial, we continued the discussion of the object-oriented programming in C#.