Component Insider

Using Xceed DataGrid for Silverlight in SharePoint 2010

Odi [Xceed] — Thu, 16 Dec 2010 18:46:00 GMT

This is a guest blog post written by Johnny Tordgeman from Guardian Information Systems. He has his own blog, check it out.

---

Hey everyone, my name is Johnny Tordgeman and I will be posting some guest posts here on SharePoint 2010 integration with Xceed DataGrid for Silverlight. I would like to thank Odi for giving me the opportunity to show everyone how easy it is to combine Xceed DataGrid for Silverlight with the SharePoint 2010 platform.

In this first post I’m going to show the basic connection of a SharePoint list with the datagrid by building a simple web part that will show all the fields of the default Tasks list using Xceed’s datagrid.

To keep things simple, I will only concentrate on the Silverlight portion for this web part and display it using SharePoint’s Silverlight web part, but on a later post we will add a custom web part to render our Silverlight application and pass parameters such as the list we want to show from SharePoint.

[Ed. note: If you are going to try to run the Silverlight web part on your development machine, see the note at the end of this post]

To get started, create a new Silverlight project and name it SLSPDataGrid then uncheck the “Host the Silverlight application in a new Web site” box and click OK.

To make this example as simple as possible we will use SharePoint’s REST web service to get the data from our Tasks list.

Right click on the project name and select “Add Service Reference”. You will get the following screen:

In the address box type in the address of your SharePoint site and add "/_vti_bin/ListData.svc" to it.

For example, if your site is http://jtordgeman the address box should read: http://jtordgeman/_vti_bin/ListData.svc. [Ed. note: If you have trouble accessing this .svc file, see this solution: http://blog.hompus.nl/2010/03/26/could-not-load-type-idataserviceupdateprovider-when-using-rest-with-sharepoint-2010/]

Change the namespace to SharePointContext and click OK.

Next, let’s add the Xceed datagrid dll to our project. Right click on "References" and choose "Add Reference", then click on “Browse” tab and navigate to where Xceed is installed. Click on "Bin" and then add "Xceed.Silverlight.DataGrid.v1.0.dll".

Your solution should look similar to this:

In MainPage.xaml add the following line to the UserControl declaration:

xmlns:sldg="http://schemas.xceed.com/silverlight/xaml/datagrid"

Now add the control under LayoutRoot using the sldg namespace. Your MainPage.xaml file should look like this:

We have added the control to our UI layer, so all we need now is to set its data. Switch to MainPage.xaml.cs file and following using statements:

using System.Data.Services.Client;
using SLSPDataGrid.SharePointContext;

Inside the MainPage constructor register the Loaded event by typing the following line under InitializeComponent():

this.Loaded += new RoutedEventHandler(MainPage_Loaded);

Finally, type the following method to your code:

void MainPage_Loaded(object sender, RoutedEventArgs e)
{
SharePointContext.HomeDataContext _context = new SharePointContext.HomeDataContext(new Uri("http://jtordgeman/_vti_bin/ListData.svc/", UriKind.Absolute));

this.DataContext = _context.Tasks.IncludeTotalCount();
}

A few things to note:

1) Your context name might be different then mine (HomeDataContext). It’s best to type SharePointContext. And check in the intellisense for your context name.
2) The url that you pass to the context instance must be the same one you typed when we added the service reference.

Build your project, upload the .xap file to a dir in your SharePoint site and add the Silverlight web part to a page. Provide the web part with the address for your xap file and… you’re all done! You should see all the fields of the task list in your Xceed datagrid, with smooth scrolling, and automatic background data virtualization (in case you have hundreds or thousands of tasks) already enabled.

Please feel free to contact me on Twitter (@jtordgeman) or on my blog with any question you might have, and I’ll see you on the next post :)

---

Note: You will need to add a clientaccesspolicy.xml or crossdomain.xml file to the root of your SharePoint website if you don't use the Silverlight web part on the same server as SharePoint (for example if SharePoint is hosted on http://mysharepoint.com and you query it from a silverlight app hosted on http://mysharepoint2.com).

Datagrid’s very capable little brother.

Odi [Xceed] — Mon, 06 Dec 2010 16:54:00 GMT

Datagrids are very flexible controls. They often contain a lot of information and provide tools to visually organize this information and sift through it.

Before WPF/Silverlight, you could not create a data template for items in a listbox or other data controls. It was not feasible to attempt to present tabular data (e.g., name, age, description, photo) beautifully in a listbox item. Datagrids and listviews were therefore a handy solution.

Now that you can template the elements of a listbox to incorporate the key information you want to display, the lowly listbox has gained superhero data visualization powers.

That’s where Xceed comes in. As datagrid experts, we were naturally concerned with the trends we have been observing in the industry. Trends towards simpler interfaces, the multiplication of smaller screens, and touch interfaces. We saw not only that datagrids would have to adapt but that the listbox has gained in importance in a world where developers are simplifying the experience and hiding extra data until the end-user specifically requests to see it.

The listbox is a wonderful control not only for desktop experiences, but for Windows Phone 7 and mobile devices. We just have a tough time visualizing end users using a datagrid on a 4” screen. Columns and rows, and editing data within the cells of those columns and rows, don’t seem to play well there.

Some say that listboxes are the new datagrids. Here's one blog post that had given us some food for thought.

So we set out to improve the listbox. Today, we launched Xceed Ultimate ListBox for Silverlight.

It is the first control Xceed has made that mimics an existing API (the one for the standard Silverlight listbox) instead of providing an entirely new one. We wanted as little of a learning curve as possible. It is also the first control Xceed has ever launched at such a low price point ($89 per developer). We want the barrier to entry to be as low as possible as well.

Why a better listbox?

In the world of Silverlight clients, whether desktop ones or for mobile devices, a lot of the data loaded into listboxes comes over the air or wire. Listboxes aren’t just used to display 5-10 items from an array of objects in memory, they are also used to display hundreds or sometimes thousands of items from remote data sources.

But as the Silverlight listbox works today, it either has to load all of those remote items first, causing the end user to wait while that happens, or it will load only some of the data first, and load it on an as-needed basis. The latter technique is called data virtualization, or paging.

In practically all the implementations we’ve seen, listboxes implementing data virtualization always have usability problems. Some of them make the end user click a “load more” button and wait every time they want more data. Others load the data automatically when you reach the bottom, but still do so only just-in-time and make the end user wait. Most of them have scrollbar thumbs that jump around.

What if the listbox was built with the idea that end users should be able to have an effortless and snappy experience when data virtualization is being used, similar to when the entire data source has already been loaded into the listbox? That’s what Xceed has worked on. I want to call it “super data virtualization”, but on the web site it is simply called “advanced background record retrieval”. Here are the innovations we have put into our super data virtualization:

Automatic record retrieval. No “load more” buttons.
Background record retrieval. Listbox never freezes, always responds to end-user’s navigation commands.
Passive pre-fetching. More than what appears in the listbox gets retrieved, but not more than is needed.
Active pre-fetching. When the listbox UI is not scrolling, the listbox actively retrieves more records to fill its cache.
Fluid UI. Without smooth scrolling, the perceived response time to load more data is that of the complete round-trip of request/response to the server. With smooth scrolling animating for about 0.8s and items that fade in when they arrive, the perceived response time begins only after the animation has completed if items still have not arrived.
Discovery-less start up. To avoid scrollbar thumbs jumping around, or to support grouping, a data-virtualized listbox typically would need to know the total row count, number and size of groups, or other information about the data source. Not this listbox, allowing it to start up faster than any other can.
Optimized navigation. The listbox requests data from the data source using relative queries instead of absolute index-based queries. Such queries execute faster on the server so navigating through the listbox is snappier. We know of no other listbox that works this way.
Query grouping and throttling. During scrolling, queries to the server for more data rows are grouped together when possible. This works because queries are asynchronous and are typically obtaining data not currently in view. During heavy scrolling, queries that are no longer needed are canceled, thereby reducing the load on the server as well as the listbox’s own CPU use.

The goal is to provide lightning fast display of remote data in a listbox. See what we’ve accomplished with Netflix’s online catalog of 130,000+ movies thanks to the listbox connected via ODATA / WCF Data Services.

What else does Xceed Ultimate ListBox for Silverlight bring to the table?

Built-in search box, of course it works with the data virtualization.
Completely fluid UI throughout. Slick and fast smooth scrolling, insert/delete items, etc.
6 beautiful themes.
Deep built-in support for WCF Data Services / ODATA and WCF Ria Services.
Complete grouping support. Displays group headers between items in different groups.
Group headers are “sticky” just like with the iOS listbox. They are always visible.
Group navigation (prev/next) and WP7-like pop-up index to jump to specific groups.
Very little learning curve, simply replace your current listbox and turn on new features.

There’s more, see the complete feature list.

We hope you love this new control as much as we do and help us spread the word about it! Tweet it, Facebook it, blog it, show it to colleagues... it's all good!

Thanks,
Odi

Silverlight Datagrid: Magical results

Odi [Xceed] — Thu, 29 Jul 2010 18:06:00 GMT

Xceed has been working for over 1.5 years and has put over 18000 person-hours of work on one single new Silverlight control, so that with only a couple of lines of code, you can achieve some magic.

A bit of history.

At Xceed, we've been creating components and class libraries for Windows developers for 16 years. Our first datagrid control was started 10 years ago. We offered a variety of other UI controls as well, such as charts, treeviews, menus, navigation and docking window controls. Like other component vendors, we created a “collection” or “suite” of many controls. Five years ago, our entire UI controls team began to focus solely on developing datagrid controls.

By putting all our energy exclusively behind datagrids, we felt we could do a better job than by spreading ourselves thin working on many controls. We could elevate datagrids to the next level, and cater to developers who would rather have a great datagrid than a collection of mediocre controls. We would target developers who value quality over quantity.

This move was made when we began developing Xceed DataGrid for WPF. It allowed Xceed to be the first to market with a datagrid for WPF (released January 2007, months to years before the other component vendors had theirs ready). We were not only first, but we had an amazing product that got impressive testimonials. Microsoft even used it in parts of Visual Studio 2010.

Our competitors kept their existing strategy of creating a wide variety of UI controls. Their datagrids received relatively little love. In contrast, with only one product type to think about, we were able to churn out an impressive 39 updates in 3.5 years. Customers were rarely kept waiting for resolutions to issues or new features. Today our WPF datagrid leads in stability and features, and offers perhaps the best user experience of any datagrid on any platform.

So what's new in the datagrid department that’s magical?

If you take a look at the competition's Silverlight datagrids and marketing for them, you'll see a recurring message: everyone claims that their datagrid is fast. "Blazing fast" says one. "The fastest" says another. Some of them are indeed fast, but in order to be fast, they have to load up the entire data source first.

That might be OK for Windows Forms applications accessing a local SQL server, however, this is ~~Sparta~~ Silverlight. Many apps built with Silverlight will be accessing data sources that are somewhere else on the internet, not located on the user’s own computer or on a company’s speedy intranet. Having to wait for hundreds (or thousands) of data rows to be transferred over the internet before your datagrid is functional yields a poor user experience. It also drains server and network resources, and client memory.

Web developers have been facing this challenge for years.

To avoid having to load all the data, Web developers use a pattern called "paging". If you've ever performed a Google search, you are familiar with paging. A Google search often yields thousands or millions of results, but Google only displays the first 10, and then presents you with a paging interface, providing you with “next page” and “previous page” navigation.

Most Silverlight datagrids have adopted paging as their solution to working with remote data sources. You put them into a special “virtual” or “server” mode. That’s where things fall apart.

The fast scrollbar experience disappears, replaced with paging navigation. Clicking on “next page” does nothing until a round trip to the database is completed and the next page of results is delivered. Unlike with Google searches, this can take seconds, and meanwhile the datagrid’s user interface is frozen. These delays are frustrating and reflect upon your entire application.

There’s nothing blazing fast about it.

That might explain why no other Silverlight datagrid currently provides a demo of the datagrid accessing a remote data source. The paging or data virtualization demos all use local or randomly generated data, not data on a server somewhere on the internet.

Now wouldn’t it be great if a datagrid could feel and behave as if all the data was already loaded, even if the data was on a remote server? Using a scrollbar instead of a paging interface? Wouldn’t it be great if we didn’t have to wait every time we navigated forwards or backwards for the remote database to respond?

That’s what Xceed set out to do, and we believe we have achieved this goal. We designed and built an entirely new datagrid built from the ground up with asynchronous data virtualization in mind. We implemented a number of important advances in data virtualization and datagrid user interface behavior that all work together to make browsing and editing remote data feel almost as fast as as working with local data. None of these advances have ever been done in a datagrid up until now.

These advances are, on a high-level:

A Fluid UI that helps mask network lag
An intelligent background record retrieval system
Optimized network communications
Asynchronous editing and validation

Let’s start with the Fluid UI. A Fluid UI is an animated one, where the content it presents is given a real-world feel. When items move in a Fluid UI, they don’t jump to their new position, they animate, with physics-like motion, to their new location. Things happen smoothly.

So how does that help mask network lag? It’s all about perception. Here is the scenario with typical datagrids: the user clicks “line down” or “page down” or “next page”. The datagrid immediately launches a query for more data. When that data comes in, only then does the datagrid update its display by jumping down one line or displaying the next page. The perceived response time is that of the complete round-trip of request/response to the server.

For example, if clicking “next page” takes 1.5s to obtain and display data from the data source, then the perceived waiting time is the entire 1.5s, even if a “loading” animation is displayed somewhere on the grid’s surface to acknowledge the command.

On the other hand, with a Fluid UI, when the user clicks “line down” or “page down”, an animation to the next line or page immediately begins. This animation typically takes about 0.8s to complete. During this time, the end user sees “dummy” data rows animate into view – exactly as expected. The end-user feels that everything is responding and working as expected, even if the dummy data rows have no data in them yet. When the data arrives, it fades in smoothly.

In this scenario, even if the database query (launched at the same time as the animation starts) takes 1.5s to complete, the true perceived waiting time starts only after the animation has completed, and only if the data hasn't arrived by that time. The effective waiting time in the above example is reduced to 0.8s – half the time.

The next advance is the use of an intelligent background record retrieval system. We also call it Asynchronous Data Virtualization, but either way, it’s new in datagrids.

In order to be able to launch database queries for more rows to display without freezing the UI, the data virtualization mechanism has to work in the background. No other Silverlight datagrid does this (actually we believe no other company's datagrid on any platform does this). Without being asynchronous, when data is being accessed from the data source, all UI interaction is halted. That means users can’t click at their pace to move forward a few pages, nor change their mind and scroll in the opposite direction (until a round-trip to the server completes). It feels sluggish.

One Silverlight datagrid has implemented “background loading”, but that only works when you are loading the entire data source into the datagrid, not when getting the data in portions as needed. It also means that while the entire data source is being transferred to the datagrid, the scrollbar thumb is constantly getting smaller, moving up, and the datagrid is slow. Another datagrid has implemented "Stealth Paging" but it offers no advantages whatsoever over regular paging UI except to provide a scrollbar.

Why is Xceed’s background retrieval “intelligent”? Because we have added “passive and active pre-fetching” to the mix.

What is passive pre-fetching? When a typical data virtualizing or paging datagrid first loads up, it queries for the first page of data to display. But why stop there? We know that there are two possible navigation commands an end-user can do. The first is to scroll down or go to the next page. The second is to go to a specific page. In a typical datagrid, if the user scrolls down (or up), it is guaranteed that the end-user will be kept waiting, because the next (or previous) page of data has to be requested from the server.

Why not, when requesting data from the server, ask for a bit more data than we need to display on that first page? Why not ask for an additional few pages, if the overhead of doing so is acceptable? The result is that, when the user starts scrolling down, there is no waiting. When the buffer runs out, a new request is made for more data, again asking for more than the next page.

Active pre-fetching: the icing on the cake.

When the datagrid is idle, meaning the end-user is not performing any actions, the datagrid runs a background task that makes sure that the buffer of pages before and after the one currently being displayed is kept full. If the buffer is nearly empty, why should the datagrid just sit there doing nothing? Doing nothing means that it will be a near certainty that the buffer will run out sooner and the end-user will experience lag.

Active pre-fetching makes the datagrid work harder to preserve the illusion that all the data is actually already loaded. It helps silently query for more data so that the datagrid is more often able to display the previous or next page with absolutely no lag at all.

Optimized network communications.

We’ve also advanced the state of the art in how queries are made to the data source. This comprises 3 innovations:

1. No discovery required: Unlike other data virtualized datagrids, this datagrid does not require knowing the total row count, number and size of groups, or any other information about the data source. This eliminates a sizeable extra query that all other datagrids that support data virtualization require, making the Xceed datagrid load faster than any other.

2. Optimized navigation: The datagrid requests data from the data source using relative queries instead of absolute index-based queries. Such queries execute faster on the server so navigating through the datagrid is snappier. We know of no other datagrid that works this way.

3. Query grouping and throttling: During scrolling, queries to the server for more data rows are grouped together when possible. This works because queries are asynchronous and are typically obtaining data not currently in view. During heavy scrolling, queries that are no longer needed are cancelled, thereby reducing the load on the server as well as the datagrid’s own CPU use.

So to conclude, I’ve talked about 7 techniques (Fluid UI, background data virtualization, passive and active pre-fetching, and three query optimizations) that we’ve applied to the datagrid’s data virtualization that all aim to make our Silverlight datagrid the only one to provide seemingly lightning fast access to remote data. Or put another way, it lets end-users access remote data as fast as local.

For a description of what is actually happening under the hood, see Jenny's blog post.

Odi

Xceed Consulting Wins on WPF gig

Odi [Xceed] — Fri, 11 Dec 2009 15:12:00 GMT

A few months back, Lee Sherry, Senior BI Manager at Microsoft Business Intelligence, contacted our sales director, Charles, about having an app created for the company. Charles understood right away what her needs were and proposed the project to Pierre-Luc (“PL” for short!), Lead Developer for Xceed DataGrid for WPF. Everyone involved with the project knew that the star of the app, our WPF datagrid, would make it easy to deliver the goods in short time!

What Lee wanted was a rich, cutting-edge XAML Browser Application that would let the company’s managers navigate easily through numerous selected reports, filtering, sorting, and grouping their data. But the application had to remain responsive at all times, and Lee wanted an all-purpose solution, one that avoided hard-coded, pre-defined views, which would have limited the flexibility of the application. She also emphasized that it had to work with their existing data structure.

Xceed’s developers met this challenge head on and devised a solution that was a stream-lined XBAP that interfaced with a SQL data source, which ran in Partial Trust. By doing things this way, the less technically savvy users of the software didn’t need to install certificates on their machines. However, this architecture meant using a Windows Communication Foundation (WCF) Web service, which acted as an intermediary between the XBAP and the SQL server. A data paging system was also implemented to fetch the data through the Web service. Of course, our designer team played a big part in the process, creating a gorgeous and compelling user experience!

The application was developed entirely by Xceed, and met Lee’s expectations fully, helping Microsoft reach its objectives and saving the company time and money. After receiving the app, Lee e-mailed the following to Charles: “The Xceed WPF grids allowed us to deliver some fantastic interactive tools to our executives and increase the impact of our information. We are extremely satisfied with the professional support by the entire Xceed team. The Xceed technology is visually striking and works beautifully with our Silverlight and WPF infrastructure.”

Overview of the new v3.2 datagrid for WPF

Odi [Xceed] — Mon, 15 Jun 2009 13:43:00 GMT

Today marks the release of v3.2 of Xceed DataGrid for WPF. This is the 9th major update since the product was first introduced 2.5 years ago. Another one is coming, hot on its heels for August, with smooth scrolling innovations and other UI improvements, but here's what's new in today's release.

- There are now two paid editions of the DatagGrid, the new Standard Edition, and the existing Professional Edition.

- The new Standard Edition is aimed at folks who don’t need a whole lot of advanced features, but would still like to save time and get better results than when using Microsoft’s upcoming datagrid for WPF. The time saved, from the more complete design, abundant data binding options, documentation and helpful Xceed staff should easily outweigh its affordable $300 cost. It also has more features than the Microsoft grid, such as rich grouping support, more cell editors and input validation. Best of all, there’s a built-in instant upgrade path, so if your users eventually want filtering, printing, exporting, field chooser or other features, you can just upgrade and turn those capabilities on, instead of being painted in a corner with a control not designed to do them.

So what’s new in v3.2? For this release, we’ve made getting to your data, and presenting it properly, a lot easier to do.

- First, the datagrid now autodetects foreign keys in your datatables, so now it is easier than ever to display the corresponding values you want to display, instead of IDs. It also works with enumerations. To activate this new feature, just set AutoCreateForeignKeyConfig to True.

- Next, we added support for custom key value mappings. This makes it easy to map any kind of values or objects to fields in your data that represent keys. For example, if your table of employees has an Employee ID integer field representing an employee object, you can easily map that field so that the datagrid uses corresponding employee’s First name and Last name fields formatted as “Last name, First name” as the value to be displayed instead of the integer.

- Next, for users of the powerful Data Virtualization feature – which in v3.2 now also supports grouping – if your data source implements IQueriable, and LINQ does, we’ve made providing data to the datagrid a snap. You no longer have to handle a bunch of events to provide the datagrid with data, and you no longer have to worry about how the datagrid is sorted or grouped. Doing so was tiresome, now it’s code free.

- We also completed full support for the Entity Framework, which makes it super easy for Entity Framework users to get the grid to display hierarchical data. When binding the datagrid to a list of Entity objects, the datagrid will now automatically find and load the detail data into subgrids and use master/detail view. To turn this on, set AutoCreateDetailsDescription to True on the DataGridColectionViewSource and AutoCreateDetailConfigurations to True on the datagrid.

- We’ve also made it easier to work with unbound columns, in two ways. First, we support unbound data, which appends data to business objects that the grid displays. This method is great for displaying calculated columns or anything else which depends on the data. Second, we now directly support unbound columns, for displaying static information, such as a delete button for every row, progress bars, or any other controls or content which don’t depend on data.

The other important updates in this release deal with filtering. In previous versions, we offered Excel-like auto filtering, which provides a button for each column so that users can filter in the same way Excel does. In this version, there are two important additions to filtering capabilities for end users.

- First, we’ve added the ability for developers to define their own custom distinct values to add to the AutoFilter drop-down. You can use this to make the auto-filtering choices a lot more useful for end-users. For example, on a column with dates, you can offer the choice to filter by month. For names, the filtering choices could now be “A-C”, “D-F”, and so on. For numbers, you could group them into appropriate ranges, such as “0-99”,”99-1000” or “Odd numbers” and “Even numbers” – anything you want.

- Next, we’ve added a new row type, called the Filter Row. This row can be placed in the grid’s fixed or scrolling headers or footers, and provides users with an alternate way to set and view the datagrid’s current filter settings. It’s always visible, and works great with date ranges, as you can set a start and end date to filter by, or set value ranges such as “>5 AND <10”. You can filter Booleans using a three state checkbox, and strings can be filtered by typing a value that is contained in the string.

One last thing. The datagrid is now compiled for .NET 3.5 SP1. This service pack has been available for some time, and according to Microsoft, should be automatically pushed out and installed everywhere through Windows Update around the November timeframe.

Thanks, and I can’t wait to show you the a video of what’s in the next release, a release that’s coming soon, and has lots of amazingly responsive smooth scrolling and animation.

Let us know what else you want us to implement, by posting in the Roadmap 2009 thread on the forums at Xceed.com.

Good programming!

How does Xceed DataGrid for WPF stack up against Microsoft’s?

Odi [Xceed] — Tue, 05 May 2009 17:17:00 GMT

Today I noticed this blog post by Nigel Spencer discussing his experiences with both Microsoft's WPF datagrid and Xceed's. I liked that Nigel recognizes that any new datagrid coming out this year will be significantly behind in maturity. If you take a look at the 25 releases of Xceed's WPF grid so far, you'll see hundreds of improvements to the product over the 2.5 years it has been on the market. Not only would you have to live through that with any new datagrid coming out soon (or even in the past year), but the competition's pace will be slower. That's because Xceed's UI controls team, which used to make a variety of controls for Windows Forms, is now focused entirely on datagrids and hasn't spread its teams to design ribbons, charts and other WPF controls not directly related to datagrids.

Nigel also mentions the Microsoft WPF toolkit datagrid. Nice to see that he thinks we got a few things right that Microsoft might have missed in their v1. Here's a portion of his post:

So how does the Xceed DataGrid stack up against Microsoft’s? Here are some of the benefits that I’ve found so far:

Binding to SelectedItem works just fine.
ReadOnly properties support at Grid, Column and Row level.
CheckBox column allows simple styling whilst preserving ReadOnly value.
Automatically supports current selection and edit indicators in the row header.
The grid theme matches the OS theme out of the box. This is how it should be. Sure the grid can be custom styled to suit but it only makes sense that by default the grid should match the look and feel of the standard themed controls.
When auto-generating column headers it correctly uses any System.ComponentModel.DisplayName attributes that have been applied to the underlying class.
There are lots of options at grid and column level that determine how a cell should enter edit mode. This is very useful for columns such as CheckBox columns where requiring a click to enter edit mode can be highly annoying (since the user would expect the click to toggle the checkbox).

Here are a couple of things Nigel suggests we could improve in an upcoming version:

An easier mechanism for custom sorting. Rather than having to specific custom IComparer implemenations often it is easier to refer to an unbound property that contains the raw data. Like Microsoft’s SortMemberPath property. Hmm… I wonder if you could use a generic SortComparer to provide the same functionality?
Smaller assembly size. I know these days 2.08Mb shouldn’t be an issue but for my current contract it is. We have a ClickOnce application that is deployed to machines in remote country areas. Many of these machines are still using dial-up! Adding another another 2Mb to our current 4.5Mb total is a decision not to be made too lightly. [We’ve already been burned with a ridiculously bloated NHibernate assembly (1.6Mb)]

Thanks for the suggestions. You can be sure the team has noticed them.

WPF vs. Silverlight: it's the wrong debate

Odi [Xceed] — Mon, 23 Mar 2009 18:43:00 GMT

The question isn't "Wither WPF?" or "Will Silverlight marginalize WPF?"

With announcements at MIX09 that Silverlight will gain many of the key features that made WPF special, developers, component vendors and the media are now concerned more than ever about the future of WPF.

It's not WPF they should be worried about.

When you elect to use Silverlight, you are really choosing to forego the full .NET framework and everything that goes along with it that isn't in the latest flavour of Silverlight. Tons of useful capabilities, thousands of APIs, file system access, you name it. And also lots of new .NET 4.0 capabilities as well, like dynamic languages, MEF, parallel programming, hard-core multi-touch support, and so on, that aren't in Silverlight.

Silverlight isn't just a compact, streamlined version of WPF, it is a compact, streamlined version of the entire .NET framework. To say the debate is about whether or not you want to forego some particular WPF features that aren't in Silverlight 3 is focusing on too fine a point. The issue at hand, and the choice being made when selecting the platform to use, is much larger than that.

Think about this question instead: Do you think there will be a significant amount of developers that will continue to use the full .NET framework for their projects? Or will they be using the more cross-platform, quick-to-install Silverlight, whether they are targeting the web or not? Consider both run-of-the-mill business apps which Silverlight 3 tries to easily enable, as well as other kinds of apps, such as “media” apps like movie players and games.

If your answer is that, Yes, there will still be many developers using the full .NET framework instead of Silverlight, then you have nothing to worry about when it comes to WPF. WPF is arguably at the point where it knocks the socks off of Windows Forms. With .NET 4, Visual Studio 2010 and Expression Blend 3, WPF will be the UI framework "par excellence" for those using the full .NET framework.

If your answer is No, you think very few developers will resist Silverlight's temptations such as being able to run on OS X and potentially other platforms, then it isn't just WPF that you should be concerned about. It's the entire .NET framework, even the Windows platform itself.

After all, if there weren't enough reasons left to develop specifically for Windows, well, all that would be left going for Windows would be features. There would be fewer and fewer Windows-only apps. That seems suicidal to me, Microsoft wouldn’t let it happen without a fight. What did Steve Jobs recently say? He insists it’s the apps that will differentiate Apple’s latest product, the iPhone, from the competition.

So what’s my answer?

Yes, moving forward, there will still be plenty of developers that choose to use the full .NET framework, for not-so-run-of-the-mill business apps as well as for a million and one other kinds of apps. I'm talking about a pretty big 'Long Tail'. And many of those apps will need a UI, and that means WPF, not Silverlight. Sure, Silverlight 3 has multi-platinum superstar potential, but WPF should get a few gold records as well. I think it’s far from withering away or being marginalized, as many are worried about.

Microsoft Tag in MSDN Magazine February 2009 issue.

Odi [Xceed] — Mon, 09 Feb 2009 20:55:00 GMT

When Microsoft Tag was announced at CES 2009 on January 7th, the official deadline for submitting ad material for the February 2009 issue of MSDN magazine (the print publication) was already passed. But I knew it still wasn't too late, most magazines always keep a safety buffer for late submissions. So we created a tag on the Microsoft Tag site, added the tag to our latest printed advertisement with the word "Surprise!" near it, and re-submitted February's material. It made it into the February issue! Visit the tag for a nice surprise (if you're interested in a fantastic datagrid for WPF development.)

Here is what the ad looks like (it is a two page spread ad, and the tag has been partially hidden here on purpose, you must get your hands on an MSDN magazine to get to the tag itself):

Is it the first use of Microsoft Tag in a printed magazine? Close, but there's this one, and perhaps one in a newspaper which doesn't require materials so long in advance.

Add this technology to the list of Microsoft technologies Xceed has been the first (or one of the first) to use :)

Ten reasons to use Xceed’s entry-level WPF datagrid instead of Microsoft’s

Odi [Xceed] — Mon, 26 Jan 2009 16:48:00 GMT

Here are 10 reasons you should pass on using the basic Microsoft WPF grid and adopt Xceed’s free Express Edition instead....(read more)

Raising the bar with smooth scrolling

Odi [Xceed] — Mon, 17 Nov 2008 20:35:00 GMT

In the past two years, Xceed has worked on the performance of Xceed DataGrid for WPF, and with August's release of v3.0, we feel we've achieved a great level of performance. The best in the industry if you not only count scrolling speed, but loading, sorting and grouping time as well.

Despite the new performance increases, there are still scenarios with slower systems on which the scrolling performance is not fast enough. The industry's solution to that (including Microsoft's own WPF datagrid) is to provide a "deferred scrolling mode". In deferred mode, a datagrid's display isn't updated while you are dragging the scrollbar, it updates only when you stop dragging. This scheme doesn't let you know where you will land when you let go of the thumb, so "scroll tips" were invented to display information about the first row of the page you would land on. Not a very good experience.

Earlier this year, we started working on Xceed DataGrid for WPF's "perceived performance". We added smooth scrolling to the datagrid, physics-like animation effects, and background generation and display of data items. The combination of these features provides a much better experience than with deferred scrolling, and boy does it look and feel delicious. When a user performs a "page down" action, the datagrid immediately responds by starting to smooth scroll to the next page, while fading-in the datarows as their containers and contents are generated. By the time the animation has slowed down, everything is properly displayed as expected. Instead of a delay on a slower computer when the user hits "page down", they get immediate feedback, giving the datagrid a snappy and fast feel to it. Here's a Channel 9 video (WMV High) on the new feature, and a couple more new related features such as group headers that always stay in view and touch gesture support.

Smooth Scrolling Datagrids with Xceed on Microsoft Channel9

I think it is clear that the industry looks toward Xceed as the trend-setter in WPF datagrid controls, and even WPF controls in general. We were the first to release one, the first to provide an XBAP demo (and a still unequaled one even after two years of availability), the first to announce the use in a major application such as Visual Studio Team System 2010, the first to bring 3D to datagrids, and now the first to demonstrate smooth scrolling, physics effects, touch gesture support, and background generation of UI elements to increase perceived performance.

Winners of the XBOX 360s drawn at PDC 2008!

Odi [Xceed] — Thu, 30 Oct 2008 17:35:00 GMT

At PDC 2008, I just went over to the Channel 9 lounge this thursday morning 10:30 am and with the help of a third-party witness sitting near the folks playing Rock Band 2, Dan Morphis from AFHCAN.org Alaska, drew the three XBOX 360's, one for each day we spotted PDC 2008 attendees wearing the "Datagrids, transformed." badge.

Day 1 winner was: Bill Janczac

Day 2 winner was: Kris Bruland

Day 3 winner was: Bob Sampson

Congratulations to the winners, you will be contacted by email shortly to obtain your address information. Thanks to all the hundreds of people that wore the badge at PDC 2008, I was told it was the third most popular badge by a friend. The first being the default PDC badge, the second being the white "brains" badge, and Xceed's being third. Nice.

Wear this PDC Badge and win one of three Xbox 360s!

Odi [Xceed] — Sat, 25 Oct 2008 14:35:00 GMT

As part of the PDC Badges concept, if you are spotted by Xceed staff wearing the above badge at PDC 2008, you'll be entered into a draw to win one of 3 Xbox 360 consoles we're giving away. One Xbox 360 a day. Get your badge by dropping by the Xceed DataGrid for WPF booth in the exhibit hall during PDC 2008, and wear it throughout the conference to increase your chances of being spotted.

Xceed PDC 2008 Badges XBOX 360 Giveaway Rules:

· Xceed will draw up to three Xbox 360 consoles, one on Oct. 27 2008, one on Oct. 28 2008, and one on Oct. 29 2008

· To enter the draw, wear the Xceed “Datagrids, transformed.” badge (the “Xceed Badge”) in the official PDC Badge holder you received with your PDC 2008 registration, and get spotted by an Xceed staff member.

· Xceed plans to have 5 staff members at PDC 2008 who will be on the lookout for PDC 2008 attendees wearing the Xceed Badge in the convention center. On any of the given days when a draw will take place, when an Xceed staff member spots an attendee wearing the Xceed Badge, they will ask the attendee for their name and email address, for inclusion in that day’s draw.

· At least 10 attendees must be spotted and entered into the day’s draw in order for the draw to take place.

· Xceed and Microsoft employees aren’t eligible to participate in these draws.

· When performing the draw, Xceed will assign an integer number sequentially to each person entered in the day’s draw, and select the winner randomly by using the result of an electronic calculator’s random number generator.

· The winners will be contacted by email, and announced through various means, such as through the @DataGrid user on Twitter.com, in an Xceed blog post, a post in the forums, etc.

· Xceed reserves the right to not “spot” attendees in front of or near Xceed’s exhibitor booth.

· Prizes may be ordered by Xceed from Amazon.com or Amazon.co.uk and sent to attendees living in the USA, Canada and Europe. For attendees living in other countries, Xceed may elect obtain an Xbox 360 to personally hand to the attendee while at the convention center during PDC 2008 or find a suitable (at Xceed's discretion) replacement giveaway of similar value.

· No purchase necessary, and giveaway rules may be revised at any time (though changes will be listed here). We're aiming for a fair and honest giveaway so if there's anything these rules forgot to mention, please let Xceed know.

Another Silverlight 2 component!

Odi [Xceed] — Thu, 23 Oct 2008 17:51:00 GMT

This past week we released our second Silverlight 2 component, Xceed Real-Time Zip for Silverlight. Our first Silverlight 2 component, Xceed Upload for Silverlight, was the industry’s first commercially available control for Silverlight 2. I think it’s great that we’ve been first to release a component for many of Microsoft’s new development platforms in the past 10 years:

· 1st .NET component (Xceed Zip for .NET, alpha, Nov. 2000)

· 1st WPF component (Xceed DataGrid for WPF, RTM, Jan. 2007)

· 1st Silverlight 2 component (Xceed Upload for .NET, RTM, May 2008)

· 1st Workflow Foundation activity (Xceed Activities for WF, RTM, Apr. 2007)

· 1st Biztalk Server 2000 component (Xceed FTP for Biztalk, RTM, Jun. 2001)

· 1st .NET Compact Framework component (Xceed Zip for .NET CF, Beta, Apr. 2003)

And, I couldn’t confirm this through Archive.org, but I seem to remember Xceed being the first to release a 32-bit OCX during the changeover from 16-bit OCX components to 32-bit ones about 12 years ago. By the way, our domain name back then was xceedsoft.com.

Back to Xceed Real-Time Zip for Silverlight, what’s great about this product is that it compresses files or streams into Zip archives and decompresses Zip archives in a streaming fashion without using intermediate disk/memory storage or temporary files. That really jives with the likes of Silverlight, which doesn’t allow local write access.

Why is it called “Real-Time Zip”? Not because it is faster, since it avoids disk writes, but because it starts outputting a Zip file as soon as the first bytes of the first file to compress are provided. In the same way, it can also start unzipping a Zip file as soon as the first bytes of the Zip file are available. By the way, the size or number of files to compress or uncompress has little bearing on the memory footprint. You can Zip many multi-GB files without worrying about memory, though if you are Zipping tens of thousands of files (regardless of their size), memory use might start to become be a factor. The component must keep some information (filename, path, checksum, size...) about each file in memory in order to be able to write the Zip file’s “central directory” portion at the end of the Zip file.

I should also mention that strong 128- to 256-bit AES encryption is also supported while compressing/uncompressing.

What use is there for a Zip library with Silverlight you might ask? First, it will let your Silverlight application read and consume the contents of a Zip file that’s stored on your user’s local filesystem. In the same fashion, it will allow your app to receive a Zip file from a server and unzip and consume the contents as the Zip file is coming in over the wire. Second, it will allow your code to compress a bunch of user selected files from their local filesystem into one Zip file that you can start uploading to a server or another user even before the complete Zip file is ready.

Well, hope to see you at next week’s PDC 2008 event, where Xceed will be dedicating the our booth to exhibiting our advanced datagrid for WPF.

Odi