¿Es esta la manera correcta de implementar una propiedad Guid de lectura/escritura segura para subprocesos?

Question

Estoy implementando una clase que se utilizará al mismo tiempo desde varios subprocesos. La mayoría de las propiedades obtienen y configuran tipos primitivos que la clase Interbloqueada puede manejar adecuadamente. La clase incluye una propiedad Guid. Esto no es tan simple de implementar de una manera segura para subprocesos. ¿Es así como implementarías la propiedad? Gracias por adelantado.

private Byte[] _activityId; 
public Guid ActivityId 
    { 
     get { return new Guid(this._activityId); } 
     set 
     { 
      Byte[] bytes = value.ToByteArray(); 
      Interlocked.Exchange(ref this._activityId, bytes); 
     } 
    } 

ACTUALIZACIÓN: Así que la única solución propuesta hasta este punto no incluye el uso de cualquier clase o construcciones "Threading". Así que voy a plantear la pregunta que ya he planteadas en los comentarios:

Mi opinión es que los tipos de referencia/valores primitivos asignaciones son atómicas embargo Interlocked garantizará el cambio se propaga a todas las roscas. Si pudiéramos simplemente asignar el valor, ¿por qué Interlocked expone las API para intercambiar tipos de referencia y valores primitivos?

Answer 1

Creo que se podría utilizar la otra sobrecarga del Interlocked.Exchange:

private volatile object _activityId; // Yes, object :) 
public Guid ActivityId { 
    get { return (Guid)_activityId; } 
    set { _activityId = value; } 
} 

Esto funciona porque el Guid está ahora en caja, y la asignación de los tipos de referencia es atómica.

Answer 2

Usted puede obtener la asignación atómica más barato en la creación de su propia clase de cuadro:

class Box<T> where T : struct { 
    public readonly T Value; 
    public Box(T value) { Value = value; } 
} 

Al almacenar una referencia a la (inmutable) instancia Box en lugar de almacenar el valor directamente, todas las operaciones en el campo serán atómica .

private Box<Guid> _activityId; 
public Guid ActivityId { 
    get { return this._activityId.Value; } 
    set { this._activityId = new Box<Guid>(value); } 
} 

De esta manera, las operaciones de copia de estructura atómica no suceda en new Box<Guid>(value) y en el .Value acceso. Como no involucran el campo, no causarán problemas.

Esto debería ser mucho más rápido que usar arrays de bytes, y un poco más rápido que el boxeo nativo con un molde. (descargo de responsabilidad: no he medido)