Блог

Я создаю библиотеку C # с некоторым повторно используемым кодом и пытался создать метод внутри метода. У меня есть такой метод:

 public static void Method1()
{
   // Code
}
 

Что я хотел бы сделать, так это:

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

Тогда я мог бы выбрать либо Method1.Method2 или Method1.Method3 . Очевидно, что компилятор недоволен этим, любая помощь очень ценится. Спасибо.

Если под вложенным методом вы подразумеваете метод, который вызывается только внутри этого метода (например, в 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);
}
 

Да, когда 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;
}
 

Обратите внимание, что public (и подобные модификаторы) не поддерживаются руководством по программированию на C #:

Поскольку все локальные функции являются частными, включая модификатор доступа, такой как ключевое слово private, генерирует ошибку компилятора CS0106, «

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

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

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

        public static void Method3()
        {
        }
    }
}
 

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

 ContainingClass.NestedClass.Method2();
 

или

 ContainingClass.NestedClass.Method3();
 

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

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

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

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

}
 

Начиная с C # 7.0, вы можете это сделать:

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

     Hi();
 }
 

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

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

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

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

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

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

 Helper.MethodA();
 

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

     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
    }
 

Вы почти там

 public static void Method1()
 

должно быть

 public static class Method1{}
 

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

Тем не менее, вы, похоже, не соблюдаете принцип единой ответственности, потому что хотите, чтобы один метод выполнял более одной задачи одновременно.

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

public void M1() { ДЕЛАТЬ ВЕЩИ}

public void M1() { ДЕЛАТЬ ВЕЩИ M1(); }