1. IronPDF
  2. IronPDF Blog
  3. .NET Help
  4. C# Extension Methods

Published May 17, 2023

C# Extension Methods (How It Works For Developers)

Extension methods are a powerful feature in C# that allows you to add new functionality to existing types without modifying their source code. They can be extremely useful in making your code more readable and maintainable. In this tutorial, we'll explore the basics of extension methods, and how to implement them.

What are Extension Methods?

Extension methods are special static methods that can be called as if they were instance methods of an existing type. They are a convenient way to add new methods to an existing class without changing the original source code or inheriting from the class.

To create an extension method, you need to define a static method inside a static class. The first parameter of the method should be the type you want to extend, prefixed with this keyword. This special keyword tells the C# compiler that this is an extension method.

Implementing Extension Methods in C#

Now that we know what extension methods are, let's implement one. Imagine you have a string that you want to reverse. Instead of writing a separate function to do this, you can create an extension method for the string class.

First, let's create a new static class called StringExtensions. The class name is not important, but it's a common convention to use the name of the type being extended followed by "Extensions". Inside this class, we'll define a static method called Reverse:

public static class StringExtensions
{
    public static string Reverse(this string input)
    {
        char[] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
}
public static class StringExtensions
{
    public static string Reverse(this string input)
    {
        char[] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
}
Public Module StringExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function Reverse(ByVal input As String) As String
		Dim chars() As Char = input.ToCharArray()
		Array.Reverse(chars)
		Return New String(chars)
	End Function
End Module
VB   C#

In this example, we created a public static string method called Reverse with a single parameter. The this keyword before the string type indicates that this is an extension method for the string class.

Now, let's see how to use this new extension method in our Program class:

class Program
{
    static void Main(string[] args)
    {
        string example = "Hello, World!";
        string reversed = example.Reverse();
        Console.WriteLine(reversed); // !dlroW ,olleH
    }
}
class Program
{
    static void Main(string[] args)
    {
        string example = "Hello, World!";
        string reversed = example.Reverse();
        Console.WriteLine(reversed); // !dlroW ,olleH
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim example As String = "Hello, World!"
		Dim reversed As String = example.Reverse()
		Console.WriteLine(reversed) ' !dlroW ,olleH
	End Sub
End Class
VB   C#

Notice that we didn't have to create an instance of the StringExtensions class. Instead, we used the Reverse method directly on the string instance as if it were an instance method.

Extension Method Syntax

Extension methods look and behave like instance methods, but there are a few important differences to keep in mind:

  1. Extension methods cannot access private members of the extended type.
  2. They also do not participate in inheritance or polymorphism.
  3. You cannot override an existing method with an extension method.

If the extended type has a method with the same signature as an extension method, the instance method will always take precedence. Extension methods are only called when there is no matching instance method.

Real-Life Examples of Extension Methods

Now that we understand the basics of extension methods in C#, let's look at some real-life examples.

String Extension Method Word Count

Imagine you want to count the number of words in a string. You can create a WordCount extension method for the string class:

public static class StringExtensions
{
    public static int WordCount(this string input)
    {
        return input.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}
public static class StringExtensions
{
    public static int WordCount(this string input)
    {
        return input.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}
Imports Microsoft.VisualBasic

Public Module StringExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function WordCount(ByVal input As String) As Integer
		Return input.Split( { " "c, ControlChars.Tab, ControlChars.Cr, ControlChars.Lf }, StringSplitOptions.RemoveEmptyEntries).Length
	End Function
End Module
VB   C#

Now, you can easily count the number of words in a string like this:

string text = "Extension methods are awesome!";
int wordCount = text.WordCount();
Console.WriteLine($"The text has {wordCount} words."); // The text has 4 words.
string text = "Extension methods are awesome!";
int wordCount = text.WordCount();
Console.WriteLine($"The text has {wordCount} words."); // The text has 4 words.
Dim text As String = "Extension methods are awesome!"
Dim wordCount As Integer = text.WordCount()
Console.WriteLine($"The text has {wordCount} words.") ' The text has 4 words.
VB   C#

IEnumerable Extension Method Median

Suppose you have a collection of numbers, and you want to calculate the median value. You can create an extension method for IEnumerable:

public static class EnumerableExtensions
{
    public static double Median(this IEnumerable source)
    {
        int[] sorted = source.OrderBy(x => x).ToArray();
        int count = sorted.Length;

        if (count == 0)
        {
            throw new InvalidOperationException("The collection is empty.");
        }

        if (count % 2 == 0)
        {
            return (sorted[count / 2 - 1] + sorted[count / 2]) / 2.0;
        }
        else
        {
            return sorted[count / 2];
        }
    }
}
public static class EnumerableExtensions
{
    public static double Median(this IEnumerable source)
    {
        int[] sorted = source.OrderBy(x => x).ToArray();
        int count = sorted.Length;

        if (count == 0)
        {
            throw new InvalidOperationException("The collection is empty.");
        }

        if (count % 2 == 0)
        {
            return (sorted[count / 2 - 1] + sorted[count / 2]) / 2.0;
        }
        else
        {
            return sorted[count / 2];
        }
    }
}
Public Module EnumerableExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function Median(ByVal source As IEnumerable) As Double
		Dim sorted() As Integer = source.OrderBy(Function(x) x).ToArray()
		Dim count As Integer = sorted.Length

		If count = 0 Then
			Throw New InvalidOperationException("The collection is empty.")
		End If

		If count Mod 2 = 0 Then
			Return (sorted(count \ 2 - 1) + sorted(count \ 2)) / 2.0
		Else
			Return sorted(count \ 2)
		End If
	End Function
End Module
VB   C#

With this extension method, you can easily find the median value of a collection:

int[] numbers = { 5, 3, 9, 1, 4 };
double median = numbers.Median();
Console.WriteLine($"The median value is {median}."); // The median value is 4.
int[] numbers = { 5, 3, 9, 1, 4 };
double median = numbers.Median();
Console.WriteLine($"The median value is {median}."); // The median value is 4.
Dim numbers() As Integer = { 5, 3, 9, 1, 4 }
Dim median As Double = numbers.Median()
Console.WriteLine($"The median value is {median}.") ' The median value is 4.
VB   C#

DateTime Extension Method StartOfWeek

Let's say you want to find the start of the week for a given date. You can create an extension method for the DateTime struct:

public static class DateTimeExtensions
{
    public static DateTime StartOfWeek(this DateTime dt, DayOfWeek startOfWeek = DayOfWeek.Monday)
    {
        int diff = (7 + (dt.DayOfWeek - startOfWeek)) % 7;
        return dt.AddDays(-1 * diff).Date;
    }
}
public static class DateTimeExtensions
{
    public static DateTime StartOfWeek(this DateTime dt, DayOfWeek startOfWeek = DayOfWeek.Monday)
    {
        int diff = (7 + (dt.DayOfWeek - startOfWeek)) % 7;
        return dt.AddDays(-1 * diff).Date;
    }
}
Public Module DateTimeExtensions
'INSTANT VB NOTE: The parameter startOfWeek was renamed since Visual Basic will not allow parameters with the same name as their enclosing function or property:
	<System.Runtime.CompilerServices.Extension> _
	Public Function StartOfWeek(ByVal dt As DateTime, Optional ByVal startOfWeek_Conflict As DayOfWeek = DayOfWeek.Monday) As DateTime
		Dim diff As Integer = (7 + (dt.DayOfWeek - startOfWeek_Conflict)) Mod 7
		Return dt.AddDays(-1 * diff).Date
	End Function
End Module
VB   C#

Now, you can easily find the start of the week for any date:

DateTime today = DateTime.Today;
DateTime startOfWeek = today.StartOfWeek();
Console.WriteLine($"The start of the week is {startOfWeek.ToShortDateString()}."); // The start of the week is 05/08/2023.
DateTime today = DateTime.Today;
DateTime startOfWeek = today.StartOfWeek();
Console.WriteLine($"The start of the week is {startOfWeek.ToShortDateString()}."); // The start of the week is 05/08/2023.
Dim today As DateTime = DateTime.Today
Dim startOfWeek As DateTime = today.StartOfWeek()
Console.WriteLine($"The start of the week is {startOfWeek.ToShortDateString()}.") ' The start of the week is 05/08/2023.
VB   C#

Generating PDFs with IronPDF and Extension Methods

In this section, we'll introduce IronPDF, a popular library for generating and working with PDF files in C#. We'll also see how we can leverage extension methods to create a more seamless and intuitive experience when working with this library.

Installing IronPDF

First, you need to install the IronPDF NuGet package. In your project folder, run the following command:

PM > Install-Package IronPdf

This will install the latest version of the IronPDF package.

Creating a Simple PDF

Before we dive into extension methods, let's see how to create a simple PDF from HTML using IronPDF:

using IronPDF;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderHtmlAsPdf("Hello, World!");
        PDF.SaveAs("HelloWorld.PDF");
    }
}
using IronPDF;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderHtmlAsPdf("Hello, World!");
        PDF.SaveAs("HelloWorld.PDF");
    }
}
Imports IronPDF

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim PDF = renderer.RenderHtmlAsPdf("Hello, World!")
		PDF.SaveAs("HelloWorld.PDF")
	End Sub
End Class
VB   C#

This code snippet creates a PDF with the text "Hello, World!" and saves it to a file named "HelloWorld.PDF".

Extension Methods for IronPDF

Now, let's explore how we can use extension methods to enhance the functionality of IronPDF and make it easier to work with. For instance, we can create an extension method that takes an instance of the string class and generates a PDF directly from it.

public static class StringExtensions
{
    public static void SaveAsPdf(this string htmlContent, string filePath)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderHtmlAsPdf(htmlContent);
        PDF.SaveAs(filePath);
    }
}
public static class StringExtensions
{
    public static void SaveAsPdf(this string htmlContent, string filePath)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderHtmlAsPdf(htmlContent);
        PDF.SaveAs(filePath);
    }
}
Public Module StringExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Sub SaveAsPdf(ByVal htmlContent As String, ByVal filePath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim PDF = renderer.RenderHtmlAsPdf(htmlContent)
		PDF.SaveAs(filePath)
	End Sub
End Module
VB   C#

With this extension method, we can now generate a PDF directly from a string:

string html = "Extension Methods and IronPDFGenerating PDFs has never been easier!";
html.SaveAsPdf("ExtensionMethodsAndIronPDF.PDF");
string html = "Extension Methods and IronPDFGenerating PDFs has never been easier!";
html.SaveAsPdf("ExtensionMethodsAndIronPDF.PDF");
Dim html As String = "Extension Methods and IronPDFGenerating PDFs has never been easier!"
html.SaveAsPdf("ExtensionMethodsAndIronPDF.PDF")
VB   C#

Generating PDFs from URLs

Another useful extension method we can create is one that generates a PDF from a URL. We can extend the Uri class to achieve this:

public static class UriExtensions
{
    public static void SaveAsPdf(this Uri url, string filePath)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderUrlAsPdf(url.AbsoluteUri);
        PDF.SaveAs(filePath);
    }
}
public static class UriExtensions
{
    public static void SaveAsPdf(this Uri url, string filePath)
    {
        var renderer = new ChromePdfRenderer();;
        var PDF = renderer.RenderUrlAsPdf(url.AbsoluteUri);
        PDF.SaveAs(filePath);
    }
}
Public Module UriExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Sub SaveAsPdf(ByVal url As Uri, ByVal filePath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim PDF = renderer.RenderUrlAsPdf(url.AbsoluteUri)
		PDF.SaveAs(filePath)
	End Sub
End Module
VB   C#

Now, we can easily generate a PDF from a URL like this:

Uri url = new Uri("https://www.ironpdf.com/");
url.SaveAsPdf("UrlToPdf.PDF");
Uri url = new Uri("https://www.ironpdf.com/");
url.SaveAsPdf("UrlToPdf.PDF");
Dim url As New Uri("https://www.ironpdf.com/")
url.SaveAsPdf("UrlToPdf.PDF")
VB   C#

C# Extension Methods (How It Works For Developers) Figure 1

Conclusion

In this tutorial, we explored the concept of extension methods in C#, learned how to implement them using static methods and static classes, and saw real-life examples for various types. Furthermore, we introduced IronPDF, a library for generating and working with PDF files in C#. By combining the power of extension methods and IronPDF, we can create a more intuitive and seamless experience when working with PDF files in C# projects.

It's worth mentioning that IronPDF offers a 30-day free trial, allowing you to evaluate its features and capabilities without any commitment. If you decide that IronPDF is the right solution for your project, licensing starts from $749,

Keep in mind the guidelines and limitations of extension methods as you incorporate them into your projects. As you start using extension methods and IronPDF together, you'll see how much cleaner, more readable, and more efficient your code can become.