In C# Object-Oriented Programming (OOP), classes and objects are two foundational concepts. These are used to model real-world entities and their interactions in the form of software objects.

1. Classes

A class in C# is a blueprint or template that defines the properties (data) and methods (functions) that the objects created from this class will have. It acts as a blueprint for creating multiple objects of the same type. A class encapsulates data for the object and methods to manipulate that data.

Key Aspects of a Class:

• Fields: Variables that hold the data for the class.
• Properties: Mechanisms to get and set the values of fields (with optional validation).
• Methods: Functions that define the behaviors of the class, allowing manipulation of the data.
• Constructors: Special methods used to initialize objects when they are created.

Syntax for Defining a Class in C#:

class ClassName
{
    // Fields
    private string name;

    // Properties
    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    // Constructor
    public ClassName(string initialName)
    {
        name = initialName;
    }

    // Method
    public void Display()
    {
        Console.WriteLine("The name is: " + name);
    }
}

2. Objects

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 represent the actual entities that exist in memory, and you interact with them through their properties and methods.

Creating Objects from a Class:

To create an object, you use the new keyword, followed by the class constructor. Once created, you can interact with the object by calling its methods and accessing its properties.

Example of Creating and Using an Object:

class Program
{
    static void Main(string[] args)
    {
        // Creating an object of the class
        ClassName obj = new ClassName("John");

        // Accessing the properties and methods
        obj.Display(); // Output: The name is: John
        obj.Name = "Jane";
        obj.Display(); // Output: The name is: Jane
    }
}

3. Key Characteristics of Classes and Objects

• Encapsulation: Data (fields) and methods (functions) are bundled inside the class. Access to the data is often restricted using access modifiers (private, public, protected).
• State and Behavior: The state of an object is defined by its data (fields), while the behavior is defined by its methods.
• Instantiation: Creating an object from a class is called instantiation. Each object has its own copy of the fields defined in the class.
• Memory Allocation: Memory is allocated when an object is created using the new keyword. Each object can hold its own data independently of other objects of the same class.

4. Example: Class and Object in C#

// Define a class
class Car
{
    // Fields (state)
    private string brand;
    private int year;

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

    // Method (behavior)
    public void Drive()
    {
        Console.WriteLine($"{brand} car from {year} is driving.");
    }

    // Property for the brand field
    public string Brand
    {
        get { return brand; }
        set { brand = value; }
    }
}

class Program
{
    static void Main()
    {
        // Create an object of the Car class
        Car myCar = new Car("Toyota", 2020);

        // Access methods and properties
        myCar.Drive(); // Output: Toyota car from 2020 is driving.

        // Set a new brand
        myCar.Brand = "Honda";
        myCar.Drive(); // Output: Honda car from 2020 is driving.
    }
}

5. Access Modifiers

Access modifiers determine the visibility and accessibility of classes, fields, methods, and properties:

• public: Accessible from outside the class.
• private: Accessible only within the class.
• protected: Accessible within the class and its derived classes.
• internal: Accessible within the same assembly.

6. Class Members in Detail

• Fields: Variables declared directly in a class.
• Methods: Functions that define behavior, manipulating fields or performing actions.
• Constructors: Special methods used to initialize new objects. Constructors can be overloaded to allow different ways to initialize objects.
• Properties: Provide controlled access to private fields, often allowing for validation or logic when getting or setting field values.

Conclusion

• Classes define a new data type that bundles fields (state) and methods (behavior) into a single unit.
• Objects are instances of a class, with each object having its own values for the fields and the ability to invoke the methods defined in the class. By using classes and objects, C# OOP allows for modular, maintainable, and reusable code structures.