Class is the Blue Print of the object. It does contain the behaviours and action of the object. And Object is the instance of the class that contain all the behaviour and action.

Classes are different type :

- Concrete Class: Regular class that is the basic blue print contains action method and properties.
- Abstract Class: It can not be instantiated through created object. It contain abstract and non-abstract mthod. It is used for the abstraction purpose and used via inherited in some other class.
- Sealed Class: Inheritance does not support.
- Partial Class: Partial class can be devided into different source file with different properties and they combine into one during the run-time. It is created as Prefix of the Partial Keyword.

Polymorphism referes multiple form. It referes that Multiple method can be formed into classes via different signature to perform diffrent operation

Different type of Polymorphism :

- Compile Time Polymorphism: Compile Time polymorphism also referred as Method Overloading, It is bind and Error generate during compilation of the code. Same method name in the class refer as method overloading and it is achieve via passing different number of parameter into mthod and changing the data types of the passaing parameter.
- Run Time Polymorphism: Run Time Polymorphism also referred as Method Overriding, It is bind and Error generate during run time of the code. Derived class method override the implementation of the same method name of the Base class refer the Run Time Polymorphism or Method Overriding. The override keyword used for overriding of the method.

Dependency Injection is the inversion of control. So What does that mean, The ASP.NET Core introduced this concept and implmentation for the loose coupling between the classes. It basically removes the dependency of one class method execution or service injection from the other class and So If A class use the object of B class and any change occur into B class' method or service then A class does not make modification or changes into it's own method or class. You can inject it through different ways, Construtor based Injection, Properties Based or Particular Method. Below are some different DI and their Scope-

- Singleton: One instance for the app’s lifetime.
- Scoped: One per HTTP request.
- Transient: New instance every time it's injected.

var result = students.Where(s => s.Marks > 75).Select(s => s.Name);

context.Students.Where(x => x.Age > 18).ToList();

app.UseMiddleware<LoggingMiddleware>();

• INNER JOIN: Matches rows in both tables.
• LEFT JOIN: All rows from left, matched rows from right.
• RIGHT JOIN: All rows from right, matched from left.
• FULL JOIN: All rows when there's a match in either table.

SELECT E.Name, D.DeptName
FROM Employees E
LEFT JOIN Departments D ON E.DeptId = D.Id;
                    

CREATE PROCEDURE GetEmployeeById @Id INT
AS
BEGIN
  SELECT * FROM Employees WHERE Id = @Id
END
                    

• DENSE_RANK(): Gives rank without skipping numbers for ties.
• RANGE: Used in `OVER` clause for windows.

  SELECT Name, Salary,
    DENSE_RANK() OVER (ORDER BY Salary DESC) AS Rank
  FROM Employees;
                              

• var - function scoped, hoisted.
• let - block scoped, mutable.
• const - block scoped, immutable binding.

async function getUser() {
  const response = await fetch('/api/user');
  const data = await response.json();
  return data;
}
                    

const add = (a, b) => a + b;