Understanding Methods and Using C# Extension Methods

In C# programming, methods are essential building blocks that encapsulate reusable code and perform specific tasks. They can accept parameters, return values, and be overloaded to handle varying inputs. A more advanced concept, extension methods enable developers to add functionality to existing types, including those they don't control.

Tim Corey’s video ‘How To Create Extension Methods in C#’ is an excellent resource, and in this guide we will be exploring several of the topics Tim covers:

1. Defining and calling methods
2. Method parameters and arguments
3. Method return values
4. Method overloading
5. Implementing Extension methods

Defining and Calling Methods

Instance Methods Defined

In C#, a method is defined within a class. The general syntax for a method definition includes an access modifier, return type, method name, and parameters.

public class SampleClass
{
    public void SampleMethod()
    {
        // Method implementation  
    }  
}

public class SampleClass
{
    public void SampleMethod()
    {
        // Method implementation  
    }  
}

In Tim Corey's example at 4:05, he defines a method within a static class to create an extension method. The method defined is PrintToConsole. The definition includes all the general syntax which clearly explains how to define a method with a practical example:

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
   }
}

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
   }
}

Calling a Method

A ‘method call’ tells the program to execute a specific method defined elsewhere in the code, performing a predefined action. Methods are called using the class instance, or directly if they are static methods. For extension methods, they appear as if they are part of the type they extend. In the video at 6:18, Tim shows how to call an extension method with a primitive data type just like its predefined methods.

string demo = "This is a demo";
demo.PrintToConsole(); // Extension method call

string demo = "This is a demo";
demo.PrintToConsole(); // Extension method call

Method Parameters and Arguments

Parameters

Parameters are specified in the method definition and act as placeholders for the values that are passed into the method. You can see it here after the WriteLine method is called, where message is the parameter.

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

Again, in the extension method example that Tim Corey gave at 4:05, message is the parameter:

public static void PrintToConsole(this string message)
{
    Console.WriteLine(message);
}

public static void PrintToConsole(this string message)
{
    Console.WriteLine(message);
}

Arguments

Arguments are the actual values passed to the method when it is called.

DisplayMessage("Hello, World!"); // "Hello, World!" is the argument

DisplayMessage("Hello, World!"); // "Hello, World!" is the argument

When Tim Corey calls the method at 6:20 using the dot syntax with string type, the string value is actually being passed as a value to the PrintToConsole method:

string demo = "This is a demo";
demo.PrintToConsole(); // "This is a demo" is the argument

string demo = "This is a demo";
demo.PrintToConsole(); // "This is a demo" is the argument

Method Return Values

Methods can return values using the return statement. The return type is specified in the method signature.

public int Add(int a, int b)
{
    return a + b;
}

public int Add(int a, int b)
{
    return a + b;
}

While the extension method in Tim Corey's video doesn't return a value (void return type), you can create extension methods with return values. The return type in Tim’s example is void which means the method doesn’t return any value. The following example shows how to return the value:

public static int WordCount(this string str)
{
    return str.Split(' ').Length;
}

public static int WordCount(this string str)
{
    return str.Split(' ').Length;
}

Method Overloading (11:15)

Method overloading allows multiple methods to have the same name but different parameters. This can be useful for creating flexible and intuitive APIs.

public void Display(string message)
{
    Console.WriteLine(message);
}

public void Display(int number)
{
    Console.WriteLine(number);
}

public void Display(string message)
{
    Console.WriteLine(message);
}

public void Display(int number)
{
    Console.WriteLine(number);
}

Tim Corey briefly touches on creating multiple methods for different logging scenarios at 11:24, which can be seen as an example of method overloading in a broader sense. The log method exists twice, one with one parameter and another with two parameters. The second log method at 11:39 is the overloaded version of the log method, giving it multiple functionalities under the same name.

Implementing Extension Methods in C#

What are Extension Methods? (3:13)

Extension methods allow you to add new methods to existing types without having to modify or recompile them. While they’re called as if they are instance methods, extension methods are defined as static. (While they’re named or called as if … ?)

Creating an Extension Method

In the previous section, ‘Defining and Calling Methods’, we highlighted how Tim Corey created an extension method in a separate static class and defined the static method within it to be used as extension method. Here are some key points Tim Corey emphasizes when creating extension methods:

1. Be sure to define a separate public static class, or, as Tim says, “mark the class as static otherwise it won’t work.”
2. As you create more extension methods, you need to group them by type (3:43)
3. Define a static method with the first parameter prefixed with the this keyword, specifying the type to extend (4:58)

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

Calling the Extension Method (6:18)

Next, Tim shows how to call an extension method on this string variable:

demo.PrintToConsole();

demo.PrintToConsole();

When you enter demo and start typing Print, IntelliSense suggests the PrintToConsole method. This is the new method added to the string type.

How the Method Call Works (6:30)

Tim explains why you can call demo.PrintToConsole():

• Demo is a String Type: The variable demo is of type string.
• Extended String Type: The string type has been extended with the new method PrintToConsole.

Understanding the Parameter (6:41)

Although it appears that no parameters are being passed to the PrintToConsole method, Tim points out the implicit parameter passing - the demo string is passed as the first parameter to the extension method.

Tim emphasizes that extension methods have one fewer parameter in the call than in their definition. This is because the first parameter (the type being extended) is implicit.

Extension Method Signature

Here, this string message means the method extends the string type, and message is the implicit parameter:

public static void PrintToConsole(this string message)

public static void PrintToConsole(this string message)

Running the Code (7:08)

Finally, when the method PrintToConsole is called, it outputs the string to the console:

Console.WriteLine(message);

Console.WriteLine(message);

So, calling demo.PrintToConsole() prints "This is a demo" to the console.

Using Extension Methods for Third-Party Classes

Extending Third-Party Classes (10:59)

Tim Corey explains that extension methods can extend any type, even third-party classes that you cannot modify directly. For example, let’s take a look at the SimpleLogger class at 11:09.

Here, Tim uses the hypothetical third-party class SimpleLogger that logs messages to the console (11:09). The class has two methods:

public class SimpleLogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }

    public void Log(string message, string messageType)
    {
        Console.WriteLine($"{messageType}: {message}");
    }
}

public class SimpleLogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }

    public void Log(string message, string messageType)
    {
        Console.WriteLine($"{messageType}: {message}");
    }
}

These methods are not ideal because the message type is a simple string, which can lead to inconsistencies, so Tim suggests creating extension methods to improve the class.

Using extension methods ensures consistency in your code by always using the same message types and formatting. Here at (12:40), Tim creates a static class ExtendSimpleLogger:

public static class ExtendSimpleLogger
{
    public static void LogError(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Error");
    }

    public static void LogWarning(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Warning");
    }
}

public static class ExtendSimpleLogger
{
    public static void LogError(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Error");
    }

    public static void LogWarning(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Warning");
    }
}

With it in hand, (14:02) he is now able to call the extension methods on a SimpleLogger instance:

SimpleLogger logger = new SimpleLogger();
logger.LogError("This is an error");
logger.LogWarning("This is a warning");

SimpleLogger logger = new SimpleLogger();
logger.LogError("This is an error");
logger.LogWarning("This is a warning");

This ensures that the message types are always ‘Error’ and ‘Warning’.

Enhancing Output Formatting (14:35)

Tim adds functionality to set the console text color for error messages:

public static void LogError(this SimpleLogger logger, string message)
{
    var defaultColor = Console.ForegroundColor;
    Console.ForegroundColor = ConsoleColor.Red;
    logger.Log(message, "Error");

    Console.ForegroundColor = defaultColor;
}

public static void LogError(this SimpleLogger logger, string message)
{
    var defaultColor = Console.ForegroundColor;
    Console.ForegroundColor = ConsoleColor.Red;
    logger.Log(message, "Error");

    Console.ForegroundColor = defaultColor;
}

This ensures that error messages are displayed in red, making them stand out.

Comparison with Direct Method Calls (17:21)

Tim compares this approach to directly calling the original Log methods, which could lead to inconsistencies:

logger.Log("Test error", "Error");
logger.Log("Another error", "ERROR");

logger.Log("Test error", "Error");
logger.Log("Another error", "ERROR");

This approach is prone to typos and inconsistent formatting.

Chaining Extension Methods (18:13)

Tim demonstrates how extension methods can be chained to make the code more readable:

public static void LogInfo(this SimpleLogger logger, string message)
{
    logger.Log(message, "Info");
}

public static void SaveToDatabase(this SimpleLogger logger)
{
    // Simulate saving to a database
}

public static void LogInfo(this SimpleLogger logger, string message)
{
    logger.Log(message, "Info");
}

public static void SaveToDatabase(this SimpleLogger logger)
{
    // Simulate saving to a database
}

Now, you can chain these methods:

logger.LogInfo("Information").SaveToDatabase()

logger.LogInfo("Information").SaveToDatabase()

This makes the code more readable and intuitive compared to nested method calls:

SaveToDatabase(LogInfo(logger, "Information"));

SaveToDatabase(LogInfo(logger, "Information"));

By using dot notation and chaining, the intent of the code is clearer and less nested.

Extending Things You Don’t Own

At 20:13, Tim Corey explains that extension methods are ideal for adding functionality to classes you don't own, such as third-party libraries. This allows for enhancements without modifying the original code.

Avoiding Dependencies

Corey also highlights using extension methods to introduce dependencies without coupling them directly to a class. For example, adding database saving functionality to a Person class without embedding database logic.

Extending Interfaces

Extension methods can also apply to interfaces, as explained from 21:30, enabling multiple classes that implement the interface to share the same functionality. This promotes code reuse and simplification.

When Not to Use Extension Methods

At 23:03, Tim Corey advises against overusing extension methods, especially with primitive or Microsoft-provided types, to prevent clutter and complexity. Use them sparingly and only when they offer clear benefits.

The Open/Closed Principle

In the section between 24:54-25:40, Tim emphasizes adhering to the open/closed principle by using extension methods to add new functionality without modifying existing, stable code, reducing the risk of introducing bugs.

Best Practices for Using Statements

Organize extension methods by grouping them logically and placing them in separate namespaces to avoid naming conflicts and facilitate easier maintenance and debugging.

Conclusion

And there you have it - you now understand the basics of defining and calling methods, handling parameters and return values, and leveraging method overloading. With that, you can build robust and flexible applications in C#.

Extension methods, as explained by Tim Corey, offer a powerful way to enhance existing types and make your code more readable and maintainable. For more detailed insights and practical examples, you can watch Tim Corey's full video on How To Create Extension Methods in C#.