The Engineering Projects

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 !!! :)

Introduction to Structures in C#

Hello friends, I hope you all are doing great. In today's tutorial, we will have a detailed Introduction to Structures in C#. It's our 17th tutorial in C# series. Structures are quite similar to classes but have few differences as well, which we will discuss today. We have discussed C# Classes in 13th lecture, so you must read it once as we will use that knowledge in today's lecture as well. So, let's get started with Introduction to Structures in C#:

Introduction to Structures in C#

• Structure in C# is a value type data type, created by using keyword struct, and can have fields, methods, properties, operators etc. just as in C# Classes.
• Main difference between C# Class & Structure is that C# Class is a Reference Type Date type while C# Struct is a Value Type Data type.

• Let's have a look at the syntax of C# Structure:

• You can see in above figure, that we have created a struct in C# named StudentsData and it has two private fields in it i.e. ID and Name.
• This structure declaration is quite similar to that of C# class and the only difference is that we have used struct keyword here, instead of class keyword.
• So, now let's add a C# Method in this structure and then invoke it from Main Function, shown in below figure:

• So, you can see in above figure that we have invoked structure in the same way as we invoked C# Class.
• We have first created a reference variable for C# structure and then invoked the Structure Method. ( as we did for C# Class )
• We can't inherit a structure from a Parent Class or any other struct but we can inherit a class from a structure.
• Both Structs & Classes can inherit from an Interface. ( which we will study in next lecture)
• C# Data Types i.e. int, float, double are examples of Struct in C#.
• Structs are stored on Stack while we use Heap for storing C# Classes.
• Let's have a look at Struct Constructor, which is slightly different than Class Constructor:

Struct Constructor in C#

• Structures in C# can't have destructors, if you add a destructor in struct, then compiler will generate an error.
• Although you can create a Constructor in C# Struct but make sure it has some parameters in its definition.
• A parameter-less constructor is not allowed in Structures but you can overload Struct Constructors.

So, that was all about Structures in C# and you must have noticed that they are just Value Type version of C# Classes, which are actually Reference Type. In the next lecture, we will have a look at Interface in C#. Till then take care & have fun !!! :)

Introduction to Polymorphism in C#

Hello friends, I hope you all are having fun. In today's tutorial, we will have a look at Introduction to Polymorphism in C#. It's our 16th tutorial in C# series and polymorphism is considered as a main pillar of object oriented programming. In our previous tutorial, we have seen a detailed Introduction to Inheritance in C# and along with it, we have also discussed How to hide a Method in Parent Class, if the same method exists in Child class. This Method Hiding is actually the basis of Polymorphism, so let's discuss it out in detail:

Introduction to Polymorphism in C#

• Polymorphism in C# enables the user to invoke a Child Class Method & override the Parent Class Method, using a Parent Class Reference variable.

• In our previous lecture on Inheritance, we have also discussed method hiding and our last code is shown in below figure:

• In the above code, you can see that we have used method hiding by using new keyword with ChildClass Method.
• So, now instead of hiding the method let's override it and have a look at the results:

• In the above figure, you can see that I have used virtual keyword with Parent Class Method.
• Moreover, instead of new keyword, I have used override keyword with Child Class Method.
• I have used the same reference variables as I did for Method Hiding code, but here in the third case, the child class method is called.
• So, in Polymorphism, if the Child Class is involved in reference variable, then it will always override the Parent Class Method and will use the Child Class Method.
• So, we can say that if we want to completely override any function in Parent Class, then we need to add virtual keyword in its definition.
• This virtual Parent Class Method will always get override by any Base Class Method, which has the same name and has override keyword in its definition.
• But if we want to invoke the virtual Parent Class Method, then we have to use Parent Class reference variable.
• So, this third variable PC2 is the main difference between Method Hiding & Method Overriding (Polymorphism).

So, that was all about Polymorphism in C# and if you have got the Method Hiding then it won't be much of an issue for you. In the next lecture, we will have a look at Introduction to Structures in C#. Till then take care & have fun !!! :)

Introduction to Inheritance in C#

Hello friends, I hope you all are having fun. In today's tutorial, we will have a detailed Introduction to Inheritance in C#. It's our 15th tutorial in C# series and again an important concept in Object Oriented Programming, as it helps in code optimization. In our previous tutorial, we have discuss namespaces in C# and that was the last storage item in C#. Today, we are dealing with entirely different entity, which is inheritance. So, let's discuss it in detail:

Introduction to Inheritance in C#

• Inheritance in C# is used to create a relation between two classes. In simple words, derived / child class is inherited from base / parent class and will automatically have all its members as its own. Inheritance is denoted by ( : ).

• Mostly in projects, there are few functions which we have to use a lot throughout the project, so we can place such functions in any parent class and then which class needs those functions, we can simply inherit it from that parent class.
• Here's the syntax for inheritance, where ChildClass is Inherited from ParentClass, so ChildClass can use all functions and fields of ParentClass:

• When we create a new instance of any child class, then parent class constructor executes first and then child class constructor executes.
• So, in below figure, I have created two classes, ChildClass is inherited from ParentClass and I have also created their Constructors.
• Mow in the Main function, I have created a new instance of ChildClass and you can see in the Console that first Parent Constructor Called & then Child Constructor Called.

• Suppose, you are designing a software for college class, where students have few same subjects but some different subjects.
• Let's say, Engineering students study Physics & Chemistry while Medical students study Biology but they all have to study Mathematics & English.
• So, I have created one Parent Class with name MainSubjects, which has the compulsory subjects in it.
• Then I have created two Derived Class named MedicalSubjects & EnggSubjects and I have derived both of them from Main Subjects, so they can use both Maths & English fields.

• You can see inheritance in above figure, in the definition of class we have MedicalSubjects : MainSubjects, so MedicalSubjects is inherited from MainSubjects.
• In the Main code, I have created new instance of MedicalSubjects & then updated score for English, which is actually in MainSubjects, and it updated correctly.
• So, I can use all members of parent class in derived class.
• The benefit of Inheritance is that, it allows user to reuse old code without writing it again, so it saves time and reduce errors.
• C# allows single class inheritance i.e. we can't derive class A from two different classes at the same time.
• C# allows multiple Interface inheritance, which we will study later in detail.

Now I hope you have understood How to use Inheritance in C#, so now we are ready to discuss a similar concept called Method Hiding, it's related to Inheritance so let's have a look at it.

Method Hiding in C#

• Method Hiding in C# is a simple technique, where we declare two methods with the same name, one in Child Class & other one in Parent Class and the Child method will hide the parent Method, if called from Child Class Reference Variable.
• We need to use new Keyword with the child class Method, which will hide the old Parent class method.
• In our previous part, we have seen How to use Inheritance and have created Parent & Child class.
• Now, let's create two Methods with the same name, one in ParentClass & one in ChildClass, as shown in below figure:

• You can see in above figure, that I have created a Method PrintMsg() in both ParentClass & ChildClass.
• In the Main Function, I have created 3 reference variables, which are:
  • PC is a ParentClass variable, pointing to ParentClass Object.
  • CC is a ChildClass variable, pointing to ChildClass Object.
  • PC2 is a ParentClass variable, pointing to ChildClass Object.
• You must be wondering about the third variable, yeah we can do that as we can use all members of ParentClass in ChildClass but we can't do the opposite.
• Moreover, when we called the PrintMsg() Function from 2nd variable, which is a ChildClass variable, then it has executed the Function in ChildClass, which has new Keyword in its definition.
• So, the second variable has completely ignored (hide) the method in ParentClass and simply used the new method in ChildClass and it's called Method Hiding.

So, that was all about Inheritance in C#, which is quite simple concept but really effective in complex projects. It is considered as a pillar of Object Oriented Programming. In the next lecture, we will have a look at Polymorphism in C#. Till then, take care & have fun !!! :)

Introduction to Namespaces in C#

Hello friends, I hope you all are doing great. In today's tutorial, we are gonna have a look at detailed Introduction to Namespaces in C#. Namespaces are considered as libraries in C#. If you have worked on any other programming language then you must be aware of the term library which contains all classes & methods etc. In C#, this functionality is performed by namespaces. In 12th tutorial, we have seen Introduction to Methods and in 13th part, we have seen Classes in C#. Methods are simple storage units and stores code only, Classes are slightly bigger storage units and can store methods. Now Namespaces are giant storage units, which can save anything in them i.e. classes, methods, namespaces etc. So, let's have a look at them in detail:

Introduction to Namespaces in C#

• Namespaces are giant code storage units, can be referred as libraries in C#, and are used for optimization & orientation of the code.
• Namespaces are included in the project with the help of using directive at the top.

• If you look at our previous codes, then you will find using Systems; at the top of your code, basically this Systems is a namespace and with the help of using directive, we have included it in our project.
• Console, which we use for printing our data, is a member of this System Namespace.
• Our whole project is also placed between { } brackets of namespace TEPProject.

Why we need namespaces ?

• Using Namespace, we can organize the code pretty well, it doesn't have much impact in simple projects but in complex projects, you can't ignore namespaces.
• Throughout our course, we have discussed classroom data and in C# Classes lecture, I have asked you to get data of all classes of a school and now in namespace case, think of data coming from all schools of British School System.
• So, in bigger projects, there's always a need to make different teams, which will be working on separate code departments.
• In such cases, each team can create project with its own namespace and at the end you can use all those namespaces in your Main code and can get access to its functions etc. without disturbing each other's code.

Creating Namespaces in C#

• So, now let's create two namespaces in our project for two different schools, named as SchoolA & SchoolB, as shown in below figure:

• In above figure, you can see our first namespace structure is: Namespace SchoolA > Class TeamA > Method printSchoolName.
• Our second namespace structure is: Namespace SchoolB > Class TeamB > Method printSchoolName.
• Now in my Main function, which is in TEPProject Namespace, I am calling both of these printSchoolName Method.
• In order to invoke the method in first namespace, I have used dot operator and the sequence is SchoolA.TeamA.printSchoolName();
• For the second namespace, I have placed using SchoolB; at the top of the code and now we can call TeamB class directly and that's why I have used TeamB.printSchoolName(); to invoke method in second namespace.
• So, we can use namespaces using these two ways and I prefer the second one as it makes the code smooth, we don't need to write SchoolB every time.

Create Project for Namespaces in C#

• Now you got the idea of what are namespaces and how to use them in C#.
• So now it's time to create separate projects for these two namespaces and you will see our code will become clear & simple.
• Right click on your Project's Name in Solution Explorer and then click on Add and then click on New Item, as shown in below figure:

• When you click on New Item, a new window will open and here you need to select C# class, as shown in below figure:

• I have given it a name SchoolA.cs and then click Add Button.
• Similarly, I have created a new project for second namespace SchoolB.cs and now my Solution Explorer is shown in below figure:

• Both of my projects' codes and Main file code are shown in below figure:

• Now you can see in the above figure that our codes are now quite simple & clear and we have created separate files for our new namespaces.
• C# Classes created in separated files and namespaces are now accessible in our Main Function.

So, that was all about Namespaces in C#, I hope you have understood the main idea. In our next tutorial, we will have a look at Inheritance in C#. Till then take care and have fun !!! :)

Introduction to Classes in C#

Hello friends, I hope you all are doing great. In today's tutorial, we are gonna have a look at detailed Introduction to Classes in C#. It's my 13th tutorial in C# series and now we are ready to understand this slightly complex subject in C#. In our previous tutorial, we have seen Introduction to Methods in C# which are used for organizing the code and we can add some code in separate methods to make the Main method simple. Classes are slightly bigger storage capacities than methods. Methods can store code, classes can store methods. So, let's discuss classes in detail:

Introduction to Classes in C#

• Classes in C# are referred as storage units for different methods, fields, objects etc. and are used for organizing the code.
• In our previous lessons in C#, we have always taken an example of a classroom but what if we have to create a software for an entire school system.

• In that case, we can create separate teams, dealing with each classroom, so you can think of that classroom as a class in C#.
• Our Main method is in class Program, Let's create a new class for OLevel classroom students:

• so, in the above figure, you can see that I have created a new class named OLevel and this class has 3 members, named as:
  • First one is field/variable named: FirstName.
  • Second one is field/variable named: SecondName.
  • Third one is method named: printStudentName.
• So, we have 3 members in our newly created class and all these members are instance members as they don't have static keyword in their statement.
• So, in order to call this OLevel method in Main method, we have created a new instance of OLevel class, as we did in our previous lecture on methods in C#.
• After that using this new instance of OLevel class, we have invoked the printStudentName method using dot operator.
• When we run our code, we have the Full Name : TEP C#, as given in the code.
• You can also use Constructors & Destructors in C#, but they are not necessary to use, as we haven't used the constructor but our code worked fine.
• So, let's have a look at what are these terms one by one:

C# Class Constructors

• C# Class Constructor is a simple method / function, which gets executed automatically whenever the new instance of class is created.
• It must have the same name as the class itself and it won't have a return type and the access modifier is public.
• Constructors are normally used for initializing data fields or for initial settings of your class methods.
• Let's create a Constructor for our OLevel class:

• In above figure, you can see I have created a new method in our OLevel class and it has the same name OLevel.
• Constructors can also have parameters, so if we want to send some data from one class to another class, we can use these constructor parameters.
• So, now instead of hard coding the data in my new class, I am sending the data, when I am create new instance of class. i.e.

OLevel O1 = new OLevel ( " TEP " , " C# " );

• So, that way I can send multiple data just by creating new instance of class.
• You must have noticed that this C# Class Constructor doesn't have a static keyword in it so its an Instance Constructor.
• So, we can also add a static Constructor in C# class, which don't have any access modifier or return type and just have static keyword in its definition and is executed before instance Constructor.
• Moreover, Destructor in C# is used to clean up any resources used by the class and these destructors are called automatically by the garbage collector so we don't need to worry about them.
• Destructors can't take any parameters and they doesn't have access modifier or return type, they just have a tilled sign ( ~ ) in front of them.
• I have created static Constructor, Instance Constructor & Destructor in below code:

• You can see in above figure, that static Constructor is called first and then instance Constructor is called and finally we printed the Full Name.
• Here's the complete code used in this lecture:

using System; namespace TEPProject { class OLevel { string FirstName; string LastName; static OLevel() { // Static Constructor Console.WriteLine("\nStatic Constructor Called\n"); } public OLevel(string Name1, string Name2) { Console.WriteLine("Instance Constructor Called\n"); this.FirstName = Name1; this.LastName = Name2; } public void printStudentName() { Console.WriteLine("Full Name : {0} {1}\n\n", FirstName, LastName); } ~ OLevel() { // Destructor } } class Program { static void Main(string[] args) { Console.WriteLine("\n\nwww.TheEngineeringProjects.com"); OLevel O1 = new OLevel("TEP","C#"); O1.printStudentName(); } } }

So, that was all about Classes in C#, I hope you have understand their basic concept, we will gradually move towards complex codes. In the next session, we will have a look at Introduction to Namespaces in C#. Till then take care & have fun !!! :)

Introduction to Methods in C#

Hello friends, I hope you all are doing great. In today tutorial, I am going to give you a detailed Introduction to Methods in C#. It's our 12th tutorial in C# series. So far, we have covered all the basic concepts in C# and now it's time to move forward and have a look at some complex concepts. Methods have an important role in C# programming and if you want to be an efficient programmer then you must set your method controls correctly. Some methods have secret codes in them, which you don't want to give access to your developers, then you can set it private. We will cover such things in detail later, let's first have a look at Introduction to Methods in C#:

Introduction to Methods in C#

• Methods in C#, also called Functions, are extremely useful in optimizing the code, normally used to create a logic once and use it repeatedly.
• It happens in projects where you need to do a similar job at various places of your code.

• In such conditions, it's wise to create a small function of your repeated code and instead of adding those lines again and again, simply call the function.
• Here's the syntax of Methods in C#:

Access-Modifiers Return-Type Method-Name ( Parameters )  { // Method-Body } public void HelloWorld(){ Console.Write("Hello World !!!"); }

• Access-Modifiers: Access Modifiers are used to control access capability of any method / function. You can set them public, protected or private etc. We will discuss them later in detail.
• Return-Type: It decides what the method is gonna return, it could be void or any data type i.e. int, float, string etc.
• Method-Name: It's the unique name of the Method / Function, which can't be any reserved keywords in C#. It's should be meaningful so you can remember later.
• Parameters: Parameters are optional and are normally used to transfer data between methods.
• There are two types of methods available in C#, which are:
  • Instance Method.
  • Static Method.
• Let's discuss both of them separately, in detail:

Instance Method in C#

• Those methods, which doesn't have static keyword in their definition are called Instance Methods in C#.
• In order to call instance method in another method, we have to first create a new instance of that method and the invoke the method using dot operator.
• Let's have a look at how to create and call an instance method in C#:

• You must have realized by now that all the work we have been doing so far was in Main Method. That's the default method, the C# compiler first goes into and it's a static method as it has static keyword in it, which will discuss next.
• So, now in above figure, I have created a new method and I have used public (access-modifier) and void (return-type) and the Method-Name is PrintNames. I am using studentsNames array as a parameter.
• I have used the same code which we have designed in our previous lecture on For Loop in C#, so I have placed the foreach loop in my newly created instance method named PrintNames.
• Now in order to call this new method in Main method, I have to first create a new instance of this method's class and you must have noticed that the class name is Program at the top.
• Both of our Main & PrintNames Methods are placed inside Program class.
• So, in our Main function, I have first created a new instance of my class Program using new keyword:

Program P = new Program ( );

• After that, using this class instance P, I have invoked the PrintNames method using dot operator ( . ).

P.PrintNames ( studentsNames ) ;

• When you are calling your method, make sure you enter the parameters correctly as specified in its definition otherwise compiler will generate an error.
• You can specify multiple parameters separated by commas.
• So, that's how we can create and call an instance method, so now let's have a look at How to call static method in C#.

Static Method in C#

• Those methods, which have static keyword in its definition are called static methods in C#.
• In order to call a static method, we don't need to create a new instance of Program class.
• Instead, we can directly invoke a static method from Program class using dot operator ( . ), as shown in below figure:

• In above figure, I have created a new method called PrintNames2 and I have used static keyword in its definition, so its a static method in C#.
• So, now in order to call that method, I have used the name of class and then invoked the method using dot operator, using below code:

Program.PrintNames2 ( stringNames );

• We don't need to create a new instance of class for static method, that's the difference between static and instance methods in C#.

So, that was all about Methods in C# and I hope you have understood the difference between static and instance methods and how to invoke them. In the next lecture, we will have a look at Introduction to Namespace in C#, which is another important concept in C#. Till then take care & have fun !!! :)

How to use for Loop in C#

Hello friends, I hope you all are doing great. In today's tutorial, we are gonna have a look at How to use For Loop in C#. It's our 11th tutorial in C# series. Till now, we have seen two loops in C# which are IF Loop and while Loop and today we are gonna have a look at for Loop. For Loop is most commonly used loop in any programming language and if you have worked on any other language then you must be aware of its syntax. It is used to create repeated loop with specified number. Let's have a look at it in detail:

How to use for Loop in C#

• For loop in C# takes an integer variable as a Controlling agent, initialized at value V1 and ends at value V2, and the travel from value V1 to V2 depends on the Condition specified in () brackets.

• In both IF loop & while loop, the small brackets just have single argument, but in for loop, the small brackets have 3 arguments, separated by semicolon ; , which are:
  • First argument is initial value of variable V1.
  • Second argument is final value of variable V2.
  • Third argument is the condition applies on this variable i.e. increment, decrement etc.
• The loop will keep on repeating itself and we will also have the value of iteration in the form of variable value.
• Let's have a look at its syntax:

for (Initial Value V1; Final Value V2; Condition) { // body of for loop }

• Now let's have a look at a simple for loop in action

• Now you can see in above figure that I have initialized an integer variable x and in for loop, I have first assigned the initial value x=0 in first argument.
• In second argument, separated by ; , I have specified the final value x<10.
• Finally in third argument, I have incremented the variable x++.
• So, now when the compiler will first reach for loop, it will get x=0 and will run the code inside { } brackets that's why when I printed the value of x, it was 0 at first.
• After running all the lines in { } brackets, compiler will run the condition, which is to increment the variable, so in second iteration, the value of x=1, that's why in second line we have 1 on console.
• So, this loop will keep on running and the variable will keep on incrementing and when it will reach x=9, it will run the code lines in { } brackets and at the end it will increment the variable and will make it x = 10.
• So, now at x=10, the compiler knows in second argument of For loop, the variable's last value is 9 i.e. x <10. So when the value is not x<10, the compiler will leave for loop and go to next line below for loop.
• So, that's how For loop works, we can use it for running some lines of code repeatedly and the use of this variable inside for loop is quite helpful.
• Here's an example, where I have decremented the variable in third argument:

• From the console, its quite evident that now the variable's value is decreasing from 10 to 1, I have used x - - in condition part of For Loop.
• Now let's create an array of students' names and display all elements of that array using for Loop, we have discussed How to use Arrays in C# in our 6th lecture, you should recall that as well.
• Here's the code and it's output on console:

• As you can see in above figure that first I have initialized a new String Array of size 5.
• After that added some data i.e. students names, in each element of C# array.
• Next, I have used for Loop and initialized the variable and also assigned the first value 0 in first argument.
• In the second argument, I have used a Length property of array and our array's length is 5.
• So, this for loop will run from 0 to 4 and we can see at the console output that it has printed all the elements of array i.e. students names.
• That's how, we can use for Loop in C#, now let's have a look at how to use foreach loop in C#, which is kind of an extension of for loop.

How to use Foreach Loop in C#

• We have discussed Foreach Loop in our 6th tutorial on arrays and I have told you that we will discuss it in detail later, so now is the time to discuss it out.
• Foreach loop in C# is used to iterate through a collection or arrays from start till end. Collections could be ArrayList, HashTable etc. we will discuss them later.
• Let's first have a look at its syntax:

foreach (item in collections/arrays) { // body of foreach loop }

• This item variable will go through the whole array and will repeat the lines of code inside { } brackets.
• So, let's rewrite our previous example with foreach loop along with for loop and look at both results:

• Now you can see in above figure that we got similar results for both loops although foreach loop is quite simple and easy to look at thus reduces your code.
• In foreach loop, we are directly accessing the elements of array, while in for loop, we are getting elements using index of array.

So, that was all about for Loop in C# and we have also had a look at foreach loop. I'm just using simple examples rite now so that you got the clear idea of these loops. We have covered all the loops now so in next tutorial, we will have a look at Methods in C#. Till then take care !!! :)

How to use while Loop in C#

Hello friends, I hope you all are great. Today, I am posting 10th tutorial in C# series and its about How to use while Loop in C#. It's gonna be a quick tutorial, as there's not much to discuss. In our 8th tutorial in C# series, we have had a look at How to use IF Loop in C# and we have seen that IF loop takes a Boolean expression and if it's TRUE then it allows the compiler to enter in it just once. While loop is quite similar to IF loop as it takes a Boolean expression as well but it will keep on executing again & again, so let's have a look at it in detail:

How to use while Loop in C#

• While Loop in C# takes a Boolean expression as a condition and it will keep on executing as long as the conditional expression returns true, we can say Execute while condition is TRUE.
• Here's the syntax of while loop:

while (Boolean Expression) { // Code will execute, while Boolean Expression is TRUE }

• So, let's design a simple example to understand How while Loop works:

• In schools, you must have studied math tables, so I have created a simple code using while loop which asks from the user to enter table of.
• When user enters the number, the program will print out its table till 10.
• If you look at the code, I have used while loop and this while loop will execute 10 times as the condition in while loop is TotalLength <= 10.
• I have incremented this TotalLength variable in while Loop so when it will become 10, the while loop will stop.
• So, instead of writing 10 lines to display table, we are just using while loop, we can also increase the lines to 20 or 30 quite easily, that's the benefit of while loop.
• Let's play with the code a little and print values till 20 and also use IF Loop in this while loop, which we have studied in 8th lecture.

• You can see in above code that I have increased the length to 20 and then in while Loop, I have used IF Loop.
• IF the length is 10 then I am just adding blank lines to separate first 10 from last 10.
• I hope you got the idea of How to use While Loop and what's its difference from IF Loop, the IF Loop executed just once when condition comes true.
• Here's the complete code used in today's lecture:

using System;

namespace TEPProject
{
    class Program
    {
        static void Main(string[] args)
        {
            
            Console.Write("Enter Table of : ");
            int TableOf = int.Parse(Console.ReadLine());

            int TotalLength = 1;

            while (TotalLength <= 20)
            {
                int TableValue = TotalLength * TableOf;
                Console.WriteLine("{0} x {1} = {2}", TableOf, TotalLength, TableValue);
                if(TotalLength==10)
                {
                    Console.WriteLine("\n");
                }
                TotalLength++;
            }
            Console.WriteLine("\n\n");
            
        }
    }
}

So, that was all about How to use while Loop in C#. In our coming tutorial, we will have a loop at How to use do While Loop in C#. Till then take care !!! :)