ligAZ blogs

Migrating Reflector’s Lists to JustDecompile ones

Stefan Dobrev — Mon, 16 May 2011 21:37:41 +0000

If you (like me) were a heavy Reflector user you will probably like the tool that I’m going to share with you today. It is a very simple WPF application that allows you to migrate your existing Reflector's list to their JustDecompile equivalents. Usage is pretty straight forward. You just™ point the app to your Reflector’s installation folder and it will take care of the rest.

You can download the tool here.

Any feedback: bugs and feature requests is more than welcome.

Let's finish with a rhyme:
Let the force
of a freely decompiled source
guide you in your course.

Why we have built RadDomainDataSource for Silverlight?

Stefan Dobrev — Mon, 03 Jan 2011 11:37:53 +0000

Although Rossen has stated almost all of the things in his introductory blog post about RadDomainDataSource I wanted to create a separate blog entry which answers the most important question that you might be asking: “Why Telerik have developed their own version of a domain data source component?” Here is the answer:

We felt your pain

We have received numerous forum posts and support tickets stating that you want a codeless approach to data-binding that supports most common data operations without the need for any custom code. During the times when RadDomainDataSource was not available you will have to write hundreds of lines of code in order to support server side filtering. Yes sorting and paging were happening on the server automatically, but who needs them without the power of the built-in Excel like filtering of RadGridView. You wanted a seamless integration between your data and our data oriented components like: RadDataFilter, RadDataPager or RadGridView and this is exactly what we have developed. We are also making sure that any future data component that will be developed will lay on the foundation that we have already established and will integrate smoothly as others do.

We wanted to add value

Microsoft’s DomainDataSource lacks some key capabilities and this is a place for someone like Telerik to step up and fill these holes. Here are some of the v1 features that add value to our offering compared to the Microsoft’s one:

Filter Composition – we support nesting of filter descriptors to unlimited depth allowing you to compose complex filter conditions.
Fine grained query parameter control – We expose a PreparedParameterValue event which provides a way for you to change each parameter or handle a possible exception before the entity query is sent to the server. This opens the door for handling any custom query scenario that you might have.
Along with the control we are shipping a set of extension methods which allow you to write native LINQ expression against an entity query object. Those are very handy in data virtualization scenarios like the one in this blog post.

We heard you - the community

One of the most requested feature on RIA services suggestions forum is “MVVM friendly DomainDataSource”. This question was also asked a great number of times on our forums as well. We as you believe that putting a control in your ViewModel is far away from any best practices and this is the reason why RadDomainDataSource was developed with MVVM in mind. What do we mean by that? We are exposing the heart of the control named – QueryableDomainServiceCollectionView as public class that you can start using in your ViewModels right away. You can learn the details here. So our answer to the MVVM purists out there is: We got you covered!

We wanted to invest in the future

Last but not least we wanted to built a foundation for future data source components that we are going to develop. We are pretty sure that what we have developed can be easily extended to support other data access technologies providing filtering, sorting, grouping, paging and aggregation out-of-the-box. This means that you can expect a pleiad of data source controls coming up during the year.

Having all these objectives on the table we have decided to invest our time in developing RadDomainDataSource for Silverlight. I hope you like the end result as much as we do.

Don’t miss other RadDomainDataSource related blog posts:

Bookvar goes open source

Stefan Dobrev — Tue, 31 Aug 2010 16:34:54 +0000

It is a great pleasure for me to share an exciting news with you. As of today we are opening the source code of Bookvar mind mapping tool. You can find the source on Codeplex right next to other open source initiatives of ours, like Telerik MVC Extensions and CAB Enabling Kit for WinForms.

A few caveats about the source code

There are a few things that you need to know about the source code:

Most of the code was written when we were quite new to WPF and we were pioneering all those concepts. Looking back at that time I realize there are things that we would have definitely done better if we had the knowledge we have today.
MAF is used instead of MEF. MEF was not available back in the time, but we would like to see the add-in model based on MEF.
WF 3.0 is used for the updating process workflow. We would love to see a flowchart implementation with new WF 4.0 capabilities.

Still there are some true gems in the source code like: undo/redo, chat service, services based architecture and others.

Play time

Now go straight to the code and start exploring it. Share your thoughts on our forums and don’t be afraid to contribute.

As always we will end this with Bookvar’s mantra: Feel Free To Mind (and contribute).

Implementing logical paging with RadDataPager for WPF and Silverlight

Stefan Dobrev — Sun, 11 Apr 2010 15:40:20 +0000

Following the great series about RadDataPager started by Rossen and Pavel today I’m going to show you how to implement logical paging. We are going to implement alphabetical paging similar to this ASP.NET AJAX Grid Demo.

As you may already know the key to the heart of the RadDataPager is the IPagedCollectionView interface. You can create your own implementations of this interface and implement any custom logic for paging you want. This is exactly what we are going to do in this article.

Introducing PagedCollectionViewBase and LogicallyPagedCollectionView<T>

If you have looked at IPagedCollectionView interface you may have found out that it is not a trivial interface to implement. It has 5 methods, 6 properties and 2 events – total number of members to implement 13. To ease any further implementation of the paging interface we are going to create a base class that will have most of the members implemented. Meet PagedCollectionViewBase class.

PagedCollectionViewBase class

This is an abstract base class, which implements IEnumerable, INotifyPropertyChanged, INotifyCollectionChanged and of course IPagedCollectionView. It boils down the implementation of the paging to overriding of two members – a property and a method: ItemCount and GetEnumerator(). It also has almost all of its members virtual so you can tweak the default implementation if you like. For the details of the implementation you can look at the attached source code.

Using this base class you can create any kind of derivatives that implement the paging using their own mechanism. One could envision an event based one, which has a custom event raised when the paging needs to happen and providing the current paged items in the events arguments. Another way of implementing the paging is via a filtering predicate.

LogicallyPagedCollectionView<T> class

This class derives from PagedCollectionViewBase and introduces the concept of paging via a predicate. You construct this view passing your collection in the constructor. Then you have to set its PageCount property to the desired number of pages and also you have to set the PagingPredicate property. Let’s look at the predicate property. It is defined like this:

public Expression<Func<T, bool>> PagingPredicate { get; set; }

If you look closely you will see that its type is a LINQ Lambda Expression. This allow us to push the paging operation on the server if the view is initialized with an IQueryable implementation. Here is the code that does the paging itself:

private IQueryable<T> PagedView
{
    get
    {
        var query = this.sourceQueryable;
        if (this.PagingPredicate != null)
        {
            query = query.Where(this.PagingPredicate);
        }
        return query;
    }
}

Implementing alphabetical paging with LogicallyPagedCollectionView<T>

Having LogicallyPagedCollectionView<T> in place implementing alphabetical paging will take no more than a few lines of code. Here is the code-behind for our page:

public MainPage()
{
    this.InitializeComponent();
 
    var pagedCollectionView = new LogicallyPagedCollectionView<Item>(new SampleDataSource().Collection);
    pagedCollectionView.PageCount = 26;
    pagedCollectionView.PagingPredicate =
        (i) => i.Property1.ToLower().StartsWith(PageIndexToCharConverter.Convert(pagedCollectionView.PageIndex).ToString());
 
    this.DataContext = pagedCollectionView;
}

You can see that we are initializing the view with some sample data that Blend generated for us. We are setting the page count to 26 – the number of letters in the English alphabet. Then we are setting the paging predicate which will filter out those items which name doesn’t not start with the given page index converted to a char. Finally we are assigning the view as data context so we can bind to it in the XAML. Before looking at the XAML lets first take a look at the PageIndexToCharConverter class. Here it goes:

public class PageIndexToCharConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        int pageNumber = System.Convert.ToInt32(value);
 
        return Convert(pageNumber - 1);
    }
 
    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
 
    public static char Convert(int pageIndex)
    {
        return (char)(pageIndex + 'a');
    }
}

It is a simple value converter class which converts given page index to the appropriate letter in the alphabet. The trick here is that we are going to use the same class to convert the pager buttons’ content to alphabet so we have to be careful when to use the page number or the page index.

Now lets take a look at the XAML for our sample:

<Grid x:Name="LayoutRoot">
    <Grid.RowDefinitions>
        <RowDefinition />
        <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
    <telerik:RadGridView ItemsSource="{Binding}" AutoGenerateColumns="False" ShowGroupPanel="False">
        <telerik:RadGridView.Columns>
            <telerik:GridViewDataColumn Header="ID" DataMemberBinding="{Binding Property2}" />
            <telerik:GridViewDataColumn Header="Name" DataMemberBinding="{Binding Property1}" />
            <telerik:GridViewDataColumn Header="Company Name" DataMemberBinding="{Binding Property3}" />
            <telerik:GridViewDataColumn Header="Email" DataMemberBinding="{Binding Property4}" />
            <telerik:GridViewDataColumn Header="Phone" DataMemberBinding="{Binding Property5}" />
        </telerik:RadGridView.Columns>
    </telerik:RadGridView>
    <telerik:RadDataPager Grid.Row="1"
       Source="{Binding}"
       NumericButtonCount="{Binding PageCount}"
       DisplayMode="Numeric"
       NumericButtonStyle="{StaticResource PagerToggleButtonStyle}"
   />
</Grid>

RadGridView and RadDataPager are both bound to the paged collection view. Pager’s NumericButtonCount is also bound to the PageCount property of the view. The last piece of the puzzle is the custom style for the pager’s buttons:

<local:PageIndexToCharConverter x:Key="PageIndexToCharConverter"/>
 
<Style x:Key="PagerToggleButtonStyle" TargetType="ToggleButton">
    <Setter Property="ContentTemplate">
        <Setter.Value>
            <DataTemplate>
                <TextBlock Text="{Binding Converter={StaticResource PageIndexToCharConverter}}"    />
            </DataTemplate>
        </Setter.Value>
    </Setter>
    <Setter Property="MinWidth" Value="25" />
    <Setter Property="Margin" Value="1,0" />
</Style>

You can see that how the custom value converter is used to format the content of the buttons.

As always you can play with the application right here in the blog post:

You can find the source code here.

(In the WPF version there is another page that illustrates how the paging takes place on the SQL Server. You will need Northwind database installed in your local SQLEXPRESS instance)

Have a great and successful rad paging (or is it just paging? :)

MicroModels for Silverlight

Stefan Dobrev — Thu, 21 Jan 2010 02:40:41 +0000

Last week I was impressed by Paul Stovell’s marvelous project – MicroModels. In a nutshell a micro model is a view model over your objects, which allow you to define dynamic properties, collection and commands. You can read more about it in Paul’s introductory blog post here.

Despite its great features, “MicroModels” has one big limitation - it does not run in Silverlight. And this is where my journey began. My mission was to port the code to Silverlight with little to no modifications.

Porting the code to Silverlight

The task was not an easy one, but after a lot of head scratching and hair pulling I was able to complete it. It involved replacing the TypeDescriptor’s logic with dynamic type generation, partially evaluating local closures in compiler generated expression trees and other tricks typically developers don’t do in a normal working day. Despite all these hurdles, the good news is that the code is working fine in Silverlight and everything is supported.

Using MicroModels in Silverlight

The way the framework is used in Silverlight is almost the same as it is in WPF. You define your MicroModel with exactly the same way using your already familiar methods:

public class EditCustomerModel : MicroModel
{
    public EditCustomerModel(Customer customer, CustomerRepository customerRepository)
    {
        Property(() => customer.FirstName);
        Property(() => customer.LastName).Named("Surname");
        Property("FullName", () => string.Format("{0} {1}", customer.FirstName, customer.LastName));
        Command("Save", () => customerRepository.Save(customer));
    }
}

The only thing that you have to change is in the XAML. You will have to data bind your root DataContext to a new property of the MicroModel, instead of the model itself. The property is called Object. Here is the respective XAML for the EditCustomerModel:

<Grid DataContext="{Binding Object}">
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto" />
        <RowDefinition />
    </Grid.RowDefinitions>
 
    <Button Content="Save" prism:Click.Command="{Binding Path=Save}"/>
 
    <Border Background="#f0f0f0" Grid.Row="1">
        <StackPanel>
            <StackPanel Orientation="Horizontal" Margin="1">
                <TextBlock Margin="1" Width="130">FirstName</TextBlock>
                <TextBox Margin="1" Width="50" Text="{Binding Path=FirstName, Mode=TwoWay}" />
            </StackPanel>
            <StackPanel Orientation="Horizontal" Margin="1">
                <TextBlock Margin="1" Width="130">Surname</TextBlock>
                <TextBox Margin="1" Width="200" Text="{Binding Path=Surname, Mode=TwoWay}" />
            </StackPanel>
            <StackPanel Orientation="Horizontal" Margin="1">
                <TextBlock Margin="1" Width="130">Full Name</TextBlock>
                <TextBlock Margin="1" Width="200" Height="50" Text="{Binding Path=FullName}" />
            </StackPanel>
        </StackPanel>
    </Border>
</Grid>

The same rule with binding to the Object applies to the Collection properties. Here is another XAML snippet, which illustrates the use of an ItemsControl bound to a collection property of the micro model:

<ItemsControl Grid.Row="1" ItemsSource="{Binding Path=LineItems}">
    <ItemsControl.ItemTemplate>
        <DataTemplate>
            <Grid DataContext="{Binding Object}" >
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="300" />
                    <ColumnDefinition Width="80" />
                    <ColumnDefinition Width="80" />
                    <ColumnDefinition Width="80" />
                </Grid.ColumnDefinitions>
 
                <TextBox Margin="1" Grid.Column="0" Text="{Binding Path=ProductName, Mode=TwoWay}" />
                <TextBlock Margin="3" Grid.Column="1" Text="{Binding Path=UnitPrice}" />
                <TextBox Margin="1" Grid.Column="2" Text="{Binding Path=Quantity, Mode=TwoWay}" />
                <TextBlock Margin="3" Grid.Column="3" Text="{Binding Path=LineTotal}" />
            </Grid>
        </DataTemplate>
    </ItemsControl.ItemTemplate>
</ItemsControl>

Samples

I have ported the sample project in the Paul’s source code so you can play with them as well. I have tried to reuse as much code as possible and almost everything except the XAML files is shared between WPF and Silverlight. Actually you can play with the example right here:

Downloads

You can download the binaries here.

You can download the source code from here.
You can browse the source code in my github repository here.

Have fun micro-modeling in Silverlight.

Highlighting Inline Search for RadGridView for Silverlight

Stefan Dobrev — Mon, 18 Jan 2010 14:56:03 +0000

A common request on our forums is how to enable the Search As You Type online example to search in DateTime or Integer properties. Also recently another request was brought to our attention: How to highlight the matching search text in the grid cells. In this blog post I’m going to show you how to achieve these goals.

Let’s start our journey, by looking at the MainPage.xaml of the attached sample application:

    1 <UserControl x:Class="DateTimeFiltering.MainPage"
    2    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4    xmlns:telerik="clr-namespace:Telerik.Windows.Controls;assembly=Telerik.Windows.Controls.GridView"
    5    xmlns:themes="clr-namespace:Telerik.Windows.Controls;assembly=Telerik.Windows.Controls"
    6    xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
    7    xmlns:local="clr-namespace:DateTimeFiltering"
    8    xmlns:jeff="clr-namespace:JeffWilcox.Samples;assembly=HighlightingTextBlock">
    9 
   10     <UserControl.Resources>
   11         <local:SearchViewModel x:Key="ViewModel" />
   12 
   13         <SolidColorBrush Color="Red" x:Key="HighlightBrush" />
   14         <Style TargetType="jeff:HighlightingTextBlock" x:Key="HighlightTextBlockStyle">
   15             <Setter Property="HighlightBrush" Value="{StaticResource HighlightBrush}" />
   16             <Setter Property="HighlightFontWeight" Value="Bold" />
   17         </Style>
   18 
   19         <DataTemplate x:Key="HighlightCellTemplate">
   20             <jeff:HighlightingTextBlock 
   21                Style="{StaticResource HighlightTextBlockStyle}" 
   22                HighlightText="{Binding SearchText, Source={StaticResource ViewModel}}" >
   23                 <i:Interaction.Behaviors>
   24                     <local:CellValueBindingBehavior />
   25                 </i:Interaction.Behaviors>
   26             </jeff:HighlightingTextBlock>
   27         </DataTemplate>
   28     </UserControl.Resources>
   29 
   30     <Grid DataContext="{Binding Source={StaticResource ViewModel}}">
   31         <Grid.RowDefinitions>
   32             <RowDefinition Height="Auto" />
   33             <RowDefinition />
   34         </Grid.RowDefinitions>
   35         <Grid.ColumnDefinitions>
   36             <ColumnDefinition Width="Auto" />
   37             <ColumnDefinition />
   38         </Grid.ColumnDefinitions>
   39 
   40         <TextBlock Text="Find:" Margin="5,5,7,5" VerticalAlignment="Center"/>            
   41         <TextBox Text="{Binding SearchText, Mode=TwoWay, UpdateSourceTrigger=Explicit}" Grid.Column="1" Margin="3">
   42             <i:Interaction.Behaviors>
   43                 <local:PropertyChangedUpdateTriggerBehavior />
   44             </i:Interaction.Behaviors>
   45         </TextBox>
   46 
   47         <telerik:RadGridView Name="playersGrid" AutoGenerateColumns="False" ItemsSource="{Binding Items}"
   48            Grid.Row="1" Grid.ColumnSpan="2">
   49             <telerik:RadGridView.Columns>
   50                 <telerik:GridViewDataColumn DataMemberBinding="{Binding Name}" CellTemplate="{StaticResource HighlightCellTemplate}" />
   51                 <telerik:GridViewDataColumn DataMemberBinding="{Binding Established}" CellTemplate="{StaticResource HighlightCellTemplate}" />
   52                 <telerik:GridViewDataColumn DataMemberBinding="{Binding StadiumCapacity}" CellTemplate="{StaticResource HighlightCellTemplate}" />
   53             </telerik:RadGridView.Columns>
   54         </telerik:RadGridView>
   55     </Grid>
   56 </UserControl>

The interesting pieces of code are as follows:

Line 11 - SearchViewModel
Line 20 – HighlightingTextBlock
Line 24 – CellValueBindingBehavior
Line 43 – PropertyChangedUpdateTriggerBehavior

Let’s look at each one of these.

SearchViewModel

This class servers as a view model for the MainPage. Its main purpose is to abstract away the logic for the inline filtering. For this purpose it exposes two properties: SearchText and Items. SearchText is the property that is bound to the TextBox used for searching. The second property Items is the actual collection that the RadGridView is bound to. The trick here is that this property returns a QueryableCollectionView over the original collection. This allow us to control the filtering in the view model using the FilterDescriptors property of the collection view. And this is where the magic happens. In the heart of the SearchViewModel lies the PredicateFilterDescriptor – a custom IFilterDescriptor which implements the heavy lifting for the search. Here is the relevant code:

   51 private void UpdateSearchPredicate()
   52 {
   53     string text = this.SearchText;
   54 
   55     Expression<Func<Club, bool>> predicate =
   56         c => string.IsNullOrEmpty(text)
   57                 ? true
   58                 : c.Name.ToString().ToLower().Contains(text) ||
   59                    c.Established.ToLongDateString().ToLower().Contains(text) ||
   60                    c.StadiumCapacity.ToString().ToLower().Contains(text);
   61 
   62     this.filter.Predicate = predicate;
   63 }

You can see how we are creating an expression which will call ToString() on each property of the Club object and then verify if this string contains our SearchText. If this expression returns true the item will be visible in the RadGridView, otherwise it will be filtered out. Explaining you how PredicateFilterDescriptor is implemented is a subject of a blog post on its own, so I’m not going to go deep in the rabbit hole.

HighlightingTextBlock

For the purpose of the sample we need a way to define a custom cell template. It should somehow have a text block which will highlight the searched text. But how to achieve this? Fortunately Jeff Wilcox comes to rescue with his HighlightingTextBlock. This custom control allow you to display a text and highlight portions of it using the HightlightText property. Thanks Jeff, this is exactly what we need. On line 22 you can see how the HightlightText is bound to the SearchText property of the SearchViewModel.

CellValueBindingBehavior

This is a custom attached behavior. Its purpose is to bind the text property of the HighlightingTextBlock to the value of its parent cell. We need this because RadGridView is smart and when you have a custom cell template the DataContext of the cell is the data item itself, not the value of its property. Here is the interesting code:

public class CellValueBindingBehavior : LoadBehavior<FrameworkElement>
{
    protected override void OnAssociatedObjectLoaded()
    {
        base.OnAssociatedObjectLoaded();
 
        var cell = this.AssociatedObject.ParentOfType<GridViewCell>();
        if (cell != null)
        {
            this.AssociatedObject.SetBinding(HighlightingTextBlock.TextProperty, new Binding("Value") { Source = cell, Mode = BindingMode.TwoWay });
        }
    }
 
    protected override void OnDetaching()
    {
        this.AssociatedObject.ClearValue(HighlightingTextBlock.TextProperty);
 
        base.OnDetaching();
    }
}

Note: This behavior is not needed in WPF because you can use RelativeSource=FindAncestor. Currently Silverlight did not have this comfortable feature.

PropertyChangedUpdateTriggerBehavior

Again we need this because of the limitation in the SIlverlight platform. This behavior enables the TextBox to update the item bound to its Text property on every key stroke. This mimics the WPF’s UpdateSourceTrigger=PropertyChanged setting of the binding. You can see how we have achieved this in Silverlight:

public class PropertyChangedUpdateTriggerBehavior : Behavior<TextBox>
{
    protected override void OnAttached()
    {
        this.AssociatedObject.TextChanged += OnTextBoxTextChanged;
    }
 
    void OnTextBoxTextChanged(object sender, TextChangedEventArgs e)
    {
        var bindingExpression = this.AssociatedObject.ReadLocalValue(TextBox.TextProperty) as BindingExpression;
        if (bindingExpression != null)
        {
            bindingExpression.UpdateSource();
        }
    }
 
    protected override void OnDetaching()
    {
        this.AssociatedObject.TextChanged -= OnTextBoxTextChanged;
    }
}

This was the last interesting piece of code for today. Hope you will find it useful.

You can play with the example bellow:

You can download the source here.

Have fun.

Sorting, Filtering, Grouping and Aggregating on all CPU cores using RadGridView for WPF and PLINQ

Stefan Dobrev — Wed, 23 Sep 2009 18:09:22 +0000

As some of you may already know the Q2 release of RadGridView for WPF ships with a brand new “data engine” entirely based on LINQ. This means that all data operations including sorting, filtering, grouping, aggregating and paging will be pushed down to the IQueryProvider when RadGridView is bound to an IQueryable. For example if you are using LinqToSql, LinqToEntities or OpenAccess ORM all gird operations are executed on the SQL server using the magic of LINQ providers.

Staying on the cutting edge I decide to try out PLINQ (Parallel LINQ) and enable RadGridView to execute its data operations on all available CPU cores. PLINQ enables LINQ queries to be execute simultaneously on all cores using the new task parallel library that will be available in .NET 4. PLINQ is straight forward to use when you are constructing your queries in code, but this is not the case when you want to enable IQueryable over IParallelEnumerable. Unfortunately PLINQ did not provide built-in query provider, so I ended up implementing ParallelQuery class similar to EnumerableQuery for LINQ to Objects. This class internally rewrites the generated Expression Tree and proxies all calls to the ParallelEnumerable extension methods.

On the following screenshots you can see the CPU utilization before and after the PLINQ is used.

Before:

After:

As you can see when PLINQ is taking place both cores are fully utilized. You can imagine what will happen when you have 4 or 8 cores. And all of this for free with a simple one line change you have to do before binding the RadGridView.

[Update: If you are wondering why the CPU is utilized at its maximum and the occupied RAM is almost 3GB you should know that these screenshots are taken when the RadGridView is bound to collection with 15,000,000 items. Yes you heard me right this is 15 million.]

You can download the sample source here

P.S. Did I mention that this “data engine” will going to used in our ASP.NET MVC Grid.

Transpose or just rows as columns

Stefan Dobrev — Mon, 16 Feb 2009 14:17:54 +0000

A common scenario when displaying tabular data is to flip the axis so your rows becomes columns and vice versa. This can be easily achieved when you know the shape of your data. For example imagine we have a Customer class with 3 properties: Name, Age and JobCode. Let’s say that we have 5 customers in our data repository. If we want to select just the names we can do something like this:

IList<Customer> customers = Customer.GetAll();
var names =
    new
        {
            Customer1 = customers[0].Name,
            Customer2 = customers[1].Name,
            Customer3 = customers[2].Name,
            Customer4 = customers[3].Name,
            Customer5 = customers[4].Name
        };

Imagine that another Customer is added and suddenly this code have to changed. Obviously this won’t scale even in a short period of time. So what is the solution?

Introducing Transpose<T> extension method

Transpose is an operation used in linear algebra to transpose (of course) a matrix. In our case Transpose is an extension method with the following signature:

public static IEnumerable Transpose<T>(this IEnumerable<T> source)

But what did Transpose do under the covers? Here are the recipe ingredients:

1 tablespoon of DynamicClass.
2 tablespoons of Reflection.
1 cup of Expression Trees.
1 slice of LINQ.
2 slices of functional programming.

Here is the code itself:

public static class EnumerableExtension
{
    private static readonly MethodInfo GetValueMethod =
        (from m in typeof(PropertyInfo).GetMethods()
        where m.Name == "GetValue" && !m.IsAbstract
        select m).First();
 
    private static readonly ConstantExpression NullObjectArrayExpression =
        Expression.Constant(null, typeof(object[]));
 
    public static IEnumerable Transpose<T>(this IEnumerable<T> source)
    {
        if (source == null)
        {
            throw new ArgumentNullException("source");
        }
 
        return TransposeCore(source);
    }
 
    private static Delegate CreateSelectorFunc<T>(IEnumerable<T> source)
    {
        T[] list = source.ToArray();
        DynamicProperty[] dynamicProperties =
            list.Select(i => new DynamicProperty(i.ToString(), typeof(object))).ToArray();
 
        Type transposedType = ClassFactory.Instance.GetDynamicClass(dynamicProperties);
 
        ParameterExpression propParam = Expression.Parameter(typeof(PropertyInfo), "prop");
 
        var bindings = new MemberBinding[list.Length];
        for (int i = 0; i < list.Length; i++)
        {
            MethodCallExpression getter =
                Expression.Call(
                    propParam,
                    GetValueMethod,
                    Expression.Constant(list[i]),
                    NullObjectArrayExpression
                    );
 
            bindings[i] = Expression.Bind(transposedType.GetProperty(dynamicProperties[i].Name), getter);
        }
 
        LambdaExpression selector =
            Expression.Lambda(
                Expression.MemberInit(
                    Expression.New(transposedType),
                    bindings),
                propParam);
 
        return selector.Compile();
    }
 
    private static IEnumerable TransposeCore<T>(IEnumerable<T> source)
    {
        List<PropertyInfo> properties = typeof(T).GetProperties().ToList();
        Delegate selector = CreateSelectorFunc(source);
 
        foreach (PropertyInfo property in properties)
        {
            yield return selector.DynamicInvoke(property);
        }
    }
}

Note that some iterator best guidelines are also in place. And the final result is:

You can download the code from here

Have fun.

IntelliSense for Expression Blend

sdobrev — Mon, 04 Aug 2008 06:55:43 +0000

[Update]: You can find the addin for Expression Blend 2.0 SP1 here.

The problem

Expression Blend has been out in the wild for quite some time. However one of the most annoying thing was the lack of autocompletion (aka IntelliSense). Most of devs/designers out there were constantly switching from Blend to VS and backwards to do their stuff. The great free tool Kaxaml is at great help as well.

The solution

Using the Blend 2.5 add-ins architecture I have created an add-in that adds IntelliSense in Blend. I have reused the code from Kaxaml and adapted it work within Blend. Take a look:

Download

You can download the add-in from here. What you need to do is:

Extract the contents of installation archive in your Blend 2.5 installation folder (typically %ProgramFiles%\Microsoft Expression\Blend 2.5 June 2008 Preview)
Run Blend from the Blend.bat file that was extracted into Blend's installation folder. (The only way to run an add-in in Blend is to use a command line argument: -addin:path_to_the_addin - in our case -addin:Addins\Expression.Blend.IntelliSense.dll. You can also create a shortcut to Blend and pass this argument.)

Limitations

There are some limitation of the current implementation:

You should have Blend 2.5 June Preview (Version 2.1.1535) - available for free download here. For version compatible with Blend 2.0 check here.
No support for custom namespace types and custom attached properties.
Currently the Silverlight support is not accurate, because it is using the WPF XML schema for IntelliSense information.

[ReSharper] Directory name donates namespace Yes or No ?

sdobrev — Fri, 04 Jul 2008 16:05:49 +0000

If you like us are passionate user of ReSharper you know that ReSharper "did not like" when a class' namespace did not correspond to the directory structure the file belongs to. To illustrate this lets look at a simple example.

Imagine that we have a project named MyProject. By default its namespace is MyProject. Lets have a folder named MyControls in the project as well. Now lets add a class file in that folder, naming it "MyControl.cs". The default namespace that will be generated for the class will be MyProject.MyControls. It is constructed using the default namespace and joining it with the folder name. But if we change the namespace to be only MyProject, ReSharper will warn us with:

However, sometimes we may not want this behavior. We may just want to have a folder, which name will not participate in the default class' namespace. How to achieve this? Just in two easy steps:

1. Right click on the folder and choose properties.

2. Change the Namespace Provider combo box value from True to False.

Now ReSharper will be happy and everything will be fine. Peace.

Tip of the Day: Clear your ClickOnce application store

sdobrev — Tue, 24 Jun 2008 12:27:36 +0000

ClickOnce is a great technology that blurs the line between web and client(windows) applications. You can use it to easily deploy windows forms and WPF (through XBAP) app's. However there is common problem with it. The application store (the place where all ClickOnce applications get stored) has the ability to corrupt it self ending in an appropriate version mix of your application. You can end up in situation where "it works on my machine", but in reality the application did not work correctly. To avoid such situation it is a good practice to clear your application store before testing the deployment locally on your machine. You can do that using a magic (I mean it for real) command. Open Visual Studio command prompt and type:

mage -cc

And a magic happens ;)

WPF Series: IFrameworkElement - the missing interface

sdobrev — Tue, 10 Jun 2008 14:51:51 +0000

If you are familiar with WPF you are aware that the the grand daddy of all controls is FrameworkElement. It is defined in the PresentationFramework.dll assembly and derives from UIElement (defined in PresentationCore.dll). Its purpose is to serve as a base element for all framework related stuff: styles, inheritance context, etc. However there is another framework element - FrameworkContentElement. The main distinct between them is that the later did not defines its own rendering behavior (its inheritors should do so). This is way properties like: (Actual)Width or (Actual)Height are not present at FrameworkContentElement. If you examine the classes that derive from FrameworkContentElement you will find out that they are mainly text and document related ones.

So, what's the deal?

Looking through the MSDN documentation you will find out that: "FrameworkContentElement deliberately parallels many of the same APIs as FrameworkElement." However they did not implement a common interface. For example if you want to access the DataContext property (present at both classes) you should check explicitly for each type like this:

var dataContect = "DataContext";
var frameworkElement = sender as FrameworkElement;
if ( frameworkElement != null )
{
    frameworkElement.DataContext = dataContect;
}
else
{
    var frameworkContentElement = sender as FrameworkContentElement;
    if ( frameworkContentElement != null )
    {
        frameworkContentElement.DataContext = dataContect;
    }
}

This is not good and pretty as it should be. Let's fix it. Introducing the IFrameworkElement - the missing interface.

IFrameworkElement

IFrameworkElement interface contains all matching members from FrameworkElement and FrameworkContentElement. It also implements IFrameworkInputElement and ISupportInitialize, which both classes implement as well. The way to work with it is to call an extension method (AsFrameworkElement()) defined for a DependencyObject that will return the type as IFrameworkElement if the target is FrameworkElement or FrameworkContentElement, otherwise it will return null. Here is now you can operate with it:

// sender is DependencyObject
var dataContext = "DataContext";
IFrameworkElement frameworkElement = sender.AsFrameworkElement();
if (frameworkElement != null)
{
    frameworkElement.DataContext = dataContect;
}

Why DependencyObject as target?

If you wonder why the method is defined on DependencyObject - simply because this is the common ancestor of both classes.

How is it implemented?

Internally there are two wrappers that wrap FrameworkElement and FrameworkContentElement and implement IFrameworkElement. All the calls to the interface are send to the wrapped element. The actual code is very simple, but about 624 lines long for each element. (It will be a much simpler one line implementation in a dynamic language - C# 4.0 is coming :) ).

You can find a sample solution here. The code can be found on CodePlex too.

Have fun.

WPF Series: Creating Generic Adorner

Stefan Dobrev — Thu, 22 May 2008 15:35:56 +0000

As I have mentioned at the end of the previous post today I will show you how to create a generic adorner, which will allow you to decorate a single element multiple times at different positions. At the end we will be able to create something that looks like this:

To achieve this we will need a way to say that we want to position the adorner at the different corners of the element as well as to specify whether we want to be inside or outside (vertically or horizontally) of the element. Let's create some enumeration types that will serve for this purpose. Introducing AdornerPosition and AdornerPlacement enums.

AdornerPosition

public enum AdornerPosition
{
    Unspecified = 0,
    TopLeft = 1,
    TopCenter = 2,
    TopRight = 3,
    MiddleLeft = 4,
    MiddleCenter = 5,
    MiddleRight = 6,
    BottomLeft = 7,
    BottomCenter = 8,
    BottomRight = 9
}

AdornerPlacement

public enum AdornerPlacement
{
    Unspecified = 0,
    In = 1,
    OutHorizontally = 2,
    OutVertically = 3
}

Each of the enums' values speak for it self, but for clarity here is a diagram that illustrates them:

The final piece is to implement the ArrangeOverride() method of the Adorner class. It looks like this:

protected override Size ArrangeOverride( Size finalSize )
{
    if ( adorningElement != null )
    {
        Point adorningPoint = new Point();
        int pos = (int) position - 1;
 
        Rect adorneredElementRect = VisualTreeHelper.GetContentBounds( AdornedElement );
        Rect adorningElementRect = VisualTreeHelper.GetContentBounds( adorningElement );
 
        adorningPoint.X = ( ( ( pos % 3 ) / 2d ) * adorneredElementRect.Width )
                          - ( ( ( pos % 3 ) / 2d ) * adorningElementRect.Width );
        adorningPoint.Y = ( ( ( pos / 3 ) / 2d ) * adorneredElementRect.Height )
                          - ( ( ( pos / 3 ) / 2d ) * adorningElementRect.Height );
        if ( placement == AdornerPlacement.OutHorizontally )
        {
            switch ( pos % 3 )
            {
                default :
                case 1 :
                {
                    //center column do nothing
                    break;
                }
                case 0 :
                {
                    adorningPoint.X -= adorningElementRect.Width;
                    break;
                }
                case 2 :
                {
                    adorningPoint.X += adorningElementRect.Width;
                    break;
                }
            }
        }
        else if ( placement == AdornerPlacement.OutVertically )
        {
            switch ( pos / 3 )
            {
                default :
                case 1 :
                {
                    //center row do nothing
                    break;
                }
                case 0 :
                {
                    adorningPoint.Y -= adorningElementRect.Height;
                    break;
                }
                case 2 :
                {
                    adorningPoint.Y += adorningElementRect.Height;
                    break;
                }
            }
        }
 
        adorningElement.Arrange( new Rect( adorningPoint, adorningElement.DesiredSize ) );
    }
    return finalSize;
}

That's it. You can now adorn your elements passing different positions and placements. Sample project can be downloaded from here.

Have fun adorning your elements.

WPF Series: Adorners, Commands and Logical Tree

Stefan Dobrev — Wed, 16 Apr 2008 11:04:40 +0000

Today I'm going to tell you a WPF story. But before I start to dig deeper let me first introduce you the main characters in this post. Here they are:

Adorner - adorners are simple UIElement decorators. Suppose that you have a RichTextBox and you want to place a comment box over it, so that users can comment on the text in the box. This can be archived with adorners. Actually the WPF framework uses adorners internally for exactly the same purpose when you edit and annotate FlowDocument in a DocumentViewer. This is the reason why adorners are in System.Windows.Documents namespace.
Command - commands are UI flavored implementation of the command pattern in WPF. You can read about them here.
Logical Tree - There are two control trees in WPF. One is the visual one, the other is the logical one. Imagine a Button for example. The button as logical entity act as a single control, you can click on it etc. However the visual representation of the button contains different UIElements - borders, TextBlock, etc. This means that WPF should maintain two separate control trees, one for the behavior elements - logical tree and one for the visual representation - visual tree. More info here.

There are a bunch of WPF adorners samples out there (including the SDK ones as well). But as usual when you try to create something more complex the standard samples break down. For example let say that we want to achieve something like the mini toolbar in Word 2007:

Let's start our quest with a TextBox that look like this:

and you want to put a simple button next to it that will let say will open a hyperlink that is somehow related to the TextBox. You could easily achieve this with adorners and end up with something which look like this:

How to do this? You could create something like TextBoxAdorner that will derive from Adorner and will look like this:

public class TextBoxAdorner : Adorner
{
    private readonly UIElement adorningElement;
 
    public TextBoxAdorner(TextBox textBox, UIElement adorningElement ) : base( textBox )
    {
        this.adorningElement = adorningElement;
 
        if (adorningElement != null)
        {
            AddVisualChild(adorningElement);
        }
    }
 
    protected override int VisualChildrenCount
    {
        get { return adorningElement == null ? 0 : 1; }
    }
 
    protected override Size ArrangeOverride(Size finalSize)
    {
        if (adorningElement != null)
        {
            Point adorningPoint = new Point();
 
            //position at the end of the text box
            adorningPoint.X = ((TextBox)AdornedElement).ActualWidth;
 
            //position above the text box
            adorningPoint.Y -= adorningElement.DesiredSize.Height;
 
            adorningElement.Arrange( new Rect( adorningPoint, adorningElement.DesiredSize ) );
        }
        return finalSize;
    }
 
    protected override Visual GetVisualChild(int index)
    {
        if (index == 0 && adorningElement != null)
        {
            return adorningElement;
        }
        return base.GetVisualChild(index);
    }
}

Note that we call AddVisualChild() method so that the element that is passed to the constructor will be visible. It is also necessary VisualChildrenCount to return count of 1 and GetVisualChild() to return the UIElement that is added to the visual tree - in our case this is the adorningElement.

So far so good. Now imagine that the button that is added as adorner did not have a click handler, but have a command set. Let's name the command - "NavigateToLink". The command handler is added to TextBox's input bindings, because the TextBox itself "knows" how to execute "NavigateToLink" command. (The sample is with TextBox, but you could imagine have your own custom control that have that logic in it). But what happens when we do this:

As you can see the button is disabled, because the command infrastructure in WPF did not manage to find a handler for our "NavigateToLink" command. This causes the Button to become disabled. Now what?

If you refer to the command readings in the links that were in the beginning of the post you will find our that the command mechanism in WPF uses the logical tree of controls to find handlers for particular commands. This bring us to point where we added the Button to visual tree. In our case we will have to add it as a logical child of the TextBox as well. This will automatically add it the logical tree of controls and the command handler will be correctly resolved and the Button enabled. Here is the new constructor of TextBoxAdorner class:

public TextBoxAdorner(TextBox textBox, UIElement adorningElement ) : base( textBox )
{
    this.adorningElement = adorningElement;
 
    if (adorningElement != null)
    {
        AddVisualChild(adorningElement);
        textBox.AddLogicalChild( adorningElement );
    }
}

Here comes the other problem. For encapsulation reasons the AddLogicalChild() method of FrameworkElement is marked as protected internal and can not be called as we call it in the snippet above. One way to workaround this is to derive from TextBox and make the method internal for your assembly. The other way is to use reflection and call the method. You can even create an extension method that will be available for all FrameworkElements. To make it even more extreme you can use expression trees to cache the method call and optimize the reflection. Here is the code:

internal static class FrameworkElementExtensions
{
    private static readonly Action<FrameworkElement, object> AddLogicalChildMethod = CreateAddLogicalChildMethod();
 
    private static Action<FrameworkElement, object> CreateAddLogicalChildMethod()
    {
        ParameterExpression instance = Expression.Parameter( typeof ( FrameworkElement ), "element" );
        ParameterExpression parameter = Expression.Parameter( typeof ( object ), "child" );
 
        MethodInfo methodInfo = typeof ( FrameworkElement ).GetMethod(
            "AddLogicalChild", BindingFlags.NonPublic | BindingFlags.Instance );
        MethodCallExpression method = Expression.Call( instance, methodInfo, parameter );
 
        Expression<Action<FrameworkElement, object>> lambda =
            Expression.Lambda<Action<FrameworkElement, object>>( method, instance, parameter );
 
        return lambda.Compile();
    }
 
    internal static void AddLogicalChild( this FrameworkElement element, object child )
    {
        AddLogicalChildMethod( element, child );
    }
}

You can find a sample solution here. Go play with it.

That its all for now folks. Next time I will show you how to create a generic adorner that can be used to decorate elements multiple times at different positions.