Comment puis-je trouver les fichiers manquants dans les projets visual studio?

avec ce nombre de fichiers et de projets, on dirait que vous voulez quelque chose de plus automatisé. Cependant, il y a une approche manuelle (pas sûr si vous êtes déjà au courant):

1. Sélectionnez le projet dans l'Explorateur de solutions volet
2. menu du projet - > afficher tous les fichiers
3. dans le cadre du projet, les fichiers qui ne font pas partie du projet apparaîtront comme des icônes "fantômes
4. sélectionnez le(S) fichier (s) vous vouloir et choisir "inclure dans le projet" dans le menu contextuel

j'ai trouvé le " Afficher les fichiers manquants " extension de Visual Studio. Il affichera la liste des fichiers manquants dans la fenêtre "Liste des erreurs" après la compilation.

après lecture il n'y a pas de solution générique pour cela ici sur le débordement de la pile, j'ai créé un module NodeJS ce week-end pour résoudre ce problème:

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

C'est assez générique, donc j'espère que cela aide les autres. Il me sauve une vérification manuelle de plus de 70 dossiers (500+ fichiers) sur chaque déploiement. Si j'ai le temps, j'espère améliorer certaines choses, comme la documentation... Mais laissez me donner un exemple simple maintenant.

exemple Simple

1. Installer nodeJS (Fonctionne très bien sur Windows aussi)

2. npm install check-vs-includes

3. ajouter une tâche et spécifier les fichiers à vérifier.

Par exemple ajouter un gulpfile.js à votre projet:

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

cet exemple vérifie que tous les fichiers .js et .less dans les dossiers spécifiés sont inclus dans votre fichier de projet. Notez que vous pouvez utiliser glob .

4. exécuter le contrôle; pour le GULFP exemple:

   gulp checkVSIncludes

vérifiez le code source pour plus d'options, tout est sur GitHub (les contributions sont les bienvenues ;)).

dans ma recherche d'une solution pour cela, je suis tombé sur ce VS Extension, mais il ne fonctionne avec VS 2012 . C'est aussi sur Github .

Pour VS 2013+ j'utilise un script Powershell trouvé sur ce post de blog. Notez qu'il ne fonctionne que pour les projets C#, mais vous pouvez le modifier pour les projets VB.

#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 ##############'

exemple d'utilisation (doit être exécuté à partir du NuGet console):

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

une petite application de console C# qui trouve tous les fichiers cs référencés à partir de fichiers de projet sous un certain dossier racine (récursivement), et compare avec les fichiers dans le système de fichiers sous le même dossier racine. Peut être appliqué à différentes extensions de fichiers, et différentes structures de fichiers de projet (je l'ai testé pour VS2008). Il faudra peut-être y apporter certaines modifications pour répondre à d'autres besoins, mais cela devrait constituer une base utile.

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("")));
                    }
                }
            }

            // 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();
        }
    }
}

aucune des solutions précédentes n'a fonctionné pour moi car le projet auquel j'ai tenté d'ajouter des fichiers était un "projet de Site web"(WSP). Lors de la sélection du projet dans l'Explorateur de solutions, l'élément de menu "Projet" converti en "site Web" et il n'y avait pas d'option "Afficher tous les fichiers".

c'est parce que pour WSP( lien ):

"tous les fichiers sont déjà affichés dans l'Explorateur de solutions."

sauf dans mon cas... J'ai résolu le problème en fermant et en rouvrant Visual Studio 2015(VS) et en rechargeant le projet. Je pense que VS ne détecte l'ajout de nouveaux fichiers que lorsque le Site Web est rechargé, pas lorsque ces fichiers sont ajoutés en dehors de VS.

nous avons eu une situation similaire qui s'est soldée par un échec des compilations en raison de dossiers manquants. Je suis tombé sur ce post lié ci-dessous, qui m'a aidé. Il décrit l'écriture D'une macro Visual Studio qui s'exécute au démarrage d'une construction.

Rapport d'erreur/d'avertissement si des fichiers manquants dans un projet/solution dans Visual Studio

(en supposant que Team Foundation Server est votre source control): si le fichier a été ajouté au projet et apparaît dans Source Control Explorer, mais N'apparaît pas dans Solution Explorer, vous devez l'ajouter manuellement à Source Control Explorer en sélectionnant" Ajouter","élément existant". C'est un bogue gênant Visual Studio/TFS que je viens de passer 2 heures à essayer de comprendre.

j'ai écrit un outil pour cela il y a quelque temps. Disponible ici .

une autre possibilité: parfois le fichier n'est pas ajouté de façon sélective au contrôle source. Pour résoudre ce problème, faites un clic droit sur le projet et sélectionnez "Ajouter des éléments au dossier".

tous les fichiers qui ne sont pas affichés dans l'Explorateur de contrôle des sources que vous voyez dans leurs dossiers sources doivent être ici et peuvent être ajoutés sélectivement.