¿Cómo paso una referencia constante en C#?

Question

En C++, pasando referencias const es una práctica común - por ejemplo:

#include <iostream> 
using namespace std; 

class X 
{ 
    public : 
    X()        {m_x = 0; } 
    X(const int & x)     {m_x = x; } 
    X(const X & other)    { *this = other; } 
    X & operator = (const X & other) { m_x = other.m_x; return *this; } 
    void print()      { cout << m_x << endl; } 
    private : 
    int m_x; 
}; 

void main() 
{ 
    X x1(5); 
    X x2(4); 
    X x3(x2); 
    x2 = x1; 
    x1.print(); 
    x2.print(); 
    x3.print(); 
} 

Este sencillo ejemplo ilustra cómo se hace - más o menos. Sin embargo, he notado que en C# no parece ser el caso. ¿Debo pasar las referencias de const en C#? ¿Para qué necesito la palabra clave "ref"? Tenga en cuenta que sé y entiendo qué referencias de C# y tipos de valores son.

Answer 1

C# no tiene la noción de objetos const (es decir, objetos que no se pueden modificar); solo las variables (es decir, los campos) pueden ser const o readonly, lo que significa que no puede asignarlas.

La palabra clave ref pasa conceptualmente una referencia a una variable como parámetro, es decir, el destinatario puede modificar la variable (en lugar de simplemente modificar el valor). Esto es particularmente útil para los tipos primitivos (int, bool, etc.).

Answer 2

const correctness in C#

A question of const

Why doesn't C# have "const"?

Answer 3

Para responder a la parte ref de su pregunta; cuando pasa una variable a un método, se crea una copia de esa variable. El uso de la palabra clave ref pasará la misma instancia de esa variable para que el método pueda actualizar esa variable para la persona que llama.

Mucha gente parece pensar que esto solo se aplica a los tipos de valores porque los tipos de referencia se pasan como referencia de todos modos, por lo que la palabra clave ref no tiene efecto. Sin embargo, esto no es cierto, la referencia se pasa al método de la misma manera que un valor; se copia y se crea una nueva instancia de esa referencia. Esto significa que la persona que llama verá modificaciones al objeto en sí, pero no a la referencia. Por lo tanto, si se trató de establecer el objeto a null, o un nuevo objeto, la persona que llama no vería esta modificación si la palabra clave ref no se utiliza:

Sin ref:

void UpdatePerson(Person person) 
{ 
    // Caller would see this change 
    person.Name = "Bob"; 
    // Caller wouldn't see this change 
    person = null; 
} 

con referencia

void UpdatePerson(ref Person person) 
{ 
    // Caller would see this change 
    person.Name = "Bob"; 
    // Caller would see this change 
    person = null; 
}