Calvin Hsia's WebLog

Be careful about nothing in managed code

CalvinH — Mon, 30 Jan 2012 22:12:26 GMT

Here’s a pattern of code use I’ve seen in a few places. There’s a function DeserializeList that returns an array of various sizes, depending on the input. This code can be called to deserialize (rehydrate) an object from a stream. For example,...(read more)

Advanced debugging: change your program execution without Edit and Continue

CalvinH — Tue, 20 Dec 2011 20:34:00 GMT

Last time ( Improve your managed debugging skills: examining registers and memory ) we examined some debugging techniques to understand the behavior of managed code. It might take a long time or many manual steps to reproduce a particular software...(read more)

Improve your managed debugging skills: examining registers and memory

CalvinH — Tue, 29 Nov 2011 21:33:51 GMT

I was helping a colleague and we were deep in the middle of a debug session, single stepping some code and we wanted to see a value in the debugger. The debugger showed either nothing, because the intermediate value has been optimized out, or a...(read more)

More fun with the Fast Fourier Transform

CalvinH — Tue, 01 Nov 2011 00:05:25 GMT

The sounds that we hear can be recorded via a microphone and can be graphed as a signal of amplitude versus time. Low notes show as a lower frequency wave, and high notes show as higher frequency waves. Over the past few decades, some music players, like...(read more)

Using and styling a treeview in WPF

CalvinH — Tue, 27 Sep 2011 18:17:43 GMT

As you know, a treeview control is very useful for viewing hierarchical information. Each node in a tree can have its own parent/child relationships. Some of these trees can be extremely large, and can thus be prohibitively expensive to...(read more)

Automatic tests protect your code

CalvinH — Wed, 31 Aug 2011 19:18:47 GMT

Last month in Dynamically create huge tooltips in WPF TreeView and ListView I showed some code that creates large tooltips to present lots of data. Today, we’ll talk about creating automatic tests for this feature. Testing...(read more)

Dynamically create huge tooltips in WPF TreeView and ListView

CalvinH — Fri, 29 Jul 2011 22:01:47 GMT

Tooltips are useful. When the mouse hovers over a button a tip can indicate what happens when it’s clicked. The mouse move does not actually invoke the button, but can give information in a passive way. Sometimes I want to make huge tooltips...(read more)

Returning data from a recursive method

CalvinH — Fri, 01 Jul 2011 01:01:00 GMT

Sometimes you need to write a method that requires recursion to be elegant. Often that method needs to accumulate data between recursion levels There are many ways to do so, and some are more elegant than others. I like the Optional Parameter method...(read more)

Embed a ListView inside another ListView for one to many relationships

CalvinH — Wed, 01 Jun 2011 01:39:23 GMT

In the old days (about 16 years ago), FoxPro’s object, containership and inheritance models made it easy to put objects inside other objects. So, for example, a FoxPro grid of Customers could have a column containing a grid of each customer’s orders,...(read more)

Use colors in WPF to show virtual memory fragmentation

CalvinH — Sat, 30 Apr 2011 00:51:47 GMT

In this post What is your computer doing with all that memory? Write your own memory browser is sample code that shows how to create a WPF grid view of a memory map of a process. You can click on a column header to sort, and you can see the various loaded images and even a binary display of the actual memory.

We can modify that code to show the data in color very easily, using the magic of Data Binding.

Paste the code from the prior post’s sample into a new VB WPF Application. You might have to change the class name from “Window1” to “MainWindow”

Hit Ctrl-F5 to run it, dbl click on a process to show the memory map of that process.

Now let’s add some color: we add a few lines of code in 2 segments: a class that implements IValueConverter, and some code to modify the Style of the items contained in the ListView

Paste this class at the end of the file:

Public Class VMBgd

Implements IValueConverter

Public Function Convert(

ByVal value As Object,

ByVal targetType As System.Type,

ByVal parameter As Object,

ByVal culture As System.Globalization.CultureInfo

) As Object Implements System.Windows.Data.IValueConverter.Convert

Dim bgColor = Brushes.White

Dim lvitem = CType(value, ListViewItem)

Dim memType = CStr(ComponentModel.TypeDescriptor.

GetProperties(lvitem.DataContext)("Type").

GetValue(lvitem.DataContext)) ' get the value of the "Type" column

Select Case memType

Case "MEM_IMAGE"

bgColor = Brushes.Violet

Case "MEM_PRIVATE"

bgColor = Brushes.Yellow

Case "MEM_MAPPED"

bgColor = Brushes.PaleTurquoise

End Select

Return bgColor

End Function

Public Function ConvertBack(

ByVal value As Object,

ByVal targetType As System.Type,

ByVal parameter As Object,

ByVal culture As System.Globalization.CultureInfo

) As Object Implements System.Windows.Data.IValueConverter.ConvertBack

Throw New NotImplementedException

End Function

End Class

And around line 160, find the “dp.Children.Add(New Browse” line and replace with this code:

'dp.Children.Add(New Browse(q, _

' delMouseMove:=AddressOf On_VirtmemMouseMove, _

' deldblclick:=AddressOf On_VirtmemDblClick))

Dim brow = New Browse(q, _

delMouseMove:=AddressOf On_VirtmemMouseMove, _

deldblclick:=AddressOf On_VirtmemDblClick)

Dim bgStyle = New Windows.Style(

GetType(ListViewItem)

) ' style for a ListViewItem

Dim binder = New Binding With {

.Converter = New VMBgd,

.RelativeSource = New RelativeSource(RelativeSourceMode.Self),

.Mode = BindingMode.OneTime

} ' Bind our color converter

Dim bgSetter = New Setter(ListViewItem.BackgroundProperty, Brushes.White) With {

.Value = binder

} ' BG bound to our binder

bgStyle.Setters.Add(bgSetter)

bgStyle.Setters.Add(

New Setter(

ListViewItem.MarginProperty,

New Thickness(0))

) ' space between rows

bgStyle.Setters.Add(

New Setter(

ListViewItem.BorderThicknessProperty,

New Thickness(0))

) ' space between rows

brow.ItemContainerStyle = bgStyle

dp.Children.Add(brow)

Now run it, select a process and see the colors! Click on BaseAddress to sort and browse around to groups of the Violet colored images and see how many of them are separated by a white Free region. If this region is less than 64k (0x10000), then that Virtual Memory address range fragment is unusable.

The pasted class VMBgd has the ability to return a color given an object. The TypeDescriptor class is used to get the properties of the ListView’s DataContext, which are the columns of the view. GetProperties returns a collection of PropertyDescriptors, and we want the Value of “Type” (which is the column indicating Memory Allocation Type from the Linq query (around line 156)) member.

An instance of the class is bound to the ListViewItem background color via a Setter in the Windows.Style for the ListView.ItemContainerStyle. When rendering the data, when the Background property is accessed, and it’s bound to our Converter which returns the desired color.

As an exercise, make these unusable regions a different color.

The cost of using nothing

CalvinH — Tue, 29 Mar 2011 01:14:22 GMT

What is the cost of using nothing? Seems like a silly question.

Suppose you see code like this:

void * MyClass::DoSomething()

{

int size = sizeof(MyThing) * m_NumItems;

var ptr = malloc(size);

return ptr;
}

It’s a method that allocates space for m_NumItems MyThings. This is a real code pattern that exists in a lot of code bases.

Suppose, however, that the m_NumItems is 0. What will this code do?

If the caller of the code does something like this:

void MyClass::CallDoSomething()

{

var ptr = DoSomething();

for (int i = 0 ; i < m_NumItems)

{

ptr[i] = …..;

}

then the code will not dereference the null block of memory, and thus seem to behave properly.

However, try the code sample below.

Start Visual Studio. File->New->Project->C# WPF Application.

Dbl-click the MainWindow.Xaml to get to the code behind and replace with the sample below.

The code calls HeapAlloc (which is what malloc does under the hood) to allocate a block of memory with a size of 0 bytes. It then prints out the address of memory returned in the debug window.

A sample of the output:

0b0d07d0

0b0d07e0

0b0d07f0

0b0d0800

0b0d0810

0b0d0820

0b0d0830

Notice that each subsequent call is 16 bytes beyond the prior on my 64 bit Windows 7. This is the overhead of allocating zero bytes.

What do you expect happens when you change the sizeToAlloc to 1? The answer will surprise you.

Not only is there overhead in allocating 0 bytes, but fragmentation too: as a heap grows with a pattern of allocates and frees, the resulting fragmentation can be crippling.

Heaps typically can coalesce adjacent free blocks, but that’s about the extent of their attempt to alleviate the defragmentation.

Defragmenting a hard disk consists of moving blocks of data around and updating the pointers (directories) to that data.

Defragmenting managed objects occurs via a Garbage Collection: the memory is moved around and pointers (objects that reference other objects) are updated.

Defragmenting a native heap is pretty much impossible: once the heap gives out a pointer to the block of memory, that memory cannot be moved.

Some memory schemes have tried to allow defragmenting in various ways, such as using a Handle to memory, and using a simple fast function that Dereferences that pointer to get the real address of the memory.

FoxPro 2.6, which allowed the same user code to run on Unix, Mac, DOS, and Windows, uses such a handle dereferencing scheme.

Older versions of Windows also used handles: see the legacy functions GlobalAlloc, LocaAlloc, which require you to dereference the returned handle via GlobalLock

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.Runtime.InteropServices;

namespace WpfApplication1

{

/// <summary>

/// Interaction logic for MainWindow.xaml

/// </summary>

public partial class MainWindow : Window

{

public MainWindow()

{

InitializeComponent();

}

private IntPtr _hpHandle;

private void Window_Loaded(object sender, RoutedEventArgs e)

{

var wordsize = IntPtr.Size;

if (wordsize != 4)

{

//are we in 32 or 64 bit land? doesn't matter!

}

_hpHandle = Heap.HeapCreate(0, 0, 0);

var nIter = 100;

IntPtr[] ptrs = new IntPtr[100];

uint sizeToAlloc = 0;

for (int i = 0; i < nIter; i++)

{

var ptr = Heap.HeapAlloc(_hpHandle, 0, sizeToAlloc);

System.Diagnostics.Trace.WriteLine(string.Format("{0:x8}", ptr.ToInt32()));

ptrs[i] = ptr;

}

for (int i = 0; i < nIter; i++)

{

var res = Heap.HeapFree(_hpHandle, 0, ptrs[i]);

if (res != true)

{

System.Diagnostics.Trace.WriteLine("Free failed");

}

Heap.HeapDestroy(_hpHandle);

}

public class Heap

{

[DllImport("kernel32.dll", SetLastError = true)]

public static extern IntPtr HeapCreate(uint flOptions, uint dwInitialsize, uint dwMaximumSize);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern IntPtr HeapAlloc(IntPtr hHeap, uint dwFlags, uint dwSize);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern bool HeapFree(IntPtr hHeap, uint dwFlags, IntPtr lpMem);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern bool HeapDestroy(IntPtr hHeap);

}

</Sample>

See and hear the effects of Garbage Collection

CalvinH — Sun, 27 Feb 2011 02:00:39 GMT

Sometimes you forget that GC’s occur: it’s hard to see it’s effect, but what does Garbage Collection do to your code?

A long time ago (3 decades!) I used Fortran and Assembly code for a PDP-11 16 bit computer to design real time signal processing systems. Two of these were used to detect submarines: one would make a very loud noise (think a very big sonar Ping), and the other would pretend to be a submarine by listening to the sound and echoing back, at various set strengths (1X, 10X, 100X), as if it were a particular kind of submarine pointing in various directions. “I’m a Submarine”, “I’m a Submarine” “I’M A SUBMARINE”. If all 3 of these echoes were heard, then we know we heard all signal strengths. If only 2,then we know by how much the target was missed.

The sound maker generated a huge amount of noise underwater via controlling precisely the release of an array of high pressure air guns. The sound wavefront could be steered via subtle variations in firing timing. Sound travels so well and fast underwater!

A typical scuba tank is about 8 inches in diameter and 20 inches long, holding maybe 3000 PSI and is very dangerous (think exploding shark a la Jaws). Our array of 10 air guns were 10 inches in diameter and 20 feet long, with 10,000 PSI.

The listener computer on a different boat hundreds of miles away used an underwater microphone to record the sounds into memory at a sub 1Khz sampling rate using an Analog to Digital converter. The code received the data via DMA (Direct Memory Access) and double-buffered it: as one buffer was being filled, the other would be processed, such as copied to an Array Processor to do a Fourier Transform.

The signal would then be convolved (multiplications, additions) with various prerecorded echoes from a submarine, and then the signal was D-A converted to a sound blasted via an underwater speaker.

The CPU needed to be fast enough to keep up with the incoming raw data: if I tuned it to sample a little bit faster, bad things would occur: missing data, distortion, etc.

I had to have precise control of these real time systems for accuracy and reliability.

Designing a real-time system with a Garbage Collected system could be quite difficult in tight performance scenarios. A GC during a sampling could cause lost data.

What does a GC actually do? Every thread that runs managed code has to be frozen during the entire GC, which means your application pauses. All objects are scanned to see if they are referenced by any other objects. Lonely objects are considered freeable: objects are moved around in memory to coalesce free space, and object references are updated with the new locations.

So how can you see or hear the effect of GC?

Start Visual Studio

File->New->Project->C# WPF Application. Name it SeeHearGC

Replace the MainWindow.Xaml.CS with the contents below.

If you run under the debugger (F5), then Uncheck this option: Project->Properties->Debug->Enable the Visual Studio Hosting Process

Click with right button for just sounds, or left mouse for color display.

The code alternately raster scans the form, painting pink squares. Then it repeats with blue. When a GC occurs, the color for that square is inverted. A Beep can be heard at the end of each horizontal scan. If a GC occurs, the square color is inverted, so you can see when it occurred.

You can also run PerfMon (start->Run->PerfMon) to see the GC behavior of any managed application, even when the program is running,

Select Performance Monitor in the Treeview, delete any counters in the display (Hit the red x), then hit the green “+” to add a couple counters.

Choose <Local computer> , scroll to and expand .NET CLR Memory, and choose “#Gen 0 Collections” and “% Time in GC”. In the Instance listbox, choose the process: SeeHearGC.

Originally I wanted to control the speaker directly because human hearing can detect subtle differences in timing. However, I had to settle on Beeps.

Perhaps in a later post, I’ll write out to a WAV file or otherwise record the GC data for further analysis.

Heartbeat: Garbage collection in VFP and .NET are similar

<Code>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.ComponentModel;

using System.Windows.Threading;

using System.Runtime.InteropServices;

using System.Diagnostics;

using System.Reflection;

namespace WpfApplication1

{

/// <summary>

/// Interaction logic for MainWindow.xaml

/// </summary>

public partial class MainWindow : Window

{

public const int xCnt = 5;

public const int yCnt = 10;

public const int xSize = 19;

public const int ySize = 19;

TextBlock[,] _btns = new TextBlock[xCnt, yCnt];

[DllImport("kernel32.dll")]

public static extern bool Beep(int BeepFreq, int BeepDuration);

PerformanceCounter _perfCounterGC;

int _nGCs = 0;

public MainWindow()

{

InitializeComponent();

// Uncheck this option: Project->Properties->Debug->Enable the Visual Studio Hosting Process

var thisAsm = System.IO.Path.GetFileNameWithoutExtension( Assembly.GetEntryAssembly().Location);

_perfCounterGC = new PerformanceCounter(".NET CLR Memory", "# Gen 0 Collections", thisAsm);

SolidColorBrush[] brushes = new SolidColorBrush[2];

brushes[0] = new SolidColorBrush(Colors.LightSalmon);

brushes[1] = new SolidColorBrush(Colors.LightBlue);

this.Title = "Click on the Red";

int i, x, y;

this.Loaded += (o, e) =>

{

var surface = new Canvas();

this.Content = surface;

for (y = 0; y < yCnt; y++)

{

for (x = 0; x < xCnt; x++)

{

var rect = new TextBlock()

{

Background = brushes[0],

HorizontalAlignment = System.Windows.HorizontalAlignment.Left,

VerticalAlignment = System.Windows.VerticalAlignment.Top,

Width = xSize,

Height = ySize

};

_btns[x, y] = rect;

surface.Children.Add(rect);

Canvas.SetLeft(rect, x * xSize);

Canvas.SetTop(rect, y * ySize);

}

int currentMainColor = 0;

this.MouseDown += (om, em) =>

{

bool fDoVisual = true;

if (Mouse.RightButton == MouseButtonState.Pressed)

{

fDoVisual = false;

}

var txt1 = "1";

var txtToUse = string.Empty;

int colorToUse = 0;

int curGCs = 0;

// main loop: we want to minimize memory allocations

for (i = 0; i < 5; i++)

{

if (fDoVisual)

{

currentMainColor = 1 - currentMainColor;

}

for (y = 0; y < yCnt; y++)

{

Beep(440, 160);

if (fDoVisual)

{

for (x = 0; x < xCnt; x++)

{

curGCs = (int)_perfCounterGC.NextValue();

colorToUse = currentMainColor;

if (curGCs != _nGCs)

{

txtToUse = txt1; // (curGCs - _nGCs).ToString();

_nGCs = curGCs;

colorToUse = 1 - colorToUse;

}

else

{

txtToUse = string.Empty;

}

_btns[x, y].Text = txtToUse;

_btns[x, y].Background = brushes[colorToUse];

{ // we want to wait til after render by synchronously running low pri empty code

this.Dispatcher.Invoke(DispatcherPriority.Render, new Action(() =>

{

}

));

}

else

{

System.Threading.Thread.Sleep(100);

}

};

}

</Code>

Are you running out of disk space? Treemap your files to see what's eating the most

CalvinH — Thu, 27 Jan 2011 03:13:30 GMT

I was running out of disk space and wanted to see what was eating the most.

About 6 years ago I wrote a FoxPro version of a TreeMap program that shows a rectangle subdivided into various subrectangles, each proportional to the amount of space taken by files on disk.

The old program had some limitations, like being able to handle Junction points which are more common these days.

Start Visual Studio 2010.

File->New->Project->C#->WPF Application. Call it TreeMap.

Add a reference to System.Windows.Forms for the FolderBrowser dialog, and System.Data.Entities.

Notice that I’m using the Browse class from my last post. I changed the MaxWidth in the MyValueConverter class and the type of Path to fully qualified System.Windows.Shapes.Path.

Because many folders start with the same name, the code adds a trailing “\” to each data entry.

C:\Program Files\Microsoft Office

C:\Program Files\Microsoft Studio

If the folder files (as opposed to only subfolders) then a “*\” is added.

The data is gathered on a background thread, which updates a temporary TextBlock to indicate status. This makes the window responsive and indicates to the user that progress is occurring.

Some folders are really Junction points (or ReparsePoints).

For example, I saw a huge amount of data in C:\Users\All Users\Microsoft Visual Studio\10.0\TraceDebugging

And an identical huge amount in

C:\ProgramData\Microsoft Visual Studio\10.0\TraceDebugging

Notice how the MapDataItem doesn’t include the path. A common programming inefficiency is to use a long key for a dictionary and include the same key in the value. That means the long key will be stored twice, using twice as much memory.

Larger rectangles will be covered by smaller ones, so the text description might be obscured, leading to rectangles that seem to have no text, but the tooltip will be correct.

What is taking up the space on your hard disk? TreeMap it!

Remove double spaces from pasted code samples in blog

Write your own Linq query viewer

<code>

using System;

using System.Collections;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data.Objects.DataClasses;

using System.IO;

using System.Linq;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Threading;

namespace TreeMap

{

public partial class MainWindow : Window, System.Windows.Forms.IWin32Window

{

public static char PathSep = System.IO.Path.DirectorySeparatorChar;

public static string DataSuffix = "*" + PathSep; // a node whose size consists of files in the node (excluding children)

public TextBlock _txtStatus;

public string _rootPath = @"C:\Program Files";

public Rect _rootRect;

public long _rootSize;

public Dictionary<string, MapDataItem> _DataDict = new Dictionary<string, MapDataItem>();

public MainWindow()

{

InitializeComponent();

this.WindowState = WindowState.Maximized;

_txtStatus = new TextBlock();

this.Content = _txtStatus;

this.Loaded += (object o, RoutedEventArgs e) =>

{ // run this after the window has been initialized:

var fldrDialog = new System.Windows.Forms.FolderBrowserDialog();

fldrDialog.Description = @"Choose a root folder. A small subtree will be faster, like c:\Program Files";

fldrDialog.SelectedPath = _rootPath;

if (fldrDialog.ShowDialog(this) != System.Windows.Forms.DialogResult.OK)

{

Application.Current.Shutdown();

}

_rootPath = fldrDialog.SelectedPath;

if (!_rootPath.EndsWith(MainWindow.PathSep.ToString()))

{

_rootPath += PathSep;// need a trailing backslash to distinguish dir name matches

}

var bgdWorkerThread = new BackgroundWorker(); // create thread to read disk

bgdWorkerThread.DoWork += (object sender, DoWorkEventArgs args) =>

{

_rootSize = FillDictionary(_rootPath);

};

bgdWorkerThread.RunWorkerCompleted += (object sender, RunWorkerCompletedEventArgs args) =>

{

var totNumFiles = _DataDict.Values.Sum(x => x.NumFiles);

this.Title = string.Format("{0} Size = {1:n0} # Files={2:n0} # Items = {3:n0}", _rootPath, _rootSize, totNumFiles, _DataDict.Count()); ;

_rootRect = new Rect(0, 0,

this.ActualWidth,

this.ActualHeight);

this.Content = new TreeMap(this, _rootPath, _rootSize);

};

bgdWorkerThread.RunWorkerAsync();

};

}

public class MapDataItem

{

public int Depth; // # of "\" in path

public long Size; // # of bytes

public int NumFiles; //# of files in curdir only

public int Index; // the order in which the item was encountered

public Rect rect;

public override string ToString()

{

return string.Format("Depth = {0} Size = {1:n0}, NumFiles = {2:n0} Index = {3:n0}", Depth, Size, NumFiles, Index);

}

public long FillDictionary(string cPath) // includes trailing "\"

{ // runs on background thread

long totalSize = 0;

long curdirFileSize = 0;

long curdirFolderSize = 0;

try

{

if (_DataDict.Count() % 100 == 0)

{ // upgrade status on foreground thread

_txtStatus.Dispatcher.BeginInvoke(

DispatcherPriority.Normal,

new Action<TextBlock>(otxtblk =>

{

otxtblk.Text = cPath; // update status

}

_txtStatus);

}

var dirInfo = new DirectoryInfo(cPath);

if ((dirInfo.Attributes & FileAttributes.ReparsePoint) != 0)

{ // some folders are not really there: they're redirect junction points.

return 0;

}

var nDepth = cPath.Where(c => c == PathSep).Count();

var curDirFiles = Directory.GetFiles(cPath);

if (curDirFiles.Length > 0) // if cur folder contains any files (not dirs)

{

foreach (var file in curDirFiles)

{

var finfo = new FileInfo(file);

curdirFileSize += finfo.Length;

}

_DataDict.Add(cPath + DataSuffix, // size of files in cur folder, excluding children

new MapDataItem() {

Depth = nDepth + 1,

Size = curdirFileSize,

NumFiles = curDirFiles.Length,

Index = _DataDict.Count

});

}

var curDirFolders = Directory.GetDirectories(cPath); // now any subfolders

if (curDirFolders.Length > 0)

{

foreach (var dir in curDirFolders)

{

curdirFolderSize += FillDictionary(System.IO.Path.Combine(cPath, dir) + PathSep); // recur

}

totalSize += curdirFileSize + curdirFolderSize;

_DataDict.Add(cPath, new MapDataItem() { Depth = nDepth, Size = curdirFileSize + curdirFolderSize, Index = _DataDict.Count });

}

catch (Exception ex)

{

if (ex is UnauthorizedAccessException)

{

System.Diagnostics.Trace.WriteLine("Ex: " + ex.Message);

}

else

{

throw;

}

return totalSize;

}

public class TreeMap : Canvas

{

internal MainWindow _mainWindow;

internal string _rootPath; // root for this canvas

internal long _rootSize; // size for this root

public int _EvenOdd = 0; // even or odd determines horiz or vert first

public TreeMap(MainWindow mainWindow, string rootPath, long rootSize)

{

_mainWindow = mainWindow;

_rootPath = rootPath;

_rootSize = rootSize;

MakeTreeMap(_rootPath, mainWindow._rootRect, rootSize);

}

public void MakeTreeMap(string parentPath, Rect parentRect, long parentTotalSize)

{

var nCurDepth = parentPath.Where(c => c == MainWindow.PathSep).Count(); // count the # of "\"

var querySubDirs = from subPath in _mainWindow._DataDict.Keys

where subPath.StartsWith(parentPath)

&& _mainWindow._DataDict[subPath].Depth == nCurDepth + 1 // we want those 1 level deeper

orderby _mainWindow._DataDict[subPath].Size descending

select subPath;

long nRunTot = 0;

foreach (var subDir in querySubDirs)

{

var curSize = _mainWindow._DataDict[subDir].Size;

Rect newRectStruct;

if (nCurDepth % 2 == _EvenOdd) // even or odd?

{

newRectStruct = new Rect(

parentRect.Left + parentRect.Width * nRunTot / parentTotalSize,

parentRect.Top,

parentRect.Width * curSize / parentTotalSize,

parentRect.Height

);

}

else

{

newRectStruct = new Rect(

parentRect.Left,

parentRect.Top + parentRect.Height * nRunTot / parentTotalSize,

parentRect.Width,

parentRect.Height * curSize / parentTotalSize

);

}

nRunTot += curSize;

var data = _mainWindow._DataDict[subDir];

var rectMapItem = new TreeMapItem(

subDir,

string.Format("{0} Files ={1:n0} Size ={2:n0} Index = {3:n0} ({4:n0},{5:n0})",

subDir, data.NumFiles, curSize, data.Index, newRectStruct.Width, newRectStruct.Height),

newRectStruct,

nCurDepth,

this

);

this.Children.Add(rectMapItem);

if (newRectStruct.Width > 5 && newRectStruct.Height > 5)

{ // if it's big enough to drill down, figure out the next level down.

var newq = from k in _mainWindow._DataDict.Keys

where k.StartsWith(subDir) && k.LastIndexOf("*") < 0

&& _mainWindow._DataDict[k].Depth >= nCurDepth + 1

orderby _mainWindow._DataDict[k].Size descending

select k;

var newParent = newq.FirstOrDefault();

if (!string.IsNullOrEmpty(newParent))

{

MakeTreeMap(newParent, newRectStruct, curSize); //recur

}

internal class TreeMapItem : TextBlock

{

internal static uint curColor = 0xffffff;

internal TreeMap _treeMap;

public TreeMapItem(string subDir, string toolTip, Rect newRectStruct, int nDepth, TreeMap treeMap)

{

_treeMap = treeMap;

var newColor = Color.FromArgb(

(byte)(0xff) , //opaque

(byte)(curColor & 0xff), //red

(byte)((curColor >> 4) & 0xff),//green

(byte)((curColor >> 8) & 0xff) //blue

);

curColor -= 100; // change the color some way

Background = new SolidColorBrush(newColor);

HorizontalAlignment = System.Windows.HorizontalAlignment.Left;

VerticalAlignment = System.Windows.VerticalAlignment.Top;

if (newRectStruct.Height > newRectStruct.Width)

{ // let's rotate the text for tall skinny rects

var trans = new RotateTransform(-90);

this.LayoutTransform = trans;

Height = newRectStruct.Width;

Width = newRectStruct.Height;

}

else

{

Height = newRectStruct.Height;

Width = newRectStruct.Width;

}

treeMap._mainWindow._DataDict[subDir].rect = newRectStruct;

Canvas.SetTop(this, newRectStruct.Top);

Canvas.SetLeft(this, newRectStruct.Left);

Text = subDir;

ToolTip = toolTip;

this.ContextMenu = _ContextMenu; // all share the same menu

}

public override string ToString()

{

return string.Format("({0}) {1}",_treeMap._mainWindow._DataDict[Text].rect, Text);

}

private static ContextMenu __ContextMenu;

public static ContextMenu _ContextMenu

{

get

{

if (__ContextMenu == null)

{ // create the menu only once

__ContextMenu = new ContextMenu();

RoutedEventHandler menuItemHandler = (object o, RoutedEventArgs e) =>

{

var curMapItem = _ContextMenu.PlacementTarget as TreeMapItem;

var subDir = curMapItem.Text;

var treeMap = GetAncestor<TreeMap>(curMapItem);

var curWin = GetAncestor<Window>(treeMap);

curWin.Cursor = Cursors.Wait;// hourglass

bool fResetCursorDelay = true; // do we wait til rendering is done to turn off hourglass?

e.Handled = true;

try

{

switch (((MenuItem)o).Header.ToString())

{

case "_Explorer":

var ndx = subDir.IndexOf("*");

if (ndx > 0)

{

subDir = subDir.Substring(0, ndx - 1);

}

System.Diagnostics.Process.Start(subDir);

break;

case "_SubTreeMap":

{

var winMain = treeMap._mainWindow;

var newWin = new Window();

newWin.WindowState = WindowState.Maximized;

newWin.Height = winMain.ActualHeight;

newWin.Width = winMain.ActualWidth;

var winRect = winMain._rootRect;

var newDepth = curMapItem._treeMap._rootPath.Where(c => c == PathSep).Count() + 1;

var newPath = curMapItem.Text;

// this is drilled in many levels: we only want to drill in 1

var split = newPath.Split(new[] { PathSep }); // create an array of path pieces

if (newDepth <= split.Length)

{

var joinedPath = String.Join(PathSep.ToString(), split, 0, newDepth) +

PathSep;

var newSize = curMapItem._treeMap._mainWindow._DataDict[joinedPath].Size;

newWin.Title = string.Format("{0} {1:n0}", joinedPath, newSize);

newWin.Content = new TreeMap(winMain, joinedPath, newSize);

newWin.Show();

}

break;

case "_New TreeMap Root":

{

var newRootWin = new MainWindow();

newRootWin._rootPath = treeMap._rootPath; // use same root path as initial default

newRootWin.Show();

}

break;

case "_Flip Horizontal/Vertical":

treeMap._EvenOdd = 1 - treeMap._EvenOdd;

goto case "_ReColor";

case "_ReColor":

treeMap.Children.Clear();

treeMap.MakeTreeMap(treeMap._rootPath, treeMap._mainWindow._rootRect, treeMap._rootSize);

break;

case "_Browse Data":

{

var win = new Window();

var query = from dat in treeMap._mainWindow._DataDict

select new

{

dat.Value.Index,

dat.Key,

dat.Value.Size,

dat.Value.Depth,

dat.Value.NumFiles

};

win.Content = new Browse(query);

win.WindowState = WindowState.Maximized;

win.Title = string.Format("Treemap Data # items = {0:n0} ", query.Count());

win.Show();

}

break;

case "_Quit":

Application.Current.Shutdown();

break;

}

catch (Exception)

{

throw;

}

finally

{

if (fResetCursorDelay)

{ // we want to wait til after render by synchronously running low pri empty code

curWin.Dispatcher.Invoke(DispatcherPriority.Render, EmptyDelegate);

{

curWin.Cursor = Cursors.Arrow;

};

}

else

{

curWin.Cursor = Cursors.Arrow;

}

};

__ContextMenu.AddMenuItem(menuItemHandler, "_SubTreeMap", "Create a new subtree map");

__ContextMenu.AddMenuItem(menuItemHandler, "_Explorer", "Open Windows Explorer");

__ContextMenu.AddMenuItem(menuItemHandler, "_New TreeMap Root", "Choose a new root folder");

__ContextMenu.AddMenuItem(menuItemHandler, "_Flip Horizontal/Vertical", "reflect through line x==y");

__ContextMenu.AddMenuItem(menuItemHandler, "_ReColor", "ReDraw with different colors");

__ContextMenu.AddMenuItem(menuItemHandler, "_Browse Data", "show the raw disk data in a grid");

__ContextMenu.AddMenuItem(menuItemHandler, "_Quit", "exit program");

}

return __ContextMenu;

}

public static Action EmptyDelegate = () => { };

public static T GetAncestor<T>(DependencyObject element) where T : DependencyObject

{

while (element != null && !(element is T))

{

element = VisualTreeHelper.GetParent(element);

}

return (T)element;

}

public IntPtr Handle

{//System.Windows.Forms.IWin32Window for parent window of FolderBrowserDialog

get

{

IntPtr hndle = ((System.Windows.Interop.HwndSource)PresentationSource.FromVisual(this)).Handle;

return hndle;

}

public static class MyExtensions

{

public static MenuItem AddMenuItem(this ContextMenu menu, RoutedEventHandler handler, string menuItemContent, string tooltip)

{

var newItem = new MenuItem()

{

Header = menuItemContent,

ToolTip = tooltip

};

newItem.Click += handler;

menu.Items.Add(newItem);

return newItem;

}

// This Browse class is identical to prior post: Write your own Linq Query Viewer http://blogs.msdn.com/b/calvin_hsia/archive/2010/12/30/10110463.aspx

public class Browse : ListView

{

public Browse(IEnumerable query)

{

this.Margin = new System.Windows.Thickness(8);

this.ItemsSource = query;

var gridvw = new GridView();

this.View = gridvw;

var ienum = query.GetType().GetInterface(typeof(IEnumerable<>).FullName);

var members = ienum.GetGenericArguments()[0].GetMembers().Where(m => m.MemberType == System.Reflection.MemberTypes.Property);

foreach (var mbr in members)

{

if (mbr.DeclaringType == typeof(EntityObject)) // if using Entity framework, filter out EntityKey, etc.

{

continue;

}

var gridcol = new GridViewColumn();

var colheader = new GridViewColumnHeader() { Content = mbr.Name };

gridcol.Header = colheader;

colheader.Click += new RoutedEventHandler(colheader_Click);

gridvw.Columns.Add(gridcol);

// now we make a dataTemplate with a Stackpanel containing a TextBlock

// The template must create many instances, so factories are used.

var dataTemplate = new DataTemplate();

gridcol.CellTemplate = dataTemplate;

var stackPanelFactory = new FrameworkElementFactory(typeof(StackPanel));

stackPanelFactory.SetValue(StackPanel.OrientationProperty, Orientation.Horizontal);

var txtBlkFactory = new FrameworkElementFactory(typeof(TextBlock));

var binder = new Binding(mbr.Name)

{

Converter = new MyValueConverter() // truncate things that are too long, add commas for numbers

};

txtBlkFactory.SetBinding(TextBlock.TextProperty, binder);

stackPanelFactory.AppendChild(txtBlkFactory);

txtBlkFactory.SetBinding(TextBlock.ToolTipProperty, new Binding(mbr.Name)); // the tip will have the non-truncated content

txtBlkFactory.SetValue(TextBlock.FontFamilyProperty, new FontFamily("courier new"));

txtBlkFactory.SetValue(TextBlock.FontSizeProperty, 10.0);

dataTemplate.VisualTree = stackPanelFactory;

}

// now create a style for the items

var style = new Style(typeof(ListViewItem));

style.Setters.Add(new Setter(ForegroundProperty, Brushes.Blue));

var trig = new Trigger()

{

Property = IsSelectedProperty,// if Selected, use a different color

Value = true

};

trig.Setters.Add(new Setter(ForegroundProperty, Brushes.Red));

trig.Setters.Add(new Setter(BackgroundProperty, Brushes.Cyan));

style.Triggers.Add(trig);

this.ItemContainerStyle = style;

}

private ListSortDirection _LastSortDir = ListSortDirection.Ascending;

private GridViewColumnHeader _LastHeaderClicked = null;

void colheader_Click(object sender, RoutedEventArgs e)

{

GridViewColumnHeader gvh = sender as GridViewColumnHeader;

if (gvh != null)

{

var dir = ListSortDirection.Ascending;

if (gvh == _LastHeaderClicked) // if clicking on already sorted col, reverse dir

{

dir = 1 - _LastSortDir;

}

try

{

var dataView = CollectionViewSource.GetDefaultView(this.ItemsSource);

dataView.SortDescriptions.Clear();

var sortDesc = new SortDescription(gvh.Content.ToString(), dir);

dataView.SortDescriptions.Add(sortDesc);

dataView.Refresh();

if (_LastHeaderClicked != null)

{

_LastHeaderClicked.Column.HeaderTemplate = null; // clear arrow of prior column

}

SetHeaderTemplate(gvh);

_LastHeaderClicked = gvh;

_LastSortDir = dir;

}

catch (Exception)

{

// some types aren't sortable

}

void SetHeaderTemplate(GridViewColumnHeader gvh)

{

// now we'll create a header template that will show a little Up or Down indicator

var hdrTemplate = new DataTemplate();

var dockPanelFactory = new FrameworkElementFactory(typeof(DockPanel));

var textBlockFactory = new FrameworkElementFactory(typeof(TextBlock));

var binder = new Binding();

binder.Source = gvh.Content; // the column name

textBlockFactory.SetBinding(TextBlock.TextProperty, binder);

textBlockFactory.SetValue(TextBlock.HorizontalAlignmentProperty, HorizontalAlignment.Center);

dockPanelFactory.AppendChild(textBlockFactory);

// a lot of code for a little arrow

var pathFactory = new FrameworkElementFactory(typeof(System.Windows.Shapes.Path));

pathFactory.SetValue(System.Windows.Shapes.Path.FillProperty, Brushes.DarkGray);

var pathGeometry = new PathGeometry();

pathGeometry.Figures = new PathFigureCollection();

var pathFigure = new PathFigure();

pathFigure.Segments = new PathSegmentCollection();

if (_LastSortDir != ListSortDirection.Ascending)

{//"M 4,4 L 12,4 L 8,2"

pathFigure.StartPoint = new Point(4, 4);

pathFigure.Segments.Add(new LineSegment() { Point = new Point(12, 4) });

pathFigure.Segments.Add(new LineSegment() { Point = new Point(8, 2) });

}

else

{//"M 4,2 L 8,4 L 12,2"

pathFigure.StartPoint = new Point(4, 2);

pathFigure.Segments.Add(new LineSegment() { Point = new Point(8, 4) });

pathFigure.Segments.Add(new LineSegment() { Point = new Point(12, 2) });

}

pathGeometry.Figures.Add(pathFigure);

pathFactory.SetValue(System.Windows.Shapes.Path.DataProperty, pathGeometry);

dockPanelFactory.AppendChild(pathFactory);

hdrTemplate.VisualTree = dockPanelFactory;

gvh.Column.HeaderTemplate = hdrTemplate;

}

public class MyValueConverter : IValueConverter

{

private const int maxwidth = 700;

public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

if (null != value)

{

Type type = value.GetType();

//trim len of long strings. Doesn't work if type has ToString() override

if (type == typeof(string))

{

var str = value.ToString().Trim();

var ndx = str.IndexOfAny(new[] { '\r', '\n' });

var lenlimit = maxwidth;

if (ndx >= 0)

{

lenlimit = ndx - 1;

}

if (ndx >= 0 || str.Length > lenlimit)

{

value = str.Substring(0, lenlimit);

}

else

{

value = str;

}

else if (type == typeof(Int32))

{

value = ((int)value).ToString("n0"); // Add commas, like 1,000,000

}

else if (type == typeof(Int64))

{

value = ((Int64)value).ToString("n0"); // Add commas, like 1,000,000

}

return value;

}

public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

throw new NotImplementedException();

}

</code>

Write your own Linq query viewer

CalvinH — Thu, 30 Dec 2010 22:55:30 GMT

Sometimes you just want to see data in a tabular format. It could be stored in a server somewhere in the cloud, in a SQL server, a FoxPro database, an EntityFramework object, or just a local object. You’d like to see all columns, without having to write code to select each column.

Linq allows you to create a query of the data, regardless of where it lives. The resulting query is strongly typed, (i.e. a column each for Name and Age, with the appropriate data types).

However, it’s not easy to write code that works generically with any Linq query: each one can have a different shape, like the number and datatype of the columns.

Below is a sample of C# code (VB code is here) that shows a general purpose class called “Browse”. (FoxPro has a command called Browse, which just presents all the data in a navigable grid format.) Try using the various sample queries, or create your own.

You can just create an instance of Browse, passing in the Linq query as an argument. The Browse figures out the rows and columns from the Linq query using reflection.

The sample also shows how to use a value converter, which will take strings that are too long and truncate them to fit in a browse. The value converter also adds commas to large numbers, like “1,000,000”.

If you want to show real database data, do this: Project->Add New Item-> Ado.Net Entity Model. The Entity Model Data Wizard starts up. Generate from Database. Give it a connection to your data. Select a table. Fiddle with the Entity and table name in the code below and/or the Entity designer (intellisense will work)

Start Visual Studio: File->New->Project->C#->WPF Application. Name it WpfApplication1

Replace the MainWindow.xaml.cs with the code below

Use LINQ to Foxpro or any SQL data and display it in a WPF form using DataSetExtensions and DataRowExtensions

Path Markup Syntax

WPF: How to create Styles in code/and magical Content

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.Collections;

using System.Data.Objects.DataClasses;

using System.Reflection;

using System.Diagnostics;

using System.ComponentModel;

namespace WpfApplication1

{

/// <summary>

/// Interaction logic for MainWindow.xaml

/// </summary>

public partial class MainWindow : Window

{

public MainWindow()

{

InitializeComponent();

this.Loaded += new RoutedEventHandler(this.Window_Loaded);

}

private void Window_Loaded(object sender, RoutedEventArgs e)

{

var dockPanel = new DockPanel();

var btnRefresh = new Button()

{

Content = "_Refresh",

HorizontalAlignment = System.Windows.HorizontalAlignment.Left,

MaxWidth = 100

};

DockPanel.SetDock(btnRefresh, Dock.Top);

this.Content = dockPanel;

btnRefresh.Click += delegate

{

dockPanel.Children.Clear();

dockPanel.Children.Add(btnRefresh);

//var ent = new MyEntities();

//var br = new Browse(from logs in ent.Customers.ToArray() // ToArray so not readonly

// //where logs.TimeStamp > DateTime.Now.AddDays(-4)

// orderby logs.ID descending

// select logs

// );

var br = new Browse(from proc in System.Diagnostics.Process.GetProcesses() select proc);

//var br = new Browse(from file in System.IO.Directory.GetFiles(

// Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)

// )

// select new System.IO.FileInfo(file)

// );

//var br = new Browse(from typ in this.GetType().GetMembers() select typ);

//var br = new Browse(from ProcessThread thrd in System.Diagnostics.Process.GetCurrentProcess().Threads select thrd );

//var br = new Browse(from ProcessModule mod in Process.GetCurrentProcess().Modules select mod);

dockPanel.Children.Add(br);

};

btnRefresh.RaiseEvent(new RoutedEventArgs(Button.ClickEvent, this));

}

public class Browse : ListView

{

public Browse(IEnumerable query)

{

this.Margin = new System.Windows.Thickness(8);

this.ItemsSource = query;

var gridvw = new GridView();

this.View = gridvw;

var ienum = query.GetType().GetInterface(typeof(IEnumerable<>).FullName);

var members = ienum.GetGenericArguments()[0].GetMembers().Where(m => m.MemberType == System.Reflection.MemberTypes.Property);

foreach (var mbr in members)

{

if (mbr.DeclaringType == typeof(EntityObject)) // if using Entity framework, filter out EntityKey, etc.

{

continue;

}

var gridcol = new GridViewColumn();

var colheader = new GridViewColumnHeader() { Content = mbr.Name };

gridcol.Header = colheader;

colheader.Click += new RoutedEventHandler(colheader_Click);

gridvw.Columns.Add(gridcol);

// now we make a dataTemplate with a Stackpanel containing a TextBlock

// The template must create many instances, so factories are used.

var dataTemplate = new DataTemplate();

gridcol.CellTemplate = dataTemplate;

var stackPanelFactory = new FrameworkElementFactory(typeof(StackPanel));

stackPanelFactory.SetValue(StackPanel.OrientationProperty, Orientation.Horizontal);

var txtBlkFactory = new FrameworkElementFactory(typeof(TextBlock));

var binder = new Binding(mbr.Name)

{

Converter = new MyValueConverter() // truncate things that are too long, add commas for numbers

};

txtBlkFactory.SetBinding(TextBlock.TextProperty, binder);

stackPanelFactory.AppendChild(txtBlkFactory);

txtBlkFactory.SetBinding(TextBlock.ToolTipProperty, new Binding(mbr.Name)); // the tip will have the non-truncated content

txtBlkFactory.SetValue(TextBlock.FontFamilyProperty, new FontFamily("courier new"));

txtBlkFactory.SetValue(TextBlock.FontSizeProperty, 10.0);

dataTemplate.VisualTree = stackPanelFactory;

}

// now create a style for the items

var style = new Style(typeof(ListViewItem));

style.Setters.Add(new Setter(ForegroundProperty, Brushes.Blue));

var trig = new Trigger()

{

Property = IsSelectedProperty,// if Selected, use a different color

Value = true

};

trig.Setters.Add(new Setter(ForegroundProperty, Brushes.Red));

trig.Setters.Add(new Setter(BackgroundProperty, Brushes.Cyan));

style.Triggers.Add(trig);

this.ItemContainerStyle = style;

}

private ListSortDirection _LastSortDir = ListSortDirection.Ascending;

private GridViewColumnHeader _LastHeaderClicked = null;

void colheader_Click(object sender, RoutedEventArgs e)

{

GridViewColumnHeader gvh = sender as GridViewColumnHeader;

if (gvh != null)

{

var dir = ListSortDirection.Ascending;

if (gvh == _LastHeaderClicked) // if clicking on already sorted col, reverse dir

{

dir = 1 - _LastSortDir;

}

try

{

var dataView = CollectionViewSource.GetDefaultView(this.ItemsSource);

dataView.SortDescriptions.Clear();

var sortDesc = new SortDescription(gvh.Content.ToString(), dir);

dataView.SortDescriptions.Add(sortDesc);

dataView.Refresh();

if (_LastHeaderClicked != null)

{

_LastHeaderClicked.Column.HeaderTemplate = null; // clear arrow of prior column

}

SetHeaderTemplate(gvh);

_LastHeaderClicked = gvh;

_LastSortDir = dir;

}

catch (Exception)

{

// some types aren't sortable

}

void SetHeaderTemplate(GridViewColumnHeader gvh)

{

// now we'll create a header template that will show a little Up or Down indicator

var hdrTemplate = new DataTemplate();

var dockPanelFactory = new FrameworkElementFactory(typeof(DockPanel));

var textBlockFactory = new FrameworkElementFactory(typeof(TextBlock));

var binder = new Binding();

binder.Source = gvh.Content; // the column name

textBlockFactory.SetBinding(TextBlock.TextProperty, binder);

textBlockFactory.SetValue(TextBlock.HorizontalAlignmentProperty, HorizontalAlignment.Center);

dockPanelFactory.AppendChild(textBlockFactory);

// a lot of code for a little arrow

var pathFactory = new FrameworkElementFactory(typeof(Path));

pathFactory.SetValue(Path.FillProperty, Brushes.DarkGray);

var pathGeometry = new PathGeometry();

pathGeometry.Figures = new PathFigureCollection();

var pathFigure = new PathFigure();

pathFigure.Segments = new PathSegmentCollection();

if (_LastSortDir != ListSortDirection.Ascending)

{//"M 4,4 L 12,4 L 8,2"

pathFigure.StartPoint = new Point(4, 4);

pathFigure.Segments.Add(new LineSegment() { Point = new Point(12, 4) });

pathFigure.Segments.Add(new LineSegment() { Point = new Point(8, 2) });

}

else

{//"M 4,2 L 8,4 L 12,2"

pathFigure.StartPoint = new Point(4, 2);

pathFigure.Segments.Add(new LineSegment() { Point = new Point(8, 4) });

pathFigure.Segments.Add(new LineSegment() { Point = new Point(12, 2) });

}

pathGeometry.Figures.Add(pathFigure);

pathFactory.SetValue(Path.DataProperty, pathGeometry);

dockPanelFactory.AppendChild(pathFactory);

hdrTemplate.VisualTree = dockPanelFactory;

gvh.Column.HeaderTemplate = hdrTemplate;

}

public class MyValueConverter : IValueConverter

{

private const int maxwidth = 70;

public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

if (null != value)

{

Type type = value.GetType();

//trim len of long strings. Doesn't work if type has ToString() override

if (type == typeof(string))

{

var str = value.ToString().Trim();

var ndx = str.IndexOfAny(new[] { '\r', '\n' });

var lenlimit = maxwidth;

if (ndx >= 0)

{

lenlimit = ndx - 1;

}

if (ndx >= 0 || str.Length > lenlimit)

{

value = str.Substring(0, lenlimit);

}

else

{

value = str;

}

else if (type == typeof(Int32))

{

value = ((int)value).ToString("n0"); // Add commas, like 1,000,000

}

else if (type == typeof(Int64))

{

value = ((Int64)value).ToString("n0"); // Add commas, like 1,000,000

}

return value;

}

public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

throw new NotImplementedException();

}

</Sample Code>

Adding a new ADO.NET Entity Data Model "Error HRESULT E_FAIL has been returned from a call to a COM component"

CalvinH — Mon, 27 Dec 2010 19:23:51 GMT

I tried adding a new ADO.NET Entity Data Model item to a VS 2010 solution, but I got this error message:

Error HRESULT E_FAIL has been returned from a call to a COM component.

It worked just a few days ago…hmmm….

I had another project open in another VS instance, and I had rebooted in the interim.

I tried a few other things, like using C#, VB, Console Application, rebooting and it still failed.

Here are the steps I was using:

1. Start VS.

2. File->New Project->C#/VB Console Application

3. Project->Add New Item-> ADO.NET Entity Data Model.

It turns out that the rebooting with the other project instigated the problem.

The other project had a Test project in it, and I had run some tests. I like to have the Test List Window and the Solution Explorer window tab docked. When rebooting, VS shut down and “remembered” the window positions, with the Test List window on top of (and thus hiding) the Solution Explorer window.

When creating a new project the Solution Explorer was still hidden. I invoked the Main Menu->Project menu->Add New Item, which attempted to invoke the wizard. The wizard tries to find the active project in the Solution window, but couldn’t find the Solution Explorer window, and thus the error message.

In fact, the problem can be reproduced by just starting VS with the Solution Explorer never having been created (or even hidden behind other docked windows).

More detailed repro step 1: Start VS: Close all Windows. Restart VS (so now only 1 window is open).

I was using Temporary projects, but apparently it doesn’t matter.

So, the simple fix is to make the Solution Explorer visible first. Many people right click on the project in the solution to add a new item, in which case this problem wouldn’t show.

The Visual Studio shell is a Win32 application that was originally written all in native C++ code many moons ago. With the advent of .Net over the years, more and more pieces are written in managed code.

Indeed, programmer productivity is substantially increased when writing in managed code, taking advantage of the .Net framework.

A simple example: how many ways can a string be represented in code? Managed code has a base String type, which is simple to use.

With native code over the years, there are many forms, like BSTRs, WSTRs, OLECHARS, CStrings, CATLStrings, etc. Each one of these has subtle semantic behavior differences, such as who is responsible for freeing the memory, whether null terminated or length prefixed, etc.

Why does your code take so long? Profile it!

CalvinH — Wed, 01 Dec 2010 03:29:53 GMT

Why does your code take so long to run? How do you improve its performance? When examining code, it’s very difficult to know which piece takes the longest, and thus should be the target of you optimization efforts.

For example, you won’t see much benefit from optimizing a part of your code if that code actually takes only 5% of the time.

Take a look at the code below and see if you can figure out where the most time is spent. Clue: you can increase the speed by 50% with a very minor change, yet do all the same work (don’t just decrease the # of iterations J).

Visual Studio 2010 comes with an easy to use profiling tool to figure out the slow parts of your application.

Start VS, File->New->Project->VB WPF Application. Call it PerfTest.

Paste in the code below to replace MainWindow.Xaml.VB

The code is chopped up sample code form this post What is your computer doing with all that memory? Write your own memory browser to demonstrate code profiling.

Notice that it shows a MessageBox before running some code in a loop. When the code continues, the sample code that we want to profile gets a map of all the virtual memory in the current process.

If you use C#, the code requires adding a reference to System.Windows.Forms.dll for the MessageBox.

Profile the builds that you distribute. If you distribute DEBUG builds, profile it. However, don’t profile while debugging. Hit Ctrl-F5 to launch the code.

When you see the MessageBox, choose main menu->Analyze->Profile->Attach/Detach, then point at the PerfTest.Exe process to which to attach. Once the attach is complete (there’s a spinning circle thingy), dismiss the MessageBox and the targeted code runs. In a few seconds, you’ll see the output in the TextBlock of the main window. Close the main window of the application to end the process and the profiling.

The VS profiler is a sampling profiler. That means, periodically, a snapshot of the process is taken, which includes the call stack for each thread. The data is accumulated until the profiling ends. The stacks are then turned into meaningful data by the profiler.

The VS profiler automatically starts creating the report. In a few seconds, a summary page with a graph of CPU usage vs time shows up. You can select a region and zoom in on it.

The Hot Path (the most expensive call path) is shown, along with the functions doing the most work.

There are several views from which to choose. Call Tree, Modules, Caller/Callee, Functions, etc.

Immediately from the summary page you can see that 50% of the time is in System.Diagnostics.Process.get_Handle()!

Just from those simple steps of profiling the code, you can identify a big improvement in performance.

This is a sample of the Call Tree output:

Function Name	Inclusive Samples	Exclusive Samples
System.Windows.Application.Run()	193	4
WpfApplication1.Application.Main()	193	0
WpfApplication1.MainWindow.Window1_Loaded(object,class System.Windows.RoutedEventArgs)	189	3
WpfApplication1.MainWindow.GetVirtualAllocs()	184	19
System.Diagnostics.Process.get_Handle()	95	95
System.Diagnostics.Process.GetCurrentProcess()	33	33
System.Runtime.InteropServices.Marshal.SizeOf(object)	22	22
_VirtualQueryEx@16	3	3
System.UIntPtr..ctor(uint64)	3	3
@JIT_NewCrossContext@4	2	2
JIT_NewFast(struct CORINFO_CLASS_STRUCT_ *)	2	2
StubHelpers::DemandPermission(class NDirectMethodDesc *)	2	2
MarshalNative::SizeOfClass(class ReflectClassBaseObject *,bool)	1	1
Microsoft.VisualBasic.Interaction.MsgBox(object,valuetype Microsoft.VisualBasic.MsgBoxStyle,object)	1	1
System.Collections.Generic.List`1.Add(!0)	1	1
System.Collections.Generic.List`1.Clear()	1	1
System.UIntPtr.ToUInt64()	1	1

Imports System.Runtime.InteropServices

Imports System.Diagnostics

Class MainWindow

Private WithEvents _btnRefresh As Button

Private _proc As Process

Private _virtAllocs As New List(Of MEMORY_BASIC_INFORMATION)

Private Sub Window1_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles MyBase.Loaded

Me.Width = 800

Me.Height = 800

Dim sbResult = New Text.StringBuilder

MsgBox("start profile")

_proc = Process.GetCurrentProcess

For i = 1 To 5

Dim nIters = 100

Dim stpwatch = Stopwatch.StartNew

For j = 0 To nIters

_virtAllocs.Clear()

GetVirtualAllocs()

stpwatch.Stop()

Dim res = String.Format("# iters = {0} # msecs = {1}", nIters, stpwatch.ElapsedMilliseconds)

Debug.WriteLine(res)

sbResult.AppendLine(res)

Me.Content = New TextBlock With {.Text = sbResult.ToString}

End Sub

Private Sub GetVirtualAllocs()

Dim mbi As New MEMORY_BASIC_INFORMATION

Dim lpMem As UInt64 = 0

Do While VirtualQueryEx(GetCurrentProcess, New UIntPtr(lpMem), mbi, Marshal.SizeOf(mbi)) = Marshal.SizeOf(mbi)

_virtAllocs.Add(mbi)

lpMem = mbi.BaseAddress.ToUInt64 + mbi.RegionSize.ToUInt64

If mbi.lType Or AllocationType.MEM_IMAGE > 0 Then

'Dim filename = GetFileNameFromMBI(mbi)

'Trace.WriteLine(String.Format("{0:x8} {1}", mbi.BaseAddress.ToUInt32, filename))

End If

Loop

End Sub

<DllImport("kernel32.dll", SetLastError:=True)> _

Public Shared Function GetCurrentProcess() As IntPtr

End Function

Const BlockSize As Integer = 1024

<StructLayout(LayoutKind.Sequential)> _

Structure ProcMemBlock

<MarshalAs(UnmanagedType.ByValArray, sizeconst:=BlockSize)> _

Dim data() As Byte

End Structure

<DllImport("kernel32.dll", SetLastError:=True)> _

Public Shared Function ReadProcessMemory( _

ByVal hProcess As IntPtr, _

ByVal lpBaseAddress As UIntPtr, _

ByRef lpBuffer As ProcMemBlock, _

ByVal dwSize As Integer, _

ByRef lpNumberOfBytesRead As Integer _

) As Integer

End Function

<DllImport("psapi")> _

Shared Function GetModuleFileNameEx(ByVal hProcess As IntPtr, ByVal hModule As UIntPtr, ByVal lpFileName As Text.StringBuilder, ByVal nSize As Integer) As Integer

End Function

<DllImport("kernel32")> _

Shared Function VirtualQueryEx( _

ByVal hProcess As IntPtr, _

ByVal lpAddress As UIntPtr, _

ByRef mbi As MEMORY_BASIC_INFORMATION, _

ByVal dwLength As UInteger) As UInteger

End Function

<StructLayout(LayoutKind.Sequential)> _

Structure MEMORY_BASIC_INFORMATION

Dim BaseAddress As UIntPtr

Dim AllocationBase As UIntPtr

Dim AllocationProtect As AllocationProtect

Dim RegionSize As UIntPtr

Dim State As AllocationState

Dim Protect As AllocationProtect

Dim lType As AllocationType

End Structure

<Flags()> _

Enum AllocationProtect

PAGE_EXECUTE = &H10

PAGE_EXECUTE_READ = &H20

PAGE_EXECUTE_READWRITE = &H40

PAGE_EXECUTE_WRITECOPY = &H80

PAGE_NOACCESS = &H1

PAGE_READONLY = &H2

PAGE_READWRITE = &H4

PAGE_WRITECOPY = &H8

PAGE_GUARD = &H100

PAGE_NOCACHE = &H200

PAGE_WRITECOMBINE = &H400

End Enum

<Flags()> _

Enum AllocationType

MEM_IMAGE = &H1000000

MEM_MAPPED = &H40000

MEM_PRIVATE = &H20000

End Enum

<Flags()> _

Enum AllocationState

MEM_COMMIT = &H1000

MEM_FREE = &H10000

MEM_RESERVE = &H2000

End Enum

Function GetFileNameFromMBI(ByVal mbi As MEMORY_BASIC_INFORMATION) As String

Dim retval = ""

If CType(mbi.lType, AllocationType) = AllocationType.MEM_IMAGE Or True Then

If mbi.AllocationBase.ToUInt64 > 0 Then

Dim sbFilename As New Text.StringBuilder(300)

If GetModuleFileNameEx(Process.GetCurrentProcess.Handle, New UIntPtr(mbi.AllocationBase.ToUInt64), sbFilename, sbFilename.Capacity) > 0 Then

retval = sbFilename.ToString

End If

Return retval

End Function

End Class

</Code Sample>

Collect system info for your application's runtime environment

CalvinH — Thu, 28 Oct 2010 17:21:25 GMT

Often your code gets run on a machine far away and it’s useful to gather some information about that machine automatically, perhaps for error reporting or statistics gathering.

This information could include the Operating System version, how much memory, logged in user, etc.

There are various means of gathering such information. Rather than using lots of APIs and rolling my own, I found SystemInfo.exe on my system and MSDN

SystemInfo is a console application which outputs to the console. To capture that data, we merely need to redirect the console StandardOuput

Also note that both C# and VB samples use both Method and Linq query syntax for sorting output.

Start VS2010. File->New->Project->VB or C# WPF Application.

Replace MainWindow.Xaml.VB/CS with the code below.

Of course, you can modify the GetInfo method to gather more info like free disk space, etc.

I’ve gathered more info by enumerating the running processes. From it, you can see the start time of your process, for example.

To get process information: a 32 bit process can’t get much information from a 64 bit process: An exception is thrown: “A 32 bit processes cannot access modules of a 64 bit process.”,

so build your app to run on a 64 bit OS.

To run on a 64 bit machine:

VB: Project->Properties->Compiler->AdvancedCompile options->TargetCPU->Any CPU

C#: Project->Properties->Build->Platform target: Any CPU

SystemInfo gives:

Systeminfo:

Host Name: CALVINH9

OS Name: Microsoft Windows 7 Enterprise

OS Version: 6.1.7601 Service Pack 1, v.178 Build 7601

OS Manufacturer: Microsoft Corporation

OS Configuration: Member Workstation

OS Build Type: Multiprocessor Free

Registered Owner: admin

Registered Organization: Microsoft IT

Product ID: 00392-918-5000002-85687

Original Install Date: 2/3/2010, 1:08:28 PM

System Boot Time: 10/20/2010, 11:00:05 PM

System Manufacturer: Dell Inc.

System Model: Studio 1558

System Type: x64-based PC

Processor(s): 1 Processor(s) Installed.

[01]: Intel64 Family 6 Model 37 Stepping 2 GenuineIntel ~2400 Mhz

BIOS Version: Dell Inc. A02, 12/23/2009

Windows Directory: C:\Windows

System Directory: C:\Windows\system32

Boot Device: \Device\HarddiskVolume2

System Locale: en-us;English (United States)

Input Locale: en-us;English (United States)

Time Zone: (UTC-08:00) Pacific Time (US & Canada)

Total Physical Memory: 8,053 MB

Available Physical Memory: 5,261 MB

Virtual Memory: Max Size: 16,103 MB

Virtual Memory: Available: 12,708 MB

Virtual Memory: In Use: 3,395 MB

Page File Location(s): D:\pagefile.sys

Domain: redmond.corp.microsoft.com

Logon Server: \\TK5-RED-DC-31

Hotfix(s): 5 Hotfix(s) Installed.

[01]: KB958559

[02]: KB2416754

[03]: KB958488

[04]: KB976902

[05]: KB976932

Network Card(s): 4 NIC(s) Installed.

[01]: Realtek RTL8168D/8111D Family PCI-E Gigabit Ethernet NIC (NDIS 6.20)

Connection Name: Local Area Connection

Status: Media disconnected

[02]: Dell Wireless 1520 Wireless-N WLAN Mini-Card

Connection Name: Wireless Network Connection

DHCP Enabled: Yes

DHCP Server: 157.54.23.66

IP address(es)

[01]: 10.80.56.203

[02]: fe80::2c5a:ec35:a53d:d23c

[03]: 2001:4898:b8:2011:69fc:cc57:34f0:64d2

[04]: 2001:4898:b8:2011:2c5a:ec35:a53d:d23c

[03]: Microsoft Virtual WiFi Miniport Adapter

Connection Name: Wireless Network Connection 2

Status: Media disconnected

[04]: Microsoft Loopback Adapter

Connection Name: MS Loopback

Status: Hardware not present

Env vars:

_NO_DEBUG_HEAP=1

_NT_SYMBOL_PATH=SRV*c:\symcache*\\ddrps\symbols;srv*c:\symcache*\\symbols\symbols

ALLUSERSPROFILE=C:\ProgramData

APPDATA=C:\Users\calvinh\AppData\Roaming

CommonProgramFiles=C:\Program Files (x86)\Common Files

CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files

CommonProgramW6432=C:\Program Files\Common Files

COMPUTERNAME=CALVINH9

ComSpec=C:\Windows\system32\cmd.exe

Copycmd=/y

COR_ENABLE_PROFILING=1

COR_PROFILER={01673DDC-46F5-454F-84BC-F2F34564C2AD}

COR_PROFILER_PATH=D:\MemSpect\Vsassert.dll

EMC_AUTOPLAY=C:\Program Files (x86)\Common Files\Roxio Shared\

FP_NO_HOST_CHECK=NO

HOMEDRIVE=C:

HOMEPATH=\Users\calvinh

INSTALL_TYPE=WDS-CLEAN

LOCALAPPDATA=C:\Users\calvinh\AppData\Local

LOGONSERVER=\\TK5-RED-DC-31

NUMBER_OF_PROCESSORS=4

OANOCACHE=1

OS=Windows_NT

Path=c:\bin;C:\Program Files\Common Files\Microsoft Shared\Windows Live;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files\System Center Operations Manager 2007\;C:\Program Files (x86)\Common Files\Roxio Shared\10.0\DLLShared\;C:\Program Files (x86)\Common Files\Roxio Shared\DLLShared\;C:\Program Files\Dell\Dell Wireless WLAN Card;C:\Program Files (x86)\Microsoft Application Virtualization Client;C:\Program Files (x86)\Microsoft SQL Server\100\Tools\Binn\;C:\Program Files\Microsoft SQL Server\100\Tools\Binn\;C:\Program Files\Microsoft SQL Server\100\DTS\Binn\

PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC

PROCESSOR_ARCHITECTURE=x86

PROCESSOR_ARCHITEW6432=AMD64

PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 37 Stepping 2, GenuineIntel

PROCESSOR_LEVEL=6

PROCESSOR_REVISION=2502

ProgramData=C:\ProgramData

ProgramFiles=C:\Program Files (x86)

ProgramFiles(x86)=C:\Program Files (x86)

ProgramW6432=C:\Program Files

PSModulePath=C:\Windows\system32\WindowsPowerShell\v1.0\Modules\

PUBLIC=C:\Users\Public

RoxioCentral=C:\Program Files (x86)\Common Files\Roxio Shared\10.0\Roxio Central36\

SESSIONNAME=Console

SystemDrive=C:

SystemRoot=C:\Windows

TEMP=C:\Users\calvinh\AppData\Local\Temp

TMP=C:\Users\calvinh\AppData\Local\Temp

UATDATA=C:\Windows\SysWOW64\CCM\UATData\D9F8C395-CAB8-491d-B8AC-179A1FE1BE77

USERDNSDOMAIN=REDMOND.CORP.MICROSOFT.COM

USERDOMAIN=REDMOND

USERNAME=calvinh

USERPROFILE=C:\Users\calvinh

VS100COMNTOOLS=C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\Tools\

windir=C:\Windows

<C# Code>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.IO;

namespace WpfApplication2

{

/// <summary>

/// Interaction logic for MainWindow.xaml

/// </summary>

public partial class MainWindow : Window

{

public MainWindow()

{

InitializeComponent();

this.Content = new TextBox()

{

Text = GetInfo(),

HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,

VerticalScrollBarVisibility = ScrollBarVisibility.Auto,

FontFamily = new FontFamily("Courier New")

};

}

string GetInfo()

{

var sb = new System.Text.StringBuilder();

var sysdir = System.Environment.GetEnvironmentVariable("systemroot");// c:\windows

var systeminfoFile = System.IO.Path.Combine(sysdir, @"system32\systeminfo.exe");

if (File.Exists(systeminfoFile))

{

var psinfo = new System.Diagnostics.ProcessStartInfo

{

FileName = systeminfoFile,

UseShellExecute = false,

RedirectStandardOutput = true

};

var p = System.Diagnostics.Process.Start(psinfo);

var sr = p.StandardOutput;

sb.Append(sr.ReadToEnd());

}

sb.AppendLine();

sb.AppendLine("Running Processes");

foreach (System.Diagnostics.Process proc in

System.Diagnostics.Process.GetProcesses().OrderBy(p=>p.ProcessName))

{

try

{

sb.AppendLine(String.Format("{0,6} {1,-20} {2,12:n0} {3,4} {4,25} {5,-50} {6,-50}",

proc.Id,

proc.ProcessName,

proc.WorkingSet64,

proc.Threads.Count,

proc.StartTime,

proc.MainWindowTitle,

proc.MainModule.FileName

));

}

catch (Exception ex)

{

sb.AppendLine(proc.ProcessName + " " + ex.Message);

}

sb.AppendLine();

sb.AppendLine("Env vars:");

foreach (string envvar in

(from string env in System.Environment.GetEnvironmentVariables().Keys

orderby env

select env))

{

sb.AppendLine(envvar + "=" + System.Environment.GetEnvironmentVariable(envvar));

}

return sb.ToString();

}

</C# Code>

Class MainWindow

Private Sub Window_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles MyBase.Loaded

Me.Content = New TextBox With {

.Text = GetInfo(),

.VerticalScrollBarVisibility = ScrollBarVisibility.Auto,

.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,

.FontFamily = New FontFamily("Courier New")

}

End Sub

Function GetInfo() As String

Dim sb As New Text.StringBuilder

Dim sysdir = System.Environment.GetEnvironmentVariable("systemroot") ' c:\windows

Dim systeminfoFile = IO.Path.Combine(sysdir, "system32\systeminfo.exe")

If IO.File.Exists(systeminfoFile) Then

Dim psinfo = New ProcessStartInfo With {

.FileName = systeminfoFile,

.UseShellExecute = False,

.RedirectStandardOutput = True

}

Dim p = Process.Start(psinfo)

Dim sr = p.StandardOutput

sb.Append(sr.ReadToEnd)

End If

sb.AppendLine()

sb.AppendLine("Running Processes")

For Each proc In System.Diagnostics.Process.GetProcesses.OrderBy(Function(p As Process) p.ProcessName)

Try

sb.AppendLine(String.Format("{0,6} {1,-20} {2,12:n0} {3,4} {4,25} {5,-50} {6,-50}",

proc.Id,

proc.ProcessName,

proc.WorkingSet64,

proc.Threads.Count,

proc.StartTime,

proc.MainWindowTitle,

proc.MainModule.FileName

))

Catch ex As Exception

sb.AppendLine(proc.ProcessName + " " + ex.Message)

End Try

sb.AppendLine()

sb.AppendLine("Env vars:")

For Each envvar As String In From env In System.Environment.GetEnvironmentVariables.Keys Order By env

sb.AppendLine(envvar + "=" + System.Environment.GetEnvironmentVariable(envvar))

Return sb.ToString

End Function

End Class

</VB Code>

Out of memory? Easy ways to increase the memory available to your program

CalvinH — Mon, 27 Sep 2010 19:59:24 GMT

When you run your VB or C# application, you might get an OutOfMemoryException thrown, even if your machine has lots of memory.

Every 32 bit process has a 2^32 bit (4 Gig) address space. That means every pointer has a size of 32 bits (4 bytes) and thus is limited to 4 Billion.

That’s the equivalent of saying a vehicle license plate number consists of 6 digits and thus there are 1 million possible numbers.

That 4 Gigs is divided into half: the user application gets the lower half and the OS gets the upper. (This boundary can be changed: see below).

Start VS 2010. File->New->Project->VB or C# Windows WPF Application.

Paste the VB or C# code below. It creates a heap then allocates 100Meg of memory in a loop continuously until an exception is thrown.

On my 64 bit Windows 7 machine with 8 Gigs of RAM (your digital camera or phone might have more memory!), I get about 1.4Gig allocated before it dies.

Iter #10 1,048,576,000

Iter #11 1,153,433,600

Iter #12 1,258,291,200

Iter #13 1,363,148,800

Exception Exception of type 'System.OutOfMemoryException' was thrown.

Now choose Project->Properties->Compile->Build Events->PostBuildEvent Command and added these 2 lines

call "$(DevEnvDir)..\..\vc\vcvarsall.bat" x86

"$(DevEnvDir)..\..\vc\bin\EditBin.exe" "$(TargetPath)" /LARGEADDRESSAWARE

Note: the positions of the quotes are critical

The first line calls a BAT file that makes various tools available on the path.

The second runs EditBin on the target binary, using the LARGEADDRESSAWARE flag (that’s almost all left hand keys on the keyboard!)

Also uncheck the option: Project->Properties->Debug->Enable the Visual Studio Hosting Process

The only effect of these 2 lines is to call EditBin to toggle a bit in the EXE. When the EXE starts a process, that entire process is flagged as able to work with pointers above 2G.

With such pointers, the high bit is a 1, which, in 2’s complement notation, is a negative number, and some applications may not be designed to work with “negative” pointers.

Now when I run the code I get 3.5 Gigs: More than twice as much memory!

Iter #30 3,145,728,000

Iter #31 3,250,585,600

Iter #32 3,355,443,200

Iter #33 3,460,300,800

Exception Exception of type 'System.OutOfMemoryException' was thrown.

This Editbin “trick” works fine on a 64bit OS. For a 32bit OS it works too, but you need to "bcdedit /set IncreaseUserVA 3072" (reboot) and you won’t get as much extra memory.

Want even more memory? If you’re on a 64 bit OS, try compiling to 64 bit:

VB: Project->Properties->Compile->Advanced->Target CPU->Any CPU (or x64)

C#: Project->Properies->Build->Platform Target->Any CPU (or x64)

Iter #110 11,534,336,000

Iter #111 11,639,193,600

Iter #112 11,744,051,200

Iter #113 11,848,908,800

Iter #114 11,953,766,400

Exception Exception of type 'System.OutOfMemoryException' was thrown.

Yes, that really is almost 12 gigs on my 8 gig machine! You can also verify via Task Manager.

A 64 bit process has a pointer of size 64 bits (8 bytes). 2 ^ 64= 18,000,000,000,000,000,000. (1.8 x 10^19)

That’s about 18 exabytes, or 900,000 years of DVD quality video.

Still that’s nowhere near the number of possible chess games or even the waaaay smaller number of electrons that will fit in the universe J(Hubble's law, big bang physics)

When I first worked for Microsoft, I developed a thunking mechanism to allow 32 bit applications to call 16 bit DLLs. (http://support.microsoft.com/kb/139070 )

We thought there’s no way anybody could run out of 32 bit address space!

If a license plate number were to double its length from 6 to 12 digits, that would go from 1 Million (population of a medium sized city) to 1Trillion (1x 10^12) , 200 times the world population.

Use Perfmon to analyze your managed memory

CalvinH — Fri, 27 Aug 2010 19:52:50 GMT

You can learn all sorts of information about your application using Perfmon. You can also inspect various aspects of managed memory.

How much time is spent in garbage collection? When managed code runs, memory management is done for you, but at the cost of freezing your application while GC is doing its thing.

The sample code below creates many instances of a class called Big, which can hold a reference to another of the same class. If the instances of Big are linked together, they can’t be GC’d, til the end of the loop so the memory footprint is very different without the links.

Start VS 2010, File->New->Project->C#->Windows->WpfApplication,

Open the MainWindow.xaml.cs file, replace with the code below

Hit F5 to run.

Start Perfmon: Windows Key+R Perfmon

Click on Performance Monitor in tree on left.

By default, % Processor time is displayed in a graph

Click the big red X to delete it.

Click the big green + to bring up the Add Counters dialog to add some things to monitor

Click on “.NET CLR Memory” in the first listbox.

For Instances of selected object:, choose “WpfApplciation1.vshost” and then click “Add”, “OK”

These are the performance counters graphed on Windows 7:

# Bytes in all Heaps

# GC Handles

# Gen 0 Collections

# Gen 1 Collections

# Gen 2 Collections

# Induced GC

# of Pinned Objects

# of Sink Blocks in use

# Total committed Bytes

# Total reserved Bytes

% Time in GC

Allocated Bytes/sec

Finalization Survivors

Gen 0 heap size

Gen 0 Promoted Bytes/Sec

Gen 1 heap size

Gen 1 Promoted Bytes/Sec

Gen 2 heap size

Large Object Heap size

Process ID

Promoted Finalization-Memory from Gen 0

Promoted Memory from Gen 0

Promoted Memory from Gen 1

You can select various ones individually by clicking on the associated Show checkbox.

Try looking at these closely:

Gen 0 heap size

Gen 1 heap size

Gen 2 heap size

% Time in GC

MultiSelect a few and right click ->Scale selected counters if you like.

At one point (change the size of the Big array to 10000), I got 70% time in garbage collection! (The values in the Textboxes are not scaled, and it showed 47.)

Try commenting out the backlink line (ptrPrev assignment) or vary the size of Big and see the effect.

Use inline XAML with clr-namespace to create a Styled Treeview

CalvinH — Wed, 28 Jul 2010 20:16:27 GMT

Writing WPF code is made easier in VB because of the built in XML features (XAML is really XML). Here is a sample that creates a TreeView of some folders on disk.

Suppose we want to add a Trigger style that will fire when the mouse is over an item. We could do it in code:

Dim style As New Windows.Style

style.Triggers.Add(…)

but it’s more elegant to do it in XAML.

One problem when doing it with inline XML occurs when you want the XML to reference a type. The MyTVItem type inherits from the TreeViewItem class, and I want the style.TargetType to apply to my class, which is not defined in XAML.

IOW, we want the WPF XAML code to refer to the VB Type. The mechanism to do that is the clr-namespace, where we can specify the NameSpace and the Assembly in which the type is found.

Start VS 2010. File->New->Project->VB->Windows->WPF Application. Make sure to name it exactly “VBTVStyle” (or change the xmlns line below)

Replace the Mainwindow.Xaml.vb code with the code below.

Hit F5.

Observe what happens as you expand treeview branches with the keyboard and the mouse.

Class MainWindow

Dim _tv As New MyTView

Private Sub Window_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles MyBase.Loaded

Dim startPath = System.Environment.GetEnvironmentVariable("programfiles") + "\Microsoft Visual Studio 10.0"

Dim tItem = New MyTVItem(_tv) With {

.Header = startPath

}

_tv.Items.Add(tItem)

Dim dp = New DockPanel

dp.Children.Add(_tv)

Me.Content = dp

GetDirs(startPath, tItem)

tItem.IsExpanded = True ' expand 1st node

End Sub

Sub GetDirs(ByVal path As String, ByVal parent As ItemsControl)

Try

Dim dirs = IO.Directory.GetDirectories(path, "*.*", IO.SearchOption.TopDirectoryOnly)

For Each dirName In dirs

Dim tItem = New MyTVItem(_tv) With {

.Header = IO.Path.GetFileName(dirName)

}

parent.Items.Add(tItem)

GetDirs(dirName, tItem) ' recur

Catch ex As Exception ' sometimes you get access denied

MessageBox.Show("Excpt: " + ex.Message + " " + If(String.IsNullOrEmpty(ex.StackTrace), "", ex.StackTrace))

End Try

End Sub

End Class

Class MyTView

Inherits TreeView

Sub New()

Dim XAMLStyle = _

<Style

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:myns="clr-namespace:VBTVStyle;assembly=VBTVStyle"

TargetType="myns:MyTVItem">

<Style.Triggers>

</Trigger>

</Style.Triggers>

</Style>

Try

Me.ItemContainerStyle = CType(Windows.Markup.XamlReader.Load(XAMLStyle.CreateReader), Windows.Style)

Catch ex As Exception

MessageBox.Show("Excpt: " + ex.Message + " " + If(String.IsNullOrEmpty(ex.StackTrace), "", ex.StackTrace))

End Try

End Sub

End Class

Class MyTVItem

Inherits TreeViewItem

Sub New(ByVal tv As MyTView)

Me.ItemContainerStyle = tv.ItemContainerStyle ' propagate to children

End Sub

End Class

</Code Sample>

Using multiple heaps efficiently

CalvinH — Fri, 25 Jun 2010 23:11:24 GMT

You can inspect the processes that run on your machine using Task Manager (Ctrl-Shift-Escape) or , Process Explorer from Sysinternals

Or you can write your own: here’s source code: What is your computer doing with all that memory? Write your own memory browser (if you’re using Dev10, just change “Class Window1” to “Class MainWindow”)

These processes use memory mainly via Heaps. What happens if a heap allocates a whole bunch of memory, and then frees it all? Last time, in Managed code using unmanaged memory: HeapCreate, Peek and Poke, I showed code that allowed you to create and manipulate Heaps in VB.Net and C#.

The pattern of heap usage, lots of small allocations or a few large ones, make a big difference.

Below is sample that allocates 1 Gig via 1024 1 Meg allocations or 1 million 1024 byte allocations. You’ll see vastly different behavior with each.

Start Visual Studio ->File->New Project->VB/C#->Windows->WPF Application, switch to the MainWindow.Xaml.vb/cs window and paste the appropriate version below. Set a breakpoint (F9), then single step and observe the code as you use the memory inspection tool. Use Set Next Statement to modify the code behavior. Change parameters and values as you single step.

If you use ProcessExplorer, watch the VirtualSize column to see that freeing all the individual allocations within a heap may not free all the virtual address space in the heap, depending on the heap usage patterns.

Using your own memory browser (from above) you can see the individual Virtual Allocs.

Internally a heap needs to use memory to track the allocations: probably more internal memory (and virtual address space) for more allocations. Even freeing the allocations may not free these internal structures. HeapDestroy will.

The moral? Even if you free memory in a heap you’re probably not getting back everything: try to combine the heaps you use.

So, for example, you start VS, work in VB for a while, then close VB and work in C# or C++ for a while. If the VB heap isn’t destroyed, it’s just taking up valuable memory. Consider using the Process Heap

Sample output:

0 Hnd= 06f10000 #Alloc=1,048,576 Tot=1,073,741,824 (40000000)

1 Hnd= 04d30000 #Alloc=715,219 Tot=732,384,256 (2ba74c00)

heap create failed

2 Hnd= 00000000 #Alloc=0 Tot=0 (00000000)

heap create failed

3 Hnd= 00000000 #Alloc=0 Tot=0 (00000000)

Option Strict On

Imports System.Runtime.InteropServices

Class MainWindow

Private Sub Window_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles MyBase.Loaded

Dim results As New List(Of heapData)

For i = 0 To 3

Dim hData = HeapCreateAndFill(1024 * 1024, 1024) ' alloc 1 gig=1Million * 1K

'Dim hData = HeapCreateAndFill(1024, 1024 * 1024) ' alloc 1 gig=1K * 1Meg

Debug.WriteLine(String.Format("{0} {1}", i, hData))

' MsgBox(String.Format("{0} {1}", i, hData))

hData.FreeAll() ' we free all allocs but not the heap itself

results.Add(hData)

End Sub

Function HeapCreateAndFill(ByVal nTimes As Integer, ByVal nSize As UInteger) As heapData

Dim hData As New heapData

' hData.hHandle = Heap.GetProcessHeap ' Heap.HeapCreate(0, 0, 0)

hData.hHandle = Heap.HeapCreate(0, 0, 0)

If hData.hHandle = IntPtr.Zero Then

Debug.WriteLine("heap create failed")

Else

For i = 0 To nTimes - 1

Dim ptr = Heap.HeapAlloc(hData.hHandle, 0, nSize)

If ptr = IntPtr.Zero Then ' did we run out of mem?

Exit For

End If

hData.TotAlloc += nSize

hData.nAllocs += 1

hData.ptrs.Add(ptr)

End If

Return hData

End Function

Class heapData

Public hHandle As IntPtr

Public TotAlloc As Int64

Public nAllocs As Integer

Public ptrs As New List(Of IntPtr)

Public Sub FreeAll()

For Each ptr In ptrs ' free every allocation

Heap.HeapFree(hHandle, 0, ptr)

End Sub

Public Overrides Function ToString() As String

Return String.Format("Hnd= {0:x8} #Alloc={1:n0} Tot={2:n0} ({3:x8})", hHandle.ToInt32, nAllocs, TotAlloc, TotAlloc)

End Function

End Class

Public Class Heap

<DllImport("kernel32.dll", SetLastError:=True)> _

Public Shared Function HeapCreate(

ByVal flOptions As HeapFlags,

ByVal dwInitialSize As UInteger,

ByVal dwMaximumSize As UInteger

) As IntPtr

End Function

<DllImport("kernel32.dll", SetLastError:=True)>

Public Shared Function HeapAlloc(

ByVal hHeap As IntPtr,

ByVal dwFlags As HeapFlags,

ByVal dwSize As UInteger

) As IntPtr

End Function

<DllImport("kernel32.dll", SetLastError:=True)>

Public Shared Function HeapFree(

ByVal hHeap As IntPtr,

ByVal dwFlags As HeapFlags,

ByVal lpMem As IntPtr

) As Boolean

End Function

<DllImport("kernel32.dll", SetLastError:=True)>

Public Shared Function HeapDestroy(

ByVal hHeap As IntPtr

) As Boolean

End Function

<DllImport("kernel32.dll", SetLastError:=True)> _

Public Shared Function GetProcessHeap(

) As IntPtr

End Function

<Flags()>

Public Enum HeapFlags

HEAP_NO_SERIALIZE = &H1

HEAP_GENERATE_EXCEPTIONS = &H4

HEAP_ZERO_MEMORY = &H8

End Enum

End Class

</VBCode>

<C# Code>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.Runtime.InteropServices;

using System.Diagnostics;

namespace Heapcs

{

/// <summary>

/// Interaction logic for MainWindow.xaml

/// </summary>

public partial class MainWindow : Window

{

public MainWindow()

{

InitializeComponent();

}

private void Window_Loaded(object sender, RoutedEventArgs e)

{

var results = new List<heapData>();

for (var i = 0; i <= 3; i++)

{

var hData = HeapCreateAndFill(1024 * 1024, 1024);

Debug.WriteLine(String.Format("{0} {1}", i, hData));

hData.FreeAll();

results.Add(hData);

}

heapData HeapCreateAndFill(int nTimes, uint nSize)

{

var hData = new heapData();

hData.hHandle = Heap.HeapCreate(0, 0, 0);

if (hData.hHandle == IntPtr.Zero)

{

Debug.WriteLine("heap create filed");

}

else

{

for (var i = 0; i < nTimes; i++)

{

var ptr = Heap.HeapAlloc(hData.hHandle, 0, nSize);

if (ptr == IntPtr.Zero)

{

break;

}

hData.TotAlloc += nSize;

hData.nAllocs++;

hData.ptrs.Add(ptr);

}

return hData;

}

class heapData

{

public IntPtr hHandle;

public Int64 TotAlloc;

public int nAllocs;

public List<IntPtr> ptrs = new List<IntPtr>();

public void FreeAll()

{

foreach (IntPtr ptr in ptrs)

{

Heap.HeapFree(hHandle, 0, ptr);

}

public override string ToString()

{

return String.Format("Hnd= {0:x8} #Alloc={1:n0} Tot={2:n0} ({3:x8})", hHandle.ToInt32(), nAllocs, TotAlloc, TotAlloc);

}

public class Heap

{

[DllImport("kernel32.dll", SetLastError = true)]

public static extern IntPtr HeapCreate(HeapFlags flOptions, uint dwInitialsize, uint dwMaximumSize);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern IntPtr HeapAlloc(IntPtr hHeap, HeapFlags dwFlags, uint dwSize);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern bool HeapFree(IntPtr hHeap, HeapFlags dwFlags, IntPtr lpMem);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern bool HeapDestroy(IntPtr hHeap);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern IntPtr GetProcessHeap();

[Flags()]

public enum HeapFlags

{

HEAP_NO_SERIALIZE = 0x1,

HEAP_GENERATE_EXCEPTIONS = 0x4,

HEAP_ZERO_MEMORY = 0x8

}

</C# Code>

Managed code using unmanaged memory: HeapCreate, Peek and Poke

CalvinH — Sun, 30 May 2010 07:45:57 GMT

In the old days of Basic (starting over 4 decades ago), there were functions called Peek and Poke that would allow you to read and write memory directly. These were incredibly powerful commands: you could, for example, read and write directly to the hardware, like the video display, the tape cassette recorder, or the speaker.

More modern versions of the language dropped Peek/Poke. However, you can still read and write memory, even from managed code, and this ability is still extremely powerful. You can’t write directly to the speaker, but you can do other fun things: see What is your computer doing with all that memory? Write your own memory browser and Use Named Pipes and Shared Memory for inter process communication with a child process or two

The word “Managed” when applied to languages means that the memory that the program uses is automatically managed for the program: you can just use memory without paying attention to freeing it (usually). there is an automatic unused memory (“garbage”) collector.

(see Examine .Net Memory Leaks).

In this sample we’ll create our own heap into which we’ll write and then read some memory. Keep in mind that the memory could come from anywhere, not just our own heap. We define a TestData structure that has only 2 integer data members. Strings are more complicated because of variable length, encoding, allocation issues.

(see HeapCreate and Marshal.PtrToStructure)

Start Visual Studio 2010. (you can use older versions, but you’ll have to remove some of the new features I’ve used in the code)

File->New Project->(VB or C#) Windows ->WPF Application.

Double click on the form designer to get the code behind file. Replace with the respective version from below.

Make sure you have Tools->Options->Debugger->Just My Code unchecked.

Put a breakpoint (F9) on the first line and single step through. Observe the values change as each line is executed.

If you choose Debug->Windows->Memory1, you can try to see the memory by putting the Address ptr ( like 0x09C307D0) in the address window to see the memory. (In C#, you can drag/drop the address from the Locals window to the Memory window.) Right click on the memory window and choose to display the memory as 4 byte integers.

Unfortunately, when the current stack frame is VB code, the debugger “thinks” that you don’t care about memory, so it won’t evaluate the memory window. You can still see the memory by double clicking a native or C# stack frame on the stack. It’ll ask you for the source code for that frame, but you can just hit escape. Presto, the allocated memory is now available for inspection or even changing via the debugger.

If you’re running on a 64 bit OS, try running the code in 32/64 bit: Project->properties->Compile->Advanced->Target CPU (x86 or x64).

Imports System.Runtime.InteropServices

Class MainWindow

Private _hpHandle As IntPtr

Private Sub Window_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles MyBase.Loaded

Dim wordsize = IntPtr.Size

If wordsize <> 4 Then

'are we in 32 or 64 bit land? doesn't matter!

End If

Dim datSize = Marshal.SizeOf(GetType(TestData))

_hpHandle = Heap.HeapCreate(0, 0, 0)

Dim ptr = Heap.HeapAlloc(_hpHandle, 0, datSize)

Dim dataOrig = New TestData With {.data1 = 1, .data2 = 2}

Marshal.StructureToPtr(dataOrig, ptr, fDeleteOld:=True)

Dim tryd1 = Marshal.ReadInt32(ptr)

Dim tryd2 = Marshal.ReadInt32(ptr + 4)

'change the memory window contents in the debugger: repeat this stmt by using Set Next Statement

Dim dataCopy = Marshal.PtrToStructure(ptr, GetType(TestData))

Heap.HeapFree(_hpHandle, 0, ptr)

End Sub

Sub on_close() Handles MyBase.Closed

Heap.HeapDestroy(_hpHandle)

End Sub

<StructLayout(LayoutKind.Sequential)>

Structure TestData

Dim data1 As Integer

Dim data2 As Integer

Public Overrides Function ToString() As String

Return data1.ToString + " " + data2.ToString

End Function

End Structure

End Class

Public Class Heap

<DllImport("kernel32.dll", SetLastError:=True)> _

Public Shared Function HeapCreate(

ByVal flOptions As UInteger,

ByVal dwInitialSize As UIntPtr,

ByVal dwMaximumSize As UIntPtr

) As IntPtr

End Function

<DllImport("kernel32.dll", SetLastError:=True)>

Public Shared Function HeapAlloc(

ByVal hHeap As IntPtr,

ByVal dwFlags As UInteger,

ByVal dwSize As UIntPtr

) As IntPtr

End Function

<DllImport("kernel32.dll", SetLastError:=True)>

Public Shared Function HeapFree(

ByVal hHeap As IntPtr,

ByVal dwFlags As UInteger,

ByVal lpMem As IntPtr

) As Boolean

End Function

<DllImport("kernel32.dll", SetLastError:=True)>

Public Shared Function HeapDestroy(

ByVal hHeap As IntPtr

) As Boolean

End Function

End Class

</VB Code>

<C# Code>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.Runtime.InteropServices;

namespace Heapcs

{

/// <summary>

/// Interaction logic for MainWindow.xaml

/// </summary>

public partial class MainWindow : Window

{

public MainWindow()

{

InitializeComponent();

}

private IntPtr _hpHandle;

private void Window_Loaded(object sender, RoutedEventArgs e)

{

var wordsize = IntPtr.Size;

if (wordsize != 4)

{

//are we in 32 or 64 bit land? doesn't matter!

}

var datSize = Marshal.SizeOf(typeof(TestData));

_hpHandle = Heap.HeapCreate(0, UIntPtr.Zero, UIntPtr.Zero);

var ptr = Heap.HeapAlloc(_hpHandle, 0, (UIntPtr)datSize);

var dataOrig = new TestData { data1 = 1, data2 = 2 };

Marshal.StructureToPtr(dataOrig, ptr, true);

var tryd1 = Marshal.ReadInt32(ptr);

var tryd2 = Marshal.ReadInt32(ptr + 4);

//change the memory window contents in the debugger: repeat this stmt by using Set Next Statement

var dataCopy = Marshal.PtrToStructure(ptr, typeof(TestData));

Heap.HeapFree(_hpHandle, 0, ptr);

this.Closed +=new EventHandler(on_close);

}

private void on_close(object sender, EventArgs e)

{

Heap.HeapDestroy(_hpHandle);

}

struct TestData

{

public int data1;

public int data2;

public override string ToString()

{

return data1.ToString() + " " + data2.ToString();

}

public class Heap

{

[DllImport("kernel32.dll", SetLastError = true)]

public static extern IntPtr HeapCreate(uint flOptions, UIntPtr dwInitialsize, UIntPtr dwMaximumSize);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern IntPtr HeapAlloc(IntPtr hHeap, uint dwFlags, UIntPtr dwSize);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern bool HeapFree(IntPtr hHeap, uint dwFlags, IntPtr lpMem);

[DllImport("kernel32.dll", SetLastError = true)]

public static extern bool HeapDestroy(IntPtr hHeap);

}

</C# Code>

Sometimes you want 2 returned values: playing around with Tuples

CalvinH — Fri, 30 Apr 2010 01:59:00 GMT

When writing code in various languages, you’ll write functions from which you get a return value.

Sometimes you’ll want to get 2 return values. A common way to handle this is to use parameters to pass a variable by reference that will get one of the return values. Alternatively, you could use a Structure, Dictionary or Map or List, and pass that around but those are heavyweight.

A lighter way is to use the std::pair class (C++: example Use a Custom Allocator for your STL container ) or the KeyValuePair Generic Structure in VB or C#.

See also the Tuple class , new to CLR4, which can hold multiple values. You can even have a Dictionary with the Value being a Tuple.

Dim resBoth = GetTwoResults()

Dim theFirst = resBoth.Key

Dim theSecond = resBoth.Value

Function GetTwoResultsOneByref(ByRef theSecond As String) As String

' caller must have already declared theSecond

theSecond = "two"

Return "One"

End Function

Sub GetTwoResultsTwoByref(ByRef theFirst As String, ByRef theSecond As String)

' caller must have already declared both theFirst and theSecond

theFirst = "One"

theSecond = "two"

End Sub

Function GetTwoResults() As KeyValuePair(Of String, String)

Dim FirstResult = "One"

Dim SecondRes = "two"

Dim dp As New KeyValuePair(Of String, String)(FirstResult, SecondRes)

Return dp

End Function

More things to play with:

Function Get2Values() As Tuple(Of Integer, String)

Return New Tuple(Of Integer, String)(11, "#of inches light travels in 1 nanosecond")

End Function

Function GetManyManyValues() As Dictionary(Of String, Tuple(Of Integer, Integer))

Return New Dictionary(Of String, Tuple(Of Integer, Integer)) From

{

{"one", New Tuple(Of Integer, Integer)(1, 2)},

{"two", New Tuple(Of Integer, Integer)(1, 2)}

}

End Function

I was writing some code using a Dictionary with an Enum as the key, and Tuple as the value.

However, sometimes not every Enum had a dictionary entry, so the code would throw an exception. So I wrote my own wrapper class of a Dictionary.

A sample is below: it uses the processes running on your machine as data, gets the number of threads per process, puts them arbitrarily into buckets. (Note: the “\” operator is integer division with truncation).

Then a summary of the buckets is created: count and size. However, not every bucket will have a value, so the dictionary will throw an exception.

A way to get around that is to create your own dictionary, handling the case where the key is absent in the overloaded default item property.

My first attempt is the MyBTDictNonGeneric below. It’s just a non-generic wrapper. Then I tried a generic approach.

Start Visual Studio 2010->File-New->Project->VB->WPF Application.

Switch to the MainWindow.xaml.vb file and replace the contents with the sample.

A Default Property is needed to create own dictionary which from which values can be returned

The “As New” is needed to constrain the generic to types that can have a New with no parameters.

'New' cannot be used on a type parameter that does not have a 'New' constraint

<code>

Class MainWindow

Enum Buckets

wee

tiny

small

medium

large

larger

grand

super

extralarge

biggest

End Enum

Private Sub Window_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles MyBase.Loaded

Me.Width = 1200

Me.Height = 800

Dim numBuckets = [Enum].GetNames(GetType(Buckets)).Length

Dim queryProc = From proc In System.Diagnostics.Process.GetProcesses

Let ThrdCnt = proc.Threads.Count

Let Bucket = ThrdCnt \ numBuckets

Where Bucket < numBuckets

Select proc.ProcessName,

proc.WorkingSet64,

ThrdCnt,

BucketName = CType(Bucket, Buckets).ToString

' now accum results Count and Size per bucket

Dim tots = From data In queryProc

Group By data.BucketName

Into Cnt = Count(), size = Sum(data.WorkingSet64)

'put results into a dictionary keyed on bucket name

Dim dict1 = New Dictionary(Of Buckets, Tuple(Of Integer, Long)) ' this won't work if values missing

Dim dict2 = New MyBTDict(Of Buckets, MyTuple(Of Integer, Long))

For Each datum In tots

dict1.Add([Enum].Parse(GetType(Buckets), datum.BucketName), New Tuple(Of Integer, Long)(datum.Cnt, datum.size))

dict2.Add([Enum].Parse(GetType(Buckets), datum.BucketName), New MyTuple(Of Integer, Long)(datum.Cnt, datum.size))

Dim nTotCnt = 0

Dim nTotSize As Long = 0

Try ' enumerating all buckets: if there's no dict entry, will throw

For Each bucket In [Enum].GetNames(GetType(Buckets))

Dim tup = dict1([Enum].Parse(GetType(Buckets), bucket))

nTotCnt += tup.Item1

nTotSize += tup.Item2

Catch ex As Exception

MsgBox("Dict1 doesn't work " + ex.Message)

End Try

' with our version of dict, no problem

For Each bucket In [Enum].GetNames(GetType(Buckets))

Dim tup = dict2([Enum].Parse(GetType(Buckets), bucket))

nTotCnt += tup.Item1

nTotSize += tup.Item2

Dim sp As New StackPanel With {.Orientation = Orientation.Horizontal}

sp.Children.Add(New Browse(queryProc))

Dim q2 = From a In dict2

Select Bucket = a.Key.ToString, a.Value.Item1, a.Value.Item2

sp.Children.Add(New Browse(q2))

Me.Content = sp

End Sub

Class MyTuple(Of t1 As New, t2 As New) 'need MyTuple, which has a Public New with no params

Inherits Tuple(Of t1, t2)

Sub New()

MyBase.New(New t1, New t2)

End Sub

Sub New(ByVal p1 As t1, ByVal p2 As t2)

MyBase.New(p1, p2)

End Sub

End Class

Private Class MyBTDict(Of key, value As New) ' value must be constructable

Inherits Dictionary(Of key, value)

Default Overloads ReadOnly Property item(ByVal bt As key) As value

Get

Dim val As value = Nothing

If Not Me.TryGetValue(bt, val) Then

val = New value

End If

Return val

End Get

End Property

End Class

Private Class MyBTDictNonGeneric ' or you could use this non-generic wrapper version

Private _dict As New Dictionary(Of Buckets, Tuple(Of Integer, Long))

Sub add(ByVal bt As Buckets, ByVal nCnt As Integer, ByVal nSize As Long)

_dict.Add(bt, New Tuple(Of Integer, Long)(nCnt, nSize))

End Sub

Default ReadOnly Property MyDefault(ByVal bt As Buckets) As Tuple(Of Integer, Long)

Get

Dim tp As Tuple(Of Integer, Long) = Nothing

If Not _dict.TryGetValue(bt, tp) Then

tp = New Tuple(Of Integer, Long)(0, 0)

End If

Return tp

End Get

End Property

End Class

'The Browse class: http://blogs.msdn.com/calvin_hsia/archive/2007/11/15/6275106.aspx

Class Browse

Inherits ListView

Sub New(ByVal Query As Object, Optional ByVal Parent As Object = Nothing)

Dim gv As New GridView

Me.View = gv

Me.ItemsSource = Query

If Not Parent Is Nothing Then

If Parent.GetType.BaseType Is GetType(Window) Then

CType(Parent, Window).Title = "# items = " + Me.Items.Count.ToString

End If

Me.AddHandler(GridViewColumnHeader.ClickEvent, New RoutedEventHandler(AddressOf HandleHeaderClick))

For Each mem In From mbr In _

Query.GetType().GetInterface(GetType(IEnumerable(Of )).FullName) _

.GetGenericArguments()(0).GetMembers _

Where mbr.MemberType = Reflection.MemberTypes.Property

Dim coltype = CType(mem, Reflection.PropertyInfo).PropertyType.Name

Select Case coltype

Case "Int32", "String", "Int64"

Dim gvc As New GridViewColumn

gvc.Header = mem.Name

gv.Columns.Add(gvc)

If coltype = "Int32" Then

gvc.Width = 80

Dim dt As New DataTemplate

Dim factSP = New FrameworkElementFactory(GetType(StackPanel))

dt.VisualTree = factSP

factSP.SetValue(StackPanel.OrientationProperty, Orientation.Horizontal)

Dim factTb = New FrameworkElementFactory(GetType(TextBlock))

factTb.SetBinding(TextBlock.TextProperty, New Binding(mem.Name))

factTb.SetValue(TextBlock.FontWeightProperty, FontWeights.Bold)

' factTb.SetValue(TextBlock.BackgroundProperty, Brushes.SpringGreen)

factSP.AppendChild(factTb)

'factTb = New FrameworkElementFactory(GetType(Button))

'factTb.SetValue(Button.ContentProperty, "hit me")

'factSP.AppendChild(factTb)

gvc.CellTemplate = dt

Else

gvc.DisplayMemberBinding = New Binding(mem.Name)

gvc.Width = 180

End If

End Select

Dim MyListboxStyle As New Style(GetType(ListBoxItem))

Dim tr = New Trigger

tr.Property = ListBoxItem.IsSelectedProperty ' when Selected

tr.Value = True ' is true

tr.Setters.Add(New Setter(ListBoxItem.ForegroundProperty, Brushes.Bisque))

MyListboxStyle.Triggers.Add(tr)

tr = New Trigger

tr.Property = ListBoxItem.IsMouseOverProperty ' when mouseover

tr.Value = True ' is true

tr.Setters.Add(New Setter(ListBoxItem.ForegroundProperty, Brushes.Red))

tr.Setters.Add(New Setter(ListBoxItem.BackgroundProperty, Brushes.Aquamarine)) ' this trigger sets both fore and back properties

MyListboxStyle.Setters.Add(New Setter(ListBoxItem.ForegroundProperty, Brushes.RoyalBlue)) ' set style for all items

MyListboxStyle.Triggers.Add(tr)

Me.ItemContainerStyle = MyListboxStyle

End Sub

Dim _Lastdir As System.ComponentModel.ListSortDirection = ComponentModel.ListSortDirection.Ascending

Dim _LastHeaderClicked As GridViewColumnHeader = Nothing

Sub HandleHeaderClick(ByVal sender As Object, ByVal e As RoutedEventArgs)

If e.OriginalSource.GetType Is GetType(GridViewColumnHeader) Then

Dim gvh = CType(e.OriginalSource, GridViewColumnHeader)

Dim dir As System.ComponentModel.ListSortDirection = ComponentModel.ListSortDirection.Ascending

If Not gvh Is Nothing AndAlso Not gvh.Column Is Nothing Then

Dim hdr = gvh.Column.Header

If gvh Is _LastHeaderClicked Then

If _Lastdir = ComponentModel.ListSortDirection.Ascending Then

dir = ComponentModel.ListSortDirection.Descending

End If

Sort(hdr, dir)

_LastHeaderClicked = gvh

_Lastdir = dir

End If

End Sub

Sub Sort(ByVal sortby As String, ByVal dir As System.ComponentModel.ListSortDirection)

Me.Items.SortDescriptions.Clear()

Dim sd = New System.ComponentModel.SortDescription(sortby, dir)

Me.Items.SortDescriptions.Add(sd)

Me.Items.Refresh()

End Sub

End Class

</code>

Use Named Pipes and Shared Memory for inter process communication with a child process or two

CalvinH — Wed, 31 Mar 2010 02:16:00 GMT

I wanted to inject some very low impact code that would run in any “parent” process, like Notepad or Excel or Visual Studio. I wanted to have some User Interface for the data that my injected code gathered about the parent process, and that would work best in a different “child” process, preferably using WPF.

In the old days, I could call a COM server to handle the job. A DLL server would be in process, but it could be made out of process by making it a COM+ application (see Blogs get 300 hits per hour: Visual FoxPro can count. and Create multiple threads from within your application).

.Net Remoting seemed to be a little heavyweight for Parent->Child process communication.

About 5 years ago, I wrote this: Use Named Pipes to communicate between processes or machines, so I thought I’d use a combination of Named Pipes and Shared Memory. Luckily .Net 3.5 added support for Named Pipes making the child process pretty simple.

Pipes could be used to send messages, and the lion’s share of data movement could be in the Shared memory.

Synchronization and lifetime management are a little tedious. We want the parent process to continue optionally if the child process terminates, but we want the child to terminate automatically when the parent terminates for any reason. Similarly, the child process should terminate if the parent has gone.

This sample shows a parent process in C++ and 2 child processes in C# and VB. The parent spins off a thread to use to service incoming requests from the children. Events are used to synchronize communication. A timer in each child process fires off requests to the parent.

I was using Visual Studio 2010: you can use VS 2008, but you’ll have to adjust for some of the new features I use, especially in the VB code.

Start Visual Studio. File->New->Project->C++ Win32 Project->Windows Application. In the wizard, Click Add common header files for ATL

Now hit F5 to build and see it execute: there’s a window and a couple menus.

Now add a second EXE project to your solution: choose File->Add->New Project->VB WPF Application. (Repeat to add a 3^rd project for C# !)

Fiddle with the Project->Properties->Compile->Build Output path so it builds into the same folder as the parent exe (for me, it was” ..\Debug\”)

Paste in the VB code below into MainWindow.Xaml.Vb

Somewhere inside the _tWinMain of your CPP project, add these 2 lines to instantiate a class that calls the WpfApplication as a child process, with a shared memory size of 2048 (make sure to change the name of the EXE to match your VB and C# EXEs):

CreateChildProcess opCreateChildProcessCS(_T("NamedPipesCS.exe"),2048, 1);

CreateChildProcess opCreateChildProcessVB(_T("NamedPipesVB.exe"),2048, 2);

Paste the CPP code below before the _tWinMain.

F5 will show both processes launched. You can alt-tab between the 2: they behave like independent processes. Try terminating one of them.

If you uncomment the MsgBox, then hit F5, you can actually use VS to attach to a child process before it does too much. Try attaching to all 3!

<C++ Code>

// CreateChildProcess : class in parent process to instantiate and communicate with a child process

// usage: CreateChildProcess opCreateChildProcess(_T("WpfApplication1.exe"),2048);

class CreateChildProcess

{

HANDLE m_hChildProcess;// handle to the child process we create

HANDLE m_hNamedPipe; // handle to the named pipe the paren process creates

HANDLE m_hEvent;

HANDLE m_hThread; // thread in parent process to communicate with child

LPVOID m_pvMappedSection;

DWORD m_cbSharedMem;

public:

CreateChildProcess(TCHAR* szChildExeFileName,DWORD cbSharedMemSize, int ChildNo )

{

m_cbSharedMem = cbSharedMemSize;

TCHAR szPipeName[1000];

TCHAR szEventName[1000];

swprintf_s(szPipeName, L"Pipe%d_%d", ChildNo, GetCurrentProcessId()); //make the names unique per child and per our (parent) process

swprintf_s(szEventName,L"Event%d_%d", ChildNo, GetCurrentProcessId()); //

SECURITY_ATTRIBUTES SecurityAttributes = {

sizeof( SECURITY_ATTRIBUTES ), // nLength

NULL, // lpSecurityDescriptor. NULL = default for calling process

TRUE // bInheritHandle

};

HANDLE hFileMapping = CreateFileMapping(

INVALID_HANDLE_VALUE, // backed by paging file

&SecurityAttributes,

PAGE_READWRITE,

static_cast< DWORD >(m_cbSharedMem), // Truncation in 64-bit

NULL);

m_pvMappedSection = MapViewOfFile( hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0 );

swprintf_s((TCHAR *)m_pvMappedSection, m_cbSharedMem,_T("here i am in shared mem %d"), 1);

CComBSTR bstrFullPipeName(L"\\\\.\\pipe\\");

bstrFullPipeName.Append(szPipeName); // the pipe name is "\\.\pipe\MyName"

m_hNamedPipe = CreateNamedPipe(

bstrFullPipeName,

PIPE_ACCESS_DUPLEX + FILE_FLAG_FIRST_PIPE_INSTANCE,

PIPE_TYPE_MESSAGE + PIPE_WAIT,

PIPE_UNLIMITED_INSTANCES,

100, //nOutBufferSize

100, //nInBufferSize

100, // nDefaultTimeout

0); // lpSecurityAttributes

m_hEvent = CreateEvent(

&SecurityAttributes,

FALSE, //bManualReset

FALSE, //bInitialState

szEventName); // name

STARTUPINFO StartupInfo = { sizeof(STARTUPINFO) };

PROCESS_INFORMATION ProcessInformation = {};

TCHAR achCommandLine[MAX_PATH*2];

// like WpfApplication1.exe 92 Event2648 Pipe2648 2048

swprintf_s( achCommandLine, _T("%s %d %s %s %d"),szChildExeFileName, hFileMapping, szPipeName, szEventName, m_cbSharedMem);

if( !CreateProcess(

NULL,

achCommandLine,

NULL,

TRUE, // inherit handles

CREATE_DEFAULT_ERROR_MODE | NORMAL_PRIORITY_CLASS,

NULL,

&StartupInfo,

&ProcessInformation))

{

OutputDebugString(L"failed to create process");

return;

}

::CloseHandle( ProcessInformation.hThread );// We don't need the thread handle

DWORD dwThreadId = 0;

m_hChildProcess = ProcessInformation.hProcess;

// Create the actual background thread in the parent process

m_hThread = CreateThread(NULL, // no security

0, // default stack size

CreateChildProcess::ThreadProc, // initial method

(void *)static_cast<CreateChildProcess *>(this), // parameter to the thread proc

0, // run immediately

&dwThreadId);

//DWORD res = ::WaitForSingleObject( hThread, INFINITE );

return ;

}

static DWORD WINAPI ThreadProc(void *pvThreadObject)

{

CreateChildProcess *pCreateChildProcess = static_cast<CreateChildProcess *>(pvThreadObject);

BOOL fDone = false;

while (!fDone)

{

DWORD res = ::WaitForSingleObject( pCreateChildProcess ->m_hEvent, 2000 );

switch(res)

{

case WAIT_OBJECT_0: // the event signalled: we got a request

{

DWORD nTotBytesAvail = 0;

PeekNamedPipe(pCreateChildProcess ->m_hNamedPipe,0,0,0,&nTotBytesAvail,0);

if (nTotBytesAvail != 0)

{

char data[1000];

DWORD nRead = 0;

//read the msg

if (ReadFile(pCreateChildProcess->m_hNamedPipe,data,nTotBytesAvail, &nRead,NULL))

{

data[nTotBytesAvail] = 0; //null terminate

CComBSTR bstrdat( data);

OutputDebugString(bstrdat);

OutputDebugString(L"\n");

if (_wcsnicmp(L"Quit",bstrdat,4)==0)

{

OutputDebugString(L"Child Proc sent Quittin' time msg\n");

fDone=true;

exit(0);

}

// write some stuff to shared mem

swprintf_s(

(wchar_t *)pCreateChildProcess->m_pvMappedSection,

pCreateChildProcess->m_cbSharedMem,

L"Written to shared mem %s", bstrdat);

// send a msg to the child

data[0]='C';

data[1]='+';

data[2]='+';

DWORD nBytesWritten= 0;

WriteFile( pCreateChildProcess->m_hNamedPipe, data, nTotBytesAvail,&nBytesWritten,0);

}

break;

case WAIT_TIMEOUT:

// test to see if child process still alive

if (WaitForSingleObject(pCreateChildProcess->m_hChildProcess,0) == WAIT_OBJECT_0) // did the proc terminate?

{

fDone = true;

}

break;

default:

fDone=true;

}

// interprocess comm is over

CloseHandle(pCreateChildProcess->m_hChildProcess);

pCreateChildProcess->m_hChildProcess = INVALID_HANDLE_VALUE;

CloseHandle(pCreateChildProcess->m_hThread);

CloseHandle(pCreateChildProcess->m_hNamedPipe);

return 0;

}

};

</C++ Code>

Imports System.IO.Pipes

Imports System.Runtime.InteropServices

Imports System.Windows.Threading

Imports System.Text

Module NativeImports

Public Const FILE_MAP_READ As Int32 = &H4

Public Const FILE_MAP_WRITE As Int32 = &H2

Declare Function MapViewOfFile Lib "kernel32" (ByVal hFileMappingObject As IntPtr, ByVal dwDesiredAccess As UInt32, ByVal dwFileOffsetHigh As UInt32, ByVal dwFileOffsetLow As UInt32, ByVal dwNumberOfBytesToMap As UInt32) As UInt32

End Module

Class MainWindow

Private WithEvents _timer As New DispatcherTimer With {.Interval = TimeSpan.FromSeconds(2)}

Private _pipestream As NamedPipeClientStream

Private _event As System.Threading.EventWaitHandle

Private _sharedMemAddr As UInteger

Private _sharedMemSize As Integer

Private _txtStatus As New TextBox With {

.AcceptsReturn = True,

.AcceptsTab = True,

.VerticalScrollBarVisibility = ScrollBarVisibility.Auto

}

Private Sub Window_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles MyBase.Loaded

' MsgBox("attach a debugger", "VB")

Me.Title = "VB Child Process"

Me.Content = _txtStatus

Dim args = System.Environment.GetCommandLineArgs

If args.Count < 4 Then

MessageBox.Show("No args")

Close()

Return

End If

Dim hFileMapping = CInt(args(1))

_sharedMemAddr = MapViewOfFile(hFileMapping, FILE_MAP_READ Or FILE_MAP_WRITE, 0, 0, 0)

Dim pipename = args(2)

_pipestream = New NamedPipeClientStream(".", pipename,

PipeDirection.InOut,

PipeOptions.Asynchronous)

Dim eventname = args(3)

_event = System.Threading.ManualResetEvent.OpenExisting(eventname)

_sharedMemSize = CInt(args(4))

_pipestream.Connect()

UpdateStatus("start: shared mem " + ReadSharedMem())

_timer.Start()

End Sub

Shared _numticks As Integer

Private _byteEncoding As New UTF8Encoding

Private _IsClosed = False

Private _decoder = _byteEncoding.GetDecoder

Sub OnTimerTick() Handles _timer.Tick

Try

If _pipestream Is Nothing Or Not _pipestream.IsConnected Then

DoForceClose()

Return

End If

SendMsg("WPFClient msg" + _numticks.ToString + " " + DateTime.Now.ToLongTimeString)

_numticks += 1

Dim str = GetMsg()

UpdateStatus("Client got data: " + str)

Dim ss = ReadSharedMem()

UpdateStatus("shared mem: " + ss)

Catch ex As IO.IOException ' a named pipe IO op failed

DoForceClose()

Catch ex As Exception

DoForceClose()

End Try

End Sub

Sub DoForceClose()

If Not _IsClosed Then

_IsClosed = True

_timer = Nothing

_pipestream = Nothing

UpdateStatus("Disconnected")

Me.Close()

End If

End Sub

Sub SendMsg(ByVal szMsg As String)

Dim barray = _byteEncoding.GetBytes(szMsg)

_pipestream.Write(barray, 0, barray.Length)

_event.Set()

End Sub

Function GetMsg() As String

Dim str = ""

Dim barrRead(90) As Byte

Dim charsRead(90) As Char

Dim nBytesRead = _pipestream.Read(barrRead, 0, barrRead.Length)

Dim nChars = _decoder.GetChars(barrRead, 0, nBytesRead, charsRead, 0)

str = New String(charsRead, 0, nChars)

Return str

End Function

Function ReadSharedMem() As String

Dim sResult = ""

For i = 0 To _sharedMemSize Step 2 ' unicode

Dim aaddr = New IntPtr(_sharedMemAddr + i)

Dim aByte = Marshal.ReadByte(aaddr)

If aByte = 0 Then

Exit For

End If

sResult += Chr(aByte)

Marshal.WriteByte(aaddr, aByte + 1) ' demo: change the mem we just read: under a debugger you can see that shared mem was written

Return sResult

End Function

Private Sub UpdateStatus(ByVal newStat As String)

newStat = DateTime.Now.ToString + " " + newStat + vbCrLf

Debug.Write(newStat)

Me._txtStatus.AppendText(newStat)

Me._txtStatus.ScrollToEnd()

End Sub

Sub On_Closed() Handles Me.Closed

_timer = Nothing

If Not _IsClosed Then

SendMsg("Quit")

End If

If _pipestream IsNot Nothing Then

_pipestream.Dispose()

_pipestream = Nothing

End If

End Sub

End Class

</VB Code>

<C# Code>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.IO.Pipes;

using System.Runtime.InteropServices;

namespace NamedPipesCS

{

/// <summary>

/// Interaction logic for MainWindow.xaml

/// </summary>

public partial class MainWindow : Window

{

[DllImport("kernel32.dll", SetLastError = true)]

static extern IntPtr MapViewOfFile(

IntPtr hFileMappingObject,

FileMapAccess dwDesiredAccess,

uint dwFileOffsetHigh,

uint dwFileOffsetLow,

uint dwNumberOfBytesToMap);

[Flags]

public enum FileMapAccess : uint

{

FileMapCopy = 0x0001,

FileMapWrite = 0x0002,

FileMapRead = 0x0004,

FileMapAllAccess = 0x001f,

fileMapExecute = 0x0020,

}

private TextBox _txtStatus;

private IntPtr _sharedMemAddr;

private NamedPipeClientStream _pipestream;

private System.Threading.EventWaitHandle _event;

private int _sharedMemSize;

private System.Windows.Threading.DispatcherTimer _timer;

static int _numticks;

private UTF8Encoding _byteEncoding = new UTF8Encoding();

private bool _IsClosed;

private Decoder _decoder;

public MainWindow()

{

//MessageBox.Show("attach a debugger","C#");

InitializeComponent();

_decoder = _byteEncoding.GetDecoder();

}

private void Window_Loaded(object sender, RoutedEventArgs e)

{

_txtStatus = new TextBox();

_txtStatus.AcceptsReturn = true;

_txtStatus.AcceptsTab = true;

_txtStatus.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;

this.Title = "C# Child Process";

this.Content = _txtStatus;

var args = Environment.GetCommandLineArgs();

if (args.Count() < 4)

{

MessageBox.Show("No args");

Close();

return;

}

var hFileMapping = int.Parse(args[1]);

_sharedMemAddr = MapViewOfFile(new IntPtr(hFileMapping), FileMapAccess.FileMapRead | FileMapAccess.FileMapWrite, 0, 0, 0);

var pipeName = args[2];

_pipestream = new System.IO.Pipes.NamedPipeClientStream(".", pipeName, System.IO.Pipes.PipeDirection.InOut, System.IO.Pipes.PipeOptions.Asynchronous);

var Eventname = args[3];

_event = System.Threading.ManualResetEvent.OpenExisting(Eventname);

_sharedMemSize = int.Parse(args[4]);

_pipestream.Connect();

UpdateStatus(string.Format("start: shared mem {0}" , ReadSharedMem()));

_timer = new System.Windows.Threading.DispatcherTimer();

_timer.Interval = TimeSpan.FromSeconds(2);

_timer.Tick += new EventHandler(OnTimerTick);

_timer.Start();

this.Closed += new EventHandler(on_Closed);

}

void OnTimerTick(Object o, EventArgs e)

{

try

{

if (_pipestream == null || !_pipestream.IsConnected)

{

DoForceClose();

return;

}

SendMsg(String.Format("WPFClient msg {0} {1}" , _numticks, DateTime.Now.ToLongTimeString()));

_numticks += 1;

var str = GetMsg();

UpdateStatus(String.Format("Client got data: {0}" , str));

var ss = ReadSharedMem();

UpdateStatus(String.Format("shared mem: {0}" , ss));

}

catch (Exception)

{

DoForceClose();

}

void DoForceClose()

{

if (!_IsClosed)

{

_IsClosed = true;

_timer = null;

_pipestream = null;

UpdateStatus("Diconnected");

Close();

}

void SendMsg(string szMsg)

{

var barray = _byteEncoding.GetBytes(szMsg);

_pipestream.Write(barray, 0, barray.Length);

_event.Set();

}

string GetMsg()

{

var str = "";

var barrRead =new Byte[90];

var charsRead = new char[90];

var nByteRead = _pipestream.Read(barrRead, 0, barrRead.Length);

var nChars = _decoder.GetChars(barrRead, 0, nByteRead, charsRead, 0);

str = new string(charsRead, 0, nChars);

return str;

}

String ReadSharedMem()

{

var sResult = "";

for (int i = 0; i < _sharedMemSize; i += 2)

{

var aaddr = _sharedMemAddr + i;

var aByte = Marshal.ReadByte(aaddr);

if (aByte == 0)

{

break;

}

sResult += Convert.ToChar(aByte);

Marshal.WriteByte(aaddr,(byte)(aByte+(byte)1));// ' demo: change the mem we just read: under a debugger you can see that shared mem was written

}

return sResult;

}

private void UpdateStatus(String newStat)

{

newStat =string.Format("{0} {1}\n", DateTime.Now.ToString(),newStat);

System.Diagnostics.Debug.Write(newStat);

_txtStatus.AppendText(newStat);

_txtStatus.ScrollToEnd();

}

void on_Closed(Object o, EventArgs e)

{

_timer = null;

if (!_IsClosed)

{

SendMsg("Quit");

}

if (_pipestream != null)

{

_pipestream.Dispose();

_pipestream = null;

}

</C# Code>

Use a Custom Allocator for your STL container

CalvinH — Tue, 16 Mar 2010 23:23:00 GMT

Last time in Play around with .Net Dictionaries and STL maps, we talked about various containers. Today we’ll write our own allocator for a particular STL container.

A general purpose allocator, like malloc in the C Runtime library or HeapAlloc in the Windows API needs to handle allocation requests of various sizes. The calls to free the memory can come at arbitrary times too. The allocator might have to track the various free blocks somehow, perhaps in a linked list. Fragmentation can occur, causing inefficient use.

A custom allocator can take advantage of various aspects of memory requestors:

· Perhaps every request is identical in size (as in the case of an array or growing a tree)

· Perhaps your usage pattern is to never delete an entry: there are only 12 months in the year, 50 states in the union, even for the forseeable future J

· Perhaps you can preallocate a large enough block for the desired scenario: then free the whole block at once when done with the data (this is the No Release Allocator: you never free the memory til the end (perhaps a destructor can free it at the end for you)). This is what our sample does below.

In some of my memory tracking diagnostic utilities, I use a custom allocator to allocate from a private heap.

The output is just 3 numbers per line, separated by spaces. You can start Excel, paste those numbers in, then choose Data->Text to Columns to convert the data to columns, then graph the data with a few keystrokes:

· Ctrl-A Select All

· Alt-N Insert

· N Line

· Enter 2-D line graph

If you want to add a column to indicate what percent faster the 3^rd is than the 1st: =+(A1-C1)/A1*100

A custom allocator can boost performance. Indeed, using my custom allocator I was able to get around 30% faster performance.

Beware when you do timings that you use a Release build and you’ve read this: You can develop code faster

Examine .Net Memory Leaks

Customize the VS debugger display of your data

Article on allocators: http://www.ddj.com/cpp/184403759

Dim a = New AtlInteropLib.TestInterop

a.Test("From VB")

</VB Code>

<C++ code>

// TestInterop.cpp : Implementation of CTestInterop

#include "stdafx.h"

#include "TestInterop.h"

#include <map>

#include <vector>

// CTestInterop

// <MyCustomAlloc>

long g_nCnt = 0; // total # blocks allocated

long g_nTot = 0; // total allocated

template <class T>

class MyCustomAlloc

A custom allocator: given a pool of memory to start, just dole out consecutive memory blocks.

this could be faster than a general purpose allocator.

E.G. it could take advantage of constant sized requests (as in a RedBlack tree)

{

public:

typedef T value_type;

typedef size_t size_type;

typedef ptrdiff_t difference_type;

typedef T* pointer;

typedef const T* const_pointer;

typedef T& reference;

typedef const T& const_reference;

MyCustomAlloc(byte *pool, int nPoolSize)

{

Init();

m_pool = pool;

m_nPoolSize = nPoolSize;

}

MyCustomAlloc(int n)

{

Init();

}

MyCustomAlloc()

{

Init();

}

void Init()

{

m_pool = 0;

m_nPoolSize = 0;

g_nCnt = 0;

g_nTot = 0;

}

MyCustomAlloc(const MyCustomAlloc &obj) // copy constructor

{

Init();

m_pool = obj.m_pool;

m_nPoolSize = obj.m_nPoolSize;

}

private:

void operator =(const MyCustomAlloc &);

public:

byte *m_pool;

unsigned m_nPoolSize;

template <class _Other>

MyCustomAlloc(const MyCustomAlloc<_Other> &other)

{

Init();

m_pool= other.m_pool;

m_nPoolSize = other.m_nPoolSize;

}

~MyCustomAlloc()

{

}

template <class U>

struct rebind

{

typedef MyCustomAlloc<U> other ;

};

pointer

address( reference r ) const

{

return &r;

}

const_pointer

address( const_reference r ) const

{

return &r;

}

pointer

allocate( size_type n, const void* /*hint*/=0 )

{

pointer p;

unsigned nSize = n * sizeof(T);

if (m_pool) // if we have a mem pool from which to allocated

{

p = (pointer) m_pool;// just return the next available mem in the pool

if (g_nTot + nSize > m_nPoolSize)

{

_ASSERT(0);//,"out of mem pool");

return 0;

}

m_pool += nSize; // and bump the pointer

}

else

{

p = (pointer) malloc(nSize);// no pool: just use malloc

}

g_nCnt+=1;

g_nTot += nSize;

_ASSERTE(p);

return p;

}

void

deallocate( pointer p, size_type /*n*/ )

{

if (!m_pool)// if there's a pool, nothing to do

{

free( p);

}

void

construct( pointer p, const T& val )

{

new (p) T(val);

}

void

destroy( pointer p )

{

p->~T();

}

size_type

max_size() const

{

return ULONG_MAX / sizeof(T);

}

};

template <class T>

bool

operator==( const MyCustomAlloc<T>& left, const MyCustomAlloc<T>& right )

{

if (left.m_pool == right.m_pool)

{

return true;

}

return false;

}

template <class T>

bool

operator!=( const MyCustomAlloc<T>& left, const MyCustomAlloc<T>& right)

{

if (left.m_pool != right.m_pool)

{

return true;

}

return false;

}

// </MyCustomAlloc>

using namespace std;

typedef pair<CComBSTR,int> PairStringInt;

// DoTest is a template func that does the test.

// it's a template because 2 diff map types are passed in

#define NSIZE 2

template <typename TMap>

void DoTest(TMap oMap, CComBSTR bstrType)

{

for (int nItem = 0 ; nItem < NSIZE; nItem++) // 2nd time through adds dupes, no prob: ignored

{

// as you single step through here, observe the value of

// oMap in the Locals window!

oMap.insert(PairStringInt (CComBSTR("Jan"),31));

oMap.insert(PairStringInt (CComBSTR("Feb"),28));

oMap.insert(PairStringInt (CComBSTR("Mar"),31));

oMap.insert(PairStringInt (CComBSTR("Apr"),30));

oMap.insert(PairStringInt (CComBSTR("May"),31));

oMap.insert(PairStringInt (CComBSTR("Jun"),30));

oMap.insert(PairStringInt (CComBSTR("Jul"),31));

if (nItem == 0)

{

// declare an iterator

TMap::const_iterator it;

// now iterate through the collection

for (it = oMap.begin() ; it != oMap.end() ; it++)

{ // note they're sorted!

wchar_t buf[1000];

CComBSTR strOutput(bstrType);

strOutput.Append(L" ");

strOutput.Append(it->first);

strOutput.Append(L" ");

_itow_s(it->second, buf,10, 10);

strOutput.Append(buf); // hi Crescens2k

strOutput.Append(L"\n");

OutputDebugString(strOutput);

}

oMap.clear();

}

#define NITERATIONS 1000

#define NumItemsToAdd 10000

#define POOLSIZE (1040208+100)

struct SomeBigData

{

long id;

long dummy[20];

} b1 = {1,{1,1}},

b2 = {2,{2,2}};

typedef pair<long, SomeBigData> mapData; // a pair that holds some data

template <typename TMap>

void DoTestTiming(TMap oMap)

{

// now insert a few big items

for (int nItem = 0 ; nItem < NumItemsToAdd; nItem++) // # items to add to the maps

{

b1.id = nItem;

b2.id = nItem;

oMap.insert(mapData(nItem,b1));

}

void TestTiming(int nIter)

{

char buff[1000];

byte *pool = 0;

for (int iType = 0 ; iType < 3 ; iType++) // the map types

{

int nTotTime = 0;

DWORD nTickStart = GetTickCount();

for (int nIter = 0 ; nIter < NITERATIONS ; nIter ++)

{

g_nTot = 0;

g_nCnt = 0;

switch(iType)

{

case 0:

{

map<long, SomeBigData> oMap0;

// OutputDebugString(L"Using plain map ");

// same as multimap<long, SomeBigData, less<long>, std::allocator<std::pair<long, SomeBigData> > > oMap0;

DoTestTiming(oMap0);

}

break;

case 1:

{

typedef MyCustomAlloc<pair< long, SomeBigData> > MyAllocator;

map<long, SomeBigData, less<long>, MyAllocator> oMap1;

// OutputDebugString(L"custom alloc ");

DoTestTiming(oMap1);

}

break;

case 2:

if (pool == 0)

{

pool = (byte *)malloc(POOLSIZE);

}

{

typedef MyCustomAlloc<pair< long, SomeBigData> > MyAllocator;

MyAllocator z = MyAllocator(pool, POOLSIZE);

// OutputDebugString(L"Custom pool ");

map<long, SomeBigData, less<long>, MyAllocator> oMap2(less<long>(),z);

DoTestTiming(oMap2);

}

break;

}

free(pool); // ok to free null (fast too)

pool = 0;

// _snprintf_s(buff,sizeof(buff),"Done nType = %d nLoop = %d mSecs = %7d %d %d\n", iType, nIter, nTickEnd, g_nTot, g_nCnt);

// OutputDebugStringA(buff);

}

DWORD nTickEnd = GetTickCount() - nTickStart;

nTotTime += nTickEnd;

_snprintf_s(buff, sizeof(buff)," %d", nTotTime);

OutputDebugStringA(buff);

}

OutputDebugString(L"\n");

}

STDMETHODIMP CTestInterop::Test(BSTR str, long *pRetval)

{

// single step through and observe the Locals window

//some of this verbosity can be reduced via more typedefs

// first we create a map object

map<CComBSTR,int> MonthDict;

DoTest(MonthDict,L"Using a map");

multimap<CComBSTR, int> MultiMapMonthDict;

DoTest(MultiMapMonthDict, "Using a multimap");

// now we declare our own custom allocator, so the map will use it

// this allocator just uses malloc/free (we don't give it a mem pool to use)

typedef MyCustomAlloc<pair< CComBSTR, int> > MyAllocator;

// we declare an instance of map which uses our custom allocator

map<CComBSTR,int,less<CComBSTR>, MyAllocator > MonthDictCustomAlloc;

DoTest(MonthDictCustomAlloc, L"Custom Alloc");

// now we create a memory pool for our allocator to use

byte *MyMemoryPool = (byte *)malloc(POOLSIZE);

// open a debug window (Debug->Windows->Memory->1)

// and drag the value of MyMemoryPool from the Locals window to it

// single step through so you can see the memory being used for

// the RedBlack tree.

{// scoping so destructors fire before we free memory

// we create an instance of the allocator

MyAllocator z = MyAllocator(MyMemoryPool, POOLSIZE);

// we declare an instance of map which uses our custom allocator using our mem pool

map<CComBSTR, int, less<CComBSTR>, MyAllocator> MonthDictCustomMemoryPool(less<CComBSTR>(),z);

DoTest(MonthDictCustomMemoryPool,L"Map with mempool");

}

free(MyMemoryPool); // ok to free(0)

for (int i = 0 ; i < 40 ; i++)

{

TestTiming(i);

}

return S_OK;

}

</C++ code>