A Simple MultiThreading Pattern For C# With No Statics. Shows Compressing A File With GZip


This post shows a very simple technique for processing a gzip compression on a background thread using c# with Visual Studio 2010.  What is unique here is we are using no statics to do it.  I’m not totally against using statics, but in general, it is best to avoid them.  I’ve heard the notorious Ward Bell say statics are evil and have had many cases where they have bitten me.  Since I heard Ward say this, I’ve been trying to avoid them where I can.


The Simple Problem

The problem is to simply compress a file to bytes and return to us the compressed, uncompressed and byte array of the result.  We can pass parameters into a thread, however we can not return them (when I say thread, I mean the anonymous method that processes our data).

Some Code

So, to that end, Let’s create a main method as below.  Notice that it creates a very simple anonymous method which executes the code cryptoCopress.CompressFile(…), then simply starts that thread.  Once the thread starts, it simply waits for the thread to end by looping every 50 milliseconds on the thread.IsAlive method.  Finally, when it returns, it simply looks at the cryptCompress object for the results.  No Statics!


private static void Main(string[] args)
var cryptCompress =
new CryptCompress();
var thread =
new Thread(
() =>

int cnt = 0;
while (thread.IsAlive)
Console.WriteLine("Waiting... " + cnt);
Console.WriteLine("Before Compression KBytes: {0}",
Console.WriteLine("After Compression KBytes: {0}",

Now, Lets look at the CryptCompress class.  Notice that it’s basically got one public method (CompressFile) and 3 public properties that will be used to hold the return values.  This way, the main method that started the thread can get the results.  Again, notice that there is no word static any place in this project.

public class CryptCompress
public byte[] CompressedBytes { get; set; }
public long BeforeCompressionBytes { get; set; }
public long AfterCompressionBytes { get; set; }

public void CompressFile(string fileName)
using (var fileStream =
new FileStream(fileName, FileMode.Open, FileAccess.Read))
var uncompressedBytes = new byte[fileStream.Length];
fileStream.Read(uncompressedBytes, 0,
(int) fileStream.Length);
CompressedBytes = CompressGzip(uncompressedBytes);
BeforeCompressionBytes = fileStream.Length;
AfterCompressionBytes = CompressedBytes.Length;

/// <summary>
/// Take a simple stream of uncompressed bytes and compress them
/// </summary>
/// <param name="uncompressedBytes"></param>
/// <returns></returns>
public byte[] CompressGzip(byte[] uncompressedBytes)
using (var memory = new MemoryStream())
(var gZipStream =
new GZipStream(memory, CompressionMode.Compress, true))
(uncompressedBytes, 0, uncompressedBytes.Length);
return memory.ToArray();


The Results

When we run this, notice that it takes 3 iterations (or 150 milliseconds) to complete. I’m only compressing a small file so no surprise.  The file is actually 2.7 Megabytes and compress to .7 Megabytes.



That’s it for now! Hope this helps.

About Peter Kellner

Peter is a software professional specializing in mobile and web technologies. He has also been a Microsoft MVP since 2007. In addition, he’s a multi-course video author at Pluralsight. To read more about Peter Kellner and his experience click here. For information about how Peter Kellner might be able to help you with your project click here.

Follow me:


  1. buy generic cialis pills online! No condition how grey a hamper is, there will come a in days of yore when they when one pleases on it abstruse (or unattainable) to accomplish and/or state an erection. And while a fetter dominion experience as if it is the end of the fabulous, it is not. buy cheap kamagra online usa
    More willingly than you start having nightmares and screaming “I am too immature representing Viagra!,” take a deep breath and tarry calm. buy cheap kamagra usa.

  2. Maybe he’s talking about using a Task, which uses ThreadPool

    Target .net 4.0 (sample project targeted 3.5 for me)

    change var thread… and thread.Start() with

    Task t = Task.Factory.StartNew(() =>

    replace while (thread.IsAlive) with

    This does seem more of a “4.0” way to do it with TPL. It does use the static factory to get an instance of Task but I think it still adheres to the heart of the post as opposed to using something like Parallel.Invoke which is a static only method.

  3. caractacus,
    Can you post a short example of using threadpool?

  4. caractacus says:

    Surely the ThreadPool class provides all the functionality you require, whilst remaining scalable?


  1. […] This post was mentioned on Twitter by pkellner, Naveen Lagadapati. Naveen Lagadapati said: "A Simple MultiThreading Pattern For C# With No Statics. Shows Compressing A File With GZip" by @pkellner http://j.mp/gQOuaj #dotnet #tech […]


Get every new post delivered to your Inbox

Join other followers: