Async loading with Non-blocking UI in ASP.NET with Gaia Ajax

   1:  namespace Gaia.WebWidgets.Samples.Combinations.WebUtilities.AsyncLoading

   2:  {

   3:      using System;

   4:      using UI;

   5:      using Utilities;

   6:      using WebWidgets.Effects;

   7:   

   8:      public partial class Default : SamplePage

   9:      {

  10:          const string CollapsedText = "Click here for more details ...";

  11:          const string ExpandedText = "Click here to hide again";

  12:   

  13:          protected void Page_Init(object sender, EventArgs e)

  14:          {

  15:              SetTimerPollingBasedOnNetworkLatency();

  16:              zViewResponse.Text = CollapsedText;

  17:          }

  18:   

  19:          protected void Page_Load(object sender, EventArgs e)

  20:          {

  21:              if (!IsPostBack) BackgroundTask = null;

  22:          }

  23:   

  24:          protected void zButton_Click(object sender, EventArgs e)

  25:          {

  26:              if (BackgroundTask.IsRunning) return;

  27:              BackgroundTask.Data.Clear(); 

  28:              BackgroundTask.RunTask();

  29:              ActivateUiTaskRunning();

  30:              DataBindGridViewToProcessedItems();

  31:          }

  32:   

  33:          protected void zTimer_Tick(object sender, EventArgs e)

  34:          {

  35:              DataBindGridViewToProcessedItems();

  36:              if (!BackgroundTask.IsRunning) DeactiveUiTaskRunning();

  37:          }

  38:   

  39:          private void DataBindGridViewToProcessedItems()

  40:          {

  41:              zGrid.DataSource = BackgroundTask.Data;

  42:              zGrid.DataBind();

  43:          }

  44:   

  45:          private void SetTimerPollingBasedOnNetworkLatency()

  46:          {

  47:              zTimer.Milliseconds = WebUtility.IsLocalhost ? 500 : 1000;

  48:          }

  49:   

  50:          private void DeactiveUiTaskRunning()

  51:          {

  52:              zImageLoader.Visible = false;

  53:              zTimer.Enabled = false;

  54:              zButton.Enabled = true;

  55:          }

  56:   

  57:          private void ActivateUiTaskRunning()

  58:          {

  59:              zTimer.Enabled = true;

  60:              zButton.Enabled = false;

  61:              zImageLoader.Visible = true;

  62:          }

  63:   

  64:          private CustomBackgroundWorker BackgroundTask

  65:          {

  66:              get

  67:              {

  68:                  return Session["worker"] as CustomBackgroundWorker ??

  69:                      (Session["worker"] = new CustomBackgroundWorker()) 

  70:                      as CustomBackgroundWorker;

  71:              }

  72:              set { Session["worker"] = value; }

  73:          }

  74:   

  75:          protected void zViewResponse_Click(object sender, EventArgs e)

  76:          {

  77:              /* some effects for show-off */

  78:   

  79:              bool show = zViewResponse.Text == CollapsedText;

  80:              zViewResponse.Text = show ? ExpandedText : CollapsedText;

  81:   

  82:              if (show)

  83:                  zCodeResponse.Effects.Add(

  84:                      new EffectParallel(

  85:                          new EffectMorph("width: 650px; height: 450px;", 0.5M),

  86:                              new EffectAppear(0.5M)));

  87:              else

  88:                  zCodeResponse.Effects.Add(

  89:                      new EffectParallel(

  90:                          new EffectMorph("width: 0px; height: 0px;", 0.5M),

  91:                              new EffectFade(0.5M)));

  92:          }

  93:      }

  94:  }

   1:  namespace Gaia.WebWidgets.Samples.Combinations.WebUtilities.AsyncLoading

   2:  {

   3:      using System;

   4:      using System.Collections.Generic;

   5:      using System.Threading;

   6:      using Utilities;

   7:   

   8:      public class CustomBackgroundWorker

   9:      {

  10:          private bool _isRunning;

  11:          public bool IsRunning

  12:          {

  13:              get { return _isRunning; }

  14:          }

  15:   

  16:          public void RunTask()

  17:          {

  18:              lock (this)

  19:              {

  20:                  if (_isRunning)

  21:                      throw new InvalidOperationException("The task is already running!");

  22:   

  23:                  _isRunning = true;

  24:                  new Thread(DoWork).Start();

  25:              }

  26:          }

  27:   

  28:          private ICollection _data;

  29:          public ICollection Data

  30:          {

  31:              get { return _data ?? (_data = new List()); }

  32:          }

  33:   

  34:          void DoWork()

  35:          {

  36:              try

  37:              {

  38:                  for (int i = 0; i < 15; i++)

  39:                  {

  40:                      lock (Data)

  41:                          foreach (CalendarItem item in CalendarController.CreatItems(new Random().Next(1, 3)))

  42:                              Data.Add(item);

  43:   

  44:                      Thread.Sleep(new Random().Next(300, 2000)); // Random Sleep to simulate variance

  45:                  }

  46:              }

  47:              catch  { /* Task failed (suppress exceptions in demo) */ }

  48:              finally { _isRunning = false; }

  49:          }

  50:      }

  51:  }