Este artículo proviene de un motor de traducción automática.

El programador políglota

Transacciones ACID con STM.NET

Ted Neward

Aunque esta columna se centra específicamente en lenguajes de programación, es interesante observar cómo ideas de lenguaje pueden a veces sangrado a través a otros idiomas sin modificarla directamente.

Un ejemplo es el idioma de Microsoft Research C-omega (a veces escrito CW, puesto que el símbolo de omega griega es muy parecido a una letra minúscula w en la configuración de teclado de Estados Unidos). Junto con la introducción de una serie de conceptos de unificación de datos y código que finalmente harían lleguen a la C# y Visual Basic idiomas como LINQ, C Omega también ofrece hasta un nuevo medio de simultaneidad denominado chords posteriormente realice él en una biblioteca conocidos como combinaciones. Mientras combinaciones no ha hecho, como redacción de este artículo, realiza el programa de TI en un producto (aún), el hecho de que el todo chords se proporcionaba el concepto de simultaneidad a través de una biblioteca significa que cualquier run-of-the-mill C# o Visual Basic (o otro lenguaje. NET) podría hacer uso de ella.

Otro tal esfuerzo es la facilidad de contratos de código disponible desde el sitio Web de Microsoft DevLabs y se explica en la expedición de agosto de 2009 de MSDN Magazine . Diseño por contrato es una característica de lenguaje que se ha destacado en lenguajes como Eiffel y incluida originalmente a .NET mediante lenguaje de Microsoft Research especificación #. Tipos de sistemas de garantía contractuales similares han llegado a través de Microsoft Research así, incluyendo uno de Mis favoritos fugue, qué hace uso de atributos personalizados y análisis estático para proporcionar comprobación de corrección de código de cliente.

Una vez más, aunque no ha enviado código contratos como técnico formal o con una licencia permite su uso en producción software, el hecho de que existe como una biblioteca en lugar de como un lenguaje independiente implica dos cosas. En primer lugar, que podría (en teoría) se escriben según una biblioteca por cualquier desarrollador de .NET suficientemente determina que tiene tipos de funcionalidad similares. Y en segundo lugar, (suponiendo que suministran) dicho funcionalidad podría estar disponible en una variedad de lenguajes, incluidos C# y Visual Basic.

Si está con detección de un tema, tiene razón. Este mes quiero aún otra biblioteca proviene del mundo de lenguaje polyglot anunció recientemente se centran en: software de memoria transaccional o STM. Biblioteca STM.NET está disponible para su descarga a través del sitio Web de DevLabs pero resalten contrasta con algunas de las implementaciones ya mencioné, no es una biblioteca independiente que obtiene vinculado en su programa o que se ejecuta como una herramienta de análisis estático: es un reemplazo y el suplemento de la biblioteca de clases de base de .NET como un todo, entre otras cosas.

Sin embargo, tenga en cuenta que la implementación actual de STM.NET no es muy compatible con versiones beta de Visual Studio 2010 actuales, por lo tanto, las renuncias habituales acerca de cómo instalar software sin terminar/beta/CTP en equipos que le interesa doblemente se aplica por lo tanto, en este caso. Debe instalar de forma simultánea con Visual Studio 2008, pero aún no pone en el equipo de trabajo. Aquí es otro caso donde Virtual PC es su amigo muy buena.

Comienzo

El fondo lingüístico de STM.NET proviene de un número de lugares diferentes pero la idea conceptual del STM es muy sencillo y familiar: en lugar de forzar a los desarrolladores centrarse en los medios de hacer cosas simultáneas (centrándose en bloqueos etc.), les Mark qué partes del código deben ejecutarse bajo determinadas características descriptivas de concurrencia y que la herramienta de lenguaje (compilador o intérprete) permiten administrar los bloqueos según sea necesario. En otras palabras, como usuarios y administradores de base de datos, permiten al programador Mark el código con la semántica transaccional ACID estilo y, a continuación, deje el trabajo pesado de administrar bloqueos para el entorno subyacente.

Aunque los bits STM.NET pueden aparecer ser simplemente otro intento en administración de simultaneidad, el esfuerzo STM representa algo más profundos que — pretende llevar todas cuatro cualidades de la base de datos de transacción ACID al modelo de programación en memoria. Además de para administrar los bloqueos en nombre del programador, el modelo STM también proporciona la atomicidad, coherencia, aislamiento y durabilidad, cuál de ellos mismos puede realizar programación mucho más sencilla, independientemente de la presencia de varios subprocesos de ejecución.

Por ejemplo, considere este ejemplo de pseudocódigo (hay que reconocer que totalmente sobreutilizados):

BankTransfer(Account from, Account to, int amount) {
  from.Debit(amount);
  to.Credit(amount);
}

¿Qué sucede si el crédito se produce un error y produce una excepción? Claramente el usuario no será feliz si el débito para el desde cuenta permanece fija en el registro cuando el crédito de la cuenta no está allí, lo que significa ahora el desarrollador que tiene algún trabajo adicional para realizar:

BankTransfer(Account from, Account to, int amount) {
  int originalFromAmount = from.Amount;
  int originalToAmount = to.Amount;
  try {
    from.Debit(amount);
    to.Credit(amount);
  }
  catch (Exception x) {
    from.Amount = originalFromAmount;
    to.Amount = originalToAmount;
  }
}

Esto parece, a primera vista, una exageración. No obstante, recuerde que dependiendo de la implementación exacta de los métodos de debe y haber excepciones se pueden producir antes de que finalice la operación de débito o después de que finaliza la operación de crédito (pero no finaliza). Esto significa que el método BankTransfer debe asegurarse de que todos los datos al que hace referencia y utilizar en esta operación vuelve a exactamente el estado en que estaba cuando comenzó la operación.

Si obtiene este BankTransfer en todos los más complicado, trabajan en tres o cuatro los elementos de datos a la vez, por ejemplo, el código de recuperación en el bloque catch se va a ponerse realmente feas realmente rápidamente. Y se muestra mucho más a menudo de lo que me gustaría poder admitir este modelo.

Otro punto merece la pena destacar es el aislamiento. En el código original, otro subproceso podría leer un saldo incorrecto mientras se estaba ejecutando y dañar al menos una de las cuentas. Además, si simplemente abofeteada un bloqueo a su alrededor, podría interbloqueo si el desde/hacia pares siempre no se pidieron. STM simplemente se encarga de para usted sin utilizar bloqueos.

Si en su lugar, el lenguaje que ofrece algún tipo de operación transaccional, como una palabra clave atómica que controla el bloqueo y lógica de error o deshacer debajo del capó, simplemente como BEGIN TRANSACTION y COMMIT hace para una base de datos, en el ejemplo BankTransfer de codificación se convierte en tan sencillo como esto:

BankTransfer(Account from, Account to, int amount) {
  atomic {
    from.Debit(amount);
    to.Credit(amount);
  }
}

Tiene que admitir, es mucho menor que preocuparse.

El enfoque STM.NET, sin embargo, que se va a biblioteca basándose, no se va a obtener bastante esto mucho porque el lenguaje C# no permite bastante dicho grado de flexibilidad sintáctica. En su lugar, que se va a estar trabajando con algo a lo largo de las líneas de:

public static void Transfer(
  BankAccount from, BankAccount to, int amount) {
  Atomic.Do(() => {
    // Be optimistic, credit the beneficiary first
    to.ModifyBalance(amount);
    from.ModifyBalance(-amount);
  });
}

Más información: Realmente es un cambio de idioma

En el curso de revisión columna del Neward, una cosa saltó fuera en mí como, por desgracia, un tergiversación básica. Neward intenta dividir las extensiones de lenguaje en aquellos que requieren los cambios en el lenguaje y los que están (puramente) cambios de biblioteca. Intenta clasificar STM.NET como ésta: un cambio sólo biblioteca: Considerando que diría más decididamente no es.

Una extensión de biblioteca sólo es uno que sea implementable completamente en el lenguaje existente. Existen sistemas STM basados en la biblioteca; éstos generalmente requieren que los datos que deben tener la semántica transaccional declararse de algún tipo especial, como “ TransactionalInt ”. STM.NET no es igual a la — proporciona la semántica transaccional para datos normales de forma transparente, simplemente, en virtud de la que se tiene acceso dentro del ámbito (dinámico) de una transacción.

Para ello, cada lectura y escritura que se produzcan en el código que se ejecuta dentro de la transacción que modificarse para realizar adicionales asociados a las llamadas que adquieren bloqueos necesarios, creación y llenar instantáneas y así sucesivamente. En nuestra implementación modificamos el compilador JIT de CLR ampliamente para producir código muy diferente que se ejecutan dentro de las transacciones. La palabra clave atómica (aunque nos hemos presentado mediante una API basados en delegado) cambia la semántica de lenguaje en un nivel bastante fundamental.

Por lo tanto, reclamar que se cambió el idioma. En un lenguaje .NET como C#, una combinación del compilador de lenguaje de nivel de origen y sus suposiciones sobre la semántica de MSIL que emite implementan la semántica de lenguaje: cómo el motor en tiempo de ejecución de CLR ejecutará esa IL. Hemos cambiado radicalmente interpretación de CLR de los códigos de bytes, por lo que diría esto cambia el idioma.

Diga en particular, que compilador JIT de CLR encuentra código como éste:

try {<br xmlns="http://www.w3.org/1999/xhtml" /> <body> <br xmlns="http://www.w3.org/1999/xhtml" />} <br xmlns="http://www.w3.org/1999/xhtml" />catch (AtomicMarkerException) {}

El código dentro de < body > (y, recursivamente, dentro de los métodos que se llama a) se modifica dinámicamente para garantizar la semántica transaccional. Debería destacar que esto sea absolutamente no tiene nada que ver con el control de excepciones: es puramente un hack para identificar un bloque atómico, puesto que la construcción try/catch es el único mecanismo disponible en IL para identificar un bloque léxicamente con ámbito. A largo plazo, le queremos algo más como un bloque de “ atómico ” explícito en el lenguaje IL. Se implementa la interfaz basado en delegados en términos de este bloque ersatz atómica.

En resumen, el bloque atómico IL nivel, sin embargo se expresan realmente cambia la semántica del código que se ejecuta en él de manera fundamental. Ésta es la razón por la STM.NET contiene un runtime CLR nuevo, modificado considerablemente, no sólo los cambios realizados en la BCL. Si ha tardado un tiempo de ejecución CLR stock y se ejecutaban con la BCL de STM.NET, el resultado no daría semántica transaccional (de hecho, dudo funcionaría en absoluto).

— Dr. Dave Detlefs, arquitecto, Common Language Runtime, Microsoft

La sintaxis no es bastante tan elegante como una palabra clave atómica sería, pero C# tiene la potencia de los métodos anónimos para capturar el bloque de código sería componen el cuerpo del bloque atómico que desee y, por lo tanto, se pueden ejecutar en tipos similares de semántica. (Lo sentimos, pero como de escribir este artículo, el esfuerzo de incubación STM.NET sólo es compatible con C#. No hay ninguna razón técnica por qué no se puede ampliarse a todos los idiomas, pero el equipo STM.NET sólo se centró en C# en la primera versión.)

Introducción a STM.NET

Lo primero que tendrá que hacer es descargar la versión beta de Microsoft .NET Framework 4 1 habilitado para utilizar software transaccional memoria v1.0 bits (un nombre long-winded, que va reduce a STM.NET BCL o simplemente STM.NET) desde el sitio Web de DevLabs. Mientras esté allí, descargue la documentación de STM.NET y ejemplos así. Es el primero las herramientas BCL y STM.NET reales y ensamblados complementarios y ésta contiene, entre la documentación y ejemplos de proyectos, una plantilla Visual Studio 2008 para generar aplicaciones STM.Net.

Crear una nueva aplicación habilitado STM.NET comienza al igual que cualquier aplicación, en el cuadro de diálogo nuevo proyecto (consulte de figura 1). Seleccionar plantilla TMConsoleApplication hace un par de cosas, algunos de los cuales no están completamente intuitivas. Por ejemplo, de escribir este artículo, que se va a ejecutar en las bibliotecas STM.NET app.config de la aplicación .NET requiere este poco de control de versiones legerdemain:

Figura 1 Iniciando un nuevo proyecto con la plantilla TMConsoleApplication

<?xml version="1.0" encoding="utf-8" ?> 
<configuration> 
  <startup> 
    <requiredRuntime version="v4.0.20506"/> 
  </startup>
  ... 
</configuration>

Otras configuraciones estará presentes pero el valor requiredRuntime es necesario saber la pastilla de reglaje del SeSelector CLR para enlazar con la versión STM.NET del motor en tiempo de ejecución. Además, la plantilla TMConsoleApplication enlaza el ensamblado con respecto a versiones de la mscorlib y System.Transactions ensamblados instalados en el directorio donde está instalado STM.NET, en lugar de las versiones que vienen con las existencias de .NET Framework 3.0 o 3.5 CLR. Esto es necesario, cuando lo piensa, porque si STM.NET se va a proporcionar acceso transaccional para nada más allá de sólo el código que escribe, se va a necesitar utilizar su propia copia de mscorlib. Además, si se va a interactuar correctamente con otros formularios de transacciones,:, como las transacciones ligeras proporcionadas por el Administrador de transacciones ligero (LTM): necesita tener su propia versión de System.Transactions.

Aparte de eso, una aplicación STM.NET será una aplicación .NET tradicional, escritas en C# y compiladas para IL, vinculado con el resto de los ensamblados .NET sin modificar y así sucesivamente. STM.NET ensamblados, como los componentes COM + y EnterpriseServices de la última década, tendrá unas cuantas más extensiones en ellas que describen transaccionales comportamientos para los métodos que interactúan con el comportamiento transaccional STM.NET pero familiarizará con la en el tiempo.

Hola, STM.NET

Como con del ejemplo Axum en el número de septiembre de 2009 de MSDN Magazine, escribir una aplicación Hello World tradicional como el punto de partida para STM.NET es realmente más difícil que usted podría pensar en primer lugar, en gran medida puesto que si se escribe sin preocuparse por las transacciones, lo exactamente es el mismo como la tradicional C# Hello World. Si escribe para aprovechar el comportamiento transaccional STM.NET, tendrá que considerar el hecho de que escribir texto en la consola es, de hecho, un método un-undoable (al menos en la medida que se refiere a STM.NET), que significa que intentar deshacer una instrucción Console.WriteLine es difícil.

Por lo tanto, en su lugar, let’s toman un ejemplo sencillo de la Guía de usuario STM.NET como una demostración rápida de los bits STM.NET. Un objeto (denominado MyObject) tiene dos cadenas privadas en ella y un método para establecer esas dos cadenas en algún par de valores:

class MyObject {
  private string m_string1 = "1";
  private string m_string2 = "2";

  public bool Validate() {
    return (m_string1.Equals(m_string2) == false);
  }
  public void SetStrings(string s1, string s2) {
    m_string1 = s1;
    Thread.Sleep(1);   // simulates some work 
    m_string2 = s2;
  }
}

Puesto que la asignación del parámetro para el campo es en sí mismo una operación atómica, no hay ninguna preocupación alrededor de simultaneidad no existe. Pero sólo como con el ejemplo BankAccount mostrado anteriormente, desee ambos establecerse o ninguno y no desea ver actualizaciones parciales; una cadena que se va a establecer, pero no el otro: durante la operación de conjunto. Podrá generar dos subprocesos para establecer ciegamente las cadenas y otra vez y un tercer subproceso para validar el contenido de la instancia de MyObject, informar de una infracción en el caso Validate devuelve false (consulte de figura 2).

Figura 2 Validar manualmente actualizaciones atómicas para MyObject

[AtomicNotSupported]
static void Main(string[] args) {
  MyObject obj = new MyObject();
  int completionCounter = 0; int iterations = 1000;
  bool violations = false;

  Thread t1 = new Thread(new ThreadStart(delegate {
    for (int i = 0; i < iterations; i++)
      obj.SetStrings("Hello", "World");
    completionCounter++;
  }));

  Thread t2 = new Thread(new ThreadStart(delegate {
    for (int i = 0; i < iterations; i++)
      obj.SetStrings("World", "Hello");
    completionCounter++;
  }));

  Thread t3 = new Thread(new ThreadStart(delegate {
    while (completionCounter < 2) {
      if (!obj.Validate()) {
        Console.WriteLine("Violation!");
        violations = true;
      }
    }
  }));

  t1.Start(); t2.Start(); t3.Start();
  while (completionCounter < 2)
    Thread.Sleep(1000);

  Console.WriteLine("Violations: " + violations);
...

Tenga en cuenta que la forma en que se construye en este ejemplo, produce un error de validación si se establecen las dos cadenas obj en lo mismo que indica que t1 Thread SetStrings(“Hello”, “World”) está parcialmente actualizado (dejando la primera “ Hello ” para que coincida con el segundo “ Hello ” establecido por t2).

Un vistazo superficial a la implementación SetStrings muestra que este código es apenas es seguro para la ejecución de subprocesos. Si se produce un cambio de subproceso en el medio (que es probable que se indicará la llamada a Thread.Sleep, lo que hará que el subproceso actualmente en ejecución renunciar a su segmento de tiempo), otro subproceso podría fácilmente saltar en medio de SetStrings nuevo, colocar la instancia de MyObject en un estado no válido. Ejecutarlo y con suficiente iteraciones, se iniciará infracciones que aparezca. (En mi equipo portátil, tuve que ejecutar dos veces antes de que obtuve infracciones, demostrando que simplemente porque se ejecuta sin error una vez no significa el código no tiene un error de concurrencia.)

Modificar esta opción para utilizar STM.NET requiere sólo un pequeño cambio en la clase de MyObject, tal como se muestra en de figura 3.

Figura 3 Validar MyObject con STM.NET

class MyObject {
  private string m_string1 = "1";
  private string m_string2 = "2";

  public bool Validate() {
    bool result = false;
    Atomic.Do(() => { 
      result = (m_string1.Equals(m_string2) == false);
    });
    return result;
  }

  public void SetStrings(string s1, string s2) {
    Atomic.Do(() => {
      m_string1 = s1;
      Thread.Sleep(1); // simulates some work 
      m_string2 = s2;
    });
  }
}

Como puede observar, era la única modificación necesaria ajustar los organismos de validar y SetStrings en métodos atómicos mediante la operación Atomic.Do. Ahora, cuando se ejecuta, no aparezcan infracciones.

Afinidad transaccional

Lectores observador tiene se haya observado el atributo [AtomicNotSupported] en la parte superior del método Main en de figura 2 y tal vez se ha preguntado alguna vez en su finalidad o incluso se habrá preguntado si servían el mismo propósito que los atributos de los días de COM +. Según parece, que es completamente correcto: el entorno STM.NET necesita ayuda en la comprensión si métodos llamados durante un bloque atomic son compatibles con la transacción, de modo que puede proporcionar el soporte necesario y conveniente para dichos métodos.

Tres dichos atributos están disponibles en la versión actual de STM.NET:

• AtomicSupported: el ensamblado, método, campo o delegar comportamiento transaccional admite y puede utilizarse dentro o fuera de bloques atómicas correctamente.
• AtomicNotSupported: ensamblado, método o delegado no admite el comportamiento transaccional y, por lo tanto, no debería utilizarse dentro de bloques atómicas.
• AtomicRequired: ensamblado, método, campo o delegado no sólo es compatible con el comportamiento transaccional, sólo debe utilizarse dentro de bloques atómicas (garantizar así que utilizar este elemento siempre se realizarán bajo la semántica transaccional).

Técnicamente es una cuarta AtomicUnchecked que señala al STM.NET que este elemento no debería comprobarse, período. Está pensada como una trampilla de evacuación para evitar el código de comprobación por completo.

La presencia del atributo AtomicNotSupported es lo que conduce al sistema STM.NET debe generar un AtomicContractViolationException cuando se intenta realizar el siguiente código (ingenua):

[AtomicNotSupported]
static void Main(string[] args) {
  Atomic.Do( () => {
    Console.WriteLine("Howdy, world!");
  });

  System.Console.WriteLine("Simulation done");
}

Puesto que el método System.Console.WriteLine no está marcado con AtomicSupported, el método Atomic.Do produce la excepción cuando ve la llamada en el bloque atómica. Este bit de seguridad garantiza que se ejecutan dentro del bloque atómico transacción compatible sólo con métodos y proporciona ese bit adicional de seguridad y la seguridad para el código.

Hola, STM.NET (segunda parte)

¿Qué sucede si realmente, realmente desea escribir la tradicional Hello World? ¿Qué sucede si realmente desea imprimir una línea en la consola (o escribir en un archivo o realizar algún otro comportamiento no transaccional) junto con dos otras operaciones transaccionales, pero sólo imprimirlo si ambas de estas operaciones se realizan correctamente? STM.NET ofrece tres formas de controlar esta situación.

En primer lugar, puede realizar la operación no transaccional fuera de la transacción (y sólo después de la transacción se confirma) colocando el código dentro de un bloque pasado a Atomic.DoAfterCommit. Como el código dentro de ese bloque normalmente desea utilizar datos generado o modificado desde dentro de la transacción, DoAfterCommit toma un parámetro de contexto que se pasa al bloque de código como su único parámetro desde dentro de la transacción.

En segundo lugar, puede crear una acción de compensación que se ejecutará in the event that se produce un error en la transacción en última instancia, llamando a Atomic.DoWithCompensation que (nuevo) toma un parámetro de contexto para calcular referencias de datos desde dentro de la transacción para la confirmación o de compensación de bloque de código (según corresponda).

En tercer lugar, puede ir totalmente y crear un administrador de recursos transaccional (RM) que entienda cómo participar con el sistema transaccional STM.NET. Esto es realmente menos difícil que puede parecer, simplemente heredan de la clase STM.NET TransactionalOperation, que tiene métodos OnCommit y OnAbort que reemplazar para proporcionar el comportamiento adecuado en cualquier caso. Cuando se utiliza este nuevo tipo de RM, llame a OnOperation al comienzo de su trabajo con él (inscripción eficazmente el recurso en la transacción STM.NET). A continuación, llame al FailOperation sobre él en caso de que fallen las operaciones que lo rodea.

Por lo tanto, si desea escribir transaccionalmente en alguna secuencia de texto, puede escribir un administrador de recursos al anexar el texto como el que se muestra en de figura 4. Esta, a continuación, le permite, de hecho, en virtud del atributo [Required atómica], requiere que: que se va a escribir en algunas secuencia de texto mediante TxAppender mientras dentro de un bloque atómico (consulte de figura 5).

Figura 4 de Un administrador de recursos transaccional

public class TxAppender : TransactionalOperation {
  private TextWriter m_tw;
  private List<string> m_lines;

  public TxAppender(TextWriter tw) : base() {
    m_tw = tw;
    m_lines = new List<string>();
  }

  // This is the only supported public method
  [AtomicRequired]
  public void Append(string line) {
    OnOperation();

    try {
      m_lines.Add(line);
    }
    catch (Exception e) {
      FailOperation();
      throw e;
    }
  }

  protected override void OnCommit() {
    foreach (string line in m_lines) {
      m_tw.WriteLine(line);
    }
    m_lines = new List<string>();
  }

  protected override void OnAbort() {
    m_lines.Clear();
  }
}

Figura 5 mediante TxAppender

public static void Test13() {
  TxAppender tracer = 
    new TxAppender(Console.Out);
  Console.WriteLine(
    "Before transactions. m_balance= " + 
    m_balance);

  Atomic.Do(delegate() {
    tracer.Append("Append 1:  " + m_balance);
    m_balance = m_balance + 1;
    tracer.Append("Append 2:  " + m_balance);
  });
            
  Console.WriteLine(
    "After transactions. m_balance= " 
    + m_balance);

  Atomic.Do(delegate() {
    tracer.Append("Append 1:  " + m_balance);
    m_balance = m_balance + 1;
    tracer.Append("Append 2:  " + m_balance);
  });

  Console.WriteLine(
    "After transactions. m_balance= " 
    + m_balance);
}

Esto es obviamente la ruta más larga y será adecuado sólo en ciertos escenarios. Podría producirse un error en el caso de algunos tipos de tipos de medios, pero la mayoría de los casos, si el comportamiento irreversible real se aplaza al método OnCommit, esto bastará para la mayoría de sus necesidades transaccionales en proceso.

Colocar STM.NET trabajo

Trabajar con un STM sistema tarda un poco obteniendo utilizado para, pero una vez está mantenido aclimatación, trabajando sin pueda sentirse paralizando. Tenga en cuenta algunos de los posibles lugares donde el uso de STM.NET puede simplificar de codificación.

Se cuando se trabaja con otros recursos de transacción, STM.NET conecta a los sistemas de transacción existentes rápida y fácilmente, hacer Atomic.Do la única fuente de código con transacciones en su sistema. Los ejemplos STM.NET lo muestran en el ejemplo de TraditionalTransactions exponer mensajes en una cola privada MSMQ y no haciéndolo evidente, cuando se produce un error en el bloque atómico, se registra ningún mensaje a la cola. Éste es probablemente el uso más obvio.

En cuadros de diálogo, especialmente para los procesos de varios pasos del asistente o cuadros de diálogo de configuración: la capacidad de deshacer los cambios en la configuración o el cuadro de diálogo miembros de datos cuando el usuario presiona el botón Cancelar es invaluables.

Pruebas unitarias como NUnit, MSTest y otros sistemas de ejercer un gran esfuerzo para garantizar que, cuando escribe correctamente, las pruebas no pueden perder los resultados de una prueba a la siguiente. Si STM.NET alcanza el estado de producción, NUnit y MSTest pueden refactorice su código de ejecución de caso de prueba para utilizar transacciones STM para aislar los resultados de prueba entre sí, generar una operación de deshacer al final de cada método de prueba y lo que elimina cualquier cambio que es posible que se han generado por la prueba. Aún más, cualquier prueba que llama a un método AtomicUnsupported se marcarán en tiempo de ejecución de prueba como un error, en lugar de en modo silencioso perdiendo la prueba es el resultado a algún medio fuera del entorno de prueba (por ejemplo, para base de datos o disco).

STM.NET también se puede utilizar en la implementación de propiedades del objeto de dominio. Aunque la mayoría de los objetos de dominio tienen propiedades bastante simple, asignando a un campo o devolver el valor del campo, propiedades más complejas que tienen varios pasos algoritmos corre el riesgo de varios subprocesos que se vean actualizaciones parciales (si otro subproceso llama a la propiedad durante su conjunto) o actualizaciones fantasmas (en caso de otro subproceso llama a la propiedad durante su conjunto, y la actualización original finalmente se produce inmediatamente debido a un error de validación de alguna forma).

Aún más interesante, investigadores fuera de Microsoft están estudiando extender las transacciones en hardware, por lo que algún día, actualizar campo del objeto o una variable local podría ser una transacción protegida en el nivel de hardware por la memoria chip propiamente dicho, realizar la transacción blindingly rápido en comparación a métodos hoy.

Sin embargo, al igual que con Axum, Microsoft depende sus comentarios para determinar si esta tecnología compensa conseguir y productizing, por lo tanto, si encuentra esta idea interesante o interesante o que falta algo importante de sus prácticas de codificación, no dude en hágales saber. 

Ted Newardes un director con Neward and Associates, una firme independiente especializado en sistemas empresariales de .NET y Java. Ha escrito numerosos libros, es Architect de Microsoft MVP, altavoz INETA y instructor de PluralSight. Llegar a Ted en ted@tedneward.com de o leer su blog en <blogs.tedneward.com> de.

Gracias a los siguientes expertos técnicos para la revisión de este artículo: Dave Detlefs y Dana Groff