When can we use the abstract class in C#.NET?

In C#.NET, an abstract class is a class that cannot be instantiated and may contain abstract methods, which are methods without a body. Abstract classes are used when you want to provide a common base class for other classes but want to leave certain methods as abstract, letting the derived classes provide their own implementation. Here are some scenarios where you might use abstract classes:

1. **Common Base Class:**
- You can use an abstract class to define a common base class for a group of related classes. This allows you to provide a shared set of fields, properties, and methods to the derived classes.

```csharp
public abstract class Shape
{
public abstract double CalculateArea();
public abstract double CalculatePerimeter();
}

public class Circle : Shape
{
public double Radius { get; set; }

public override double CalculateArea()
{
return Math.PI * Math.Pow(Radius, 2);
}

public override double CalculatePerimeter()
{
return 2 * Math.PI * Radius;
}
}

public class Square : Shape
{
public double SideLength { get; set; }

public override double CalculateArea()
{
return Math.Pow(SideLength, 2);
}

public override double CalculatePerimeter()
{
return 4 * SideLength;
}
}
```

2. **Enforcing a Contract:**
- Abstract classes can define abstract methods that must be implemented by derived classes. This enforces a contract, ensuring that all derived classes provide their own implementation for specific methods.

```csharp
public abstract class DatabaseConnection
{
public string ConnectionString { get; set; }

public abstract void Open();
public abstract void Close();
public abstract void ExecuteQuery(string query);
}
```

3. **Partial Implementation:**
- Abstract classes can provide a partial implementation of methods, leaving some parts to be implemented by derived classes. This is useful when there's common functionality shared among derived classes.

```csharp
public abstract class Animal
{
public void Eat()
{
Console.WriteLine("Animal is eating.");
}

public abstract void MakeSound();
}

public class Dog : Animal
{
public override void MakeSound()
{
Console.WriteLine("Dog barks.");
}
}

public class Cat : Animal
{
public override void MakeSound()
{
Console.WriteLine("Cat meows.");
}
}
```

4. **Preventing Direct Instantiation:**
- Since abstract classes cannot be instantiated directly, they prevent the creation of objects of the abstract class itself. Instances are created through derived classes.

```csharp
// This is not allowed:
// Animal animal = new Animal();

// This is allowed:
Animal dog = new Dog();
```

In summary, abstract classes are used in C#.NET when you want to provide a common base with some default implementation and leave certain methods to be implemented by derived classes. They help in creating a consistent and extensible class hierarchy.