Where do I put my extension method?

Question

A senior member here gave me this code:

public static string Truncate(this string value, int maxChars)
{
    return value.Length <= maxChars ? value : value.Substring(0, maxChars) + " ..";
}

He said to use it as an extension method. But where do I put this method? It looks like it adds something to .Net

Answer 1

Consider a class named StringExtensions like so:

static class StringExtensions {
    public static string Truncate(this string value, int maxChars) {
        return value.Length <= maxChars ? 
               value : 
               value.Substring(0, maxChars) + " ..";
    }
}

Be sure that whatever namespace you put this class in, you include a using declaration for that namespace.

Thus, for a full example:

StringExtensions.cs:

namespace My.Extensions {
    static class StringExtensions {
        public static string Truncate(this string value, int maxChars) {
            return value.Length <= maxChars ?
                   value :
                   value.Substring(0, maxChars) + " ..";
        }
    }
}

Program.cs:

using System;
using My.Extensions;

namespace My.Program {
    static class Program {
        static void Main(string[] args) {
            string s = "Hello, World";
            string t = s.Truncate(5);
            Console.WriteLine(s);
            Console.WriteLine(t);
        }
    }
}

By the way, you are not adding it to .NET. You are not even adding a new method to the class String. Rather, it's a compiler trick that makes static methods living in static classes with their first parameter declared as this *TypeName* *valueParameter* where *TypeName* is the name of a type, and *valueParameter* is the name of the parameter can be made to appear as an instance method on instances of the type with type name *TypeName*. That is

string t = s.Truncate(5);

is translated by the compiler into

string t = StringExtensions.Truncate(s, 5);

Answer 2

Put it in a static class, and use using on its namespace.

e.g.

namespace Foo
{
    static class Extensions
    {
        public static string Truncate(this string value, int maxChars)
        {
            return value.Length <= maxChars ?
                value : value.Substring(0, maxChars) + " ..";
        }
    }
}

And then in a different file:

using Foo;  //Don't forget this!

class Tester
{
    static void Test()
    {
        Console.WriteLine("123456".Truncate(3));
    }
}

Answer 3

Yes, use a static class. I organize in a separate project that I can use across solutions. I also organize in separate files grouped by what I'm extending such as strings, enums, io, datetime, etc

Answer 4

In addition to other answers: yes, it's a kind of extending .NET. More strictly speaking, extending already compiled classes. You can "add" methods to the classes which are not accessible for your modification. From the internal point of view, it's just a syntactic sugar: your methods cannot be seen by reflection. But for the users of your extension, it looks as if the methods were really added to the target class (well, with some distinctions).

The possibility to influence in some way the code that is already written is an essential part of object-oriented approach. In almost any OO language you can derive from some existing class and add some functionality to it this way (although this is not the preferred way for code reusing). In Objective C, you can modify existing classes using categories at compile time. In JavaScript, you can modify them even at runtime, using prototype.

As C# is not such a dynamic language as JavaScript is, modifying the existing classes is available in a somewhat limited form of extension methods.