1. Concrete Class:

   csharp
   1public class Car
   2{
   3    public string Make { get; set; }
   4    public string Model { get; set; }
   5}

2. Abstract Class:

   csharp
   1public abstract class Animal
   2{
   3    public abstract void Speak();
   4}

3. Static Class:

   csharp
   1public static class MathUtilities
   2{
   3    public static int Add(int a, int b) => a + b;
   4}

4. Partial Class:

   csharp
   1public partial class Person
   2{
   3    public string Name { get; set; }
   4}

5. Nested Class:

   csharp
   1public class OuterClass
   2{
   3    public class InnerClass
   4    {
   5        public void Display() => Console.WriteLine("Inner Class");
   6    }
   7}

6. Generic Class:

   csharp
   1public class Box<T>
   2{
   3    private T content;
   4    public void Add(T item) => content = item;
   5}

7. Sealed Class:

   csharp
   1public sealed class FinalClass
   2{
   3    public void Show() => Console.WriteLine("This is a sealed class.");
   4}

Access Modifiers in C#

Example of Each Access Modifier

Here’s an example demonstrating each access modifier:

csharp
1public class Example
2{
3    // Public member
4    public string PublicField;
5
6    // Private member
7    private string PrivateField;
8
9    // Protected member
10    protected string ProtectedField;
11
12    // Internal member
13    internal string InternalField;
14
15    // Protected internal member
16    protected internal string ProtectedInternalField;
17
18    // Private protected member
19    private protected string PrivateProtectedField;
20
21    public Example()
22    {
23        // Accessing all fields within the constructor
24        PublicField = "I am public";
25        PrivateField = "I am private";
26        ProtectedField = "I am protected";
27        InternalField = "I am internal";
28        ProtectedInternalField = "I am protected internal";
29        PrivateProtectedField = "I am private protected";
30    }
31}
32
33// Derived class
34public class DerivedExample : Example
35{
36    public void Display()
37    {
38        // Can access PublicField, ProtectedField, and ProtectedInternalField
39        Console.WriteLine(PublicField);
40        Console.WriteLine(ProtectedField);
41        Console.WriteLine(ProtectedInternalField);
42
43        // Cannot access PrivateField or PrivateProtectedField
44        // Console.WriteLine(PrivateField); // Error
45        // Console.WriteLine(PrivateProtectedField); // Error
46    }
47}
48
49// Another class in the same assembly
50public class AnotherClass
51{
52    public void Show()
53    {
54        Example example = new Example();
55        Console.WriteLine(example.PublicField); // Accessible
56        // Console.WriteLine(example.PrivateField); // Error
57        // Console.WriteLine(example.ProtectedField); // Error
58        Console.WriteLine(example.InternalField); // Accessible
59        // Console.WriteLine(example.ProtectedInternalField); // Accessible
60        // Console.WriteLine(example.PrivateProtectedField); // Error
61    }
62}

Explanation of the Example

1. Public Field: PublicField can be accessed from anywhere.
2. Private Field: PrivateField can only be accessed within the Example class.
3. Protected Field: ProtectedField can be accessed within Example and any derived classes (like DerivedExample).
4. Internal Field: InternalField can be accessed within the same assembly but not from outside.
5. Protected Internal Field: ProtectedInternalField can be accessed from derived classes and from anywhere within the same assembly.
6. Private Protected Field: PrivateProtectedField can only be accessed within the Example class and in derived classes, but only if they are in the same assembly.

Static Members of C# Class 

csharpCopy code
1using System;
2
3public class Employee
4{
5    // Static variable to keep track of the number of employees
6    private static int employeeCount = 0;
7
8    // Instance variables
9    public string Name { get; set; }
10    public int ID { get; set; }
11
12    // Constructor
13    public Employee(string name, int id)
14    {
15        Name = name;
16        ID = id;
17        employeeCount++; // Increment the static employee count each time a new employee is created
18    }
19
20    // Static method to get the current employee count
21    public static int GetEmployeeCount()
22    {
23        return employeeCount;
24    }
25}
26
27// Usage
28public class Program
29{
30    public static void Main()
31    {
32        Employee emp1 = new Employee("Alice", 1);
33        Employee emp2 = new Employee("Bob", 2);
34        Employee emp3 = new Employee("Charlie", 3);
35
36        // Accessing the static method without creating an instance
37        Console.WriteLine("Total Employees: " + Employee.GetEmployeeCount()); // Output: Total Employees: 3
38    }
39}

csharp
1public class MathConstants
2{
3    // Static variable initialized at the point of declaration
4    public static readonly double Pi = 3.14159;
5}
6
7// Usage
8public class Program
9{
10    public static void Main()
11    {
12        // Accessing the static variable directly
13        Console.WriteLine("Value of Pi: " + MathConstants.Pi); // Output: Value of Pi: 3.14159
14    }
15}