devplanet.com

Thread Safe Library Update

Brian Rudolph — Wed, 02 Sep 2009 16:33:00 GMT

As always, my life revolves around threading. So I have a few classes that I use frequently for these purposes. Now, fortunately, .NET 4.0 will include much of this functionality in PFX, but for now, we have this.

ThreadSafeLibrary

AutoProcessingQueue: This is a queue that as you add things to it, will automatically begin dispatching on a seperate thread and begin calling a specified delegate to process the items.

Batch: This is a class that is similar to a queue except that it allows you to do work in batches. Set the max & minimum sizes, and start adding items to it. When it reaches a certain size it will attempt to close the batch and will fire an event that will allow you to wire in code for processing the data in the batch. It also has a timer that can be enabled if you'd prefer to allow the batch to be closed at a certain interval. This is great for database calls and bulk inserts. Say I want to send a series of messages, but i don't want to send them one at a time. I would like to send the messages when the batch reaches 100 items, or every 5 seconds. I use this class alot for messaging.

Dispatcher: This is the class that does the heavy lifting for the majority of things in this library. You give it a maximum number of threads to work with, and as you add workers to it's queue, it will begin spawning threads to process them(carefully re-using them whenever possible)

ResourcePool: The dispatcher uses this internally to store & manage it's threads. Though it can be used for any object type. One case where i use this frequently is to pool connections to webservices. To save the time required to open and close connections constantly, i set up a pool, give it a threshold(so as to not flood the service i'm calling) and ask it to get the resource for you via the delegate you provide.

ThreadSafeDictionary<K,V>: The classic threadsafe implementation of a dictionary, with several added methods to support atomic operations.

ThreadSafeQueue<T>: The classic Queue implementation of a dictionary, with several added methods to support atomic operations.

ThreadSafeHashSet<T>: The classic HashSet implementation of a dictionary, with several added methods to support atomic operations.

ThreadSafeStackList<T>: This is similar to a stack, without alot of the limitations. Multi-level peek, unwind, etc.

AsyncBlock:
This is a class that allows you to wrap async work into serial action for the purposes of simplicity. If you need have a function that needs to run numerous asynchronous calls, and then return only when they are all finished, this is your class.

You can use it like so:

     public class AsyncSample
    {
        private Dispatcher Dispatcher;


        public AsyncSample()
        {
            //init a dispatcher that uses 5 threads and doesn't carry execution context
            Dispatcher = new Dispatcher(5, false);
        }


        public void ExecuteParallel<T>(IList<T> work)
        {
            var workers = ConstructParallelWorkers(work);


            //the async block will pause this thread until all workers finish
            using (AsyncBlock block = new AsyncBlock(this.Dispatcher, 10))
            {
                foreach (var worker in workers)
                {
                    block.AddToQueue(worker);
                }
            }
        }


        private IList<AnyWorkerBee<T>> ConstructParallelWorkers<T>(IList<T> work)
        {
            var workers = new List<AnyWorkerBee<T>>();


            foreach (var workUnit in work)
                workers.Add(new AnyWorkerBee<T>() { WorkUnit = workUnit });


            return workers;
        }
    }

Thirsty Developer Interview Posted

Chuck — Tue, 28 Apr 2009 22:26:00 GMT

For those of you interested, I have recorded an interview with The Thirsty Developer (http://www.thirstydeveloper.com). The interview is based around a user group presentation that I give about the new features of SQL Server 2008 for developers.

I do need to clarify one statement in the interview. We were talking about spatial data and support for the Z dimension. We talk about SQL Server's support for Z, and I want to clarify that SQL Server will allow you to store the Z dimension with points but it will not use Z in calculations.

Thank you to Larry Clarkin and Dave Bost for inviting me to participate in their project.

Chuck

SQL Server 2008 Backup Compression

Chuck — Tue, 21 Apr 2009 03:00:00 GMT

With SQL Server 2008, Microsoft introduced native backup compression. Prior to SQL Server 2008, the only way to get real-time backup compression was to buy a third-party tool. There were – and still are – several third-party tools on the market. I have used a few of them, and they each have their pros and cons. But, this post is not to debate the merits of the different tools – it is to discuss the native functionality that ships with SQL Server 2008.

If you’ve ever used an off-the-shelf compression utility (such as WinZip) on a SQL Server native backup, you’ve probably noticed that they usually compress down quite well. I’ve seen certain backups compress down 75% or more. The problem with this method is that you need a lot of disk to make it happen. If you have a 10GB database, a full backup will take 10GB of disk space. If that backup achieves 75% compression, if will end up taking up 2.5GB of disk space. The problem is that you really need 12.5GB of disk to get to a 2.5GB compressed backup (10GB for the initial backup then an additional 2.5GB for the compression). Now, increase the size of your database by 10 or 100 times. Do you really have an extra 1TB of disk lying around so that you can end up with a 250GB backup? I certainly don’t.

This is where SQL Server’s native backup compression can really help. The compression happens as the data is being written to disk, not after it is there. So, if you have a 10GB database that will achieve 75% compression, you only need 2.5GB of disk to perform the backup – not 10GB like you would without compression.

From my experience, the native backup compression performs quite well, although your mileage may vary. You will have additional processor overhead above and beyond the overhead required for a standard backup, but in my testing the overhead was comparable to what I was getting with several of the third-party tools.

I don’t want it to sound like I’m against the third-party tools. I still use a third-party backup utility where it makes sense. Remember that the native backup compression won’t fit all situations – most of the third-party tools include encryption and other features that are not included in the native solution – and there isn’t a nice management console like what you get with the third party tools. But, if you can live without these added features, you might be able to save some money by using the native backups.

The best advice that I can give you is to give it a try and gather metrics to compare your third-party tool to the native compressed backups. Look at the backup time, restore time, processor utilization and final compressed size. If your experiences are similar to mine, I am guessing that you will be quite impressed.

Chuck

PASS Call for Presentations - You've Got Through April 24, 2009

Chuck — Mon, 20 Apr 2009 00:59:00 GMT

Those of you who know me know that I am a big supporter of the Professional Association for SQL Server (PASS). I have been involved with this organization since 2000 - when I spoke at their North American conference in San Francisco. Since then I have held a variety of volunteer positions including author, editor, presenter and - for a few years - member of the Board of Directors.

I can't express enough how important I believe this organization is to the SQL Server community. The annual conference is a hotbed of SQL Server education. In my opinion, you won't find any better source for high-end, high-quality SQL Server speakers and presentations. In reality, PASS is much more than the annual conference - but I'm here to talk about the conference.

Each year PASS requests presentation abstracts from members of the SQL Server community. It has been like that all along (that's how I got my start with PASS). The non-Microsoft speaking slots at the conference are filled by a committee of volunteers who review and evaluate the submissions that are received. This is a daunting task, and I truly appreciate the people who do it.

I would like to encourage anyone who has ever thought - or even if you have never thought - about presenting at a conference to hit www.sqlpass.org and submit an abstract. If you've got something that others might be interested in hearing about, write it up. Speaking at an event like this is not as hard as you might think - it's actually quite fun.

You can submit up to four abstracts. Now go forth and submit!

Chuck

HashSet Deserialization Oddities

Brian Rudolph — Wed, 25 Mar 2009 14:15:00 GMT

So, yesterday was a fun day. I spent all day trying to debug a state in which one of your QA web servers' worker processes would go into an infinite loop and peg a core on the CPU. After many hours, and finally installing the remote debugging tools on the server, I eventually found the problem - removing an item from a HashSet. ?!?

So let me set the scenario up. I have a website that runs in a farm, so I utilize SQL for state management. As you probably already know, all objects that go into state are binary serialized, forwarded to the SQL server, and then fetched and deserialized upon request after the next page load.

I have a state object that is placed in to session state. It contains some state that is a HashSet<Guid> object. The first time this object is put into state, it is empty. I then retrieve it and place a few guids into it. This is where it gets odd. If i browse the object after I add the guids to it, it appears that some of them go in to the set as Empty Guids, regardless of their value when i actually added them. This is after the set has been deserialized from state empty, then values added to it.

Interestingly enough, it actually adds multiple duplicate keys to the set, which is natively not permissable. Under normal circumstances, were I to add Guid.Empty into a hashset 3 times, it will only appear in the set once. Not in this case. It appears that the set is checking for uniqueness with the real value being passed in, detects that the value is unique, yet after the value is added it is actually added as Guid.Empty. So this would be crazy enough... but thats not where the story ends.

Now, a few methods away I am tearing through the values in the set, and removing ones that meet a certain condition. Except that since I am receiving empty guids back for most of the items i put in the set, these are always meeting my removal condition. Aside from the craziness, this shouldn't be a huge problem, except that when i go to remove one of the empty guids from the set, within framework code it gets stuck in an infinite loop. I have not Reflected this to see where, but i would guess that it is not pleased having duplicate keys internally. Interestingly enough, if i replace the hashset with a List<Guid>, all is well.

So here's the kicker. This is not reproducible on my development box, only on this QA server. The possible reasons are many. For instance, my dev box runs .Net 3.5 SP1, while the server is running without SP1. My dev box is running Vista x64 hosting under cassini, while the server is running Server 2008 x64 hosting under IIS 7. My guess for the culprit would be the former. I am upgrading the server to SP1 today to see if that resolves the issue.

I will update this post with the results.

MSCS Clusters, iSCSI, Distance Clusters and SQL 2005

Michael Steineke — Sat, 07 Mar 2009 05:30:00 GMT

This has been a fun week with clustering. Myself and a few others have been working this week on setting up a couple lab environments.

Lab 1:
2 - Hyper-V Windows 2003 R2 Enterprise 64Bit VM's
iSCSI LUNS
MSCS Shared Quorum Cluster
1 - SQL Server 2005 sp2 3159 clustered instance

Lab 2:
2 - Dual Quad Core Xeon servers running Windows 2003 R2 Enterprise 64Bit
SAN attached LUNS
MSCS Shared Quorum Cluster
1 - SQL Server 2005 sp2 3159 clustered instance

The kicker with LAB 2 is that the two servers are ~850 miles apart using two different SAN's, but more on that later. Lab 1s configuration went smoothly, having not done iSCSI in a cluster before this install it was a learning experience, but overall very similar to using FC attached disk. The process that Brian has posted for configuring MSDTC in a Cluster was helpful, and worked perfectly.

Lab 2 was slightly more complicated, but only because of having a few more steps; it is using Unisys SafeGuard 30m Clustering. The Unisys documentation was spot-on; it covered every step necessary to configure everything in 30m, as well as MSCS.

Above is the basic configuration for the distance cluster.

The SQL servers have a splitter driver loaded on them that splits all writes to the cluster disk resources to both the SAN and the 30m appliances via the SAN Fabric. The 30m appliances then handle all of the block level replication to the distance SAN, as well as provide control resources to MSCS to make sure all of the disk is consistent prior to brining the resources on-line. The whole system is very cool, and in my opinion under-marketed.

SQL Server 2008 Upgrade Woes

Chuck — Mon, 02 Mar 2009 22:37:00 GMT

I’ve been working on upgrading an application from SQL Server 2005 to SQL Server 2008. Simple process, right? Well, I ran into a few issues along the way that I thought I would share with you.

First, make sure that your processor configuration matches your affinity mask. You might be thinking that I’m crazy right now, but it is a problem that I think more people will run into. Take the following example:

You are planning to upgrade a production system and you want to test it before you do the upgrade. Your production server has 8 processor cores and you have an affinity mask set to use cores 0, 2, 4 and 6. You take a P to V image of your production system and stand it up in a virtual environment (such as HyperV), but that virtual environment only has 4 processor cores configured.

In this scenario, the upgrade will fail. The user interface will not tell you exactly what went wrong…rather it will direct you to a log file that is extremely full of information. When you finally find the error message in the log file, you will find that it could not do the upgrade because the affinity mask could not be set.

I noticed this when one of my development servers (an 8 core Itanium) was rebooted and only had four cores available when it came back up. Once I got the other four cores online, the upgrade was able to complete.

The other issue came out of restoring databases. I currently use ToolX (name withheld because I don’t know if it is the cause) for my production backup software. When I upgraded to SQL Server 2008, I used ToolX to restore backups from one of my SQL Server 2005 environments into SQL Server 2008. The backups appeared to complete successfully, but when I ran a DBCC CHECKDB on them, some of them had consistency errors that did not exist in the original that the backups were pulled from. I had to do a repair_allow_data_loss to get the databases usable again.

I haven’t nailed down what the exact cause of the second problem is, but I will post a follow-up when I know.

Inline Asynchronous UI Coding using IDisposable in C# .NET

Brian Rudolph — Mon, 15 Dec 2008 17:00:00 GMT

I recently watched this video on the PowerThreading library: http://blogs.msdn.com/charlie/archive/2008/12/03/jeff-richter-video-on-asynchronous-programming-and-his-power-threading-library.aspx

This is very interesting as Jeff Richter utilizes a strange behavior in the way the C# compiler works with IEnumerables to make a useful and easy-to-use async library. His primary goal was to allow a website\service yield processing during I/O operations, which can provide for better scalability in your app tier.

While this is quite interesting, I personally would avoid using strange compilation patterns to my advantage in an application. Specifically because you have no assurance that the compiler will always do this as the language and subsequent compilers evolve. What I was interested in was the mechanism for including asynchronous calls into code without using a complex series of callbacks.

Now, to be quite fair, Jeff's implementation was an attempt to limit thread spawning, and context switches. I am not going to account for this. I am more interested in parrallel processing.

Let me give you an example. Take for instance a series of objects that the UI is going to take cues from and make subsequent database calls to retrieve extra data for. A simple example is a treeview. If I have a bunch of nodes in a tree and the UI requires that I display the child node or items count for each of these nodes. What you would generally do is loop through the objects and call the DB to retrieve the data, and assign the UI components in one serial block of code. The problem with this is that the database is more than likely capable of servicing the request for numerous nodes simultaneously, but in the UI we are implementing this serially. If the tree structure is complex, and you are showing more than just a node count, it is plausible that each of these requests will take upward of 50ms. If you have several dozen nodes being displayed this can easily add seconds to your response time.

A serial block of code might look like this:

TreeNodeCollection nodes = new TreeNodeCollection();
foreach (TreeNode node in nodes)
{
     int objectCount = database.DoSomething((MyObject)node.Tag); //call the database
     node.Text = String.Format("{0} ({1})", node.Text, objectCount); //update the UI
 }

Simple and clean, but slow.

Why not do all of these calls asynchronously, wait for all of the results to filter in, and then update the UI? This should surely be faster than a serial operation. Let's say, we spawn Math.Min(nodes.Count, 10) threads to accomplish this task. So at a maximum, we will use 10 threads to do the work. If we have 20 nodes, it should take at the longest 2 times as long as the longest running call.

The usual issue with this is that it requires you to use several call-back methods, do complicated thread monitoring, and subsequently put the UI into a wait state until all of the external threads have finished. Unfortunately there just is no simple way to do it.

So I got to thinking, what construct can I use to signal an asynchronous block, that would prevent execution beyond it's bounds until all the threads were done. The answer, IDisposable. If I created an IDisposable object and wrapped it in a "using" I could prevent the Dispose method from exiting until all the threads have finished.

Utilizing the rest of my Threading objects, this should be fairly simple to accomplish, all I had to do was add a done flag to my workerbee:

public class AsyncBlock : IDisposable
{


        long timeoutMS = 0;
        Dispatcher dispatcher = null;
        bool started = false;

        public AsyncBlock() : this(10) { }

        public AsyncBlock(int timeoutSeconds) : this(timeoutSeconds, 5) { }

        public AsyncBlock(int timeoutSeconds, int threads) : this(new Dispatcher(threads), timeoutSeconds) { }

        public AsyncBlock(Dispatcher dispatcher, int timeoutSeconds)
        {
            this.dispatcher = dispatcher;
            this.timeoutMS = timeoutSeconds * 1000;
            this.WorkQueue = new List<WorkerBee>();
        }


        private IList<WorkerBee> WorkQueue
        {
            get;
            set;
        } 


       public IList<WorkerBee> GetWorkers()        
       {
            return new List<WorkerBee>(this.WorkQueue);
        } 


        public void AddToQueue(WorkerBee bee)
        {
            this.WorkQueue.Add(bee);
            this.dispatcher.AddToQueue(bee);
            started = true;
        }


        public void Start()
        {
            foreach (WorkerBee bee in this.WorkQueue)
                if (!bee.Done)
                    this.dispatcher.AddToQueue(bee);


            started = true;
        }


        public void Dispose()
        {
            if (!started && WorkQueue.Count != 0)
            {
                throw new Exception("Work was never started");
            }


            System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
            watch.Start();
            bool done = false;

            while (!done)
            {
                done = true;
                foreach (WorkerBee bee in WorkQueue)
                {
                    if (!(done = done && bee.Done))
                        break;
                }
 


                if (watch.ElapsedMilliseconds > timeoutMS)
                    throw new TimeoutException("Timeout elapsed");
 
                if (!done)
                    Thread.Sleep(1); // wait 1ms to try again
            }
 
            watch.Stop();
        }
}


public class DatabaseWorkerBee<RefType, ReturnType> : AnyWorkerBee<Delegate>
{
        public delegate ReturnType DBDelegate();
        private DBDelegate dbDelegate;

        public ReturnType ReturnValue
        {
            get;
            set;
        } 


        public RefType ReferenceObject
        {
            get;
            set;
        } 


        public DatabaseWorkerBee(RefType refObject, DBDelegate del)
        {
            this.ReferenceObject = refObject;
            dbDelegate = del;
        } 


        protected override void WorkStart()
        {
            base.WorkStart();
 
            if (dbDelegate != null)
            {
                ReturnValue = dbDelegate();
            }
        }
    }

Alright, this is now a fairly simple implementation in the UI:

IList<WorkerBee> workers = null;


using (AsyncBlock block = new AsyncBlock(30, Math.Min(nodes.Count, 10))) // do these async with a 30 second timeout
{
      foreach (TreeNode o in nodes)
      {
          TreeNode node = o; //must declare this in the loop, or you get the same object in every worker, this is a documented closure bug in the framework
          block.AddToQueue(
              new DatabaseWorkerBee<TreeNode, int>( node, delegate { /* Do Database Call Here using the node object*/; }));
       }


      workers = block.GetWorkers()


}//using will not return until all workers have been processed.


foreach (WorkerBee worker in workers)
{
      DatabaseWorkerBee<TreeNode, int> dbworker = worker as DatabaseWorkerBee<TreeNode, int>;
      dbWorker.ReferenceObject.Text = String.Format("{0} ({1})", dbWorker.ReferenceObject.Text, dbWorker.ReturnValue); //update the UI
}

Woot! All of the nodes are executed async, and all of the values are returned properly. One thing to note, notice I am declaring a redundant TreeNode object inside the loop. This is necessary, since we are using an anonymous method inside of the loop. If we were to just reference the "o" in the iterator, we would get the same object passed to each anonymous method.

My Threading Objects can be found here: ThreadLib.zip

[Edit]
After further review and testing this code works quite well, except in the instance of windows authenticated database connections. Because we are spawning new threads, and your security context is thread based, all of the subsequent database calls were made using the applications default user. This isn't a problem in Windows UI's but in Web apps this is not good. It could be as simple as setting the new threads to the same security context as the spawning thread, but I'm not sure I want that to happen for every thread. I will work this out and do an update.

I have worked this security context issue out. If anyone is interested in it, email me.

PASS Community Summit Recap

Chuck — Thu, 04 Dec 2008 01:18:00 GMT

This year was my last year as a member of the leadership of the Professional Association for SQL Server. I will still be involved with the organization, but will be rolling off of the Board of Directors at the end of my 2 year term in December.

That made this event a little different for me. I've been at 9 of the 10 US PASS conferences - the only one that I missed was the first one. I've attended them in a variety of capacities - speaker, board member and even general attendee.

This year was the largest PASS conference ever. It included three amazing keynotes. My favorite was given by Dr. David DeWitt. Dr. DeWitt is a Technical Fellow with the Gray Systems Lab in Madison, WI (which is located just an hour down the road from me). The keynote contained no marketing - the entire presentation was about the theory and research that goes into building high performance scalable database systems. It was one of the best technical lectures that I have ever attended.

There were over 120 technical sessions at this conference - and I did manage to make it to a few of them. One of my goals for the conference was to meet as many Microsoft employees as I could, and I think I did quite well for myself. I also served as the moderator for a panel debate on the pros and cons of NULL. The panel consisted of 5 SQL Server MVPs, and one guy who should be one. The session was well attended and the debate got quite heated at times. Who would have thought that a debate about nothing would be so well received?

Next year's PASS conference is again going to be held in Seattle. The dates are November 3 - 6, 2009. I encourage anyone who is interested in the best SQL Server education for the money to attend.

That's it for now...got to get back to installing MOSS and PerformancePoint - but that's another blog post entirely.

Chuck

More Threading Goodness!

Brian Rudolph — Wed, 26 Nov 2008 20:48:00 GMT

Threading - I write about it a lot, even though i would consider myself somewhat of a rookie when it comes to threading complexities.

One of the challenges we often find when trying to incorporate threading into applications is managing work units, thread pools, and queues. What I've ended up doing is writing a few helpers to accommodate just these things.

To start, we need to manage a pool of available thread resources. This pool needs to have a limit, and needs to be able to generate threads on the fly if necessary. However, the need for resource pools is not limited to threading. Consider the scenario where you have a web service of some sort, being WSE, FTP HTTP whatever. There is a lot of overhead in opening and handshaking for these connections. If I had say a list of 100k files I needed to upload, and wanted to do that asynchronously, I wouldn't want to throw away the connection after every upload. So I need to do simple connection pooling. But I don't want to open 10 connections immediately if I am only going to need 2 either, so this pool needs to be dynamic.

To even start writing a pool, we need some sort of queuing class for resource storage, and in the threaded world, this needs to be thread safe.

So a simple wrapper may look something like this:

public class ThreadSafeQueue<T>
    {
        //This is the internal queue that we are wrapping
        Queue<T> queue = new Queue<T>();
 
        [NonSerialized]
        ReaderWriterLockSlim objLock = Locks.GetLockInstance(LockRecursionPolicy.NoRecursion); //setup the lock;
 
        public int Count
        {
            get
            {
                using (new ReadOnlyLock(this.objLock))
                {
                    return this.queue.Count;
                }
            }
        }
 
        public void Clear()
        {
            using (new WriteLock(this.objLock))
            {
                this.queue.Clear(); ;
            }
        }
 
        public bool Contains(T item)
        {
            using (new ReadOnlyLock(this.objLock))
            {
                return this.queue.Contains(item);
            }
        }
 
        public bool TryDequeue(out T obj)
        {
            using (new ReadLock(this.objLock))
            {
                if (this.queue.Count != 0)
                {
                    obj = this.Dequeue();
                    return true;
                }
            }
 
            obj = default(T);
            return false;
        }
 
        public T Dequeue()
        {
            using (new WriteLock(this.objLock))
            {
                return this.queue.Dequeue();
            }
        }
 
        public void Enqueue(T item)
        {
            using (new WriteLock(this.objLock))
            {
                this.queue.Enqueue(item);
            }
        }
 
        public T Peek()
        {
            using (new ReadOnlyLock(this.objLock))
            {
                return this.queue.Peek();
            }
        }
    }

Then we can move on to the Resource Pool, which we want to be generic so that it can serve up any kind of resource, be it a thread, a web service connection, a widget of any sort.

public class ResourcePool<T> : IDisposable
        where T : class
    {
 
        public event EventHandler CreatedResource;
        public delegate T CreateResourceDelegate();
        public delegate bool CanReuseResourceDelegate(T obj);
 
        public ResourcePool(CreateResourceDelegate creatorDelegate, CanReuseResourceDelegate checkerDelegate)
        {
            this.MaxResourceCount = 10;
            this.IterationTimeout = 5;
            this.MaxRetry = 100;
            this.Creator = creatorDelegate;
            this.CheckResource = checkerDelegate;
        }
 
        private CreateResourceDelegate Creator { get; set; }
 
        private CanReuseResourceDelegate CheckResource { get; set; }
 
        /// <summary>
        /// Retreives a resource from the pool.
        /// </summary>
        /// <returns></returns>
        public T Get()
        {
            T obj = null;
            try
            {
                int tries = 0;
                while (obj == null && (this.MaxRetry == 0 || tries++ <= this.MaxRetry))
                {
                    if (Queue.Count == 0)
                    {
                        if (this.MaxResourceCount == 0 || (this.MaxResourceCount > this.ActiveResourceCount))
                        {
                            if (this.Creator == null)
                                throw new NullReferenceException("Unable to create new Resource Instance");
 
                            obj = this.Creator();
                            FireEvent(ref this.CreatedResource);
                        }
                        else
                        {
                            Thread.Sleep(this.IterationTimeout); // wait for one to become available if we can't create one.
                        }
                    }
                    else
                    {
                        obj = Queue.Dequeue();
                    }
                }
            }
            finally
            {
                Interlocked.Increment(ref this._ActiveResourceCount);
            }
 
            if (obj == null)
                throw new NullReferenceException("Unable to retrieve Resource Instance");
 
            return obj;
        }
 
        /// <summary>
        /// Returns a resource to the pool.
        /// </summary>
        /// <param name="obj"></param>
        public void Release(T obj)
        {
            try
            {
                if (this.MaxResourceCount == 0 || Queue.Count < this.MaxResourceCount)
                {
                    if (this.CheckResource == null || this.CheckResource(obj))
                    {
                        Queue.Enqueue(obj);
                    }
                }
            }
            finally
            {
               Interlocked.Decrement(ref this._ActiveResourceCount); //decrement counter so we know we can reuse the resource.
            }
        }
 
        private int _ActiveResourceCount;
         
        /// <summary>
        /// This is the maximum number of resources the pool will hold and subsequently attempt to create.  Default is 10.
        /// Set to 0 enables no limit.
        /// </summary>
        public int MaxResourceCount { get; set; }
 
        /// <summary>
        /// This is the maximum number of times the pool will look for or attempt to create a resource.  Default is 100.
        /// Set to 0 enables no limit.
        /// </summary>
        public int MaxRetry { get; set; }
 
        /// <summary>
        /// This is the length of time(in milliseconds) that the pool will wait between tries to get a resource. Default is 5ms.
        /// </summary>
        public int IterationTimeout { get; set; }
 
        private ThreadSafeQueue<T> Queue
        {
            get { return this._Queue; }
        }readonly ThreadSafeQueue<T> _Queue = new ThreadSafeQueue<T>();
 
        private void FireEvent(ref EventHandler targetEvent)
        {
            Eventing.FireEvent(ref targetEvent, this);
        }
 
        public void Dispose(bool disposing)
        {
            if (disposing)
            {
                this.Queue.Clear();
            }
        }
 
        public void Dispose()
        {
            this.Dispose(true);
        }
    }

I know I am tearing through this quickly, but it's a lot to explain.

Now we need to have some sort of managed work unit that the thread can work on. We want it's work unit to be generic and should be easily derived from:

public abstract class WorkerBee
    {
        public WorkerBee() { }
 
        public abstract void Start();
    }
 
    public abstract class WorkerBee<T> : WorkerBee
    {
        public T WorkUnit { get; set; }
    }
 
    /// <summary>
    /// This worker can be used as it.  Subscribe to the WorkBegan and WorkFinished events to inject logic.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class AnyWorkerBee<T> : WorkerBee<T>
    {
        public delegate void WorkerEventHandler(WorkerBee<T> sender);
        public event WorkerEventHandler WorkBegan;
        public event WorkerEventHandler WorkFinished;
 
        protected virtual void OnWorkBegan()
        {
            if (this.WorkBegan != null)
                this.WorkBegan(this);
        }
 
        protected virtual void OnWorkFinished()
        {
            if (this.WorkFinished != null)
                this.WorkFinished(this);
        }
 
        protected virtual void WorkStart()
        {
            this.OnWorkBegan();
        }
 
        protected virtual void WorkFinish()
        {
            this.OnWorkBegan();
        }
 
        public virtual void DoWork() { }
 
        public override void Start()
        {
            this.WorkStart();
            this.DoWork();
            this.WorkFinish();
        }
    }

Now we can look at the actual dispatcher, we need some way to add work to a queue, have it spawn a thread if it has any left, and then execute the work. One of the tricky things was to make sure the dispatcher thread was not ALWAYS running. It would start itself up anytime work was added, continue running and waiting until it's work queue was empty, then shut down. Every subsequent addition to the queue would ensure that the dispatcher was still running.

 
public class Dispatcher : IDisposable
    {
        public Dispatcher(int maxThreadCount)
        {
            this.Threads = new ResourcePool<Thread>(
                new ResourcePool<Thread>.CreateResourceDelegate(this.CreateThread),
                new ResourcePool<Thread>.CanReuseResourceDelegate(this.ValidateThread));
 
            this.Threads.MaxRetry = 0;
 
            this.WorkQueue = new ThreadSafeQueue<WorkerBee>();
 
            this.Threads.MaxResourceCount = maxThreadCount;
            this.EnsureDispatch(false); // setup the dispatcher
        }
 
        /// <summary>
        /// Call this to stop the dispatcher
        /// </summary>
        public void Abort()
        {
            this.AbortDispatch = true;
        }
 
        /// <summary>
        /// Call this to pause the dispatcher
        /// </summary>
        public void Pause()
        {
            this.AbortDispatch = true;
        }
 
        /// <summary>
        /// Call this to resume the dispatcher
        /// </summary>
        public void Resume()
        {
            if (this.AbortDispatch)
            {
                this.AbortDispatch = false;
                this.EnsureDispatch();
            }
        }
 
        /// <summary>
        /// Set this to prevent the dispatcher from spawning threads.
        /// </summary>
        private bool AbortDispatch
        {
            get;
            set;
        }
 
        /// <summary>
        /// This is the thread that will dispatch work to other threads.
        /// </summary>
        private Thread DispatchThread
        {
            get;
            set;
        }object _DispatcherLock = new Object();
 
        /// <summary>
        /// This will make sure that the Dispatcher is active and running.
        /// </summary>
        private void EnsureDispatch()
        {
            this.EnsureDispatch(true);
        }
 
        /// <summary>
        /// This will make sure that the Dispatcher is active and running.
        /// </summary>
        private void EnsureDispatch(bool start)
        {
            lock (this._DispatcherLock)
            {
                if (this.DispatchThread == null || this.DispatchThread.ThreadState == ThreadState.Stopped)
                {
                    this.DispatchThread = new Thread(new ThreadStart(this.FireThread));
                    this.DispatchThread.IsBackground = true;
                }
 
                if (start && ((this.DispatchThread.ThreadState | ThreadState.Unstarted) == this.DispatchThread.ThreadState))
                    this.DispatchThread.Start();
            }
        }
 
        /// <summary>
        /// This is a required callback for the Resource pool.
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        private bool ValidateThread(Thread obj)
        {
            return false; //never reuse threads
        }
 
        /// <summary>
        /// This is the method that the resource pool will call to get a new thread to work with.
        /// </summary>
        /// <returns></returns>
        private Thread CreateThread()
        {
            return new Thread(new ParameterizedThreadStart(this.DispatchWork));
        }
 
        /// <summary>
        /// The function starts the work on a new thread.
        /// </summary>
        private void DispatchWork(object state)
        {
            try
            {
                WorkerBee work = state as WorkerBee;
 
                if (work != null)
                    work.Start();
            }
            finally
            {
                //Give the thread back.
                this.Threads.Release(Thread.CurrentThread);
            }
        }
 
        /// <summary>
        /// This puts work on the queue and starts the dispatcher
        /// </summary>
        /// <param name="obj"></param>
        public void AddToQueue(WorkerBee obj)
        {
            this.WorkQueue.Enqueue(obj);
            this.EnsureDispatch();
        }
 
        private int GetQueueLength()
        {
            return this.WorkQueue.Count;
        }
 
        /// <summary>
        /// This is the callback that the dispatcher thread calls.
        /// It will initialize a new thread from the pool and start work
        /// </summary>
        private void FireThread()
        {
            WorkerBee work = null;
            while (!AbortDispatch && this.WorkQueue.TryDequeue(out work))
            {
                if (work != null)
                {
                    Thread thread = this.Threads.Get();
                    
                    if (!AbortDispatch) // check again
                        thread.Start(work);
                    else
                        this.Threads.Release(Thread.CurrentThread);
                }
            }
        }
 
        /// <summary>
        /// This is the queue of stuff to be done.
        /// </summary>
        private ThreadSafeQueue<WorkerBee> WorkQueue
        {
            get;
            set;
        }
 
        /// <summary>
        /// Simple resource pool filled with threads
        /// </summary>
        private ResourcePool<Thread> Threads
        {
            get;
            set;
        }
 
        public void Dispose(bool disposing)
        {
            if (disposing)
            {
                this.WorkQueue.Clear();
                this.Threads.Dispose();
            }
        }
 
        public void Dispose()
        {
            this.Dispose(true);
        }
    }

ThreadingDemo.zip

Download the code and test project and try it for yourself. I will say that this is fairly experimental, although I have been using it for quite a few things and have experienced no issues. One of the major things I have used it for is the cache scavenger in my Factory caching model and it seems to work great.

Silverlight 2 XAML Binding and Custom / Core Dependency Properties

David Justice — Sun, 23 Nov 2008 18:14:00 GMT

The basic scenario is as follows: I have done quite a bit of WPF programming in the past (since back when it was WinFx). I feel pretty damn good about the bindings in WPF, and I feel like I have wrapped my head around binding and dependency properties pretty well. So, I thought when I decided to write Silverlight 2 apps rather than straight to the vein, white horse, WPF apps, it would be a very similar feeling. The feeling was abruptly interrupted by the evilness of the ElementName Binding param. For those of you who have spent time writing WPF apps, you will know the joy of binding element properties to each other and having no problems. It's easy to take such things for granted.

...(read more)

Silver Lining for Windows Azure -- Silverlight 2 Sample Hosted in Azure

David Justice — Sat, 08 Nov 2008 16:00:00 GMT

I melded an Azure Web Role project and the Silverlight Toolkit sample to give you guys a quick download, so you can play with them together. I hope you like it, and I hope it helps you explore some of the new technology. I call it SilverLining.

...(read more)

Unique Identifier Flat File Import with SSIS

David Justice — Fri, 07 Nov 2008 16:44:00 GMT

This morning I found myself wrestling with SSIS to convert a string from a flat file to a unique identifier via a Data Flow inside of an SSIS package. I figured this would be a rather trivial case (the midget was kicking my ass!). I use guids all over for application development and for database keys. They are very useful, and very dependable. Here is a line from my flat file:

61898d4c-3a1b-4736-9a36-eb90a23322e0|:|10/13/2008 11:59:58 PM|:|74afebfe-9523-4977-b5f6-5154b6c91211

Anyone see anything wrong with this? I didn't see anything wrong, outside of the silly |:| delimiter (I don't want to get started on that <rant/> <--- rant with no content!).

...(read more)

MetaTable Expression Builder for Fetching Any Object Via Collection of Primary Keys

David Justice — Tue, 04 Nov 2008 14:53:00 GMT

Basically, I wanted to build a method that gets an object from a data context whatever the primary key may look like, and whatever type that object may be. I wrote this code a little while ago when I was exploring the DynamicData libs. I was checking out some of the code in the libs, and noticed a very slick way one of devs was building expressions to grab back a data item based on a single key ID. I thought the idea of building up the expression completely ROCKED, but I wanted to expand it out to include composite primary keys. Below is my implementation of the composite primary key object fetcher. Hopefully, it will make your life a little easier.

...(read more)

Windows Azure and _NOT_ SQLExpress

David Justice — Sun, 02 Nov 2008 17:37:00 GMT

I've been very excited recently by the release of Windows Azure, and rest of the Microsoft suite of cloud based services. I downloaded all of the sdk's, signed up for all the invitation tokens I could, and began writing code. The Visual Studio templates for Windows Azure projects makes getting your first Azure project up and running super simple. I did run into one issues with the project templates setting up my first project.

...(read more)

Work Harder

Brian Rudolph — Tue, 21 Oct 2008 15:26:00 GMT

Work Harder! That is a statement I find myself repeating daily. People often wonder what makes one person better at a certain task than others. There is a truly simple answer, practice.

Natural ability is a myth. With the exception of physical limitations, all ability is gained through practice. No infant is born with the innate ability to walk. No musician picks up an instrument for the first time and performs a flawless number. Everything ‘great' is preceded by countless not-so-great attempts.

The human race is a term that to some is a simple definition of our status as homosapiens. To me, it is a bit more literal. I recognize that there are billions of people in this world, all of whom want the same things I do. What sets certain individuals apart from the pack is their willingness to work harder than the rest. So for me, it's the race of humans. Who wants to work harder? Who wants to spend that extra effort day after day to be the best at what they do. Someone who doesn't work as hard as I do does not deserve the same things I deserve, just as I do not deserve the same benefits of the people who work harder than I am willing to.

I hear complaints from people about the state of their lives, every argument of which never focuses on their lack of effort. It is always the result of some innocuous outside influence. Bunk. People who work hard, achieve more. Good things happen to good people who work hard. Being good isn't enough. There are lots of "good" people, if the definition of "good" can be simplified to "not being bad". Spend a few more hours with your face buried in a book rather than a pint of beer. Unless, of course, your goal is to be the best drinker on earth.

Everything that has gone right in my life happened to me when I went the extra mile. Every real accomplishment didn't come from the 8 to 5 daily grind. Good things happened during the hundred-hour weeks of work. Times when 8 to 5 wouldn't have been enough to get the job done, allowing the opportunity to pass right by.

There have been many times I have explained to people that epiphanies have come to me in my sleep. Though I was not lying, this is not a result of me having some abnormal super power. It is a result of me wrapping my mind so deeply around a problem that I am consumed by it even during my few hours of sleep.

I like to think that everything that has happened to me in my life, I've earned. This, of course, includes all of the bad things. For many years my interests were simply in having fun, so my career took a nose-dive. Then I focused entirely on work which destroyed countless relationships, as well as my physical health. So while balance has become important, I have recognized that every decision comes with consequences; consequences which I hope to never complain about.

People make choices in their lives. If your choice is to pursue a career or path in your life that will never financially stabilize, you have no right to complain about finances. You have chosen to sacrifice financial success for your love or interest in what it is you do. It is not society's responsibility to fill in for your financial woes. If you choose to sacrifice your personal life for professional glory, then do not cry about your lack of intimacy. You chose that path. Just realize that everything requires hard work. Even if an individual's goal in life is to be the best parent their child could have, then they must work for it.

This is not to say that I am better or worse than anyone else in this world. What I am attempting to say is that I take responsibility for what happens in my life. I will not give up, I will not rest until I am the best I can be at what I do, regardless of what this life throws at me. The best I can be at anything will require a lifetime of effort. So I suppose it is a valid assumption to say that I will only achieve this in the moment immediately before my death.

I truly wish more people would take responsibility for their lives.

Thread Safe Dictionary Update

Brian Rudolph — Mon, 29 Sep 2008 16:14:00 GMT

For those of you that have read my post about the Thread Safe Dictionary, I have a few updates.

In recent months, I have done a ridiculous amount of multi-threaded work. This has forced me to expand my threading libraries. One of the primary objects that required changes\fixes was my dictionary.

The dictionary uses ReaderWriterLockSlim locks. These are clean, lightweight locks that MS has provided. Most importantly, they allow upgradeable read locks. I now use simple IDisposable locking wrappers. This allows us to use the "using" syntax to ensure lock releases.

It is important to note that no safe dictionary can provide safe inserts without the caller forcing a lock. This is because by the time you check for the existence of an object and then insert it, it may have been inserted by another thread. The only way to prevent this is by doing a "blind" merge. The reason I call it blind, is that when you do a merge, we check for existence, and do a replace\insert within the scope of a single write lock. This means you cannot control which objects get replaced in the dictionary. This is rarely important in caching situations.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;


public interface IThreadSafeDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
    /// <summary>
    /// Merge is similar to the SQL merge or upsert statement.  
    /// </summary>
    /// <param name="key">Key to lookup</param>
    /// <param name="newValue">New Value</param>
    void MergeSafe(TKey key, TValue newValue);


    /// <summary>
    /// This is a blind remove. Prevents the need to check for existence first.
    /// </summary>
    /// <param name="key">Key to Remove</param>
    void RemoveSafe(TKey key);
}


[Serializable]
public class ThreadSafeDictionary<TKey, TValue> : IThreadSafeDictionary<TKey, TValue>
{
    //This is the internal dictionary that we are wrapping
    IDictionary<TKey, TValue> dict = new Dictionary<TKey, TValue>();


    [NonSerialized]
    ReaderWriterLockSlim dictionaryLock = Locks.GetLockInstance(LockRecursionPolicy.NoRecursion); //setup the lock;


    /// <summary>
    /// This is a blind remove. Prevents the need to check for existence first.
    /// </summary>
    /// <param name="key">Key to remove</param>
    public void RemoveSafe(TKey key)
    {
        using (new ReadLock(this.dictionaryLock))
        {
            if (this.dict.ContainsKey(key))
            {
                using (new WriteLock(this.dictionaryLock))
                {
                    this.dict.Remove(key);
                }
            }
        }
    }


    /// <summary>
    /// Merge does a blind remove, and then add.  Basically a blind Upsert.  
    /// </summary>
    /// <param name="key">Key to lookup</param>
    /// <param name="newValue">New Value</param>
    public void MergeSafe(TKey key, TValue newValue)
    {
        using (new WriteLock(this.dictionaryLock)) // take a writelock immediately since we will always be writing
        {
            if (this.dict.ContainsKey(key))
            {
                this.dict.Remove(key);
            }


            this.dict.Add(key, newValue);
        }
    }


    public virtual bool Remove(TKey key)
    {
        using (new WriteLock(this.dictionaryLock))
        {
            return this.dict.Remove(key);
        }
    }


    public virtual bool ContainsKey(TKey key)
    {
        using (new ReadOnlyLock(this.dictionaryLock))
        {
            return this.dict.ContainsKey(key);
        }
    }


    public virtual bool TryGetValue(TKey key, out TValue value)
    {
        using (new ReadOnlyLock(this.dictionaryLock))
        {
            return this.dict.TryGetValue(key, out value);
        }
    }


    public virtual TValue this[TKey key]
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return this.dict[key];
            }
        }
        set
        {
            using (new WriteLock(this.dictionaryLock))
            {
                this.dict[key] = value;
            }
        }
    }


    public virtual ICollection<TKey> Keys
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return new List<TKey>(this.dict.Keys);
            }
        }
    }


    public virtual ICollection<TValue> Values
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return new List<TValue>(this.dict.Values);
            }
        }
    }


    public virtual void Clear()
    {
        using (new WriteLock(this.dictionaryLock))
        {
            this.dict.Clear();
        }
    }


    public virtual int Count
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return this.dict.Count;
            }
        }
    }


    public virtual bool Contains(KeyValuePair<TKey, TValue> item)
    {
        using (new ReadOnlyLock(this.dictionaryLock))
        {
            return this.dict.Contains(item);
        }
    }


    public virtual void Add(KeyValuePair<TKey, TValue> item)
    {
        using (new WriteLock(this.dictionaryLock))
        {
            this.dict.Add(item);
        }
    }


    public virtual void Add(TKey key, TValue value)
    {
        using (new WriteLock(this.dictionaryLock))
        {
            this.dict.Add(key, value);
        }
    }


    public virtual bool Remove(KeyValuePair<TKey, TValue> item)
    {
        using (new WriteLock(this.dictionaryLock))
        {
            return this.dict.Remove(item);
        }
    }


    public virtual void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        using (new ReadOnlyLock(this.dictionaryLock))
        {
            this.dict.CopyTo(array, arrayIndex);
        }
    }


    public virtual bool IsReadOnly
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return this.dict.IsReadOnly;
            }
        }
    }


    public virtual IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        throw new NotSupportedException("Cannot enumerate a threadsafe dictionary.  Instead, enumerate the keys or values collection");
    }


    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new NotSupportedException("Cannot enumerate a threadsafe dictionary.  Instead, enumerate the keys or values collection");
    }
}


public static class Locks
{
    public static void GetReadLock(ReaderWriterLockSlim locks)
    {
        bool lockAcquired = false;
        while (!lockAcquired)
            lockAcquired = locks.TryEnterUpgradeableReadLock(1);
    }


    public static void GetReadOnlyLock(ReaderWriterLockSlim locks)
    {
        bool lockAcquired = false;
        while (!lockAcquired)
            lockAcquired = locks.TryEnterReadLock(1);
    }


    public static void GetWriteLock(ReaderWriterLockSlim locks)
    {
        bool lockAcquired = false;
        while (!lockAcquired)
            lockAcquired = locks.TryEnterWriteLock(1);
    }


    public static void ReleaseReadOnlyLock(ReaderWriterLockSlim locks)
    {
        if (locks.IsReadLockHeld)
            locks.ExitReadLock();
    }


    public static void ReleaseReadLock(ReaderWriterLockSlim locks)
    {
        if (locks.IsUpgradeableReadLockHeld)
            locks.ExitUpgradeableReadLock();
    }


    public static void ReleaseWriteLock(ReaderWriterLockSlim locks)
    {
        if (locks.IsWriteLockHeld)
            locks.ExitWriteLock();
    }


    public static void ReleaseLock(ReaderWriterLockSlim locks)
    {
        ReleaseWriteLock(locks);
        ReleaseReadLock(locks);
        ReleaseReadOnlyLock(locks);
    }


    public static ReaderWriterLockSlim GetLockInstance()
    {
        return GetLockInstance(LockRecursionPolicy.SupportsRecursion);
    }


    public static ReaderWriterLockSlim GetLockInstance(LockRecursionPolicy recursionPolicy)
    {
        return new ReaderWriterLockSlim(recursionPolicy);
    }
}


public abstract class BaseLock : IDisposable
{
    protected ReaderWriterLockSlim _Locks;


    public BaseLock(ReaderWriterLockSlim locks)
    {
        _Locks = locks;
    }


    public abstract void Dispose();
}


public class ReadLock : BaseLock
{
    public ReadLock(ReaderWriterLockSlim locks)
        : base(locks)
    {
        Locks.GetReadLock(this._Locks);
    }


    public override void Dispose()
    {
        Locks.ReleaseReadLock(this._Locks);
    }
}


public class ReadOnlyLock : BaseLock
{
    public ReadOnlyLock(ReaderWriterLockSlim locks)
        : base(locks)
    {
        Locks.GetReadOnlyLock(this._Locks);
    }


    public override void Dispose()
    {
        Locks.ReleaseReadOnlyLock(this._Locks);
    }
}


public class WriteLock : BaseLock
{
    public WriteLock(ReaderWriterLockSlim locks)
        : base(locks)
    {
        Locks.GetWriteLock(this._Locks);
    }


    public override void Dispose()
    {
        Locks.ReleaseWriteLock(this._Locks);
    }
}

Thread Safe Dictionary in .NET with ReaderWriterLockSlim

Brian Rudolph — Fri, 26 Sep 2008 15:14:00 GMT

Since MS has decided to not include a thread-safe dictionary in the .NET framework, many of us have been forced to implement our own. What MS has done now with .NET 3.5 is given us a newer locking mechanism which makes this task easier.

Previously, we had 2 lock mechanisms, neither of which worked very well for my uses. The first is the Lock statement. While this method is effective, it causes serious contention issues with simultaneous reads\writes. Since it is generally safe to execute multiple concurrent reads from a dictionary, this was a huge performance flaw as the Lock statement was forcing us to perform all actions against the object in a serial fashion.

So that left ReaderWriterLock, which would allow us to take out Reader & Writer locks independently. This seemed to be the answer. Unfortunately, after further testing and review, MS and the dev communities warned against this lock type as it could have unintended consequences in certain situations. The explanations for these I will not go in to, a simple Google search will answer those questions. For the most part, I don't have the mental capacity to understand, much less explain the failures. I will tell you that I have tested this method, and ran in to some issues, and subsequently abandoned the approach.

With .NET 3.5 comes the brand-spankin-new ReaderWriterLockSlim. ReaderWriterLockSlim is similar to the ReaderWriterLock in functionality, minus some of the drawbacks. Of course any new approach will bring on its own consequences, and if you do a little research, you will find that Slim isn't infallible either.

Many of our applications implement the Factory model. Factory models are great, they are extensible, and they can be extremely performant. With that said, any data driven application that uses the Factory model without a caching model, will most likely perform poorly. So, in our factories, we build in a caching mechanism. A very simple type and ID based cache that allows us to persist commonly used objects to in-memory cache for a specific amount of time. I won't go in to the implementation of this model here as every caching implementation has its own needs and wants.

At the heart of this and likely any caching model is inevitably a Dictionary or Dictionary like structure. MS programmers have spent countless hours fine-tuning the Dictionary class to make it as performant as possible. I challenge anyone to write a managed Dictionary that performs as well in such a wide variety of scenarios. I've tried and failed. Unfortunately, MS has not provided a thread-safe implementation. Generally when you run into the question of thread-safety, most people have no idea what you are talking about. The problem with writing truly thread-safe code that can work in any scenario is that you will sacrifice performance. If you tailor your thread-safe mechanisms to your particular problem, you can generally maintain a higher level of performance.

The reason we need thread-safety is not that we are specifically spawning threads. In IIS, worker processes are inherently multi-threaded. Therefore, using static objects in a web-farm generally requires some level of thread safety, otherwise you will get dreaded "An item with the same key has already been added" errors. This is because between the time you check to see if a key already exists in your dictionary and the time you insert it, some other thread may have inserted this key. This is especially the case in object factories, because you have multiple threads attempting to access/create objects and subsequently cache them.

This is the code I've written. Update: This code has been tested, and is working well. I will keep this post updated with any changes and test results. I also have not made this class utilize lock escalation, which ReaderWriterLockSlim supports. As always, please perform your own testing.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;


public interface IThreadSafeDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
    /// <summary>
    /// Merge is similar to the SQL merge or upsert statement.  
    /// </summary>
    /// <param name="key">Key to lookup</param>
    /// <param name="newValue">New Value</param>
    void MergeSafe(TKey key, TValue newValue);


    /// <summary>
    /// This is a blind remove. Prevents the need to check for existence first.
    /// </summary>
    /// <param name="key">Key to Remove</param>
    void RemoveSafe(TKey key);
}


[Serializable]
public class ThreadSafeDictionary<TKey, TValue> : IThreadSafeDictionary<TKey, TValue>
{
    //This is the internal dictionary that we are wrapping
    IDictionary<TKey, TValue> dict = new Dictionary<TKey, TValue>();


    [NonSerialized]
    ReaderWriterLockSlim dictionaryLock = Locks.GetLockInstance(LockRecursionPolicy.NoRecursion); //setup the lock;


    /// <summary>
    /// This is a blind remove. Prevents the need to check for existence first.
    /// </summary>
    /// <param name="key">Key to remove</param>
    public void RemoveSafe(TKey key)
    {
        using (new ReadLock(this.dictionaryLock))
        {
            if (this.dict.ContainsKey(key))
            {
                using (new WriteLock(this.dictionaryLock))
                {
                    this.dict.Remove(key);
                }
            }
        }
    }


    /// <summary>
    /// Merge does a blind remove, and then add.  Basically a blind Upsert.  
    /// </summary>
    /// <param name="key">Key to lookup</param>
    /// <param name="newValue">New Value</param>
    public void MergeSafe(TKey key, TValue newValue)
    {
        using (new WriteLock(this.dictionaryLock)) // take a writelock immediately since we will always be writing
        {
            if (this.dict.ContainsKey(key))
            {
                this.dict.Remove(key);
            }


            this.dict.Add(key, newValue);
        }
    }


    public virtual bool Remove(TKey key)
    {
        using (new WriteLock(this.dictionaryLock))
        {
            return this.dict.Remove(key);
        }
    }


    public virtual bool ContainsKey(TKey key)
    {
        using (new ReadOnlyLock(this.dictionaryLock))
        {
            return this.dict.ContainsKey(key);
        }
    }


    public virtual bool TryGetValue(TKey key, out TValue value)
    {
        using (new ReadOnlyLock(this.dictionaryLock))
        {
            return this.dict.TryGetValue(key, out value);
        }
    }


    public virtual TValue this[TKey key]
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return this.dict[key];
            }
        }
        set
        {
            using (new WriteLock(this.dictionaryLock))
            {
                this.dict[key] = value;
            }
        }
    }


    public virtual ICollection<TKey> Keys
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return new List<TKey>(this.dict.Keys);
            }
        }
    }


    public virtual ICollection<TValue> Values
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return new List<TValue>(this.dict.Values);
            }
        }
    }


    public virtual void Clear()
    {
        using (new WriteLock(this.dictionaryLock))
        {
            this.dict.Clear();
        }
    }


    public virtual int Count
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return this.dict.Count;
            }
        }
    }


    public virtual bool Contains(KeyValuePair<TKey, TValue> item)
    {
        using (new ReadOnlyLock(this.dictionaryLock))
        {
            return this.dict.Contains(item);
        }
    }


    public virtual void Add(KeyValuePair<TKey, TValue> item)
    {
        using (new WriteLock(this.dictionaryLock))
        {
            this.dict.Add(item);
        }
    }


    public virtual void Add(TKey key, TValue value)
    {
        using (new WriteLock(this.dictionaryLock))
        {
            this.dict.Add(key, value);
        }
    }


    public virtual bool Remove(KeyValuePair<TKey, TValue> item)
    {
        using (new WriteLock(this.dictionaryLock))
        {
            return this.dict.Remove(item);
        }
    }


    public virtual void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        using (new ReadOnlyLock(this.dictionaryLock))
        {
            this.dict.CopyTo(array, arrayIndex);
        }
    }


    public virtual bool IsReadOnly
    {
        get
        {
            using (new ReadOnlyLock(this.dictionaryLock))
            {
                return this.dict.IsReadOnly;
            }
        }
    }


    public virtual IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        throw new NotSupportedException("Cannot enumerate a threadsafe dictionary.  Instead, enumerate the keys or values collection");
    }


    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new NotSupportedException("Cannot enumerate a threadsafe dictionary.  Instead, enumerate the keys or values collection");
    }
}


public static class Locks
{
    public static void GetReadLock(ReaderWriterLockSlim locks)
    {
        bool lockAcquired = false;
        while (!lockAcquired)
            lockAcquired = locks.TryEnterUpgradeableReadLock(1);
    }


    public static void GetReadOnlyLock(ReaderWriterLockSlim locks)
    {
        bool lockAcquired = false;
        while (!lockAcquired)
            lockAcquired = locks.TryEnterReadLock(1);
    }


    public static void GetWriteLock(ReaderWriterLockSlim locks)
    {
        bool lockAcquired = false;
        while (!lockAcquired)
            lockAcquired = locks.TryEnterWriteLock(1);
    }


    public static void ReleaseReadOnlyLock(ReaderWriterLockSlim locks)
    {
        if (locks.IsReadLockHeld)
            locks.ExitReadLock();
    }


    public static void ReleaseReadLock(ReaderWriterLockSlim locks)
    {
        if (locks.IsUpgradeableReadLockHeld)
            locks.ExitUpgradeableReadLock();
    }


    public static void ReleaseWriteLock(ReaderWriterLockSlim locks)
    {
        if (locks.IsWriteLockHeld)
            locks.ExitWriteLock();
    }


    public static void ReleaseLock(ReaderWriterLockSlim locks)
    {
        ReleaseWriteLock(locks);
        ReleaseReadLock(locks);
        ReleaseReadOnlyLock(locks);
    }


    public static ReaderWriterLockSlim GetLockInstance()
    {
        return GetLockInstance(LockRecursionPolicy.SupportsRecursion);
    }


    public static ReaderWriterLockSlim GetLockInstance(LockRecursionPolicy recursionPolicy)
    {
        return new ReaderWriterLockSlim(recursionPolicy);
    }
}


public abstract class BaseLock : IDisposable
{
    protected ReaderWriterLockSlim _Locks;


    public BaseLock(ReaderWriterLockSlim locks)
    {
        _Locks = locks;
    }


    public abstract void Dispose();
}


public class ReadLock : BaseLock
{
    public ReadLock(ReaderWriterLockSlim locks)
        : base(locks)
    {
        Locks.GetReadLock(this._Locks);
    }


    public override void Dispose()
    {
        Locks.ReleaseReadLock(this._Locks);
    }
}


public class ReadOnlyLock : BaseLock
{
    public ReadOnlyLock(ReaderWriterLockSlim locks)
        : base(locks)
    {
        Locks.GetReadOnlyLock(this._Locks);
    }


    public override void Dispose()
    {
        Locks.ReleaseReadOnlyLock(this._Locks);
    }
}


public class WriteLock : BaseLock
{
    public WriteLock(ReaderWriterLockSlim locks)
        : base(locks)
    {
        Locks.GetWriteLock(this._Locks);
    }


    public override void Dispose()
    {
        Locks.ReleaseWriteLock(this._Locks);
    }
}

[Update]
Through some testing, I found the need to update the ThreadSafe Dictionary. I changed all of the locking to use IDisposables to ensure lock creation and destruction.

I'm an MVP!

Chuck — Wed, 02 Jul 2008 06:26:00 GMT

I found out this morning that I've been named a SQL Server MVP (Most Valuable Professional).

For those of you who don't know what the MVP program is, here's a brief overview.

Each quarter, Microsoft selects a group of people across many different technologies to become MVPs. Your selection is based on your community involvement over the past year. Community involvement can include presenting at user group meetings, posting answers to questions on newsgroups, writing articles for online magazines, etc.

My community involvement is primarily through the Professional Association for SQL Server (PASS). I currently serve on the Board of Directors and am in charge of two techincal publications - a newsletter that goes out every other week and a magazine that goes out every other month.

Thank you to everyone who has supported my efforts in the community over the years. You'll probably be seeing much more of me out there in the future.

Chuck

SQL Server 2008 RC0

Chuck — Fri, 13 Jun 2008 18:39:00 GMT

For those of you who haven't heard, RC0 of SQL Server 2008 has been released.

If you have played with any of the CTP releases of SQL Server 2008, you'll notice that there are a few differences in the installer - but not enough to cause you to relearn anything.

I loaded it up on my dev box this week, and I am quite impressed with what I am seeing so far. There's a nice new Activity Monitor that is similar to the default view of the Vista Reliability and Performance Monitor - and it even works against SQL Server 2005 servers.

Over the next couple of months, I'll be writing some fairly detailed blog posts on SQL Server 2008 - each of them based on a different new feature. Keep checking back - I hope to profile at least one new feature every other week.

Chuck

TechEd Developer - Day 3

Chuck — Fri, 06 Jun 2008 20:14:00 GMT

Another day, more booth duty. I spent a good part of my day working with the VSTS Database Edition team. Great group of people - and they have a great product. It is nice talking to people who have no idea how the product can help them. When they see what it can do, they normally want to get it in place quick.

I also caught a session on a new in-memory distributed caching technology from Microsoft codenamed "Velocity". It is quite impressive. It can actually be an in-memory store for your IIS Session State - and it allows you to move from machine to machine in a web farm without losing your session!

More to come on Day 4!

Chuck

TechEd Developer - Day 2

Chuck — Thu, 05 Jun 2008 20:35:00 GMT

I spent a bunch of time today in the SQL Server TLC area down on the show floor. I did, however, manage to get away for a great session on Extended Events presented by Bob Beauchemin - who I had dinner with the night before at a great Brazilian steakhouse. It's amazing all that you can do with the extended events architecture.

More to come tomorrow.

TechEd Developer - Day 1

Chuck — Tue, 03 Jun 2008 15:10:00 GMT

I just got out of the keynote for TechEd Developer. Bill Gates actually opened up for a Q&A session from the floor. Quite impressive.

It was announced that Silverlight 2 Beta 2 will be released by the end of the week, and that you will be able to get a Go-Live license. I know some of my co-workers will be happy about that.

I'm getting ready to go do my first shift in the TLC area. I'll be working the SQL Server area (look for the green). Today I'll be at the Storage demo station. The rest of the week I'll be splitting my time between Storage and Team Edition for Database Professionals. If you're here, stop by and say hi!

That's all for now. I'll have more to report later.

Chuck

TechEd Developer

Chuck — Fri, 30 May 2008 21:15:00 GMT

If you're going to be at TechEd in Orlando next week, stop by and say Hi! I'll be in the Microsoft TLC area over lunch Tuesday through Friday. I'll be helping out the VSTS folks. Hope to see you there.

PASS Call for Presentations - Deadline Extended Again!

Chuck — Tue, 01 Apr 2008 16:39:00 GMT

Due to technical difficulties, the deadline for submitting abstracts for the 2008 PASS Community Summit has been extended through Monday, April 7, 2008.

If you are interested in submitting an abstract, please do so at http://calltospeakers.sqlpass.org/.

Chuck