WPF Application Framework (WAF)

New Post: Login (inferring existence of different user roles) and modules composition

elemont071 — Thu, 23 May 2013 13:42:06 GMT

Hello,

Thank you, first, for the quality and amount of work put in this framework.
Recognizing here and there the whys and hows the framework is built in such a way is utterly impressive. I know why I want it.

I would like in the meantime ask you any advise about a new application we are about to develop. the application is multi users and multi roles, depending of the role of the current user.

I would like to ask advise on implementing use-cases for more advanced roles (admin);

would it be acceptable to place the implementation of these - restricted- use-cases within Extension modules?

If this makes sense up to here, would it be reasonable to "MEF" compose the different parts after the login is actually performed?

Or, said in another manner, having the application composed in two phases? Minimal to offer logins then the in a second phase the construction of right extension based on current role of the user?

Let me know if I m about to hit the wall too hard.
Thank you very much in advance.

New Post: How to update a cell in a DataGrid once another cell is modified on the same row?

Sabba — Thu, 23 May 2013 10:10:27 GMT

Hello!

I have developed a program to display and edit data in a DataGrid, based on the Book Library sample. My setting are:

Data Mapping: Entity Framework

Database: SQL Server 2010

Binding main table: tblAddress; fields: Address_ID (auto-incremented), FK_Contact_ID, Address_1, Address_2, ...

Binding foreign (linked) table: tblContact; field: Contact_ID (auto-incremented), ContactName

Navigation Property: AddressToContact (tblAddress.FK_Contact_ID ==> tblContact.Contact_ID)

DataGrid Columns: Address_ID, FK_Contact_ID, ContactName, Address_1, Address_2, ...

XAML:

<DataGrid x:Name="xDataGrid" DataContext="{Binding}" ItemsSource="{Binding AddressCollection}" SelectedItem="{Binding SelectedAddress}" SelectionChanged="DataGridSelectionChanged">
<DataGrid.Columns>
            <DataGridTextColumn Header="Address_ID" IsReadOnly="True"
                    Binding="{Binding Address_ID,  Mode=OneWay}" />

            <DataGridTextColumn Header="FK_Contact_ID" 
                    Binding="{Binding FK_Contact_ID, Mode=TwoWay, 
                    UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True, ValidatesOnExceptions=True, NotifyOnValidationError=True}" />
<DataGridTextColumn Header="ContactName" 
                    Binding="{Binding AddressToContact.ContactName, Mode=TwoWay, 
                    UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True, ValidatesOnExceptions=True, NotifyOnValidationError=True}" />
</DataGrid.Columns>
</DataGrid>

When I run the application all cells are populated from the database correctly. However, when I change a cell value in the FK_Contact_ID column, the corresponding ContactName cell should get updated automatically; but it does not until I click on it.

Please advise how I can fix this issue. In fact, the Mode attribute of the ContactName column should be set to OneWay.

If you need more info, please let me know.

Regards

Sabba

Closed Issue: BookLibrary: Backspace in a cell doesn't produce a validation error. [7106]

jbe2277 — Thu, 16 May 2013 11:50:43 GMT

Steps to reproduce:
1. Start BookLibrary sample application
2. Select the first cell in the DataGrid (title of the first book)
3. Press the Backspace key
4. Press the Tab key to commit the change

No validation error is visible. But it should be shown because the Title property is defined as Required.

Closed Issue: WAF Template installer not compatible with VS11 Beta [7808]

jbe2277 — Thu, 16 May 2013 11:50:42 GMT

The WAF Template installer is not compatible with VS11 Beta. It cannot be installed.

Closed Issue: Model class SetValue does not work for nullable properties [8020]

jbe2277 — Thu, 16 May 2013 11:50:42 GMT

The SetValue method on System.Waf.Foundation.Model class does not support nullable types. In some scenarios, e.g. binding a three-state checkbox to a bool?, it would be necessary.

Closed Issue: Error when use with Telerik RadTreeListView. [8183]

jbe2277 — Thu, 16 May 2013 11:50:42 GMT

This is the error when I use waf with Telerik RadTreeListView. I think DataModel class should marked a serializable, because sometime we need to serialize classes that inherits from Datamodel class.
Best,
Asad

Type 'System.Waf.Applications.DataModel' in Assembly 'WpfApplicationFramework, Version=2.5.0.6, Culture=neutral, PublicKeyToken=null' is not marked as serializable.

Closed Issue: BookLibrary: edit mode lost [8478]

jbe2277 — Thu, 16 May 2013 11:50:41 GMT

Steps to reproduce:

1. Start BookLibrary sample application

2. Add a new book

3. Click to the new row to be able to edit it but do type any character

4. Click to remove button

Now you cannot edit the DataGrid. It is the same with the persons.
Maybe you should not be able to leave a non valid row?

Updated Wiki: Modular Architecture

jbe2277 — Fri, 10 May 2013 07:37:02 GMT

Modular Architecture

1. Introduction

Applying only the Layered Architecture for structuring a large software system into maintainable parts might not be sufficient. The Modular Architecture can solve this issue. It extends the layering by introducing another dimension to separate the software system.

Separation dimensions:

Layers separate the software artifacts into technical groups (e.g. Presentation layer contains UI related code).
Modules separate the software artifacts into distinct parts which are often specific domain aspects (e.g. an email client might separate the email management implementation and the address book implementation into separate modules).

Figure 1: Shows the two separation dimensions of layers and modules.

2. Motivation

Applying the Modular Architecture gives us the following advantages:

Provides a simple and clean software structure.
Prevents that unrelated classes depend on each other.
Changing the implementation of a module doesn’t affect other modules.
Reduces the efforts to maintain and extend the software system. This comes of fewer dependencies in the software system.
Helps to scale the software development to more development teams. A Modular Architecture requires good interfaces between the modules. These interfaces can be used to separate the responsibilities of the development teams.
Developers can concentrate on their own modules and don’t need to understand the implementation of the other modules. They just work with the “documented” interfaces of the other modules.
Simplifies unit testing because dependent modules can be replaced by mock implementations.

Note: These advantages are not for free! They are seen only if the development teams follow the Software Architecture rules. And that requires a severe discipline of all involved developers.

3. Participants

The three types participating in a Modular Architecture are: Module; Interface; Application Framework.

Figure 2: Shows the participants of a Modular Architecture.

3.1. Module

A module contains all software artifacts for a distinct part of the software system. This distinct part represents often a specific domain/business aspect.

Characteristics

A module contains all the types that are necessary to implement the distinct part of the software system.
A module is responsible for all technical aspects. This might include the user interface for the module’s domain or the persistency. Therefore, a module consists of various layers.
A module must not have a direct dependency to another module.
Communication between modules must be decoupled by an Interface.
A module can be replaced by another module without the need to recompile the software system.
A module consists of one or more .NET Assemblies.

Common Issues

A module has an assembly reference to another module. As a result, these modules aren’t decoupled of each other.
Avoid creating too much modules in a software system. The overall complexity will rise because the communication between the modules must be decoupled.
A module does not focus on the specific part for which it is responsible for. This results in a negative impact on the understandability and manageability of the code.

3.2. Interface

The interface exposes the public functionality of a module. Different modules can communicate via this interface with each other.

Characteristics

An interface contains the types that are necessary to expose the public functionality of one module.
Other modules might use this public functionality. Thus, they have a direct dependency to the interface.
The types can be:
- Interfaces
- Data Transfer Objects (DTO). These are simple immutable objects without any logic.
- EventArgs. These classes are similar to DTOs.
The number of types in the interface assembly should be low. This ensures low coupling between the modules.
An interface consists of one or more .NET Assemblies. In most scenarios only one .NET Assembly is used.

Common Issues

If the interface contains a lot of types then this can be a sign that the module boundaries are not chosen well. Bloating interfaces tighten the coupling between the modules and this lowers the advantages of the Modular Architecture (see 2. Motivation).
Every module that exposes public functionality must provide it’s on interface assemblies. An interface is implemented by only one module but it can be used by any module.
Avoid exposing the module’s domain objects via the interface. Instead, create a DTO object which contains the required data.

Quality

Changing the interfaces has a huge impact on the whole software system. Therefore, the quality of the interfaces is very important. Here are some recommendations to improve the quality of the interface assemblies:

Apply code reviews.
Activate Code Analysis with “Microsoft All Rules”.
Enable XML Comments. Use them to document the interface members.
Write a document about the usage of the module’s public functionality. Consider to add important design decisions regarding the interface to this document.

3.3. Application Framework

The application framework is the foundation for the software system. It contains all the types that should be shared between multiple modules.

Characteristics

The application framework might provide reusable types of various layers. Examples:
- Presentation layer: Custom controls, global ResourceDictionaries
- Domain layer: Custom base class for domain objects
The WPF Application Framework (WAF) can also be seen as application framework. It provides types that can be used by all modules (e.g. ViewModel).

Common Issues

Avoid using the application framework to overcome the effort to decouple the module communication.
Do not implement types that are used by only one module. These types should reside within the responsible module.

Quality

Changing the application framework has a major impact on the whole software system. All modules might have a dependency to this framework. For that reason, the quality is very important. Here are some recommendations to improve the quality of the application framework:

Apply code reviews.
Activate Code Analysis with “Microsoft All Rules”.
Enable XML Comments. Use them to document the public types and members.
Write a document about the usage and architecture of the application framework.

4. Alternative: Extensions

Sometimes it is not appropriate to separate a part of the system into two modules because they would have to work tightly together. Consequently, this would create a bloating interface for the communication.

In that case the usage of an extension might be the better choice. An extension is part of the module and thus, it is able to access the internal implementation.

Figure 3: Shows the dependency between the core implementation and the extension.

Example

The BookLibrary sample application comes with a reporting extension. This extension allows the user to create reports about the books in the library. The extension needs full access to the Book and Person entities (domain objects).

Characteristics

The extension can easily be replaced with another implementation (e.g. a mock implementation to simplify the unit testing of the module).
The module might be implemented in a way that the availability of the extension is optional.
An extension is part of one module. It cannot be reused by other modules.

Updated Wiki: Downloads

jbe2277 — Sun, 21 Apr 2013 13:33:03 GMT

Downloads Overview

Stable

Platform	Version	Date	Download
.NET Framework 4.0	2.5.0.400	Dec 08 2012	WPF Application Framework (WAF) 2.5.0.400
.NET Framework 4.0	2.5.0.1	Jan 03 2013	WAF Project Template
.NET Framework 4.0	2.0.0.400	Sep 19 2011	WPF Application Framework (WAF) 2.0.0.400
.NET Framework 4.0	1.0.0.400	Aug 13 2010	WPF Application Framework (WAF) 1.0.0.400
.NET Framework 3.5 SP1	1.0.0.350	Jun 18 2010	WPF Application Framework (WAF) 1.0.0.350

Alpha

Platform	Version	Date	Download
.NET Framework 4.5	3.0.0.5	Apr 21 2013 (NEW)	WPF Application Framework (WAF) 3.0.0.5

Experimental

Platform	Version	Date	Download
.NET Framework 3.5 SP1	1.0.0.1	Sep 19 2010	WAF Windows Forms Adapter 1.0.0.1
Silverlight 3	1.0.0.0	Jul 12 2009	WAF Concepts in Silverlight 3 (Experimental)

Created Release: WPF Application Framework (WAF) 3.0.0.5 (Apr 21, 2013)

jbe2277 — Sun, 21 Apr 2013 13:31:50 GMT

Version: 3.0.0.5 (Milestone 5): This release contains the source code of the WPF Application Framework (WAF) and the sample applications.

Please build the whole solution before you start one of the sample applications.

Requirements

.NET Framework 4.5 (The package contains a solution file for Visual Studio 2012)

Changelog

Legend: [B] Breaking change; [O] Marked member as obsolete
WAF: Add the ValidatableModel class that implements the INotifyDataErrorInfo interface.
WAF: Improve ValidationErrorsConverter to support ValidationResult objects as well.
BookLibrary: Refactor the domain objects to use the new ValidatableModel class.
InfoMan: Refactor the PresentationService implementations to overcome a WPF bug.
Samples: Fix bug in upgrade the settings file from a previous version.

Other Downloads

Downloads Overview

Released: WPF Application Framework (WAF) 3.0.0.5 (Apr 21, 2013)

Sun, 21 Apr 2013 13:31:50 GMT

.NET Framework 4.5 (The package contains a solution file for Visual Studio 2012)

Changelog

Legend: [B] Breaking change; [O] Marked member as obsolete
WAF: Add the ValidatableModel class that implements the INotifyDataErrorInfo interface.
WAF: Improve ValidationErrorsConverter to support ValidationResult objects as well.
BookLibrary: Refactor the domain objects to use the new ValidatableModel class.
InfoMan: Refactor the PresentationService implementations to overcome a WPF bug.
Samples: Fix bug in upgrade the settings file from a previous version.

Other Downloads

Downloads Overview

New Post: Using VS 2012 (or even 2010) - project errors

jbe2277 — Sat, 20 Apr 2013 10:26:47 GMT

Please build the whole solution before you start one of the sample applications.

New Post: Using VS 2012 (or even 2010) - project errors

raisen — Sat, 20 Apr 2013 07:56:14 GMT

Hi jbe2277,

I have just downloaded the 3.0.0.4 version and tried to load the Book Library sample application but I'm getting the following error on line 58 of App.xaml.cs:

Could not load file or assembly 'Waf.BookLibrary.Reporting.Presentation.dll' or one of its dependencies. The system cannot find the file specified.

New Post: EntityController

3WaySoftware — Mon, 08 Apr 2013 07:07:16 GMT

Thnx for the insights

The second approach matches what i had i mind. the idea is that some modules will be reusable in different apps so it clearly must be separated from the rest completely. on the other had some app can have different implementations depending on the customer where the app is deployed. e.g. contacts and contactsex...

A major requirement is that not the complete app should be rebuild when minor changes are done in one of the modules...

this way however it requires a separate context for each module...
There is still one problem and that will be the reporting module needing data from different tables across the different modules. this requires duplicate entity classes over the modules and most likely require a rebuild of the reporting module when module database changes occur...

it's acceptable to me (not ideal) but was wondering if there would be a better approach for this!?

any suggestions on this are welcome.

New Post: EntityController

jbe2277 — Sun, 07 Apr 2013 18:39:38 GMT

You could put the entity related stuff into the “Common” projects. All modules have access to the “Common” assemblies.

But from an architectural point of view I do not recommend this approach. If you create 7 modules then this modules should be isolated of each other. This is important because the modules should be able to evolve independently of each other. Modifications of one module should not affect another module.

Isolating the modules is not possible if they share the same entities (or the same database tables). The module separation has not only to be done on code level but on data storage level as well.

Dependent on the situation I recommend one of the following approaches:

If different modules have to work with the same domain objects (entities) then they should not be divided into separate modules.
If different modules work with the same database but use different database tables, views, etc. then every module should get its own domain objects (entities) and persistency related code. But these domain objects must not be shared between modules. Data that needs to be shared should be transferred via DTO (data transfer objects) between the modules.

New Post: Using VS 2012 (or even 2010) - project errors

jbe2277 — Sun, 07 Apr 2013 18:23:17 GMT

Could you provide me more information?

Which download/version of the WPF Application Framework are you using?
Which version of Visual Studio 2010 are you using (e.g. Express, Ultimate)?
Do you have installed the Service Pack 1 for Visual Studio 2010?

However, the “Code Snippets” are not important for the WPF Application Framework (WAF) libraries or the sample applications. You can ignore this message.

New Post: EntityController

3WaySoftware — Fri, 05 Apr 2013 22:26:16 GMT

Hi,

I started from the Information manager sample to a POC for an modular app.

now i was just wondering where to place the entity related stuff...

Any suggestions... database is shared over 7 of the modules...

thnx Mike

New Post: Using VS 2012 (or even 2010) - project errors

imDanish — Thu, 04 Apr 2013 14:22:25 GMT

VS 2010 Says Code Snippets.dll missing ... ??

Commented Issue: Crash adding a new record from DataGrid [8627]

gusi — Sat, 23 Mar 2013 11:26:30 GMT

BookApplication, press Add to add a new book, click on Title to start editing cell, then lose focus clicking on another control (for example, "Address Book" tab) and there is an exception from line

_Title = StructuralObject.SetValidValue(value, false);

because it tries to set a null value to the Title.

How can this be avoided?
Comments: ** Comment from web user: gusi **

Hi! And thanks for checking this.
You're right, I had the debugger set to halt on exceptions, but without the debugger the exception is correctly handled. Sorry for not seeing this first! :(

Commented Issue: Crash adding a new record from DataGrid [8627]

jbe2277 — Sat, 23 Mar 2013 11:00:30 GMT

Thank you for your feedback.

I’m able to see this exception in the Debugger but the BookLibrary application doesn’t crash. The exception is catched by the WPF Binding infrastructure. Therefore, this shouldn’t be an issue.

The exception comes because the Title column in the database is set to Nullable = false. When the WPF Binding tries to write “null” into the property setter then this exception is thrown. You might initialize the Title and Author properties with “string.Empty” in the constructor of the Book class.

This exception does not occur anymore in the new WAF BookLibrary sample application because now it uses the POCO approach.