web-dev-qa-db-de.com

Wie finde ich Dateien, die in Visual Studio-Projekten fehlen?

Aufgrund von Problemen beim Zusammenführen usw. haben wir viele Projektdateien, die nicht alle Quellcodedateien enthalten, die sich in ihren Ordnern befinden.

Bevor ich ein kleines Tool schreibe, das überprüft, ob jede *.cs-Datei in einer Projektdatei enthalten ist, möchte ich sicherstellen, dass no-body other dies zuvor bereits getan hat.

(Wir haben fast 100 Projektdateien und Tausende von C # -Dateien.)

-------------------

Offensichtlich ist die Unterstützung von Visual Studio für die Verwendung von Platzhaltern zum Einschließen aller „* .cs“ -Dateien aus einem bestimmten Verzeichnis im Projekt die beste Lösung für dieses Problem. In diesem Fall müssen keine Projektdateien aktualisiert werden, wenn „.cs“ -Dateien hinzugefügt und in ete umbenannt werden. Dies ist jedoch erst in VS2017 von der Benutzeroberfläche aus möglich. 

39
Ian Ringrose

Bei dieser Anzahl von Dateien und Projekten scheint es, als würden Sie etwas mehr Automatisierung wünschen. Es gibt jedoch einen manuellen Ansatz (nicht sicher, ob Sie sich dessen bereits bewusst sind):

  1. Wählen Sie das Projekt im Projektmappen-Explorer aus
  2. Projektmenü -> Alle Dateien anzeigen 
  3. Unter dem Projekt werden Dateien, die nicht Teil des Projekts sind, als "Geister" -Symbole angezeigt
  4. Wählen Sie die gewünschten Dateien aus und klicken Sie im Kontextmenü auf "In Projekt einbeziehen"
47
JohnD

Ich habe die Visual Studio-Erweiterung " Show missing files " gefunden. Nach dem Build wird die Liste der fehlenden Dateien im Fenster "Fehlerliste" angezeigt.

14
izogfif

Nach dem Lesen gibt es hier keine generische Lösung für Stack Overflow. Ich habe an diesem Wochenende ein NodeJS-Modul erstellt, um dieses Problem zu lösen:

https://www.npmjs.com/package/check-vs-includes

Dies ist ziemlich allgemein, also hoffe ich, dass dies auch anderen hilft. Es erspart mir eine manuelle Überprüfung von mehr als 70 Ordnern (mehr als 500 Dateien) bei jeder Bereitstellung. Wenn ich etwas Zeit habe, hoffe ich, einige Dinge zu verbessern, wie zum Beispiel die Dokumentation ... Aber lassen Sie mich jetzt ein einfaches Beispiel geben.

Einfaches Beispiel

  1. Installiere nodeJS (Funktioniert auch unter Windows)
  2. npm install check-vs-includes

  3. Fügen Sie eine Aufgabe hinzu, und geben Sie die Dateien an, nach denen gesucht werden soll.

Fügen Sie Ihrem Projekt beispielsweise einen gulpfile.js hinzu:

gulp.task('checkVSIncludes', function(cb) {
    checkVSIncludes(['/Content/**/*.less', '/app/**/*.js']);
});

In diesem Beispiel wird geprüft, ob alle .js- und .less-Dateien in den angegebenen Ordnern in Ihrer Projektdatei enthalten sind. Beachten Sie, dass Sie glob 's verwenden können.

  1. Führen Sie die Prüfung aus. für das GULP-Beispiel:

    gulp checkVSIncludes

Überprüfen Sie den Quellcode auf weitere Optionen. Alles auf GitHub (Beiträge sind willkommen;)).

9
Bart

Bei meiner Suche nach einer Lösung dafür bin ich auf this VS Extension gestoßen, aber es funktioniert nur mit VS 2012. Es ist auch auf Github .

Für VS 2013+ verwende ich ein Powershell-Skript, das in this blog post zu finden ist. Beachten Sie, dass dies nur für C # -Projekte funktioniert, Sie können es jedoch für VB -Projekte ändern.

#Author: Tomasz Subik http://tsubik.com
#Date: 8/04/2012 7:35:55 PM
#Script: FindProjectMissingFiles
#Description: Looking for missing references to files in project config file
Param(
    [parameter(Mandatory=$false)]
    [alias("d")]
    $Directory,
    [parameter(Mandatory=$false)]
    [alias("s")]
    $SolutionFile
)


Function LookForProjectFile([System.IO.DirectoryInfo] $dir){
    [System.IO.FileInfo] $projectFile = $dir.GetFiles() | Where { $_.FullName.EndsWith(".csproj") } | Select -First 1

    if ($projectFile){
        $projectXmlDoc = [xml][system.io.file]::ReadAllText($projectFile.FullName)
        #[xml]$projectXmlDoc = Get-Content $projectFile.FullName
        $currentProjectPath = $projectFile.DirectoryName+"\"
        Write-Host "----Project found: "  $projectFile.Name

        $nm = New-Object -TypeName System.Xml.XmlNamespaceManager -ArgumentList $projectXmlDoc.NameTable
        $nm.AddNamespace('x', 'http://schemas.Microsoft.com/developer/msbuild/2003')
        [System.Collections.ArrayList]$filesListedInProjectFile = $projectXmlDoc.SelectNodes('/x:Project/x:ItemGroup/*[self::x:Compile or self::x:Content or self::x:None]/@Include', $nm) | Select-Object Value

        CheckProjectIntegrity $dir $currentProjectPath $filesListedInProjectFile;
    }
    else { $dir.GetDirectories() | ForEach-Object { LookForProjectFile($_); } }
}

Function CheckProjectIntegrity([System.IO.DirectoryInfo] $dir,[string] $currentProjectPath,  [System.Collections.ArrayList] $filesListedInProjectFile ){
    $relativeDir = $dir.FullName -replace [regex]::Escape($currentProjectPath)
    $relativeDir = $relativeDir +"\"
    #check if folder is bin obj or something
    if ($relativeDir -match '(bin\\|obj\\).*') { return }

    $dir.GetFiles()  | ForEach-Object {
        $relativeProjectFile = $_.FullName -replace [regex]::Escape($currentProjectPath)
        $match = $false
        if(DoWeHaveToLookUpForThisFile($relativeProjectFile))
        {
            $idx = 0
            foreach($file in $filesListedInProjectFile)
            {
                if($relativeProjectFile.ToLower().Trim() -eq $file.Value.ToLower().Trim()){
                    $match = $true
                    break
                }
                $idx++
            }
            if (-not($match))
            {
                Write-Host "Missing file reference: " $relativeProjectFile -ForegroundColor Red
            }
            else
            {
                $filesListedInProjectFile.RemoveAt($idx)
            }
        }
    }
    #lookup in sub directories
    $dir.GetDirectories() | ForEach-Object { CheckProjectIntegrity $_ $currentProjectPath $filesListedInProjectFile }
}

Function DoWeHaveToLookUpForThisFile($filename)
{
    #check file extensions
    if ($filename -match '^.*\.(user|csproj|aps|pch|vspscc|vssscc|ncb|suo|tlb|tlh|bak|log|lib|sdf)$') { return $false }
    return $true    
}

Write-Host '######## Checking for missing references to files started ##############'
if($SolutionFile){
    [System.IO.FileInfo] $file = [System.IO.FileInfo] $SolutionFile
    $Directory = $file.Directory
}
LookForProjectFile($Directory)
Write-Host '######## Checking for missing references to files ends ##############'

Verwendungsbeispiel (sollte von der NuGet-Konsole aus ausgeführt werden):

./FindProjectMissingFiles.ps1 -s $dte.Solution.FileName
7
TWilly

Eine kleine C # -Konsolenanwendung, die alle cs-Dateien aus Projektdateien unter einem bestimmten Stammordner (rekursiv) ermittelt und mit Dateien im Dateisystem unter demselben Stammordner vergleicht. Kann auf verschiedene Dateierweiterungen und verschiedene Projektdateistrukturen angewendet werden (ich habe es für VS2008 getestet). Möglicherweise müssen einige Modifikationen vorgenommen werden, um anderen Anforderungen gerecht zu werden, sie sollten jedoch eine nützliche Grundlage darstellen.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;

namespace CompareProjectFilesWithFileSystem
{
    class Program
    {
        static void Main(string[] args)
        {
            string ext = "cs";
            string rootProjectFolder = @"C:\MySolutionRootFolder";
            Regex projectFileReferenceRegEx = new Regex(@"<(Compile|Content|None) Include=\""([^\""]+." + ext + @")\""( /)?>");

            // Files in file system:
            List<string> filesInFileSystem = new List<string>();
            filesInFileSystem.AddRange(Directory.GetFiles(rootProjectFolder, "*." + ext, SearchOption.AllDirectories));

            // Files referred from project files:
            string[] projectFilePaths = Directory.GetFiles(rootProjectFolder, "*.csproj", SearchOption.AllDirectories);
            List<string> filesReferredInProjectFiles = new List<string>();
            foreach (string projectFilePath in projectFilePaths)
            {
                string[] lines = File.ReadAllLines(projectFilePath);
                foreach (string line in lines)
                {
                    Match match = projectFileReferenceRegEx.Match(line);
                    if (match.Success)
                    {
                        filesReferredInProjectFiles.Add(Path.Combine(Path.GetDirectoryName(projectFilePath), match.Result("$2")));
                    }
                }
            }

            // Finding files referred from project files that are not contained in file system. And reversely.
            var list1 = filesReferredInProjectFiles.Except(filesInFileSystem).ToList();
            var list2 = filesInFileSystem.Except(filesReferredInProjectFiles).ToList();
        }
    }
}
4
Jesper Mygind

Keine der vorherigen Lösungen funktionierte für mich, da das Projekt, zu dem ich Dateien hinzufügte, ein "Website-Projekt" (WSP) war. Bei der Auswahl des Projekts im Projektmappen-Explorer wurde der Menüpunkt "Projekt" in "Website" konvertiert und es gab keine Option "Alle Dateien anzeigen".

Dies ist so, weil für WSP ( link ):

"Alle Dateien werden bereits im Projektmappen-Explorer angezeigt."

Außer in meinem Fall waren sie nicht ... Ich habe das Problem gelöst, indem Sie einfach Visual Studio 2015 (VS) schließen und erneut öffnen und das Projekt erneut laden. Ich denke, VS erkennt das Hinzufügen neuer Dateien nur, wenn die Website erneut geladen wird, nicht wenn diese Dateien außerhalb von VS hinzugefügt werden.

2
David Rogers

Eine andere Möglichkeit: Manchmal wird die Datei selektiv nicht zur Quellcodeverwaltung hinzugefügt. Um dieses Problem zu beheben, klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie "Elemente zum Ordner hinzufügen".

Alle Dateien, die nicht im Explorer für die Quellcodeverwaltung angezeigt werden und in den Quellordnern angezeigt werden, sollten sich hier befinden und können selektiv hinzugefügt werden.

0
JWiley

(Angenommen, Team Foundation Server ist Ihre Quellcodeverwaltung): Wenn die Datei zum Projekt hinzugefügt wurde und im Quellcodeverwaltungs-Explorer angezeigt wird, aber NICHT im Projektmappen-Explorer angezeigt wird, müssen Sie sie manuell zum Quellcodeverwaltungs-Explorer hinzufügen. Fügen Sie "," Vorhandenes Element "hinzu. Dies ist ein ärgerlicher Visual Studio/TFS-Fehler, den ich gerade zwei Stunden damit verbringe, herauszufinden.

0
dmbreth

Wir hatten eine ähnliche Situation, die aufgrund fehlender Dateien zu fehlgeschlagenen Kompilierungen führte. Ich stolperte über diesen unten verlinkten Beitrag, der mir geholfen hat. Es beschreibt das Schreiben eines Visual Studio-Makros, das ausgeführt wird, wenn ein Build gestartet wird.

Fehler/Warnung melden, wenn Dateien in Projekt/Lösung in Visual Studio fehlen

0
Andy S.

Ich habe vor einiger Zeit ein Werkzeug dafür geschrieben. Verfügbar hier .

0
Roger