What is extension method with example in c#


An extension method in C# allows you to add methods to existing types without modifying their source code or inheriting from them. These methods appear as if they were part of the original type. 

Here's an example of an extension method:

*** csharp code
using System;

public static class StringExtensions
{
    // Extension method to reverse a string
    public static string Reverse(this string input)
    {
        char[] charArray = input.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }
}

class Program
{
    static void Main(string[] args)
    {
        string originalString = "hello";
        string reversedString = originalString.Reverse(); // Calling the extension method
        Console.WriteLine($"Original string: {originalString}"); // Output: Original string: hello
        Console.WriteLine($"Reversed string: {reversedString}"); // Output: Reversed string: olleh
    }
}
****

In this example:

- We define a static class `StringExtensions` to contain our extension method(s).
- The extension method `Reverse` is defined to operate on strings (`this string input`). This syntax indicates that `Reverse` is an extension method for the `string` type.
- Inside the `Reverse` method, we reverse the characters of the input string and return the result.
- In the `Main` method, we call the extension method `Reverse` on a string object `originalString`. This call appears as if the `Reverse` method is a member of the `string` class, even though it's actually defined in the `StringExtensions` class.

Extension methods are powerful tools for adding functionality to existing types, especially when you can't or don't want to modify the original source code. They're commonly used in C# to provide additional convenience methods for existing types or to integrate with third-party libraries.

Comments

Post a Comment

Popular posts from this blog

What is hash table in c# and when we should use it

Image
In C#, a hash table is implemented using the `Hashtable` class or, more commonly, the `Dictionary<TKey, TValue>` class in the `System.Collections.Generic` namespace. Both are used for storing key-value pairs, but `Dictionary<TKey, TValue>` is more type-safe and generally preferred over `Hashtable`. ### When to use a hash table (Dictionary in C#): 1. Fast Retrieval: Hash tables provide fast retrieval of values based on their associated keys. This is particularly useful when you need quick access to data based on some identifier. 2. Unordered Collection: If the order of elements doesn't matter, and you need to store and retrieve data based on unique keys, a hash table is a good choice. 3. Associative Mapping: When you want to establish an association between keys and values, such as mapping usernames to user profiles or IDs to corresponding objects. 4. Efficient Search: Hash tables provide O(1) average time complexity for retrieval, making them efficient for s...
Read more

What is valuetuple in c# with example

Image
In C#, a ValueTuple is a lightweight data structure introduced in C# 7.0 that allows you to create tuples with named or unnamed elements. ValueTuples are value types, which means they are structs rather than reference types (classes), making them more memory-efficient. Here's an example of using ValueTuples: ```csharp using System; class Program {     static void Main()     {         // Creating a ValueTuple with named elements         var person = (Name: "John", Age: 30);         // Accessing elements using names         Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");         // Creating a ValueTuple with unnamed elements         var point = (3, 4);         // Accessing elements using itemN notation         Console.WriteLine($"X: {point.Item1}, Y: {point.Item2}");     } } `...
Read more