L'analyse de solutions de Visual Studio fichiers

L' .NET 4.0 version de Microsoft.De montage contient un SolutionParser classe dans le Microsoft.Construire.La Construction de l'espace de noms que l'analyse de solutions de Visual Studio fichiers.

Malheureusement cette classe est interne, mais j'ai regroupé certaines de ces fonctionnalités dans une classe qui utilise la réflexion pour obtenir des propriétés communes qui peuvent vous être utiles.

public class Solution
{
//internal class SolutionParser
//Name: Microsoft.Build.Construction.SolutionParser
//Assembly: Microsoft.Build, Version=4.0.0.0
static readonly Type s_SolutionParser;
static readonly PropertyInfo s_SolutionParser_solutionReader;
static readonly MethodInfo s_SolutionParser_parseSolution;
static readonly PropertyInfo s_SolutionParser_projects;
static Solution()
{
s_SolutionParser = Type.GetType("Microsoft.Build.Construction.SolutionParser, Microsoft.Build, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", false, false);
if (s_SolutionParser != null)
{
s_SolutionParser_solutionReader = s_SolutionParser.GetProperty("SolutionReader", BindingFlags.NonPublic | BindingFlags.Instance);
s_SolutionParser_projects = s_SolutionParser.GetProperty("Projects", BindingFlags.NonPublic | BindingFlags.Instance);
s_SolutionParser_parseSolution = s_SolutionParser.GetMethod("ParseSolution", BindingFlags.NonPublic | BindingFlags.Instance);
}
}
public List<SolutionProject> Projects { get; private set; }
public Solution(string solutionFileName)
{
if (s_SolutionParser == null)
{
throw new InvalidOperationException("Can not find type 'Microsoft.Build.Construction.SolutionParser' are you missing a assembly reference to 'Microsoft.Build.dll'?");
}
var solutionParser = s_SolutionParser.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic).First().Invoke(null);
using (var streamReader = new StreamReader(solutionFileName))
{
s_SolutionParser_solutionReader.SetValue(solutionParser, streamReader, null);
s_SolutionParser_parseSolution.Invoke(solutionParser, null);
}
var projects = new List<SolutionProject>();
var array = (Array)s_SolutionParser_projects.GetValue(solutionParser, null);
for (int i = 0; i < array.Length; i++)
{
projects.Add(new SolutionProject(array.GetValue(i)));
}
this.Projects = projects;
}
}
[DebuggerDisplay("{ProjectName}, {RelativePath}, {ProjectGuid}")]
public class SolutionProject
{
static readonly Type s_ProjectInSolution;
static readonly PropertyInfo s_ProjectInSolution_ProjectName;
static readonly PropertyInfo s_ProjectInSolution_RelativePath;
static readonly PropertyInfo s_ProjectInSolution_ProjectGuid;
static readonly PropertyInfo s_ProjectInSolution_ProjectType;
static SolutionProject()
{
s_ProjectInSolution = Type.GetType("Microsoft.Build.Construction.ProjectInSolution, Microsoft.Build, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", false, false);
if (s_ProjectInSolution != null)
{
s_ProjectInSolution_ProjectName = s_ProjectInSolution.GetProperty("ProjectName", BindingFlags.NonPublic | BindingFlags.Instance);
s_ProjectInSolution_RelativePath = s_ProjectInSolution.GetProperty("RelativePath", BindingFlags.NonPublic | BindingFlags.Instance);
s_ProjectInSolution_ProjectGuid = s_ProjectInSolution.GetProperty("ProjectGuid", BindingFlags.NonPublic | BindingFlags.Instance);
s_ProjectInSolution_ProjectType = s_ProjectInSolution.GetProperty("ProjectType", BindingFlags.NonPublic | BindingFlags.Instance);
}
}
public string ProjectName { get; private set; }
public string RelativePath { get; private set; }
public string ProjectGuid { get; private set; }
public string ProjectType { get; private set; }
public SolutionProject(object solutionProject)
{
this.ProjectName = s_ProjectInSolution_ProjectName.GetValue(solutionProject, null) as string;
this.RelativePath = s_ProjectInSolution_RelativePath.GetValue(solutionProject, null) as string;
this.ProjectGuid = s_ProjectInSolution_ProjectGuid.GetValue(solutionProject, null) as string;
this.ProjectType = s_ProjectInSolution_ProjectType.GetValue(solutionProject, null).ToString();
}
}

Noter que vous devez changer votre cible cadre ".NET Framework 4" (pas le profil du client) pour être en mesure d'ajouter de Microsoft.Construire référence à votre projet.

Je ne sais pas si quelqu'un est toujours à la recherche de solutions à ce problème, mais j'ai couru à travers un projet qui semble faire exactement ce qui est nécessaire.
https://slntools.codeplex.com/
L'une des fonctions de cet outil est de fusionner plusieurs solutions ensemble.

Je ne peux pas vraiment vous offrir une bibliothèque et a mon avis il n'y en a pas un qui existe là-bas. Mais j'ai passé beaucoup de temps à déconner avec .la sln fichiers en lot modification des scénarios et j'ai trouvé Powershell pour être un outil très utile pour cette tâche. L' .La SLN format est assez simple et peut-être presque entièrement analysé avec un peu rapide et sale expressions. Par Exemple

Inclus les fichiers de Projet.

gc ConsoleApplication30.sln | 
? { $_ -match "^Project" } | 
%{ $_ -match ".*=(.*)$" | out-null ; $matches[1] } | 
%{ $_.Split(",")[1].Trim().Trim('"') }

Il n'est pas toujours joli, mais il est un moyen efficace de faire du traitement par lot.

Tout est parfait, mais je voulais également à obtenir de la sln capacité de production - dans le code de l'instantané ci-dessus, vous êtes seulement à l'analyse .la sln fichiers - j'ai voulu faire une chose semblable, sauf à être en mesure de re-générer de la sln avec de légères modifications .la sln fichier. De tels cas pourrait être, par exemple, le portage d'un même projet pour différents .NET plate-forme. Pour l'instant c'est uniquement de la sln ré-génération, mais plus tard, je vais l'étendre aux projets.

Je suppose que je voulais aussi faire la démonstration de la puissance des expressions régulières et des interfaces natives.
(Plus petite quantité de code avec plus de fonctionnalités)

Mise à jour 4.1.2017
J'ai créé séparer le dépôt svn pour l'analyse .la sln solution:
https://sourceforge.net/p/syncproj/code/HEAD/tree/

Ci-dessous est mon propre exemple de code snippet (prédécesseur). Vous êtes libre de les utiliser.

Il est possible qu'à l'avenir, svn solution basée sur le code d'analyse sera mise à jour avec des capacités de génération de bien.

Mise à jour 4.2.2017
Code Source dans le SVN est en charge .la sln génération.

using System;
using System.Linq;
using System.Collections.Generic;
using System.IO;
using System.Diagnostics;
using System.Text.RegularExpressions;
using System.Text;
public class Program
{
[DebuggerDisplay("{ProjectName}, {RelativePath}, {ProjectGuid}")]
public class SolutionProject
{
public string ParentProjectGuid;
public string ProjectName;
public string RelativePath;
public string ProjectGuid;
public string AsSlnString()
{ 
return "Project(\"" + ParentProjectGuid + "\") = \"" + ProjectName + "\", \"" + RelativePath + "\", \"" + ProjectGuid + "\"";
}
}
///<summary>
///.sln loaded into class.
///</summary>
public class Solution
{
public List<object> slnLines;       //List of either String (line format is not intresting to us), or SolutionProject.
///<summary>
///Loads visual studio .sln solution
///</summary>
///<param name="solutionFileName"></param>
///<exception cref="System.IO.FileNotFoundException">The file specified in path was not found.</exception>
public Solution( string solutionFileName )
{
slnLines = new List<object>();
String slnTxt = File.ReadAllText(solutionFileName);
string[] lines = slnTxt.Split('\n');
//Match string like: Project("{66666666-7777-8888-9999-AAAAAAAAAAAA}") = "ProjectName", "projectpath.csproj", "{11111111-2222-3333-4444-555555555555}"
Regex projMatcher = new Regex("Project\\(\"(?<ParentProjectGuid>{[A-F0-9-]+})\"\\) = \"(?<ProjectName>.*?)\", \"(?<RelativePath>.*?)\", \"(?<ProjectGuid>{[A-F0-9-]+})");
Regex.Replace(slnTxt, "^(.*?)[\n\r]*$", new MatchEvaluator(m =>
{
String line = m.Groups[1].Value;
Match m2 = projMatcher.Match(line);
if (m2.Groups.Count < 2)
{
slnLines.Add(line);
return "";
}
SolutionProject s = new SolutionProject();
foreach (String g in projMatcher.GetGroupNames().Where(x => x != "0")) /* "0" - RegEx special kind of group */
s.GetType().GetField(g).SetValue(s, m2.Groups[g].ToString());
slnLines.Add(s);
return "";
}), 
RegexOptions.Multiline
);
}
///<summary>
///Gets list of sub-projects in solution.
///</summary>
///<param name="bGetAlsoFolders">true if get also sub-folders.</param>
public List<SolutionProject> GetProjects( bool bGetAlsoFolders = false )
{
var q = slnLines.Where( x => x is SolutionProject ).Select( i => i as SolutionProject );
if( !bGetAlsoFolders )  //Filter away folder names in solution.
q = q.Where( x => x.RelativePath != x.ProjectName );
return q.ToList();
}
///<summary>
///Saves solution as file.
///</summary>
public void SaveAs( String asFilename )
{
StringBuilder s = new StringBuilder();
for( int i = 0; i < slnLines.Count; i++ )
{
if( slnLines[i] is String ) 
s.Append(slnLines[i]);
else
s.Append((slnLines[i] as SolutionProject).AsSlnString() );
if( i != slnLines.Count )
s.AppendLine();
}
File.WriteAllText(asFilename, s.ToString());
}
}
static void Main()
{
String projectFile = @"yourown.sln";
try
{
String outProjectFile = Path.Combine(Path.GetDirectoryName(projectFile), Path.GetFileNameWithoutExtension(projectFile) + "_2.sln");
Solution s = new Solution(projectFile);
foreach( var proj in s.GetProjects() )
{
Console.WriteLine( proj.RelativePath );
}
SolutionProject p = s.GetProjects().Where( x => x.ProjectName.Contains("Plugin") ).First();
p.RelativePath = Path.Combine( Path.GetDirectoryName(p.RelativePath) , Path.GetFileNameWithoutExtension(p.RelativePath) + "_Variation" + ".csproj");
s.SaveAs(outProjectFile);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
}
}

Réponse par @jean-leidegren est grande. Pour le pré-VS2015, c'est d'une grande utilité. Mais il y avait une petite erreur, comme le code pour récupérer les configurations manquait. Si envie d'ajouter, dans le cas où quelqu'un est en difficulté pour utiliser ce code.

L'amélioration est très simple:

    public class Solution
{
//internal class SolutionParser
//Name: Microsoft.Build.Construction.SolutionParser
//Assembly: Microsoft.Build, Version=4.0.0.0
static readonly Type s_SolutionParser;
static readonly PropertyInfo s_SolutionParser_solutionReader;
static readonly MethodInfo s_SolutionParser_parseSolution;
static readonly PropertyInfo s_SolutionParser_projects;
static readonly PropertyInfo s_SolutionParser_configurations;//this was missing in john's answer
static Solution()
{
s_SolutionParser = Type.GetType("Microsoft.Build.Construction.SolutionParser, Microsoft.Build, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", false, false);
if ( s_SolutionParser != null )
{
s_SolutionParser_solutionReader = s_SolutionParser.GetProperty("SolutionReader", BindingFlags.NonPublic | BindingFlags.Instance);
s_SolutionParser_projects = s_SolutionParser.GetProperty("Projects", BindingFlags.NonPublic | BindingFlags.Instance);
s_SolutionParser_parseSolution = s_SolutionParser.GetMethod("ParseSolution", BindingFlags.NonPublic | BindingFlags.Instance);
s_SolutionParser_configurations = s_SolutionParser.GetProperty("SolutionConfigurations", BindingFlags.NonPublic | BindingFlags.Instance); //this was missing in john's answer
//additional info:
var PropNameLst = GenHlp_PropBrowser.PropNamesOfType(s_SolutionParser);
//the above call would yield something like this:
//[ 0] "SolutionParserWarnings"        string
//[ 1] "SolutionParserComments"        string
//[ 2] "SolutionParserErrorCodes"      string
//[ 3] "Version"                       string
//[ 4] "ContainsWebProjects"           string
//[ 5] "ContainsWebDeploymentProjects" string
//[ 6] "ProjectsInOrder"               string
//[ 7] "ProjectsByGuid"                string
//[ 8] "SolutionFile"                  string
//[ 9] "SolutionFileDirectory"         string
//[10] "SolutionReader"                string
//[11] "Projects"                      string
//[12] "SolutionConfigurations"        string
}
}
public List<SolutionProject> Projects { get; private set; }
public List<SolutionConfiguration> Configurations { get; private set; }
//...
//...
//... no change in the rest of the code
}

Que l'aide supplémentaire, fournissant un code simple pour parcourir les propriétés d'un System.Type comme suggéré par @oasten.

public class GenHlp_PropBrowser
{
public static List<string> PropNamesOfClass(object anObj)
{
return anObj == null ? null : PropNamesOfType(anObj.GetType());
}
public static List<String> PropNamesOfType(System.Type aTyp)
{
List<string> retLst = new List<string>();
foreach ( var p in aTyp.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance) )
{
retLst.Add(p.Name);
}
return retLst;
}
}

Pour ce que sa vaut le coup, j'ai créé un petit projet pour lire la sln et proj fichiers disponibles sur nuget:

https://www.nuget.org/packages/ByteDev.DotNet/