C # - Metodi

Un metodo è un gruppo di istruzioni che insieme eseguono un'attività. Ogni programma C # ha almeno una classe con un metodo denominato Main.

Per utilizzare un metodo, è necessario:

• Definisci il metodo
• Chiama il metodo

Definizione di metodi in C #

Quando definisci un metodo, in pratica dichiari gli elementi della sua struttura. La sintassi per la definizione di un metodo in C # è la seguente:

<Access Specifier> <Return Type> <Method Name>(Parameter List) {
   Method Body
}

Di seguito sono riportati i vari elementi di un metodo:

• Access Specifier - Questo determina la visibilità di una variabile o di un metodo di un'altra classe.

• Return type- Un metodo può restituire un valore. Il tipo restituito è il tipo di dati del valore restituito dal metodo. Se il metodo non restituisce alcun valore, il tipo restituito èvoid.

• Method name- Il nome del metodo è un identificatore univoco e distingue tra maiuscole e minuscole. Non può essere uguale a qualsiasi altro identificatore dichiarato nella classe.

• Parameter list- Racchiusi tra parentesi, i parametri vengono utilizzati per trasmettere e ricevere dati da un metodo. L'elenco dei parametri si riferisce al tipo, all'ordine e al numero dei parametri di un metodo. I parametri sono opzionali; ovvero, un metodo non può contenere parametri.

• Method body - Contiene il set di istruzioni necessarie per completare l'attività richiesta.

Esempio

Il seguente frammento di codice mostra una funzione FindMax che accetta due valori interi e restituisce il maggiore dei due. Ha un identificatore di accesso pubblico, quindi è possibile accedervi dall'esterno della classe utilizzando un'istanza della classe.

class NumberManipulator {

   public int FindMax(int num1, int num2) {
      /* local variable declaration */
      int result;

      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result;
   }
   ...
}

Chiamata di metodi in C #

È possibile chiamare un metodo utilizzando il nome del metodo. Il seguente esempio lo illustra:

using System;

namespace CalculatorApplication {
   class NumberManipulator {
      public int FindMax(int num1, int num2) {
         /* local variable declaration */
         int result;
         
         if (num1 > num2)
            result = num1;
         else
            result = num2;
         return result;
      }
      
      static void Main(string[] args) {
         /* local variable definition */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();

         //calling the FindMax method
         ret = n.FindMax(a, b);
         Console.WriteLine("Max value is : {0}", ret );
         Console.ReadLine();
      }
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Max value is : 200

È inoltre possibile chiamare il metodo pubblico da altre classi utilizzando l'istanza della classe. Ad esempio, il metodo FindMax appartiene alla classe NumberManipulator , puoi chiamarlo da un'altra classe Test .

using System;

namespace CalculatorApplication {
   class NumberManipulator {
      public int FindMax(int num1, int num2) {
         /* local variable declaration */
         int result;
         
         if(num1 > num2)
            result = num1;
         else
            result = num2;
         
         return result;
      }
   }
   class Test {
      static void Main(string[] args) {
         /* local variable definition */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();
         
         //calling the FindMax method
         ret = n.FindMax(a, b);
         Console.WriteLine("Max value is : {0}", ret );
         Console.ReadLine();
      }
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Max value is : 200

Richiamo del metodo ricorsivo

Un metodo può chiamare se stesso. Questo è noto comerecursion. Di seguito è riportato un esempio che calcola fattoriale per un dato numero utilizzando una funzione ricorsiva:

using System;

namespace CalculatorApplication {
   class NumberManipulator {
      public int factorial(int num) {
         /* local variable declaration */
         int result;
         if (num == 1) {
            return 1;
         } else {
            result = factorial(num - 1) * num;
            return result;
         }
      }
      static void Main(string[] args) {
         NumberManipulator n = new NumberManipulator();
         //calling the factorial method {0}", n.factorial(6));
         Console.WriteLine("Factorial of 7 is : {0}", n.factorial(7));
         Console.WriteLine("Factorial of 8 is : {0}", n.factorial(8));
         Console.ReadLine();
      }
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Factorial of 6 is: 720
Factorial of 7 is: 5040
Factorial of 8 is: 40320

Passaggio di parametri a un metodo

Quando viene chiamato il metodo con parametri, è necessario passare i parametri al metodo. Ci sono tre modi in cui i parametri possono essere passati a un metodo:

Sr.No.	Meccanismo e descrizione
1	Parametri di valore Questo metodo copia il valore effettivo di un argomento nel parametro formale della funzione. In questo caso, le modifiche apportate al parametro all'interno della funzione non hanno effetto sull'argomento.
2	Parametri di riferimento Questo metodo copia il riferimento alla posizione di memoria di un argomento nel parametro formale. Ciò significa che le modifiche apportate al parametro influiscono sull'argomento.
3	Parametri di output Questo metodo aiuta a restituire più di un valore.