[C#] Passare parametri ai metodi e modifica loro valore

[dwb]

Ho questo codice:

using System;

namespace Wrox.ProCSharp.ParameterTestSample
{
    class ParameterTest
    {
        static void SomeFunction(int[] ints, int i)
        {
            ints[0] = 100;
            i = 100;
        }
        public static int Main()
        {
            int i = 0;
            int[] ints = { 0, 1, 2, 3, 4, 8 };
            //Mostra il valore originario
            Console.WriteLine("i = " + i);
            Console.WriteLine("ints[0] = " + ints[0]);
            Console.WriteLine("Calling SomeFunction...");

            //Dopo che il metodo ritorna, gli int saranno cambiati
            //ma non i
            SomeFunction(ints, i);
            Console.WriteLine("i = " + i);
            Console.WriteLine("ints[0] = " + ints[0]);
            return 0;
        }

    }
}

mi da come output:



non capisco cosa voglia farmi capire(scusate il gioco di parole) questo esempio di codice!Ho capito che mi vuole spiegare la differenza tra il passaggio di parametri a un metodo per valore e per riferimento, ma io proprio

Spero, come molte altre volte, che qualcuno di voi possa farmi entrare il concetto in testa! :berto:

[oregon]

Pero', scusa, la spiegazione e' nel testo ..

//Dopo che il metodo ritorna, gli int saranno cambiati
//ma non i

Piu' chiaro di cosi' ...

[dwb]

oregon, scusami, ma non ci arrivo!Qualcosa potresti dirmela te?

[oregon]

All'entrata della funzione, il valore del primo elemento dell'array

ints[0]

e' 0 come il valore di i

Nella funzione queste due variabili (i e ints[0]) sono modificate e viene assegnato loro il valore 100.

Pero' , all'uscita della funzione solamente l'elemento ints[0] vale 100 mentre i vale ancora 0.

Questo significa che il valore di i NON viene modificato dalla funzione, mentre questo succede per ints[0].

Per la variabile i, viene modificata *la copia* che il compilatore fa nel passarla alla funzione, mentre per l'elemento ints[0], viene proprio modificato *l'originale* ...

[vaitrafra]

In pratica.

Quando dichiari una variabile il compilatore non fa altro che segnare un'area di memoria dedicata a quella e solo a quella variabile(detta molto semplice).

ora, è possibile specificare al compilatore di usare queste aree di memoria in due modi fondamentali, valore e riferimento.

Quando passi ad una funzione una variabile per valore il compilatore assegna un'area di memoria temporanea dove copia la variabile originale.
L'indirizzo a questa area temporanea viene passato alla funzione e questa può pocciare li dentro finchè vuole. non appena la funzione ha fatto il suo dovere questa area temporanea viene eliminata e il valore perduto.(l'esempio del libraccio WROX è fuorviante perchè nell'intestazione di somefunction le variabili in ingresso hanno lo stesso nome di quelle originali del metodo main)

Quando invece passi un parametro per riferimento il compilatore passa alla funzione l'indirizzo all'area memoria che contiene la variabile originale.
Quindi la funzione legge e scrive direttamente dall'originale. Quindi se la funzione cambia il valore di quella variabile il suo contenuto sarà modificato anche dopo che la funzione sarà stata eseguita.

ti riscrivo l'esempio in modo umano.

namespace Wrox.ProCSharp.NoiNonSappiamoInsegnare
{
    class ParameterTest
    {

        }
        public static int Main()
        {
            string VariabileOriginale = "Variabile Originale";
            string[] ArrayOriginale = { "Originale1","Originale2","Originale3"};
            //Mostra il valore originario Prima della chiamata della funzione
            Console.WriteLine("VariabileOriginale = " + VariabileOriginale);
            Console.WriteLine("ArrayOriginale[0] = " + ArrayOriginale[0]);
            Console.WriteLine("Calling SomeFunction...");
            SomeFunction(ArrayOriginale, VariabileOriginale);

            //Dopo che il metodo ritorna, gli ArrayOriginale sarà Stato realmente modificato
            //ma non VariabileOriginale

            Console.WriteLine("VariabileOriginale = " + VariabileOriginale);
            Console.WriteLine("ArrayOriginale[0] = " + ArrayOriginale[0]);
            Console.WriteLine("Calling SomeFunction...");
            return 0;
        }
        static void SomeFunction(string[] ArrayDiStringhe, String Variabilestringa)
        {
            ArrayDiStringhe[0]= "La funzione mi sta modificando!"; //Questa variabile è quella passata per riferimento e verrà modificata
            VariabileStringa= "La Funzione mi sta modificando!"; //questa per valore e non sarà modificata
    }
}

se esegui il codice capisci subito che metre VariabileOriginale mantiene il suo valore anche dopo essere stata passata alla funzione, ArrayOriginale viene modificato permanentemente dalla funzione in quanto essa ha a disposizione l'indirizzo diretto al suo contenuto, e non un indirizzo ad una copia come accade per VariabileOriginale.

spero ora ti sia più chiaro, sennò ho insultato apertamente wrox per niente

[dwb]

Tutto più chiaro ora, grazie a tutti!