¿Versión C # de la palabra clave sincronizada de java?

¿Tiene c # su propia versión de la palabra clave java “sincronizada”?

Es decir, en java se puede especificar ya sea para una función, un objeto o un bloque de código, así:

public synchronized void doImportantStuff() { // dangerous code goes here. } 

o

 public void doImportantStuff() { // trivial stuff synchronized(someLock) { // dangerous code goes here. } } 

Primero: la mayoría de las clases nunca necesitarán ser seguras para subprocesos. Use YAGNI : aplique solo seguridad de subprocesos cuando sepa que realmente lo va a usar (y pruébelo).

Para las cosas a nivel de método, hay [MethodImpl] :

 [MethodImpl(MethodImplOptions.Synchronized)] public void SomeMethod() {/* code */} 

Esto también se puede usar en accesadores (propiedades y eventos):

 private int i; public int SomeProperty { [MethodImpl(MethodImplOptions.Synchronized)] get { return i; } [MethodImpl(MethodImplOptions.Synchronized)] set { i = value; } } 

Tenga en cuenta que los eventos de tipo campo se sincronizan de forma predeterminada, mientras que las propiedades implementadas automáticamente no son :

 public int SomeProperty {get;set;} // not synchronized public event EventHandler SomeEvent; // synchronized 

Personalmente, no me gusta la implementación de MethodImpl porque bloquea this o typeof(Foo) , lo cual va en contra de las mejores prácticas. La opción preferida es usar sus propios lockings:

 private readonly object syncLock = new object(); public void SomeMethod() { lock(syncLock) { /* code */ } } 

Tenga en cuenta que para los eventos de tipo campo, la implementación de locking depende del comstackdor; en los viejos comstackdores de Microsoft es un lock(this) / lock(Type) ; sin embargo, en comstackdores más recientes usa actualizaciones Interlocked , por lo que es seguro para subprocesos sin las partes desagradables.

Esto permite un uso más granular y permite el uso de Monitor.Wait / Monitor.Pulse etc. para comunicarse entre hilos.

Una entrada de blog relacionada (más tarde revisitada ).

 static object Lock = new object(); lock (Lock) { // do stuff } 

¿Tiene c # su propia versión de la palabra clave java “sincronizada”?

No. En C #, se lock explícitamente lock recursos en los que se desea trabajar de forma síncrona a través de subprocesos asíncronos. lock abre un bloque; no funciona en el nivel del método

Sin embargo, el mecanismo subyacente es similar ya que el lock funciona al invocar Monitor.Enter (y posteriormente Monitor.Exit ) en el tiempo de ejecución. Java funciona de la misma manera, según la documentación de Sun.

Tome nota, con rutas completas la línea: [MethodImpl(MethodImplOptions.Synchronized)] debería verse como

[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.Synchronized)]

Puede usar la instrucción de lock lugar. Creo que esto solo puede reemplazar la segunda versión. Además, recuerde que tanto el synchronized como el lock deben operar en un objeto.