February 2016 – LearnC#WithDarko

MonthFebruary 2016

Constructors are a public methods with the same name as a class were they resides. Constructors are always created with a class, weather we write it ourselves or if class creates it for us(although it will not be visible ). Role of constructors is to initialize fields when we instantiate class. It is possible to create multiple constructors. Adding „: this()“ after parameters of constructor with parameters will execute default constructor before constructors with parameters. To easily create constructors type ctor keyword an new one will be generated for you.

public class ClassWithConstructor
{
    // Default ctor
    public ClassWithConstructor()
    {
        PrintDefaultConstructor();
    }

    // Parameterised ctor
    public ClassWithConstructor(string name, int id)
    {
        Name = name;
        Id = id;

        PrintParameterisedConstructor();
    }

    private string _name;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    private int _id;

    public int Id
    {
        get { return _id; }
        set { _id = value; }
    }

    private void PrintDefaultConstructor()
    {
        Console.WriteLine("Default Constructor");
    }

    private void PrintParameterisedConstructor()
    {
        Console.WriteLine("Parameterised Constructor");
    }

}

public class SomeOtherClass
{
    private static void Main(string[] args)
    {
        ClassWithConstructor firstInstance = new ClassWithConstructor();

        ClassWithConstructor secondInstance = new ClassWithConstructor("Mike", 1);

        Console.WriteLine(secondInstance.Name + " " + secondInstance.Id);
    }
}

public class ClassWithConstructor

{

// Default ctor

public ClassWithConstructor()

{

PrintDefaultConstructor();

}

// Parameterised ctor

public ClassWithConstructor(string name, int id)

{

Name = name;

Id = id;

PrintParameterisedConstructor();

}

private string _name;

public string Name

{

get { return _name; }

set { _name = value; }

}

private int _id;

public int Id

{

get { return _id; }

set { _id = value; }

}

private void PrintDefaultConstructor()

{

Console.WriteLine("Default Constructor");

}

private void PrintParameterisedConstructor()

{

Console.WriteLine("Parameterised Constructor");

}

public class SomeOtherClass

{

private static void Main(string[] args)

{

ClassWithConstructor firstInstance = new ClassWithConstructor();

ClassWithConstructor secondInstance = new ClassWithConstructor("Mike", 1);

Console.WriteLine(secondInstance.Name + " " + secondInstance.Id);

}

If you have ever initialized class you have consumed constructors in one way or another. Example of consuming constructors would be in previous example where we have instantiated ClassWithConstructor class with string “Mike” and integer 1.

ClassWithConstructor secondInstance = new ClassWithConstructor("Mike", 1);

1	ClassWithConstructor secondInstance = new ClassWithConstructor("Mike", 1);

Is it possible to forbid class to initialize constructor?

Yes it is, just create empty one and set private access modifier.

public class MyClass
{
   private MyClass()
   {
      // Do some work
   }
}

public class MyClass

{

private MyClass()

{

// Do some work

}

What about other access modifiers? Can I use them all?

Public, private, protected, internal, or protected internal access modifiers are allowed to be used with constructors.

How can i initialize base class constructors ?

Simply type

: base(paramterName)

1	: base(paramterName)

after constructors parameters . Remember, you don’t have to supply parameters for base class constructor because base constructor will always be called before derived class constructor, weather we call it or not.

Explicit Interface member implementations

09/02/2016 / Darko / 0 Comments

Explicit Interface are implemented explicitly if for example two or more of our interfaces implement same method/properties/etc… names and different implementation. Other usages can be to implement strong typing and cleaner code.

interface ICarWheels
    {
        void Method();
        string Property { get; set; }
    }

    interface ICarEngine
    {
        void Method();
        string Property { get; set; }
    }

public class Car : ICarEngine, ICarWheels
    {
        void ICarEngine.Method()
        {
            Console.WriteLine("ICarWheels.Method");
        }

        string ICarWheels.Property { get; set; }

        void ICarWheels.Method()
        {
            Console.WriteLine("ICarWheels.Method");
        }

        string ICarEngine.Property { get; set; }
        }
    }

interface ICarWheels

{

void Method();

string Property { get; set; }

}

interface ICarEngine

{

void Method();

string Property { get; set; }

}

public class Car : ICarEngine, ICarWheels

{

void ICarEngine.Method()

{

Console.WriteLine("ICarWheels.Method");

}

string ICarWheels.Property { get; set; }

void ICarWheels.Method()

{

Console.WriteLine("ICarWheels.Method");

}

string ICarEngine.Property { get; set; }

}

Implicit Interface member implementations

08/02/2016 / Darko / 0 Comments

Example will show how to create new interface called ICarSpecifications which will hold a property and a method. ICarSpecifications interface will be implemented inside Car class and its implementation will be inside region InterfaceImplementation(note: you can manually create implementation OR when you type ICarSpecifications pres keys CTRL + . and click Implement missing members. Region will not be implemented automatically).

interface ICarSpecifications
    {

        // void method with one parameter
        void CarName(string carColor);

        // simple auto-implemented property
        string CarColor { get; set; }
    }

    public class Car : ICarSpecifications
    {
        // our field
        private static string _carName;


        #region InterfaceImplementation
        public void CarName(string carColor)
        {
            _carName = "Black " + CarColor;
        }

        public string CarColor { get; set; }
        #endregion


        private static void Main(string[] args)
        {
            Car newCar = new Car();
            newCar.CarColor = "BMW";
            newCar.CarName(newCar.CarColor);

            Console.WriteLine("Model name is {0}", _carName); 
        }
    }
}

interface ICarSpecifications

{

// void method with one parameter

void CarName(string carColor);

// simple auto-implemented property

string CarColor { get; set; }

}

public class Car : ICarSpecifications

{

// our field

private static string _carName;

#region InterfaceImplementation

public void CarName(string carColor)

{

_carName = "Black " + CarColor;

}

public string CarColor { get; set; }

#endregion

private static void Main(string[] args)

{

Car newCar = new Car();

newCar.CarColor = "BMW";

newCar.CarName(newCar.CarColor);

Console.WriteLine("Model name is {0}", _carName);

}

Tomorrow we will continue with explicit interfaces implementations.

Interfaces

07/02/2016 / Darko / 0 Comments

Interfaces are a type of contract between interface and class or struct. Interface is defined by interface keyword and the name of interface should usually start with capital letter I to make it more recognizable.

When we say Interface is a contract, what do you really mean?

Every class or struct that uses some interface must implement all of its functionalities.
Why would you use Interface at all?

There are multiple reasons actually:

Firstly, a class or classes that use Interface must use all of Interfaces functionalities. Secondly, names of all properties, methods… must be same in all classes as they are in that specific Interface. Furthermore Interfaces are obligatory, imagine situation where you must in a few classes use 3 methods Get, Insert and Delete, when you use interface with your classes there is no possibility of forgetting to implement either of these methods. Lastly, because C# does not allow us to inherit multiple classes but allows us to implement multiple Interfaces, we can create multiple interfaces where each interface inherits a class and use these interface as workaround.

What can we define inside Interface?

Events

Indexers

Methods (but without implementation)

Properties

What are Interface limitations?

Interfaces cannot define:

Constants

Constructors

Fields

Operators

We cannot make interface or its members static

What about access modifiers?

By default all interface members are public and we cannot change it.

Can we instantiate Interface? Yes we can, limitation is that you must instantiate them using a class or struct that implements that interface.

Is there a limit to how many Interfaces can we implement at the same time? Yes and no. Although language specification state that you can implement as many Interfaces as you like, there are few technical limitations: heap size and metadata tables size, but worry not, you will never exceed that limit.

Please, drop by tomorrow to see a few Interface examples .

Explicit Interface member implementations

Implicit Interface member implementations

Inheritance

06/02/2016 / Darko / 2 Comments

Inheritance

What exactly is Inheritance? MSDN explanation says : Inheritance enables you to create new classes that reuse, extend, and modify the behavior that is defined in other classes. The class whose members are inherited is called the base class, and the class that inherits those members is called the derived class. A derived class can have only one direct base class. However, inheritance is transitive. If ClassC is derived from ClassB, and ClassB is derived from ClassA, ClassC inherits the members declared in ClassB and ClassA.

So what can we inherit? For example we have Car and Motorcycle classes, and as we know cars and motorcycles have a few things in common such as engine and color. We could create a base class named Vehicle that has those properties and make Car and Motorcycle classes which will inherit Vehicle class.

using System;

namespace Vehicle
{
    public class Vehicle
    {
        public string EngineModel { get; set; }
        public string VechileColor { get; set; }
    }

    public class Car : Vehicle
    {
        public bool IsHybrid { get; set; }
    }

    public class RacingCar :Car
    {
        public bool IsStreetLegal { get; set; }
    }

    public class Motorcycle : Vehicle
    {
        public bool HasSideCar { get; set; }
    }

    public class Program1
    {
        private static void Main(string[] args)
        {
            Car car = new Car();
            car.EngineModel = "Medium Engine Mk.1";
            car.VechileColor = "Black";
            car.IsHybrid = false;
            // Try commenting next line and you will see proof that Car class can inherit from Vehicles class not from RacingCar class
            // or that
            //car.IsStreetLegal = true;

            Motorcycle motorcycle = new Motorcycle();
            motorcycle.EngineModel = "Light Engine Mk. 4";
            motorcycle.VechileColor = "Orange";
            // Try uncommenting next line to see if Motorcycle class can iherit from Car class
            //motorcycle.IsHybrid = true;

            RacingCar raceCar = new RacingCar();
            raceCar.EngineModel = "Lightning Engine Mk. 7";
            raceCar.VechileColor = "Red";
            raceCar.IsStreetLegal = true;
            car.IsHybrid = false;

            Console.WriteLine("Car engine model is {0} and color of a car is {1}. Is car hybrid? {2}", car.EngineModel, car.VechileColor, car.IsHybrid);
            Console.WriteLine("Motorcycle engine model is {0} and color of a motorcycle is {1}. Does this model come with side car? {2}", motorcycle.EngineModel, motorcycle.VechileColor, motorcycle.HasSideCar);
            Console.WriteLine("Racing car engine model is {0} and color of a racing car is {1}. Is racing car hybrid? {2}. Is racing car legal to drive on the streets? {3}", raceCar.EngineModel, raceCar.VechileColor, raceCar.IsHybrid, raceCar.IsStreetLegal);
        }
    }
}

using System;

namespace Vehicle

{

public class Vehicle

{

public string EngineModel { get; set; }

public string VechileColor { get; set; }

}

public class Car : Vehicle

{

public bool IsHybrid { get; set; }

}

public class RacingCar :Car

{

public bool IsStreetLegal { get; set; }

}

public class Motorcycle : Vehicle

{

public bool HasSideCar { get; set; }

}

public class Program1

{

private static void Main(string[] args)

{

Car car = new Car();

car.EngineModel = "Medium Engine Mk.1";

car.VechileColor = "Black";

car.IsHybrid = false;

// Try commenting next line and you will see proof that Car class can inherit from Vehicles class not from RacingCar class

// or that

//car.IsStreetLegal = true;

Motorcycle motorcycle = new Motorcycle();

motorcycle.EngineModel = "Light Engine Mk. 4";

motorcycle.VechileColor = "Orange";

// Try uncommenting next line to see if Motorcycle class can iherit from Car class

//motorcycle.IsHybrid = true;

RacingCar raceCar = new RacingCar();

raceCar.EngineModel = "Lightning Engine Mk. 7";

raceCar.VechileColor = "Red";

raceCar.IsStreetLegal = true;

car.IsHybrid = false;

Console.WriteLine("Car engine model is {0} and color of a car is {1}. Is car hybrid? {2}", car.EngineModel, car.VechileColor, car.IsHybrid);

Console.WriteLine("Motorcycle engine model is {0} and color of a motorcycle is {1}. Does this model come with side car? {2}", motorcycle.EngineModel, motorcycle.VechileColor, motorcycle.HasSideCar);

Console.WriteLine("Racing car engine model is {0} and color of a racing car is {1}. Is racing car hybrid? {2}. Is racing car legal to drive on the streets? {3}", raceCar.EngineModel, raceCar.VechileColor, raceCar.IsHybrid, raceCar.IsStreetLegal);

}

Can i inherit from multiple classes? No, but you can Inherit multiple Interfaces that inherit one class.

I don’t wish for my class or method to be directly instantiated. What can I do about that problem? You can make those classes or methods abstract. Beware, when you make your class abstract one, none of your class members have to be marked as abstract, but if at least one of your members is marked as abstract, entire class must be marked as abstract.

Can derived class access private fields of base class? No, it can not. You can only access internal, public, protected, and protected internal members of a base class.

Is it possible to prevent our class from becoming other classes base class? Yes, mark that class as sealed and other classes cannot inherit from this class.

Properties

05/02/2016 / Darko / 0 Comments

It is good practice to keep our fields private but so far we had to create at least two methods to access or change their values.

private string someString;

public void SetString(string newStringName)
{
    someString = newStringName;
}

public string GetString()
{
    return someString;
}

//And we access it like this
SomeClass stringName1 = new SomeClass ();
stringName1.SetString("cool name");
Console.WriteLine(stringName1.GetString());

private string someString;

public void SetString(string newStringName)

{

someString = newStringName;

}

public string GetString()

{

return someString;

}

//And we access it like this

SomeClass stringName1 = new SomeClass ();

stringName1.SetString("cool name");

Console.WriteLine(stringName1.GetString());

Why not star using properties? You consume properties as fields and write them (almost) as methods.

Simple property example:

// Field
private string _flowerName;

// Property signature:
// public access modifier
// return type
// property name
public string FlowerName
{
    // get accessor
    // used to return value
    get
    {
        return _flowerName;
    }
    // set accessor
    // used to set value
    set
    {
        _flowerName = value;
    }
}

// Usage
SomeClass flower = new SomeClass ();
flower.FlowerName = "Rose";
Console.WriteLine(flower.FlowerName);

// Field

private string _flowerName;

// Property signature:

// public access modifier

// return type

// property name

public string FlowerName

{

// get accessor

// used to return value

get

{

return _flowerName;

}

// set accessor

// used to set value

set

{

_flowerName = value;

}

// Usage

SomeClass flower = new SomeClass ();

flower.FlowerName = "Rose";

Console.WriteLine(flower.FlowerName);

But why stop there we can add more functionality to our properties, like set our string name to Upercase, return default value or check if integer is a positive number.

private string _uppercaseString;
public string UppercaseString
{
    get
    {
        return _uppercaseString != null ? _uppercaseString : "Name not available";
    }
    set
    {
        _uppercaseString = value.ToUpper();
                
    }
}


private int _positiveInteger;
public int PositiveInteger
{
    get
    {
        return _positiveInteger;
    }
    set
    {
        if (value <= 0)
        {
            Console.WriteLine("Number must be bigger than 0");
            return;
        }
        _positiveInteger = value;
    }
                 
}

// Usage
SomeClass someClass = new SomeClass();

someClass.UppercaseString = "lower case name";
Console.WriteLine(someClass.UppercaseString);

someClass.PositiveInteger = -1;
Console.WriteLine(someClass.PositiveInteger);

private string _uppercaseString;

public string UppercaseString

{

get

{

return _uppercaseString != null ? _uppercaseString : "Name not available";

}

set

{

_uppercaseString = value.ToUpper();

}

private int _positiveInteger;

public int PositiveInteger

{

get

{

return _positiveInteger;

}

set

{

if (value <= 0)

{

Console.WriteLine("Number must be bigger than 0");

return;

}

_positiveInteger = value;

}

// Usage

SomeClass someClass = new SomeClass();

someClass.UppercaseString = "lower case name";

Console.WriteLine(someClass.UppercaseString);

someClass.PositiveInteger = -1;

Console.WriteLine(someClass.PositiveInteger);

A property that has both accessors is read-write property. Properties with only get accessor are called read-only properties, properties with only get accessor are called write-only properties.

When you only need basic property without any additional logic, you could create auto-implemented property without filed (actually compiler creates one for you).

public int AutoImpelementedInt { get; set; }

1	public int AutoImpelementedInt { get; set; }

Simple isn’t it 🙂

Encapsulation example

03/02/2016 / Darko / 0 Comments

In our encapsulation example we will create 3 classes:

Color

Car

And Manufacturer

In color Class there will be 2 private read-only fields containing colors and two public methods to access them. Fields will be private read-only because we do not want someone to access or change their values, and methods will be public because we want to access values from our fields.

Car class will also contain 2 private fields but with car model names and two public methods which can access our fields, but we will also create two public static integers whose values we will access and alter in Manufacturer class.

Manufacturer class will access methods from Color and Car classes and alter one of static integers from Car class.

Encapsulation example:

using System;

namespace Encapsulation
{
    public class Color
    {
        private readonly string colorBlack = "Black";
        private readonly string colorWhite = "White";

        public void GetColorBlack()
        {
            Console.WriteLine("Car Color is {0}", colorBlack);
        }

        public void GetColorWhite()
        {
            Console.WriteLine("Car Color is {0}", colorWhite);
        }
    }

    public class CarModel
    {
        private readonly string firstCarModelName = "Tipo";
        private readonly string secoundCarModelName = "Bravo";

        public static int RemainingPicesOfFirstModel = 23;
        public static int RemainingPicesOfSecoundModel = 6;

        public void GetFirstCarModelName()
        {
            Console.WriteLine("Car Color is {0}", firstCarModelName);
        }

        public void GetSecoundCarModelName()
        {
            Console.WriteLine("Car Color is {0}", secoundCarModelName);
        }
    }

    class Manufacturer
    {
        static void Main(string[] args)
        {
            Color firstCarColor = new Color();
            firstCarColor.GetColorBlack();
            CarModel firstCarModel = new CarModel();
            firstCarModel.GetFirstCarModelName();
            Console.WriteLine("");

            Color secoundCarColor = new Color();
            secoundCarColor.GetColorWhite();
            CarModel secoundCarModel = new CarModel();
            secoundCarModel.GetFirstCarModelName();
            Console.WriteLine("");

            Console.WriteLine("Do you wish to buy Car 1 or 2?\nThere are currently:\n{0} pieces of model Tipo and {1}\npieces of model Bravo available\nPlease enter 1 for Tipo and 2 for Bravo!", CarModel.RemainingPicesOfFirstModel, CarModel.RemainingPicesOfSecoundModel);
            Console.WriteLine("");
            string choice = Console.ReadLine();

            if (choice == "1")
            {
                var reminingPiecesOfCar1 = CarModel.RemainingPicesOfFirstModel - 1;
                Console.WriteLine("Congratulations, You have bought Tipo. There are {0} remaining units left", reminingPiecesOfCar1);
            }

            if (choice == "2")
            {
                var reminingPiecesOfCar2 = CarModel.RemainingPicesOfSecoundModel - 1;
                Console.WriteLine("Congratulations, You have bought Bravo. There are {0} remaining units left", reminingPiecesOfCar2);
            }

            else
            {
                Console.WriteLine("Thanks for stopping by!");
            }

            Console.ReadKey();
        }
    }
}

using System;

namespace Encapsulation

{

public class Color

{

private readonly string colorBlack = "Black";

private readonly string colorWhite = "White";

public void GetColorBlack()

{

Console.WriteLine("Car Color is {0}", colorBlack);

}

public void GetColorWhite()

{

Console.WriteLine("Car Color is {0}", colorWhite);

}

public class CarModel

{

private readonly string firstCarModelName = "Tipo";

private readonly string secoundCarModelName = "Bravo";

public static int RemainingPicesOfFirstModel = 23;

public static int RemainingPicesOfSecoundModel = 6;

public void GetFirstCarModelName()

{

Console.WriteLine("Car Color is {0}", firstCarModelName);

}

public void GetSecoundCarModelName()

{

Console.WriteLine("Car Color is {0}", secoundCarModelName);

}

class Manufacturer

{

static void Main(string[] args)

{

Color firstCarColor = new Color();

firstCarColor.GetColorBlack();

CarModel firstCarModel = new CarModel();

firstCarModel.GetFirstCarModelName();

Console.WriteLine("");

Color secoundCarColor = new Color();

secoundCarColor.GetColorWhite();

CarModel secoundCarModel = new CarModel();

secoundCarModel.GetFirstCarModelName();

Console.WriteLine("");

Console.WriteLine("Do you wish to buy Car 1 or 2?\nThere are currently:\n{0} pieces of model Tipo and {1}\npieces of model Bravo available\nPlease enter 1 for Tipo and 2 for Bravo!", CarModel.RemainingPicesOfFirstModel, CarModel.RemainingPicesOfSecoundModel);

Console.WriteLine("");

string choice = Console.ReadLine();

if (choice == "1")

{

var reminingPiecesOfCar1 = CarModel.RemainingPicesOfFirstModel - 1;

Console.WriteLine("Congratulations, You have bought Tipo. There are {0} remaining units left", reminingPiecesOfCar1);

}

if (choice == "2")

{

var reminingPiecesOfCar2 = CarModel.RemainingPicesOfSecoundModel - 1;

Console.WriteLine("Congratulations, You have bought Bravo. There are {0} remaining units left", reminingPiecesOfCar2);

}

else

{

Console.WriteLine("Thanks for stopping by!");

}

Console.ReadKey();

}

Encapsulation

02/02/2016 / Darko / 0 Comments

Encapsulation is one of main four object-oriented programming concepts. Encapsulation is part of OOP where we decide on which depth level another user (programmer) can can dig in our code. Encapsulation is implemented by using access modifiers.

List of access modifiers:

Public
Private
Protected
Internal
Protected internal

Public access modifier allows a class to expose its variables and methods to other classes/methods/objects/etc.. inside and and outside of it’s original class even outside of original assembly.

Private access modifier is default access modifier, meaning if we do not specify access modifier explicitly private is set as default one. Only methods of the same class can access its private members, meaning an instance of a class cannot access its private members L.

Protected and Protected internal access modifier are mostly used in implementing inheritance (one of the pillars of OOP). They allow child class to access variables and methods of base class. These access modifier will be explained later in Inheritance chapter.

Internal access modifier, same as public but is limited only to its root assembly. Internal is default access modifier of classes.

Theme by Anders Noren — Up ↑

Language

Recent Posts

Archives

Categories

MonthFebruary 2016

Code Snippets

Constructor

Is it possible to forbid class to initialize constructor?

What about other access modifiers? Can I use them all?

How can i initialize base class constructors ?

Explicit Interface member implementations

Implicit Interface member implementations

Interfaces

Inheritance

Properties

Encapsulation example

Encapsulation example:

Encapsulation