Метод внутри метода

Ответ 1

Этот ответ был написан до выхода С# 7. С С# 7 вы можете написать локальные методы.

Нет, вы не можете этого сделать. Вы можете создать вложенный класс:

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

        public static void Method3()
        {
        }
    }
}

Затем вы вызывали:

ContainingClass.NestedClass.Method2();

или

ContainingClass.NestedClass.Method3();

Я бы не рекомендовал этого. Обычно это плохая идея иметь общедоступные вложенные типы.

Можете ли вы рассказать нам больше о том, чего вы пытаетесь достичь? Там может быть лучший подход.

Ответ 2

Если по вложенному методу вы имеете в виду метод, который может быть вызван только в этом методе (например, в Delphi), вы можете использовать делегатов.

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);
}

Ответ 3

Да, когда C# 7.0 будет выпущен, Локальные функции позволит вам это сделать. Вы сможете использовать метод внутри метода:

public int GetName(int userId)
{
    int GetFamilyName(int id)
    {
        return User.FamilyName;
    }

    string firstName = User.FirstName;
    var fullName = firstName + GetFamilyName(userId);

    return fullName;
}

Ответ 4

Вы можете определить делегатов в своем методе с полным кодом и вызвать их, если хотите.

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);

   }
}

Всегда существует альтернатива использованию вложенного класса внутри класса, который не будет видимым снаружи и вызовет его методы, например:

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

    public void Method1 ()
    {
      HelperClass.Method2();
    }

}

Ответ 5

С С# 7.0 вы можете сделать это:

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

     Hi();
 }

Это называется локальными функциями, это именно то, что вы искали.

Я привел пример из здесь, но дальнейший информатив можно найти здесь и здесь.

Ответ 6

Почему вы не используете классы?

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

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

Теперь вы можете получить метод MethodA через

Helper.MethodA();

Ответ 7

Твой почти там

public static void Method1()

должен быть

public static class Method1{}

Ответ 8

Разве вы не хотите использовать вложенный класс?

Тем не менее, вы, похоже, не уважаете принцип Single Responsibility Principle, потому что вы хотите, чтобы один метод выполнял несколько операций одновременно.

Ответ 9

Старый поток, но у С# есть понятие вложенных функций

    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
    }

Ответ 10

Почему бы вам просто не запустить метод в другом

public void M1() { DO STUFF }

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