Cuándo usar ref y cuándo no es necesario en C #

Tengo un objeto que está en mi estado de memoria del programa y también tengo algunas otras funciones de trabajo a las que paso el objeto para modificar el estado. Lo he estado pasando por referencia a las funciones de trabajador. Sin embargo, encontré la siguiente función.

byte[] received_s = new byte[2048];
IPEndPoint tmpIpEndPoint = new IPEndPoint(IPAddress.Any, UdpPort_msg);
EndPoint remoteEP = (tmpIpEndPoint);

int sz = soUdp_msg.ReceiveFrom(received_s, ref remoteEP); 

Me confunde porque ambos received_sy remoteEPestán devolviendo cosas de la función. ¿Por qué remoteEPnecesita un refy received_sno?

También soy programador de corriente alterna, así que tengo problemas para sacarme los punteros de la cabeza.

Editar: Parece que los objetos en C # son punteros al objeto debajo del capó. Entonces, cuando pasa un objeto a una función, puede modificar el contenido del objeto a través del puntero y lo único que se pasa a la función es el puntero al objeto para que el objeto en sí no se esté copiando. Use ref o out si desea poder cambiar o crear un nuevo objeto en la función que es como un puntero doble.

Respuesta corta: lea mi artículo sobre el paso de argumentos .

Respuesta larga: cuando un parámetro de tipo de referencia se pasa por valor, solo se pasa la referencia, no una copia del objeto. Esto es como pasar un puntero (por valor) en C o C ++. Los cambios en el valor del parámetro en sí no serán vistos por la persona que llama, pero los cambios en el objeto que los puntos de referencia a la va a ser visto.

Cuando un parámetro (de cualquier tipo) se pasa por referencia, eso significa que la persona que llama ve cualquier cambio en el parámetro; los cambios en el parámetro son cambios en la variable.

El artículo explica todo esto con más detalle, por supuesto :)

Respuesta útil: casi nunca es necesario usar ref / out . Básicamente, es una forma de obtener otro valor de retorno y, por lo general, debe evitarse precisamente porque significa que el método probablemente esté tratando de hacer demasiado. Ese no es siempre el caso ( TryParseetc son los ejemplos canónicos de uso razonable de out) pero el uso de ref / out debería ser una rareza relativa.

Piense en un parámetro no ref como un puntero y un parámetro ref como un puntero doble. Esto me ayudó más.

Casi nunca debería pasar valores por ref. Sospecho que si no fuera por problemas de interoperabilidad, el equipo de .Net nunca lo habría incluido en la especificación original. La forma OO de lidiar con la mayoría de los problemas que resuelven los parámetros de referencia es:

Para múltiples valores de retorno

• Cree estructuras que representen los múltiples valores devueltos

Para primitivas que cambian en un método como resultado de la llamada al método (el método tiene efectos secundarios en los parámetros primitivos)

• Implementar el método en un objeto como método de instancia y manipular el estado del objeto (no los parámetros) como parte de la llamada al método
• Utilice la solución de valor de retorno múltiple y combine los valores de retorno con su estado
• Cree un objeto que contenga un estado que pueda ser manipulado por un método y pase ese objeto como parámetro, y no las primitivas mismas.

Probablemente podría escribir una aplicación C # completa y nunca pasar ningún objeto / estructura por ref.

Tuve un profesor que me dijo esto:

El único lugar donde usarías refs es donde tú:

1. Quiere pasar un objeto grande (es decir, los objetos / estructura tiene objetos / estructuras dentro de él a múltiples niveles) y copiarlo sería costoso y
2. Está llamando a un Framework, API de Windows u otra API que lo requiera.

No lo hagas solo porque puedes. Puede ser mordido por algunos errores desagradables si comienza a cambiar los valores en un parámetro y no está prestando atención.

Estoy de acuerdo con su consejo, y en mis más de cinco años desde la escuela, nunca lo he necesitado más allá de llamar al Framework o la API de Windows.

Dado queived_s es una matriz, está pasando un puntero a esa matriz. La función manipula los datos existentes en su lugar, sin cambiar la ubicación o el puntero subyacentes. La palabra clave ref significa que está pasando el puntero real a la ubicación y actualizando ese puntero en la función exterior, por lo que el valor en la función exterior cambiará.

Por ejemplo, la matriz de bytes es un puntero a la misma memoria antes y después, la memoria se acaba de actualizar.

La referencia de punto final en realidad está actualizando el puntero al punto final en la función exterior a una nueva instancia generada dentro de la función.

Piense en una referencia como lo que significa que está pasando un puntero por referencia. No usar una referencia significa que está pasando un puntero por valor.

Mejor aún, ignore lo que acabo de decir (probablemente sea engañoso, especialmente con los tipos de valor) y lea esta página de MSDN .

Tengo entendido que todos los objetos derivados de la clase Object se pasan como punteros, mientras que los tipos ordinarios (int, struct) no se pasan como punteros y requieren ref. No estoy seguro de la cadena (¿se deriva en última instancia de la clase Object?)

Si bien estoy de acuerdo con la respuesta de Jon Skeet en general y algunas de las otras respuestas, hay un caso de uso para usar ref, y es para ajustar las optimizaciones de rendimiento. Se ha observado durante la elaboración de perfiles de rendimiento que establecer el valor de retorno de un método tiene ligeras implicaciones de rendimiento, mientras que el uso refcomo argumento mediante el cual el valor de retorno se completa en ese parámetro da como resultado la eliminación de este pequeño cuello de botella.

Esto realmente solo es útil cuando los esfuerzos de optimización se llevan a niveles extremos, sacrificando la legibilidad y tal vez la capacidad de prueba y el mantenimiento para ahorrar milisegundos o quizás milisegundos divididos.

Primero, la regla de la zona cero, las primitivas se pasan por valor (pila) y las no primitivas por referencia (montón) en el contexto de los TIPOS involucrados.

Los parámetros involucrados se pasan por Valor por defecto. Buen post que explica las cosas en detalle. http://yoda.arachsys.com/csharp/parameters.html

Student myStudent = new Student {Name="A",RollNo=1};

ChangeName(myStudent);

static void ChangeName(Student s1)
{
  s1.Name = "Z"; // myStudent.Name will also change from A to Z
                // {AS s1 and myStudent both refers to same Heap(Memory)
                //Student being the non-Primitive type
}

ChangeNameVersion2(ref myStudent);
static void ChangeNameVersion2(ref Student s1)
{
  s1.Name = "Z"; // Not any difference {same as **ChangeName**}
}

static void ChangeNameVersion3(ref Student s1)
{
    s1 = new Student{Name="Champ"};

    // reference(myStudent) will also point toward this new Object having new memory
    // previous mystudent memory will be released as it is not pointed by any object
}

Podemos decir (con advertencia) Los tipos no primitivos no son más que punteros Y cuando los pasamos por ref podemos decir que estamos pasando Double Pointer