Functions in C# with Examples

In C# programming, functions are critical in organizing and managing code. Functions, also called methods, are blocks of code designed to perform a specific task, and their proper implementation is a hallmark of good software design. They enable programmers to divide complex problems into smaller, more manageable parts. As reusable units of code, functions can be called multiple times within a program, reducing redundancy and promoting readability.

Functions in C# are building blocks of code that perform specific tasks. They are defined using the void keyword or a return type, and can be called from other parts of the code. These functions enhance code reusability and organization by allowing you to execute the same code multiple times without rewriting it. They can also return values and take parameters, providing flexibility and efficiency in programming.

C# functions encapsulate behavior with different levels of accessibility, and understanding these is key for effective programming. There are various types of functions, such as static, instance, or extension methods, each serving distinct purposes. They can take parameters, allowing for customized behavior, and can return values to the calling code. Through parameters, C# methods can receive the data they need to operate and optionally return a result.

Understanding Functions in C#

In C#, functions are essential building blocks of a program. They are defined as self-contained blocks of code designed to perform a particular task. These blocks can be reused throughout the program, which leads to more manageable and readable code.

Defining a Function: A function is declared by specifying the return type, name, and parameters. The syntax for a typical function is as follows:

returnType functionName(parameters)
    // Code to execute
    return value; // if returnType is not void

Parameters are variables that accept values passed into the function. Return type indicates the type of value the function will return. It can be any data type, or void if no value is returned.

Calling a Function: To execute a function, one invokes it by its name and passes any required arguments:


Example of a Simple Function: One might define a function to add two integers like this:

int Add(int num1, int num2)
    int result = num1 + num2;
    return result;

Call the function with:

int sum = Add(5, 10);

Here is a complete example of how we can use a function in C#.

using System;

class Program
    // Function to add two numbers
    static int AddNumbers(int num1, int num2)
        return num1 + num2;

    static void Main()
        // Example usage
        int number1 = 10;
        int number2 = 20;

        // Calling the AddNumbers function
        int sum = AddNumbers(number1, number2);

        // Displaying the result
        Console.WriteLine($"The sum of {number1} and {number2} is: {sum}");

Once you run the code using a C# Windows application, you can see the output in the screenshot below:

functions in C# with examples

In C#, functions can also be termed as methods and are associated with classes and objects. However, static methods belong to the class itself rather than any object instance and are called using the class name.

Scope and Accessibility: Functions can have different access levels—such as public, private, or protected—which determine where they can be accessed from.

By adhering to the principles of encapsulation and using functions effectively, developers can create modular, efficient, and error-free C# programs.

C# Function Parameters and Return Types

In C#, a function may accept parameters, which are inputs specified when a function is called. These parameters are defined within the parentheses of the function definition. The syntax for parameter declaration is <data-type> <parameter-name>. C# supports different types of parameters such as value, reference, and output.

For example:

void DisplayMessage(string message) {

Here, DisplayMessage has one parameter named message of type string.

Functions in C# can also specify a return type. If a function is intended to return a value upon completion, the return type must be defined in the function signature; if no value is returned, the keyword void is used.

For instance:

int AddNumbers(int number1, int number2) {
    return number1 + number2;

In this case, AddNumbers returns an int.

Parameter Types:

  • Value Parameters: Parameters are passed by value by default, creating a copy of the value in the function’s scope.
  • Reference Parameters (ref): Allows a function to modify the variable directly.
  • Output Parameters (out): Similar to reference parameters, but intended for returning multiple values.
  • Parameters with Default Values: Allows for optional parameters with default values if not provided.

Return Types:

  • Primitive types like int, float, double, bool, etc.
  • Complex types like custom class, struct, or enum.
  • Special types like void for no return value or Task for asynchronous operations.

A properly designed function with clear parameters and return types enhances code readability and maintainability. It ensures that functions operate as intended and their usage within the codebase remains consistent and predictable.

Access Modifiers and Function Scope of C# Functions

Access modifiers in C# control the visibility of functions and other members within a class or struct. They define the scope at which functions can be accessed, ensuring encapsulation and security of code. There are five primary access modifiers:

  • public: The function is accessible from any other code in the same assembly or another assembly that references it.
  • private: The function is only accessible within the class or struct it is defined in.
  • protected: The function is accessible within its class and by derived class instances.
  • internal: The function is accessible within the same assembly, but not from another assembly.
  • protected internal: The function can be accessed from the current assembly or from types that are derived from the containing class.

Here is an example of how to use access modifiers with functions:

public class MyClass
    // Public function: Accessible from anywhere
    public void PublicFunction() { }

    // Private function: Accessible only inside MyClass
    private void PrivateFunction() { }

    // Protected function: Accessible inside MyClass and in derived classes
    protected void ProtectedFunction() { }

    // Internal function: Accessible within the same assembly
    internal void InternalFunction() { }

    // Protected Internal function: Accessible in current assembly or in derived classes
    protected internal void ProtectedInternalFunction() { }

Each access modifier serves a distinct purpose, determining how and where a function can be invoked. It is crucial for developers to choose the appropriate access modifier to maintain a secure and structured code base. Careful use of function scoping ensures that a class adheres to the principles of object-oriented programming, particularly encapsulation.

Built-In Functions in C#

In C#, built-in functions are pre-defined methods provided by the .NET Framework library to perform common tasks. These methods help developers avoid re-inventing the wheel for common programming scenarios.

Mathematical Functions

The System.Math class contains methods for mathematical operations. Examples include:

  • Math.Abs: Returns the absolute value of a number.
  • Math.Pow: Raises a number to a specified power.
  • Math.Sqrt: Calculates the square root of a number.
double result = Math.Sqrt(16); // result is 4

String Functions

For string manipulation, the System.String class offers many useful functions:

  • String.Concat: Concatenates two strings.
  • String.ToUpper: Converts a string to uppercase.
  • String.Trim: Removes all leading and trailing whitespace.
string greeting = String.Concat("Hello", " World").ToUpper(); // greeting is "HELLO WORLD"

DateTime Functions

The System.DateTime class provides functionality to work with dates and times:

  • DateTime.Now: Gets the current date and time.
  • DateTime.AddDays: Adds days to a DateTime object.
DateTime tomorrow = DateTime.Now.AddDays(1);

These examples showcase the diversity of built-in functions in C# that simplify common programming tasks. Utilizing these can greatly enhance the efficiency of application development.

User-Defined Functions in C#

In C#, user-defined functions are blocks of code designed to perform a specific task, encapsulated within a class. These can be defined by the programmer to offer modular code segments that can be reused.

Defining a Function A function in C# is defined with a return type, a name, and parameters if needed. Below is the syntax for defining a user-defined function:

<ReturnType> FunctionName(<Parameters>)
    // Function body
    // Return statement if needed


public int AddNumbers(int number1, int number2)
    return number1 + number2;

Calling a Function To invoke a user-defined function, reference the function by its name and pass any required parameters.

Example Call:

int result = AddNumbers(5, 10);

Parameters and Return Types Functions can accept zero or more parameters and return data. If a function does not return any value, use the void keyword.

Table of Parameter Types:

Parameter TypeDescription
ValueDirect value passed to the function
ReferenceReference to the original data passed
OutputUsed to return additional data

To utilize reference and output parameters, the ref and out keywords are used, respectively.

Best Practices

  • Functions should be named to clearly indicate their purpose.
  • The parameter list should be kept concise to improve readability and maintainability.
  • Separate computation and presentation logic for cleaner code.

Visibility Function visibility can be controlled using access modifiers such as public, private, protected, and internal. This ensures that only the intended parts of the program can access and run the function.

Advanced C# Function Concepts

In C#, advanced functions extend beyond basic parameter passing and return types. Here are key concepts:


  • They are akin to function pointers in other languages.
  • Delegates allow methods to be passed as parameters.


public delegate void PrintDelegate(string message);
public void Print(string message) {
PrintDelegate pd = Print;
pd("Hello, World!");

Anonymous Methods

  • These don’t have a name and are defined using the delegate keyword.


PrintDelegate pd = delegate(string message) {
pd("Hello from Anonymous Method!");

Lambda Expressions -Lambda expressions are a concise way to define anonymous methods using =>.


PrintDelegate pd = message => Console.WriteLine(message);
pd("Hello from Lambda Expression!");

Extension Methods

  • They enable adding new methods to existing types without altering the type’s source code.
  • Declared static within a static class but called as if they were instance methods.


public static class ExtensionMethods {
    public static int WordCount(this string str) {
        return str.Split(new char[] { ' ', '.', '?' }, StringSplitOptions.RemoveEmptyEntries).Length;
// Usage: "Hello World".WordCount();

**LINQ (Language Integrated Query)**
- Provides querying capabilities to .NET languages.
- Allows complex data queries using fluent syntax or query syntax.

**Asynchronous Functions (async/await)**
- Enable writing asynchronous code resembling synchronous code flows.
- `async` marks a method for asynchronous operations.
- `await` yields control till the awaited task completes.

public async Task<int> CalculateValueAsync() {
    await Task.Delay(1000); // Simulate long-running operation
    return 123;

Understanding and properly utilizing these advanced concepts can greatly enhance the functionality and efficiency of C# applications.

Error Handling in Functions in C#

In C#, error handling within functions is primarily managed using exceptions. When a function encounters an error, it can throw an exception, which is an object representing an error or an unexpected behavior.

Exception Types:

  • System.Exception: The base class for all exceptions.
  • System.ApplicationException: Used for application errors.
  • System.SystemException: Base class for system exceptions.

Functions should handle errors using the try, catch, and finally blocks:

  1. try: Contains the code that may cause an exception.
  2. catch: Allows the interception of exceptions thrown in the try block.
  3. finally: Executes code after try and catch, regardless of whether an exception was thrown.


public void ReadFile(string path)
        // Code that may cause an exception
        var content = File.ReadAllText(path);
    catch (FileNotFoundException ex)
        // Handle FileNotFoundException
        Console.WriteLine("File not found: " + ex.Message);
    catch (Exception ex)
        // Handle all other exceptions
        Console.WriteLine("An error occurred: " + ex.Message);
        // Clean up resources, if needed
        Console.WriteLine("Executing finally block.");

When a function throws an exception, it is recommended to document this behavior using XML comments:

/// <summary>
/// Reads the content of a file.
/// </summary>
/// <param name="path">The file path.</param>
/// <exception cref="FileNotFoundException">Thrown when file is not found.</exception>

This allows others to understand what exceptions they should expect and handle when utilizing the function.

Best Practices for Functions in C#

When defining functions in C#, certain practices can enhance the readability, maintainability, and performance of the code.

  • Naming Conventions: Function names should follow PascalCase and be descriptive. For example, CalculateTotal clearly conveys the function’s intent.
  • Single Responsibility: Each function should perform a single task or action. This simplifies testing and debugging.
  • Parameter Usage: Functions should have a limited number of parameters. If more than three or four are required, consider grouping them into a class or struct.
  • Return Types: Functions should have a clear return type. Avoid returning null if possible; consider using a default value or a design pattern like the Null Object Pattern.
  • Error Handling: Utilize exceptions to handle errors rather than return codes, which can be easily ignored by the caller.


public int AddNumbers(int firstNumber, int secondNumber)
    return firstNumber + secondNumber;

In this example, AddNumbers adheres to the mentioned best practices: it has a clear name, performs a single responsibility, has a limited number of parameters, and a clear return type.

  • Comments and Documentation: Functions should be accompanied by XML comments to explain their behavior, parameters, and return values. This assists IntelliSense and code documentation.

Avoiding Global State:

  • Functions should avoid dependence on global state to ensure predictability and facilitate unit testing.
  • Performance Considerations:
    • Minimize Resource Usage: Where appropriate, use StringBuilder for string manipulations over concatenation in loops.
    • Efficient Algorithms: Choose algorithms and data structures that offer optimal performance for the problem at hand.


Functions in C# are vital building blocks in creating maintainable, reusable, and well-organized code. They enable developers to encapsulate code logic that can be easily tested and debuged. Over the course of using functions, one will notice an enhancement in the clarity and readability of the codebase.

  • Encapsulation: Functions wrap up complexities and offer a simple interface for executing tasks.
  • Code Reusability: They allow code to be used across various parts of an application without duplication.
  • Testing: Individual functions can be tested separately, leading to more robust applications.

When designing functions, careful consideration should be given to their signatures, with an emphasis on parameter types and return values.

Best Practices:

  • Use descriptive names that convey purpose.
  • Keep functions focused on a single task.
  • Minimize side effects to ensure predictability.

In this C# tutorial, we discussed what are functions in C# with various examples.

You may also like: