using System;
namespace Metodi;

internal class Program
{
    private static void Main(string[] args)
    {
        Console.WriteLine("Chiamata a metodo della classe Console.");
    }
}

using System;

namespace Metodi;

internal class Program
{
    private static void Main(string[] args)
    {
        Console.WriteLine("Chiamata a metodo della classe Console.");
        var x = Somma(50, 25);
        Console.WriteLine(x); //75
    }

    //DEFINIZIONE DEL METODO SOMMA
    private static int Somma(int a, int b)
    {
        var result = a + b;
        return result;
    }
}

METODI IN C SHARP

C sharpI  metodi in C Sharp sono una delle più importanti strutture dati nella programmazione Object Oriented detta anche OOP. La funzione di un metodo è quella di racchiudere del codice in un blocco delimitato da parentesi graffe per poter poi essere chiamato o come si dice invocato in altri parti del programma. Un metodo particolare lo abbiamo incontrato tante volte, il metodo Main generato quando creiamo una applicazione Console.

ANALIZZIAMO IN DETTAGLIO IL METODO MAIN

    • Innanzitutto il nome del metodo in questo caso Main ogni metodo per poter essere invocato ha bisogno di un nome. Le regole per l’assegnazione del nome le abbiamo già viste, non deve essere una Keyword riservata del linguaggio e deve iniziare con una lettera maiuscola.
    • Un metodo può accettare dei parametri in ingresso che forniamo quando lo chiamiamo, si pensi ad esempio ad un metodo il cui compito è quello di calcolare la radice quadrata di un numero (Questo è solo un esempio perché il C# mette a disposizione la classe Math per operazioni di questo tipo). Per calcolare la radice quadrata il metodo avrà bisogno del numero su cui vogliamo che avvenga il calcolo, questo viene fornito subito dopo il nome del metodo chiuso tra parentesi tonde. Anche se un metodo non accetta parametri dobbiamo comunque specificare una coppia di parentesi tonde ().Nel codice sopra riportato il nostro metodo Main accetta come parametro di ingresso (i parametri di ingresso possono essere anche più di uno) un array di stringhe chiamato args gli array li vedremo in dettaglio più avanti.
    • Un metodo può restituire un valore, si pensi all’esempio della radice quadrata ovviamente il metodo dopo averla calcolata dovrà restituire il risultato al chiamante. Il tipo restituito precede immediatamente il nome del metodo, nel nostro codice di esempio la parola void sta ad indicare che questo metodo non restituirà alcun valore. Nell’esempio della radice quadrata avremmo messo un double come tipo restituito.
    • La parola chiave static sta ad indicare che questo non sarà un metodo di istanza di un tipo (questo argomento sarà più chiaro quando parleremo delle classi) ma bensì un metodo di classe. Un metodo di classe viene richiamato con la dot notation, ne puoi vedere un esempio nel blocco di codice del metodo Main in cui sulla classe Console seguita da un punto viene richiamato il metodo WriteLine anch’esso statico come puoi vedere.
    • Il blocco di codice racchiuso tra parentesi graffe è uno statement che in ordine eseguirà il metodo, nel nostro caso abbiamo un solo statement.
    • Un metodo deve avere sempre un contenitore superiore che lo racchiude, nell’esempio di codice che ti ho riportato c’è la classe Program che fa da contenitore all’unico metodo che essa racchiude. Un metodo viene anche detto membro di classe o membro di istanza della classe qualora esso venga richiamato sugli oggetti della classe (in questo caso non si usa la parola chiave static).

DEFINIRE E DICHIARARE UN METODO

Ho definito un metodo Somma che prende in input due interi a e b e restituisce un int e non void come abbiamo analizzato nel caso precedente e che rappresenta la somma dei due valori. Le variabili a, b, e result che raccoglie la somma di a e di b, sono variabili locali al metodo, come si suole dire il loro ambito di visibilità (o scope) è limitato nel blocco di codice del metodo Somma, tali variabili non sono visibili all’esterno del metodo. Incontriamo una nuova parola chiave return seguita dalla variabile result.

L’ISTRUZIONE RETURN

Questa istruzione provoca immediatamente la fine del metodo e il ritorno al chiamante cioè nel punto in cui abbiamo invocato il metodo Somma nel Main. Tale istruzione è obbligatoria per i metodi che restituiscono un valore, può esserci oppure no per i metodi che restituiscono void, cioè quelli che non restituiscono un valore. Se non è presente una istruzione return allora il metodo determina all’ultima parentesi graffa che delimita il blocco di codice e torna al chiamante. Nella variabile x viene deposta la somma anch’essa una variabile di tipo intero poi il flusso del programma continua con l’istruzione Console.WriteLine(x); È importante notare che in questo caso non è stata usata la dot notation in quanto somma è un metodo statico definito nella classe Program, tuttavia se vogliamo avere una maggiore chiarezza nel codice possiamo usare la dot notation.

int x = Program.Somma(50,25);

OVERLOAD DI UN METODO

  • La firma di un metodo (o signature) è costituita dal nome del metodo, dal numero e dal tipo di parametri che prende in input e dal tipo di ritorno. Detto ciò noi possiamo introdurre nel programma n metodi chiamati Somma ma con signature diverse, cioè aventi ad esempio tipi di parametri di input diversi. Puoi vedere alcuni esempi nel codice.

METODI RICORSIVI

static void MetodoRicorsivo()

{

           MetodoRicorsivo();

}

Il metodo richiama sé stesso. Dobbiamo stare attenti ad introdurre un caso base, cioè una condizione di test che pone fine alla ricorsione, altrimenti si entrerebbe in un loop infinito che manda in crash il programma.

CODICE VISUAL STUDIO CODE

using System;
namespace Metodi;

internal class Program
{
    private static void Main(string[] args)
    {
        Console.WriteLine("Chiamata a metodo della classe Console.");
        var x = Somma(50, 25);
        Console.WriteLine(x); //75
        var y = Somma(14.1f, 16.9f);
        Console.WriteLine(y);
        var z = Somma(14.1m, 16.9m);
        Console.WriteLine(z);
        Console.Write("Inserisci un numero ");
        var fatt = Convert.ToInt32(Console.ReadLine());
        var fattoriale = Fattoriale(fatt);
        Console.WriteLine($"Il fattoriale di {fatt} è : {fattoriale}");
    }

    //DEFINIZIONE DEL METODO SOMMA
    private static int Somma(int a, int b)
    {
        var result = a + b;
        return result;
    }

    //OVERLOAD DEL METODO SOMMA
    private static float Somma(float a, float b)
    {
        var result = a + b;
        return result;
    }

    //OVERLOAD DEL METODO SOMMA
    private static decimal Somma(decimal a, decimal b)
    {
        var result = a + b;
        return result;
    }

    //METODI RICORSIVI CALCOLARE IL FATTORIALE DI UN NUMERO.
    private static int Fattoriale(int n)
    {
        if (n == 0) //CASO BASE CHE PERMETTE DI USCIRE DAL LOOP.
            return 1;
        return n * Fattoriale(n - 1);
    }

    private static double RadiceQuadrata(int a)
    {
        return Math.Sqrt(a);
    }
}
Calcolo del fattoriale di un numero

APPROFONDIMENTO SUI METODI

I metodi in C# sono blocchi di codice che eseguono operazioni specifiche e possono essere richiamati da altre parti del programma. Sono definiti all’interno delle classi e strutture. Ecco una panoramica dei metodi in C#:

Dichiarazione di un Metodo

Un metodo in C# è dichiarato con un modificatore di accesso, un tipo di ritorno, un nome, e una lista di parametri opzionale. Esempio:

public int Add(int a, int b)
{
  return a + b;
}

Modificatori di Accesso

I modificatori di accesso determinano la visibilità del metodo:

•public: Accessibile da qualsiasi altra parte del codice.

•private: Accessibile solo all’interno della stessa classe.

•protected: Accessibile all’interno della stessa classe e delle classi derivate.

•internal: Accessibile all’interno dello stesso assembly.

•protected internal: Accessibile dall’interno dello stesso assembly o da classi derivate.

Tipi di Ritorno

Il tipo di ritorno specifica il tipo di dato che il metodo restituirà. Se il metodo non restituisce nulla, viene usato void:

public void DisplayMessage()
{
Console.WriteLine(“Hello, World!“);
}

Parametri

I parametri permettono di passare dati ai metodi. Esistono anche parametri opzionali e parametri con params:

public void PrintNumbers(params int[] numbers)
{
    foreach (int number in numbers)
{
Console.WriteLine(number);
}
}

Overloading

C# permette di definire più metodi con lo stesso nome ma con firme diverse (numero o tipo di parametri):

public int Multiply(int a, int b)
{
    return a * b;
}

public double Multiply(double a, double b)
{
   return a * b;
}

Metodi Statici

I metodi statici appartengono alla classe piuttosto che a istanze specifiche e possono essere chiamati senza creare un’istanza della classe:

public static void ShowMessage()
{
Console.WriteLine(“This is a static method.“);
}

Metodi di Estensione

Permettono di aggiungere metodi a tipi esistenti senza modificarli:

public static class StringExtensions
{
public static bool IsNumeric(this string str)
{
return int.TryParse(str, out _);
}
}

Metodi Asincroni

Usati per operazioni asincrone, permettono di non bloccare il thread chiamante:

public async Task<string> GetDataAsync()
{
await Task.Delay(1000); // Simula un’operazione asincrona
return “Data”;
}

Esempio Completo

Ecco un esempio completo che include vari tipi di metodi:

using System;
public class Codice
{
    public static void Main()
    {
        Codice p = new Codice();
        p.DisplayMessage();
        int result = p.Add(5, 7);
        Console.WriteLine($"Add: {result}");

        result = Multiply(3, 4);
        Console.WriteLine($"Multiply: {result}");

        string data = p.GetData().Result;
        Console.WriteLine($"GetData: {data}");

        string numStr = "123";
        bool isNumeric = numStr.IsNumeric();
        Console.WriteLine($"IsNumeric: {isNumeric}");
    }

    public void DisplayMessage()
    {
        Console.WriteLine("Hello, World!");
    }

    public int Add(int a, int b)
    {
        return a + b;
    }

    public static int Multiply(int a, int b)
    {
        return a * b;
    }

    public async Task<string> GetData()
    {
        await Task.Delay(1000); // Simula un'operazione asincrona
        return "Data";
    }
}

public static class StringExtensions
{
    public static bool IsNumeric(this string str)
    {
        return int.TryParse(str, out _);
    }
}

LINK AI POST PRECEDENTI