Blog de Rochdi Chakroun

Pour ceux qui ne le savent pas encore, Visual Studio 2010 en version Ultimate offre la possibilité d'explorer et d'analyser l'architecture d'un projet. Cette fonctionnalité est accessible via le menu Architecture / Generate Dependency Graph.

Un diagramme (DGML : Directed Graph Markup Language) représente les composants du projet (dll, namespaces, classes) et  leurs relations.

Si on se positionne dans un contexte entreprise, j'ai voulu utiliser le DGML pour représenter les applications au sein du SI, et ainsi profiter des outils d'analyse de Visual Studio (Circular reference, hubs .)

En entrée j'ai besoin d'avoir la liste des applications, les relations, le type de relation (WS, DB, File .) et en plus j'ai trouvé intéressant de regrouper les applications par domaine (BackOffice, FrontOffice, Accounting, BI .). Ce qui va me permettre de détecter des anomalies : une application bureautique qui référence une application de production par exemple.

Ci-dessous les entités Application et Relation

    public class Application
    {
        public string Name { get;set; }
        public string Domain { get; set; }
    }

    public class Relation
    {
        public string Source { get; set; }
        public string Target { get; set; }
        public string Type { get; set; }
    }

Pour pouvoir générer du DGML, il faut référencer les DLL suivantes qui se trouvent ~\Program Files\visual Studio 10\Common7\Ide\PrivateAssemblies :

Microsoft.VisualStudio.Progression.Common et Microsoft.VisualStudio.Progression.GraphModel

Après avoir récupérer les liste des applications, domaines, et relations il suffit de construire le graphe comme suit:

            //Graph Creation
            Graph graph = new Graph();
            // Create domains and add them to the graph
            Parallel.ForEach(domains, domain =>
            {
                Node node = new Node(domain);
                node.IsGroup = true;
                graph.Nodes.Add(node);
            });

            //Create application Node, and add the application to the appropriate domain
            Parallel.ForEach(applications, a =>
            {
                Node node = new Node(a.Name);
                graph.Nodes.Add(node);
                string domain = a.Domain;
                if (!string.IsNullOrEmpty(domain))
                {
                    Node domainNode = graph.Nodes.FirstOrDefault(n => n.Label == domain);
                    if (domainNode != null)
                    {
                        Link link = new Link(graph, domainNode, node);
                        link.SetValue(GraphProperties.IsContainment, true);
                        graph.Links.Add(link);
                    }
                }
            });

            //having all node, create the relations (links)
            Parallel.ForEach(relations, r =>
            {
                Link link = new Link(graph, graph.Nodes.First(n => n.Label == r.Source), graph.Nodes.First(n => n.Label == r.Target));
                link.Label = r.Type;
                graph.Links.Add(link);
            });

            //Write the DGML to file 
            string graphXml = graph.ToXml();

            using (StreamWriter writer = new StreamWriter("si.dgml"))
            {
                writer.Write(graphXml);
                writer.Flush();
            }
        }

En ouvrant le fichier dgml dans Visual Studio le résultat est le suivant : Un beau plat de spaghettis qui peut motiver l'urbanisation du SI:

La capture d'écran ci-dessous montre l'interaction d'un domaine FontOffice avec le reste du SI :

La capture d'écran ci-dessous montre l'interaction d'une application avec le reste du SI :

La capture d'écran ci-dessous montre les références cycliques.

L'outil est assez sympa basé sur WPF mais malheureusement on ne peut l'utiliser qu'avec Visual Studio Ultimate et pas d'intégration dans Visio.