Wie konsolidiert man alle anwendbaren Projekte und nuget Pakete von der Kommandozeile?

Question

ich zwei Lösungen bin Zusammenführung und haben nun folgende Situation

Es ist ein großes Projekt und ein einzelnes Paket nimmt genug Zeit zu konsolidieren. Konsolidierung von 26 und ich werde den ganzen Tag hier sein. Gibt es eine Möglichkeit, die Chargen zu konsolidieren, so dass ich ein Mittagessen einnehmen kann und es erledigt ist, wenn ich zurück bin?

Answer 1

In Bezug auf die Kommentare werde ich meine Lösung hier posten. Es ist ein Teil eines größeren Werkzeugs, also werde ich hier eine Schlüssel-Klasse veröffentlichen, es sollte ziemlich einfach sein, es miteinander zu verbinden. Installierte Pakete (Sie können sich wahrscheinlich neuere Versionen verwenden):

"NuGet.Core": "2.12.0-rtm-815", 
    "NuGet.Packaging": "3.5.0-beta2-1484", 
    "NuGet.ProjectManagement": "3.5.0-beta2-1484", 

Quelle:

public class NugetSource 
{ 
    public string Name { get; set; } 
    public string Value { get; set; } 
} 

public class MyAppVersion 
{ 
    public double Id { get; set; } 
    public ObservableCollection<Dependency> Dependencies { get; set; } 

    public MyAppVersion() 
    { 
     Dependencies = new ObservableCollection<Dependency>(); 
    } 
} 

public class Dependency : ReactiveObject 
{ 
    public Dependency() 
    { 
     AvailableVersions = new List<SemanticVersion>(); 
    } 

    private SemanticVersion _version; 
    private string _name; 
    private List<SemanticVersion> _availableVersions; 

    [JsonProperty] 
    public string Name 
    { 
     get { return _name; } 
     set 
     { 
      _name = value; 
      this.RaiseAndSetIfChanged(ref _name, value); 
     } 
    } 

    [JsonProperty] 
    public SemanticVersion Version 
    { 
     get { return _version; } 
     set { this.RaiseAndSetIfChanged(ref _version, value); } 
    } 

    [JsonIgnore] 
    public List<SemanticVersion> AvailableVersions 
    { 
     get { return _availableVersions; } 
     set { this.RaiseAndSetIfChanged(ref _availableVersions, value); } 
    } 

    public override string ToString() 
    { 
     return $"Name: {Name}, Version: {Version}"; 
    } 
} 

public class NugetUpdater : INugetUpdater 
{ 
    private readonly List<IPackageRepository> _supportedRepositories; 

    public NugetUpdater() 
    { 
     _supportedRepositories = 
      GetSources().Select(x => PackageRepositoryFactory.Default.CreateRepository(x.Value)).ToList(); 
    } 

    public NugetSource[] GetSources() 
    { 

     var sources = new[] 
     { 
      new NugetSource() {Name = nameof(AppPaths.Dev), Value = AppPaths.Dev}, 
      new NugetSource() {Name = nameof(AppPaths.Uat), Value = AppPaths.Uat}, 
      new NugetSource() {Name = nameof(AppPaths.ThirdParty), Value = AppPaths.ThirdParty}, 
     }; 

     return sources; 
    } 

    public List<SemanticVersion> GetVersions(IEnumerable<string> feedUrls, string packageId) 
    { 
     var versions = new List<SemanticVersion>(); 
     var repos = GetRepositories(feedUrls); 

     foreach (var currentRepo in repos) 
     { 
      var packages = currentRepo.FindPackagesById(packageId).ToList(); 
      versions.AddRange(packages.Select(x => x.Version)); 
     } 

     return versions; 
    } 

    public SemanticVersion GetLatestVersion(IEnumerable<string> feedUrls, string packageId) 
    { 
     var versions = GetVersions(feedUrls, packageId); 
     return versions.Any() ? versions.Max() : null; 
    } 

    public SemanticVersion GetLatestVersion(string feedUrl, string packageId) 
    { 
     return GetLatestVersion(new[] {feedUrl}, packageId); 
    } 

    public List<SemanticVersion> GetVersions(string feedUrl, string packageId) 
    { 
     return GetVersions(new[] {feedUrl}, packageId); 
    } 

    public List<Dependency> GetSolutionDependencies(string baseDir) 
    { 
     return Directory.EnumerateFiles(baseDir, "project.json", SearchOption.AllDirectories) 
      .Select(File.ReadAllText) 
      .Select(JObject.Parse) 
      .Select(GetDependencies) 
      .SelectMany(x => x) 
      .DistinctBy(x => x.Name) 
      .ToList(); 
    } 

    private List<IPackageRepository> GetRepositories(IEnumerable<string> feedUrls) 
    { 
     return _supportedRepositories.Where(x => feedUrls.Contains(x.Source)).ToList(); 
    } 

    public void Update(string baseDir, MyAppVersion version) 
    { 
     IEnumerable<string> jsonFiles = 
      Directory.EnumerateFiles(baseDir, "project.json", SearchOption.AllDirectories).ToList(); 

     foreach (var projectJsonPath in jsonFiles) 
     { 
      var content = File.ReadAllText(projectJsonPath); 
      JObject json = JObject.Parse(content); 
      var projectDependencies = GetDependencies(json); 

      if (!projectDependencies.Any()) 
       continue; 

      var projectDepNames = projectDependencies.Select(x => x.Name).ToList(); 
      var toUpdateDependencies = version.Dependencies.Where(x => projectDepNames.Contains(x.Name)).ToList(); 

      if (toUpdateDependencies.Count != projectDependencies.Count) 
       throw new Exception("Dependencies count is not equal. Something went wrong"); 

      var dependenciesPairs = toUpdateDependencies.OrderBy(x => x.Name) 
       .Zip(projectDependencies.OrderBy(x => x.Name), (x, y) => new {ToUpdate = x, Project = y}).ToList(); 


      bool anyChanged = false; 

      foreach (var dependencyPair in dependenciesPairs) 
      { 
       if (dependencyPair.Project.Version != dependencyPair.ToUpdate.Version) 
       { 
        anyChanged = true; 
        dependencyPair.Project.Version = dependencyPair.ToUpdate.Version; 
       } 
      } 

      if (anyChanged) 
      { 
       JObject obj = new JObject(projectDependencies.Select(x => new JProperty(x.Name, x.Version.ToNormalizedString()))); 
       json["dependencies"] = obj; 
       File.WriteAllText(projectJsonPath, json.ToString(Formatting.Indented)); 
      } 
     } 
    } 

    private static List<Dependency> GetDependencies(JObject json) 
    { 
     JObject dependenciesObject = (JObject) json["dependencies"]; 

     var dependencies = dependenciesObject.Properties().Select(x => new Dependency 
     { 
      Name = x.Name, 
      Version = SemanticVersion.Parse(x.Value.Value<string>()) 
     }).ToList(); 

     return dependencies; 
    } 
} 

Grundsätzlich Anwendung verwendet NugetUpdaterGetSolutionDependencies dem Benutzer alle Abhängigkeiten in einer Lösung angezeigt werden soll.

Dann wird GetVersions Methode verwendet, um verfügbare Versionen für das ausgewählte Paket zu erhalten. Der Benutzer kann die Version auswählen, an der er interessiert ist. Wenn er fertig ist, klickt er auf update und die Funktion Update verwendet vom Benutzer ausgewählte Versionen, um alle Abhängigkeiten in allen project.jsons in einer Lösung zu ersetzen.

Statt die Versionen einzeln auszuwählen, können Benutzer neuesten Versionen wählen für alle Pakete, ist es ziemlich einfach, mit Kombination von

GetSolutionDependencies + GetLatestVersion für jedes einzelne Paket + Update.

Im Grunde ist das Ergebnis eine Liste von project.json aktualisiert mit den neuesten Versionen von Paketen.

Alles, was Sie tun müssen, ist entweder nuget restore laufen oder bauen Sie die Lösung mit VS, die automatisch Wiederherstellung aufrufen.