Revisiting C# Classes and Object-Oriented Programming

Greetings! Today, we're revisiting C# classes, the core building block of Object-Oriented Programming (OOP) in C#. Classes play a pivotal role in structuring code to model real-world entities and behaviors. Through hands-on examples, we'll revisit the fundamental concepts of C# classes, including their structure, properties, and methods. This session aims to enhance your understanding of how classes facilitate better code organization and reusability.

C# Classes Refresher

Let's begin with a refresher on C# classes. Essential to OOP, C# classes bundle relevant data and functions into compact units called objects. Consider a video game character, which is a typical example of a class instance, with specific properties (such as Health and Strength) and methods (such as Attack). C# public class GameCharacter {// Fields private string name; private int health; private int strength; // Constructor method public GameCharacter(string name, int health, int strength) {this.name = name; // Property this.health = health; // Property this.strength = strength; // Property} // Method public void Attack(GameCharacter otherCharacter) {otherCharacter.health -= this.strength;} // Properties public string Name {get { return name; }} public int Health {get { return health; }} public int Strength {get { return strength; }}} In the code above, the GameCharacter class has properties Name, Health, and Strength . Each of these properties includes a getter, which allows the retrieval of the corresponding private field values— name, health, and strength . Getters provide a way to access these private fields from outside the class, maintaining encapsulation while allowing read-only access to these properties. C# classes facilitate the grouping of associated code elements, simplifying their management. Now, let's go through it step-by-step to better understand how the above example works.

Structure of a C# Class

A C# class serves as a blueprint consisting of properties and methods. While properties represent data relevant to a class instance, methods are actions or functions that manipulate this data. Each class includes a constructor function, which is used to define class properties. A constructor is a special method that is called when an object of the class is created. An essential keyword within these methods is this, which represents the class instance. In the constructor, this.name refers to the class property name, while name refers to the parameter passed to the constructor. In object-oriented programming, this is needed to access the class's properties and methods. When a new class instance is created, C# automatically passes it to the this parameter to access individual instance properties and methods using the this keyword. This mechanism allows each object to keep track of its own state and behaviors. When creating an instance of the class, parameters are passed to the constructor, and a new instance of the class is created, as demonstrated in GameCharacter character = new GameCharacter("Hero", 100, 20); . C# public class GameCharacter {// Fields private string name; private int health; private int strength; // Constructor: Defines class properties public GameCharacter(string name, int health, int strength) {this.name = name; // Property this.health = health; // Property this.strength = strength; // Property} // Properties public string Name {get { return name; }} public int Health {get { return health; }} public int Strength {get { return strength; }}} public class Program {public static void Main(string[] args) {GameCharacter character = new GameCharacter("Hero", 100, 20); // Object or instance of the class}}

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Class Properties

Properties in C# classes hold data associated with each class instance. For example, in our GameCharacter class, Name, Health, and Strength are properties.

In the code block, we create a GameCharacter object and store it in the character variable with the name 'Hero', health set to 100, and strength set to 20. We can then access its name by using character.Name, which will return 'Hero'. Similarly, character.Health returns 100, and character.Strength returns 20.

public class GameCharacter
{
    // Fields
    private string name;
    private int health;
    private int strength;

    // Constructor: Defines class properties
    public GameCharacter(string name, int health, int strength)
    {
        this.name = name;       // Property
        this.health = health;   // Property
        this.strength = strength;   // Property
    }

    // Properties
    public string Name 
    {
        get { return name; }
    }

    public int Health 
    {
        get { return health; }
    }

    public int Strength 
    {
        get { return strength; }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        GameCharacter character = new GameCharacter("Hero", 100, 20);  // Object or instance of the class
        Console.WriteLine(character.Name);     // Prints: Hero
        Console.WriteLine(character.Health);   // Prints: 100
        Console.WriteLine(character.Strength); // Prints: 20
    }
}

public class GameCharacter
{
    // Fields
    private string name;
    private int health;
    private int strength;

    // Constructor: Defines class properties
    public GameCharacter(string name, int health, int strength)
    {
        this.name = name;       // Property
        this.health = health;   // Property
        this.strength = strength;   // Property
    }

    // Properties
    public string Name 
    {
        get { return name; }
    }

    public int Health 
    {
        get { return health; }
    }

    public int Strength 
    {
        get { return strength; }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        GameCharacter character = new GameCharacter("Hero", 100, 20);  // Object or instance of the class
        Console.WriteLine(character.Name);     // Prints: Hero
        Console.WriteLine(character.Health);   // Prints: 100
        Console.WriteLine(character.Strength); // Prints: 20
    }
}

Properties differentiate one class instance from another and store the state of the instance.

Class Methods

A class also contains methods — actions or functions that manipulate the data in the class. For example, the Attack method in our GameCharacter class simulates an attack by one game character on another.

public class GameCharacter
{
    // Fields
    private string name;
    private int health;
    private int strength;

    // Constructor: Defines class properties
    public GameCharacter(string name, int health, int strength)
    {
        this.name = name;       // Property
        this.health = health;   // Property
        this.strength = strength;   // Property
    }

    // Method
    public void Attack(GameCharacter otherCharacter)
    {
        otherCharacter.health -= this.strength;  // Modifies 'otherCharacter's health property
    }

    // Properties
    public string Name 
    {
        get { return name; }
    }

    public int Health 
    {
        get { return health; }
    }

    public int Strength 
    {
        get { return strength; }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        GameCharacter character1 = new GameCharacter("Hero", 100, 20);   // First instance of GameCharacter
        GameCharacter character2 = new GameCharacter("Villain", 80, 15); // Second instance

        Console.WriteLine(character2.Health);  // Prints: 80
        character1.Attack(character2);  // character1 attacks character2
        Console.WriteLine(character2.Health);  // Prints: 60
    }
}

public class GameCharacter
{
    // Fields
    private string name;
    private int health;
    private int strength;

    // Constructor: Defines class properties
    public GameCharacter(string name, int health, int strength)
    {
        this.name = name;       // Property
        this.health = health;   // Property
        this.strength = strength;   // Property
    }

    // Method
    public void Attack(GameCharacter otherCharacter)
    {
        otherCharacter.health -= this.strength;  // Modifies 'otherCharacter's health property
    }

    // Properties
    public string Name 
    {
        get { return name; }
    }

    public int Health 
    {
        get { return health; }
    }

    public int Strength 
    {
        get { return strength; }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        GameCharacter character1 = new GameCharacter("Hero", 100, 20);   // First instance of GameCharacter
        GameCharacter character2 = new GameCharacter("Villain", 80, 15); // Second instance

        Console.WriteLine(character2.Health);  // Prints: 80
        character1.Attack(character2);  // character1 attacks character2
        Console.WriteLine(character2.Health);  // Prints: 60
    }
}

This code demonstrates object interaction using the Attack method. Initially, character2 has a health of 80. character1 invokes the Attack method on character2, reducing the health of character2 by character1's strength (20). After the attack, character2's health decreases to 60.

Examples of C# Classes, Properties, and Methods

To deepen our understanding of C# classes, let's explore another example where we build a basic BankAccount class. This class will demonstrate how we can model real-world entities using object-oriented programming by defining properties like the account holder's name and balance, and methods for depositing and withdrawing money.

// Define the BankAccount class
public class BankAccount
{
    // Fields
    private string holderName;
    private decimal balance;

    // Constructor with a default balance of 0
    public BankAccount(string holderName, decimal balance = 0)
    {
        this.holderName = holderName;
        this.balance = balance;
    }

    // Method to deposit money
    public void Deposit(decimal amount)
    {
        if (amount > 0)
        {
            this.balance += amount;
            Console.WriteLine($"{amount} deposited. New balance: {this.balance}");
        }
        else
        {
            Console.WriteLine("Deposit amount must be positive.");
        }
    }

    // Method to withdraw money
    public void Withdraw(decimal amount)
    {
        if (0 < amount && amount <= this.balance)
        {
            this.balance -= amount;
            Console.WriteLine($"{amount} withdrawn. Remaining balance: {this.balance}");
        }
        else
        {
            Console.WriteLine("Insufficient balance for the withdrawal or amount is not positive.");
        }
    }

    // Properties
    public string HolderName 
    {
        get { return holderName; }
    }

    public decimal Balance 
    {
        get { return balance; }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        // Create an instance of BankAccount
        BankAccount account = new BankAccount("Alex", 1000);  // An account with an initial balance of 1000

        // Perform some transactions
        account.Deposit(500);  // Deposit money
        // Output: 500 deposited. New balance: 1500

        account.Withdraw(200);  // Withdraw money
        // Output: 200 withdrawn. Remaining balance: 1300

        Console.WriteLine($"Final balance in {account.HolderName}'s account: {account.Balance}");
        // Output: Final balance in Alex's account: 1300
    }
}

// Define the BankAccount class
public class BankAccount
{
    // Fields
    private string holderName;
    private decimal balance;

    // Constructor with a default balance of 0
    public BankAccount(string holderName, decimal balance = 0)
    {
        this.holderName = holderName;
        this.balance = balance;
    }

    // Method to deposit money
    public void Deposit(decimal amount)
    {
        if (amount > 0)
        {
            this.balance += amount;
            Console.WriteLine($"{amount} deposited. New balance: {this.balance}");
        }
        else
        {
            Console.WriteLine("Deposit amount must be positive.");
        }
    }

    // Method to withdraw money
    public void Withdraw(decimal amount)
    {
        if (0 < amount && amount <= this.balance)
        {
            this.balance -= amount;
            Console.WriteLine($"{amount} withdrawn. Remaining balance: {this.balance}");
        }
        else
        {
            Console.WriteLine("Insufficient balance for the withdrawal or amount is not positive.");
        }
    }

    // Properties
    public string HolderName 
    {
        get { return holderName; }
    }

    public decimal Balance 
    {
        get { return balance; }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        // Create an instance of BankAccount
        BankAccount account = new BankAccount("Alex", 1000);  // An account with an initial balance of 1000

        // Perform some transactions
        account.Deposit(500);  // Deposit money
        // Output: 500 deposited. New balance: 1500

        account.Withdraw(200);  // Withdraw money
        // Output: 200 withdrawn. Remaining balance: 1300

        Console.WriteLine($"Final balance in {account.HolderName}'s account: {account.Balance}");
        // Output: Final balance in Alex's account: 1300
    }
}

In the BankAccount class, the properties HolderName and Balance include getters that enable access to the private fields holderName and balance. These getters allow external code to retrieve the account holder's name and account balance while maintaining data encapsulation, as the fields are not directly accessible from outside the class.

This example further illustrates how classes effectively encapsulate data (properties) and functionalities (methods), enabling us to mimic real-life scenarios. Here, the BankAccount class allows the creation of objects representing bank accounts, emphasizing the powerful organizational benefits of using classes in C#.

Revisiting C# Classes and Object-Oriented Programming