CODEWITHSUNDEEP
c#extension-methodsencapsulation
David
David

Reputation: 219037

Can There Be Private Extension Methods?

Let's say I have a need for a simple private helper method, and intuitively in the code it would make sense as an extension method. Is there any way to encapsulate that helper to the only class that actually needs to use it?

For example, I try this:

class Program
{
    static void Main(string[] args)
    {
        var value = 0;
        value = value.GetNext(); // Compiler error
    }

    static int GetNext(this int i)
    {
        return i + 1;
    }
}

The compiler doesn't "see" the GetNext() extension method. The error is:

Extension method must be defined in a non-generic static class

Fair enough, so I wrap it in its own class, but still encapsulated within the object where it belongs:

class Program
{
    static void Main(string[] args)
    {
        var value = 0;
        value = value.GetNext(); // Compiler error
    }

    static class Extensions
    {
        static int GetNext(this int i)
        {
            return i + 1;
        }
    }
}

Still no dice. Now the error states:

Extension method must be defined in a top-level static class; Extensions is a nested class.

Is there a compelling reason for this requirement? There are cases where a helper method really should be privately encapsulated, and there are cases where the code is a lot cleaner and more readable/supportable if a helper method is an extension method. For cases where these two intersect, can both be satisfied or do we have to choose one over the other?

Upvotes: 71

Views: 28534

Answers (8)

pasx
pasx

Reputation: 2985

Here is my use case:

namespace UnitTests.SomeNameSpace
{
    [TestFixture]
    public class SomeTests
    {
        //Extension on IEnumerable<SomeStuff> can be used here...
    }
    
    static class NameSpaceExtensions
    {
        public static int SomeExtension(this IEnumerable<SomeStuff> stuffs) => ...;
    }
}

The goal is to have extensions that are visible to one test namespace only so they can be very specific to a series of tests e.g. return an incremented Id from the last item in a specific collection or asserting the content of the collection. Not something you want to expose in the whole test solution.

The documentation says extension methods should live in non generic static classes but says nothing about them being public. It shows examples of private extension classes here.

Upvotes: -1

Darian Lehmann-Plantenberg
Darian Lehmann-Plantenberg

Reputation: 49

For anyone coming here that may be looking for an actual answer, it is YES.

You can have private extension methods and here is an example that I am using in a Unity project I am working on right now:

[Serializable]
public class IMovableProps
{
    public Vector3 gravity = new Vector3(0f, -9.81f, 0f);
    public bool isWeebleWobble = true;
}

public interface IMovable
{
    public Transform transform { get; }
    public IMovableProps movableProps { get; set; }
}

public static class IMovableExtension
{
    public static void SetGravity(this IMovable movable, Vector3 gravity)
    {
        movable.movableProps.gravity = gravity;
        movable.WeebleWobble();
    }

    private static void WeebleWobble(this IMovable movable)
    {
        //* Get the Props object
        IMovableProps props = movable.movableProps;
        //* Align the Transform's up to be against gravity if isWeebleWobble is true
        if (props.isWeebleWobble)
        {
            movable.transform.up = props.gravity * -1;
        }
    }
}

I obviously trimmed down quite a bit, but the gist is that this compiles and runs as expected AND it makes sense because I want the extension method to have Access to the WeebleWobble functionality but I don't want it exposed anywhere outside of the static class. I COULD very well configure the WeebleWobble to work in the IMovableProps class but this is just to simply demonstrate that this is possible!

EDIT: If you have Unity and want to test this here is a MonoBehaviour to test it with (This will not actually apply gravity obviously, but it should change the rotation when you check the inverseGravity box in the inspector during play mode)

public class WeebleWobbleTest : MonoBehaviour, IMovable
{
    public bool inverseGravity;
    private IMovableProps _movableProps;
    public IMovableProps movableProps { get => _movableProps; set => _movableProps = value; }

    void Update()
    {
        if (inverseGravity)
        {
            this.SetGravity(new Vector3(0f, 9.81f, 0f);
        }
        else
        {
            this.SetGravity(new Vector3(0f, -9.81f, 0f);
        }
    }
}

Upvotes: 3

beatcoder
beatcoder

Reputation: 723

While the question is corretly answered by Alexei Levenkov I would add a simple example. Since the extension methods - if they are private - has no much point, because unreachable outside the containing extension class, you can place them in a custom namespace, and use that namespace only in your own (or any other) namespaces, this makes the extension methods unreachable globally.

namespace YourOwnNameSpace
{
    using YourExtensionNameSpace;

    static class YourClass
    {
        public static void Test()
        {
            Console.WriteLine("Blah".Bracketize());
        }
    }
}

namespace YourOwnNameSpace
{
    namespace YourExtensionNameSpace
    {
        static class YourPrivateExtensions
        {
            public static string Bracketize(this string src)
            {
                return "{[(" + src + ")]}";
            }
        }
    }
}

You have to define your namespace twice, and nest your extension namespace inside the other, not where your classes are, there you have to use it by using. Like this the extension methods will not be visible where you are not using it.

Upvotes: 1

Eric Lippert
Eric Lippert

Reputation: 660445

Is there a compelling reason for this requirement?

That's the wrong question to ask. The question asked by the language design team when we were designing this feature was:

Is there a compelling reason to allow extension methods to be declared in nested static types?

Since extension methods were designed to make LINQ work, and LINQ does not have scenarios where the extension methods would be private to a type, the answer was "no, there is no such compelling reason".

By eliminating the ability to put extension methods in static nested types, none of the rules for searching for extension methods in static nested types needed to be thought of, argued about, designed, specified, implemented, tested, documented, shipped to customers, or made compatible with every future feature of C#. That was a significant cost savings.

Upvotes: 66

Bearcat9425
Bearcat9425

Reputation: 1608

This is taken from an example on microsoft msdn. Extesnion Methods must be defined in a static class. See how the Static class was defined in a different namespace and imported in. You can see example here http://msdn.microsoft.com/en-us/library/bb311042(v=vs.90).aspx 

namespace TestingEXtensions
{
    using CustomExtensions;
    class Program
    {
        static void Main(string[] args)
        {
            var value = 0;
            Console.WriteLine(value.ToString()); //Test output
            value = value.GetNext(); 
            Console.WriteLine(value.ToString()); // see that it incremented
            Console.ReadLine();
        }
    }
}

namespace CustomExtensions 
{
    public static class IntExtensions
    {
        public static int GetNext(this int i)
        {
            return i + 1;
        }
    }
}

Upvotes: -4

Alexei Levenkov
Alexei Levenkov

Reputation: 100565

I believe the best you can get in general case is internal static class with internal static extension methods. Since it will be in your own assembly the only people you need to prevent usage of the extension are authors of the assembly - so some explicitly named namespace (like My.Extensions.ForFoobarOnly) may be enough to hint to avoid misuse.

The minimal internal restriction covered in implement extension article

The class must be visible to client code ... method with at least the same visibility as the containing class.

Note: I would make extension public anyway to simplify unit testing, but put in some explicitly named namespace like Xxxx.Yyyy.Internal so other users of the assembly would not expect the methods to be supported/callable. Essentially rely on convention other than compile time enforcement.

Upvotes: 32

TyCobb
TyCobb

Reputation: 9089

I believe it is the way they implemented the compiling of the Extensions Methods.

Looking at the IL, it appears that they add some extra attributes to the method.

.method public hidebysig static int32 GetNext(int32 i) cil managed
{
    .custom instance void [System.Core]System.Runtime.CompilerServices.ExtensionAttribute::.ctor()
    .maxstack 2
    .locals init (
        [0] int32 num)
    L_0000: nop 
    L_0001: ldarg.0 
    L_0002: ldc.i4.1 
    L_0003: add 
    L_0004: dup 
    L_0005: starg.s i
    L_0007: stloc.0 
    L_0008: br.s L_000a
    L_000a: ldloc.0 
    L_000b: ret 
}

There is probably some very fundamental that we are missing that just doesn't make it work which is why the restriction is in place. Could also just be that they wanted to force coding practices. Unfortunately, it just doesn't work and has to be in top-level static classes.

Upvotes: 1

Kaveh Shahbazian
Kaveh Shahbazian

Reputation: 13523

This code compiles and works:

static class Program
{
    static void Main(string[] args)
    {
        var value = 0;
        value = value.GetNext(); // Compiler error
    }

    static int GetNext(this int i)
    {
        return i + 1;
    }
}

Pay attention to static class Program line which was what the compiler said is needed.

Upvotes: 2

Related Questions