Void Keyword in C#

All keywords are unique to the vast universe of programming languages, carrying the influence on express functions visually and logically. Such as, the "void" keyword is the keystone of these fundamentals of C# that help define those methods without using any return value. You can press on to the key issue without exaggeration since being based on neat, short, and efficient code is essential.

Void keyword is used to show the compiler and other developers that the function or method action is meant for carrying out a set of instructions or processes in a sequence with no intention of returning a value. Although the void keyword, which is used for a purpose that may glance simple, has the significance of understanding and code organization as well.

For every developer who writes programs in C#, void is one of the main keywords to know about. Developers clearly show their wish not to bother about the returning value and stay focused on what they are doing by always marking "void" as their return type while designing a method. This shortened syntax succinctly nets the void keyword, which has been found to be quite simple and time-consuming to comprehend and use.

The following part will be devoted to actual-life examples, in which we will gain a greater comprehension of this keyword. Void is the keyword that allows coding experts to design easy-to-understand and more economical software solutions for both the novice and the more elaborate functions. However, the void keyword, in the same way as other tools, can have some subtleties as well. It gives the code simplicity and readership characteristics, but there are also a large number of restrictions.

Whether you are a C# pro or a beginner in C# development, it is necessary to be familiar with void keywords. Now, let's go on an adventure to reveal the possibility and potential of this beautiful piece. After this, we can see the road ahead to C# development.

In this blog, we will discuss on syntax, example with proper explanation, and pros and cons of void keyword.

Syntax:

In C#, the void keyword has a simple syntax, which is the most important for defining a function or method. No values are being returned. When writing highly legible and workable code, the syntax and implications of the code must be considered.

The syntax for declaring a method or function with the void keyword is as follows:

public void MethodName(parameters)
{
    // Method implementation
}

Let us dissect this syntax:

Public: Visibility of the method is insured by this access controller. In this case, if this method is required from any other class, it can just be called 'public'.
Void: The string k beyond it designates the method's result type. "void" is the way to inform the fact that there is no function return value.
MethodName: The developer decides to name the method in this manner in order that it represents what the method performs in comparison to others.
(parameters): The method would accept the parameters. If it does accept it, then these are the only values. One comes after the other with optional arguments in parentheses. There are procedures by which the method can acquire input data, which it can then use to get its execution done.
{}: The braces of costly type close off the scope of the method and encapsulate the block of codes that is the way the method is being implemented.

Example 1: Bank Account Management System

using System;
class BankAccount
{
    private string accountHolder;
    private double balance;
 
    public BankAccount(string accountHolder, double initialBalance)
    {
        this.accountHolder = accountHolder;
        this.balance = initialBalance;
    }
 
    public void Deposit(double amount)
    {
        balance += amount;
        Console.WriteLine($"Deposited ${amount}. Current balance: ${balance}");
    }
 
    public void Withdraw(double amount)
    {
        if (amount <= balance)
        {
            balance -= amount;
            Console.WriteLine($"Withdrawn ${amount}. Current balance: ${balance}");
        }
        else
        {
            Console.WriteLine("Insufficient funds.");
        }
    }
 
    public void DisplayBalance()
    {
        Console.WriteLine($"Account balance for {accountHolder}: ${balance}");
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        BankAccount account = new BankAccount("John Doe", 1000);
 
        account.DisplayBalance();
        account.Deposit(500);
        account.Withdraw(200);
        account.Withdraw(1500);
    }
}

Output:

Account balance for John Doe: $1000
Deposited $500. Current balance: $1500
Withdrawn $200. Current balance: $1300
Insufficient funds.

Explanation:

BankAccount Class:

The entity for a bank account is represented by it.
The account holder's name and balance are kept in the private fields protocol that is declared as the account holder and balance, respectively.
Using the supplied constructor method, new Balance and accountHolder fields can be initialized at the time of creation of a new BankAccount object.
Draws only the Deposit, Withdraw, and DisplayBalance void methods.

Deposit Method:

Reflects the designated amount in the account balance.
Prints the message containing the updated balance and the amount of deposit.

Withdraw Method:

To make sure that the amount of withdrawal is either the same as the amount within the account or less than that.
If the money available in the account is sufficient, the withdrawal amount is debited out, and a notice with the updated balance and the withdrawal amount is printed.
The message is printed if the account balance is not sufficient, "Insufficient funds".

DisplayBalance Method:

The account holder's name and the balance are printed.

Program Class:

Instantiates a new BankAccount object called account to the account holder "John Doe" that is initialized with a starting balance of $1000.

Main Method:

In the main method, the dev calls the object of the account, DisplayBalance, to call the starting balance.
$500 is deposited using the Deposit method, and the updated balance is on display.
Makes two calls, the first for $200 and the second for $1,500, to the Withdraw method.
The official approval of the initial withdrawal and the updated balance is $1300.
The error message "Insufficient funds." appears when the second withdrawal is tried again, but it doesn't work.

Example 2: Employee Management System

using System;
using System.Collections.Generic;
class Employee
{
    public string Name { get; set; }
    public string Department { get; set; }
 
    public Employee(string name, string department)
    {
        Name = name;
        Department = department;
    }
 
    public void DisplayDetails()
    {
        Console.WriteLine($"Name: {Name}, Department: {Department}");
    }
}
 
class Company
{
    private List<Employee> employees;
 
    public Company()
    {
        employees = new List<Employee>();
    }
 
    public void AddEmployee(Employee employee)
    {
        employees.Add(employee);
    }
 
    public void DisplayEmployees()
    {
        for each (var employee in employees)
        {
            employee.DisplayDetails();
        }
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        Company company = new Company();
 
        Employee emp1 = new Employee("John", "HR");
        Employee emp2 = new Employee("Alice", "Finance");
 
        company.AddEmployee(emp1);
        company.AddEmployee(emp2);
 
        company.DisplayEmployees();
    }
}

Output:

Name: John, Department: HR
Name: Alice, Department: Finance

Explanation:

Employee Class:

It is a staff grouping.
The employee's name and department are stored as their values in their Name and Department properties, respectively.
Includes a constructor method which, during the creation of a new Employee object, initializes the properties Department and Name
Shows that the null method Returns the employee's name and his department by selecting DisplayDetails.

Company Class:

Symbolizes a business entity.
It uses a private member of type List<Employee> named employees to keep a group of staff.
Involves a constructor method that, upon creation of the new Company object, initializes the employee's list.
It is the defining AddEmployee and DisplayEmployees void methods.

AddEmployee Method:

Passes an Employee object to the list of employees if it is argument.

DisplayEmployees Method:

The employees' details are shown by the DisplayDetails method on each cycle through the employee's list.

Program Class:

Includes the cold contact method which is termed as the warm entry point technique.
Creates a brand-new object.

Main Method:

Creates two new Employee objects, emp1 and emp2, with departments "HR" and "Finance" and the names "John" and "Alice, "respectively.
Creates two new employees, emp1 and emp2, and adds them to the employee list of the firm through its AddEmployee method invocation.
The firm object is called to view all the employees.

Pros and Cons of Void Keyword in C#:

Pros:

Clarity and Intention: The indication that the methods do not take part in the execution operation but do not affect the value return is made obvious from the void methods. This specificity aims at achieving code legibility and helps other programmers understand the method's purpose.
Simpleness: The design of void methods in such a way so that only one thing is being done and eliminating the requirement of handling back values allows for straightforward programming. Therefore, it becomes streamlined, more compact, and easier to manage.
Efficiency: Void methods don't know the overheads of returning values. So, they provide better performance advantages over methods that do return values. For performance-critical applications, void methods are much better as the values don't need to be assigned or managed.
Flexible Usage: There are a lot of occasions where the result isn't the main goal but rather the process of executing an action, like in the event handlers, utility functions, or helper methods, null methods can be applied. The adaptability of way methods makes them a fundamental technique in a programmer's toolbox.

Cons:

Restricted Usability: Blank methods can execute methods and return "null". This limitation might become ineffective when using the method's output in processing or using it by other parts of the code. Consequently, the flexibility of the code may go down, and the function may need to be corrected to get the intended behavior.
Code Duplication: If this code generation does not yield the same results or needs to be repeated without having the capability to produce results, void methods may be one of the factors leading to code duplication. This might result in excessive code segments that increase the probability of a bug or a slip-up, and the codebase would be significantly harder to maintain.
Testing Complexity: Testing the void methods, however, may be more complicated than testing those which return a value. In most instances, a void method is known to lead to side effects, so testing them simply involves confirming the effects against the correct results rather than just picking up the return values. It may complicate the process of unit testing and may imply the need for more setup or other dependency mocking.
Error Handling: Void methods can hardly manage errors, especially when it happens in the process of the method being executed. It also gets complicated to handle and pass on errors inside void methods, which don't offer the possibility to return error codes or exceptions. It will lead to non-handled exceptions or inconsistent error handling within the whole code.

Conclusion:

To conclude, in C#, the "void" keyword is the essential component of a method introduction, which means that the method provides the output, but it does not return anything. The high rank of void methods in C# programming has become evident as we have seen them promote the clarity of code, simplicity, encapsulation, efficiency, side-effect handling, and flexibility of use, among others.

The void keyword is inherently feature-rich; however, it also has some downsides. These include reduced usability, the possibility of code duplication, complicated testing, issues related to error handling, and struggling with controlling a side effect. In their codebase, void methods in which developers engage should have these disadvantages taken into consideration as they make wise decisions and avoid any issues.

Nevertheless, the void keyword keeps being a powerful tool in the developer's toolbox, allowing them to specify the methods that run operations but don't return data. Writing easy-to-read and understandable code should be the goal. So, it doesn't matter whether you are at a junior or advanced level of C#; you must know how to use the void keyword. Practicing the craft of C# programming, programmers get advantage on the void keyword to build dependable systems they can easily teach to end-users once the pros and cons involved have been weighed.

Next TopicEncrypt and Decrypt Using Rijndael Key in C#

← prev next →