Comment trouver les fichiers manquants dans les projets de Visual Studio?
En raison de problèmes de fusion, etc., nous avons beaucoup de fichiers de projet qui ne contiennent pas tous les fichiers de code source contenus dans leurs dossiers.
Avant d'écrire un petit outil qui vérifie que chaque fichier *.cs est inclus dans un fichier de projet, je souhaite m'assurer que personne d'autre ne l'a déjà fait auparavant.
(Nous avons près de 100 fichiers de projet et 1 000 fichiers C #)
-------------------
Clairement, le support dont dispose actuellement Visual Studio pour l’utilisation de caractères génériques pour inclure tous les fichiers «* .cs» d’un répertoire donné dans le projet est la meilleure solution à ce problème. Dans ce cas, il n'est pas nécessaire de mettre à jour les fichiers de projet lorsque des fichiers “.cs” sont ajoutés, renommés ete. Cependant, ce n'est que dans VS2017 que cela devient utilisable à partir de l'interface utilisateur.
Avec ce nombre de fichiers et de projets, il semble que vous souhaitiez peut-être quelque chose de plus automatisé. Cependant, il existe une approche manuelle (vous ne savez pas si vous en êtes déjà au courant):
- Sélectionnez le projet dans le volet Explorateur de solutions.
- Menu Projet -> Afficher tous les fichiers
- Sous le projet, les fichiers qui ne font pas partie du projet apparaîtront sous forme d'icônes "fantômes".
- Sélectionnez le (s) fichier (s) de votre choix et choisissez "Inclure dans le projet" dans le menu contextuel.
J'ai trouvé l'extension " Afficher les fichiers manquants " Visual Studio. Il montrera la liste des fichiers manquants dans la fenêtre "Liste des erreurs" après la construction.
Après avoir lu qu'il n'y a pas de solution générique à ce problème ici sur Stack Overflow, 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, alors j'espère que cela aidera les autres aussi. Cela me évite une vérification manuelle de plus de 70 dossiers (plus de 500 fichiers) sur chaque déploiement. Si j'ai un peu de temps, j'espère améliorer certaines choses, comme la documentation ... Mais laissez-moi maintenant vous donner un exemple simple.
Exemple simple
- Installer nodeJS (Fonctionne également très bien sous Windows)
npm install check-vs-includes- Ajoutez une tâche pour cela et spécifiez les fichiers à vérifier.
Par exemple, ajoutez 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 des dossiers spécifiés sont inclus dans votre fichier de projet. Notez que vous pouvez utiliser glob '.
- Exécutez le chèque; pour l'exemple GULP:
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 à cela, j'ai rencontré this VS Extension, mais cela ne fonctionne qu'avec VS 2012. C'est aussi sur Github .
Pour VS 2013+, j'utilise un script Powershell disponible sur this blog. Notez que cela ne fonctionne que pour les projets C #, mais que 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 de la console NuGet):
./FindProjectMissingFiles.ps1 -s $dte.Solution.FileName
Une petite application console C # qui trouve tous les fichiers cs référencés à partir de fichiers de projet dans un dossier racine donné (de manière récursive) et se compare aux fichiers du système de fichiers sous le même dossier racine. Peut être appliqué à différentes extensions de fichier et à différentes structures de fichiers de projet (je l’ai testé pour VS2008). Il peut nécessiter des modifications pour répondre à d’autres besoins, mais devrait fournir 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("$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();
}
}
}
Aucune des solutions précédentes ne fonctionnait pour moi car le projet auquel je tentais 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 l'option "Afficher tous les fichiers" n'existait pas.
En effet, pour WSP ( link ):
"tous les fichiers sont déjà affichés dans l'explorateur de solutions."
Sauf que dans mon cas, ils ne l'étaient pas ... 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 que l'ajout de nouveaux fichiers lorsque le site Web est rechargé, pas lorsque ces fichiers sont ajoutés en dehors de VS.
Autre possibilité: Parfois, le fichier n'est pas ajouté de manière sélective au contrôle de source. Pour résoudre ce problème, cliquez avec le bouton droit sur le projet et sélectionnez "Ajouter des éléments au dossier".
Tous les fichiers ne figurant pas dans l'explorateur de contrôle de code source que vous voyez dans leurs dossiers source doivent être ici et peuvent être ajoutés de manière sélective.
(En supposant que Team Foundation Server soit votre contrôle de code source): si le fichier a été ajouté au projet et s'affiche dans l'Explorateur de contrôle des sources, mais ne s'affiche PAS dans l'Explorateur de solutions, vous devez l'ajouter manuellement à l'Explorateur de contrôle des sources en sélectionnant " Ajouter "," Elément existant ". C’est un bogue ennuyeux de Visual Studio/TFS que je passe 2 heures à essayer de comprendre.
Nous avons eu une situation similaire qui a abouti à l'échec de la compilation en raison de fichiers manquants. Je suis tombé sur ce poste lié ci-dessous, qui m'a aidé. Il décrit l'écriture d'une macro Visual Studio qui s'exécute lorsqu'une génération est démarrée.
J'ai écrit un outil pour cela il y a quelque temps. Disponible ici .