C#

public partial class rs : ServiceBase
    {
        private Queue jobQueue = Queue.Synchronized(new Queue());
        private Queue DatafeedQueue = Queue.Synchronized(new Queue());
        private Dictionary<...> ScheduleJobs = new Dictionary<...>();
        private AutoResetEvent _BlockThreadTaskScheduler = new AutoResetEvent(true);
        private AutoResetEvent _BlockThreadDatafeedSourceTaskScheduler = new AutoResetEvent(false);
        private LimitedConcurrencyLevelTaskScheduler _TaskScheduler;
        private LimitedConcurrencyLevelTaskScheduler _DatafeedSourceTaskScheduler;

        public rs()
        {
			InitializeComponent();
			_timer = new System.Timers.Timer(POLL_INTERVAL_MINUTE * 60 * 1000);
			_timer.Elapsed += new System.Timers.ElapsedEventHandler(_timer_Elapsed);
			_TaskScheduler = new LimitedConcurrencyLevelTaskScheduler(2);
			_DatafeedSourceTaskScheduler = new LimitedConcurrencyLevelTaskScheduler(1);
	  
			protected void _timer_Elapsed(object sender, ElapsedEventArgs e)
			{
				try
				{
					DatafeedQueue.Clear();
					try
					{
						(Execute a stored procedure here)
						while(xxx.Read())
						{
							DatafeedObj dfo = new DatafeedObj();
							...
							DatafeedQueue.Enqueue(dfo);
						}
					}
					catch()...
				
				TaskFactory DatafeedSourceFactory = new TaskFactory(_DatafeedSourceTaskScheduler);
				// DatafeedQueue.Count = 3
				for (int i = 0; i < DatafeedQueue.Count; i++)
				{
					DatafeedSourceFactory.StartNew(() => processDatafeedQueue());
				}

				_BlockThreadDatafeedSourceTaskScheduler.Set();

				}
				catch()...
			}
			private void processDatafeedQueue()
			{
				_BlockThreadDatafeedSourceTaskScheduler.WaitOne();
				try
				{
					lock (DatafeedQueue.SyncRoot)
					{
						if (DatafeedQueue.Count > 0)
						{
							DatafeedObj dfo = ((DatafeedObj)(DatafeedQueue.Dequeue()));
							
							#region DataFeed Type A
							
							ScheduleJobs = (Calls a static class, static method);
							jobQueue = (Calls a static class, static method turn ScheduleJobs  dictionary into Queue);
							var factory = new TaskFactory(_TaskScheduler);
							for (int i = 0; i < jobQueue.Count; i++)
							{
								factory.StartNew(() => startTypeA());
							}
							
							#endregion
							  
							#region DataFeed Type B
							
							ScheduleJobs = (Calls a static class, static method);
							jobQueue = (Calls a static class, static method turn ScheduleJobs  dictionary into Queue);
							var factory = new TaskFactory(_TaskScheduler);
							for (int i = 0; i < jobQueue.Count; i++)
							{
								factory.StartNew(() => startTypeB());
							}
							
							#endregion
							
							#region DataFeed Type C
							
							ScheduleJobs = (Calls a static class, static method);
							jobQueue = (Calls a static class, static method turn ScheduleJobs  dictionary into Queue);
							var factory = new TaskFactory(_TaskScheduler);
							for (int i = 0; i < jobQueue.Count; i++)
							{
								factory.StartNew(() => startTypeC());
							}
							
							#endregion
						}
					}
				}
				if (_TaskScheduler.NumberOfRemainingScheduledTasks == 0)
				{
					_BlockThreadDatafeedSourceTaskScheduler.Set();
				}
			}
			void startTypeA()
			{
				(In this method, it creates a object from another project class which calls a WCF Service and select data and insert into local db and run stored procedures)
			}
			void startTypeB()
			{
				(Same as startTypeA but calls a different WCF and insert into the same set of tables which startTypeA also insert into then also run a same set of stored procedures)
			}
			void startTypeC()
			{
				(Same as startTypeC but calls a different WCF and into different set of tables than startTypeA and startTypeB then run different set of stored procedures)
			}

    ...

class Program
    {
        static SemaphoreSlim _sem = new SemaphoreSlim(3);

        static void Main()
        {
            for (int i = 1; i <= 3; i++)
            {
                new Thread(RunThisMethod).Start(i);
            }
            Console.ReadLine();
        }

        static void RunThisMethod(Object id)
        {
            Console.WriteLine(id + " wants to enter");
            _sem.Wait();
            if (id.ToString() == "1")
            {
                Console.WriteLine("Start Type A");
                Thread.Sleep(3000);
                Console.WriteLine("End Type A");
            }
            else if (id.ToString() == "2")
            {
                Console.WriteLine("Start Type B");
                Thread.Sleep(6000);
                Console.WriteLine("End Type B");
            }
            else if (id.ToString() == "3")
            {
                Console.WriteLine("Start Type C");
                Thread.Sleep(9000);
                Console.WriteLine("End Type C");
            }
            _sem.Release();
        }
    }

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
        private struct Header
        {
            public byte version;
            public Int32 numRecords;
            public Int16 headerLen;
            public Int16 recordLen;
            public byte encryptionFlag;
            public Int64 reserved;
            ....
        }

using (OpenFileDialog of=new OpenFileDialog())
           {
               of.ShowDialog();
               FileStream fs = new FileStream(of.FileName,FileMode.Open,FileAccess.ReadWrite);
               BinaryWriter bw = new BinaryWriter(fs);
               BinaryReader br = new BinaryReader(fs);

               byte[] buffer = new byte[Marshal.SizeOf(typeof(Header))];

               buffer = br.ReadBytes(Marshal.SizeOf(typeof(Header)));
               GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
               Header rHeader = ((Header)(Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(Header))));
               handle.Free();

               Header wHeader = rHeader;
               wHeader.numRecords = 5;
               IntPtr ptr = Marshal.AllocHGlobal(buffer.Length);
               Marshal.StructureToPtr(wHeader, ptr, true);
               Marshal.Copy(ptr, buffer, 0, buffer.Length);
               Marshal.FreeHGlobal(ptr);

               bw.Seek(0, SeekOrigin.Begin);

               bw.Write(buffer);
               bw.Close();
               br.Close();
               fs.Close();
           }

protected override void OnPaintBackground(PaintEventArgs e)
    {

    }
    private Bitmap _cachedBitmap;
    protected override void OnPaint(PaintEventArgs e)
    {
        using (Graphics g = e.Graphics)
        {
            if (!_isPainted)
            {
                _cachedBitmap = new Bitmap(ClientRectangle.Width, ClientRectangle.Height);
                InitilizeBitmap(g);
                _isPainted = true;
            }

            //Rectangle to show a particular portion of bitmap.
            Rectangle rec = new Rectangle(0, _bitmapLocation.Y, ClientRectangle.Width, ClientRectangle.Height);
            //using (Graphics gCached = Graphics.FromImage(_cachedBitmap))
            //{
            //   gCached.Clear(BackColor);
            //   gCached.DrawImage(_bmpControl, 0, 0, rec, GraphicsUnit.Pixel);
            //}

            //g.DrawImage(_cachedBitmap, 0, 0);
            g.DrawImage(_bmpControl, 0, 0, rec, GraphicsUnit.Pixel);
        }
    }