Types of Classes

In C#, classes can be categorized into various types based on their functionality and usage. Here are some common types of classes in C#: 

1. Standard or Concrete Classes
2. Abstract Classes
3. Static Classes
4. Sealed Classes
5. Partial Classes
6. Nested Classes
7. Generic Classes
8. Anonymous Classes
9. Partial Methods
10. Extension Methods

1. Standard or Concrete Classes: These are the most common types of classes used in C#. They define objects with specific attributes and behaviors. Examples include classes for modeling entities in a system, such as Person, Car, or Employee.

2. Abstract Classes: Abstract classes cannot be instantiated directly; they serve as base classes for other classes. They may contain abstract methods that must be implemented by derived classes. Abstract classes are declared using the abstract keyword.

3. Static Classes: Static classes cannot be instantiated, and they can only contain static members (fields, methods, properties). They are commonly used to define utility classes that provide helper functions or constants. Static classes are declared using the static keyword.

4. Sealed Classes: Sealed classes cannot be inherited. They are often used to prevent further derivation or overriding of functionality. Sealed classes are declared using the sealed keyword.

5. Partial Classes: Partial classes allow a class's members to be split into multiple files. This is useful for separating auto-generated code from hand-written code, or for organizing large classes into manageable parts. Partial classes are declared using the partial keyword.

6. Nested Classes: Nested classes are classes defined within another class. They can access the private members of the enclosing class and are often used for encapsulation or to logically group related functionality. Nested classes can be static or non-static.

7. Generic Classes: Generic classes are parameterized types that can work with any data type. They allow you to create classes, structures, interfaces, and methods with placeholders for data types, making them highly reusable and flexible.

8. Anonymous Classes: Anonymous classes are created dynamically without explicitly defining a class type. They are typically used in LINQ queries or when returning multiple values from a method.

9. Partial Methods: Partial methods are methods declared in a partial class or a partial struct that may or may not have an implementation. Partial methods with no implementation are automatically removed at compile time if not implemented by any part of the class or struct.

10. Extension Methods: Extension methods allow you to add new methods to existing types without modifying the original type's source code. They are declared as static methods in static classes and must be in the same namespace as the extended type or included via a using directive.

These are some common types of classes in C#, each serving different purposes and providing various features to support object-oriented programming principles and design patterns.

EXamples:

1. Standard or Concrete Class:

csharp
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    
    public void SayHello()
    {
        Console.WriteLine($"Hello, my name is {Name} and I am {Age} years old.");
    }
}

2. Abstract Class:

csharp
public abstract class Shape
{
    public abstract double Area();
    public abstract double Perimeter();
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    
    public override double Area() => Width * Height;
    public override double Perimeter() => 2 * (Width + Height);
}

3. Static Class:

csharp
public static class MathHelper
{
    public static double Square(double number) => number * number;
    public static double Cube(double number) => number * number * number;
}

4. Sealed Class:

csharp
public sealed class FinalClass
{
    // Class implementation
}

5. Partial Class:

csharp
// File 1
public partial class PartialExample
{
    public void Method1() { /* Implementation */ }
}

// File 2
public partial class PartialExample
{
    public void Method2() { /* Implementation */ }
}

6. Nested Class:

csharp
public class OuterClass
{
    private int outerField;

    public class NestedClass
    {
        public void InnerMethod(OuterClass outer)
        {
            outer.outerField = 10;
        }
    }
}

7. Generic Class:

csharp
public class GenericList<T>
{
    private List<T> items = new List<T>();
    
    public void Add(T item) => items.Add(item);
    public void Remove(T item) => items.Remove(item);
}

8. Anonymous Class:

csharp
var person = new { Name = "John", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

9. Partial Method:

csharp
public partial class PartialMethodExample
{
    partial void PartialMethod();
    
    public void CallPartialMethod()
    {
        PartialMethod();
    }
}

public partial class PartialMethodExample
{
    partial void PartialMethod()
    {
        Console.WriteLine("Partial method implementation");
    }
}

10. Extension Method:

csharp
public static class StringExtensions
{
    public static bool IsPalindrome(this string str)
    {
        string reversed = new string(str.Reverse().ToArray());
        return str.Equals(reversed, StringComparison.OrdinalIgnoreCase);
    }
}

// Usage:
string word = "radar";
bool isPalindrome = word.IsPalindrome();