Here is a scenario: For WPF and Silverlight it is pretty much standard these days to write a ViewModel class that encapsulates a Model class in a way that makes WPF/Silverlight databinding easier and adds additional properties that are only relevant to the view. One way is to implement INotifyPropertyChanged in the ViewModel. For a class:

    public class Customer 
    { 
        public string Email { get; set; } 
        // ... 
    }

you write a corresponding ViewModel class

    public partial class CustomerViewModel : INotifyPropertyChanged 
    { 
        public CustomerViewModel(Customer modelElement) 
        { 
            this._modelElement = modelElement; 
        } 

        private readonly Customer _modelElement; 
        public string Email 
        { 
            get { return _modelElement.Email; } 
            set 
            { 
                if(value != Email) 
                { 
                    Email = value; 
                    OnPropertyChanged("Email"); 
                } 
            } 
        } 
        // ... 
    }

Pretty tedious.

With T4 and the Visual Studio Code Model you can read the properties of the Model class (Customer in our example) and generate the ViewModel wrapper. Here is roughly what I do, a running Visual Studio 2010 RC project is attached.

To get to the data (= the code in the other file) you write a small code block in the T4 file.

    ProjectItem inputProjectItem = DTE.Solution.FindProjectItem(inputFileName);
    FileCodeModel codeModel = inputProjectItem.FileCodeModel;
    CodeClass modelClass = FindCodeElement<CodeClass>(codeModel.CodeElements);

All the methods are in VS libraries except FindCodeElement<T> . It basically traverses the hierarchy that is created by the CodeElement.Children property and finds the first type that matches. In our case it is a CodeClass . CodeClass has a property called Members that returns a list that contains CodeProperty instances.

<#  foreach(CodeProperty prop in modelClass.Members)
    { #>
        public <#= prop.Type.AsString #> <#= prop.Name #>
        {
            get { return _modelElement.<#= prop.Name #>; }
            set
            { 
                if(value != _modelElement.<#= prop.Name #>)
                {
                    _modelElement.<#= prop.Name #> = value;
                    OnPropertyChanged("<#= prop.Name #>");
                }
            }
        }
<#    } #>

This is the core of the idea. In the attached demo Solution I also did a bit more around formatting and you will see the necessary references and imports .

This is obviously not complete. To make this ready for real use one would need to think about references between Model classes, access modifiers, methods, naming, namespaces and more.

Some more background info and inspiration can be found on Gareth Jones' blog. And Colin Eberhardt has a sophisticated solution and more complete that uses the same ideas.

DryadLINQ is a programming environment that does automatic parallelization and is based on LINQ. To describe the power of the framework the Microsoft Research Project page has some sample code that shows how to implement MapReduce

public static IQueryable<TResult>
MapReduce<TSource, TMap, TKey, TResult>(this IQueryable<TSource> source,
                                        Expression<Func<TSource, TMap>> mapper,
                                        Expression<Func<TMap, TKey>> keySelector,
                                        Expression<Func<TKey, IEnumerable<TMap>, TResult>> reducer)
{
    return source.SelectMany(mapper).GroupBy(keySelector).Select(reducer);
}

Isn’t that nice. The full power of functional programming :-) . And suddenly MapReduce makes sense.

Of course there is some heavy lifting going on internally. It also shows that the DryadLINQ thing is more general than an implementation that does MapReduce only. I love .NET :-)

But from time to time you want to implement your own collection class and that poses a slight challenge because you need implement to INotifyCollectionChanged. This interface is used by the Data Binding mechanism to figure out if and what has changed in the collection it binds to.

The challenge that I had a few times is, to figure out how to call the constructor of NotifyCollectionChangedEventArgs. It has 11 (in words eleven) overloaded versions of the constructor. The first argument of all constructors are an enumeration that stated the change "action" NotifyCollectionChangedAction. That is the easy part, but what to do with the remaining parameters?

It is all documented in the MSDN Library but it is in the wrong order: for each constructor it tells you which action can be used. But you need know which constructor to use for a certain action. So I create the small table below.

	Reset	Add	Remove	Replace	Move
EventArgs (Action)	x
EventArgs (Action, IList changedItems)	x	x	x
EventArgs (Action, object changedItem)	x	x	x
EventArgs (Action, IList changedItems, int startingIndex)	x	x	x
EventArgs (Action, object changedItem, int index)	x	x	x
EventArgs (Action, IList newItems, IList oldItems)				x
EventArgs (Action, object newItem, object oldItem)				x
EventArgs (Action, IList newItems, IList oldItems, int startingIndex)				x
EventArgs (Action, object newItem, object oldItem, int index)				x
EventArgs (Action, IList changedItems, int index, int oldIndex)					x
EventArgs (Action, object changedItems, int index, int oldIndex)					x

And suddenly it makes sense: four versions for add & remove (single& list, indexed and not), four versions for replace, two versions for move (single & list). (Why Reset has five versions is still not clear to me ).

Hope that it is useful

I had the pleasure to present at a Developer Conference in Denver, CO last Thursday. It is coined 'the Big Event', and it deserves it's name, not necessarily in terms of numbers (my guess iss 300+ attendees) but how it was organized: down-to-earth, time for discussion, clear agenda. Thank you very much Joe for inviting me.

If you want to see the PowerPoint you can find it on SkyDrive  (10.2 MB, sorry).

- Christof

I am on my way returning from ReMIX 07 Boston.

https://www.remix07boston.com/

It has been a long time since I presented in public. But this was definitly a conference worht going to. Great mix of content and it seemd that the attendees like it a lot.

I had two presentations: Bring back the User into Architecture and What an Architect needs to know about Architecture.

My slides can be found here https://cid-ff9137c9a26814d6.skydrive.live.com/self.aspx/Boston/ I used skydrive the first time. hope that works.

Thanks, Christof

A while ago I played around with DataBinding an tried to implement a Sudoku Game similar to Sudoku in the WPF tutorial https://blogs.msdn.com/coding4fun/archive/2006/11/06/999502.aspx 

One thing that is not in that game is, that some People (including me :-) ) like to enter all possible numbers in each cells of the grid and narrow it down stp by step till only one number is left in the cell.

I implemented a kind of a bit-set that can contains digits from 1 to 9. And wanted to bind it to each of the 9x9 cells of the Sudoku game in a small grid where the digits are shown or hidden accordingly.

I exposed the individual digits through an indexer that returns a Boolean value.

I bind this bitset to a TextBlock that is either shown or hidden according to the Boolean value of the indexer

This goes on for all nine elements. I had to use a converter since the Visibility is not boolean but an enumeration.

It worked great, only the digits are shown that are in the bitset.

But: updates to the bitset where not reflected in the UI. I knew it had something to do with INotifyPropertyChange or INotifyCollectionChanged but couldn't find anything.

Beatriz Costa https://www.beacosta.com/blog/ helped me and showed me that the Binding class is looking for "Item[]" in the argument of the PorpertyChanged Event

So with the following code did it :

Thanks Beatriz.

Christof worked for many years as an Architect and Evangelist in Germany, has a broad eperience in working with customers and presenting at events and enjoys the technologies and methodologies that have good amount of pragmtism as well as a thought-out foundation.

I recently had the chance to spend quite some time to familiarize myself with WPF. But I do not have endless time (who has?). And I will probably not spend more than a few hours a month programming with WPF. I thought it might be a worthwhile exercise to define my top 10 list of cool and useful things in WPF.

My reasoning behind this is

• WPF is a complex but promising piece of technology
• How can you work with people that use it, discuss with them without spending weeks of in depth training.
• What are the principals behind WPF and why do people think it is better than technologies before

There is no specific order in the list and I might change my mind what is a core feature in the future anyway. Would love to hear your feedback.

1)    XAML as the Markup: XAML goes in some ways beyond XML with rules simple to understand. Sure there are other ways, but I like it.
2)    Dependency properties as a basis for features such as data binding, styling, triggers, and animation. Who knows how long it takes till they are part of a framework.
3)    Styles & Triggers: CSS shows that this is very useful
4)    Layout system: practical to use out of the box and extensible
5)    Control templates: Separation of appearance and behavior
6)    Input + events : right level of abstraction
7)    Animation : declarative rocks :-)
8)    Databinding : easy and very flexible in combination with the templates and all.
9)    Documents, Text: haven’t seen a lot yet but it looks as powerful as TeX
10)  Integration of 2D and 3D : the fact that there is 3D is great in its own, but the integration will make it more pervasive