Silverlight 4 released today, and with it came a new version of the Silverlight Toolkit and several improvements to the DataGrid control.

Silverlight 4

See what’s new for line of business applications in Silverlight 4 in my presentation.  Also for more information about Silverlight 4 you can check out the FAQ.

Get the bits here: https://www.silverlight.net/getstarted/

New Toolkit Release

There is also a new release of the Silverlight Toolkit which you can get here.

What’s New

For all of you who came to MIX, and those who are just interested in what Silverlight 4 has done for business applications, below is the content from my MIX talk. 

The talk was a lot of fun, and my apologies to anyone who got turned away at the door because the room was packed.

Recording

You can find a recording of the talk here: https://live.visitmix.com/MIX10/Sessions/CL08 

Downloads

For those of you who want to follow along at home, here are the files for the demos that I showed in my presentation.

What you’ll need

All demos were done using the free MIX10 Silverlight 4 RC bits and accompanying tools:

These include

• The latest Visual Studio 2010 or Visual Web Developer Express 2010
• Silverlight 4 Tools for Visual Studio 2010
• WCF RIA Services
• Silverlight Toolkit

The installation instructions for all of the above and other SL4 tools can be found here: https://silverlight.net/getstarted/silverlight-4/

Project

You can download the samples and snippets here: https://cid-e7a27f7920b66c3f.office.live.com/self.aspx/Downloads/MIX10%5E_CL08.zip?lc=1033 https://drop.io/MIX10CL08/asset/mix10-cl08-zip

Notes

Building and Running Either the Final or Start Project

1. If you are getting a “Visual Studio Project Sample Loading Error” it is because you need to unblock the zip file.  Directions on how to do that can be found here
2. The dlls for any broken References can be found in the Project’s Lib directory
3. There are a few known issues that you might run into that have been fixed in later bits

Recreating the Project From the Start Folder

1. If your DataSources window is empty, try building
2. The Toolkit dlls are included to allow the sample to run and shouldn’t be used outside of the sample.  The fully supported dlls will be shipping in the next Toolkit drop which ships alongside Silverlight 4 RTW.
3. The designer files for the Toolkit were not included in the project, so the Charting section is likely to not work as smoothly as in the video.  As mentioned when the supported Toolkit is used such issues will not be present.

Slides

You can download the slides here

What we covered:

We covered an huge amount of content but we still didn’t even cover all of the new features for LOB in Silverlight 4.

Displaying data

• WCF .NET RIA Services
• Data Sources Window
• DataGrid Column Editor
• Binding enhancements
• DataGrid enhancements
• DataForm
• Sorting
• Grouping
• Charts

Professional look and feel

• ICommand
• Right-Click
• Context Menu *
• Implicit Styles
• Theme switching *
• Mouse wheel support in list controls

Getting user input

• Webcam
• Drag & Drop

Validating user input

• INotifyDataErrorInfo
• Cross-field Validation
• Async Validation

Saving data and sharing it

• Clipboard
• Printing

* Coming in the next drop of the Toolkit

As promised, here are the files for the demos that I showed in my presentations.

All demos were done on the MIX’09 Silverlight Beta bits and accompanying tools:

• VS 2008 SP1
• Sql Express 2008
• .NET RIA Services March '09 Preview
• Silverlight 3 Beta

WUX 303: Building Data-Driven RIAs with Microsoft ASP.NET and Microsoft Silverlight

What we covered:

• Navigation, browser integration, permalinks
• Domain methods, filtering, paging, grouping, sorting
• Adding validation metadata
• Windows Authentication
• Writing a different view in ASP.Net and SEO

Watch It: (Right now it is restricted to Tech Ed attendees)

https://www.msteched.com/online/view.aspx?tid=ff4f56fc-ff74-4a68-90a8-33c69b0acecc

Files:

WUX 308: Delivering Rich User Experiences for Business Applications with Microsoft Silverlight 3

What we covered:

• Customizing the DataGrid: TemplateColumns, Row Details, events in template columns
• Charts
• Custimizing the DataForm: Using the Display attribute, the Display / Edit templates
• Writing a custom cross-field validation method
• Export to Excel
• DataGrid Copy / Paste with Excel
• Going out of browser

Watch It: (Right now it is restricted to Tech Ed attendees)

https://www.msteched.com/online/view.aspx?tid=b35f4684-54b2-4da5-9a70-663f79dd9ab7 

Files:

Note: If you get a reference error for the Activity control, re-add the dll that is included in the zip.

Enjoy!

Today we are releasing an updated DataGrid that contains almost 30 fixes to the top issues that we heard, including:

• Rows containing focus no longer disappear when the ItemsSource changes
• ComboBox and other controls opening a popup now work as expected when set as cell content 
• DataGrid Selection is preserved when sorting
• Buttons outside the DataGrid work as expected when they are clicked while the DataGrid is in editing mode
• Improved FrozenColumn behavior
• Improved cell currency
• SelectedItem is updated before the CurrentCellChanged event is raised
• Many more...

For the full list of fixes check out this post by Brian Braeckel one of our DataGrid developers.

Breaking Changes

As a result of these fixes there are several behavioral breaking changes that you should consider before upgrading:

1. FrozenColumnCount now takes hidden columns into account.  Previously, only the first columns with Visibility set to Visible were included in the range of frozen columns.  A column with Visibility set to Collapsed can now be considered frozen even though it isn’t visible.  This is to ensure that a column’s DisplayIndex corresponds with the DataGrid’s FrozenColumnCount (i.e. if FrozenColumnCount == 3, columns with DisplayIndex < 3 are considered frozen).
2. The DataGrid’s current cell is now kept in sync with an ICollectionView’s notion of currency.  Moving the current position or changing the current item of an ICollectionView will now move the current cell and selected item of a DataGrid, and vice versa.  For this to work, the DataGrid’s ItemsSource must be set to a collection that fully implements ICollectionView.
3. A developer can now programmatically reorder a non-frozen column to the frozen column range (and vice versa) by changing a column’s DisplayIndex.  The DataGrid used to throw an exception in these cases.  An end-user, however, is still unable to do this through the UI by dragging column headers.

Installation Instructions

Visit the Silverlight 2 DataGrid December 2008 Release download page and follow the installation instructions carefully. 

In order to use the new DataGrid you need to do all of the following:

1. Close all instances of Microsoft Visual Studio.
2. Delete all cached toolbox items by removing all files beginning with "toolbox" from %LocalAppData%\Microsoft\VisualStudio\9.0.
   • On Microsoft Windows XP, %LocalAppData% is Documents and Settings\UserName\Local Settings\Application Data.
   • On Microsoft Windows Vista, %LocalAppData% is Users\UserName\AppData\Local.
3. Replace the following assemblies with the ones contained in the package in the link above:
   • %ProgramFiles%\Microsoft SDKs\Silverlight\v2.0\Libraries\Client\System.Windows.Controls.Data.dll
   • %ProgramFiles%\Microsoft SDKs\Silverlight\v2.0\Libraries\Client\System.Windows.Controls.Data.Design.dll
4. For any existing projects, delete the reference to System.Windows.Controls.Data.dll and then re-add the reference.

We hope you enjoy the update and we look forward to bringing great new things to future versions of the DataGrid.

Freezing columns is just one of the many things you can do with the Silverlight DataGrid. Read more about the features that the Silverlight 2 DataGrid has to offer...

Freezing Columns

Have you ever been working with a large enough number of columns that you get horizontal scrolling, but you want some of the columns to not scroll?  Think of a column such as Employee Name that you want to remain visible while you scroll through ten weeks of sales data.  You might want to see which employee had the best sales for week 4.  Since the Employee column is on the far left, any amount of scrolling causes it to scroll out of view, that is unless you freeze it.  This causes it to not scroll and always be visible putting your other data in context.

To freeze columns, you simply set the FrozenColumnCount property on the DataGrid to the number of columns you want to freeze.  For instance, to freeze the Employee column pictured above, you would write:

C#

employeeSalesGrid.FrozenColumnCount = 1;

VB

EmployeeSalesGrid.FrozenColumnCount = 1

IsFrozen

If you are programmatically working with a column and want to know if it is frozen or not, you can check the IsFrozen property on the Column.  This is a readonly property that will let you know if the column you are working with is frozen.

DataGrid breaking changes

DisplayMemberBinding renamed to Binding

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

DisplayMemberBinding wasn’t an ideal name, but we used it because WPF has some precedence with it.  This breaks down in scenarios where there is a separate Binding for display like in ComboBox scenarios since our Binding is actually the property field binding as opposed to the display binding.

Fix Required

Users using DataGridBoundColumn will need to change DisplayMemberBinding to Binding.

Beta 2

[Xaml]

<data:DataGridTextColumn DisplayMemberBinding="{Binding FirstName}" />

RTM

[Xaml]

<data:DataGridTextColumn Binding="{Binding FirstName}" />

DataGrid has VSM support

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

The DataGrid now supports the Visual State Manager.

Fix Required

Custom DataGrid templates need to be updated.  The new templates can be found at: https://msdn.microsoft.com/library/cc278066(vs.95).aspx

IEditableObject moved to System.ComponentModel namespace

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

In the full framework IEditableObject is part of the System.ComponentModel namespace and it is located in System.dll  For Silverlight, it was temporarily in the System.Windows.Controls.Data.dll under the System.Windows.Controls namespace.  It now  matches the full framework.

Fix Required

Users using IEditableObject need to update the namespace.

Beta 2

[c#]

using System.Windows.Controls;

RTM

[c#]

using System.ComponentModel;

SelectionChanged event changed from EventHandler to SelectionChangedEventHandler

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

Using SelectionChangedEventHandler allows the user to access OldItems and NewItems.

Fix Required

The signature for the SelectionChanged event handler needs to be updated.

Beta 2

[c#]

void SelectionChanged(object sender, EventArgs e)
{

}

RTM

[c#]

void SelectionChanged(object sender, SelectionChangedEventArgs e)
{

}

DataGridHeaders enum renamed to DataGridHeadersVisibility

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

DataGridHeadersVisibility is a better indication of what the enum is.

Fix Required

DataGridHeaders -> DataGridHeadersVisibility.

Beta 2

[c#]

dataGrid.HeadersVisibility = DataGridHeaders.Column;

RTM

[c#]

dataGrid.HeadersVisibility = DataGridHeadersVisibility.Column;

DataGridAutoGeneratingColumnEventArgs change

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

The PropertyInfo of DataGridAutoGeneratingColumnEventArgs was changed to PropertyName and PropertyType.

Fix Required

Update to use PropertyName and PropertyType.

Beta 2

[c#]

string name = e.Property.Name;
Type type = e.Property.Type;

RTM

[c#]

string name = e.PropertyName;
Type type = e.PropertyType;

DataGridColumn GenerateElement and GenerateEditingElement now take in the cell

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

GenerateElement and GenerateEditingElement now provide the containing cell

Fix Required

Update signature.

Beta 2

[c#]

protected override FrameworkElement GenerateEditingElement(object dataItem)
{

}

protected override FrameworkElement GenerateElement(object dataItem)
{ 

}

RTM

[c#]

protected override FrameworkElement GenerateEditingElement(DataGridCell cell, object dataItem)
{

}

protected override FrameworkElement GenerateElement(DataGridCell cell, object dataItem)
{ 

}

DataGridColumnReorderingEventArgs changed

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

The following modifications were made to the DataGridColumnReorderingEventArgs:

Old:

public object DragIndicatorContent { get; set}
public FrameworkElement DropLocationIndicator { get; set}

New:

public Control DragIndicator { get; set}
public Control DropLocationIndicator { get; set}

Fix Required

Update to use DragIndicator.

Beta 2

[c#]

object dragIndicator = e.DragIndicatorContent;
FrameworkElement dropIndicator = e.DropLocationIndicator;

RTM

[c#]

Control dragIndicator = e.DragIndicator;
Control type = e.DropLocationIndicator;

DataGrid.CancelingEdit and DataGrid.CommittingEdit events removed

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

Explicit Binding is required to implement these 2 events correctly.  Since the Silverlight Binding does not support explicit Bindings, these events were removed.  They will be resurrected when explicit Binding is supported.

Fix Required

The DataGrid.CancelingEdit and the DataGrid.CommittingEdit events can no longer be used.  It is recommended that you use IEditableObject to track when a commit has occurred.

DataGrid.DataError event removed

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

The concept of a DataError event was taken from Winforms.  This does not fit well into the WPF model so the event was removed.

Fix Required

The DataGrid.DataError event can no longer be used.

DataGridColumn.Header no longer supports visuals

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

Visuals cannot be duplicated so they cannot be used for the Header property due to column reordering.

Fix Required

To put visuals in column headers, users will need to use the header's ContentTemplate to include the visual instead of setting it as the Header.

Beta 2

[Xaml]

<data:DataGridTextColumn DisplayMemberBinding="{Binding FirstName}">
    <data:DataGridTextColumn.Header>
        <Button Content="hello" />
    </data:DataGridTextColumn.Header>
</data:DataGridTextColumn>

RTM

[Xaml]

<data:DataGridTextColumn Binding="{Binding LastName}" Header="hello">
    <data:DataGridTextColumn.HeaderStyle>
        <Style TargetType="dataprimitives:DataGridColumnHeader">
            <Setter Property="ContentTemplate">
                <Setter.Value>
                    <DataTemplate>
                        <Button Content="{Binding}" />
                    </DataTemplate>
                </Setter.Value>
            </Setter>
        </Style>
    </data:DataGridTextColumn.HeaderStyle>
</data:DataGridTextColumn>

Root element of DataGridRow changed from Grid to DataGridFrozenGrid

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

DataGridFrozenGrid derives from Grid and it contains an IsFrozen attached property.  Users can use IsFrozen to specify parts of the Row that are frozen

Fix Required

Custom DataGridRow templates need to use DataGridFrozenGrid as the root element instead of Grid.

Gridline renamed to GridLine

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

Gridline would be appropriate if it was a word.  MS Word says it is, but the dictionary says it’s not.  WPF has precedence with GridLine so we went with that.

Fix Required

All instances of Gridline need to be renamed to GridLine.

Beta 2

[c#]

dataGrid.GridlinesVisibility = DataGridGridlinesVisibility.All;

RTM

[c#]

dataGrid.GridLinesVisibility = DataGridGridLinesVisibility.All;

Template only controls moved to primitives namespace

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

These types moved from the System.Windows.Controls namespace to the System.Windows.Controls.Primitives namespace:

• DataGridCellsPresenter
• DataGridColumnHeadersPresenter
• DataGridDetailsPresenter
• DataGridRowsPresenter
• DataGridColumnHeader
• DataGridRowHeader

Fix Required

The types above need to be referenced using the System.Windows.Controls.Primitives namespace.

DataGridCheckBoxColumn.Content was removed

Who Is Affected: Silverlight 2 Beta 2 managed applications that use the DataGrid.

Summary

The Content property was not useful for mainline scenarios so it was removed.

Fix Required

The DataGridCheckBoxColumn.Content property can no longer be used.  In rare scenarios where it is needed, users can template the CheckBox through ElementStyle and EditingElementStyle

In celebration of its release, all of the previous walkthroughs have been updated to work with the RTW bits, and new walkthroughs are on their way. 

Also, if you have never used the Silverlight DataGrid before, here is a good place to start.

What's New?

You might be wondering what has changed since Beta 2:

	Accessibility: One of the biggest features that we have added since Beta 2 is the addition of an automation peer framework which allows the DataGrid to work well with screen readers.
	Support for the VSM: The Visual State Manager (VSM) is a tool that allows designers to customize how a control looks in various states, and the animations used to switch between these states. Read more about the Visual State Manager...
	Performance, Performance, Performance: We have done a lot in this area to try to get the DataGrid running as fast as possible. If the last time you used it was in Beta 1 or even Beta 2, you should definitely take another look.
	API Improvements: Based on your feedback, we took another pass through the API in an effort to simplify it more and give you more control over the DataGrid. Read about the Breaking Changes since Beta 2...
	Great New Look: The entire framework got a visual upgrade since Beta 2, and the DataGrid is no exception.

What's Else Can It Do?

For those of you new to the Silverlight DataGrid, here is a quick rundown of what it could already do:

	Auto-sizing: Everything in the DataGrid can be auto-sized.  That includes the DataGrid itself, Columns, Rows, Headers, and Row Details meaning that you do not have to worry about the size of what you are putting into the DataGrid, it will grow to accommodate it. Read more about Auto-sizing...
	Sorting: Any time you bind the DataGrid to a collection that implements IList such as a List<T> you now get sorting for free.  Even better, sorting isn't limited to a single column, but end users can sort by multiple columns by holding Shift and clicking on additional column headers. As an RTM improvement, you can also choose which columns you want to support sorting. Read more about Sorting...
	Column Reordering: End users can reorder columns at runtime just by dragging a column's header, and developers can control not only the order, but the appearance of the reordering UI as well as the behavior.
	Column Resizing: Just like reordering, and sorting, end users can control the size of columns at runtime.
	Frozen Columns: This is a semi-advanced feature, but once you know about it you'll be surprised at how useful it can be.  A frozen column does not scroll horizontally but rather is "frozen" in place.  This is the same as the Freeze Column feature in Excel. Read more about Freezing Columns...
	Row Details: This feature is one that we are very excited about.  In short, it is an area in each row that allows you to put any UI you want that spans all columns.  This could be anything from form-based entry to the contents of a column that would do better if given more space.
	Auto-Generation of Columns: A great feature to help get an application up and running quickly, auto-generation of columns creates a column for every property on the item that it is bound to.
	Highly Customizable Visuals: The look of the Silverlight 2 DataGrid has been improved, but it doesn't mean that you can't change it.  Every aspect of the DataGrid's appearance can be retemplated to create a drastically different looking DataGrid that maintains all of the great features listed here. Read more about Customizing Control Visuals...
	Editable: The DataGrid control allows your users to edit the data that it is bound to.  One benefit of the Silverlight DataGrid is that it gives you control over what control is used to display the data for each cell, and what control is used to edit the data for each cell even if they are different.  The customization is easy, and it handles switching between the two when the user wants to go into edit mode.
	Scrollable: Another benefit that the DataGrid provides is the ability to scroll through long lists of data.  The DataGrid does a lot behind the scenes to make this experience as smooth as possible for your users even when you have a large number of rows.  You can also scroll columns and items into view to make sure that an item you want to highlight to your user is visible on screen.
	Multi-Selection: The DataGrid provides both single as well as extended selection modes, allowing you to choose if you want users to be able to select more than one row at a time
	Built-in Column Types: Out of the box you can use both Text columns as well as CheckBox columns, and creating your own column types is easy. Read more about using the Built-in Column Types: In XAML In Code Behind at Runtime
	Template Column: In addition to the built-in column types, the template column gives you complete control of what to show during display and edit modes. Read more about using the Template Column: In XAML In Code Behind at Runtime

Multi-column Sorting

One of the most requested features in Beta 1 was a way to sort the data contained in the DataGrid.  In fact it was so desired that clever developers such as Matt Berseth simply created their own implementation.  Fortunately, you no longer have to put much work into getting this functionality out of the box. 

To get sorting functionality in your DataGrid you will need to perform the following steps:

1. Make sure that the collection that you use as the DataGrid's ItemsSource implements IList.  Common implementations are List<T> and ObservableCollection<T>. 
2. That's it, you don't need to do anything else

Why this odd requirement?  Under the covers, when a DataGrid is data bound to a collection that implements IList, it creates an internal ListCollectionView to provide the sorting functionality.  Since CollectionViews can handle multiple levels of sorting, the DataGrid also possesses this functionality and exposes it by allowing your users to click on multiple headers while holding the Shift key.

Here is the DataGrid showing off multi-column sorting:

Customizing Sorting

Alternatively if you want more control over how the sorting algorithm is performed, you can implement the ICollectionView interface currently found in System.Windows.Controls.Data.  The DataGrid knows that when it is bound to an implementation of ICollectionView that it should delegate all sorting to it, listening to its SortDescriptions collection and visually displaying the sorting status of the CollectionView.  Additionally by using an external CollectionView, you can have multiple controls share the same sort order.

Turning Off Sorting

It is easy to get sorting out of the box, but you might not want to allow your DataGrid or a particular column to be sorted by your user.  To turn this off, use DataGrid's CanUserSortColumns property to turn on or off all sorting at the DataGrid level, or use DataGridColumn's CanUserSort to turn on or off sorting for a particular column.

C#

dataGrid1.CanUserSortColumns = false;

unsortableColumn.CanUserSort = false;

VB

DataGrid1.CanUserSortColumns = False

UnsortableColumn.CanUserSort = False

Choosing Which Property to Sort By

Sometimes the property that your column is bound to is not always the one that you want it to sort by.  Normally a column sorts by the property that it is bound to through the Binding property.  However, if you look at the Template Column there is no Binding property, meaning that the DataGrid has no idea of how to sort the data if you were to click on that column's header.  To give the DataGrid that information, you can use a property found on all column types called SortMemberPath.  This property allows you to specify a path to the property on the data item that you want that particular column to sort by.  Now if you create a template column that uses a DatePicker to allow your user to select a date instead of the standard TextBox, you can still provide sorting for that column by setting the SortMemberPath.

C#

datePickerColumn.SortMemberPath = "Birthday";

VB

DatePickerColumn.SortMemberPath = "Birthday"

Notice that since SortMemberPath is on DataGridColumn, you can use this beyond just template columns and can actually have a column bound to one property, but sort based on another property.  This is a much less common scenario, but becomes useful when working with types that normally don't support sorting such as Colors or Images.

Sorting UI Cues

In the picture above you can see that each sorted column has an arrow in its header indicating if it is sorted ascending or descending.  It also has a subtle animation when switching between the two.  If you want to customize how this looks or behaves, the easiest way to do this is to use the Visual State Manager in Blend.  Otherwise, you can manually override the default DataGridColumnHeader template using the DataGrid.ColumnHeaderStyle property.  The template contains two storyboards, one named "SortAscending" and the other named "SortDescending".  These two storyboards are ran by the DataGrid when a column is sorted ascending or descending.  Finally there is a third storyboard called "Unsorted" that is ran when the data is no longer being sorted by that column and can be used to clean up any UI that you used to display sort status.

Auto-sizing the DataGrid

The Silverlight 2 DataGrid is auto-sized by default.  This means that if you put it in a Canvas or a StackPanel and don't specify a Height or Width, or a MaxHeight or MaxWidth, you will get a DataGrid that is sized to its contents. 

Warning: This can be dangerous however if you are working with a large (1000+ item) collection as the ItemsSource.  Since the DataGrid will grow to the size of its contents, and will create objects for each cell that it can show based on its height, it will literally create thousands of objects to display all of the data.  As you can guess this has app performance implications so you should avoid the combination of an auto-sized DataGrid and a large amount of data to display.  This isn't an issue of course if you specify a Height or MaxHeight for the DataGrid, or put it in a container such as a Grid that provides it with a size.

Since the default size for the DataGrid is auto you won't have write any code to get auto-sizing behavior, but if you do give the DataGrid a height or width, and then want to switch it back to auto-size at runtime, simply set that value to double.NaN which is WPF and Silverlight's way of having a FrameworkElement auto-size itself.

C#

dataGrid1.Height = double.NaN;

VB

DataGrid1.Height = Double.NaN

Auto-sizing Columns and Rows

In addition to the DataGrid auto-sizing itself, Columns and Rows are also auto-sized by default.  Like the DataGrid, rows are auto-sized in the same manner by setting the value to double.NaN while columns on the other hand are done slightly differetly.  If you have ever worked with the Grid control, you might have noticed that the Width property of its ColumnDefinitions is not of type double, but rather a struct called GridLength.  The reason for this is that unlike a FrameworkElement's Width or Height properties which only have the possible values of Auto or a numeric value, a ColumnDefinition's Width can be set to a numeric value, Auto, or Star.  DataGridColumn.Width follows a similar pattern where instead of being of type double, it is of type DataGridLength.

The possible values for DataGridLenth are:

• Auto: This auto-sizes the column or row to grow to the size of the largest header or cell.  It is effectively a combination of the other two auto-size modes.  You might notice as you scroll when a new larger cell is encountered that this value increases.  It will however not decrease once that item is scrolled out of view.
• SizeToHeader: This auto-sizes the column or row the grow to the size of the header.  This will ignore the contents of the cells when determining its size and will not change unless the size of the header changes.
• SizeToCells: This auto-sizes the column or row to grow to the size of the largest visible cell.  It will ignore the header cell in this calculation.  You might notice as you scroll when a new larger cell is encountered that this value increases.  It will however not decrease once that item is scrolled out of view.
• Numeric: Unlike the others this is not an enum value, but rather simply a numeric value such as 100.  This mode will behave the same way that Beta 1 did, however setting it in code behind is slightly different.

Setting these in XAML is straight forward other than that unfortunately just like GridLength, there is no Intellisense for the enum values since a number is a valid entry as well.

XAML

<data:DataGrid x:Name="dataGrid1" AutoGenerateColumns="False">
    <data:DataGrid.Columns>
        <data:DataGridTextColumn Binding="{Binding}" 
            Width="Auto" Header="Auto"/>
        <data:DataGridTextColumn Binding="{Binding}" 
            Width="SizeToHeader" Header="Size to Header"/>
        <data:DataGridTextColumn Binding="{Binding}" 
            Width="SizeToCells" Header="Size to Cells"/>
        <data:DataGridTextColumn Binding="{Binding}" 
            Width="50" Header="Numeric"/>
    </data:DataGrid.Columns>
</data:DataGrid>

If you were to run the code above and give it a data source it would look something like this:

As you can see, once you know the possible enum values, setting it in XAML is fairly simple, and the Beta 1 code of Width="100" just works.  When you are working in code behind however things get slightly more tricky.

If you wanted to write code to do the same as above:

C#

DataGrid dataGrid1 = new DataGrid();
dataGrid1.AutoGenerateColumns = false;

DataGridTextColumn col1 = new DataGridTextColumn();
col1.Binding = new Binding();
col1.Width = DataGridLength.Auto;
col1.Header = "Auto";
dataGrid1.Columns.Add(col1);
DataGridTextColumn col2 = new DataGridTextColumn();
col2.Binding = new Binding();
col2.Width = DataGridLength.SizeToHeader;
col2.Header = "Size to Header";
dataGrid1.Columns.Add(col2);
DataGridTextColumn col3 = new DataGridTextColumn();
col3.Binding = new Binding();
col3.Width = DataGridLength.SizeToCells;
col3.Header = "Size to Cells";
dataGrid1.Columns.Add(col3);
DataGridTextColumn col4 = new DataGridTextColumn();
col4.Binding = new Binding();
col4.Width = new DataGridLength(50);
col4.Header = "Numeric";
dataGrid1.Columns.Add(col4);

dataGrid1.ItemsSource = "a b c d e f g h i j".Split();
LayoutRoot.Children.Add(dataGrid1);

VB

Dim dataGrid1 As New DataGrid
dataGrid1.AutoGenerateColumns = False

Dim col1 As New DataGridTextColumn
col1.Binding = New Binding
col1.Width = DataGridLength.Auto
col1.Header = "Auto"
dataGrid1.Columns.Add(col1)
Dim col2 As New DataGridTextColumn
col2.Binding = New Binding
col2.Width = DataGridLength.SizeToHeader
col2.Header = "Size to Header"
dataGrid1.Columns.Add(col2)
Dim col3 = New DataGridTextColumn
col3.Binding = New Binding
col3.Width = DataGridLength.SizeToCells
col3.Header = "Size to Cells"
dataGrid1.Columns.Add(col3)
Dim col4 = New DataGridTextColumn
col4.Binding = New Binding
col4.Width = New DataGridLength(50)
col4.Header = "Numeric"
dataGrid1.Columns.Add(col4)

dataGrid1.ItemsSource = "a b c d e f g h i j".Split()
LayoutRoot.Children.Add(dataGrid1)

The interesting line above is where the Numeric column's width is set to 50.  There are two ways to do this.  If you are working with doubles, you can create a new GridLength that takes a double in its constructor.  This is the most common and the easiest way to do it.  If however you are working with strings such as a value in a TextBox, you can use the ConvertFrom method on DataGridLengthConverter which takes an object and returns a GridLength.

New Features Overview

• Auto-sizing: Unlike Beta 1 when you had to specify widths and heights yourself, everything in the DataGrid now can be auto-sized.  That includes the DataGrid itself, Columns, Rows, Headers, and Row Details.
• Sorting: Now any time you bind the DataGrid to a collection that implements IList such as a List<T> you now get sorting for free.  Even better sorting isn't limited to a single column, but end users can sort by multiple columns by holding Ctrl and clicking on additional column headers.
• Column Reordering: In Beta 1 the order of columns could be set programmatically, but now in Beta 2 we have extended this capability to the end user, where column reordering can be performed at runtime just by dragging a column's header.
• Frozen Columns: This is a semi-advanced feature, but once you know about it you'll be surprised at how useful it can be.  A frozen column does not scroll horizontally but rather is "frozen" in place.  This is the same as the Freeze Column feature in Excel.
• Programmatic Scrolling: Now you can scroll columns and items into view to make sure that an item you want to highlight to your user is visible on screen.
• Performance Enhancements: One of the big points of feedback we got in Beta 1 was vertical scrolling speed needed to be faster.  We've made some improvements in this space to speed things up.
• API Improvements: These are changes that we made to existing API's to try to make using the DataGrid easier.  Hopefully they are all for the better, and we would love to hear your feedback if you think that something could be easier.