Fabrice's weblog : Architecture

New article: How to detect and avoid memory and resources leaks in .NET applications

Fabrice Marguerie — Mon, 02 Nov 2009 23:32:00 GMT

My new article, which I've been preparing over the last few months, is now available. It's about memory and resources leaks in .NET.
You'll find it in English on MSDN and in French on DotNetGuru.org. It's also available in PDF in English and in French.

Here is the table of content:

Introduction
Leaks? Resources? What do you mean?
How to detect leaks and find the leaking resources
Common memory leak causes
Common memory leaks causes demonstrated
How to avoid leaks
Tools
Conclusion
Resources

Despite what a lot of people believe, it's easy to introduce memory and resources leaks in .NET applications. The Garbage Collector, or GC for close friends, is not a magician who would completely relieve you from taking care of your memory and resources consumption.
I'll explain in this article why memory leaks exist in .NET and how to avoid them. Don't worry, I won't focus here on the inner workings of the garbage collector and other advanced characteristics of memory and resources management in .NET.
It's important to understand leaks and how to avoid them, especially since they are not the kind of things that is easy to detect automatically. Unit tests won't help here. And when your application crashes in production, you'll be in a rush looking for solutions. So, relax and take the time to learn more about this subject before it's too late.

Mon nouvel article, que j'ai préparé durant ces derniers mois, est maintenant disponible. Il parle des fuites de mémoire et de ressources en .NET.
Vous le trouverez en français sur DotNetGuru.org et en anglais sur MSDN. Il est également disponible en PDF en français et en anglais.

Voici la table des matières :

Introduction
Fuites ? Ressources ? Qu'entendez-vous par là ?
Comment détecter des fuites et repérer les ressources qui fuient
Les causes habituelles de fuites de mémoire
Les causes habituelles de fuites en pratique
Comment éviter les fuites
Outils
Conclusion
Ressources

En dépit de ce que beaucoup de personnes pensent, il est facile d'introduire des fuites de mémoire et de ressources dans les applications .NET. Le Garbage Collector, également appelé ramasse-miettes ou GC pour les intimes, n'est pas un magicien qui vous affranchirait totalement de vous soucier de la consommation de ressources et de mémoire.
J'expliquerai dans cet article pourquoi les fuites de mémoire existent en .NET et comment les éviter. Ne vous en faites pas, je ne vais pas me focaliser ici sur le fonctionnement interne du garbage collector et autres caractéristiques avancées de la gestion de la mémoire et de ressources en .NET
Il est important de comprendre les fuites et comment les éviter, particulièrement car elles n'entrent pas dans la catégorie des choses facilement détectables de manière automatisée. Les test unitaires ne vous aideront pas ici. Et quand votre application se plantera en production, vous serez à la recherche de solutions dans l'urgence. Alors, détendez-vous et prenez le temps dès maintenant d'en apprendre plus sur ce sujet avant qu'il ne soit trop tard.

UI design patterns libraries

Fabrice Marguerie — Sun, 15 Feb 2009 13:34:00 GMT

Over the time, I've collected a set of UI design patterns libraries. Some of them present patterns with descriptions and advices, others collect screenshots of UI designs. With all the available sites, you have a lot of patterns to tap into for your sites and applications!

Feel free to suggest more UI patterns collections.

.NET sessions at the Université du SI and .NET 3.5+ expertise

Fabrice Marguerie — Mon, 02 Jun 2008 21:09:00 GMT

I announced in April that I'll be part of the Université du Système d'Information event on July 2 and 3. With Frédéric Schäfer, we're actively preparing our session, which will allow you to discover in action no less than .NET 3.5, Visual Studio 2008, ADO.NET Entity Framework, LINQ, WPF and Silverlight.

On Octo's blog, Frédéric gives the complete list of sessions that will cover .NET (in French).

I'd like to take this opportunity to announce that I'm available to give presentations and training about the above technologies and products. If you're getting started with VS 2008, C# 3.0, .NET 3.5 and the accompanying tools, feel free to contact me!

J'ai annoncé début avril ma participation à l'événement Université du Système d'Information, organisé par Octo. Avec Frédéric Schäfer, nous sommes actuellement en pleine préparation de notre session, qui vous permettra de découvrir en action pas moins que les technologies et outils .NET 3.5, Visual Studio 2008, ADO.NET Entity Framework, LINQ, WPF et Silverlight. Notre session d'une heure et demie se présentera sous la forme du développement en direct d'une application d'exemple utilisant les technologies sus-citées.

La session que nous allons présenter n'est pas la seule abordant .NET parmi la soixantaine que comprend l'événement. Frédéric reprend d'ailleurs la liste des sessions traitant de .NET sur le blog d'Octo :

Building Web Applications Using Volta par Erik Meijer (Microsoft)

Les défis de l'utilisation de LINQ to SQL par Guy Barette (Indépendant)

Survol des nouvelles techniques d'accès aux données de Microsoft par Guy Barette (Indépendant)

Séparation des préoccupations: Nouveautés pour diminuer le couplage et augmenter la cohésion par Mario Cardinal (Indépendant)

Futur de Java et Csharp par Alexis Moussine-Pouchkine (Sun) et Vincent Guigui (Octo)

L'avenir est aux technologies vectorielles ! par Christian Blavier (Octo) et Eric Groise (Octo)

Venez expérimenter en direct les dernières innovations de .NET par Fabrice Marguerie (Indépendant) et Frédéric Schäfer (Octo)

J'aimerais profiter de l'occasion pour annoncer que je suis disponible pour donner des présentations ou des formations sur les technologies couvertes durant notre session. Si vous démarrez avec VS 2008, C# 3.0, .NET 3.5 et les outils qui les accompagnent, n'hésitez-pas à me contacter !

Acropolis is around the corner

Fabrice Marguerie — Tue, 05 Jun 2007 10:34:00 GMT

If you are working with the CAB (Composite UI Application Block) or the SCSF (Smart Client Software Factory), you should check out Acropolis. If you are not using CAB or SCSF but you need to develop Windows applications, you should take a look at Acropolis too!

Acropolis has just been announced by Brad Abrams and others. It's supposed to be the integration of ideas and concepts from CAB and SCSF into Visual Studio.

Acropolis is an initial “experiment” at up leveling the .NET Framework application model to enable more modular application that enables developers to focus on their business logic while reaping the benefits of Xaml and WPF and of course carrying forward all of your existing Windows Forms assets.

Acropolis builds on the rich capabilities of Microsoft Windows and the .NET Framework, including Windows Presentation Foundation (WPF), by providing tools and pre-built components that help developers quickly assemble applications from loosely-coupled parts and services. With Acropolis you will be able to:

Quickly create WPF enabled user experiences for your client applications.
Build client applications from reusable, connectable, modules that allow you to easily create complex, business-focused applications in less time.
Integrate and host your modules in applications such as Microsoft Office, or quickly build stand-alone client interfaces.
Change the look and feel of your application quickly using built-in themes, or custom designs using XAML.
Add features such as workflow navigation and user-specific views with minimal coding.
Manage, update, and deploy your application modules quickly and easily.

Acropolis requires Visual Studio 2008 (Orcas) Beta 1. The first preview can be downloaded here. Acropolis also has a home page, where you'll be able to find an introduction video.
If you are at Tech Ed in Orlando, you can also learn more about Acropolis. You can find the sessions by searching for the Acropolis keyword in the session catalog.

At first sight, Acropolis looks very different from the CAB and SCSF. I'll be experimenting with it very soon because this is most likely the way to go for some of my clients.

Change tracking, the ADO.NET Entity Framework and DataSets

Fabrice Marguerie — Sat, 31 Mar 2007 11:58:00 GMT

Andres Aguiar started an interesting discussion about disconnected operation and change tracking in the ADO.NET Entity Framework.

Andres regrets that the Entity Framework doesn't provide change tracking information:

This basically means that if you plan to build a multi-tier application with ADO.NET Orcas in the middle tier, you will need to hack your own change tracking mechanism in the client, send the whole changeset, and apply it in the middle tier. From this point of view, it's a huge step backwards, as that's something we already have with DataSets today.

In a reply to Andres' post, Udi Dahan states that an application should not rely on change tracking information.

I believe that there are several kinds of applications and I don't think everybody must move to a unique kind of application. Some application don't require change tracking, others do. I've worked on applications that require it and Andres describes very well how they work in a subsequent post. One additional advantage of having state information is that you can display a collection of items (often details in a master-details relationship) in a grid, with changed items in italic, new items in bold and deleted items with strike-through text.
I don't understand why an SOA architecture wouldn't allow an UpdateOrder kind of command, but if it's the case, then a lot of applications are not compatible with SOA. If the ADO.NET Entity Framework or other mapping frameworks do not provide change information, then I'd say that DataSets are here to stay for a while...
I don't think there can be only one architecture for all applications. Both approaches described by Andres and Udi should coexist. If the ADO.NET Entity Framework doesn't provide support for change tracking, then another tool is need for some applications. If the the Entity Framework is open enough, then maybe extensions to it can add the support for change tracking?

CAB and SCSF resources

Fabrice Marguerie — Mon, 07 Aug 2006 22:31:00 GMT

I've been extensively using the CAB (Composite UI Application Block) and the SCSF (Smart Client Software Factory) lately. You should really dig them if you are creating Windows Forms applications. The CAB is a great tool to structure your developments and create reusable components. The SCSF is great for working with the CAB...

Eugenio Pace, product manager at Microsoft Patterns & Practices, has compiled a list of resources about the CAB and the SCSF. This can be really useful if you are using these technologies or want to know more.

Sample uses of LINQ, DLINQ and XLINQ

Fabrice Marguerie — Wed, 10 May 2006 23:17:00 GMT

My article entitled Sample uses of LINQ, DLINQ and XLINQ is now available in English.

In this article, we will see how to put LINQ, DLINQ and XLINQ in action. The goal is just to show how to use these technologies, and not to provide a target architecture or demonstrate optimal uses. The goal is not either to explain how Linq works. The goal is instead to explore the possibilities that Linq and co will offer to us, as well as to highlight some best practices.

Warning: this article was written several months ago, is based on the first preview of Linq and on my knowledge at that time. Most of the content is still valid today though.

Cet article est aussi disponible en français: Exemples de mise en oeuvre de Linq, DLinq et XLinq

Using LINQ, DLINQ and XLINQ

Fabrice Marguerie — Tue, 06 Dec 2005 22:35:00 GMT

My new article has been published: Using LINQ, DLINQ and XLINQ for application development.
It is currently available only in French, but translation is pending. In the meantime, you can use your favorite fish for translation.
Of course, I'll let you know when the English version is available.

Update: This article is now available in English as well.

Mon nouvel article intitulé Exemples de mise en oeuvre de LINQ, DLINQ et XLINQ a été publié sur DotNetGuru.
Introduction : Cet article met l'accent sur l'utilisation de LINQ, DLINQ et XLINQ pour le développement d'applications. Il s'agit uniquement d'un exemple de mise en oeuvre, et non d'une architecture de référence ou d'une utilisation optimale de ces technologies. Le but n'est pas d'expliquer comment fonctionne Linq mais plutôt d'explorer les multiples facettes de Linq au travers de bonnes pratiques.

More mappings: Relational Model - Domain Model - Presentation Model

Fabrice Marguerie — Tue, 18 Jan 2005 18:55:00 GMT

A new meme is starting to make some buzzing noise.
Paul Wilson started to talk about UI Mapping in July, and lately more and more people are talking about this concept.
Mats Helander has a complete series on various mappings (1, 2, 3, and up to 6). Roger Johansson is also talking about the concept and even has a prototype implementation (1, 2, 3).
Roughly, the idea is to use more mappings than just object-relational mapping, which is used to map your domain objects to a relational database. The first new mapping is between your domain objects and the presentation layer. This means we would have Relational Model <-> Domain Model <-> Presentation Model.
But I won't try to explain the concept, Roger Johansson and Mats Helander do this very well on their weblogs.

This goes towards a more declarative approach, and I think we need it because GUI code is the next pain in the neck after data access - a lot of code for nothing.
No need to say I'll follow this closely and even use it if possible.

Choosing an object-relational mapping tool

Fabrice Marguerie — Mon, 20 Dec 2004 15:59:00 GMT

My new article is available online in French: Choosing an object-relational mapping tool.
There is no English version yet, but maybe I'll take the time to translate it. If someone feels like helping...
Update: this article is now available in English as well.

Mon nouvel article est paru sur DotNetGuru : Choisir un outil de mapping objet-relationnel.

Difficile d'échapper à l'écriture de code d'accès et de manipulation de données quand on développe une application. Les outils de mapping objet-relationnel se proposent de vous aider. Encore faut-il faire le bon choix... Cet article vous présente les différents critères à étudier avant de faire l'acquisition d'un tel outil.

How do you see data? table, entity or domain model?

Fabrice Marguerie — Wed, 08 Dec 2004 14:59:00 GMT

Frans Bouma gives a clear presentation of three different ways to see data from an application developer's perspective. It helps to know where you are, and what the alternatives are.
The three approaches are:

I tend to use the entity approach (2), which is most of the time more SOA friendly.

Events, references, garbage collecting, memory leaks and weak delegates

Fabrice Marguerie — Tue, 27 Jul 2004 15:11:00 GMT

I was playing with services and containers, as part of my implementation of Inversion of Control. All was fine until events came into play.
I needed to connect two services through events. Oh, all was working fine: there were no apparent troubles. But under the too calm surface sneaked a dreadful memory leak. Events don't play well with a loosely coupled environment by default. Better be warned.

This is related to the so-called "lapsed listener" problem.
Steve Maine has a good description of the problem. I'll copy-paste it here so I don't have to rephrase it:

The “lapsed listener” problem occurs when objects subscribe to events and subsequently fall out of scope. The problem is that the event subscriber doesn’t get garbage collected because the event is still holding a reference to it inside of the event’s invocation list. The event subscriber is still considered reachable from the GC’s point of view. As such, it doesn’t get collected until the event goes out of scope (which is usually at application shutdown) which means that the event subscriber is effectively “leaked”. Moral of the story: when you implement an Observer pattern, it’s important to consider the relative lifetime of events and subscribers. If implemented naively, you’ll end up having objects that live a lot longer than you think they should. Unsubscribe() is your friend.

Here is a small schema representing this:

In fact, .NET's delegates and events are implementations of the Observer Design Pattern. But the current problem is one more reminder that Design Patterns should not be applied blindly.

If you write the following code, you'll see that the object instance gets correctly released and collected:

StoopidObject object = new StoopidObject();
GC.Collect();
GC.WaitForPendingFinalizers();

If you write the following code instead, although there is no apparent reference kept to the Observer, the Observer instance will not be released:

Observer observer = new Observer();
Subject subject = new Subject();
subject.SomethingHappened += new EventHandler(observer.subject_SomethingHappened);
GC.Collect();
GC.WaitForPendingFinalizers();

Guys from around the community came with various solutions. They call them Weak Delegates. Follow the links to learn more:

~~Shawn A. Van Ness~~
Greg Schechter (real case study; schemas will help you to understand the problem)
Ian Griffiths and Xavier Musy (extensions and improvements)

I chose another way because the proposed solutions rely on weak references, and that is not satisfying in my case. With "weak delegates", the observers continue to receive events while not garbage collected. You never know when garbage collecting happens. If you base your developments on weak references, you have to accept the fact that your objects do not disappear immediately.

I want to prevent the notifications to be received by the observer as soon as it is meant to be disconnected. For that purpose, I ask the observer I'm going to remove to disconnect cleanly from its subjects. For simplicity, I use the Dispose method for this. This is because I know I'll call Dispose() each time I want to get rid of an object, this runs in a specific framework. Another method more explicit to the user could be used instead.

You can take a look at the source code I used for my tests.

Update: I show how to force disconnection in another post.
Update: I cover the same subject and much more in an article.

Objects and Services

Fabrice Marguerie — Tue, 20 Jul 2004 12:02:00 GMT

Clemens Vasters' post "Rows and Columns + Elements and Attributes is all you need" initiated an interesting discussion about the place of objects in SOA.

Does Object Oriented Programing fits with Service Orientation?
Read comments from Udi Dahan, Steve Eichert, and Jimmy Nilsson(1 and 2), for example.

In my opinion, the way to work with Entities, Managers, Objects and Services is still not clear. I haven't looked enough at architectures like ShadowFax or FABRIQ to know whether they contain guidance on this. My guess is that we'll have to wait some more time before best practices become clearly defined. Maybe all this is already well settled in the J2EE world?

I tend to do something similar to what Udi does. One of the open issues I see is "how to share business and validation rules between the Business layer and the Presentation layer?". If the rules are in the Managers, and not in the Entities, how do we use these rules in the Presentation layer?

Anyway, "encore un pavé dans la mare des tout-objet"...

Inscriptions Symposium DotNetGuru

Fabrice Marguerie — Thu, 08 Jul 2004 12:47:00 GMT

Les inscriptions sont ouvertes, et le nombre de places et limité. Qu'on se le dise...

Rendez-vous en octobre.

Symposium DotNetGuru 2004

Fabrice Marguerie — Mon, 28 Jun 2004 11:59:00 GMT

Réservez dès aujourd'hui votre journée du 8 octobre !

Au plaisir de vous y retrouver.