Advertisement
Fhernd

ContextoSincronizacion.cs

Jul 11th, 2016
1,026
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 4.09 KB | None | 0 0
  1. using System;
  2. using System.Diagnostics;
  3. using System.Text;
  4. using System.Threading.Tasks;
  5. using System.Windows;
  6. using System.Windows.Controls;
  7.  
  8. namespace Ch05_UsingCSharp5Dot0.R0506
  9. {
  10.     /// <summary>
  11.     /// Aplicación de demostración del uso de un contexto de sincronización.
  12.     /// </summary>
  13.     public class ContextoSincronizacion
  14.     {
  15.         private static Label _lblResultado;
  16.        
  17.         // Inicia la ejecución de esta aplicación de demostración.
  18.         // Configura la interfaz gráfica de usuario.
  19.         public void Ejecutar()
  20.         {
  21.             var app = new Application();
  22.             var win = new Window();
  23.             var panel = new StackPanel();
  24.             var btnEjecutar = new Button();
  25.            
  26.             _lblResultado = new Label();
  27.             _lblResultado.FontSize = 32;
  28.             _lblResultado.Height = 200;
  29.  
  30.             btnEjecutar.Height = 100;
  31.             btnEjecutar.FontSize = 32;
  32.             btnEjecutar.Content = new TextBlock {Text = "Iniciar Operaciones Asincrónicas"};
  33.             btnEjecutar.Click += Click;
  34.  
  35.             panel.Children.Add(_lblResultado);
  36.             panel.Children.Add(btnEjecutar);
  37.  
  38.             win.Content = panel;
  39.  
  40.             app.Run(win);
  41.         }
  42.  
  43.         /// <summary>
  44.         /// Inicia la ejecución de operaciones asincrónicas con y sin contexto.
  45.         /// </summary>
  46.         /// <param name="sender">Objeto generador del evento.</param>
  47.         /// <param name="e">Datos del evento.</param>
  48.         private async void Click(object sender, EventArgs e)
  49.         {
  50.             // Valor inicial de la etiqueta de la aplicación gráfica:
  51.             _lblResultado.Content = new TextBlock {Text = "Calculando..."};
  52.  
  53.             // Inicia la ejecución de las operaciones asincrónicas con y sin contexto:
  54.             TimeSpan resultadoConContexto = await OperacionConContexto();
  55.             TimeSpan resultadoSinContexto = await OperacionSinContexto();
  56.  
  57.             //TimeSpan resultadoSinContexto = await OperacionSinContexto()
  58.             //    .ConfigureAwait(false);
  59.  
  60.             // Reúne la información del resultado de la ejecución de las tareas con y sin contexto:
  61.             var sb = new StringBuilder();
  62.             sb.AppendLine(String.Format("Resultado con contexto: {0}", resultadoConContexto.ToString()));
  63.             sb.AppendLine(String.Format("Resultado sin contexto: {0}", resultadoSinContexto.ToString()));
  64.             sb.AppendLine(String.Format("Proporción {0:0.00}",
  65.                 resultadoConContexto.TotalMilliseconds/resultadoSinContexto.TotalMilliseconds));
  66.  
  67.             // Muestra en la interfaz gráfica la cadena de texto con la información de la ejecución de este evento:
  68.             _lblResultado.Content = new TextBlock {Text = sb.ToString()};
  69.         }
  70.  
  71.         /// <summary>
  72.         /// Ejecuta una tarea en un contexto de sincronización.
  73.         /// </summary>
  74.         /// <returns>Intervalo ocurrido en la ejecución de esta tarea.</returns>
  75.         private async Task<TimeSpan> OperacionConContexto()
  76.         {
  77.             const int numeroIteraciones = 100000;
  78.             var sw = new Stopwatch();
  79.             sw.Start();
  80.  
  81.             for (int i = 1; i <= numeroIteraciones; ++i)
  82.             {
  83.                 var t = Task.Run(() => { });
  84.                 await t;
  85.             }
  86.  
  87.             sw.Stop();
  88.  
  89.             return sw.Elapsed;
  90.         }
  91.  
  92.         /// <summary>
  93.         /// Ejecuta una tarea sin el uso de un contexto de sincronización.
  94.         /// </summary>
  95.         /// <returns>Intervalo ocurrido en la ejecución de esta tarea.</returns>
  96.         private async Task<TimeSpan> OperacionSinContexto()
  97.         {
  98.             const int numeroIteraciones = 100000;
  99.             var sw = new Stopwatch();
  100.             sw.Start();
  101.  
  102.             for (int i = 1; i <= numeroIteraciones; ++i)
  103.             {
  104.                 var t = Task.Run(() => { });
  105.                 await t.ConfigureAwait(
  106.                     continueOnCapturedContext: false);
  107.             }
  108.  
  109.             sw.Stop();
  110.  
  111.             return sw.Elapsed;
  112.         }
  113.     }
  114. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement