Mastering Classes in C# (Part 1 of 2)

Introduction

Welcome to the exciting world of Classes in C#! This Article will guide you through the fundamentals of creating and using classes, empowering you to build your own object-oriented programs in C#. Let’s begin by understanding the two key concepts: classes and objects.

What are Classes and Objects in C#?

Classes: Imagine a class as a blueprint, a template for creating real-world entities like cars, bank accounts, or even video game characters. This blueprint defines the characteristics (properties) and behaviors (methods) that these entities share.For example, a car class might have properties like color, weight, and speed, and methods like accelerate, brake, and turn.

Objects: Each unique instance created from a class blueprint is called an object. Think of objects as individual cars, bank accounts, or characters brought to life. Each object retains the properties and methods defined in its class but holds its own unique data, like a specific car’s color and speed or a unique bank account’s balance.

Why Use Classes?

Classes offer several advantages over simply using variables and functions:

• Organized Code: Classes group related data and functionality, making your code cleaner and easier to understand.
• Reusability: A well-designed class can be reused multiple times throughout your program or even in different projects.
• Maintainability: Modifying a class affects all its objects, simplifying code updates.
• Encapsulation: Classes allow you to control data access and prevent accidental modifications, ensuring data integrity.
• Object-Oriented Thinking: Classes help you model real-world problems using familiar objects and their interactions.

Benefits of Object-Oriented Programming (OOP)

Object-Oriented Programming (OOP) is a popular programming paradigm that relies heavily on classes and objects. By using OOP, you enjoy several benefits:

• Modular Design: Break down complex problems into smaller, manageable units.
• Code Reusability: Reduce code duplication and increase development efficiency.
• Flexibility and Maintainability: Adapt and update code easily as requirements change.
• Real-World Modeling: Represent real-world entities and their relationships accurately.

So, whether you’re building small scripts or large applications, understanding classes and objects is essential for mastering C# and reaping the benefits of OOP. In the next section, we’ll dive deeper into how to define and use classes in your C# code!

How to create a new file for you classes in C# with visual studio

Creating a new file for your class in Visual Studio is quite straightforward! Here are three different ways you can do it:

1. Using the “Add” menu:

1. Right-click on the folder where you want to create the file (usually your project folder or a specific subfolder like “Classes”).
2. Select Add -> New Item….
3. In the “Add New Item” dialog box, navigate to the “Code” section on the left pane.
4. Select the type of file you want to create for your class (usually a “Class” file for C# or a “VB Class” file for Visual Basic).
5. Give your file a meaningful name and click Add.

2. Using the keyboard shortcut:

1. Place your cursor where you want to create the file (within the desired folder).
2. Press Ctrl+Shift+A (for C#) or Alt+I+V (for Visual Basic).
3. Type the name of the file type you want to create (e.g., “class” for C#).
4. Select the appropriate file type from the suggestions and press Enter.

3. Using the Solution Explorer:

1. In the Solution Explorer window, right-click on the project folder or the desired subfolder.
2. Select Add -> New File….
3. In the “Add New File” dialog, select the “General” section on the left pane.
4. Choose the “Empty File” template and give your file a name with the appropriate extension (e.g., “.cs” for C# or “.vb” for Visual Basic).
5. Click Add.

Understanding Class Fundamentals

Now that you understand the core concepts of classes and objects, let’s explore how to build them in C#.

Defining a Class

Syntax and Structure:

A class definition resembles a blue box in your code, starting with the class keyword followed by the class name (PascalCase convention) and curly braces:

class Car
{
 // Class members go here
}

Inside the curly braces, you define the members of your class, which can be:

• Fields: Variables that store data specific to an object (e.g., color, weight)
• Methods: Functions that define the object’s behaviors (e.g., accelerate, brake)
• Properties: Special constructs that provide controlled access to fields like getters and setters

Members

Let’s explore these members in more detail:

Fields:

class Car
{
 public string color; // Public field accessible from anywhere
 private int weight; // Private field only accessible within the class
}

Methods:

class Car
{
 public void accelerate()
 {
 // Code to increase speed
 }
 
 private void brake()
 {
 // Code to decrease speed
 }
}

Properties:

class Car
{
  private int speed;

  public int Speed
  {
     get { return speed; }
     set { speed = value; } // Optional setter to control how speed is set
  }
}

Access Modifiers

You can control access to class members using modifiers like:

• public: Accessible from anywhere in your code.
• private: Only accessible within the class itself.
• internal: Accessible within the same assembly (project or group of projects).
• protected: Accessible within the class and its derived classes.

Example:

Let’s create a simple Car class:

public class Car {
 // Fields (data)
 public string color;
 private int speed;

// Methods (behavior)
 public void Accelerate() {
   speed++;
 }
 
 public int GetSpeed() {
   return speed;
 }
}

In this example:

• `color` is a public field, accessible from anywhere.
• `speed` is private, accessible only within the Car class.
• `Accelerate` increases the speed and is public.
• `GetSpeed` retrieves the speed and is public.

Remember, this is just a basic example. Classes can become much more complex, incorporating inheritance, interfaces, and other OOP concepts. We’ll explore these advanced topics in later sections!

Creating Objects: Bringing Your Classes to Life

Now that you understand class blueprints, let’s see how to create individual objects from them:

Instantiation using the new keyword

Imagine a factory churning out cars based on a blueprint. In C#, the new keyword acts as your factory, taking a class blueprint and creating a unique object:

// Create a new Car object
Car myCar = new Car();

// Set the color of the object
myCar.color = "red";

// Call a method on the object
myCar.Accelerate();

// Get the object's speed
int currentSpeed = myCar.GetSpeed();
Console.WriteLine("My car is " + myCar.color + " and going " + currentSpeed + " mph.");

Here’s what happens:

1. `Car myCar = new Car();` creates a new object called myCar of type Car. This object has its own copy of the class’s members.
2. `myCar.color = “red”;` assigns the value “red” to the color field of the myCar object.
3. `myCar.Accelerate();` calls the Accelerate method on the myCar object, increasing its internal speed.
4. `int currentSpeed = myCar.GetSpeed();` calls the GetSpeed method and stores the retrieved speed value in the currentSpeed variable.
5. `Console.WriteLine(…)` prints a message displaying the car’s color and speed.

Remember, each object is independent. Creating another Car object wouldn’t affect myCar’s color or speed. They each maintain their own state based on the class blueprint.

Member Access and Multiple Objects

Accessing Member Values:

You use the dot notation (objName.memberName) to access the values of public fields and call public methods of an object:

Car myCar = new Car();
myCar.color = “red”; // Set the color field
int currentSpeed = myCar.GetSpeed(); // Call the GetSpeed method and store the value

Remember, access modifiers control visibility:

• Public members: Accessible from anywhere in your code.
• Private members: Only accessible within the same class.
• Internal members: Accessible within the same assembly (project or group of projects).
• Protected members: Accessible within the class and its derived classes.

Accessing Methods:

To call a method on an object, use the dot notation followed by parentheses containing any required arguments:

myCar.Accelerate(); // No arguments needed
int distance = myCar.CalculateDistance(10); // Requires an argument (time)

The method receives the provided arguments and executes its defined logic within the class, potentially modifying the object’s state or returning a value.

Key Points:

• Only public members are accessible from outside the class.
• Accessing private members directly outside the class leads to errors.
• Use appropriate access modifiers to control member visibility and maintain good code organization.

Additional Notes:

• Properties provide an alternative way to access and modify data, often with additional logic or validation.
• You can create methods that access and modify private members within the class itself.

Multiple Objects:

You can create multiple objects from the same class, each with its own unique data and behavior:

Car firstCar = new Car();
firstCar.color = “blue”;
firstCar.Accelerate();

Car secondCar = new Car();
secondCar.color = "green";
secondCar.Accelerate();
secondCar.Accelerate();

Console.WriteLine("First car: " + firstCar.color + ", speed: " + firstCar.GetSpeed());
Console.WriteLine("Second car: " + secondCar.color + ", speed: " + secondCar.GetSpeed());

This code creates two Car objects and demonstrates how each object can have different values for its fields and can call its methods independently.

Constructors in C#

Introduction to Constructors

Constructors play a vital role in object-oriented programming languages like C#. They are special member functions of a class that are automatically called when an instance of the class is created. Constructors are used to initialize the newly created object, ensuring that it’s in a valid state for use. We’ll explore the different types of constructors in C# and their usage.

Default Constructors

A default constructor is a constructor with no parameters. If a class doesn’t explicitly define any constructors, C# provides a default constructor implicitly. Its primary function is to initialize the fields of the class to their default values, typically zero for numeric types, null for reference types, and so on. Let’s consider an example:

public class MyClass
{
 // Default constructor
 public MyClass()
 {
 // Initialization code
 }
}

In the absence of any other constructors, this default constructor is automatically invoked when an object of MyClass is created.

Parameterized Constructors

Parameterized constructors are constructors that accept parameters, allowing for initialization of object properties with specific values. These constructors enable flexibility by allowing clients to create objects with initial states tailored to their needs. Here’s an example demonstrating the usage of parameterized constructors:

public class Person
{
 public string Name { get; set; }
 public int Age { get; set; }

// Parameterized constructor
 public Person(string name, int age)
 {
   Name = name;
   Age = age;
 }
}

In this example, the Person class has a parameterized constructor that takes name and age as parameters to initialize the Name and Age properties, respectively.

Overloading Constructors

In C#, constructors can be overloaded, meaning a class can have multiple constructors with different parameter lists. This allows for different initialization scenarios based on the parameters provided. Overloaded constructors provide flexibility and convenience to developers. Let’s extend our Person class to demonstrate constructor overloading:

public class Person
{
   public string Name { get; set; }
   public int Age { get; set; }
  
   // Parameterized constructor
   public Person(string name, int age)
   {
       Name = name;
       Age = age;
   }
   
   // Overloaded constructor
   public Person(string name)
   {
       Name = name;
       Age = 0; // Default age
   }
}

In this example, we’ve added another constructor to the Person class that only takes the name parameter, setting the Age property to a default value. This allows clients to create Person objects without specifying an age.

Properties

Introduction to Properties

Properties are special member functions of a class that provide a flexible mechanism for controlling access to the fields or data of a class. They encapsulate the fields within a class, allowing controlled access to them while ensuring data integrity and security. We’ll explore various aspects of properties in C#, including getters and setters, read-only and write-only properties, and customizing property behavior.

Getters and Setters

In C#, properties are typically composed of a getter and/or a setter method, which allow “reading from” and “writing to” the property, respectively. The getter returns the current value of the property, while the setter assigns a new value to the property. Here’s a simple example demonstrating the usage of getters and setters:

public class Person
{
    private string _name;
    
    public string Name
    {
       get { return _name; }
       set { _name = value; }
    }
}

In this example, the `Name` property has both a getter and a setter method, allowing clients to retrieve and modify the `_name` field indirectly.

Read-only and Write-only Properties

Sometimes, it’s desirable to create properties that can only be read from or written to, but not both. In C#, this can be achieved by providing only a getter (read-only) or only a setter (write-only). Let’s see examples of both:

public class Circle
{
   private readonly double _radius;

   // Read-only property
   public double Radius
   {
       get { return _radius; }
   }
   
   private int _counter;
   // Write-only property
   public int Counter
   {
       set { _counter = value; }
   }
}

In this example, the `Radius` property is read-only, allowing clients to retrieve the value of `_radius` but not modify it. Conversely, the `Counter` property is write-only, enabling clients to set the value of `_counter` but not retrieve it.

Customizing Property Behavior

In addition to simple getters and setters, C# allows for customizing the behavior of properties using access modifiers, validation logic, calculations, and more. Here’s an example demonstrating custom property behavior:

public class BankAccount
{
   private decimal _balance;

   // Property with custom logic
   public decimal Balance
   {
     get { return _balance; }
     set
     {
       if (value >= 0)
       _balance = value;
       else
       throw new ArgumentException("Balance cannot be negative.");
     }
   }
}

In this example, the `Balance` property ensures that the balance cannot be set to a negative value by throwing an exception if a negative value is provided.

Code Challenge

Defining a Class

Create a class called “Car” with the following specifications:

- Define fields for make, model, and year of the car.

- Create methods to set and get the values of these fields.

- Make sure the fields are accessible only within the class (use appropriate access modifiers).

- Write a main program to demonstrate accessing these members from outside the class.

Creating Objects

Write a program that defines a class called “Student” with fields for name, age, and grade.

- Instantiate three objects of the Student class.

- Set values for each object’s fields using constructors.

- Print out the information of each student object.

Constructors

Extend the “Car” class from assignment 1.1 by adding constructors.

- Implement a default constructor that initializes the make, model, and year to default values.

- Implement a parameterized constructor that accepts values for make, model, and year.

- Implement an overloaded constructor that accepts only make and model, and sets the year to a default value.

- Demonstrate the use of each constructor in a main program.

Properties

Create a class called “Rectangle” with fields for length and width.

- Implement properties for getting and setting the length and width.

- Create a property called “Area” that calculates and returns the area of the rectangle.

- Create a read-only property called “Perimeter” that calculates and returns the perimeter of the rectangle.

• Demonstrate the use of these properties in a main program by creating an object of the Rectangle class and accessing its properties.

What’s Next?

Congratulations on completing “Mastering Classes (Part 1 of 2)”! Now that you’ve mastered the Fundamentals of Classes in C#, it’s time to take your coding journey to the next level.

Next Topic:

Ready to continue your exploration of C# programming? The next topic to dive into is Mastering Classes in C# (Part 2 of 2). Streamline your code with this powerful construct, enabling efficient and structured organization of data and behavior in your programs.