sesion - ¿Qué hacen las llaves después de la nueva declaración C#?

optimizar consultas lentas mysql

Question

Dado el siguiente código, ¿cuál es la diferencia entre la forma en que se inicializa position0 y la forma en que se inicializa position1 ? ¿Son equivalentes? Sí no, ¿Cuál es la diferencia?

class Program
{
    static void Main(string[] args)
    {
        Position position0 = new Position() { x=3, y=4 };

        Position position1 = new Position();
        position1.x = 3;
        position1.y = 4;
    }
}

struct Position
{
    public int x, y;
}

Answer 1

Es un inicializador de objetos y simplemente le permite asignar valores en una sola expresión. Lo más importante, esto también funciona dentro de LINQ an para tipos anónimos (de lo contrario inmutables). También hay una sintaxis similar de inicialización de colección para elementos adicionales a colecciones nuevas.

Tenga en cuenta que hay un problema de tiempo sutil que puede ser útil; con los iniciadores, las asignaciones / adiciones suceden antes de que se asigne la variable, lo que puede ayudar a evitar que otros subprocesos vean un objeto incompleto. De lo contrario, necesitaría una variable adicional para lograr el mismo resultado.

Answer 2

Estos son completamente equivalentes. El compilador simplemente transforma la primera versión en la segunda.

La única diferencia entre los dos es que con el primero, puedes hacer cosas buenas, como pasar la versión inicializada a un método:

DoSomethingWithPoint(new Position() { x=3, y=4 });

Esto es mucho más líneas de código que el segundo ejemplo de inicialización.

Answer 3

Iniciales de objeto y colección, utilizados para inicializar campos en un objeto.

http://msdn.microsoft.com/en-us/library/bb384062.aspx

Producen IL casi equivalente. Jon Skeet tiene la respuesta sobre lo que realmente está pasando.

Answer 4

No son del todo equivalentes, al menos no en el caso general. El código que usa un inicializador de objetos está más cerca de esto:

Position tmp = new Position();
tmp.x = 3;
tmp.y = 4;
Position position1 = tmp;

En otras palabras, la asignación a la variable solo ocurre después de que se hayan establecido las propiedades. Ahora, en el caso de que esté declarando una nueva variable local, eso en realidad no importa, y el compilador puede optimizar su primer formulario. Pero, lógicamente, sí importa. Considerar:

Position p1 = new Position { x = 10, y = 20 };

p1 = new Position { x = p1.y, y = p1.x };

Si eso hiciera la asignación a p1 primero , terminarías con 0 para p1.x y p1.y Mientras que eso es realmente equivalente a:

Position tmp = new Position();
tmp.x = 10;
tmp.y = 20;
Position p1 = tmp;

tmp = new Position();
tmp.x = p1.y; // 20
tmp.y = p1.x; // 10
p1 = tmp;

EDITAR: Me acabo de dar cuenta de que estás usando una estructura en lugar de una clase. Eso puede hacer algunas diferencias sutiles ... pero es casi seguro que no deberías estar usando una estructura mutable para empezar :)

Answer 5

Olvidando todas las cosas de IL, es solo una notación abreviada. Lo que estás haciendo es esto:

a. En un caso, está utilizando explícitamente el constructor predeterminado y luego establece las dos propiedades.

segundo. En el otro, está utilizando la nueva sintaxis de inicializador que implícitamente hace que el compilador haga lo que hizo en el caso a.

A pesar de las subestigaciones de IL, lograrán lo mismo para usted.

Answer 6

Son equivalentes, aparte de que uno es más fácil de leer que el otro.

También considere el caso cuando desee pasar el nuevo objeto a otro lugar:

var aList = new List<Position>();
aList.Add( new Position() { x=3, y=4 } );

Answer 7

Tus dos muestras de código generarán IL idéntica. (Al menos en compilaciones de Release)