traves - metodo invoke c#

¿Las propiedades estáticas implementadas automáticamente en C#son seguras para subprocesos?

Question

Me gustaría saber si C # implementó automáticamente las propiedades, como public static T Prop { get; set; } public static T Prop { get; set; } public static T Prop { get; set; } , son seguros para subprocesos o no. ¡Gracias!

Answer 1

La sección 10.7.4 de la especificación C # establece:

Cuando una propiedad se especifica como una propiedad implementada automáticamente, un campo de respaldo oculto está automáticamente disponible para la propiedad, y los accesores se implementan para leer y escribir en ese campo de respaldo. El siguiente ejemplo:

public class Point {
public int X { get; set; } // automatically implemented
public int Y { get; set; } // automatically implemented
}

Es equivalente a la siguiente declaración:

public class Point {
private int x;
private int y;
public int X { get { return x; } set { x = value; } }
public int Y { get { return y; } set { y = value; } }
}

Eso es lo que prometemos, y eso es lo que obtienes. El punto de las propiedades automáticas es hacer lo más básico, simple y barato; Si desea hacer algo más sofisticado, debe escribir una propiedad "real".

Answer 2

No hay sincronización provista con propiedades automáticas, incluyendo propiedades estáticas.

Si necesita seguridad total de subprocesos, querrá usar sus propias propiedades con un campo de respaldo y manejar la sincronización usted mismo.

Answer 3

No lo creo Creo que son solo azúcar sintáctica para:

private static T _prop;
public static T Prop
{
get { return _prop; }
set { _prop = value; }
}

Answer 4

No, ellos no son seguros para hilos. Las propiedades estáticas son tan vulnerables como los campos estáticos a problemas de concurrencia.

Answer 5

No. Debes envolverlos en mecanismos de bloqueo de hilos.

object _lock = new object();
public static Main(string[] args)
{
lock(_lock)
{
Prop = new T();
}
T val = null;
lock(_lock)
{
val = Prop;
}
}

Answer 6

Para completar, los eventos tipo campo tienen una seguridad de subprocesos integrada, pero están solos en esto. Las propiedades implementadas automáticamente no tienen tales características. Sin embargo, puedes hacer algo como:

public static double SomeProp
{ // ### NOT RECOMMENDED ###
[MethodImpl(MethodImplOptions.Synchronized)] get;
[MethodImpl(MethodImplOptions.Synchronized)] set;
}

El problema con esto es que bloqueará el Type , lo cual es algo malo . Yo implementaría mi propia sincronización para esto, personalmente.

Answer 7

Parece que no. Esta es la descompilación con reflector:

private static string Test
{
[CompilerGenerated]
get
{
return <Test>k__BackingField;
}
[CompilerGenerated]
set
{
<Test>k__BackingField = value;
}
}