Dotmad.net

When I reviewed some 3rd party WPF components out there I noticed the fact most of them showcased a datagrid claimed to perform better than the default grid.

After reading Tamir’s post about the new WPF DataGrid CTP I have to wonder if this is about the change, as there seem to be serious performance improvements in the new grid:

WPF’s goals for controls in 3.5 SP1 focused on supporting building DataGrid in our next release and improving the performance of our controls overall. One of our top priorities is to develop a high performance, full-featured DataGrid to support demanding LOB and ISV scenarios, and many of our improvements in controls focused in this area. We also wanted to make changes to our infrastructure to improve performance of all of our controls and achieve faster application start-up times

One specific feature that looks promising is deferred scrolling:

Deferred scrolling is a perceived performance improvement for ItemsControls such as ListBox. The default behavior of ScrollViewer in WPF is “live” scrolling, where the user is able to see the contents of the scroll viewer move while dragging the thumb of a scroll bar. This can be problematic for controls such as ListView and DataGrid, which often have complex item templates and use virtualization. In these cases, the amount of processing required to refresh the view with new items consumes too large an amount of time for the UI to appear snappy. To the end-user, the UI could feel sluggish and non-responsive. Deferred (”non-live”) scrolling is an alternative scrolling behavior where the contents of the scroll viewer remain static until the user releases the mouse button (similar to the behavior of the Outlook 2007 Inbox). In the absence of other performance improvements, having non-live (deferred) scrolling could be beneficial for improving the end-user’s perception of scrolling performance.

You can find additional information on using the datagrid in Vincent Sibal’s blog.

I did a small review of available components suites for WPF. I focused mainly on grid and charting controls, as the nature of WPF allows customization of the UI in ways that previously required 3rd party components in a Winforms development:

Xceed:
Grid control only
Express edition - Free
Professional edition - 500$
With source code - 1250$

Infragistics:
Netadvantage for WPF
Includes DataGrid, Carousel controls, Ribbon, Chart, editor controls (masked edit, datetime picker, etc)
Price - 800$
Source code not included

Component One:
Studio for WPF
Includes DataGrid, Chart, Report viewer, Schedule controls (datetime picker, calendar, scheduler)
Price - 800$
Source code not included

Syncfusion:
Essential studio WPF edition
Includes Chart, Docking manager, Ribbon, Groupbar, Taskbar, Datetime editor, Autocomplete textbox, Font listbox, Color picker, numeric updown, masked edit, Tree view
Currently no grid is available
Price (with source) - 600$

As you can see, there aren’t many options available at the moment. What is worse is the fact most tools don’t come with a source control, meaning using them means taking a risk of losing support in the future.

My recommendation: Don’t purchase anything unless you absolutly need to. The only thing worth considering purchasing at the moment is a charting control (as there is none from Microsoft), but you should also consider an open-source solution.

I have written before a short comparison between “old” and newer technologies, but at the beginning of that post I state that part of the choice of a new technology is the market trend towards that technology.
After reading Justin’s post showing that moving to ASP.NET is beneficiary because it’s becoming a prominent technology I decided to implement his research methods (using Google) on different technologies.

I began by searching for file types

However, this reflects only on files shared on the web, and since JAVA is a web technology (unlike Delphi) the results don’t say much.

But Google trends provides a clearer picture - while C# remains stable, other programming languages are on the decline:

Focusing on the .Net world, you can clearly see new technologies are dominant in Google searches:

WPF vs. Winforms

WCF vs. Remoting

The rise of .Net Framework 3.0 technologies

With Silverlight being the “Hot New Thing” (maybe because it’s a web-based technology)

So maybe choosing a new technology is a logical move even if it doesn’t offer a significant technological advantage - since keeping older technologies means you are working against the market trend.

So consider switching from Winforms to WPF, from various communication technologies to WCF and from VS 2003 or 2005 to VS 2008 - in the long run the market will force you to do it anyway, either through the job market or through customers demands.

We all know about the “cool new kids in town”, meaning new technologies all developers want to use. Offer a developer two positions:

1. Programming with C# 1.1
2. Programming with WPF and C# 3.5

What do you think most developers will choose?

However, there is the question of an existing project, written in an “uncool” technology.
In my experience developers tend to push towards using newer technologies, but how do you convince the people in charge?

Here are my thoughts on the subject:

Framework 2.0 vs. 1.1
Advantages: Performance boost if you are using ArrayLists with value types in them (when you switch to generic Lists)
Disadvantages: Incompatibility issues requiring code changes (should be very minor)

Framework 3.5 vs. 2.0
Advantages: Using Linq for new complex data access and query modules, otherwise I’m unsure
Disadvantages: Same as switching between 1.1 and 2.0

WCF vs. Various communication technologies
Advantages: Much easier to configure and deploy, can drastically change the communication method without any code changes
Disadvantages: Not applicable when you do most of the communication in a non-.Net world if you remote points are not using web services protocols (example: communication with hardware sensors)

Workflow foundation
Advantages: Easier to manage complex workflows. Enables user modification of workflows.
Disadvantages: If an existing workflow code is already written - major code rewrite.

WPF vs. Winforms (with CGI+)
Advantages: Creating easily resizable forms due to vector graphics use. Customize look & feel in ways which are almost impossible to duplicate using winforms. Easier interaction between UI/graphics designers and developers.
Disadvantages: Will require serious code rewrite. Performance issues still exist (I have yet to witness a professional map engine based on WPF)

Team system vs. various source control / task management systems
Advantages: I have used SourceSafe, PVCS and Rational ClearCase/ClearQuest, and to this date I think VSTS is better is terms of performance, ease of use and customizability, especially when you need to integrate source control and task management.
Disadvantages: Requires Windows - how do you use VSTS to manage C++ code in a Unix/Linux environment?

Most WPF programmers know the mythological XAMLPad tool, but it’s supplied without source code (although the EditingExaminer sample should be something close to it).
You can also find Kaxaml, XamlHack, and now you can get Petzold’s “XAML Cruncher“, with source code.
It should be a nice tutorial on run-time rendering of XAML code.

Taken from Scott Hanselman’s blog.