I always wanted to get my hands dirty with a little expression tree magic but never had the time to do so. When test driving code of a component you are currently working on you might feel in the middle of the “Do a little change, let it fail, make it green” process that your component needs an event which is publicly visible and can be subscribed by clients. But how would you test that the event is fired on your component’s interface? I’ll show you how this is normally achieved and how an event tester could simplify the process.

.NET AutoAttachEventTester, EventTester, Expression Trees, TDD

In this post, we are going to have a look at UI commands. UI commands are responsible for reacting to user input, for example the send button click in the sample I use throughout this series of agile user interface development in .NET series. For other posts in this series look here: table of contents.

We have seen in the last post that the view binds a command to the send button that it gets from the view-model:

<Button Command="{Binding SendMessageCommand}" IsDefault="True">Send</Button>

.NET, Administration, Agile .NET, Agile, Architecture, Design, User Interface, WPF

Last time we started looking at sample code with the view-model class for the UI to send messages on channels (table of contents).

In this post, we continue with the next responsibility, the visualization.

The View

The view is responsible for visualizing the domain model to the user. We have seen in the last post that the view-model provides a simplified mini-model to the view. That means that the view does not have to care about the domain model as a whole with all its interactions and constraints. The view-model provides only the part of the domain model that is relevant to the current screen the user is seeing thus simplifying the job of the view.

.NET, Administration, Agile .NET, Agile, Architecture, Design, User Interface, WPF

After the posts (table of contents) in which I covered why we need an agile UI design pattern, it’s big picture and the needed tools, I start digging into sample code. I’ll show in each post a small part of the whole picture. If you want to get all at once then you find the source of all samples at http://sourceforge.net/projects/procollee. ProCollEE is my playground to experiment with WPF and UI design.

Lets start

Yes, let’s start. But where?

There is one UI design pattern – presenter first (link) – that explicitly states where to start in its name. But unfortunately, the presenter first pattern packs too many responsibilities into the presenter. Therefore, not the best source to get an answer from.

But we have to start somewhere, don’t we?

In my experience, I normally know what has to be visualized in a dialog or window, but I don’t know yet how exactly the data is visualized or where to get it from.

.NET, Administration, Agile .NET, Agile, Architecture, Design, User Interface, WPF

In the last post, I showed you the big picture of my UI design pattern. Before I can start showing you sample code for the different parts, I need to introduce some tools, which are used to glue all the tiny parts together:

• Dependency Injection
• Design By Contract
• Synchronous and Asynchronous Communication
• Test Driven Development

.NET, Administration, Agile .NET, Agile, Architecture, code contracts, event broker, Ninject, Test Driven Development, User Interface

My series on agile UI development in .NET consists of several individual posts. To simplify navigation, you’ll find here an up-to-data table of contents with links.

Stay tuned for updates…

Introduction

UI Responsibilities

The Big Picture

Tools

View-Model

View

UI Commands

Presenter

Model Commands

Nested Views

Uncategorized

In the last two posts of this series (table of contents) I explained the need for a new UI design pattern: changeability and extensibility.

In this post, I’ll throw a big diagram in your face without much explanation. The reason for this is that I want to give you the big picture before I start digging into details in the following posts of this series. You can always come back here to see where we are.

The Big Picture

.NET, Agile, Architecture .NET, Agile, Architecture, Design, MVVM, User Interface, WPF

In the first post in this series (table of contents) I explained why agile software development influences the choice of the UI design pattern. For short, changeability and extensibility are must have characteristics.

In this post, I’ll show you the corner stones of a UI design pattern that fulfills these needs.

Principles of Object Oriented Software Design – SOLID

One of the best known set of principles to achieve my goal of a UI design pattern that is changeable and extensible is SOLID by Robert C. Martin (link).

If you don’t already know those principles then please follow the above link and read it before continuing here.

The principle I’m most interestes at the moment is the S in SOLID, the Single responsibility principle:
A class should have one, and only one, reason to change.

.NET, Agile, Architecture .NET, Agile, Architecture, Design, User Interface

There are a lot of patterns available for UI architecture: Model-View-Presenter (MVP), Model-View-Controller (MVC), Passive View, Model View View-Model (MVVM) and some more.

However, none does really fit my needs in an agile project.

In this series, I’ll show you first why they don’t work for me and then I’ll try to evolve a pattern that matches the special needs in agile software development.

Why is Agile Software Development different?

In agile development, we start little and add small parts to evolve a complete application. This approach allows us to deliver every sprint (= iteration in Scrum terminology; 2 weeks in our case) a working software and  to get early feedback from our customer.

When we start a project, we don’t have a complete requirement specification (nor do we want one). The requirements (or user stories in Scrum) evolve together with the software: appetite comes with eating. The requirements get clearer and more precise as we learn more about what the software has to do and how we can implement them providing best user experience.

.NET, Agile, Architecture .NET, Agile, Architecture, Design, User Interface

PartCover is an open source coverage tool. Unfortunately, the current release does not run on a 64bit OS out of the box. The reason is that PartCover uses a 32bit COM component to determine coverage and that a 64bit process cannot load a 32bit COM component.

.NET, Software corflags, coverage, PartCover, x64