The xmas spammer

by Administrator 27. December 2005 16:16
I have always had a small amount of spam on this site.  I checked my email on christmas day to discover I had 6000 referral spam instances (I had the blog engine set up to email me) waiting for me.  I will be temporarily turning off all the trackback, pingback, and referral features until I get time to upgrade the engine later this week.

Tags:

Invoking and Delegates

by Administrator 20. December 2005 17:19

As promised, I have some ideas regarding Async code for beginners.  Part one of three.

Compact Framework

The first thing to learn when doing asynchronous programming on the Compact Framework is that it is not as forgiving as the full .NET framework.  Threading things that might be a problem on a Pentium IV will be a problem on a 400mhz XScale.  The first problem you may run into, since its not well documented is Thread priorities.  You may want to give your "worker" threads more CPU time than the UI thread.  While the thread priority method exists on the thread class in the CF it is unofficially unsupported in CF 1.0.  I have tested this on at least 3 different devices with both CE.NET 4.2 and Windows Mobile and any attempt to set a thread priority locks up execution and debugging.

Your UI is running on a thread that processes events and updates UI controls.  In fact the compact framework starts quite a few threads you have no control over, for exampleTCP listeners and such when you execte web services.  Any attempt to access a GUI control's properties from outside this UI thread could cause unexpected behavior, including the program locking up and no longer responding.  Often you can get away with reading a control's properties without locking up, but setting a Label Text property is much more likely to cause a deadlock.  The way you access a control's properties from your worker threads, then, is using Control.Invoke.  The method description for Control.Invoke says:

"Executes the specified delegate on the thread that owns the control's underlying window handle."

That should be fairly straight forward.  There is a Message Pump running.  Every time something happens in GUI code that changes some visual aspect of a control it occurs as the Message Pump dispatches messages.  Code you call directly from the UI thread automatically gets executed this way,  Control.Invoke gives you a way to execute some code from within this message pump without exposing the internals to you.  On Compact Framework 1.0 only the version of Control.Invoke that takes a no-arguments Delegate is supported.  In CF 2.0, Control.Invoke (Delegate, object[]) is also supported, which eliminates the need for the following tip:

Since you cannot pass arguments to Control.Invoke in CF 1.0 you may need a way to communicate with your UI controls from a worker thread.  For example, suppose you have a custom sync process running on a worker thread and you want to update a Label each time a table is processed with the name of the next table name.  I would argue that the worker thread having any knowledge of the UI controls is bad, so you need a better means of communicating.  The Mediator/Director pattern from the GOF design patterns book provides a solution.  Consider the following:

On the Worker thread class:

OnPullStart(new PullStartEventArgs("Next Table Name"));

...

public event PullStartEventHandler PullStart;
        protected void OnPullStart(PullStartEventArgs e)
{
  if (this.PullStart != null)
  {
    PullStart(this, e);
  }
}

On the Director we have a method or property we can talk to which keeps the UI control decoupled from other classes:

...
public string SyncMessage
{
get{ return _syncMessage;}
set
{
_syncMessage = value;
_someControl.Invoke( new EventHandhler(_someControl.SyncMessageChanged));
}
}
...

On the GUI control owning the Label, which also kicked off the worker thread, you supply an EventHandler:

public void SyncMessageChanged(object sender, EventArgs e)
{
  _someLabel.Text = Director.Instance.SyncMessage;
}

Note that in some cases you may wish to synchronize access to the value from the Director.  Every application is different.  This is a somewhat simplified example.  In my real applications I typically have a "Context" (Possibly State pattern) object of some kind which keeps State for me, and the Director just fires messages.  There are different techniques to use, but I will offer some tips:

  1. Whenver dealing with updating the UI, always be concious of "What thread is this method being called from?"
  2. In light of #1, be sure ALL code that touches GUI components has come from an invoke method.  Sometimes even Querying a Control's property from outside the UI thread can cause a lockup.
  3. Use Events on a worker thread to signal a significant event that a client class may be interested in.
  4. Do not pass instances of your controls to worker threads so that the worker can call Invoke, use a technique that decouples the worker thread from any classes that might subscribe to the worker class's events.

Modal Mixing

The very excellent OpenNETCF libraries for the .Net compact framework provides some extended functionality for processing windows messages.  Much of this is in the ApplicationEx class, allowing you to run your GUI's main form using ApplicationEx.Run( new MyForm() );.  I have also experienced different GUI lockup situations where different ShowModal() and MessageBox calls are mixed.  If you need to show a modal Form be sure to use the new ApplicationEx.ShowDialog(Form, bool dispose) rather than Form.ShowDialog(); this will ensure the form is blocking the correct message pump.

The next threading article will be a short one discussing a couple of easy performance tricks you can use Threads for in ASP.NET.  In the article after that I will show some other threading techniques.

Tags:

Thinking Async and Optimization

by Administrator 14. December 2005 17:27

.NET Architect, gourmet cook, and all-around good guy Matt Terski confided in me once that the great hurdle in getting peolpe to understand SOA was not teaching them transport protocols and such but getting them to Think Asynchronously.  I have posted before about how the Cage Builder culture in some organizations tells developers to "Never use threads".  This is a barrier to responsive apps, great performance, and adoption of SOA.

For my current client I built another custom data synchronization process for a mobile device.  We are not using Merge Replication for any number of reasons, mostly because of the constraints it puts on your database schema.  This sync process runs over a Sprint Airlink modem mounted on a truck; the speed of the modem is entirely dependent upon the quality of the connection it has at any given time.  Since the trucks could be in the middle of nowhere or surrounded by power lines I'm lucky to get 4k/s on some days.  A normal sync was taking about 3 and a half minutes and I was asked to optimize it.  We are moving to SQL Mobile in Q2 2006 but that doesn't help us today so I sat down to see what I could do to make this faster.

Long story short, I have it to just under one minute now.  They are pleased.

Most of the Performance talk you see going around deals with things like "avoid boxing", "use StringBuilder", "stored procedure", etc.  Those are the last things I look at, the first things are improving the efficiency of data stores and Asynchronous processing. 

Improving the efficiency of your database is a huge topic and one that I am only now becoming more familiar with.  My current sync process is largely based on DateLastChanged fields on various tables, and some of those are large for SQL CE, say 20,000 rows.  Adding an Index on the DateLastChanged fields of some large tables changed the operation from Table Scan to Bookmark seek, and took many seconds off of my times.  There is no execution plan viewer on SQL CE 2 to prove that statement, but the proof is in the performance. 

The larger part of my 300% improvement was "Processing Item A while waiting on Item B to be done". I am going to write three articles as I get time about some very simple Practices I use to keep me honest and reap the benefits of Thinking Asynchronously.  My 3-part intro to threading will consist of:

  1. Control.Invoke practices for the CF and Delegates in ASP.NET
  2. Practices for Work Item constructs
  3. Thread Signaling

Tags:

About the author

Damon Payne is a Microsoft MVP specializing in Smart Client solution architecture. 

INETA Community Speakers Program

Month List

Page List

flickr photostream