¿Cuál es la diferencia entre las palabras clave 'ref' y 'out'?

Estoy creando una función donde necesito pasar un objeto para que pueda ser modificado por la función. Cuál es la diferencia entre:

public void myFunction(ref MyClass someClass)

y

public void myFunction(out MyClass someClass)

¿Cuál debería usar y por qué?

refle dice al compilador que el objeto se inicializa antes de ingresar a la función, mientras que outle dice al compilador que el objeto se inicializará dentro de la función.

Entonces, si bien refes bidireccional, outes exclusivo.

El refmodificador significa que:

1. El valor ya está establecido y
2. El método puede leerlo y modificarlo.

El outmodificador significa que:

1. El valor no se establece y el método no puede leerlo hasta que se establece.
2. El método debe establecerlo antes de regresar.

Digamos que Dom aparece en el cubículo de Peter sobre la nota sobre los informes de TPS.

Si Dom fuera un argumento de referencia, tendría una copia impresa del memo.

Si Dom fuera una discusión, haría que Peter imprimiera una nueva copia de la nota para que se la llevara.

Voy a probar suerte con una explicación:

Creo que entendemos cómo funcionan los tipos de valor, ¿verdad? Los tipos de valor son (int, long, struct, etc.). Cuando los envía a una función sin un comando ref, COPIA los datos . Cualquier cosa que haga a esos datos en la función solo afecta a la copia, no al original. El comando ref envía los datos ACTUALES y cualquier cambio afectará los datos fuera de la función.

De acuerdo con la parte confusa, tipos de referencia:

Vamos a crear un tipo de referencia:

List<string> someobject = new List<string>()

Cuando renueva un objeto , se crean dos partes:

1. El bloque de memoria que contiene datos para algún objeto .
2. Una referencia (puntero) a ese bloque de datos.

Ahora, cuando envía algún objeto a un método sin referencia, COPIA el puntero de referencia , NO los datos. Entonces ahora tienes esto:

(outside method) reference1 => someobject
(inside method)  reference2 => someobject

Dos referencias apuntando al mismo objeto. Si modifica una propiedad en algún objeto utilizando referencia2, afectará los mismos datos señalados por referencia1.

 (inside method)  reference2.Add("SomeString");
 (outside method) reference1[0] == "SomeString"   //this is true

Si anula la referencia2 o la señala a datos nuevos, no afectará la referencia1 ni la referencia de datos1 a la que apunta.

(inside method) reference2 = new List<string>();
(outside method) reference1 != null; reference1[0] == "SomeString" //this is true

The references are now pointing like this:
reference2 => new List<string>()
reference1 => someobject

¿Qué sucede cuando envía un objeto por referencia a un método? La referencia real a algún objeto se envía al método. Entonces ahora solo tiene una referencia a los datos:

(outside method) reference1 => someobject;
(inside method)  reference1 => someobject;

Pero ¿qué significa esto? Actúa exactamente igual que enviar algún objeto, no por referencia, excepto por dos cosas principales:

1) Cuando anule la referencia dentro del método, anulará la que está fuera del método.

 (inside method)  reference1 = null;
 (outside method) reference1 == null;  //true

2) Ahora puede apuntar la referencia a una ubicación de datos completamente diferente y la referencia fuera de la función ahora apuntará a la nueva ubicación de datos.

 (inside method)  reference1 = new List<string>();
 (outside method) reference1.Count == 0; //this is true

ref está dentro y fuera .

Debería usar outcon preferencia donde sea suficiente para sus requisitos.

fuera:

En C #, un método solo puede devolver un valor. Si desea devolver más de un valor, puede usar la palabra clave out. El modificador out regresa como retorno por referencia. La respuesta más simple es que la palabra clave "out" se usa para obtener el valor del método.

1. No necesita inicializar el valor en la función de llamada.
2. Debe asignar el valor en la función llamada, de lo contrario, el compilador informará un error.

árbitro:

En C #, cuando pasa un tipo de valor como int, float, double, etc. como argumento al parámetro del método, se pasa por valor. Por lo tanto, si modifica el valor del parámetro, no afecta el argumento en la llamada al método. Pero si marca el parámetro con la palabra clave "ref", se reflejará en la variable real.

1. Debe inicializar la variable antes de llamar a la función.
2. No es obligatorio asignar ningún valor al parámetro ref en el método. Si no cambia el valor, ¿cuál es la necesidad de marcarlo como "ref"?

Extendiendo el perro, ejemplo de gato. El segundo método con ref cambia el objeto al que hace referencia la persona que llama. Por lo tanto "Gato" !!!

    public static void Foo()
    {
        MyClass myObject = new MyClass();
        myObject.Name = "Dog";
        Bar(myObject);
        Console.WriteLine(myObject.Name); // Writes "Dog". 
        Bar(ref myObject);
        Console.WriteLine(myObject.Name); // Writes "Cat". 
    }

    public static void Bar(MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

    public static void Bar(ref MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

Como está pasando un tipo de referencia (una clase), no es necesario usarlo refporque, por defecto, solo se pasa una referencia al objeto real y, por lo tanto, siempre cambia el objeto detrás de la referencia.

Ejemplo:

public void Foo()
{
    MyClass myObject = new MyClass();
    myObject.Name = "Dog";
    Bar(myObject);
    Console.WriteLine(myObject.Name); // Writes "Cat".
}

public void Bar(MyClass someObject)
{
    someObject.Name = "Cat";
}

Mientras pase una clase, no tiene que usarla refsi desea cambiar el objeto dentro de su método.

refy outcomportarse de manera similar, excepto las siguientes diferencias.

• refLa variable debe inicializarse antes de su uso. outvariable se puede usar sin asignación
• outEl parámetro debe ser tratado como un valor no asignado por la función que lo utiliza. Entonces, podemos usar el outparámetro inicializado en el código de llamada, pero el valor se perderá cuando se ejecute la función.

Para aquellos que aprenden con el ejemplo (como yo), esto es lo que dice Anthony Kolesov .

He creado algunos ejemplos mínimos de ref, out y otros para ilustrar el punto. No estoy cubriendo las mejores prácticas, solo ejemplos para entender las diferencias.

https://gist.github.com/2upmedia/6d98a57b68d849ee7091

"Panadero"

Esto se debe a que el primero cambia su referencia de cadena para que apunte a "Baker". Es posible cambiar la referencia porque la pasó a través de la palabra clave ref (=> una referencia a una referencia a una cadena). La segunda llamada obtiene una copia de la referencia a la cadena.

La cadena parece algo especial al principio. Pero string es solo una clase de referencia y si define

string s = "Able";

¡entonces s es una referencia a una clase de cadena que contiene el texto "Capaz"! Otra asignación a la misma variable vía

s = "Baker";

¡no cambia la cadena original, sino que simplemente crea una nueva instancia y señalamos esa instancia!

Puedes probarlo con el siguiente pequeño ejemplo de código:

string s = "Able";
string s2 = s;
s = "Baker";
Console.WriteLine(s2);

¿Qué esperas? Lo que obtendrá seguirá siendo "Capaz" porque simplemente establece la referencia en s a otra instancia mientras s2 apunta a la instancia original.

EDITAR: la cadena también es inmutable, lo que significa que simplemente no hay ningún método o propiedad que modifique una instancia de cadena existente (puede intentar encontrar una en los documentos pero no encontrará ninguna :-)). ¡Todos los métodos de manipulación de cadenas devuelven una nueva instancia de cadena! (Es por eso que a menudo obtienes un mejor rendimiento cuando usas la clase StringBuilder)

ref significa que el valor en el parámetro ref ya está establecido, el método puede leerlo y modificarlo. Usar la palabra clave ref es lo mismo que decir que la persona que llama es responsable de inicializar el valor del parámetro.

out le dice al compilador que la inicialización del objeto es responsabilidad de la función, la función debe asignarse al parámetro out. No está permitido dejarlo sin asignar.

Fuera: una declaración de devolución se puede usar para devolver solo un valor de una función. Sin embargo, utilizando parámetros de salida, puede devolver dos valores de una función. Los parámetros de salida son como parámetros de referencia, excepto que transfieren datos fuera del método en lugar de hacerlo al mismo.

El siguiente ejemplo lo ilustra:

using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* local variable definition */
         int a = 100;

         Console.WriteLine("Before method call, value of a : {0}", a);

         /* calling a function to get the value */
         n.getValue(out a);

         Console.WriteLine("After method call, value of a : {0}", a);
         Console.ReadLine();

      }
   }
}

ref: Un parámetro de referencia es una referencia a una ubicación de memoria de una variable. Cuando pasa parámetros por referencia, a diferencia de los parámetros de valor, no se crea una nueva ubicación de almacenamiento para estos parámetros. Los parámetros de referencia representan la misma ubicación de memoria que los parámetros reales que se proporcionan al método.

En C #, declara los parámetros de referencia utilizando la palabra clave ref. El siguiente ejemplo demuestra esto:

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void swap(ref int x, ref int y)
      {
         int temp;

         temp = x; /* save the value of x */
         x = y;   /* put y into x */
         y = temp; /* put temp into y */
       }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* local variable definition */
         int a = 100;
         int b = 200;

         Console.WriteLine("Before swap, value of a : {0}", a);
         Console.WriteLine("Before swap, value of b : {0}", b);

         /* calling a function to swap the values */
         n.swap(ref a, ref b);

         Console.WriteLine("After swap, value of a : {0}", a);
         Console.WriteLine("After swap, value of b : {0}", b);

         Console.ReadLine();

      }
   }
}

ref y out funcionan como pasar por referencias y pasar por punteros como en C ++.

Para ref, el argumento debe declararse e inicializarse.

Para salir, el argumento debe declararse pero puede o no inicializarse

        double nbr = 6; // if not initialized we get error
        double dd = doit.square(ref nbr);

        double Half_nbr ; // fine as passed by out, but inside the calling  method you initialize it
        doit.math_routines(nbr, out Half_nbr);

Tiempo de autoría:

(1) Creamos el método de llamada Main()

(2) crea un objeto List (que es un objeto de tipo de referencia) y lo almacena en la variable myList.

public sealed class Program 
{
    public static Main() 
    {
        List<int> myList = new List<int>();

Durante el tiempo de ejecución:

(3) El tiempo de ejecución asigna una memoria en la pila en el # 00, lo suficientemente ancho como para almacenar una dirección (# 00 = myList, ya que los nombres de las variables son realmente solo alias para ubicaciones de memoria)

(4) Runtime crea un objeto de lista en el montón en la ubicación de memoria #FF (todas estas direcciones son, por ejemplo, sake)

(5) Runtime almacenaría la dirección inicial #FF del objeto en # 00 (o en palabras, almacena la referencia del objeto List en el puntero myList)

Volver al tiempo de autoría:

(6) Luego pasamos el objeto List como argumento myParamListal método llamado modifyMyListy le asignamos un nuevo objeto List

List<int> myList = new List<int>();

List<int> newList = ModifyMyList(myList)

public List<int> ModifyMyList(List<int> myParamList){
     myParamList = new List<int>();
     return myParamList;
}

Durante el tiempo de ejecución:

(7) Runtime inicia la rutina de llamada para el método llamado y, como parte del mismo, verifica el tipo de parámetros.

(8) Al encontrar el tipo de referencia, asigna una memoria en la pila en el # 04 para aliasar la variable del parámetro myParamList.

(9) Luego almacena el valor #FF también en él.

(10) Runtime crea un objeto de lista en el montón en la ubicación de memoria # 004 y reemplaza #FF en # 04 con este valor (o desreferencia el objeto de lista original y señala el nuevo objeto de lista en este método)

La dirección en # 00 no se altera y conserva la referencia a #FF (o el myListpuntero original no se altera).

La palabra clave ref es una directiva del compilador para omitir la generación de código de tiempo de ejecución para (8) y (9), lo que significa que no habrá asignación de montón para los parámetros del método. Utilizará el puntero original # 00 para operar el objeto en #FF. Si el puntero original no se inicializa, el tiempo de ejecución dejará de quejarse de que no puede continuar ya que la variable no está inicializada

La palabra clave out es una directiva del compilador que es casi lo mismo que ref con una ligera modificación en (9) y (10). El compilador espera que el argumento no se inicialice y continuará con (8), (4) y (5) para crear un objeto en el montón y almacenar su dirección inicial en la variable del argumento. No se generará ningún error no inicializado y se perderá cualquier referencia previa almacenada.

Además de permitirle reasignar la variable de otra persona a una instancia diferente de una clase, devolver múltiples valores, etc., usando refo le outpermite a otra persona saber qué necesita de ellos y qué piensa hacer con la variable que proporcionan

• No es necesario ref o outsi todo lo que vas a hacer es modificar las cosas dentro de la MyClassinstancia que se pasa en el argumento someClass.

  • El método llamando verá cambios como someClass.Message = "Hello World"si se utiliza ref, outo nada
  • Escribir someClass = new MyClass()dentro myFunction(someClass)intercambia el objeto visto por el someClassen el alcance del myFunctionmétodo solamente. El método de llamada aún conoce la MyClassinstancia original que creó y pasó a su método

• Usted necesita ref o outsi usted planea en el bombeo de someClasssalida para un objeto completamente nuevo y desea que el método de llamada para ver su cambio

  • Escribir someClass = new MyClass()dentro myFunction(out someClass)cambia el objeto visto por el método que llamómyFunction

Existen otros programadores

Y quieren saber qué vas a hacer con sus datos. Imagine que está escribiendo una biblioteca que será utilizada por millones de desarrolladores. Desea que sepan qué va a hacer con sus variables cuando llaman a sus métodos

• El uso refhace una declaración de "Pase una variable asignada a algún valor cuando llame a mi método. Tenga en cuenta que podría cambiarlo por algo completamente diferente durante el curso de mi método. No espere que su variable apunte al objeto antiguo Cuando termine"

• El uso outhace una declaración de "Pasar una variable de marcador de posición a mi método. No importa si tiene un valor o no; el compilador me obligará a asignarlo a un nuevo valor. Garantizo absolutamente que el objeto señalado por su variable antes de llamar a mi método, será diferente para cuando termine

Por cierto, en C # 7.2 también hay un inmodificador

Y eso evita que el método cambie la instancia pasada por una instancia diferente. Piense en ello como decir a esos millones de desarrolladores "pásenme su referencia variable original, y prometo no cambiar sus datos cuidadosamente elaborados por otra cosa". intiene algunas peculiaridades, y en algunos casos, como cuando se puede requerir una conversión implícita para hacer que su corto sea compatible con un in intcompilador, temporalmente hará un int, lo ampliará, lo pasará por referencia y terminará. Puede hacer esto porque has declarado que no te meterás con eso.

Microsoft hizo esto con los .TryParsemétodos en los tipos numéricos:

int i = 98234957;
bool success = int.TryParse("123", out i);

Al marcar el parámetro como outestán declarando activamente aquí " definitivamente vamos a cambiar su minuciosamente elaborado valor de 98234957 por algo más"

Por supuesto, tienen que hacerlo, por ejemplo, para analizar tipos de valores porque si no se permitiera al método de análisis intercambiar el tipo de valor por otra cosa, no funcionaría muy bien ... Pero imagine que hubiera algún método ficticio en algunos biblioteca que estás creando:

public void PoorlyNamedMethod(out SomeClass x)

Puedes ver que es un out, y así puedes saber que si pasas horas calculando números, creando el SomeClass perfecto:

SomeClass x = SpendHoursMakingMeAPerfectSomeClass();
//now give it to the library
PoorlyNamedMethod(out x);

Bueno, eso fue una pérdida de tiempo, tomar todas esas horas para hacer esa clase perfecta. Definitivamente será desechado y reemplazado por PoorlyNamedMethod

Para aquellos que buscan una respuesta concisa.

Ambas palabras clave refy outse utilizan para pasar por alto reference.

---

Una variable de refpalabra clave debe tener un valor o debe referirse a un objeto o null antes de pasar.

---

A diferencia ref, una variable de outpalabra clave debe tener un valor o debe referirse a un objeto o null después de su paso, así como no tener que tener un valor o referirse a un objeto antes de pasar.

Para ilustrar las muchas explicaciones excelentes, desarrollé la siguiente aplicación de consola:

using System;
using System.Collections.Generic;

namespace CSharpDemos
{
  class Program
  {
    static void Main(string[] args)
    {
      List<string> StringList = new List<string> { "Hello" };
      List<string> StringListRef = new List<string> { "Hallo" };

      AppendWorld(StringList);
      Console.WriteLine(StringList[0] + StringList[1]);

      HalloWelt(ref StringListRef);
      Console.WriteLine(StringListRef[0] + StringListRef[1]);

      CiaoMondo(out List<string> StringListOut);
      Console.WriteLine(StringListOut[0] + StringListOut[1]);
    }

    static void AppendWorld(List<string> LiStri)
    {
      LiStri.Add(" World!");
      LiStri = new List<string> { "¡Hola", " Mundo!" };
      Console.WriteLine(LiStri[0] + LiStri[1]);
    }

    static void HalloWelt(ref List<string> LiStriRef)
     { LiStriRef = new List<string> { LiStriRef[0], " Welt!" }; }

    static void CiaoMondo(out List<string> LiStriOut)
     { LiStriOut = new List<string> { "Ciao", " Mondo!" }; }
   }
}
/*Output:
¡Hola Mundo!
Hello World!
Hallo Welt!
Ciao Mondo!
*/

• AppendWorld: Se pasa una copia de StringListnamed LiStri. Al comienzo del método, esta copia hace referencia a la lista original y, por lo tanto, puede usarse para modificar esta lista. Más tarde hace LiStrireferencia a otro List<string>objeto dentro del método que no afecta a la lista original.

• HalloWelt: LiStriRefes un alias de lo ya inicializado ListStringRef. El List<string>objeto pasado se usa para inicializar uno nuevo, por reflo tanto, era necesario.

• CiaoMondo: LiStriOutes un alias de ListStringOuty debe inicializarse.

Entonces, si un método simplemente modifica el objeto al que hace referencia la variable pasada, el compilador no le permitirá usarlo outy no debe usarlo refporque confundiría no al compilador sino al lector del código. Si el método hará que el argumento pasado haga referencia a otro objeto, úselo refpara un objeto ya inicializado y outpara métodos que deben inicializar un nuevo objeto para el argumento pasado. Además de eso, refy outcomportarse igual.

Son más o menos lo mismo: la única diferencia es que una variable que pasa como parámetro de salida no necesita inicializarse, y el método que usa el parámetro ref tiene que establecerla en algo.

int x;    Foo(out x); // OK 
int y;    Foo(ref y); // Error

Los parámetros de referencia son para datos que pueden modificarse, los parámetros de salida son para datos que son una salida adicional para la función (por ejemplo, int. TryParse) que ya están utilizando el valor de retorno para algo.

A continuación, he mostrado un ejemplo usando tanto Ref como out . Ahora, todos estarán libres de ref y out.

En el ejemplo mencionado a continuación, cuando comento // myRefObj = new myClass {Name = "ref outside called !!"}; línea, se obtiene un error diciendo "El uso de variable local no asignada 'myRefObj'" , pero no hay tal error en la salida .

Dónde usar Ref : cuando llamamos a un procedimiento con un parámetro in y se usará el mismo parámetro para almacenar la salida de ese proceso.

Dónde usar Out: cuando llamamos a un procedimiento sin parámetro in y el mismo parámetro se utilizará para devolver el valor de ese proceso. También tenga en cuenta la salida

public partial class refAndOutUse : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        myClass myRefObj;
        myRefObj = new myClass { Name = "ref outside called!!  <br/>" };
        myRefFunction(ref myRefObj);
        Response.Write(myRefObj.Name); //ref inside function

        myClass myOutObj;
        myOutFunction(out myOutObj);
        Response.Write(myOutObj.Name); //out inside function
    }

    void myRefFunction(ref myClass refObj)
    {
        refObj.Name = "ref inside function <br/>";
        Response.Write(refObj.Name); //ref inside function
    }
    void myOutFunction(out myClass outObj)
    {
        outObj = new myClass { Name = "out inside function <br/>" }; 
        Response.Write(outObj.Name); //out inside function
    }
}

public class myClass
{
    public string Name { get; set; }
} 

 public static void Main(string[] args)
    {
        //int a=10;
        //change(ref a);
        //Console.WriteLine(a);
        // Console.Read();

        int b;
        change2(out b);
        Console.WriteLine(b);
        Console.Read();
    }
    // static void change(ref int a)
    //{
    //    a = 20;
    //}

     static void change2(out int b)
     {
         b = 20;
     }

puede verificar este código, le describirá su diferencia completa cuando use "ref", lo que significa que ya ha inicializado ese int / string

pero cuando usa "out" funciona en ambas condiciones, ya sea que inicialice ese int / string o no, pero debe inicializar ese int / string en esa función

Ref: la palabra clave ref se usa para pasar un argumento como referencia. Esto significa que cuando el valor de ese parámetro se cambia en el método, se refleja en el método de llamada. Un argumento que se pasa usando una palabra clave ref debe inicializarse en el método de llamada antes de pasarlo al método llamado.

Out: la palabra clave out también se usa para pasar un argumento como la palabra clave ref, pero el argumento se puede pasar sin asignarle ningún valor. Un argumento que se pasa usando una palabra clave out debe inicializarse en el método llamado antes de que regrese al método de llamada.

public class Example
{
 public static void Main() 
 {
 int val1 = 0; //must be initialized 
 int val2; //optional

 Example1(ref val1);
 Console.WriteLine(val1); 

 Example2(out val2);
 Console.WriteLine(val2); 
 }

 static void Example1(ref int value) 
 {
 value = 1;
 }
 static void Example2(out int value) 
 {
 value = 2; 
 }
}

/* Output     1     2     

Ref y fuera en método de sobrecarga

Tanto ref como out no se pueden usar en la sobrecarga de métodos simultáneamente. Sin embargo, ref y out se tratan de manera diferente en tiempo de ejecución, pero se tratan igual en tiempo de compilación (CLR no diferencia entre los dos mientras crea IL para ref y out).

Desde el punto de vista de un método que recibe un parámetro, la diferencia entre refy outes que C # requiere que los métodos deben escribir en cada outparámetro antes de regresar, y no deben hacer nada con dicho parámetro, aparte de pasarlo como outparámetro o escribir en él , hasta que se haya pasado como outparámetro a otro método o se haya escrito directamente. Tenga en cuenta que algunos otros idiomas no imponen tales requisitos; un método virtual o de interfaz que se declara en C # con un outparámetro puede anularse en otro idioma que no imponga restricciones especiales sobre dichos parámetros.

Desde el punto de vista de la persona que llama, C # en muchas circunstancias asumirá que llamar a un método con un outparámetro hará que la variable pasada se escriba sin haber sido leída primero. Esta suposición puede no ser correcta al llamar a métodos escritos en otros idiomas. Por ejemplo:

struct MyStruct
{
   ...
   myStruct(IDictionary<int, MyStruct> d)
   {
     d.TryGetValue(23, out this);
   }
}

Si myDictionaryidentifica una IDictionary<TKey,TValue>implementación escrita en un lenguaje que no sea C #, aunque MyStruct s = new MyStruct(myDictionary);parezca una tarea, podría dejars sin modificar.

Tenga en cuenta que los constructores escritos en VB.NET, a diferencia de los de C #, no hacen suposiciones sobre si los métodos llamados modificarán algún outparámetro y borrarán todos los campos incondicionalmente. El comportamiento extraño aludido anteriormente no ocurrirá con el código escrito completamente en VB o completamente en C #, pero puede ocurrir cuando el código escrito en C # llama a un método escrito en VB.NET.

Si desea pasar su parámetro como una referencia, debe inicializarlo antes de pasar el parámetro a la función; de lo contrario, el compilador mismo mostrará el error. Pero en caso de que no haya un parámetro, no necesita inicializar el parámetro del objeto antes de pasarlo al método. Puede inicializar el objeto en el propio método de llamada.

Tenga en cuenta que el parámetro de referencia que se pasa dentro de la función se trabaja directamente.

Por ejemplo,

    public class MyClass
    {
        public string Name { get; set; }
    }

    public void Foo()
    {
        MyClass myObject = new MyClass();
        myObject.Name = "Dog";
        Bar(myObject);
        Console.WriteLine(myObject.Name); // Writes "Dog".
    }

    public void Bar(MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

Esto escribirá Perro, no Gato. Por lo tanto, debe trabajar directamente en someObject.

Puede que no sea tan bueno en esto, pero seguramente las cadenas (aunque técnicamente son tipos de referencia y viven en el montón) se pasan por valor, no por referencia.

        string a = "Hello";

        string b = "goodbye";

        b = a; //attempt to make b point to a, won't work.

        a = "testing";

        Console.WriteLine(b); //this will produce "hello", NOT "testing"!!!!

Es por eso que necesita ref si desea que existan cambios fuera del alcance de la función que los hace, de lo contrario no está pasando una referencia.

Por lo que sé, solo necesita ref para estructuras / tipos de valor y la cadena en sí, ya que la cadena es un tipo de referencia que finge que es pero no es un tipo de valor.

Sin embargo, podría estar completamente equivocado aquí, soy nuevo.