creating an alias for a function name in C#

Question

I want to create an alias for a funcion name in C#.

Is there any way but function overloading?

public class Test
{
    public void A()
    {
        ...
    }
}

I want to call B replace A same below.

var test = new Test();
test.B();

Answer 1

You can use an extension method

public static class Extensions 
{
    public static void B(this Test t)
    {
       t.A();
    }
}

But it is not an alias. It is a wrapper.

---

EDIT
ps: I agree with the commenters on your question that we'd be able to give better answers if we knew what you really wanted to do, if we understood the problem you're trying to solve.

I don't really see the point of producing the above extension method.

Answer 2

C# is object oriented language, so you cant create "alias for function". You can only manipulate with classes. As it was mentioned, you can extend class with extension method, you also can create derived class and create new method in it, which would call derived method:

    class Test
    {
        public void A()
        {
            MessageBox.Show("Function A");
        }
    }

    class Test2: Test
    {
        public void B()
        {
            A();
        }
    }

But if you desire to call B() on your initial class Test you have only one way - creation of extension method.

Answer 3

This works.

class Program
{
    delegate void B();
    static Test t = new Test();
    static B b = t.A;

    static void Main(string[] args)
    {
        b();
    }

}

class Test
{
    public void A()
    {
    }
}

Answer 4

This is so old, but I have a response as to why a person may want to alias a method name. It happens all the time. Because some developer has given a method a name that does not make any sense or it simply does not accurately describe the purpose of the method. The method is called many times throughout an old, well-seasoned solution. So rather performing a large refactoring and retesting that cannot be justified because of a poorly named method, simply give it an alias that makes sense. That way new code will read properly in the future.

i.e. A grid control is saved, and there is a method name IsReferenceSelectedSendEmail. The name implies that the method will identify if the user selected reference in the grid is SendEmail. What the method really does is iterate over all the references and identifies if any one of them is SendEmail.

Simple solution. Alias the method as AnyReferenceIsSendEmail so that future code will read properly: if ( AnyReferenceIsSendEmail() )...

Now, if we can just get a keyword "unless" to negate an if condition.

IMO

Answer 5

I'm surprised that noone has mentioned Delegates. It's probably as close to a method alias as you will come in C#:

class DelegaTest
{
    public string F()
    {
        return null;
    }

    public string F(int arg)
    {
        return arg.ToString();
    }

    public void G(int arg1, int arg2)
    {
    }

    /// <summary>
    /// Delegate for `string F()`
    /// </summary>
    public Func<string> D1 => F;

    /// <summary>
    /// Delegate for `string F(int arg)`
    /// </summary>
    public Func<int, string> D2 => F;

    /// <summary>
    /// Delegate for `void G(int arg1, int arg2)`
    /// </summary>
    public Action<int, int> E => G;
}

Answer 6

Actually function aliases are more of delegates in C# terminology (like function pointers in C++). Here is one:

public class Test
{
    public void Test()
    {
        B += A;
    }

    public void A()
    {
        ...
    }

    public Action B;
}

But you'll have to call this as B.Invoke() as it is parameterless. If it had one or more parameters, this wouldn't be a problem.