C++ Declaring A Static Type

In header

class Xxx {
...
  static sometype dict_;
...

In source:

sometype Xxx::dict_;

Windows Message Queues Important Notes

About Messages and Message Queues
PeekMessage
Win32 Message Processing Primer
See also this post on this blog

PostMessage => Asynchronous, message goes into the message queue
SendMessage => Synchronous, message is sent to WinProc immediately and processed immediately.
Note: WM_PAINT, WM_TIMER, WM_QUIT handled differently when posted. They are only processed when there are no other messages in the queue. Multiple WM_PAINT messages for the same window are combined consolidating all invalid parts of the client area into a single area.
GetMessage() - Does not return until message matching the filter criteria is found. Removes message from queue

while (GetMessage (&msg, NULL, 0, 0))
{
  TranslateMessage (&msg) ;
  DispatchMessage (&msg) ;
}

PeekMessage() - Looks for message matching the filter criteria. Returns immediately. Whether the matching message is removed from the queue or not is determined by the last parameter of the method

do
{
  if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
  {
    TranslateMessage (&msg) ;
    DispatchMessage (&msg) ;
  }
} while (msg.message != WM_QUIT);

Neither GetMessage or PeekMessage will remove WM_PAINT messages unless the update area of the message is null!
 

Simple Pie Chart using WPF Toolkit

Here is more detail
Also look at WPF Toolkit Tutorial – Part 1

A simple pie chart example in that there only 2 wedges in the pie chart!
Add a reference to the WPFToolkit data visualisation assembly ("...\Program Files\WPF Toolkit\v3.5.50211.1\System.Windows.Controls.DataVisualization.Toolkit.dll")

Add following xaml to the window where the pie chart will be placed:

<Window ...
  <!-- First define the namespace for charting -->
  xmlns:charting="clr-namespace:
  System.Windows.Controls.DataVisualization.Charting;
  assembly=System.Windows.Controls.DataVisualization.Toolkit"

  <charting:Chart Name="pieChart">
    <charting:PieSeries ItemsSource="{Binding}" 
      IndependentValueBinding="{Binding Path=Description}"
   DependentValueBinding="{Binding Path=Percentage}"
    />
  </charting:Chart>

Set the Pie chart wedges

void AssignPieChartWedges()
{
    System.IO.DriveInfo cdrive = new System.IO.DriveInfo("C");
    double availPercentage = Math.Round(100.0d * 
        (double)cdrive.TotalFreeSpace / (double)cdrive.TotalSize);

    List<DrivePercentage> dpList = new List<DrivePercentage>();
    dpList.Add(new DrivePercentage() 
    { Percentage=availPercentage, Description="Free" });
    dpList.Add(new DrivePercentage() 
    { Percentage=100.0d-availPercentage, Description="Used" });
    pieChart.DataContext = dpList;
}

IsDrivefree

A simple helper to check if a specified drive letter is free for use:

public static class DriveInfoExtender
{
    public static bool IsDriveFree(string drive)
    {
        if (string.IsNullOrEmpty(drive) || !char.IsLetter(drive[0]))
            return false;
        if (drive.Length >= 2)
            drive = drive.Substring(0,1).ToUpper();
        bool isFree = true;
        DriveInfo[] nonFreeDrives = System.IO.DriveInfo.GetDrives();
        foreach (DriveInfo di in nonFreeDrives)
        {
            if (di.Name.StartsWith(drive))
            {
                isFree = false;
                break;
            }
        }
        return isFree;
    }
}

AssemblyVersion and AssemblyFileVersion

See here
and here

• AssemblyVersion is .NET version info whilst 'AssemblyFileVersion' is Windows version number, ie., what you see when you do view the file properties of an assembly in windows explorer. AssemblyVersion defines the version other assemblies are compiled against in their manifest.
• If 'AssemblyFileVersion' attribute is not present in 'AssemblyInfo.cs' then AssemblyFileVesrion takes the same value as AssemblyVersion.

Proxy, Decorator, Adapter, Bridge and Facade Patterns

Found the following explanantion here. It is a useful description of the differences between these patterns as they are very similar.

Proxy, Decorator, Adapter, and Bridge are all variations on "wrapping" a class. But their uses are different:

• Proxy could be used when you want to lazy-instantiate an object, or hide the fact that you're calling a remote service, or control access to the object.
• Decorator is also called "Smart Proxy." This is used when you want to add functionality to an object, but not by extending that object's type. This allows you to do so at runtime.
• Adapter is used when you have an abstract interface, and you want to map that interface to another object which has similar functional role, but a different interface.
• Bridge is very similar to Adapter, but we call it Bridge when you define both the abstract interface and the underlying implementation. I.e. you're not adapting to some legacy or third-party code, you're the designer of all the code but you need to be able to swap out different implementations.
• Facade is a higher-level (read: simpler) interface to a subsystem of one or more classes. Think of Facade as a sort of container for other objects, as opposed to simply a wrapper.

Deleting a Read-Only File

See also the FileAttributesExtender class
and the PathCombine class

string fullPath = PathCombine(pathRoot, relativePath);
if (File.Exists(fullPath))
{
    FileAttributes fas = File.GetAttributes(fullPath);
    if (fas.Contains(FileAttributes.ReadOnly))
        File.SetAttributes(fullPath, FileAttributes.Normal);
    File.Delete(fullPath);
}