Classes And Objects In C# Complete Guide

Classes and Objects in C#

C#, being a robust and object-oriented programming language, fundamentally revolves around the principles of classes and objects. Understanding these two core constructs is essential to mastering C# and its powerful features. This guide will explore in depth what classes and objects are in C#, how they interact, and the implications of using them effectively.

What Are Classes in C#?

In C#, a class serves as a blueprint or template from which individual objects (instances) are created. A class can contain various members, such as fields, properties, methods, constructors, events, and nested types. It defines the behavior and characteristics that every object instantiated from it will possess.

public class Car
{
    // Field
    private int year;

    // Property
    public string Make { get; set; }

    // Constructor
    public Car(int year, string make)
    {
        this.year = year;
        this.Make = make;
    }

    // Method
    public void DisplayDetails()
    {
        Console.WriteLine($"Year: {year}, Make: {Make}");
    }
}

• Encapsulation: One of the key principles in object-oriented programming, encapsulation involves bundling the data (fields) with the methods that operate on the data into a single unit or class. This enhances security by restricting access to certain parts of your code.

• Inheritance: This allows you to create a new class based on an existing class. The derived class inherits the features (fields, methods) of the base class, and you can add additional members to the derived class.

  public class ElectricCar : Car
  {
      public int BatteryCapacity { get; set; }
  
      public ElectricCar(int year, string make, int batteryCapacity) : base(year, make)
      {
          this.BatteryCapacity = batteryCapacity;
      }
  
      public override void DisplayDetails()
      {
          base.DisplayDetails();
          Console.WriteLine($"Battery Capacity: {BatteryCapacity} kWh");
      }
  }
  

• Polymorphism: This principle enables different classes to be treated as instances of the same class through a common interface. It promotes flexibility and reusability.

  public abstract class Vehicle
  {
      public abstract void Drive();
  }
  
  public class Car : Vehicle
  {
      public override void Drive()
      {
          Console.WriteLine("Car is driving...");
      }
  }
  
  public class Bicycle : Vehicle
  {
      public override void Drive()
      {
          Console.WriteLine("Bike is moving...");
      }
  }
  

• Abstraction: Abstraction hides the detailed implementation of a class and exposes only the necessary parts to the user. This is achieved using abstract classes and interfaces.

What Are Objects in C#?

An object is an instance of a class. When a class is defined, no memory is allocated until an object of that class is created. Objects encapsulate data and behaviors defined by their class. In C#, an object is a specific realization of a class.

Car myCar = new Car(2020, "Toyota");
myCar.DisplayDetails(); // Outputs: Year: 2020, Make: Toyota

• Instantiation: Creating an object from a class is called instantiation. This process involves invoking a constructor to allocate memory and initialize the object's state.

• State and Behavior: Every object has a state, which is represented by the values of its fields, and a behavior, which is represented by its methods.

Key Members of a Class

Fields

Fields represent the variables in a class and hold the object's state. They can be public, private, protected, internal, or a combination of internal and protected (protected internal).

private int year;

Properties

Properties provide a way to read, write, or compute the value of a private field. They offer better control over data by enabling validation when setting a value.

public string Model { get; set; }

• Auto-implemented properties: Short form where the compiler automatically generates the backing field.

  public string Color { get; set; }
  

• Read-only and Write-only properties: Can be designed to allow either reading or writing but not both.

  public string Make { get; private set; } // Read-only after initialization
  

Methods

Methods encapsulate actions or behaviors associated with a class. They can take parameters, perform operations, and return values.

public void StartEngine()
{
    Console.WriteLine("Engine started...");
}

• Constructor: A special method used to initialize objects. It shares the same name as the class and doesn't have a return type. There can be multiple constructors in a class overloaded with different sets of parameters.

  public Car(int year, string make)
  {
      this.year = year;
      this.Make = make;
  }
  

• Destructor: A special method used to release resources held by an object. It is invoked automatically by the garbage collector (GC) when an object's life cycle ends.

  ~Car()
  {
      Console.WriteLine("Car object is destroyed.");
  }
  

• Static Methods: Methods that belong to the class rather than any particular object. They can access static data and can be called without creating an instance of the class.

  public static void PrintStaticInfo()
  {
      Console.WriteLine("This is a static method.");
  }
  

Events

Events are special kinds of multicast delegates that are used to signal the occurrence of something that happens in the course of execution.

public event EventHandler EngineStarted;
protected virtual void OnEngineStarted(EventArgs e)
{
    EngineStarted?.Invoke(this, e);
}

public void StartEngine()
{
    Console.WriteLine("Engine started...");
    OnEngineStarted(EventArgs.Empty);
}

Creating and Using Objects

To create an object from a class, use the new keyword followed by the class name and parentheses containing arguments required by the constructor.

Car myCar = new Car(2020, "Toyota", "Corolla", "Red");

Once instantiated, you can access the object's properties and methods via dot notation.

myCar.Make = "Honda";
myCar.Model = "Accord";
myCar.Color = "Blue";

myCar.DisplayDetails();

// Accessing static method
Car.PrintStaticInfo();

Object Instantiation and Memory Management

• Garbage Collection: C# uses automatic garbage collection, a feature that helps to reclaim memory used by objects that are no longer in use. GC runs periodically and identifies objects that can be safely reclaimed.

• IDisposable Interface: For resources that need explicit cleanup (like file handles, database connections), implement the IDisposable interface and call Dispose() method or use the using statement to ensure proper resource management.

  public class DatabaseConnection : IDisposable
  {
      private bool disposed = false;
  
      public void Connect()
      {
          Console.WriteLine("Connected to database.");
      }
  
      public void Dispose()
      {
          Dispose(true);
          GC.SuppressFinalize(this);
      }
  
      protected virtual void Dispose(bool disposing)
      {
          if (!disposed)
          {
              if (disposing)
              {
                  // Dispose managed resources here
              }
  
              // Free unmanaged resources here
              disposed = true;
          }
      }
  
      ~DatabaseConnection()
      {
          Dispose(false);
      }
  }
  
  using (var dbConnection = new DatabaseConnection())
  {
      dbConnection.Connect();
      // Connection is closed after block execution
  }
  

Accessibility Modifiers

Accessibility modifiers define the accessibility of types and type members. They ensure that types and members are accessed only from appropriate areas of the code to enforce encapsulation.

| Modifier | Description | |-----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------| | public | Access is not restricted. This is the least restrictive access level. | | private | Access is limited to the containing type. This is the most restrictive access level. | | protected | Access within this class and by derived classes. | | internal | Access is limited to files within its current assembly. | | protected internal | Access is limited to the current assembly or types derived from the containing class in other assemblies. |

Example:

public class MyClass
{
    public int PublicProperty { get; set; }
    private int PrivateField;
    protected int ProtectedField;
    internal int InternalProperty { get; set; }
    protected internal int ProtectedInternalProperty { get; set; }
}

Static vs. Instance Members

• Instance Members: Belong specifically to an instance of a class. You need to create an object of the class to access its instance members.

  public class Person
  {
      public string Name { get; set; } // Instance property
      public void Introduce()
      {
          Console.WriteLine($"Hello, my name is {Name}."); // Instance method
      }
  }
  

• Static Members: Belong to the class rather than any specific object. They can be accessed without creating an instance of the class using the class name directly.

  public class MathUtils
  {
      public static int Add(int a, int b)
      {
          return a + b;
      }
  }
  
  int result = MathUtils.Add(5, 3); // Outputs: 8
  

Static members are useful for utility functions, constants, and shared states across all instances.

Nested Types

A nested type is a type declared within another type. It can be a class within a class, a struct within a class, etc. Nested types help to logically group types together and can be declared as public, private, protected, internal, or protected internal.

public class Garage
{
    public class Car
    {
        public string Make { get; set; }
        public string Model { get; set; }

        public void DisplayDetails()
        {
            Console.WriteLine($"Car Make: {Make}, Model: {Model}");
        }
    }
}

Garage.Car myCar = new Garage.Car();
myCar.Make = "BMW";
myCar.Model = "X5";
myCar.DisplayDetails(); // Outputs: Car Make: BMW, Model: X5

Object Lifetime

The lifetime of an object begins when an instance is created and ends when all references pointing to the object are set to null or go out of scope. At this point, the object becomes eligible for garbage collection. The destructor (finalizer) is called before the object is reclaimed by the GC, providing an opportunity to release unmanaged resources.

public class ResourceHolder
{
    public ResourceHolder()
    {
        Console.WriteLine("Object created.");
    }

    ~ResourceHolder()
    {
        Console.WriteLine("Object finalized.");
    }
}

When you create an instance of ResourceHolder, you might see output like this:

ResourceHolder holder = new ResourceHolder(); // Output: Object created.
holder = null; // At some point, this object becomes unreachable.
// Garbage collector will eventually finalize the object and free resources.
// Output: Object finalized.

Example: Building Real-world Objects Through Classes

Let's build a simple real-world application involving cars, drivers, and races.

public class Driver
{
    public string Name { get; set; }
    
    public void Drive(Car car)
    {
        Console.WriteLine($"{Name} is driving the car...");
        car.StartEngine();
        car.Accelerate();
    }
}

public class Car
{
    private int speed;

    public string Make { get; set; }
    public string Model { get; set; }

    public void StartEngine()
    {
        Console.WriteLine("Car engine started.");
    }

    public void Accelerate()
    {
        speed += 10;
        Console.WriteLine($"Car accelerated. Current speed: {speed}");
    }

    public int GetSpeed() => speed;
}

public class Race
{
    private List<Car> cars;
    private List<Driver> drivers;

    public Race()
    {
        cars = new List<Car>();
        drivers = new List<Driver>();
    }

    public void AddCar(Car car)
    {
        cars.Add(car);
    }

    public void AddDriver(Driver driver)
    {
        drivers.Add(driver);
    }

    public void StartRace()
    {
        foreach (var driver in drivers)
        {
            if (cars.Count > 0)
            {
                var car = cars[0];
                drivers.Remove(driver);
                cars.Remove(car);

                Console.WriteLine($"Race started! {driver.Name} is competing in:");
                car.DisplayDetails();
                driver.Drive(car);

                cars.Add(car);
                drivers.Add(driver);
            }
        }
    }
}

public class Program
{
    public static void Main()
    {
        Race race = new Race();
        
        Car car1 = new Car { Make = "Ferrari", Model = "488 GTB" };
        Car car2 = new Car { Make = "Porsche", Model = "911 GT3" };
        
        race.AddCar(car1);
        race.AddCar(car2);
        
        Driver driver1 = new Driver { Name = "Lewis Hamilton" };
        Driver driver2 = new Driver { Name = "Max Verstappen" };
        
        race.AddDriver(driver1);
        race.AddDriver(driver2);

        race.StartRace();
        // Outputs:
        // Race started! Lewis Hamilton is competing in:
        // Car Make: Ferrari, Model: 488 GTB
        // Lewis Hamilton is driving the car...
        // Car engine started.
        // Car accelerated. Current speed: 10
        // ...
    }
}

In this example:

• Race class manages a list of cars and drivers.
• AddCar and AddDriver methods are used to populate these lists.
• StartRace simulates multiple races.
• Driver class encapsulates driver-specific details and behaviors like driving.
• Car class contains the details about a car, including methods to start the engine and accelerate.

Best Practices

Naming Conventions

Adopt consistent naming conventions for classes and objects. Typically, class names should be nouns or noun phrases (e.g., Customer, ProductManager), while object names should be camel case (e.g., customer, productManager).

Encapsulation

Encapsulate the data by making fields private and exposing them via properties or methods. This ensures that the internal state of an object cannot be altered inadvertently.

Avoid Global State

Minimize the use of global state. Instead, prefer passing necessary state as parameters to methods.

Use Interfaces Liberally

Define interfaces to specify contracts that classes must implement. This promotes a loosely coupled architecture and makes it easy to extend applications.

public interface IVehicle
{
    void Start();
    void Stop();
}

public class Car : IVehicle
{
    public void Start()
    {
        Console.WriteLine("Car engine started.");
    }

    public void Stop()
    {
        Console.WriteLine("Car engine stopped.");
    }
}

public class Bicycle : IVehicle
{
    public void Start()
    {
        Console.WriteLine("Bicycle pedal started.");
    }

    public void Stop()
    {
        Console.WriteLine("Bicycle pedal stopped.");
    }
}

Consider Immutable Objects

Immutable objects can improve the safety, security, and performance of your applications. Once an immutable object is created, its state cannot change.

public class ImmutableCar
{
    public int Year { get; }
    public string Make { get; }

    public ImmutableCar(int year, string make)
    {
        Year = year;
        Make = make;
    }
}

Conclusion

Classes and objects are foundational building blocks in C#. They provide a mechanism to create modular, reusable, and maintainable code through concepts like encapsulation, inheritance, and polymorphism. Properly designing and implementing classes and objects adhering to best practices can significantly enhance the quality and performance of applications developed in C#. Mastery of these concepts empowers developers to harness the full potential of C#'s object-oriented features, leading to scalable and efficient software solutions.