byte[] data = new byte[1000]; // We would expect a good compression ratio from an empty array!
var msObj = new MemoryStream();
using (Stream ds = new DeflateStream (msObj, CompressionMode.Compress))
ds.Write (data, 0, data.Length);
byte[] compressed = msObj.ToArray();
Console.WriteLine (compressed.Length); // 113
// Decompress back to the data array:
msObj= new MemoryStream (compressed);
using (Stream ds = new DeflateStream (msObj, CompressionMode.Decompress))
for (int i = 0; i < 1000; i += ds.Read (data, i, 1000 - i));

In the above code the using statement wrapped around the DeflateStream closes it in  textbook fashion, and flushes  unwritten buffers in the process. The structure also closes the MemoryStream it wraps and so we will  then need to call ToArray to extract its data.
The below code shows an alternative which avoids closing the MemoryStream:

byte[] data = new byte[1000];
MemoryStream  msObj= new MemoryStream();
using (Stream ds = new DeflateStream (ms, CompressionMode.Compress, true))
ds.Write (data, 0, data.Length);
Console.WriteLine (msObj.Length); // 113
msObj.Position = 0;
using (Stream ds = new DeflateStream (msObj, CompressionMode.Decompress))
for (int i = 0; i < 1000; i += ds.Read (data, i, 1000 - i));

Here, the additional flag which is sent to the DeflateStream’s constructor instructs it not to follow the usual protocol of taking the underlying stream with it in disposal. Thus, the MemoryStream is still left open, allowing us to reposition it  to zero and then reread it.

Both these compressions streams use popular compression algorithm which is similar to that used by the ZIP format. The difference is that GZipStream writes an additional protocol at the start and at the end which includes a CRC to detect  errors. The GZipStream also conforms to a standard recognized by other software.

Both DeflateStream and  GZipStream allow reading and writing, with the below provisos:

• Always write to the stream when compressing.
• Always read from the stream when decompressing.

DeflateStream and GZipStream are both decorators –  compress or decompress data from another stream which is supplied in the construction. In the below sample, the code compresses and decompresses a series of bytes, using a FileStream as the backing store:

using (Stream s = File.Create ("compressed.bin"))
using (Stream ds = new DeflateStream (s, CompressionMode.Compress))
for (byte i = 0; i < 100; i++)
ds.WriteByte (i);
using (Stream s = File.OpenRead ("compressed.bin"))
using (Stream ds = new DeflateStream (s, CompressionMode.Decompress))
for (byte i = 0; i < 100; i++)
Console.WriteLine (ds.ReadByte()); // Writes 0 to 99

Note that even with the smaller of the two algos, the compressed file is 241 bytes which is more than twice the size of the original file. Thus, compression does not work well with dense  nonrepetitive binary files. Compression is instead a better fit for files such as text text files as shown in the example below:

string[] words = "The quick brown fox jumps over the lazy dog".Split();
Random rand = new Random();
using (Stream s = File.Create ("compressed.bin"))
using (Stream ds = new DeflateStream (s, CompressionMode.Compress))

using (TextWriter w = new StreamWriter (ds))

for (int i = 0; i < 1000; i++)
w.Write (words [rand.Next (words.Length)] + " ");
Console.WriteLine (new FileInfo ("compressed.bin").Length); // 1073
using (Stream s = File.OpenRead ("compressed.bin"))
using (Stream ds = new DeflateStream (s, CompressionMode.Decompress))
using (TextReader r = new StreamReader (ds))
Console.Write (r.ReadToEnd()); // Output below:
lazy lazy the fox the quick The brown fox jumps over fox over fox The
brown brown brown over brown quick fox brown dog dog lazy fox dog brown
over fox jumps lazy lazy quick The jumps fox jumps The over jumps dog..

In the above sample, DeflateStream efficiently compresses to 1,073 bytes which is just slightly over one byte per word.

//6 parts of the book
string[] inputTextFiles =
{
“part1.txt”, “part2.txt”, “part3.txt”,
“part4.txt”, “part5.txt”, “part6.txt”
};

foreach (string file in inputTextFiles)

{
string contentStr = File.ReadAllText(file);
CountCharacters(contentStr);
CountWords(contentStr);
}

The Parallel class can be used with lambda expressions to parallelize the two calculation methods:

foreach(string file in inputFiles)

{
string contentStr = File.ReadAllText(file);
Parallel.Invoke(
() => CountCharacters(contentStr),
() => CountWords(contentStr)
);
}

The results from using the Parallel Class to split tasks are normally not as dramatic  as using Parallel to split data across processors but they are still significant.

For a task which is easily split into independent sub-tasks, or data that can be partitioned and computed separately you can use the Parallel class in System.Threading to assign tasks to be automatically scheduled and then wait for the tasks to be completed. The Parallel class will automatically scale to the number of available processors or cores.

Process Data in Parallel across Multiple Processors or Cores

When you have a data set which can be split over multiple processors and then processed independently, you should use constructs such as Parallel.For(), in the below example this is demonstrated for computing prime numbers:

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace  PrimesDemo
{
class Program
{
static void Main(string[] args)
{
int maxPrimes = 1000000;
int maxNumber = 200000000;
long primesFound = 0;
Console.WriteLine(“Iterative”);
Stopwatch watchObj = new Stopwatch();
watchObj.Start();

for (UInt32 i = 0; i < maxNumber; ++i) { if (IsPrime(i)) { Interlocked.Increment(ref primesFound); if (primesFound > maxPrimes)
{
Console.WriteLine(“Last prime found was: {0:N0}”,
i);
break;
}
}
}
watchObj.Stop();
Console.WriteLine(“Found {0:N0} prime numbers in {1}”,
primesFound, watchObj.Elapsed);
watchObj.Reset();
primesFound = 0;
Console.WriteLine(“Parallel”);
watchObj.Start();
// to stop the loop, there is an overload that takes Action
Parallel.For(0, maxNumber, (i, loopState) =>
{
if (IsPrime((UInt32)i))
{
Interlocked.Increment(ref primesFound);
if (primesFound > maxPrimes)
{
Console.WriteLine(“Last prime found was: {0:N0}”,
i);
loopState.Stop();
}
}
});
watchObj.Stop();
Console.WriteLine(“Found {0:N0} prime numbers in {1}”,
primesFound, watchObj.Elapsed);
Console.ReadKey();
}
public static bool IsPrime(UInt32 number)
{

//check for evenness
if (number % 2 == 0)
{
if (number == 2)
return true;
return false;
}

UInt32 max = (UInt32)Math.Sqrt(number);
for (UInt32 i = 3; i <= max; i += 2)
{
if ((number % i) == 0)
{
return false;
}
}
return true;
}
}
}

When you run this note the drastically reduced time using Parallel, also note that the results are not necessarily in order and that the parallel evaluation of the data does not arrive at the same results as the iterative evaluation. As opposed to running sequentially from 1 to 200,000,000 until one million primes are found, the input space is instead divided up and therefore it is possible to get different results in some circumstances.