Rename

DotNetSolutionTools.Core/DotNetSolutionTools.Core.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.Build" Version="17.7.2" />
+    </ItemGroup>
+
+</Project>

DotNetSolutionTools.Core/FormatCsproj.cs

@@ -0,0 +1,37 @@
+using System.Text;
+using System.Xml;
+
+namespace DotNetSolutionTools.Core;
+
+public static class FormatCsproj
+{
+    public static void FormatCsprojFile(string csprojFilePath)
+    {
+        using TextReader rd = new StreamReader(csprojFilePath, Encoding.Default);
+
+        XmlDocument doc = new XmlDocument();
+        doc.Load(rd);
+
+        if (rd != Console.In)
+        {
+            rd.Close();
+        }
+
+        using var wr = new StreamWriter(csprojFilePath, false, Encoding.Default);
+
+        var settings =
+            new XmlWriterSettings 
+            { 
+                Indent = true, 
+                IndentChars = "\t",
+                NewLineOnAttributes = false,
+                OmitXmlDeclaration = true
+            };
+
+        using (var writer = XmlWriter.Create(wr, settings))
+        {
+            doc.WriteContentTo(writer);
+            writer.Close();
+        }
+    }
+}

DotNetSolutionTools.Core/ImplicitUsings.cs

@@ -0,0 +1,60 @@
+using Microsoft.Build.Construction;
+
+namespace DotNetSolutionTools.Core;
+
+public static class ImplicitUsings
+{
+    public static List<ProjectRootElement> FindCSharpProjectsMissingImplicitUsings(List<ProjectRootElement> projectList)
+    {
+        var projectsMissingImplicitUsings = new List<ProjectRootElement>();
+        
+        foreach (var project in projectList)
+        {
+            var implicitUsings = project.PropertyGroups
+                .SelectMany(x => x.Properties)
+                .FirstOrDefault(x => x.Name == "ImplicitUsings");
+            if (implicitUsings is null || implicitUsings.Value is not "enable")
+            {
+                projectsMissingImplicitUsings.Add(project);
+            }
+        }
+
+        return projectsMissingImplicitUsings;
+    }
+
+    public static void AddMissingImplicitUsings(List<ProjectRootElement> projectsMissingImplicitUsings)
+    {
+        foreach (var project in projectsMissingImplicitUsings)
+        {
+            if (ProjectIsMissingImplicitUsings(project))
+            {
+                project.AddProperty("ImplicitUsings", "enable");
+                project.Save();
+                FormatCsproj.FormatCsprojFile(project.FullPath);
+            }
+        }
+    }
+
+    public static void EnableDisabledImplicitUsings(List<ProjectRootElement> projectsMissingImplicitUsings)
+    {
+        throw new NotImplementedException();
+    }
+
+    public static void EnableAllImplicitUsings(List<ProjectRootElement> projectsMissingImplicitUsings)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public static bool ProjectIsMissingImplicitUsings(ProjectRootElement project)
+    {
+        var implicitUsings = project.PropertyGroups
+            .SelectMany(x => x.Properties)
+            .FirstOrDefault(x => x.Name == "ImplicitUsings");
+        if (implicitUsings is null)
+        {
+            return true;
+        }
+
+        return false;
+    }
+}

DotNetSolutionTools.Core/SolutionParityChecker.cs

@@ -0,0 +1,82 @@
+using Microsoft.Build.Construction;
+
+namespace DotNetSolutionTools.Core;
+
+public static class SolutionParityChecker
+{
+    public static List<string> CompareSolutionAndCSharpProjects(
+        string solutionFolderPath,
+        string solutionFilePath
+    )
+    {
+        var csprojList = RetrieveAllCSharpProjectNamesFromFolder(solutionFolderPath);
+        var solutionFile = ParseSolutionFileFromPath(solutionFilePath);
+        ArgumentNullException.ThrowIfNull(solutionFile);
+        var projectsMissingFromSolution = FindProjectsMissingFromSolution(csprojList, solutionFile);
+
+        return projectsMissingFromSolution;
+    }
+
+    public static string[] RetrieveAllCSharpProjectNamesFromFolder(string solutionFolderPath)
+    {
+        var csprojList = RetrieveAllCSharpProjectFullPathsFromFolder(solutionFolderPath);
+
+        csprojList = csprojList.Select(x => x.Replace(solutionFolderPath, "")).ToArray();
+        return csprojList;
+    }
+
+    public static string[] RetrieveAllCSharpProjectFullPathsFromFolder(string solutionFolderPath)
+    {
+        // if solutionFolderPath does not end with a slash, add one
+        if (solutionFolderPath[^1] != Path.DirectorySeparatorChar)
+        {
+            solutionFolderPath += Path.DirectorySeparatorChar;
+        }
+        var csprojList = Directory.GetFiles(
+            solutionFolderPath,
+            "*.csproj",
+            SearchOption.AllDirectories
+        );
+        return csprojList;
+    }
+
+    public static SolutionFile? ParseSolutionFileFromPath(string solutionFilePath)
+    {
+        var solutionFile = SolutionFile.Parse(solutionFilePath);
+
+        return solutionFile;
+    }
+
+    public static List<string> FindProjectsMissingFromSolution(
+        string[] csprojList,
+        SolutionFile solutionFile
+    )
+    {
+        var projects = solutionFile.ProjectsInOrder;
+        var projectsMissingFromSolution = new List<string>();
+
+        foreach (var project in csprojList)
+        {
+            var projectInSolution = projects.FirstOrDefault(x => x.RelativePath == project);
+
+            if (projectInSolution == null)
+            {
+                projectsMissingFromSolution.Add(project);
+            }
+        }
+
+        return projectsMissingFromSolution;
+    }
+
+    public static List<ProjectRootElement> GetCSharpProjectObjectsFromSolutionFile(
+        SolutionFile solutionFile
+    )
+    {
+        var projectList = solutionFile.ProjectsByGuid
+            .Where(x => x.Value.ProjectType == SolutionProjectType.KnownToBeMSBuildFormat)
+            .Select(s => ProjectRootElement.Open(s.Value.AbsolutePath))
+            .ToList();
+
+        return projectList;
+    }
+}