But for some personal fun project or some quick mockup we might need a few designs. For finding few UI designs we can use the websites like Product Hunt, Dribbble or many other similar sites.

The above website shows us the stunning designs but integrating the designs we see on these platforms can be overwhelming and for finding the color combinations and color contrasts so the text should be visible and all these things are part of the design. Along with all these things finding design, mixing and matching with our idea will be hard for many developers to design and it is time consuming.

Also, the freshers who gets started with the Frontend they struggle with creating a visually stunning UIs hard as a beginners.

My company had an old website they needed it to be completely revamped and we didn’t have any UI/UX designers and they were asking for suggestions on how to we make the colors good and which should be around our company color theme.

But we tried to show many of the designs online but most of them might needed a complete rework as we might need to redesign the all the components of the webpage.

We didn’t want to spend time on completely rewriting the components and re-designing the web pages and The only requirement by manager was it needs little revamp from the perspective of colors.

That’s when I started looking around for the option to generate something colors from the company logo and I use this website from Adobe for the extracting the color theme from the logo.

Then I started looking for changing the current UI with some color change as per the logo theme I have been using the Uizard which is a great tool for taking screenshot and converting it to UI, but after few free trails. It got locked behind a paywall.

Then, I thought of trying the ChatGPT after giving just logo and the screenshot of the old website with proper prompt I started getting UI/UX mockups and After generating multiple mockups. I selected a mockup and asked it to generate the color palette used in this generated UI/UX of my selection and it gave me the list of the color.

After this I just changed the given color code by the AI and the UI was completely changed with proper contrast and added few box shadows to make it modern.

Another time, I was working on different UI design had a card which needed some changes in the images that is they wanted to change the illustration images to the icon based images. After making the changes to the given icon the page was not looking visually appealing and was lacking some color.

That when I took the screenshot of the web app and ran through it through ChatGPT and asked it to add some background color to the icons and that when after generating multiple option I added the color given by AI. The generated color were taken from the icons itself and the AI gave a lighter version of color used in icons it made the things more visually appealing.

I shared the latest version of the design with the team and they were happy with the changes.

The classes which are declared using the abstract keyword are known as the abstract class. And methods declared using the abstract keyword are known as abstract methods.

abstract class Demo
{
  int x = 10;
  abstract public void display();
}

The abstract modifier indicates that the thing being modified has a missing or incomplete implementation.

As you can see in the above code example the class and method are declared using the abstract keyword and the method is just declared without the body({ }) of the method and the method declaration is ended with ;.

Use of abstract class and methods :

• The abstract keyword enables you to create classes and class members that are incomplete and must be implemented in a derived class.

abstract class A
    {
        public abstract void display();
    }
    class B : A
    {
        public override void display()
        {
            Console.WriteLine("Implenented in class B");
        }
    }

• The purpose of an abstract class is to provide a common definition of a base class that multiple derived classes can share.

abstract class Shape
    {
        public abstract void GetArea();
    }
    class Square : Shape
    {
        public override void GetArea()
        {
            //implementation
        }
    }
    class Triangle : Shape
    {
        public override void GetArea()
        {
            //implementation
        }
    }

The Shape abstract class is implemented by the Square and Triangle class which override the GetArea method.

Note: If a class is inheriting the abstract class but not overriding the abstract method then the class needs to be declared as an abstract class as shown below.

abstract class A
    {
        public abstract void GetArea();
    }
    abstract class B : A
    {
        //Method is not implemented
        //If this class is not declared abstract then it will throw a compile-time error
    }

Abstract class has the following features :

• An abstract class cannot be instantiated this means the object of the abstract class can't be created. We can just create a reference variable.

• Abstract class can be declared without any abstract methods.

• Abstract methods are meant for overridden in another class this means that abstract methods are implicitly virtual method.

• Abstract methods can be declared inside only abstract classes.

• Abstract class can have static members which can be accessed just using the class name with the . operator.

The git can be used to share code with others and to collaborate with other developers. To learn why use git? check this blog.

git vs github :

As you know git is a VCS that was created by the developer of the Linux Kernel in 2005 by Linus Torvalds. And GitHub is a service built on top of the git and GitHub is owned by Microsoft. Github also has added more features of its own on top of git.

Installing git :

Before we start talking about the git check if you have git installed on your computer by running below command.

git --version

If git is installed then it will show the version when you run above command.

Git is a free and open source you can install it from its official site.

DOWNLOAD GIT

Git installation instructions for each platform

Basic command to work with file directory :

These are the basics commands well to know. These commands are helpful to interact with the file directory from git bash.

• mkdir - This command is used to create a folder inside the present directory.

mkdir FolderName

• ls - This is a command used to list all the files inside the directory.

  ls
  

• cd - This command is used to change the directories.

  cd
  

  Note: The cd will move one folder backward from the current directory.

cd FolderName

Note: The cd Foldername will move forward inside the specified FolderName if the folder exists.

Basic git commands for beginners:

• git config - This command of git is used to configure the git as per the user requirement.

git config --global user.name="yourname"

git config --global user.email="your email"

By setting the user.name and user.email Whenever you commit to the repo. It will show the name and email in the history log.

Note: Here --global will set the given value to all the repo, not to the particular repo.

• git config -l this will list all config settings.

git config -l

• git init - This command of git is used to initialize an empty repository in short it is called repo. The repo in git is like a folder. Repo is the place where the code and configuration files are stored. The repo is also called a working tree this is where the current version of the code is stored.

git init

• git add - This command of git is used to add the files to the staging area from here only the git will track the changes before we commit.

git add filename.extension

In the above command, we can add file by file. example: git add Demo.java.

Adding files to the staging area file by file is not a practical way if we have more files in the repo. We can add all the files to the staging area by using the following command.

git add .

In this . is a wild card this will add all the files to the *staging area`. This is better compared to writing names of files.

• git status - This command is used to check the status. In git there are traced and untracedfiles. Traced files are the files that are committed in the git repo. And the untraced files are the files that are new or modified or removed from the working tree.

To make the files untraced to traced add the files to the staging area to check this we can use the git status command to do so.

git status

• git commit - This command is used to save the changes which are in the `staging area to the repo. After we commit the changes repo* creates the history of changes made.

git commit

The above command can be used to commit to the repo. When you execute the above command it will open a default editor which you have set up in git config. The editor will open because it needs a commit message before committing. If you didn't give the commit message then the commit will be aborted.

This is not a perfect way to write a commit message. We can use the other method.

git commit -m "message"

Unlike the above git commit, This will not open the editor to take the commit message. But, in this one in the same line only we can write the commit message. In this -m git will understand that we are writing the commit message. Example: `git commit -m "Created Demo.java".

After committing the changes to the repo the files will be in the git directory and git will create history.

References if you want to learn more about git :

1. PRO GIT - This book (available online and in print) covers all the fundamentals of how Git works and how to use it. Refer to it if you want to learn more about the git.

2. GIT TUTORIALS - This tutorial includes a very brief reference of all Git commands available. You can use it to quickly review the commands that you need to use.

3. GIT OFFICIAL DOCS - This is official documentation of git. Best source to learn about git and it's updates.

If we didn't have git then we need to copy the file, again and again, modify the code and rename the file. Like as shown below.

Cons without VCS :

• The problem with copying the file, again and again, is that we need to make a copy of the file whenever we are modifying the code. and after modifying we need to rename the file.

• Generally in Software we work in a team after modification we need to mail the code file to our team whatever changes we made and they will also do the same.

• In previous steps we created multiple copies of the file. It is very hard to tell which is the latest copy and which file was created before which one.

• When we mail the files to other teammates it is very hard to compare the files for changes they have made. This will may lead to the bugs.

• Also, If teammates are sharing their piece of code it is very hard to keep track of who, when, and why the changes were made in the code.

Note: Before git and VCS there were some tools like 'diff' and wdiff using which we can just compare the files. And there are some graphical tools like meld, KDiff3, and vimdiff which are more advanced than diff etc.

Centralized version control :

This is another VCS in this one the code is stored in the central server you need to be connected to the server to access the code and its modification and updates.

Disadvantages of centralized VC :

• In this we need to be always connected to the Server. We cant access the code from anywhere.

• If the server was down or got crashed then the team cant work on the project.

Git :

Let's understand how git can help us with a story Imagine we are cooking some dish with the help of a recipe book. we need to follow step by step procedure to cook a particular recipe. and while cooking you are also watching television. In the beginning, everything was going fine. While watching television you have messed up some of the steps. The dish was ruined because you didn't follow the guide properly.

In the real-life, we can't reverse anything but by using tools likegit while writing code if we have made some mistake we can always rollback from problematic changes to the stable version of the code.

We can use the git as a time machine to move forward or backward.

Git is useful to know the history of modification in a much-simplified way in an editor. We can also write commit messages before to tell why the change was made.

Advantages of git :

• The code was stored locally on every machine of the team that is every team member had a copy of their own code because of this no connection of server or internet was required to work on a project.

• The work will not stop because of some internet or server problems.

• Git we don't need to make a copy of the file, again and again, to make changes to the file. Because the git will take care of the changes made by who, when, and why.

• Using gitwe can collaborate with other developers like on open source software.

• We all know what is String in programming and they are enclosed between the double quotes " " in most of the programming languages. The String may include any characters, numbers, and any special character we can include them in the String.

using System;

class Demo
{
 public static void Main()
 {
    string fav = "Ironman";
    String name = "Tony Stark";
    String power = new String("Intelligence");

    // GetType() is used to find type of variable.
    Console.WriteLine(fav.GetType()); 
    Console.WriteLine(name.GetType());
    Console.WriteLine(power.GetType());
 }
}
/*
Output : 
System.String
System.String
System.String
*/

Note: The String variable declared using all three gives the same String class object only.

Escape character in String \ :

• In programming we use String in many places some times we need to show/use the double quotes inside a message we want to print on console. but we can't do this because of the special property of the double-quotes.

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello "RDJ""); //Gives error
        }
    }

• In the above code the "Hello " and " are considered two separate strings because as we know string that is enclosed between two double quotes and RDJ will not be considered as a string because it is not inside quotes.

• Whenever we want to remove the special meaning of any character we can use the escape character \. As shown in the below program.

class Program
    {
        static void Main(string[] args)
        {
            string name = "RDJ";

            Console.WriteLine("Hello \"RDJ\"");
        }
    }
/*
Output :
Hello "RDJ"
*/

Note: If we want to remove the special meaning of any special character we need to add the escape character that is a backslash (\) with the special character as shown in the above code example.

Verbatim String @ :

• The dictionary meaning of the word verbatim is in the same words as were used originally. We call also call the verbatim string a multiline string. If we want to return any lines however it is written then we need to use this verbatim string.

class Program
    {
        static void Main(string[] args)
        {
            string sentence = @"This is a verbatim string this has      spaces          tabs 
            and this also has the next line";

            Console.WriteLine(sentence);
        }
    }
/*
This is a verbatim string this has      spaces          tabs
            and this also has the next line
*/

Note: The above verbatim string will print with all the space and tabs and next line. To write verbatim string just add the @ symbol in front of the string it will be considered as a verbatim string.

String Interpolation $:

• String interpolation is nothing but string formating. This is new compared to other old formatting systems in the string.

• If we don't use the string formating we need to use the string concatenation which may not properly format the string and we need to format the string with space by typing in the program explicitly. Like in the below program.

class Program
    {
        static void Main(string[] args)
        {
            string userName = "Robert";

            Console.WriteLine("Hello"+userName);

            Console.WriteLine("Hello "+userName);
        }
    }
/*
Output :
HelloRobert
Hello Robert
*/

• As you can see we need to concatenate space to string to format the welcome message. The above example is we are concatenating only two strings we can add spaces but when we are concatenating more strings then the code will not be readable and understandable. To make the code look clean we can use the String interpolation just by adding the $ sign in front of the string to tell the compiler we are doing string interpolation As shown below.

class Program
    {
        static void Main(string[] args)
        {
            string userName = "Robert";

            Console.WriteLine($"Hello {userName}");
        }
    }
/*
Output :
Hello Robert
*/

• Compared to the string concatenation the above String interpolation formatted string looks clean to read.

Inheritance is one of the core concepts of the OOPS.The definition of Inheritance is one class deriving the property of another class is known as inheritance.

• The class from which we are going to inherit the properties then that class is known as superclass or base class or parent class.

• The class which is inheriting the property of the class is known as the subclass or derived class or child class.

class Subclass : SuperClass
    {
        //methods and fields
    }

Note: In C# we use : to inherit other classes.

Why do we need inheritance?

• Using inheritance we can reuse the code instead of rewriting the code again and again.

• Using inheritance the number of lines of code can be reduced.

Types of inheritance :

These are the types of inheritance.

1. Single Inheritance.
2. Multilevel Inheritance.
3. Multiple Inheritance.
4. Hierarchical Inheritance.
5. Hybrid Inheritance.

1. Single Inheritance :

• One class inheriting the properties of another class is called as Single inheritance.

class A
    {
        public void display()
        {
            Console.WriteLine("display() of Superclass");
        }
    }

    class B : A
    {
        public void view()
        {
            Console.WriteLine("view() of ChildClass");
        }
    }
    class Program
    {
        public static void Main()
        {
            B b = new B();
            //Using this the property of the superclass can also be called
            b.view(); //Sub class method
            b.display(); //Super class method
        }
    }
/*
Output :
view() of ChildClass
display() of Superclass
*/

2. Multilevel Inheritance :

In this type of inheritance subclass inheritance, the properties of the superclass and this superclass inherit the properties of another superclass is known as the Multilevel Inheritance.

class A
    {
        public void display()
        {
            Console.WriteLine("display() of class of A");
        }
    }

    class B : A
    {
        public void view()
        {
            Console.WriteLine("view() of class of B");
        }
    }
    class C : B
    {
        public void run()
        {
            Console.WriteLine("run() of class of C");
        }
    }
    class Program
    {
        public static void Main()
        {
            C c = new C();
            c.run();
            c.view();
            c.display();
        }
    }
*/
Output :
run() of class of C
view() of class of B
display() of class of A
*/

Note: We can access the properties of all the classes using the Object of class C because C is inheriting the class B and class B is inheriting the class A.

3. Multiple Inheritance :

In this type of inheritance one, subclass inheriting the properties of the multiple classes is known as Multiple Inheritance.

Note: The multiple inheritance is not supported in C#.

4. Hierarchical Inheritance :

In this type of inheritance from one superclass, multiple subclasses inheritances the properties this creates the hierarchical structure so, this is called as the Hierarchical Inheritance.

class Car
    {
        public void drive()
        {
            Console.WriteLine("drive() of the Car class");
        }
    }

    class Tesla : Car
    {
        public void electric()
        {
            Console.WriteLine("electric() of Tesla");
        }
    }
    class RollsRoyce : Car 
    {
        public void luxury()
        {
            Console.WriteLine("luxury() of Rolls-Royce");
        }
    }
    class Program
    {
        public static void Main()
        {
            Tesla tesla = new Tesla();

            tesla.drive();
            tesla.electric();

            RollsRoyce rolls = new RollsRoyce();

            rolls.drive();
            rolls.luxury();
        }
    }
/*
Output :
drive() of the Car class
electric() of Tesla
drive() of the Car class
luxury() of Rolls-Royce
*/

Note: In both the subclasses the basic property that is drive() is inherited along with their own methods.

5. Hybrid Inheritance :

Hybrid Inheritance is the combination of the other type of inheritance.

• The constructors are the special methods that have the same name as the class name and used to initialize the global variables.

• Every class by default have their own constructors even if the programmer doesn't write it explicitly.

• Whenever we create the object what actually happening in the background is we are calling the constructor.

Note : Changes made using the one object reference will not effect other object reference.

// Topic: Constructor
using System;
class MainClass {
  // this class has its own Constructor even if the programmer doesn't write explicitly.
}

Types of Constructor in C#:

1. Default Constructor

2. Parameterized Constructor

3. Copy Constructor

4. Static Constructor

1. Default constructor :

• This constructor is also known as Zero argument Constructors We can write this constructor as follows :

// Topic: Default Constructor
using System;
class Test {
  public Test()
  {
    Console.WriteLine("Default Constructor");
  }
}
class MainClass {
  public static void Main() {
    Test test = new Test();
  }
}
/*
Output :
Default Constructor
*/

2. Parameterized Constructor :

• Parameterized constructor takes the arguments and initialize the value to the given instance of the object. This helps us to make every object different instead of hardcoding the values inside the class.

  // Topic: Parameterized Constructor
  using System;
  class Account {
  public Account(string name)
  {
    Console.WriteLine($"This account belongs to {name}");
  }
  }
  class MainClass {
  public static void Main() {
    Account a1 = new Account("Vishal");
    Account a2 = new Account("Pawar");
  }
  }
  /*
  Output :
  This account belongs to Vishal
  This account belongs to Pawar
  */
  

  3. Copy Constructor :

• This constructor is used whenever we need a copy of the other object by copying the variable values from another object.

• Copy Constructor is a parameterized constructor that takes object reference as an argument and copies the values of the variable and creates a new Object.

  // Topic: Copy Constructor
  using System;
  class Account {
  string name, bankName;
  public Account(string name, string bankName)
    {
    this.name = name;
    this.bankName = bankName;
    }
  public Account(Account ac)
    {
    Console.WriteLine("Copying values.....");
   this.name = ac.name;
   this.bankName = ac.bankName;
   Console.WriteLine("Copied values.....");
    }
  public void display()
    {
    Console.WriteLine($"The account holder name is {name} and bankname is {bankName}");
    }
  }
  class MainClass {
  public static void Main() {
    Account a1 = new Account("Vishal","Axis bank");
    a1.display();
    Account a2 = new Account(a1);
    a2.display();
    }
  }
  /*
  Output :
  The account holder name is Vishal and bankname is Axis bank
  Copying values.....
  Copied.....
  The account holder name is Vishal and bankname is Axis bank
  */
  

4. Static Constructor :

• The static constructor is used to initialize the static variables of the class and the static constructor executes first whenever the object being created. and, We can't create a static parameterized constructor. Also, the static Constructor executes only once.

Note: We can't overload and pass arguments to the static constructor.

// Topic: static Constructor
using System;
class Account {
  static string bankName;
  //This class has default Constructor

  //static Constructor
  static Account()
  {
    Console.WriteLine("Static Constructor called");
    bankName = "Axis bank";
  }
}
class MainClass {
  public static void Main() {
    Account a1 = new Account();
    Account a2 = new Account();
  }
}
/*
Output :
Static Constructor called
*/

Note: In the above code the object created for the Account class was 2 times still the static constructor was executed one time only. By this we can tell the static constructor executes only once for n number of objects created.

Types of access modifiers in C# :

1. public
2. protected
3. Internal
4. private
5. protected internal
6. private protected

Let's understand each one of them below with the program :

1. public: The type or member can be accessed by any other code in the same assembly or another assembly that references it.

class PointTest
{
    public int x;
    public int y;
}

class MainClass4
{
    static void Main()
    {
        var p = new PointTest();
        // Direct access to public members.
        p.x = 10;
        p.y = 15;
        Console.WriteLine($"x = {p.x}, y = {p.y}");
    }
}
// Output: x = 10, y = 15

Note: If you change the public access level to private or protected, you will get the error message: 'PointTest.y' is inaccessible due to its protection level.

1. protected: The type or member can be accessed only by code in the same class, or in a class that is derived from that class.

class Point
{
    protected int x;
    protected int y;
}

class DerivedPoint: Point
{
    static void Main()
    {
        var dpoint = new DerivedPoint();

        // Direct access to protected members.
        dpoint.x = 10;
        dpoint.y = 15;
        Console.WriteLine($"x = {dpoint.x}, y = {dpoint.y}");
    }
}
// Output: x = 10, y = 15

Note: If you change the access levels of x and y to private, the compiler will issue the error messages:

'Point.y' is inaccessible due to its protection level.

'Point.x' is inaccessible due to its protection level.

1. internal: The type or member can be accessed by any code in the same assembly, but not from another assembly.

public class BaseClass
{  
   internal static int intM = 0;  
}
public class TestAccess
{  
   static void Main()
   {  
      var myBase = new BaseClass();   
      BaseClass.intM = 444;    
   }  
}

Note: Using this internal the visibility of the variable only in the same assembly.

1. private: The type or member can be accessed only by code in the same class.

class Employee2
{
    private string name = "FirstName, LastName";
    private double salary = 100.0;

    public string GetName()
    {
        return name;
    }

    public double Salary
    {
        get { return salary; }
    }
}

class PrivateTest
{
    static void Main()
    {
        var e = new Employee2();

        // The data members are inaccessible (private), so
        // they can't be accessed like this:
        //    string n = e.name;
        //    double s = e.salary;

        // 'name' is indirectly accessed via method:
        string n = e.GetName();

        // 'salary' is indirectly accessed via property
        double s = e.Salary;
    }
}

Note: Using private the visibility of the variable name and salary only in the same class. We cant access them in the same assembly also. (Accessing them using the getter and setter methods is another concept known as encapsulation).

1. protected internal:The type or member can be accessed by any code in the assembly in which it's declared, or from within a derived class in another assembly.

// Assembly1.cs
public class BaseClass
{
   protected internal int myValue = 0;
}

class TestAccess
{
    void Access()
    {
        var baseObject = new BaseClass();
        baseObject.myValue = 5;
    }
}

// Assembly2.cs
class DerivedClass : BaseClass
{
    static void Main()
    {
        var baseObject = new BaseClass();
        var derivedObject = new DerivedClass();

        // Error CS1540, because myValue can only be accessed by
        // classes derived from BaseClass.
        // baseObject.myValue = 10;

        // OK, because this class derives from BaseClass.
        derivedObject.myValue = 10;
    }
}

Note: This access modifier is a combination of both protected internal here the properties of both access specifiers are combined that is., it is accessible in the same assembly and another assembly's derived class.

1. private protected: The type or member can be accessed only within its declaring assembly, by code in the same class, or in a type that is derived from that class.

public class BaseClass
{
    private protected int myValue = 0;
}

public class DerivedClass1 : BaseClass
{
    void Access()
    {
        var baseObject = new BaseClass();

        // Error CS1540, because myValue can only be accessed by
        // classes derived from BaseClass.
        // baseObject.myValue = 5;

        // OK, accessed through the current derived class instance
        myValue = 5;
    }
}

Note: Like the protected internal this is also a combination of two access modifiers and 'private protectedcombines the properties of both access modifiers that is.,privateandprotected. Unlikeprivateusing this, we can access the properties insame assembly.

What is class?

The class and objects are the blueprint or prototype. The class can be created for the entity which has states and behaviors. The entity may be a living or non-living thing.

Declaring the class :

AccessModifiers class ClassName
{
    // fields also known as variables

    // functions also known as methods
}

• The class will always have access modifiers to control the visibility of the class. To learn more about the access modifiers please check my blog on access modifiers.

Note: If we are not writing the access modifiers explicitly then the class will by default internal as access modifier.

• The classes are declared using the class keyword.

• The class will have the name and body the body of the class is surrounded using the { }.

Example :

namespace Demo
{
    class Add
    {
        int a = 10;
        int b = 20;
        public int sum;

        public void Sum()
        {
            sum = a + b;
        }
    }
    class Program
    {
        public static void Main()
        {
            Add add = new Add();

            add.Sum();
            Console.WriteLine($"The sum of a and b : {add.sum}");
        }

    }
}
/*
Output :
The sum of a and b: 30
*/

Explanation :

• namespace is a way of organizing the code and namespace also helps in avoiding the naming collision of the class.

• The access modifiers for the above class is internal because we didn't mention it explicitly.

• The class Add has variables like a, b, and sum. The Add class also has a method named Sum which takes above both values from a and b using the operator + performs the addition operation and store the value returned value inside the sum variable.

Note: In C# the execution of the program from Main() only.

• To access the variables and methods of the different classes we need to create the object of that class.

• To create the object of the class we use the new keyword.

Note: The objects created using the new keyword are stored inside the heap area.

• Whenever we create the object of the class the constructor of that class gets called.

Note: Each and every class has will have a constructor of its own even if we didn't write the constructor explicitly. To learn more about Constructor please check my blog on constructor.

• By using the object reference we can call the methods and variable and perform the required operation.

using System;
class Base:Object {
  public static void Main() 
  {
    //using this class we can access all the properties of Base class and Object class.
  }
}

Note: Even if we didn't inherit the Object class explicitly then also the compiler will implicitly inherit the Object class to all the class.

• If some class is inheriting properties of other class then that class will not implicitly inherit the Object class because C# doesn't support the multiple inheritances.

using System;

class Super {
  //This class will inherit the Object class implicitly.
}

class Base:Super, Object {
  public static void Main() 
  {
    //This class inherited the Superclass and we can't inherit implicitly or explicitly the Object class.
  }
}

• We have some useful methods in the Object class which we can use in our program.

Methods of Object class :

Equals(Object): Determines whether the specified object is equal to the current object.

Equals(Object, Object): Determines whether the specified object instances are considered equal.

Finalize(): Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.

GetHashCode(): Serves as the default hash function.

GetType(): Gets the Type of the current instance.

MemberwiseClone(): Creates a shallow copy of the current Object.

ReferenceEquals(Object, Object): Determines whether the specified Object instances are the same instance.

ToString(): Returns a string that represents the current object.

Overriding methods of Object class :

• The Object class has multiple methods but we can only override three methods from the Object class.

• GetHashCode(), Equals(Object), and ToString() only these methods of the Object class can be overridden by the programmer.

Introduction :

• There are multiple ways to writing the loops in C# the most basics loops in any programming languages are for and while loop. In C# we have another type of advance loop that is the foreach loop. We will see the syntax and execution of the foreach loop below.

• Before we talk about the advanced foreach loop let me just give a brief explanation of the other looping condition.

Types of Loops :

foreach loop :

• foreach is advanced for loop which can be used to access the element of the collection without using indexes.

Syntax :

foreach(data_type var_name in collection_var) {
    //statements
}

Understanding the foreach loop :

using System;
// Topic: foreach
class MainClass {
  public static void Main (string[] args) 
  {
    int[] num = {1,2,3,4,5};
    Console.WriteLine("Using the for loop");
    //for loop
    for(int i=0;i<num.Length;i++)
    {
      Console.WriteLine(num[i]);
    }

    Console.WriteLine("Using the foreach loop");
    //foreach loop
    foreach(int a in num)
    {
      Console.WriteLine(a);
    }
  }
}

Output :

Using the for loop
1
2
3
4
5
Using the foreach loop
1
2
3
4
5

Explanation :

for loop :

• In the above code, you can see using the for loop we need to access the elements using the index value. Here using the for loop we need to keep the index values in check that is if the index values are in the range of the given collection/array length or else this will lead to the System.IndexOutOfRangeException. And also, we need to increment/decrement the index value as per our required outputs.

foreach loop :

• Like for loop this doesn't use any kind of index to retrieve elements from the array. This advanced foreach loop will take the array and retrieve the elements one by one until the array will not have any elements left. This happens because if the array has elements then the foreach loop returns true else it will return false and stop the execution.

How to create an array :

type[] variable-name = new type[size];
// example
int[] num = new num[5];

• This is the basic syntax of array creation.
  • type - Type is nothing but datatype or object type of the array you want to create.
  • variable-name - This is a variable name that can be used to access the elements of an array.
  • new - This is a keyword of C# which is used for object creation.
  • size - The size is used to create a specific length array element.

Note: Array is an object and every array has a fixed size and the size of the array can't be changed after creation.

Creating an array using different techniques :

The array can be created in multiple ways they are :

Way 1:

The array can be created in 3 steps array declaration, creation, and initialization.

i. Array declaration :

type variable_name[];
//example
int num[];

• The above line of code will just declare the int array with the name num.

ii. Array creation :

variable_name = new type[size];
//example
num = new int[3];

• The above line of code will create the array with a given size that is 3. This array num will have the size of 3. and all the elements of the array are default values with respect to the datatypes here in this case datatype is int so the default value is 0.

iii. Array initialization :

variable_name[index];
//example
num[0] = 11;
num[1] = 22;
num[2] = 33;

Note: The array index starts from zero

• As we have initialized the array with size 3. We can initialize the array element using an index.

• For the above example with size 3 index values will be 0, 1, '2' and the values assigned are '11`, '22', '33' respectively.

Way 2 :

As we have seen above it requires 3 steps to create an array but we can do it in a different way as shown below.

type[] variable_name = {e1,e2,..en};
//or
type[] variable_name = new type[]{e1,e2,..en};
//both of the above line does the same thing

• In the above syntax as you see we can declare and initialize the values of the array without mentioning the size. We can use this method whenever we know the values we are going to store.

Note: We can use any technique to create the array depending on the requirements.

Accessing the array elements :

• We can retrieve/access the array elements using the loops. We use the for, while, and foreach loop to access the array elements.

• We are going to learn about retrieving the array element using the for loop.

using System;
class MainClass {
  public static void Main() 
  {
    //Array declaration and initialization
    int[] num = {1,2,3}; 

    for(int i=0;i<num.Length;i++)
    {
      Console.Write(num[i]+" ");
    }
  }
}

Note: We can use the Length property of the array to find the unknown array length.

• The above for loop will create the index values using the given condition. The index values generated by the for loop for the above-given condition of the index are 0, 1, and 2.
• The above code inside the loop is the same as adding the array element to the respective index as we have seen above. Instead of adding we can retrieve the element using an index same as adding them to the respective index.

Changing the array element using the index :

We can update the array elements by retrieving them using the index and reassigning them with the new values.

num[0] = 44;

Note: If you try to store the string values inside the int array it will throw an exception that is Cannot implicitly convert type 'string' to 'int'.

Primitive Datatypes :

• Generally we use the datatype to declare and store the value inside the variable but in the C#, we have another 2 ways to do the same that is using the var and dynamic keywords we will discuss these keywords in later parts of this blog. ###

  datatype variableName = value; //this is declaration of variable using the primitive data types
  int a = 10;
  

  var type :

• The var type is introduced in the C# 3.0 version. The var are those variables that are declared without specifying the type explicitly. Instead, we use the var keyword to declare the variables. The type check occurs during the compilation. These are not designed to replace the normal variable declaration, it is designed to handle the special case situation.

  • Difference between the implicitly typed and explicitly typed

    int i = 10; // Explicitly type of the variable is mentioned.
    var i = 10; // Implicitly type check occurs by the compiler
    

    dynamic type :

• The dynamic type is introduced in the C# 4.0 version. Here also we don't need to mention the type of variable like the var. Here we can declare the variable using the dynamic keyword. The compiler will not check the type of the variable which is declared using the dynamic keyword during compile time. This is used to avoid the compile-time type checking.
  • Difference between the implicitly typed and explicitly typed

    int num = 8; // Explicitly type of variable is mentioned.
    dynamic = 8; //Implicitly type check occurs during runtime