Method Within A Method

I am creating a C# library with some reusable code and was trying to create a method inside a method. I have a method like this:

public static void Method1()
{
   // Code
}

What I would like to do is this:

public static void Method1()
{
   public static void Method2()
   {
   }
   public static void Method3()
   {
   }
}

Then I could choose either Method1.Method2 or Method1.Method3. Obviously the compiler isn't happy about this, any help is much appreciated. Thanks.

If by nested method, you mean a method that is only callable within that method (like in Delphi) you could use delegates.

public static void Method1()
{
   var method2 = new Action(() => { /* action body */ } );
   var method3 = new Action(() => { /* action body */ } );

   //call them like normal methods
   method2();
   method3();

   //if you want an argument
   var actionWithArgument = new Action<int>(i => { Console.WriteLine(i); });
   actionWithArgument(5);
  
   //if you want to return something
   var function = new Func<int, int>(i => { return i++; });
   int test = function(6);
}

Yes, when C# 7.0 is released, Local Functions will allow you to do that. You will be able to have a method, inside a method as:

public int GetName(int userId)
{
    int GetFamilyName(int id)
    {
        return User.FamilyName;
    }
    
    string firstName = User.FirstName;
    var fullName = firstName + GetFamilyName(userId);

    return fullName;
}

Note that public (and similar modifiers) are not supported C# programming guide: >Because all local functions are private, including an access modifier, such as the private keyword, generates compiler error CS0106, "

This answer was written before C# 7 came out. With C# 7 you can write local methods.

No, you can't do that. You could create a nested class:

public class ContainingClass
{
    public static class NestedClass
    {
        public static void Method2()
        {
        } 

        public static void Method3()
        {
        }
    }
}

You'd then call:

ContainingClass.NestedClass.Method2();

or

ContainingClass.NestedClass.Method3();

I wouldn't recommend this though. Usually it's a bad idea to have public nested types.

Can you tell us more about what you're trying to achieve? There may well be a better approach.

You can define delegates within your method with complete code and call them if you want.

public class MyMethods
{
   public void Method1()
   {
     // defining your methods 
	 
     Action method1 = new Action( () => 
	  { 
	     Console.WriteLine("I am method 1");
		 Thread.Sleep(100);
		 var b = 3.14;
		 Console.WriteLine(b);
	  }
	 ); 

     Action<int> method2 = new Action<int>( a => 
	  { 
	     Console.WriteLine("I am method 2");
		 Console.WriteLine(a);
	  }
	 ); 

	 Func<int, bool> method3 = new Func<int, bool>( a => 
	  { 
	     Console.WriteLine("I am a function");
		 return a > 10;
	  }
	 ); 

	 
	 // calling your methods

	 method1.Invoke();
	 method2.Invoke(10);
	 method3.Invoke(5);
	
   }
}

There is always an alternative of using a nested class within a class that will not be visible from outside and calling its methods, like:

public class SuperClass
{
    internal static class HelperClass
	{
	  internal static void Method2() {}
	}
  
    public void Method1 ()
	{
	  HelperClass.Method2();
	}

}

As of C# 7.0 you can do that:

 public static void SlimShady()
 {
     void Hi([CallerMemberName] string name = null)
     {
         Console.WriteLine($"Hi! My name is {name}");
     }

     Hi();
 }

> This is called local functions, that is just what you were looking for.

I took the example from here, but further informatin can be found here and here.

Why you don't use classes?

public static class Helper
    {
        public static string MethodA()
        {
            return "A";
        }

        public static string MethodA()
        {
            return "A";
        }
    }

Now you can acces MethodA via

Helper.MethodA();

Older thread, but C# does have the concept of nested functions

    Func<int> getCalcFunction(int total, bool useAddition)
    {
        int overallValue = 0;
        if (useAddition)
        {
            Func<int> incrementer = new Func<int>(() =>
            {
                overallValue += total;
                return overallValue;
            });
            return incrementer;
        }
        else
        {
            Func<int> decrementer = new Func<int>(() =>
            {
                overallValue -= total;
                return overallValue;
            });
            return decrementer;
        }
    }
    private void CalcTotals()
    {
        Func<int> decrem = getCalcFunction(30, false);
        int a = decrem(); //result = -30
        a = decrem(); //result = -60

        Func<int> increm = getCalcFunction(30, true);
        int b = increm(); //result = 30
        b = increm(); //result = 60
    }

Your nearly there

public static void Method1()

should be

public static class Method1{}

Don't you want to use nested class instead?

That's said, you seem to not respect the Single Responsibility Principle because you want a single method do more than one thing at a time.

Why don't you just Run a method within another

public void M1() { DO STUFF }

public void M1() { DO STUFF M1(); }