Paul Shinn

While you don't have a trivial 1:1 Mapping from IEnumerable<Period> to List<CellViewModel>, you can still derive some value from Automapper by using it only at the place where you get class-to-class contact, which in your example is between Period and RowViewModel.

With this in mind, you can also make better use of LINQ and get everything done in one sweeping motion, provided you set up the projections that require re-shaping from Period to RowViewModel.

Here's a console code example that demonstrates exactly that. Note that we're using Automapper's notion of resolver classes via ValueResolve<TSource,TDestination> do the re-shaping, and I've added an extra constructor to CellViewModel to accept an IEnumerable<RowViewModel>, which helps improve our declarations.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using AutoMapper;

namespace GroupingMapping
{
    public class PeriodRequest
    {
        public IEnumerable<Period> Periods { get; set; }
        public IEnumerable<DateTime> Weeks { get; set; }
    }

    public class RowViewModel
    {
        public string DayName { get; set; }
        public string SchoolclassCode { get; set; }
        public string Content { get; set; }
        public int DayIndex { get; set; }
        public int LessonNumber { get; set; }
    }

    public class Period
    {
        public int PeriodId { get; set; }
        public DateTime LessonDate { get; set; }
        public int LessonNumber { get; set; }
        public string SchoolclassCode { get; set; }
        public string Content { get; set; }
        public int SchoolyearId { get; set; }
        // No definition provided for Schoolyear
        //public Schoolyear Schoolyear { get; set; }
    }

    public class CellViewModel
    {
        public CellViewModel()
        {
            Rows = new List<RowViewModel>();
        }

        public CellViewModel(IEnumerable<RowViewModel> rowVMSet)
        {
            Rows = new List<RowViewModel>(rowVMSet);
        }

        public List<RowViewModel> Rows { get; set; }
    }

    public class PeriodListViewModelEx
    {
        public PeriodListViewModelEx(IEnumerable<Period> periods)
        {
            CellViewModels = new List<CellViewModel>(periods
                .GroupBy(p => p.LessonNumber)
                .OrderBy(grp => grp.Key)
                .Select(grp =>
                {
                    return new CellViewModel(
                        grp.Select(p => { return Mapper.Map<Period, RowViewModel>(p); }));
                }));
        }
        public List<CellViewModel> CellViewModels { get; set; }
    }

    class DateTimeToDateNameResolver : ValueResolver<DateTime, string>
    {
        protected override string ResolveCore(DateTime source)
        {
            return source.ToShortDateString();
        }
    }

    class DateTimeToDayOfWeekResolver : ValueResolver<DateTime, int>
    {
        protected override int ResolveCore(DateTime source)
        {
            return (int)source.DayOfWeek;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Mapper.CreateMap<Period, RowViewModel>()
                .ForMember(dest => dest.DayName, opt => opt.ResolveUsing<DateTimeToDateNameResolver>().FromMember(src => src.LessonDate))
                .ForMember(dest => dest.DayIndex, opt => opt.ResolveUsing<DateTimeToDayOfWeekResolver>().FromMember(src => src.LessonDate));

            Period[] periods = new Period[3];

            periods[0] = new Period { PeriodId = 1, LessonDate = DateTime.Today.Add(new TimeSpan(1, 0, 0, 0)), LessonNumber = 101, SchoolclassCode = "CS101", Content = "Intro to CS", SchoolyearId = 2013 };
            periods[1] = new Period { PeriodId = 2, LessonDate = DateTime.Today.Add(new TimeSpan(2, 0, 0, 0)), LessonNumber = 101, SchoolclassCode = "CS101", Content = "Intro to CS", SchoolyearId = 2013 };
            periods[2] = new Period { PeriodId = 3, LessonDate = DateTime.Today.Add(new TimeSpan(1, 0, 0, 0)), LessonNumber = 102, SchoolclassCode = "EN101", Content = "English (I)", SchoolyearId = 2013 };

            PeriodListViewModelEx pvModel = new PeriodListViewModelEx(periods);

            Console.WriteLine("CellViews: {0}", pvModel.CellViewModels.Count);

            foreach (CellViewModel cvm in pvModel.CellViewModels)
            {
                Console.WriteLine("{0} items in CellViewModel Group", cvm.Rows.Count);
            }

            Console.WriteLine("Inspecting CellViewModel Rows");
            foreach (CellViewModel cvm in pvModel.CellViewModels)
            {
                foreach (RowViewModel rvm in cvm.Rows)
                {
                    Console.WriteLine("  DayName: {0}", rvm.DayName);
                    Console.WriteLine("  SchoolclassCode: {0}", rvm.SchoolclassCode);
                    Console.WriteLine("  Content: {0}", rvm.Content);
                    Console.WriteLine("  DayIndex: {0}", rvm.DayIndex);
                    Console.WriteLine("  LessonNumber: {0}", rvm.LessonNumber);
                    Console.WriteLine("  -");
                }
                Console.WriteLine("--");
            }

            Console.ReadKey();
        }
    }
}

You can specify a transform at the moment just before the gradient is applied if you would like to declare the brush only once. Note that using transformations will override many of the constructor arguments that can be specified on a LinearGradientBrush.

LinearGradientBrush.Transform Property (System.Drawing.Drawing2D)

To modify the transformation, call the methods on the brush object corresponding to the desired matrix operations. Note that matrix operations are not commutative, so order is important. For your purposes, you'll probably want to do them in this order for each rendition of your rectangles: Scale, Rotate, Offset/Translate.

LinearGradientBrush.ResetTransform Method @ MSDN

LinearGradientBrush.ScaleTransform Method (Single, Single, MatrixOrder) @ MSDN

LinearGradientBrush.RotateTransform Method (Single, MatrixOrder) @ MSDN

LinearGradientBrush.TranslateTransform Method (Single, Single, MatrixOrder) @ MSDN

Note that the system-level drawing tools don't actually contain a stock definition for gradient brush, so if you have performance concerns about making multiple brushes, creating a multitude of gradient brushes shouldn't cost any more than the overhead of GDI+/System.Drawing maintaining the data required to define the gradient and styling. You may be just as well off to create a Brush per rectangle as needed, without having to dive into the math required to customize the brush via transform.

Brush Functions (Windows) @ MSDN

Here is a code example you can test in a WinForms app. This app paints tiles with a gradient brush using a 45 degree gradient, scaled to the largest dimension of the tile (naively calculated). If you fiddle with the values and transformations, you may find that it isn't worth using the technique setting a transform for all of your rectangles if you have non-trivial gradient definitions. Otherwise, remember that your transformations are applied at the world-level, and in the GDI world, the y-axis is upside down, whereas in the cartesian math world, it is ordered bottom-to-top. This also causes the angle to be applied clockwise, whereas in trigonometry, the angle progresses counter-clockwise in increasing value for a y-axis pointing up.

using System.Drawing.Drawing2D;

namespace TestMapTransform
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Paint(object sender, PaintEventArgs e)
        {
            Rectangle rBrush = new Rectangle(0,0,1,1);
            Color startColor = Color.DarkRed;
            Color endColor = Color.White;
            LinearGradientBrush br = new LinearGradientBrush(rBrush, startColor, endColor, LinearGradientMode.Horizontal);

            int wPartitions = 5;
            int hPartitions = 5;

            int w = this.ClientSize.Width;
            w = w - (w % wPartitions) + wPartitions;
            int h = this.ClientSize.Height;
            h = h - (h % hPartitions) + hPartitions;

            for (int hStep = 0; hStep < hPartitions; hStep++)
            {
                int hUnit = h / hPartitions;
                for (int wStep = 0; wStep < wPartitions; wStep++)
                {
                    int wUnit = w / wPartitions;

                    Rectangle rTile = new Rectangle(wUnit * wStep, hUnit * hStep, wUnit, hUnit);

                    if (e.ClipRectangle.IntersectsWith(rTile))
                    {
                        int maxUnit = wUnit > hUnit ? wUnit : hUnit;

                        br.ResetTransform();
                        br.ScaleTransform((float)maxUnit * (float)Math.Sqrt(2d), (float)maxUnit * (float)Math.Sqrt(2d), MatrixOrder.Append);
                        br.RotateTransform(45f, MatrixOrder.Append);
                        br.TranslateTransform(wUnit * wStep, hUnit * hStep, MatrixOrder.Append);

                        e.Graphics.FillRectangle(br, rTile);

                        br.ResetTransform();
                    }
                }
            }
        }

        private void Form1_Resize(object sender, EventArgs e)
        {
            this.Invalidate();
        }
    }
}

Here's a snapshot of the output:

This happens when one has other threads that continue to run that have no relation (or have become disassociated from) the threads related to your service.

Note that a process may be multi-tenant and host multiple services, so a stop command doesn't always imply that the owner process must exit, just that the service should stop running in that process.

To debug further, when you encounter this limbo state, you should attach a debugger and stop all threads and inspect the call stacks on each thread. For a single service process, you are likely to find that a thread has hung while waiting for IO or other operations to complete, or that there are idle threads such as message loop threads that are awaiting signals that will never be raised.

Font names are localized if the font creator chooses to publish metadata for a specific locale, but all fonts have a system-known name, usually the PostScript name, that ensures that the same font can be referenced and retrieved with a reasonable amount of reliability.

For OpenType and TrueType fonts, you can find localized names in the name record of an OpenType file.

The Naming Table (OpenType Spec 1.6) @ Microsoft Typography
Font Names Table (TrueType Spec) @ Apple

For PostScript Type 1 fonts, you can locate the assigned names by their FontName declarations.

Adobe Type 1 Font Format @ Adobe (PDF)

Update:

I checked to see whether the PostScript name can be used to instantiate a font, and unfortunately it doesn't work. However, using the localized name (as retrieved from Mark Ransom's link in his comment) does work. This sample is in C#.

using System.Drawing;

namespace FontNameCheckApplication
{
    class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            Font TimesNewRomanByPSName = new Font("TimesNewRomanPSMT", 16f);
            Console.WriteLine("TimesNewRomanPSMT = {0}", TimesNewRomanByPSName.Name);

            Font TimesNewRomanByName = new Font("Times New Roman", 16f);
            Console.WriteLine("Times New Roman = {0}", TimesNewRomanByName.Name);

            Font ArialByPSName = new Font("ArialMT", 16f);
            Console.WriteLine("ArialMT = {0}", ArialByPSName.Name);

            Font ArialByName = new Font("Arial", 16f);
            Console.WriteLine("Arial = {0}", ArialByName.Name);

            Font GulimByEnglishName = new Font("Gulim", 16f);
            Console.WriteLine("Gulim = {0}", GulimByEnglishName.Name);

            Font GulimByKoreanName = new Font("굴림", 16f);
            Console.WriteLine("굴림 = {0}", GulimByKoreanName.Name);

            Console.ReadKey();
        }
    }
}

Unfortunately we've butted heads with Font substitution, as "Microsoft Sans Serif" is definitely not Times New Roman nor Arial. This indicates that the PostScript name can't be used reliably to reference the same font.

Here's the output:

TimesNewRomanPSMT = Microsoft Sans Serif
Times New Roman = Times New Roman
ArialMT = Microsoft Sans Serif
Arial = Arial
Gulim = Gulim
?? = Gulim

Update #2:

Here's a sample for Win32.

One thing to note is that CreateFontIndirect() is subject to substitution. When running this sample, I never got an empty handle, even for PostScript names. To see whether we can get an unsubstituted match, we should use EnumFontFamiliesEx() to scan the available system font list. We get the same results as the C#, but without substitutions. For some fonts the results may depending on the graphics mode setting (see SetGraphicsMode() / GM_ADVANCED).

LOGFONT structure (Windows) @ MSDN
CreateFontIndirect function (Windows) @ MSDN
SetGraphicsMode function (Windows) @ MSDN
EnumFontFamiliesEx function (Windows) @ MSDN
EnumFontFamExProc callback function (Windows) @ MSDN

#include "stdafx.h"
#include <Windows.h>

void TestCreateFont(LPCTSTR lpczFontName, BYTE bCharSet)
{
  LOGFONT lf;
  lf.lfHeight = 0;
  lf.lfWidth = 0;
  lf.lfEscapement = 0;
  lf.lfOrientation = 0;
  lf.lfWeight = FW_DONTCARE;
  lf.lfItalic = FALSE;
  lf.lfUnderline = FALSE;
  lf.lfStrikeOut = FALSE;
  lf.lfCharSet = bCharSet;
  lf.lfOutPrecision = OUT_OUTLINE_PRECIS;
  lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  lf.lfQuality = DEFAULT_QUALITY;
  lf.lfPitchAndFamily = DEFAULT_PITCH;  
  // NOTE: LF_FACESIZE = 32, WinGdi.h
  _tcsncpy_s(lf.lfFaceName, 32, lpczFontName, _tcsnlen(lpczFontName, 32));

  HFONT hf = ::CreateFontIndirect(&lf);

  // NOTE: LF_FACESIZE = 32, WinGdi.h
  _tprintf_s(_T("TestCreateFont:\r\n%.32s = %.32s, bCharSet=%d, HFONT=0x%8.8x\r\n\r\n"), lpczFontName, lf.lfFaceName, bCharSet, hf);

  ::DeleteObject(hf);
}

int CALLBACK MyEnumFontFamExProc(const LOGFONT *lpelfe, const TEXTMETRIC *lpntme, DWORD FontType, LPARAM lParam)
{
  _tprintf_s(_T("  Found: %.32s, bCharSet=%d\r\n"), lpelfe->lfFaceName, lpelfe->lfCharSet);

  return 1;
}

void TestEnumFontFamiliesEx(LPCTSTR lpczFontName, BYTE bCharSet)
{
  LOGFONT lf;
  lf.lfHeight = 0;
  lf.lfWidth = 0;
  lf.lfEscapement = 0;
  lf.lfOrientation = 0;
  lf.lfWeight = FW_DONTCARE;
  lf.lfItalic = FALSE;
  lf.lfUnderline = FALSE;
  lf.lfStrikeOut = FALSE;
  lf.lfCharSet = bCharSet;
  lf.lfOutPrecision = OUT_OUTLINE_PRECIS;
  lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  lf.lfQuality = DEFAULT_QUALITY;
  lf.lfPitchAndFamily = DEFAULT_PITCH; // NOTE: DEFAULT_PITCH = 0, WinGdi.h
  // NOTE: LF_FACESIZE = 32, WinGdi.h
  _tcsncpy_s(lf.lfFaceName, 32, lpczFontName, _tcsnlen(lpczFontName, 32));

  _tprintf_s(_T("TestEnumFontFamiliesEx: %.32s, bCharSet=%d\r\n"), lpczFontName, bCharSet);

  HDC hdcAll = GetDC(NULL);

  ::EnumFontFamiliesEx(hdcAll, &lf, &MyEnumFontFamExProc, 0, 0);
}

int _tmain(int argc, _TCHAR* argv[])
{
  TestCreateFont(_T("TimesNewRomanPSMT"), DEFAULT_CHARSET);
  TestCreateFont(_T("Times New Roman"), DEFAULT_CHARSET);

  TestCreateFont(_T("ArialMT"), DEFAULT_CHARSET);
  TestCreateFont(_T("Arial"), DEFAULT_CHARSET);

  TestCreateFont(_T("Gulim"), DEFAULT_CHARSET);

  TestCreateFont(_T("굴림"), DEFAULT_CHARSET);

  TestEnumFontFamiliesEx(_T("TimesNewRomanPSMT"), DEFAULT_CHARSET);
  TestEnumFontFamiliesEx(_T("Times New Roman"), DEFAULT_CHARSET);

  TestEnumFontFamiliesEx(_T("ArialMT"), DEFAULT_CHARSET);
  TestEnumFontFamiliesEx(_T("Arial"), DEFAULT_CHARSET);

  TestEnumFontFamiliesEx(_T("Gulim"), DEFAULT_CHARSET);

  TestEnumFontFamiliesEx(_T("굴림"), DEFAULT_CHARSET);

  return 0;
}

And here are the results:

TestCreateFont:
TimesNewRomanPSMT = TimesNewRomanPSMT, bCharSet=1, HFONT=0xda0a117c

TestCreateFont:
Times New Roman = Times New Roman, bCharSet=1, HFONT=0xdb0a117c

TestCreateFont:
ArialMT = ArialMT, bCharSet=1, HFONT=0xdc0a117c

TestCreateFont:
Arial = Arial, bCharSet=1, HFONT=0xdd0a117c

TestCreateFont:
Gulim = Gulim, bCharSet=1, HFONT=0xde0a117c

TestCreateFont:
?? = ??, bCharSet=1, HFONT=0xdf0a117c

TestEnumFontFamiliesEx: TimesNewRomanPSMT, bCharSet=1
TestEnumFontFamiliesEx: Times New Roman, bCharSet=1
  Found: Times New Roman, bCharSet=0
  Found: Times New Roman, bCharSet=177
  Found: Times New Roman, bCharSet=178
  Found: Times New Roman, bCharSet=161
  Found: Times New Roman, bCharSet=162
  Found: Times New Roman, bCharSet=186
  Found: Times New Roman, bCharSet=238
  Found: Times New Roman, bCharSet=204
  Found: Times New Roman, bCharSet=163
  Found: Times New Roman, bCharSet=0
  Found: Times New Roman, bCharSet=177
  Found: Times New Roman, bCharSet=161
  Found: Times New Roman, bCharSet=162
  Found: Times New Roman, bCharSet=186
  Found: Times New Roman, bCharSet=238
  Found: Times New Roman, bCharSet=204
  Found: Times New Roman, bCharSet=163
  Found: Times New Roman, bCharSet=0
  Found: Times New Roman, bCharSet=177
  Found: Times New Roman, bCharSet=178
  Found: Times New Roman, bCharSet=161
  Found: Times New Roman, bCharSet=162
  Found: Times New Roman, bCharSet=186
  Found: Times New Roman, bCharSet=238
  Found: Times New Roman, bCharSet=204
  Found: Times New Roman, bCharSet=163
  Found: Times New Roman, bCharSet=0
  Found: Times New Roman, bCharSet=177
  Found: Times New Roman, bCharSet=161
  Found: Times New Roman, bCharSet=162
  Found: Times New Roman, bCharSet=186
  Found: Times New Roman, bCharSet=238
  Found: Times New Roman, bCharSet=204
  Found: Times New Roman, bCharSet=163
TestEnumFontFamiliesEx: ArialMT, bCharSet=1
TestEnumFontFamiliesEx: Arial, bCharSet=1
  Found: Arial, bCharSet=0
  Found: Arial, bCharSet=177
  Found: Arial, bCharSet=178
  Found: Arial, bCharSet=161
  Found: Arial, bCharSet=162
  Found: Arial, bCharSet=186
  Found: Arial, bCharSet=238
  Found: Arial, bCharSet=204
  Found: Arial, bCharSet=163
  Found: Arial, bCharSet=0
  Found: Arial, bCharSet=177
  Found: Arial, bCharSet=161
  Found: Arial, bCharSet=162
  Found: Arial, bCharSet=186
  Found: Arial, bCharSet=238
  Found: Arial, bCharSet=204
  Found: Arial, bCharSet=163
  Found: Arial, bCharSet=0
  Found: Arial, bCharSet=177
  Found: Arial, bCharSet=178
  Found: Arial, bCharSet=161
  Found: Arial, bCharSet=162
  Found: Arial, bCharSet=186
  Found: Arial, bCharSet=238
  Found: Arial, bCharSet=204
  Found: Arial, bCharSet=163
  Found: Arial, bCharSet=0
  Found: Arial, bCharSet=177
  Found: Arial, bCharSet=161
  Found: Arial, bCharSet=162
  Found: Arial, bCharSet=186
  Found: Arial, bCharSet=238
  Found: Arial, bCharSet=204
  Found: Arial, bCharSet=163
TestEnumFontFamiliesEx: Gulim, bCharSet=1
  Found: Gulim, bCharSet=0
  Found: Gulim, bCharSet=129
  Found: Gulim, bCharSet=161
  Found: Gulim, bCharSet=162
  Found: Gulim, bCharSet=186
  Found: Gulim, bCharSet=238
  Found: Gulim, bCharSet=204
TestEnumFontFamiliesEx: ??, bCharSet=1
  Found: Gulim, bCharSet=0
  Found: Gulim, bCharSet=129
  Found: Gulim, bCharSet=161
  Found: Gulim, bCharSet=162
  Found: Gulim, bCharSet=186
  Found: Gulim, bCharSet=238
  Found: Gulim, bCharSet=204

Here's a snippet from wingdi.h for the CharSet values.

#define ANSI_CHARSET            0
#define DEFAULT_CHARSET         1
#define SYMBOL_CHARSET          2
#define SHIFTJIS_CHARSET        128
#define HANGEUL_CHARSET         129
#define HANGUL_CHARSET          129
#define GB2312_CHARSET          134
#define CHINESEBIG5_CHARSET     136
#define OEM_CHARSET             255

#define JOHAB_CHARSET           130
#define HEBREW_CHARSET          177
#define ARABIC_CHARSET          178
#define GREEK_CHARSET           161
#define TURKISH_CHARSET         162
#define VIETNAMESE_CHARSET      163
#define THAI_CHARSET            222
#define EASTEUROPE_CHARSET      238
#define RUSSIAN_CHARSET         204

#define MAC_CHARSET             77
#define BALTIC_CHARSET          186

IServiceProvider is an imported (or perhaps held-over) COM interface that is intended to be used for private features in the context of the object whom you interrogate for a Service. The term 'Service' is applied rather loosely here, it originally meant any COM object that could be returned based upon what GUID is given.

IServiceProvider @ MSDN (.NET reference)
IServiceProviderImpl Class @ MSDN (C++ ATL reference)

In .NET, you don't need to implement it unless you have a client that specifically supports it, and in many cases you won't need to add yet another level of indirection that is implied by using IServiceProvider. Also, you can devise your own scheme to share common objects or implement other use patterns based upon IoC / Dependency Injection that are more flexible or more rigid as dictated by your needs.

One good historical context for IServiceProvider is the IE Browser Plugin Spec. Here, it is used to allow plugin components to use Browser Host features in-context. In a COM context, this interface is useful because it hides the details of instantiation and also can be used as part of a object construction and utilization strategy to avoid reference loops.

WebBrowser Customization (Part 2) @ MSDN

Update:

Indeed, the response is malformed as well. I tried the URL with a different ticker symbol and it looks like there is a stray " mark in the output in the previous_close field. If you remove the stray " mark, it should validate properly.

"meta" :
 {
  "uri" :"/instrument/1.1/ITW/chartdata;type=close;range=1d/json/?callback=",
  "ticker" : "itw",
  "unit" : "MIN",
  "timezone" : "EST",
  "currency" : "USD",
  "gmtoffset" : -18000,
  "previous_close" : 62.9000"
 }

~

Original:

The response returned is in JSONP format.

finance_charts_json_callback( {
...
} )

Off the cuff, you should be able to strip away finance_charts_json_callback( from the start and the trailing ) from the end and end up with valid JSON data.

JSONP @ Wikipedia

Remoting in a COM context means "ability to reference an object in another scope" where that scope could be in another apartment in the same process, or in another process on the same machine or even a different machine. A COM apartment is a running context whose configuration defines the ways other COM objects may call COM objects inside the apartment.

Processes, Threads, and Apartments (COM) @ MSDN

In .NET, remoting means "ability to converse with an object in another location", and is an entire subsystem in itself for making calls across process and machine boundaries.

.NET Framework Remoting Overview @ MSDN

.NET has the concept of AppDomains, which have intents that are similar to COM apartments. Most applications written on .NET don't explicitly manage multiple AppDomains at anywhere near the same amount of awareness that is required in COM.

System.AppDomain @ MSDN

For your work items, Windows Workflow is probably your quickest means to refactor your service.

Windows Workflow Foundation @ MSDN

The most useful thing you'll get out of WF is workflow persistence, where a properly designed workflow may resume from a Persist point, should anything happen to the workflow from the last point at which it was saved.

Workflow Persistence @ MSDN

This includes the ability for a workflow to be recovered from another process should any other process crash while processing the workflow. The resuming process doesn't need to be on the same machine if you use the shared workflow store. Note that all recoverable workflows require the use of the workflow store.

For work distribution, you have a couple options.

1. A service to produce messages combined with host-based load balancing via workflow invocation using WCF endpoints via the WorkflowService class. Note that you'll probably want to use the design-mode editor here to construct entry methods rather than manually setup Receive and corresponding SendReply handlers (these map to WCF methods). You would likely call the service for every Message, and perhaps also call the service for every Report. Note that the CanCreateInstance property is important here. Every invocation tied to it will create a running instance that runs independently.
   ~
   WorkflowService Class (System.ServiceModel.Activities) @ MSDN
   Receive Class (System.ServiceModel.Activities) @ MSDN
   Receive.CanCreateInstance Property (System.ServiceModel.Activities) @ MSDN
   SendReply Class (System.ServiceModel.Activities) @ MSDN

2. Use a service bus that has Queue support. At the minimum, you want something that potentially accepts input from any number of clients, and whose outputs may be uniquely identified and handled exactly once. A few that come to mind are NServiceBus, MSMQ, RabbitMQ, and ZeroMQ. Out of the items mentioned here, NServiceBus is exclusively .NET ready out-of-the-box. In a cloud context, your options also include platform-specific offerings such as Azure Service Bus and Amazon SQS.
   ~
   NServiceBus
   MSMQ @ MSDN
   RabbitMQ
   ZeroMQ
   Azure Service Bus @ MSDN
   Amazon SQS @ Amazon AWS
   ~
   Note that the service bus is just the glue between a producer that will initiate Messages and a consumer that can exist on any number of machines to read from the queue. Similarly, you can use this indirection for Report generation. Your consumer will create workflow instances that may then use workflow persistence.

3. Windows AppFabric may be used to host workflows, allowing you to use many techniques that apply to IIS load balancing to distribute your work. I don't personally have any experience with it, so there's not much I can say for it other than it has good monitoring support out-of-the-box.
   ~
   How to: Host a Workflow Service with Windows App Fabric @ MSDN

You're in luck, as there's already a container control called a FlowLayoutPanel that will get you 90% of the way there as a flowing tag host.

FlowLayoutPanel Class @ MSDN

This control is available from the Toolbox in Visual Studio, so a good starting point would be to make a custom control based upon a FlowLayoutPanel, and another custom control to represent a tag based upon a Label or Checkbox, and update the drawing and behavior (in the case of a Label) to respond to clicks and to display the [x] to dismiss the tag.

Label Class @ MSDN
CheckBox Class @ MSDN

After making these two controls, you will need to do additional work to make your FlowLayoutPanel-derived control add/remove Label-based controls representing the state of the tags present.

Update: One thing I missed, a TextBox or other input field would need to be added in place to support adding new tags.

TextBox @ MSDN

A brief walk through the source code provided by twitterizer suggests that their API target hasn't been updated yet.

The lines of code that call this into question are at Twitterizer/Twitterizer2/Core/OptionalProperties.cs at https://github.com/Twitterizer/Twitterizer starting at line 50. Here's a snippet.

    public OptionalProperties()
    {
        // Set the default values for the properties
        this.UseSSL = false;
        this.APIBaseAddress = "http://api.twitter.com/1/";
    }

There are quite a bit of source code that look like it will need to be checked against v1.1, but you could try building the library with the version number in the APIBaseAddress symbol changed from /1/ to /1.1/ to see what breaks, and perhaps send a pull request with updates if you're up to it.

A complete list of the REST API methods for 1.1 is here. (@ dev.twitter.com)

Footnote: Twitterizer3 has the same base endpoint URL too. (@ github)

The documentation for IDirect3D9Ex::CreateDeviceEx says the HWND parameter is optional if you are in windowed mode and your presentation HWND in your D3DPRESENT_PARAMETERS structure is set (late edit: oops, can't be blank).

From IDirect3D9Ex::CreateDeviceEx @ MSDN

hFocusWindow [in]
Type: HWND
The focus window alerts Direct3D when an application switches from foreground mode to background mode. For full-screen mode, the window specified must be a top-level window. For windowed mode, this parameter may be NULL only if the hDeviceWindow member of pPresentationParameters is set to a valid, non-NULL value.

D3DPRESENT_PARAMETERS struct @ MSDN

To get a window handle for use, you can make another top-level window via regular .NET framework methods and grab its window handle instead of going through the motions with Win32 method calls.

If you find can't use the Handle provided by WPF (per Hans Passant's comment), you can also make a dummy Windows Form and instantiate it as a hidden window, and use its handle instead.

WindowInteropHelper (WPF) @ MSDN

Control.Handle (Windows Forms) @ MSDN

Footnote: Your existing WPF main window handle is probably fine unless some mechanism in SharpDX or an existing Viewport3D has a conflict with using Direct3D9 in this manner.

3-D Graphics Overview (WPF) @ MSDN
Viewport3D Class (WPF) @ MSDN

You'll need to enumerate all the monitors and check on their mappings on the virtual screen (MSDN).

Monitors are enumerated via a call to EnumDisplayMonitors (MSDN). This will enumerate a series of HMONITOR handles that you can pass to GetMonitorInfo (MSDN) to get the location of the monitor on the virtual screen.

There's also a whole guide to Multi-Monitor support that may also be worth reading.

About Multiple Display Monitors (Windows) @ MSDN

Some Caveats: Because the virtual screen is a user-controlled mapping, there's nothing preventing a user from setting up a monitor on the opposite physical side of where the monitor is placed in virtual coordinate space, and vice versa, as well as any number of other weird placement scenarios. Also, some display cards try to assume where the monitor is upon plug-in detection, which may be wrong from your software's point of view but could be caused by the user not paying attention to which display port maps to a left-hand side (if it is even labeled at all).

To consume functions from DLLs as done in a Win32 context, these functions need to be export-visible from the DLL. These functions are usually flagged with dllexport and will show up in the export table of a DLL. You can verify that user32 and other Win32 DLLs do this by using a utility such as dumpbin (MSDN).

dllexport, dllimport @ MSDN

Unfortunately, .NET doesn't have immediate support for making functions export-visible, only for bringing in such functions via the DllImport (MSDN) Attribute.

COM is the easiest way to consume code written within .NET from a non-.NET environment, but if you must use the lower level bindings, you can make an intermediate DLL in C, C++/CLI, or any other language and framework combination that can write export headers to a dll, to call your .NET code.

Also, A few articles exist on making this happen via post-compilation automation or other workarounds, here are a few for your reference.

How to Automate Exporting .NET Function to Unmanaged Programs @ CodeProject

Unmanaged Exports @ Google Sites

DllExport - Provides C-style exports for pure .NET assemblies

The windows message you wish to handle is WM_EXITSIZEMOVE.

WM_EXITSIZEMOVE message (Windows) @ MSDN

Depending on what you wish to accomplish, there's also the possibility that you might be better served by reacting to WM_NCLBUTTONUP, which is sent when the mouse button is released in the non-client areas of a window, such as the title bar of any window with a caption, border chrome, etc.

WM_NCLBUTTONUP message (Windows) @ MSDN

ExpandoObject derives from IEnumerable<KeyValuePair<string, Object>>, and most serializers will recognize a dynamic as this type when you assign an ExpandoObject. This is why you see an array type on the javascript side with named Key::Value pairs.

ExpandoObject Class (System.Dynamic) @ MSDN

One alternative to using ExpandoObject is to use C# anonymous types. When serialized to json, these map field by field as you expect.

Anonymous Types (C# Programming Guide) @ MSDN

It is possible to access values declared with dynamic from jQuery, but most likely you won't be returning a MVC View() with the model to be consumed with jQuery, as any server-side view template engine (razor, etc.) can already perform the same template activities with less overhead. Instead, jQuery templates are better used with Ajax calls.

Here are code examples demonstrating three cases where a variable declared dynamic on the server is consumed with jQuery templates in the browser.

The first example uses an anonymous type for the member field SomeValue, and has a jQuery template that treats it as a member object.

The second example uses an array of anonymous types for the member field SomeValue and has a template that uses {{each}} syntax to enumerate the items. Note that this is a scenario where things can go badly with dynamic, as you get no strongly-typed support and must either know the correct type or discover it at the time you access it.

The third example uses an ExpandoObject for the member field SomeValue, and has a jQuery template like the first example (single member object). Note that in this case, we need to use a helper function pivotDictionaryMap() to pivot Key::Value pairs into object members.

Starting with a blank C# MVC3 Web Project, we need to modify three files to demonstrate these examples.

Inside _Layout.cshtml, add script includes for jQuery templates and a proper version of jQuery in your <head> element.

<script src="@Url.Content("~/Scripts/jquery-1.8.2.min.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/jquery.tmpl.js")" type="text/javascript"></script>

Inside HomeController.cs, we'll add some methods that return json ActionResults. Also, for brevity we'll just declare a class SomeModelType here; and note that a proper application would probably have this class declared in its Models.

using System.Dynamic; // up top...

public class HomeController : Controller
{
    public ActionResult Index()
    {
        ViewBag.Message = "Welcome to ASP.NET MVC!";

        return View();
    }

    public ActionResult SomeDataSource(int id)
    {
        dynamic d = new { innerId = 99, innerLabel = "inside object" };
        SomeModelType obj = new SomeModelType(id, "new object");
        obj.SomeValue = d;

        return Json(obj, "text/plain");
    }

    public ActionResult SomeDataSourceWithArray(int id)
    {
        dynamic d1 = new { innerId = 99, innerLabel = "inside object (first array member)" };
        dynamic d2 = new { innerId = 100, innerLabel = "inside object (second array member)" };

        SomeModelType obj = new SomeModelType(id, "new object");
        obj.SomeValue = new object[] {d1, d2};

        return Json(obj, "text/plain");
    }

    public ActionResult SomeDataSourceWithExpando(int id)
    {
        dynamic d = new ExpandoObject();
        d.innerId = 99;
        d.innerLabel = "inside object";

        SomeModelType obj = new SomeModelType(id, "new object");
        obj.SomeValue = d;

        return Json(obj, "text/plain");
    }
}

public class SomeModelType
{
    public SomeModelType(int initId, string initLabel)
    {
        Id = initId;
        Label = initLabel;
    }

    public int Id { get; set; }
    public string Label { get; set; }
    public dynamic SomeValue { get; set; }
}

Finally, in the default view, we will add script tags for the templates and the javascript necessary to consume them. Note the use of $.post() and not $.get(), as a JsonResult in MVC disallows GET requests by default (you can turn these on with an attribute).

@{
    ViewBag.Title = "Home Page";
}
<h2>@ViewBag.Message</h2>

<script id="someDataTemplate" type="text/x-jquery-tmpl">
Item <b>${Id}</b> is labeled "<i>${Label}</i>" and has an inner item with id <b>${SomeValue.innerId}</b> whose label is "<i>${SomeValue.innerLabel}</i>".
</script>

<h3>SomeDataSource Example #1 (Single Item)</h3>
<div id="someData">
</div>

<script id="someDataArrayTemplate" type="text/x-jquery-tmpl">
Item <b>${Id}</b> is labeled "<i>${Label}</i>" and has these inner items:
<ul>
 {{each SomeValue}}
    <li><b>${innerId}</b> has a label "<i>${innerLabel}</i>".</li>
 {{/each}}
</ul>
</script>

<h3>SomeDataSource Example #2 (Array)</h3>
<div id="someArrayData">
</div>

<script id="someDataTemplateFromExpandoObject" type="text/x-jquery-tmpl">
Item <b>${Id}</b> is labeled "<i>${Label}</i>" and has an inner item with id <b>${SomeValue.innerId}</b> whose label is "<i>${SomeValue.innerLabel}</i>".
</script>

<h3>SomeDataSource Example #3 (Single Item, Expando Object)</h3>
<div id="someDataFromExpandoObject">
</div>

<script type="text/javascript">
function pivotDictionaryMap(src)
{
    var retval = {};

    $.each(src, function(index, item){
        retval[item.Key] = item.Value;
    });

    return retval;
}
</script>

<script type="text/javascript">
$(document).ready(function() {
    // Ajax Round-Trip to fill example #1
    $.post("/Home/SomeDataSource/5", function(data) {
        $("#someDataTemplate").tmpl(data).appendTo("#someData");
    }, "json");

    // Ajax Round-Trip to fill example #2
    $.post("/Home/SomeDataSourceWithArray/67", function(data) {
        $("#someDataArrayTemplate").tmpl(data).appendTo("#someArrayData");
    }, "json");

    // Ajax Round-Trip to fill example #3
    $.post("/Home/SomeDataSourceWithExpando/33", function(data) {
        data.SomeValue = pivotDictionaryMap(data.SomeValue);
        $("#someDataTemplateFromExpandoObject").tmpl(data).appendTo("#someDataFromExpandoObject");
    }, "json");
});
</script>

There's no bug in your code. Your graph is accurately drawing the values that are in your histogram[] array.

You mention that your array contains the following values:

histogram[0] = 34118
histogram[1] = 1521
histogram[2] = 522
...

If you inspect your screenshot, the plots are correct. The very first bar drawn is quite tall, and the other remaining values (to your expectations) are close to the 1x10^3 band. It is likely that your histogram[] array is being initialized with the wrong data, or faulty data at index [0].

I can only provide speculation about the significance of the value in at histogram[0] from this side of your code and data, but perhaps you are receiving an array that has the sum of all of the remaining data in index [0].

As a quick check of expectations, if you change your loop to start from index [1] instead of [0], you will see that the plot control you are using will perform correctly for all the other values that are expected to be near the 1x10^3 band, and you should check the data source that fills your histogram array to see if that first data point is relevant or has been set to an erroneous value.

for (int i = 1; i < histogram.Length; i++)
{
    double x = (double)i + 1;
    //double y = (double)i + 1;//rand.NextDouble() * 1000;
    double z = i / 4.0;
    list.Add(x, histogram[i], z);
}

Updated

The only other remaining places where your code could fail is in these two lines in your snippet for the SelectedDatabase property.

        RaisePropertyChanged("SelectedDatabase");
        // Update the can execute flag based on the save
        ((DelegateCommand)OpenDatabaseCommand).RaiseCanExecuteChanged();

There are others who have had some problems with RaisePropertyChanged() and it's use of magic strings; but this is probably not your immediate problem. Nonetheless, you can look at these links if you want to go down the path of removing the magic string dependency.

WPF, MVVM, and RaisePropertyChanged @ WilberBeast
MVVM - RaisePropertyChanged turning code into a mess

The RaiseCanExecuteChanged() method is the other suspect, and looking up documentation in PRISM reveals that this method expects to dispatch events on the UI thread. From mstest, there are no guarantees that a UI thread is being used to dispatch tests.

DelegateCommandBase.RaiseCanExecuteChanged @ MSDN

I recommend you add a try/catch block around it and see if any exceptions are thrown when RaiseCanExecuteChanged() is called. Note the exceptions thrown so that you can decide how to proceed next. If you absolutely need to test this event dispatch, you may consider writing a tiny WPF-aware app (or perhaps a STAThread console app) that runs the actual test and exits, and having your test launch that app to observe the result. This will isolate your test from any threading concerns that could be caused by mstest or your build server.

Original

This snippet of code seems suspect. If your event fires from another thread, the original thread may exit the wait first before your assignment, causing your flag to be read with a stale value.

viewModel.OpenDatabaseCommand.CanExecuteChanged += (s, e) =>
    {
         resetEvent.Set();
         canExecuteChanged = true;
    };

Consider reordering the lines in the block to this:

viewModel.OpenDatabaseCommand.CanExecuteChanged += (s, e) =>
    {
         canExecuteChanged = true;
         resetEvent.Set();
    };

Another issue is that you don't check if your wait was satisfied. If 250ms did elapse without a signal, your flag will be false.

See WaitHandle.WaitOne to check what return values you'll receive and update this section of code to handle the case of an unsignaled exit.

// Allow the event to happen
resetEvent.WaitOne(250);

// Check that it worked
Assert.IsTrue(canExecuteChanged,
    "OpenDatabaseCommand.CanExecuteChanged should be raised when SelectedDatabase is set");

You can't avoid the RichTextBox's intrinsic behavior to queue up at least one redraw whenever the text changes, but in the code snippet you've provided, you can just set prepare the text out of band instead of calling clear. This will cut the amount of visual activity change to a minimum without having to change it's normal operation. In addition, it looks like you wish to keep the contents the same as the view for your KeyValue set.

Use a StringBuilder to assemble your text before applying it to the RichTextBox, then assign the Text property if there is a difference. If there is no change to the contents of the RichTextBox, it will not redraw everything, which is the source of the flashing behavior that you are seeing.

private void clearRichtextBox()
{
    StringBuilder sb = new StringBuilder();

    foreach (KeyValuePair<string, List<string>> kvp in LocalyKeyWords)
    {
        for (int i = 0; i < kvp.Value.Count(); i++)
        {
            sb.AppendFormat("Url: {0} --- Localy KeyWord: {1}{2}", kvp.Key,kvp.Value[i],Environment.NewLine);
        }
    }

    string viewString = sb.ToString();
    if(viewString != richTextBox2.Text)
    {
         richTextBox2.Text = viewString;
    }
}

Your source JSON is just a single object. Instead of loading into an array, loading straight into a JSONObject should suffice.

JSONObject jsonObject = new JSONObject(builder.toString());

This object will have a single property named ipinfo.

The out keyword (and ref keyword) are used to indicate that a variable is provided from the caller's scope. They don't change the nature of the type in question.

out parameter modifier (C# Reference) @ MSDN

If you're concerned requiring the caller being forced to specify out every time they use your method, you can use a Helper class or a Tuple to wrap the set of values returned.

Tuple Class @ MSDN

You mention that you are concerned about reference-types being changed. This shouldn't be an issue to your method. The parameter specified by out is not shared by all cases where your method may used, they're local to the scope where your method is called. Only the caller needs to worry, and only in their own scope.

Last, if you want to indicate that a variable may be altered or used without being required to assign a value to it as out requires, use ref.

Your sample works if you populate a DataSet instead of a DataTable.

Here is a copy of your source with the minimum changes required. Note that when you're using a DataSet you should add code to check whether any tables were returned, and whether there are rows in the first table available, etc.

Caller:

SqlParameter[] Parameters = new SqlParameter[1];
Parameters[0] = new SqlParameter();
Parameters[0].ParameterName = "@TestId";
Parameters[0].Value = TestId;
Parameters[0].SqlDbType = SqlDbType.Int;
Parameters[0].Size = 50;

DataSet data = ExecuteDataSet("ExportTestAsXML", Parameters);

// Read First table (Tables[0]), First Row (Rows[0]), First Column of that Row (Rows[0][0])
System.Diagnostics.Debug.Write(data.Tables[0].Rows[0][0]);

Method:

private DataSet ExecuteDataSet(string storedProcName, SqlParameter[] parameters)
{
    SqlCommand command = new SqlCommand();
    command.CommandText = storedProcName;
    command.Parameters.AddRange(parameters);
    command.CommandType = CommandType.StoredProcedure;
    command.Connection = (SqlConnection)dcMUPView.Connection;

    command.Connection.Open();
    command.Prepare();

    SqlDataAdapter adapter = new SqlDataAdapter(command);
    DataSet ds = new DataSet ();
    adapter.Fill(ds);

    command.Connection.Close();
    return ds;
}

The default packing is along 8-byte boundaries, according to the MIDL command line switch reference here:

/Zp switch @ MSDN (MIDL Language Reference)

Other parts of your code are more likely to break first if the pack value is changed, as the IDL file is usually pre-compiled ahead of time, and it is rare that someone will deliberately alter the command line switches given to MIDL (but not so rare that someone could fiddle with the C-scope #pragma pack and forget to restore the default state).

If you have a good reason to alter the setting, you can explicitly set the packing with a pragma pack statement.

pragma Attribute @ MSDN (MIDL Language Reference)

It is pretty good fortune that no party has changed any setting that would interfere with the default packing. Can it go wrong? Yes, if someone goes out of their way to change the defaults.

When using an IDL file, the details are typically compiled into a typelib (.tlb), and it is assumed that the platform are the same for both servers and clients when using the same typelib. This is suggested in the footnotes for the /Zp switch, as certain values will fail against certain non-x86 or 16-bit targets. There can also be 32bit <-> 64bit conversion cases that could cause expectations to break. Unfortunately I don't know if there are even more cases out there, but the defaults do work with minimal fuss.

C# and VB do not have any intrinsic behavior to handle information in a .tlb; instead, a tool like tlbimp is typically used to convert COM definitions into definitions usable from .NET. I can't verify whether all expectations succeed between C#/VB.NET and COM clients and servers; However, I can verify that using a specific pragma setting other than 8 will work if you reference a .tlb that was created from an IDL compiled under that setting. While I wouldn't recommend going against the default pragma pack, here are the steps to perform if you'd like a working example to use as a reference. I created a C++ ATL project and a C# project to check.

Here are the C++ side instructions.

1. I created an ATL project called SampleATLProject with the default settings in Visual Studio 2010, no fields changed. This should create a dll project for you.
2. Compiled the project to assure that the proper C-side interface files are being created (SampleATLProject_i.c and SampleATLProject_i.h).
3. I added an ATL Simple Object called SomeFoo to the project. Again, no defaults were altered. This creates a class called CSomeFoo that is added to your project.
4. Compile SampleATLProject.
5. I right-clicked the SampleATLProject.idl file, then under the MIDL settings, set the Struct Member Alignment to 4 bytes (/Zp4).
6. Compile SampleATLProject.
7. I altered the IDL to add a struct definition called 'BarStruct'. This entailed adding a C-style struct definition with the MIDL uuid attribute, and an entry in library section referencing the struct definition. See snippet below.
8. Compile SampleATLProject.
9. From the Class View, I right-clicked on ISomeFoo and added a method called FooIt, that takes a struct BarStruct as an [in] parameter called theBar.
10. Compile SampleATLProject.
11. In SomeFoo.cpp, I added some code to print out the size of the struct and throw up a Message Box containing the details.

Here is my IDL for the ATL project.

import "oaidl.idl";
import "ocidl.idl";

[uuid(D2240D8B-EB97-4ACD-AC96-21F2EAFFE100)]
struct BarStruct
{
  byte a;
  int b;
  byte c;
  byte d;
};

[
  object,
  uuid(E6C3E82D-4376-41CD-A0DF-CB9371C0C467),
  dual,
  nonextensible,
  pointer_default(unique)
]
interface ISomeFoo : IDispatch{
  [id(1)] HRESULT FooIt([in] struct BarStruct theBar);
};
[
  uuid(F15B6312-7C46-4DDC-8D04-9DEA358BD94B),
  version(1.0),
]
library SampleATLProjectLib
{
  struct BarStruct;
  importlib("stdole2.tlb");
  [
    uuid(930BC9D6-28DF-4851-9703-AFCD1F23CCEF)      
  ]
  coclass SomeFoo
  {
    [default] interface ISomeFoo;
  };
};

Inside the CSomeFoo class, here is the implementation for FooIt().

STDMETHODIMP CSomeFoo::FooIt(struct BarStruct theBar)
{
  WCHAR buf[1024];
  swprintf(buf, L"Size: %d, Values: %d %d %d %d", sizeof(struct BarStruct), 
           theBar.a, theBar.b, theBar.c, theBar.d);

  ::MessageBoxW(0, buf, L"FooIt", MB_OK);

  return S_OK;
}

Next, on the C# side:

1. Go to the debug or desired output directory for SampleATLProject and run tlbimp.exe on the .tlb file generated as part of the C++ project output. The following worked for me:

   tlbimp SampleATLProject.tlb /out:Foo.dll /namespace:SampleATL.FooStuff

2. Next, I created a C# console application, and added a reference to Foo.dll to the project.

3. In the References folder, go to the Properties for Foo and turn off Embed Interop Types by setting it to false.
4. I added a using statement to reference the namespace SampleATL.FooStuff as given to tlbimp, added the [STAThread] attribute to Main() (the COM apartment models have to match for in-proc consumption), and added some code to call the COM component.

Tlbimp.exe (Type Library Importer) @ MSDN

Here is the source code for that console app.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using SampleATL.FooStuff;

namespace SampleATLProjectConsumer
{
    class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            BarStruct s;
            s.a = 1;
            s.b = 127;
            s.c = 255;
            s.d = 128;

            ISomeFoo handler = new SomeFooClass();
            handler.FooIt(s);
        }
    }
}

Finally, it runs and I get a modal popup with the following string displayed:

Size: 12, Values: 1 127 255 128

To be sure that a pragma pack change can be made (as 4/8 byte packing are the most common alignments used), I followed these steps to change it to 1:

1. I returned to the C++ project, went to the properties for SampleATLProject.idl and changed the Struct Member Alignment to 1 (/Zp1).
2. Recompile SampleATLProject
3. Run tlbimp again with the updated .tlb file.
4. A warning icon will appear on the .NET File Reference to Foo, but may disappear if you click on the reference. If it doesn't, you can remove and re-add the reference to the C# console project to be sure it is using the new updated version.

I ran it from here and got this output:

Size: 12, Values: 1 1551957760 129 3

That's weird. But, if we forcefully edit the C-level pragma in SampleATLProject_i.h, we get the correct output.

#pragma pack(push, 1)
/* [uuid] */ struct  DECLSPEC_UUID("D2240D8B-EB97-4ACD-AC96-21F2EAFFE100") BarStruct
    {
    byte a;
    int b;
    byte c;
    byte d;
    } ;
#pragma pack(pop)

SampleATLProject is recompiled here, no changes to the .tlb or .NET project, and we get the following:

Size: 7, Values: 1 127 255 128

Regarding IDispatch, it depends on whether your client is late-bound. Late-bound clients have to parse the type information side of IDispatch and discern the proper definitions for non-trivial types. The documentation for ITypeInfo and TYPEATTR suggests that it is possible, given that the cbAlignment field provides the information necessary. I suspect most will never alter or go against the defaults, as this would be tedious to debug if things went wrong or if the pack expectations had to change between versions. Also, structures are not typically supported by many scripting clients that can consume IDispatch. One can frequently expect that only the types governed by the IDL oleautomation keyword are supported.

IDispatch interface @ MSDN
IDispatch::GetTypeInfo @ MSDN
ITypeInfo interface @ MSDN
TYPEATTR structure @ MSDN

oleautomation keyword @ MSDN

I don't think there is a trivial way to resolve the actual owner of a Mutex, but the process that owns it can create other secondary items whose lifetimes are tied to it. There are plenty of mechanisms that are suitable for calling back across-process without having a main window.

1. Register an object in the COM Running Object Table. Clients that are unable to take ownership of the Mutex can lookup the owner via the ROT and call back to the owner. A File Moniker should be suitable for registration here.
2. Create a chunk of shared memory containing location details for the owner process. From there, write into the buffer the process handle and thread handle of a thread that can receive windows messages, and then use PostThreadMessage() to send a notification. Any other competing process may open the shared memory for read-only to determine where to send a windows message.
3. Listen in the owner process on a Socket or Named Pipe. Probably overkill and not a good match for your needs.
4. Use a shared file with locking. I'm not fond of this because the owner will need to poll, and it won't gracefully handle N potential other processes that could be trying to contact the owner at the same time.

Here are reference links for the first two options.

1. IRunningObjectTable @ MSDN , File Monikers @ MSDN
2. Creating Named Shared Memory @ MSDN

MessageBox() has a windows message pump cycle built into it to service window messages.

Somewhere in your application at a very low level within your design, you need a windows message loop to service messages for the window hosting your openGL content. This should run from within the thread that created the window. The ill effects you are seeing in other places could easily be caused by contention side-effects when MessageBox() is invoked from a different thread.

Here is an intro to the operation of window messages at MSDN.

Using Messages and Message Queues @ MSDN

Very simply put (via a code sample from wikipedia), you need a standing loop akin to the following:

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    MSG msg;
    while(GetMessage(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

Depending on how you have handled updating the window, if you are using paint messages (WM_PAINT), you need to ensure these are dispatched as quickly as possible, or you may need to suppress them entirely if you are drawing direct to the the device DC. I'm mentioning this because you may find additional bugs once a message loop is properly setup.

WM_PAINT message @ MSDN

The sample you've provided doesn't match the members of the class TwitterProfile. Notwithstanding this, you don't need a helper class to handle an array. You can simply target the array type directly at deserialization.

Here's a code sample that you can use to test. I've removed your TwitterProfiles class and stripped down TwitterProfile to just a field named CreatedAt.

Note the following line in the source below:

DataContractJsonSerializer js = 
    new DataContractJsonSerializer(typeof(TwitterProfile[]));

Here is the rest.

using System.Windows.Forms;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.IO;

namespace TwProfileJson
{
    class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            OpenFileDialog dlg = new OpenFileDialog();
            if (dlg.ShowDialog() != DialogResult.OK) { return; }
            string json = System.IO.File.ReadAllText(dlg.FileName);

            using(MemoryStream stm = new MemoryStream(Encoding.UTF8.GetBytes(json)))
            {
                DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(TwitterProfile[]));
                TwitterProfile[] pps = (TwitterProfile[])js.ReadObject(stm);

                foreach(TwitterProfile p in pps)
                {
                    Console.WriteLine(p.CreatedAt);
                }
            }

            Console.ReadKey();
        }

        [DataContract]
        public class TwitterProfile
        {
            [DataMember(Name = "created_at")]
            public string CreatedAt { get; set; }
        }
    }
}

The original specification for COM is old in age, but the specification as well as the concepts are still in use, and you can still create and consume COM objects.

For .NET, you can start by looking at the following links:

Com Interop Part 1: C# Client Tutorial (C#) @ MSDN
Interoperating with unmanaged code @ MSDN

In addition, there are other specs that are very similar to COM or have semantics that are the same. Most notably, XPCOM is in use in FireFox for their plugin spec and also used internally to FireFox to connectable objects.

XPCOM @ MDN (Mozilla)

WinRT is an upcoming platform update for windows that is also heavy in COM concepts.

There are some useful here: Why is WinRT unmanaged @ StackOverflow

For .NET developers, a lot of the declarative overhead is hidden as mentioned here: WinRT demystified - Miguel de Icaza

The head of the spec is here: The Windows Runtime @ MSDN

And in the context of COM, developing WinRT components with C++ has similarities, although some syntax is borrowed from managed C++: Creating Windows Runtime Components in C++ @ MSDN

You were quite close in syntax. The key here is that d["members"] is of type Object[] / object[]. Instead of Array, you can use dynamic[] and everything works just fine.

Also note that even this declaration isn't explicitly necessary, as shown in DPeden's updated sample.

Here is the code for your updated snippet (I used a console app to test):

JavaScriptSerializer js = new JavaScriptSerializer();
dynamic d = js.Deserialize<dynamic>(json);

string key = d["key"];
string status = d["status"];
dynamic[] members = d["members"];

Console.WriteLine("key = {0}", key);
Console.WriteLine("status = {0}", status);

Console.WriteLine("members.length = {0}", members.Length);
Console.WriteLine("members type name = {0}", members.GetType().Name);
Console.WriteLine("d[\"members\"] type name = {0}", d["members"].GetType().Name);

And here is additional code showing array and member access.

Console.WriteLine("--");

for (int i = 0; i < members.Length; i++)
{
    Console.WriteLine("members[{0}][\"id\"] = {1}", i, members[i]["id"]);
    Console.WriteLine("members[{0}][\"name\"] = {1}", i, members[i]["name"]);
}

Console.WriteLine("--");

Console.WriteLine("{0}", d["members"][0]["id"]);
Console.WriteLine("{0}", d["members"][0]["name"]);

Console.ReadKey();

Added after comment:

You would need to pickup some latent detail that you can exploit to be able to accomplish that goal.

One thing that comes to mind is creating your own Forms/WPF timer at construction time and then use this and some synchronization to hide the details of coordination across threads. We can infer from your sample that construction of your poller should always happen in context of your consumer's thread.

This is a rather hack-ish way to accomplish what you want, but it can accomplish the deed because the construction of your poll-listener happens from the consumer's thread (which has a windows message pump to fuel the dispatches of Forms/WPF timers), and the rest of the operation of the class could occur from any thread as the forms Timer's tick will heartbeat from the original thread. As other comments and answers have noted, it would be best to reassess and fix the operating relationship between your polling operations and the consumer.

Here is an updated version of the class, PollingListener2 that uses a ManualResetEvent and a concealed System.Windows.Forms.Timer to ferry the polling notice across threads. Cleanup code is omitted for the sake of brevity. Requiring the use of IDisposable for explicit cleanup would be recommended in a production version of this class.

ManualResetEvent @ MSDN

public class PollingListener2
{
    System.Timers.Timer timer = new System.Timers.Timer(1000);
    public event EventHandler<EventArgs> Polled;

    System.Windows.Forms.Timer formsTimer;
    public System.Threading.ManualResetEvent pollNotice;

    public PollingListener2()
    {
        pollNotice = new System.Threading.ManualResetEvent(false);
        formsTimer = new System.Windows.Forms.Timer();
        formsTimer.Interval = 100;
        formsTimer.Tick += new EventHandler(formsTimer_Tick);
        formsTimer.Start();
        timer.Elapsed += new System.Timers.ElapsedEventHandler(PollNow);
        timer.Start();
    }

    void formsTimer_Tick(object sender, EventArgs e)
    {
        if (pollNotice.WaitOne(0))
        {
            pollNotice.Reset();
            var temp = Polled;
            if (temp != null)
            {
                Polled(this, new EventArgs());
            }
        }
    }

    void PollNow(object sender, EventArgs e)
    {
        pollNotice.Set();
    }
}

This has some precedent in the distant Win32 past where some people would use hidden windows and the like to maintain one foot in the other thread without requiring the consumer to make any significant changes to their code (sometimes no changes are necessary).

Original:

You could add a member variable on your helper class of type Control or Form and use that as the scope for a BeginInvoke() / Invoke() call on your event dispatch.

Here's a copy of your sample class, modified to behave in this manner.

public class PollingListener
{
    System.Timers.Timer timer = new System.Timers.Timer(1000);
    public event EventHandler<EventArgs> Polled;

    public PollingListener(System.Windows.Forms.Control consumer)
    {
        timer.Elapsed += new System.Timers.ElapsedEventHandler(PollNow);
        timer.Start();
        consumerContext = consumer;
    }

    System.Windows.Forms.Control consumerContext;

    void PollNow(object sender, EventArgs e)
    {
        var temp = Polled;
        if ((temp != null) && (null != consumerContext))
        {
            consumerContext.BeginInvoke(new Action(() =>
                {
                    Polled(this, new EventArgs());
                }));
        }
    }
}

Here's a sample that shows this in action. Run this in debug mode and look at your output to verify that it is working as expected.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();

        listener = new PollingListener(this);
    }

    PollingListener listener;

    private void Form1_Load(object sender, EventArgs e)
    {
        listener.Polled += new EventHandler<EventArgs>(listener_Poll);
    }

    void listener_Poll(object sender, EventArgs e)
    {
        System.Diagnostics.Debug.WriteLine("ding.");
    }
}

There are multiple ways to parse this; but in the style you've initially presented, you should try accessing it with [] indexers.

Note that your data has a root object with two properties, meta and response. Assuming response can't be null, you can access categories from it directly like this:

var root = JObject.Parse(/* your json string here */);
var categories = root["response"]["categories"];
var firstCategory = categories[0];

Note that you can use strings matching property names to descend into nested levels, and integers to index into arrays in scope.

Here is the rest of a sample program that can parse the json snippet you've provided.

using System.Windows.Forms;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;

namespace _4sqCatResponse
{
    class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            OpenFileDialog dlg = new OpenFileDialog();
            if(dlg.ShowDialog() != DialogResult.OK){return;}
            string json = System.IO.File.ReadAllText(dlg.FileName);

            var root = JObject.Parse(json);
            var categories = root["response"]["categories"];
            var firstCategory = categories[0];
            Console.WriteLine("id: {0}", firstCategory["id"]);
            Console.WriteLine("name: {0}", firstCategory["name"]);
            Console.WriteLine("pluralName: {0}", firstCategory["pluralName"]);
            Console.WriteLine("shortName: {0}", firstCategory["shortName"]);
            var icon = firstCategory["icon"];
            Console.WriteLine("icon.prefix: {0}", icon["prefix"]);
            Console.WriteLine("icon.sizes[0]: {0}", icon["sizes"][0]);
            Console.WriteLine("icon.name: {0}", icon["name"]);

            Console.ReadKey();
        }
    }
}

Also I'm a little confused by your json sample; I think you may have overlaid part of your sample or cut something out as you have categories nested in categories. If there is indeed a 2nd level categories inside your categories element and that's what you want, you can access it with this:

var categories2 = root["response"]["categories"][0]["categories"][0];
Console.WriteLine("inner categories id: {0}", categories2["id"]);

Here is the json source I used to test, copied from yours but with closing } and ] marks where needed to make it parse.

{
    "meta": {
        "code": 200
    },
    "response": {
        "categories": [{
            "id": "4d4b7104d754a06370d81259",
            "name": "Arts & Entertainment",
            "pluralName": "Arts & Entertainment",
            "shortName": "Arts & Entertainment",
            "icon": {
                "prefix": "https:\/\/foursquare.com\/img\/categories\/arts_entertainment\/default_",
                "sizes": [32, 44, 64, 88, 256],
                "name": ".png"
            },
            "categories": [{
                "id": "4bf58dd8d48988d1e1931735"
                }]
            }]
    }
}

The byte array arguments to Socket.IOControl() are specific to the IOControlCode that is specified as the first argument.

The first array is for input data, the second array is for output data.

To find more information about the specific layout for these arrays, it is helpful to start by looking at the enumeration, which lists all the possible operations for you. From there, you should cross reference with the documentation listed for the C-operable functions that Socket.IOControl() wraps. These are WSAIoctl() and ioctlsocket().

IOControlCode Enumeration @ MSDN

WSAIoctl() function @ MSDN
ioctlsocket() function @ MSDN

Per the documentation for IOControlCode.ReceiveAll:

Enable receiving all IPv4 packets on the network. The socket must have address family InterNetwork, the socket type must be Raw, and the protocol type must be IP. The current user must belong to the Administrators group on the local computer, and the socket must be bound to a specific port. This control code is supported on Windows 2000 and later operating systems. This value is equal to the Winsock 2 SIO_RCVALL constant.

Cross referencing SIO_RCVALL, we find it has an entry in the winsock documentation.

SIO_RCVALL control code @ MSDN

Reading through this entry, it mentions that the input buffer is required to select a mode of operation, with minimum size corresponding to a RCVALL_VALUE. In your statement you are passing the value 1 in the input argument array. We can check header files to see what this should mean.

You should double check this with C header files at hand, but the interface-compatible copy for wine (windows emulator) says the value for mode RCVALL_ON is 1. The .NET method should wrap the details of managing array size for you, so the code snippet you encountered is trying to enable RCVALL_ON for the socket.

Here is the link to the C header file at winehq.org: mstcpip.h at winehq.org

If you've installed C/C++ support for visual studio, you may be able to locate mstcpip.h and winsock2.h locally at a path similar to the following:

C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Include\

My copy says:

//
// Values for use with SIO_RCVALL* options
//
typedef enum {
    RCVALL_OFF             = 0,
    RCVALL_ON              = 1,
    RCVALL_SOCKETLEVELONLY = 2,
    RCVALL_IPLEVEL         = 3,
} RCVALL_VALUE, *PRCVALL_VALUE;

I couldn't find any documentation that specifically says what size byte array should be used to pass a RCVALL_VALUE, but if you look at the the samples for IOControl(), they use BitConverter.GetBytes(0) for default parameters which would have a size of 4 bytes (corresponding to a .NET int) and matches your example. This is large enough to fit a RCVALL_VALUE in C operation as well.