public void getResults(string websiteURL)
{
  WebClient c = new WebClient();
  c.DownloadStringAsync(new Uri(websiteURL));
  c.DownloadStringCompleted += new DownloadStringCompletedEventHandler(c_DownloadStringCompleted);
}

void c_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
{
  lock (this)
  {
    string s = e.Result;
    XmlReader r = XmlReader.Create(new MemoryStream(System.Text.UnicodeEncoding.Unicode.GetBytes(s)));
    // So something with the XML we get back
  }
}

So basically all we do is say download the string and make the action to take when it is completed as c_DownloadStringCompleted event handler. You may want to do something different than place it in an xml reader (in this case the string we are getting back corresponds to a non-xhtml xml file. Enjoy.

In WP7, if you try to use a ListBox control, you’ll noticed that child controls do not completely fill the available space of the control. To do this you have to override the style of the ListBox’s ItemContainer, as well as override the template and set the appropriate HorizontalContentAlignment properties.

First, this is what the problem looks like. In blue we have the entire ListBox Control, and in white is the space for an individual item.

The Problem

As you can see, the ListBoxItem is shown in white and only fits the size of the content. The entire ListBox is shown in red and remains empty. If you increase the size of the text it will stretch to the width. But if we wanted to align the button on the right as its own column we want the text to take up the remaining space and we need the item to fit the width of the control. Then we’d be able to use a Grid control to set the proper alignment.

The Solution

We have to override not only the HorizontalContentAlignment Properties of the ItemContainer but also pass those onto the Template and Container in the Style. This is very unintuitive as you would expect HorizontalContentAlignment to just work.

 <phone:PhoneApplicationPage.Resources>          <Style x:Key="ListBoxItemStyle1" TargetType="ListBoxItem">
            <Setter Property="Background" Value="Transparent"/>
            <Setter Property="BorderThickness" Value="0"/>
            <Setter Property="BorderBrush" Value="Transparent"/>
            <Setter Property="Padding" Value="0"/>
            <Setter Property="HorizontalContentAlignment" Value="Stretch"/>
            <Setter Property="HorizontalAlignment" Value="Stretch" />
            <Setter Property="VerticalContentAlignment" Value="Stretch"/>
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate TargetType="ListBoxItem">
                        <Border x:Name="LayoutRoot" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" HorizontalAlignment="{TemplateBinding HorizontalAlignment}" VerticalAlignment="{TemplateBinding VerticalAlignment}">
                            <ContentControl x:Name="ContentContainer" ContentTemplate="{TemplateBinding ContentTemplate}" Content="{TemplateBinding Content}" Foreground="{TemplateBinding Foreground}" HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}" Margin="{TemplateBinding Padding}" VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"/>
                        </Border>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>      </phone:PhoneApplicationPage.Resources> 

Then apply it to the ListBox:

 <ListBox x:Name="SearchResultsListBox"
                     Grid.Row="0"
                     HorizontalContentAlignment="Stretch"
                     ItemContainerStyle="{StaticResource ListBoxItemStyle1}"
                     ItemsSource="{Binding ElementName=SearchPageControl, Path=QueryHandler.OpenSearchSuggestion.section.items, Mode=OneWay}">  ... 

The Result

As you can see the item wrapped in white stretches the entire width of the ListBox in red.

Conclusions

Although unintuitive this should get the job done. Hopefully Microsoft can make some of these details more straightforward before the final release or in updated versions of .NET.

You’ll want the dll which pertains to your version and binary type (in my case I want the path referring to v4.030319 and non-64bit).

Next we’ll open up our application in visual studio and start the debugger.First you need to enable unmanaged debugging. So right click on your project and go to properties. You should see a window similar to the one below. Select debugging and make sure the circled checkbox is enabled:

Run your application and wait until the point you want to check your memory usage. You’ll want to look for the pause button or hit CTRL+BREAK to break the running of your application.

Next, open the immediate window or go to Debug->Windows->Immediate Window to bring it up.

Now, you’ll want to load SOS.dll to access the extensions, we do this with the load command in below:

Ok, now we can issue commands to find out information about our system. Type in “!dumpheap” to get a list of all the allocated objects on the heap. Be careful though, you can easily overwhelm your system with output. To summarize and get only the useful information type “!dumpheap –stat”. You see something like this:

The columns in order are, method table, number of instances in memory, total size of instances, type.

!dumpheap has a ton of flags. If you use !dump –type System.String, you can get a summary of all heap objects matching the type (in this case, System.String). Not that the method table is not the same as the memory address. Say we wanted to find out what was holding one of the dictionary objects. We could use !dumpheap –mt <methodtable> to get a list of all the objects in that method table. Then used the address provided to use gcroot to give us all the paths to the object in our application.

Notice in this case there is only one object and one memory address. If your method table or type has many addresses it could be difficult to identify or find your target object (in that case try to find the memory address through a parent object with less instances (or preferably, 1). If we use that address we can use the command “!gcroot 02369d30” to find all references the garbage collector knows is keeping the object down. Output will look something like this:

Work backwards from the bottom of each trace. It starts with the object in question and moves up the reference tree to a root node for the application. This would tell us that the object directly above our object is another dictionary, then a schema context and eventually a template. You can do this for any object you’d like to trace and see if the garbage collector will cleanup the object.

So whatever is holding onto our object could be causing the leak, therefore we could try to remove the link at the appropriate time, then re-observe to verify its status.

There are many functions available for SOS.dll. For a complete list of functions please visit the MSDN site.

WinForms objects are embeddable in WPF applications and vice versa. To do so, you simply create the appropriate “host”, then place the controls you want in the host as the child. If you want more than one, you can just create a container like a Panel and add any children as children to the Panel.

How To Embed WinForms in WPF

First, you’ll need to add references to your project. In your WPF application you’ll need references to System.Windows.Forms. So check for it in the references under .NET. Additionally, if you are using a third party library like Infragistics for the controls you’ll need to right click on your project, select Properties, and verify that you are NOT using a Client Profile under your .NET framework version. Client Profiles are great for applications running only on local machines because they omit certain needless libraries pertaining to web code and servers. However, some third party libraries may link to those libraries and so you’ll need them in order to build your project. If you import the references for whatever third party controls but notice they are missing or namespaces won’t resolve, it’s because you are probably using the wrong .NET version or a Client Profile.

Once you are ready you can simply type the following:

WindowsFormsHost host = new WindowsFormsHost();
host.child = someControl;
// Add the host object to whatever your page happens to be
myWindowGrid.Children.Add(host);

Hosting a WinForms control in WPF

You should then be able to access the WinForms control and have programmatic access to all its fields, properties and methods as though it were a WinForms application.

Some Caveats

Namespace Conflicts

If you are trying to replace a WPF control with a WinForms control you should be aware of some gotchas. You will invariably run into namespace conflicts. When you hover the mouse over an object or method in VS2010 it will show you the return type of the object. Notice that many controls share a common name, however in WPF they are in System.Windows.Controls and in WinForms they are in System.Windows.Forms. Similarly, attributes and helpers in WPF tend to be in System.Media (like Colors, etc) but WinForms may be in System.Drawing. You’ll have to be explicit when talking about the type, especially since an event or attribute of a WPF control may not be compatible with a WinForms control (like Colors from styles and Points from MouseEvents).

Marshaling Data on the UI

As you may or may not know, you cannot update an object on a different thread than the one it which it was created. This is true of both WPF and WinForms, but the method by which you perform this marshaling is different. In WPF you perform an operation like this:

 this.myObjects.Dispatcher.Invoke(myDelegateFunction, DispatcherPriority.Normal, myParams); 

where the delegate function signifies the operation that will modify myObject. This simply tells .NET to perform the operation on a compatible thread when it is able to. The Priority specifies how quickly this can be done. You can find details on which priorities to specify on Microsoft’s official page on the DispatcherPriority.

Now, the same function can be (and must be) performed in WinForms in a slightly different way.

 if(this.myUIControl.InvokeRequired) this.myUIControl.Invoke(myDelegateFunction, myParams); 

Keep this in mind as you create your app since this will cause crashes if not done correctly. Specifically in Infragistics UltraGrid, this results in random exceptions and a big red X after a couple of updates.

For more details and clarity on Marshaling data, visit this page, which provides an excellent overview on the subject.

Specifically in WPF, we can perform databinding simply by providing a binding target and a binding source. The binding target is the object in which the data belongs and the source is the property which it will be placed (sort of backwards, but basically they refer to the two endpoints). I won’t write an entire article on Databinding but instead point you to MSDN’s official documentation on the subject.

Needless to say Databinding is immensely powerful and greatly simplifies how we as developers deal with code in UI space. Now from the Microsoft example, assume we have a databinding code snippet that looks like this:

 MyData myDataObject = new MyData(DateTime.Now);
  Binding myBinding = new Binding("MyDataProperty");
  myBinding.Source = myDataObject;
  myText.SetBinding(TextBlock.TextProperty, myBinding);

Then if we want to load the data asynchronously we would simply add:

 MyData myDataObject = new MyData(DateTime.Now);
  Binding myBinding = new Binding("MyDataProperty");
  myBinding.Source = myDataObject;
  myText.SetBinding(TextBlock.TextProperty, myBinding);
// Load this asynchronously
myText.IsAsync = true;

Which tells the binding to not wait for the value but instead move on with any other work while it waits for the value to come in. If you want to display a placeholder value, we can set that as well.

 MyData myDataObject = new MyData(DateTime.Now);
  Binding myBinding = new Binding("MyDataProperty");
  myBinding.Source = myDataObject;
  myText.SetBinding(TextBlock.TextProperty, myBinding);
// Load this asynchronously
myText.IsAsync = true;
myText.FallbackValue = "Loading..."

Which will initially display “Loading…” until the value is ready from the bound property. This is useful in situations where you want to load an image which may take a while but want to hold some placeholder image until it is ready (we see in many mobile applications where data loading may be unpredictable and slow).

If you want to load multiple levels of objects, you can create a PriorityBinding object which can contain multiple bindings as above, and set each individual Binding object to be asynchronous and it will load them in order as it gets them. You can find details about this on Microsoft’s PriorityBinding MSDN documentation page.

Lastly, remember that just because a value is asynchronous does not mean it is automatically loaded from a different thread. If you want to ensure that the UI thread is not held up, whichever property you are bound to must have its data dispatched from another thread or launch a thread. This will ensure that retrieving the property will take slightly long and make the UI thread run smooth (user interactions will take precedent).

Generating XML Proxy Objects

Open the VS2010 command prompt available via start->programs->visual studio 2010-> vs2010 command prompt.

Navigate through the DOS prompt to the area containing your .xsd or .xml schema file

You simply run the command:

xsd schemafile.xsd /c

This will create a .cs file contain all the necessary partial class definitions for deserializing any xml file conforming to the schema. Now you are ready to parse any XML file.

Parsing XML through de-serialization

Now you simply de-serialize the object like so:

XmlReader r = new XmlReader(fileName);
// Set any XmlReader settings

ProxyObject o = new XmlSerializer(typeof(ProxyObject)).Deserialize(r) as ProxyObject;

Then all fields, tags, attributes are available in an object model where attributes are object fields and sub elements are arrays in parent objects (you can see the details in the generated .cs).

Consider the following example which performs the map command, which applies a function on every object in a collection and returns a list with the result of each function call. This is accomplished in C# with the Select command.

            IEnumerable<double> myList = new List<double>();
            // Populate the list ...

            // Fills the list with the sqrt of all the values in myList
            IEnumerable<double> sqrtList = myList.Select<double, double>(Math.Sqrt);

You can use this as a short cut way of applying an operation on all the elements in a list. Of course you could do this in a slightly longer way by just iterating over all the elements in the list.

In the following example I’m solving an example of the lagrangian dual form used for classification in an SVM.

// Classify using solver
InteriorPointSolver solver = new InteriorPointSolver();

// Langrangian Dual
int dual = 0;
solver.AddRow("L", out dual);

// Sum Constraint
int linearConstraint = 0;
solver.AddRow("SumConstraint", out linearConstraint);

// Add variables and Lagrangian linear terms
int[] vars = new int[n];
for (int i = 0; i < n; i++)
{
	// Add the variable
	solver.AddVariable("a" + i, out vars[i]);

	// Factor in C upper bounds
	solver.SetBounds(vars[i], 0, C);
}

// Linear constraint must equal 0
solver.SetBounds(linearConstraint, 0, 0);

// Lagrangian Quadratic Terms
for (int i = 0; i < n; i++) { 	solver.SetCoefficient(linearConstraint, vars[i], trainingData[i].output()); 	solver.SetCoefficient(dual, vars[i], 1); 	Parallel.For(0, n, o, (int j) =>
	{
		double coef = trainingData[i].output() * trainingData[j].output() *
			kernel.evaluate(trainingData[i].point(), trainingData[j].point());

		solver.SetCoefficient(dual, -0.5 * coef, vars[i], vars[j]);
	});
}

solver.AddGoal(dual, 0, false);

InteriorPointSolverParams param = new InteriorPointSolverParams();

Essentially all we are doing here is adding all the variables to our constraint optimization problem and asking the solver to minimize. The vars array simply expressing a list of identifier for variables in the constraint problem. You should fire up the Solver Foundation library and give it a shot yourself.

Here are some resources that should make understanding this a bit easier as well. Its the official blog of one of the key developers on the project, specifically the links to tutorial on the quadratic programming solver.

Nathan Brixius’ QP Solver Tutorial

chessgl3d, originally uploaded by dandesousa.

Here is a demo video for my 3d chess game. See the games page for more details.

glutSetWindow(main_window);
initDisplayLists();
...
void main_display()
{
   drawDisplayList();
}

It will work just fine. But if I try to do the same in a display function of the sub window it won’t draw. You need to call whatever init() function you create your models / display lists in AFTER setting the window. For example

glutSetWindow(main_window);
// do stuff

glutSetWindow(sub_window);
initDisplayLists();
...

void sub_display()
{
    drawDisplayList();
}

Hope that helps someone out there!