¿Es posible devolver una referencia a una variable en C#?

Question

¿Puedo devolver una referencia a un valor doble, por ejemplo?

Esto es lo que quiero hacer:

ref double GetElement() 
{ 
    ...... 
    // Calculate x,y,z 
    return ref doubleArray[x,y,z]; 
} 

Para utilizar de esta manera

void func() 
{ 
    GetElement()=5.0; 
} 

Es como volver un doble puntero en C++ ... sé que la forma en que escribió que está mal ... pero ¿hay una forma correcta de hacerlo?

Answer 1

Valor los tipos en C# siempre pasan por valor. Los objetos siempre tienen su referencia aprobada por valor. Esto cambia en el código "inseguro" como señala Axarydax.

La manera más fácil y segura de evitar esta restricción es asegurarse de que su doble esté conectada a un objeto de alguna manera.

public class MyObjectWithADouble { 
    public double Element {get; set;} // property is optional, but preferred. 
} 

... 
var obj = new MyObjectWithADouble(); 
obj.Element = 5.0 

También quiero destacar que estoy un poco confundido acerca de cómo se anticipa que la asignación de un doble con una matriz tridimensional. Es posible que desee aclarar lo que está buscando.

Creo que entiendo un poco mejor lo que está pasando por ahora. Desea devolver la ubicación del valor en una matriz determinada y luego puede cambiar el valor en esa ubicación. Este patrón rompe algunos de los paradigmas esperados de C#, por lo que sugiero considerar otras formas de lograr lo que estás buscando. Pero si realmente tiene sentido hacerlo, lo haría algo más parecido a esto:

public class 3dArrayLocation {public int X; public int Y; public int Z;} 

... 

public 3dArrayLocation GetElementLocation(...) 
{ 
    // calculate x, y, and z 
    return new 3dArrayLocation {X = x, Y = y, Z = z} 
} 

... 

var location = GetElementLocation(...); 
doubleArray[location.X, location.Y, location.Z] = 5.0; 

Answer 2

No, esto no es posible en C#. Solo puede pasar parámetros por referencia.

Sin embargo, se puede lograr el mismo resultado con una propiedad:

double Element 
{ 
    get { return doubleArray[x,y,z]; } 
    set { doubleArray[x,y,z] = value; } 
} 

void func() 
{ 
    Element = 5.0; 
} 

Answer 3

Usted podía hacerlo en unsafe code y tener un método que devuelve un puntero a doble:

unsafe double* GetElementP(){ 
... 
} 

Answer 4

Después de pensar un poco, ¿por qué no envía el valor que se debe ajustar en la función como esta:

void SetElement(double value) 
{ 
    ...... 
    // Calculate x,y,z 
    doubleArray[x,y,z]=value; 
} 

y utilizarla:

void func() 
{ 
    SetElement(5.0); 
} 

Sin embargo, todavía voy a elegir una de sus votos respuestas ...

Answer 5

updat E: La característica deseada es ahora compatible con C# 7.

---

El sistema de tipos de CLR no apoyar métodos REF-volver, y he escrito un prototipo experimental del compilador de C#, que es compatible con la función que desea. (El prototipo también implementa variables locales ref-tipadas, pero los campos ref-typed son ilegales en el sistema de tipo CLR.)

Ha accedido exactamente a la sintaxis que elegí para el prototipo, lo que significa que las grandes mentes piensan igual , o que los tontos nunca difieren.

Aunque el prototipo funciona muy bien, es muy poco probable que esto haga que la barra se convierta en una característica de la próxima versión del lenguaje C#. Muy pocos clientes quieren esta característica, es bastante costosa de implementar, tenemos una lista siempre y cuando su brazo de características más importantes, y hay otras maneras de hacer que este tipo de cosas funcionen sin agregar esta complejidad al sistema de tipos. Estos son todos grandes "puntos en contra" de hacer la función.

Por ejemplo, usted podría hacer un par de delegados:

struct Ref<T> 
{ 
    private readonly Func<T> getter; 
    private readonly Action<T> setter; 
    public Ref(Func<T> getter, Action<T> setter) 
    { 
     this.getter = getter; 
     this.setter = setter; 
    } 
    public T Value { get { return getter(); } set { setter(value); } } 
} 

var arr = new int[10]; 
var myref = new Ref<int>(()=>arr[1], x=>arr[1]=x); 
myref.Value = 10; 
Console.WriteLine(myref.Value); 

Eso es considerablemente más lento que la misma característica implementada con rendimientos árbitro, pero la ventaja es que se puede hacer una Ref<T> en lugares donde ref es ilegal. Por ejemplo, puede almacenar Ref<T> en un campo, que no puede hacer con un método de devolución de referencia.

Si usted tiene un escenario realmente impresionante convincente de por qué se necesita métodos REF-volver, me amor oír hablar de eso. Cuantos más escenarios del mundo real tengamos, más probable es que dicha característica se implemente en una versión futura hipotética del idioma.

Ver preguntas También relacionado:

Can I use a reference inside a C# function like C++?

Why doesn't C# support the return of references?

y mi blog sobre el tema:

http://ericlippert.com/2011/06/23/ref-returns-and-ref-locals/