The Engineering Projects

Introduction to Delegates in C#

Hello friends, I hope you all are doing great. In today's tutorial, we will have a look at detailed Introduction to Delegates in C#. It's our 21st tutorial in C# series and now we are entering in the complex field. C# concepts, we have studied so far, were quite simple, but now we are slowly moving towards complex topics. Delegates are not that difficult as normally considered, you just need to understand its basic idea and rest is quite simple. So, let's get started with Introduction to Delegates in C#:

Introduction to Delegates in C#

• Delegates in C#, created by using delegate keyword, are used as a type safe pointer, normally pointing towards C# Methods & Events.

• The signature of the Delegate & the function ( its pointing to ) must be same.
• As Delegate is a reference type Data type, so we can create its new instance.
• If you want to use any Method as a variable, then Delegates are literally the answer. ( We will have a look at it shortly )
• Delegates belong to builtin C# class named System.Delegate.
• Let's have a look at it's syntax:

• You can see in above figure that I have first declared the delegate, outside the class and I have used delegate keyword in its definition.
• Now in the Main function, I have created a new instance of this Delegate and in its constructor, I have pointed out the Method Name, to which I want to assign this delegate.
• After that I have invoked the Method using Delegate, instead of the Method's name itself.
• You need to make sure that signature of this delegate & the function must be same, when I use the word signature then that means return type and parameters.
• My Function & delegate, both have void return type, so if I change return type of any one of them, then compiler will generate an error and that's why we call it type safe.
• Similarly, the number & type of Function Parameters must have to be same for both Delegate & its pointed Method.
• Let's have a look at MultiCast Delegate in C#:

MultiCast Delegate in C#

• We can assign / point a single delegate to multiple Methods / Functions, such delegates are called MultiCast Delegates in C#.
• In the below figure, I have assigned a single delegate to 3 methods and when I invoked the delegate then it has executed all these 3 methods.

• In the above figure, I have used two ways to chain delegates together, in the first way I have used plus sign ( + ), while in second one I have used append sign ( += ).
• You must be wondering why to use these function pointers when we can directly invoke the Method using its own name.
• So, in order to understand the importance of delegates, let's design a simple example:

Example of Delegate in C#

• Let's create simple code, where we create a new class named StudentsData and it will have 3 C# Properties and 1 C# Method.
• You can see this code in below figure and I have placed an if loop in my method which has a Boolean expression in it i.e. score < 40.

• This condition Score < 40 is hard coded in my method, which makes my code quite rigid, whereas its always good practice to add flexibility in your code so that you could reuse it.
• So, now let's create a new method and add a delegate instead of this Boolean expression and as its a Boolean expression, so my delegate also has to be of Boolean return type.

• You can see in above figure that I have created a delegate named StudentsDelegate, which is of Boolean return type.
• After that, I have created a method in Main Function named CheckStatus, which is also of Boolean Type and taking Score as a parameter.
• If you look closely, the signature of this delegate & method CheckStatus are same.
• I have used the delegate to point to this method CheckStatus and have placed our failed condition in it.
• Now this function will return either TRUE or FALSE i.e. it's kind of a Boolean expression.
• Finally, I have added a delegate as a second parameter in FailedStudents Function, and then used this parameter as a condition in IF Loop.
• So, now my class is completely flexible, if I wanna change the condition, then I don't need to change the class, I can change score condition in my Main class.
• Now, you must be thinking, we have done so much coding just to shift a condition from one class to another, we have done it for a purpose.
• So, let's have a look at the below image, where I have used Lambda Expression in C#:

• In C#, we can use lambda expressions, which we will study in coming lectures, but for now you can see in above figure that I have removed the delegate instantiation and have also removed the pointed method.
• Instead I have just placed a Lambda expression and visual studio has created the delegate & method in the background, which we don't need to worry about.
• We just need to understand this lambda expression where we have placed our condition i.e. Score < 40.
• Delegates are the basis of this lambda expression, which is quite handy, it has not only made the class flexible but have also reduced the code to just single line.

So, that was all about Delegates in C# and I hope you have understood their importance. In the coming lecture, we will have a look at Exception Handling in C#. Till then take care & have fun !!! :)

Introduction to Properties in C#

Hello friends, I hope you all are doing great. In today's tutorial, we will have a look at Properties in C#. It's our 20th tutorial in C# Series and a quite important one as we are gonna use properties a lot in our coming lectures. If you haven't studied C# Methods & C# Classes then I would suggest you to read them first before starting today's tutorial, as we are gonna use methods today. So, let's get started with Properties in C#:

Introduction to Properties in C#

• Today I am not gonna start with the definition as I did in previous tutorial, instead we will first understand the concept and then will define it.
• So, let's create a new C# Class named StudentsClass shown in figure on right side.

• this class has 3 fields in it, first one is int and other two are string and all these three fields are public.
• Moreover, it has a C# Method in it, which is also public and printing the Full Name.
• In our Main Function, I have created new instance of this Class and then invoked the Method.
• So what if, we want to add some restrictions on these fields i.e. we can't have a negative roll number & the name fields can't be null.
• We don't want garbage values as well, to pass on to our project so its always wise to use private fields instead of public and place some controls on the coming values.
• We can do this by using C# Methods, as I did in this right image. ( you may need to click the image to look at the zoomed version)
• So, here I have created two C# Methods, which are receiving values from external classes and then I have placed the check on the coming value and if it satisfies the condition then I have passed it on to my field or variable.
• Now the field is also private, instead of public.
• But you must be wondering that its a lot of work to add two functions for every field, so here comes the properties in C#.
• In the below figure, I have created a C# Property named RollNo for the private field _RollNo and then I have used accessor in C#, which are:
  • set: To save the value of Property.
  • get: To read the value of Property.

• In the above figure, you can see that I have created a property named RollNo and in that property, I have used set accessor & get accessor.
• Moreover, in the Main function, now we are treating RollNo as a Property and using dot operator to set or get the value.
• Instead of using the setRollNo function, we are simply using SC.Roll = 20; to set the Roll no. and compiler will automatically move to set accessor of this property and the value we will assign it i.e. 21 it will be used by the value keyword.
• You can see in set accessor that, I have used value keyword and this keyword will have the value coming from invoking request i.e. 21 in our case.
• Similarly, when we want to read the Roll No, we are using SC.RollNo and the compiler will automatically know that it need to move into RollNo Property and then check the get accessor.
• So, we can say that our property RollNo is a read / write property, if it just has the get accessor then it will be read only property.

Auto Implemented Properties in C#

• In the above case, we have seen tha we have to place some logic in our set & get accessor, but in most of the cases, we don't need to add any additional logic in our accessors.
• For example, I am creating fields for City, Phone Number, Email Address etc. then in such cases, we can make use of C# Auto-Implemented Properties which were introduced in C# 3.0.
• In the below figure, I have created  Properties with get & set accessors:

• You can see that now I have created 3 new C# Properties and haven't even created any field for them, that's created & implemented automatically by C#.
• So, when I create a C# Property then its auto-Implemented its private field, which we can control by using set & get accessors, if we want to.
• So, our whole field vanished & protected and our new Property code is also lies in just one line, so kind of brilliant idea, introduced in C# 3.0.

Object Initializer Syntax

• Now let's have a look at a new Object Initializer Syntax, which was also introduced in C# 3.0 and I think it's best among all.
• Let's instantiate our StudentsClass using this new Object Initializer Syntax, as shown in below figure:

• You can see in above figure that it's now quite simple to assign & get data to & from Class Properties.
• I am updating all Members of C# Class in just single line, although you can add single property per line as well, but I like it that way, simple and clear.

So, that was all about Properties in C# and I hope now you can set & get them quite easily. In our coming tutorial, we will have a look at Delegates in C#. Till then take care & have fun !!! :)

Introduction to Abstract Classes in C#

Hello friends, I hope you all are doing great. In today's tutorial, we will have a look at detailed Introduction to Abstract Classes in C#. It's our 19th tutorial in C# series. Today, we are gonna discuss another new concept in C# and I would recommend you to follow these tutorials at least 3 to 4 times, so that these concepts find the right place in your brain and stick there. C# Abstract Classes are quite similar to C# Interface in many respects, so if you have studied previous tutorial in C# Series, then do read it first. So, let's get started with Introduction to Abstract Classes in C#:

Introduction to Abstract Classes in C#

• Abstract Classes in C# are created by using Abstract Keyword, and are used to create abstract members, which have their declaration but no implementation (as in C# Interfaces) but unlike Interfaces, Abstract Classes can also have complete methods, properties etc.
• Abstract Methods in C# are also created by using Abstract Keyword, these methods are only declared in Abstract classes and are then implemented in one of its derived classes & the implementation of the Method must have override Keyword in it.

• You must be finding these definitions a bit difficult but no need to worry as we will discuss them one by one in detail.
• The Abstract Modifier / Keyword is used to indicate an incomplete implementation that's why we can't instantiate such objects. We can use it with classes, methods, properties, events and Indexers.
• Moreover, the class inherited from Abstract Class must have the complete implementation of all the members of Abstract Class, along with override keyword in their declaration. (We will discuss it shortly)
• It's not compulsory for the Abstract Class to must have some Abstract members, instead we can add only normal members as well.
• Let's have a look at the syntax of Abstract Class having 1 Abstract Method & 1 normal Method, shown in below figure:

• In the above figure, we have created a public class with abstract keyword/modifier in it named StudentsAbstract, so it's an abstract class.
• As StudentsAbstract is an Abstract Class, so we can create both Abstract (Incomplete) members and normal (complete) members in it.
• So, I have created two methods, printMsg() is an abstract Method as it has Abstract Keyword in its declaration, that's why we haven't placed the implementation of this method.
• While printMsg2() is a normal method so it's fully implemented in Abstract Class.
• These Abstract Classes are normally used as a Parent Class in Inheritance and it's kind of their main role. So, let's have a look at Inheritance in Abstract Classes:

Inheritance in C# Abstract Classes

• As I mentioned earlier, Inheritance is the main role of C# Abstract Classes and they normally play the role of Parent Class and we inherit different classes & structs from them.
• We can't use the sealed keyword with abstract class, as then we can't inherit any other class. ( We have studied sealed keyword in C# Classes Lecture )
• Abstract Class can inherit from other Abstract Classes & C# Interfaces. ( Interfaces can't inherit from Abstract Classes )
• The class inherited from Abstract Class, must have the implementation of all abstract members of its Parent Class, otherwise, we will get a compiler error.

• In the above figure, we can see that I have added a new class StudentsClass derived from our Abstract Class StudentsAbstract.
• Now, this new derived class must have the implementation of its Parent's Abstract Members, as I did for printMsg() Method in above figure.
• Moreover, we need to use override keyword in our derived class method's declaration.
• So, now we have created an Abstract Class and have also added an Abstract Method in it, after that we have derived a new class and provided implementation of our Abstract Method.
• Let's now invoke this Abstract Method, declared in Abstract Class & Implemented in Derived Class, shown in below figure:

• In the Main function, I have simply created a reference variable of Child Class and then invoked both of these methods.
• You must have noticed that Abstract Classes are quite similar to Interfaces but they have few differences as well, let's have a quick look at them:

Abstract Classes Vs. Interfaces

• Abstract Classes & Interfaces have a lot in common as both are used for creating incomplete members i.e. declaration only, yet they have some differences as well.
• We can't create implementation of any member in Interfaces but that's not the case in Abstract Classes, we have the option to create Full members in Abstract Classes.
• Members in Interfaces can't use access modifier and they are all public by default, but in Abstract Classes we can provide access modifier and can make them private etc.
• We can't declare C# Fields in Interfaces but that's possible in Abstract Classes.

So, that was all about C# Abstract Classes and I hope you can now differentiate them from Interfaces. In the next lecture, we will have a look at Introduction to Delegates in C#. Till then take care & have fun !!! :)

Introduction to Interface in C#

Hello friends, I hope you all are doing great. In today's tutorial, we will discuss another important concept named Interface in C#. It's our 18th tutorial in C# series. It's one of my favorite concepts in C# as its come quite handy in complex projects. Interfaces are quite similar to C# Classes & C# Structs in design so if you haven't studied those lectures then do read them first. So, let's get started with the Introduction to Interface in C#:

Introduction to Interface in C#

• Interface in C# is created using Interface Keyword and is used for the declaration of Methods, Properties, Events etc. but we can't add any implementation in it. ( we can't declare Fields in Interface )

• You can think of Interface as a signature, you look at the interface and you will know all Methods, Properties etc. used in your project.
• Interface members don't use access modifier in their definitions, by default they all are public.
• It's a naming convention to use capital ( I ) as the first character of interface name, so that you know, just by looking at the name, that it's an Interface.
• Let's have a look at the syntax of Interface , before exploring it any further:

• In the above figure, I have created an interface named IStudentsInterface and it contains declaration of two C# Methods.
• We can't implement these methods in Interface, as it will generate a compiler error.
• Now you must be wondering, what's the benefit of using Interfaces, when we can't add the Implementation, and here comes Inheritance:

Interface Inheritance in C#

• Interfaces are normally used as Parent Node in Inheritance, while C# Classes and C# Structs are inherited from Interfaces.
• We can inherit a class or struct from multiple Inheritances, separated by commas. (We can't inherit a class from multiple classes)
• When we inherit a C# Class or Struct from an Interface, then it must provide the implementation for all the Members of that Interface.
• If we miss implementation of any single member, then compiler will generate an error.
• We can't create a new instance of Interface as we can do for Classes & Structs, although we can create an Interface Reference variable that will point to its derived class object.
• So, let's inherit a C# Class from our interface IStudentsInterface and see How it works:

• In the above figure, I have created an Interface named IStudentsInterface and it has declaration of two Methods i.e. PrintMsg() & StudentsNames().
• After that, I have inherited a class named StudentsClass from this interface IStudentsInterface .
• This class must have the implementation of those two methods we declared in our Interface IStudentsInterface.
• So, I have just created two simple methods with Console ouput, so we remove any one of them, the compiler will generate an error.
• Let's inherit our class from multiple interfaces, shown in below figure:

• In the above figure, I have created two C# Interfaces having 1 Method each.
• Moreover, the class is inherited from both of these interfaces, separated by commas, so it must have the implementation of both of these methods.
• Similarly, if an interface is inherited from another interface and you are inheriting your class from Child Interface, then still you must have the implementation of all Members of these two Interfaces in your class.
• Let's have a look at this multiple level inheritance of Interfaces:

• You can see in above figure, that IStudentInterface2 is inherited from IStudentInterface and our class is inherited from IStudentInterface2. (Like a chain)
• So, in this case as well, our class must have the implementation of both these methods, otherwise we will get compiler error.
• This type of Interface Members' Implementation in C# Classes or Structs is called Implicit Interfaces Implementation.
• So, now let's have a look at Explicit Interfaces Implementation:

Explicit Interfaces Implementation

• In Explicit Interfaces Implementation, we have to use the Interface Name along with dot operator and then name of the Method in its implementation.
• An example of Explicit Interfaces Implementation is shown in below figure:

• As you can see in above figure that our class is inherited from two interfaces.
• Moreover, in this class I have implemented C# Methods explicitly i.e. now compiler won't need to find which method belongs to which interface.
• Instead the interface name is present in Methods' definition along with dot operator ( . ).
• You must have noticed that now we have removed the access modifier and its public by default as of Interface members.
• When Interface members are implemented explicitly, then we can't access them using  reference variable, instead we need to use cast operator:

( ( IStudentsInterface) SC ) . PrintMsg();

• So, we need to use above method in order to invoke the Explicitly Implemented Interface Method.
• There's another way as well, which I have told you at the very top of today's tutorial i.e. we can't create a new instance of Interface yet we can create its reference variable, as shown in below figure:

• You can see in above figure that in Main function, I have created Interface variables both pointing to its derived class object.
• Now, as they are interface variables so we can use them to invoke respective explicitly implemented method.

So, that was all about Interfaces in C#. I hope you have completely understood its operation and working. In next tutorial, we will have a look at Abstract Classes in C#. Till then take care & have fun !!! :)