'How to call an extension method without using

using System;

class Runner
{
    static void Main()
    {
        A a = new A();
        // how to say a.PrintStuff() without a 'using'
        Console.Read();
    }
}

class A { }

namespace ExtensionMethod
{
    static class AExtensions
    {
        public static void PrintStuff(this A a)
        {
            Console.WriteLine("text");
        }
    }
}

How would I call the extension method without a 'using'? And not ExtensionMethod.AExtensions.PrintStuff(a), since that doesn't make use of extension method.

c++sharp


Solution 1:[1]

It is possible to directly call your extension like so since it is simply a static method, passing the instance it will act on as the first this parameter:

A a = new A();
ExtensionMethod.AExtensions.PrintStuff(a);

This might be confusing to other developers who happen across this code if you followed this pattern for more commonly used extension methods. It would also make chaining extension calls such as LINQ appear more like a functional language because you would be nesting each call instead of chaining them.

Solution 2:[2]

that is possible if Extension Method and class A in same namespace,

If you have to use different namespaces then you have to use using, i don't think there is a way to do this without using. But you may reduce the number of using by putting all the extensions in one namespace like for Linq (System.Linq.Extensions)

Note : You can remove the namespace for Extension methods, then it will make them globally available

Solution 3:[3]

It needs the using to know where the function lives. One example of this in Linq. Without the System.Linq using - you won't have linq enabled for any of your IEnumerable<T>'s

However, you can define the extension method in the same namespace as the caller to avoid putting in a using. This approach will however not work if it's needed in many namespaces

Solution 4:[4]

This makes me feel dirty, but you can put your extension methods in the System namespace. This namespace is included by default in your question

using System;

class Runner
{
    static void Main()
    {
        A a = new A();
        // how to say a.PrintStuff() without a 'using'
        Console.Read();
    }
}

class A { }

namespace System
{
    static class AExtensions
    {
        public static void PrintStuff(this A a)
        {
            Console.WriteLine("text");
        }
    }
}

Solution 5:[5]

Ruminations on the creation of extension methods for a type ExtendableType:

  • Name the class ExtendableTypeExtensions
  • Declare the extension class partial so that clients can add extension methods following the same pattern; and
  • Put the extension methods in the same namespace as the base type

unless you have a very good reason to follow a model like that of LINQ:

  • A substantial family of extension methods,
  • That all apply to multiple base classes.

Solution 6:[6]

You can add extensions method without namespace. This will affect the whole systems which is not recommended.

public static class StringExtensions
{       
    public static void HelloWorld(this String s)
    {
        Console.Write("Hello World");
    }
}



    string str = "s";
    str.HelloWorld();

Solution 7:[7]

In our projects extensions are placed in the same namespace as class extension for. Your example:

A.cs:
using System;
namespace ANamespace
{

     class A { }
}

AExtensions.cs:
namespace ANamespace
{
    static class AExtensions
    {
        public static void PrintStuff(this A a)
        {
            Console.WriteLine("text");
        }
    }
}

Now when you add using for ANamespace for using the A class, all extensions for A class will be included too.

Solution 8:[8]

As of C# v6.0 (circa 2015) you can use using static to access a specific class's static members without including it's whole namespace.

An example, using your code, would be:

using System;
using static ExtensionMethod.AExtensions;

class Runner
{
    static void Main()
    {
        A a = new A();
        a.PrintStuff();
        Console.Read();
    }
}

class A { }

namespace ExtensionMethod
{
    static class AExtensions
    {
        public static void PrintStuff(this A a)
        {
            Console.WriteLine("text");
        }
    }
}

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1 AaronLS
Solution 2
Solution 3 TGH
Solution 4 David Colwell
Solution 5 Pieter Geerkens
Solution 6 code4j
Solution 7 zabulus
Solution 8 Akaoni

Related Questions