J’écrit cet article suite à la question que Loïc NICOLAS a posé sur Stackoverflow :

http://stackoverflow.com/questions/8436246/is-it-possible-to-configure-embbeded-dictionaries-using-c-net4-0-and-windsor-ca

En effet, Loic a relevé une question très intéressante et pertinente sur le moyen de configurer

Une propriété de service Windsor relativement complexe.

Tout d’abord je commence par répondre à la question de Loïc pour montrer que c’est parfaitement faisable, contrairement aux réponses négatives qu’il a reçu dans le thread.

En second lieu j’expliquerai en quoi cette méthode est une mauvaise pratique et son alternative.

La clé au problème du  snippet de code de Loïc réside en la façon avec laquelle sont configurés les « Generics », supposons que j’ai la classe Generic suivante :

Public class GenericClass<Type1, Type2>:where Type1…

{

//Do stuff here

}

Comment configurer un service windsor en xml pour cette class ?

-         Pour dire à Windsor que c’est un generic on utilise le `

-         2 pour dire que le generic est bidimensionnel

-         Pour passer les types (dans ce cas) [[namespace du Type1,Assembly Type2],[namespace du Type1,Assembly Type 2]]

Nous pouvons donc avoir un service qui ressemble à ça :

<component id= «myGenericService »     service= « System.Collections.Generic.Dictionary`2[[namespace du Type1,Assembly Type2],[namespace du Type1,Assembly Type 2]] >

<componen/>

Donc pour la question de Loïc voici une solution :

<MyComplexDictionaryProperty>

  <Dictionary keyType=="Namespace de MyEnum1, Assembly de MyEnum1" valueType=valueType="System.Collections.Generic.Dictionary`2[[namespace de MyEnum2,Assembly de MyEnum2],[system.Int32,mscorlib]]"

    <Entry key=”MyEnum1Value”>

      <Dictionary

        keyType="namespace de MyEnum2,Assembly de MyEnum2"

        valueType="System.Int32, mscorlib">

        <Entry key="MyEnum2Value1">1</Entry>

      </Dictionary>

    </Entry>

  </Dictionary>

</MyComplexDictionaryProperty>

Je passe à la deuxième partie de ma réponse:

Comme vous avez bien, remarqué cette solution à la question de Loic est l’une des plus simples, alors que le xml est assez conséquent, complexe, difficile à comprendre et très verbeux.

La configuration xml de Castle Windsor est sensible à la casse ce qui fait qu’utiliser  ce contenaire IoC pour découpler des composants Devient un parcours du combattant.

Dans le cas de MyComplexDictionaryProperty on voit bien que cette propriété est plutôt faite Avec un esprit de créer un type et l’initialiser ce qui est hors Scope de tout contenaire IoC.

Il est plus intéressant dans le cas de figure de cette property de créer un type wrapper pour cette collection complexe et de la gérer par un service.

Si Vous n’arrivez pas à comprendre la solution, vous pouvez revenir vers moi pour avoir une application sample.

Je voudrais dans cet article essayer de résoudre une problématique qui est pour peu bloquante pour les utilisateurs de ActiveWriter.

ActiveWriter est un outil qui permet de modéliser et définir les relations entres des entités.

Pour plus d’informations  visiter le site officiel du développeur  http://altinoren.com/activewriter/

La première version de ActiveWriter est un add-in VS2005 développé avec le DSLtool de Visual Studio,

Compte tenu du succées de l’outil, il a été ensuite porté à VS2010 comme une extension (.VSIX),

Sauf que là (d’ou le problème) en téléchargeant la solution ne compile pas et on se trouve face à une erreur de compilation, j’ai remarqué beuacoup de questions dans les forums techniques concernant cette erreur de compilation et comment la résoudre.

En cherchant, j’ai pu corriger cette erreur, la solution compile et on peu donc installer l’extension ActiveWriter sous VS2010.

L’erreur réside au niveau d’une classe qui s’appelle ServerExplorerHelper et qui permet d’interagir avec l’explorateur de serveurs de BD et gérer les Drag & Drop.

Dans VS2010 le DSLTool a beaucoup bougé par rapport aux versions précédentes.

Voici le code qui permet de corriger l’erreur :

#region License
//  Copyright 2004-2010 Castle Project – http:www.castleproject.org/
//
//  Licensed under the Apache License, Version 2.0 (the « License »);
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//      http:www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an « AS IS » BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//
#endregion

using System.Collections.Generic;

namespace Castle.ActiveWriter.ServerExplorerSupport
{
using System;
using System.Data;
using Microsoft.VisualStudio.Data.Services;
using Microsoft.VisualStudio.Shell;

internal static class ServerExplorerHelper
{
public static Guid IUnknown = new Guid(« 00000000-0000-0000-c000-000000000046″);
public static Guid ServerExplorer = new Guid(« 7494682C-37A0-11d2-A273-00C04F8EF4FF »);
private static Guid SqlServerProvider = new Guid(« 91510608-8809-4020-8897-FBA057E22D54″);
private static Guid ODBCProvider = new Guid(« C3D4F4CE-2C48-4381-B4D6-34FA50C51C86″);
private static Guid OracleProvider = new Guid(« 8F5C5018-AE09-42cf-B2CC-2CCCC7CFC2BB »);
private static Guid OleDBProvider = new Guid(« 7F041D59-D76A-44ed-9AA2-FBF6B0548B80″);
private static Guid SqlServerCompactProvider = new Guid(« 7C602B5B-ACCB-4acd-9DC0-CA66388C1533″);

private static Dictionary<string, Guid> Providers = new Dictionary<string, Guid>();

public static IDbConnection GetConnection(DSRefNavigator navigator, out string type)
{
type = null;
try
{
if (navigator != null)
{
IVsDataExplorerConnectionManager dataConnectionsService =
(IVsDataExplorerConnectionManager) Package.GetGlobalService(typeof(IVsDataExplorerConnectionManager));

string itemName = navigator.GetConnectionName();

if (itemName != null)
{
Providers.Add(« System.Data.SqlClient.SqlConnection », SqlServerProvider);
Providers.Add(« ODBC », ODBCProvider);
Providers.Add(« Oracle.DataAccess.Client.OracleConnection », OracleProvider);
Providers.Add(« OLEDB », OleDBProvider);
Providers.Add(« SqlServerCompact », SqlServerCompactProvider);
foreach(var conn in dataConnectionsService.Connections)
{
if(conn.Value.Connection.SafeConnectionString.Equals(itemName))
{
foreach (KeyValuePair<string, Guid> provider in Providers)
{
if(provider.Value.Equals(conn.Value.Connection.Provider))
{
type = provider.Key;
break;
}
}
Providers.Clear();
return (IDbConnection)conn.Value.Connection.GetLockedProviderObject();
}

}
//var connection = dataConnectionsService.Connections[itemName];

//return (IDbConnection) connection.Connection.GetLockedProviderObject();

//int iConn; // = dataConnectionsService.GetConnectionIndex(itemName);
//DataViewHierarchyAccessor dataViewHierarchy = null;

//for(iConn = 0; iConn < dataConnectionsService.Connections.Count; iConn++)
//{
//    DataViewHierarchyAccessor hierarchyAccessor =
//        new DataViewHierarchyAccessor((IVsUIHierarchy) dataConnectionsService.GetConnectionHierarchy(iConn));
//    try
//    {
//        if (hierarchyAccessor.Connection.DisplayConnectionString == itemName)
//        {
//            dataViewHierarchy = hierarchyAccessor;
//            break;
//        }
//    }
//    catch
//    {
//    }
//}
//if (dataViewHierarchy != null)
//{
//    DataConnection connection = dataViewHierarchy.Connection;
//    if (connection != null && connection.ConnectionSupport.ProviderObject != null)
//    {
//        type = connection.ConnectionSupport.ProviderObject.GetType().FullName;
//        return (IDbConnection) connection.ConnectionSupport.ProviderObject;
//    }
//}
}}}
catch{}
return null;
}}}

Vous noterez bien que l’ancien code a été commenté.

J’espère que cela aidera les développeurs qui utilisent ActiveWriter.