Grafico delle dipendenze dei progetti di Visual Studio

Attualmente sto migrando una grande soluzione (~ 70 progetti) da VS 2005 + .NET 2.0 a VS 2008 + .NET 3.5. Attualmente ho VS 2008 + .NET 2.0.

Il problema è che devo spostare i progetti uno alla volta nel nuovo framework .NET assicurandomi che nessun progetto .NET 2.0 faccia riferimento al progetto .NET 3.5. Esiste uno strumento che potrebbe darmi un bel grafico delle dipendenze del progetto?

Hai provato NDepend? Ti mostrerà le dipendenze e potrai anche analizzare l'usabilità delle tue classi e dei tuoi metodi.

Il loro sito Web:

http://ndepend.com

Per completare la risposta di @Eriawan nell'aprile 2020, è stata rilasciata la versione NDepend 2020.1 con il grafico delle dipendenze completamente ricostruito. Ora si adatta a soluzioni di grandi dimensioni costituite da centinaia di progetti e offre molte funzionalità di navigazione.

Ecco come appare nel progetto OSS di NopCommerce .

Ecco come appare sull'intera libreria di classi .NET Core 3 (176 assembly).

Disclaimer: lavoro a NDepend

Avevo bisogno di qualcosa di simile, ma non volevo pagare (o installare) uno strumento per farlo. Ho creato un rapido script di PowerShell che analizza i riferimenti del progetto e li sputa in un formato amichevole yuml.me :

Function Get-ProjectReferences ($rootFolder)
{
    $projectFiles = Get-ChildItem $rootFolder -Filter *.csproj -Recurse
    $ns = @{ defaultNamespace = "http://schemas.microsoft.com/developer/msbuild/2003" }

    $projectFiles | ForEach-Object {
        $projectFile = $_ | Select-Object -ExpandProperty FullName
        $projectName = $_ | Select-Object -ExpandProperty BaseName
        $projectXml = [xml](Get-Content $projectFile)

        $projectReferences = $projectXml | Select-Xml '//defaultNamespace:ProjectReference/defaultNamespace:Name' -Namespace $ns | Select-Object -ExpandProperty Node | Select-Object -ExpandProperty "#text"

        $projectReferences | ForEach-Object {
            "[" + $projectName + "] -> [" + $_ + "]"
        }
    }
}

Get-ProjectReferences "C:\Users\DanTup\Documents\MyProject" | Out-File "C:\Users\DanTup\Documents\MyProject\References.txt"

Aggiornamento: ReSharper dalla versione 8 ha incorporato la funzione "Visualizza dipendenze del progetto" .

La versione di ReSharper <8 ha una funzione interna per mostrare i grafici delle dipendenze nell'uso del visualizzatore yFiles. Vedi il manuale rapido in fondo al post.

Come

1. Installa lo strumento yEd da qui .
2. Eseguire VS con /resharper.internal argomento della riga di comando.
3. Vai a ReSharper / Internal / Show Dependencies.
4. Specificare i progetti che si desidera includere nel "quadro generale".
5. Deseleziona "Escludi nodi terminali ..." a meno che non sia necessario.
6. Premi "Mostra".
7. Usa layout gerarchico in yEd (Alt + Maiusc + H)
8. Fornisci feedback =)

È possibile ottenere facilmente un grafico di dipendenza del progetto utilizzando Visual Studio 2010 Ultimate, scansionare fino a 5 minuti in questo video per vedere come: http://www.lovettsoftware.com/blogengine.net/post/2010/05/27/Architecture-Explorer aspx

In Visual Studio 2010 Ultimate: Architecture | Genera grafico delle dipendenze | Per Assemblea.

Ho scritto uno strumento che potrebbe aiutarti. VS Solution Dependency Visualizer analizza le dipendenze del progetto all'interno di una soluzione e crea un diagramma delle dipendenze da queste informazioni, nonché un rapporto di testo.

Ho avuto un problema simile, ma è stato ulteriormente complicato perché diversi progetti si riferivano a versioni diverse dello stesso assieme.

Per ottenere un output che includa informazioni sulla versione e controlli possibili problemi di caricamento dell'assembly di runtime, ho creato questo strumento:

https://github.com/smpickett/DependencyViewer

(collegamento diretto alla versione di github: https://github.com/smpickett/DependencyViewer/releases )

È possibile creare un grafico delle dipendenze dei progetti in VS 2010 Ultimate. Architecture Explorer consente di sfogliare la soluzione, selezionare i progetti e le relazioni che si desidera visualizzare, quindi creare un grafico delle dipendenze dalla selezione.

Per ulteriori informazioni, vedere i seguenti argomenti:

Procedura: generare documenti grafici dal codice : http://msdn.microsoft.com/en-us/library/dd409453%28VS.100%29.aspx#SeeSpecificSource

Procedura: trovare il codice utilizzando Architecture Explorer : http://msdn.microsoft.com/en-us/library/dd409431%28VS.100%29.aspx

Download RC : http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=457bab91-5eb2-4b36-b0f4-d6f34683c62a .

Forum di Visual Studio 2010 Architectural Discovery & Modeling Tools : http://social.msdn.microsoft.com/Forums/en-US/vsarch/threads

Per completare la risposta eriawan sui grafici generati da NDepend, vedere gli screenshot di seguito. È possibile scaricare e utilizzare l'edizione di prova gratuita di NDepend per un po '.

Altre informazioni sul grafico delle dipendenze NDepend

Altre informazioni sulla matrice di dipendenza NDepend :

Disclaimer: faccio parte del team di strumenti

La soluzione Powershell è la migliore. L'ho adattato in uno script bash che funziona sulla mia macchina (TM):

#!/bin/bash

for i in `find . -type f -iname "*.csproj"`; do
    # get only filename
    project=`basename $i`

    # remove csproj extension
    project=${project%.csproj}

    references=`cat $i | grep '<ProjectReference' | cut -d "\"" -f 2`
    for ref in $references; do
        # keep only filename (assume Windows paths)
        ref=${ref##*\\}

        # remove csproj extension
        ref=${ref%.csproj}

        echo "[ $project ] -> [ $ref ]"
    done

done

Puoi creare un bel grafico dei riferimenti nei tuoi progetti. Ho descritto il modo in cui l'ho fatto sul mio blog http://www.mellekoning.nl/index.php/2010/03/11/project-references-in-ddd/

Se vuoi semplicemente un grafico delle dipendenze, ho scoperto che questo è uno dei modi più chiari per ottenerne uno:

Analizzatore di dipendenza

VS 2019 ha rinominato il modulo del grafico delle dipendenze in Code Map

ecco la documentazione ufficiale: https://docs.microsoft.com/en-us/visualstudio/modeling/map-dependencies-across-your-solutions?view=vs-2019

Questa versione estesa dello script PS di Danny Tuppeny mostra riferimenti sia a progetto che esterni:

Function Get-ProjectReferences($rootPath)
{
  $projectFiles = Get-ChildItem $rootPath -Filter *.csproj -Recurse
  $ns = @{ defaultNamespace = "http://schemas.microsoft.com/developer/msbuild/2003" }

  $projectFiles | ForEach-Object {
    $projectFile = $_ | Select-Object -ExpandProperty FullName
    $projectName = $_ | Select-Object -ExpandProperty BaseName
    $projectXml = [xml](Get-Content $projectFile)

    $projectReferences = $projectXml | Select-Xml '//defaultNamespace:ProjectReference/defaultNamespace:Name' -Namespace $ns | Select-Object -ExpandProperty Node | Select-Object -ExpandProperty "#text"
    $projectReferences | ForEach-Object {
        "PR:[" + $projectName + "]:[" + $_ + "]"
    }
  }

  $projectFiles | ForEach-Object {
    $projectFile = $_ | Select-Object -ExpandProperty FullName
    $projectName = $_ | Select-Object -ExpandProperty BaseName
    $projectXml = [xml](Get-Content $projectFile)

    $externalReferences = $projectXml | Select-Xml '//defaultNamespace:Reference/@Include' -Namespace $ns
    $externalReferences | ForEach-Object {
        "ER:[" + $projectName + "]:[" + $_ + "]"
    }

  }

}

Get-ProjectReferences "C:\projects" | Out-File "C:\temp\References.txt"

Fornirà un file separato da due punti che può essere aperto e analizzato in Excel.

Ho controllato tutte le risposte ma nessuna delle opzioni mi soddisfaceva, quindi ho scritto il mio strumento per visualizzare in anteprima le dipendenze progetto-progetto.

https://github.com/Audionysos/VSProjectReferencesViewer

È fase iniziale ma ha funzionato per le mie esigenze :)