puede - ref c#

¿Qué significan ref, val and out en los parámetros del método?

Question

Estoy buscando una respuesta clara, concisa y precisa.

Idealmente como la respuesta real, aunque los enlaces a buenas explicaciones son bienvenidos.

Esto también se aplica a VB.Net, pero las palabras clave son diferentes: ByRef y ByVal .

Answer 1

Una nota adicional sobre ref vs. out: La distinción entre los dos se aplica mediante el compilador de C #. El CLR no distingue entre out y ref. Esto significa que no puede tener dos métodos cuyas firmas difieran solo por una salida o ref

void foo(int value) {}

// Only one of the following would be allowed

// valid to overload with ref
void foo(ref int value) {}

// OR with out
void foo(out int value) {}

Answer 2

out significa que el parámetro se inicializará con el método:

int result; //not initialised

if( int.TryParse( "123", out result ) )
   //result is now 123
else
   //if TryParse failed result has still be 
   // initialised to its default value (0)

ref obligará a que se pase la referencia subyacente:

void ChangeMyClass1( MyClass input ) {
   input.MyProperty = "changed by 1";
   input = null;
   //can''t see input anymore ... 
   // I''ve only nulled my local scope''s reference
}

void ChangeMyClass2( ref MyClass input ) {
   input.MyProperty = "changed by 2";
   input = null;
   //the passed reference is now null too.
}

MyClass tester = new MyClass { MyProperty = "initial value" };

ChangeMyClass1( tester );
// now tester.MyProperty is "changed by 1"

ChangeMyClass2( ref tester );
// now tester is null

Answer 3

Por defecto (en C #), pasar un objeto a una función en realidad pasa una copia de la referencia a ese objeto. Cambiar el parámetro en sí solo cambia el valor en el parámetro, y no la variable que se especificó.

void Test1(string param)
{
    param = "new value";
}

string s1 = "initial value";
Test1(s1);
// s1 == "initial value"

Usando out o ref pasa una referencia a la variable especificada en la llamada a la función. Cualquier cambio en el valor de un parámetro de out o ref se transmitirá a la persona que llama.

Tanto el out como el ref comportan de forma idéntica, excepto por una pequeña diferencia: se requiere inicializar los parámetros ref antes de la llamada, mientras out parámetros out pueden inicializarse. Por extensión, se garantiza que los parámetros de ref inicialicen al comienzo del método, mientras out parámetros de out se tratan como no inicializados.

void Test2(ref string param)
{
    param = "new value";
}

void Test3(out string param)
{
    // Use of param here will not compile
    param = "another value";
}

string s2 = "initial value";
string s3;
Test2(ref s2);
// s2 == "new value"
// Test2(ref s3); // Passing ref s3 will not compile
Test3(out s2);
// s2 == "another value"
Test3(out s3);
// s3 == "another value"

Editar : como señala dp , la diferencia entre out y ref solo se ve reforzada por el compilador de C #, no por el CLR. Hasta donde yo sé, VB no tiene equivalente para out e implementa ref (como ByRef ) solamente, igualando el soporte del CLR.

Answer 4

Una de mis propias preguntas en maneja este tema también.
Se trata de "pasar por referencia" y "pasar por alto" en diferentes tipos de idiomas, se incluye c #, por lo que quizás pueda encontrar información adicional allí también.

Básicamente se trata de:

• ref: el parámetro con la palabra clave ref se pasará por referencia
• out: el parámetro con la palabra clave out se tratará como un parámetro de salida

pero esa es realmente la respuesta más básica que puede dar, ya que es un poco más compleja de lo que se afirma aquí