Git-wijzigingen in meerdere projecten verwerken in Visual Studio

Inleiding tot het beheren van Git-wijzigingen

We zijn onlangs overgestapt naar Azure DevOps en zijn een bruikbaarheidsprobleem tegengekomen bij onze uitgebreide verzameling van 482 applicaties. Deze applicaties zijn gegroepeerd in repositories, die elk meerdere oplossingen bevatten. Eén zo'n repository herbergt vijf applicaties, waarbij één oplossing meer dan twintig projecten heeft, waarbij er slechts één door de applicaties wordt gedeeld, terwijl andere 10 tot 15 unieke projecten hebben.

Onze uitdaging ontstaat wanneer we tegelijkertijd aan meerdere applicaties binnen dezelfde repository werken. In tegenstelling tot SVN, dat wijzigingen filterde om alleen de wijzigingen weer te geven die relevant zijn voor het project in de oplossing, geeft Git Changes van Visual Studio alle wijzigingen in de repository weer. Dit zorgt voor een rommelig beeld, waardoor het moeilijk is om je op specifieke projecten te concentreren. We onderzoeken manieren om dit effectief te beheren.

Commando	Beschrijving
git -C $repoPath rev-parse --abbrev-ref HEAD	Haalt de huidige vertakkingsnaam op in de opgegeven repository.
git -C $repoPath diff --name-only $branch	Geeft een overzicht van de namen van bestanden die in de huidige vertakking zijn gewijzigd in vergelijking met de opgegeven vertakking.
Where-Object	Filtert objecten in een verzameling op basis van opgegeven voorwaarden in PowerShell.
IVsWindowFrame	Vertegenwoordigt een raamkozijn in Visual Studio, dat wordt gebruikt voor het aanpassen van gereedschapsvensters.
Package.Initialize()	Overschrijft de initialisatiemethode voor een Visual Studio-pakket om aangepaste logica toe te voegen.
IVsWindowFrame.Show()	Geeft een toolvenster weer in Visual Studio.
Package	De basisklasse voor het maken van een Visual Studio-pakket dat de IDE kan uitbreiden.

De scriptoplossingen begrijpen

Het meegeleverde PowerShell-script is ontworpen om de Git-wijzigingen te filteren, zodat alleen de wijzigingen worden weergegeven die relevant zijn voor een specifieke oplossing binnen een grotere opslagplaats. Het begint met het definiëren van het pad naar de repository en haalt de huidige vertakking op met behulp van de opdracht . Vervolgens worden de namen weergegeven van bestanden die in de huidige vertakking zijn gewijzigd met behulp van . Het script filtert vervolgens deze gewijzigde bestanden zodat alleen de bestanden binnen het opgegeven oplossingspad worden opgenomen met behulp van , waarmee we een voorwaarde kunnen toepassen dat de bestandspaden moeten overeenkomen met het oplossingspad.

Aan de andere kant past de Visual Studio-extensie geschreven in C# het Git Changes-venster aan om relevante wijzigingen te filteren en weer te geven. Het haakt in op de Visual Studio-omgeving met behulp van de klasse, die een raamkozijn in Visual Studio vertegenwoordigt. De belangrijkste logica van de extensie is ingekapseld in de methode, waar het het Git Changes-vensterframe vindt en aangepaste filterlogica toepast om alleen de wijzigingen weer te geven die deel uitmaken van de huidige oplossing. Dit helpt ontwikkelaars zich te concentreren op de relevante wijzigingen zonder te worden afgeleid door niet-gerelateerde wijzigingen in de repository.

# Define the path to the repository
$repoPath = "C:\path\to\your\repository"
# Get the current branch
$branch = git -C $repoPath rev-parse --abbrev-ref HEAD
# Get the list of changed files
$changedFiles = git -C $repoPath diff --name-only $branch
# Define the solution path
$solutionPath = "C:\path\to\your\solution"
# Filter the changed files to include only those in the solution
$filteredFiles = $changedFiles | Where-Object { $_ -like "$solutionPath\*" }
# Output the filtered files
$filteredFiles

using System;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Shell.Interop;
namespace GitChangesFilter
{
    public class GitChangesFilterPackage : Package
    {
        protected override void Initialize()
        {
            base.Initialize();
            // Hook into the Git Changes window
            IVsWindowFrame windowFrame = /* Get the Git Changes window frame */
            if (windowFrame != null)
            {
                // Customize the Git Changes display
                // Apply filtering logic here
            }
        }
    }
}

Meerdere projecten beheren in Visual Studio met Git

Een andere benadering voor het beheren van Git-wijzigingen in Visual Studio is het effectief gebruiken van branch-strategieën. Door voor elke applicatie of groep applicaties binnen dezelfde repository afzonderlijke vertakkingen te maken, kunt u wijzigingen isoleren en voorkomen dat ze in niet-gerelateerde projecten verschijnen. Op deze manier worden, wanneer je tussen vertakkingen schakelt, alleen de wijzigingen weergegeven die relevant zijn voor de huidige vertakking in het Git Changes-venster. Deze methode zorgt ook voor een betere samenwerking, omdat teamleden op verschillende vestigingen kunnen werken zonder elkaars werk te hinderen.

Bovendien kunnen tools zoals Git-submodules of Git sparse-checkout worden gebruikt om grote repository's met meerdere projecten te beheren. Met Git-submodules kun je andere repository's in een repository opnemen, waardoor je betere controle krijgt over afhankelijkheden en projectscheiding. Met Git sparse-checkout kun je slechts een subset van de bestanden in de repository uitchecken, waardoor de rommel in de werkmap wordt verminderd en het gemakkelijker wordt om je op specifieke projecten te concentreren. Deze technieken kunnen de productiviteit aanzienlijk verbeteren bij het omgaan met complexe repository's met meerdere projecten.

1. Hoe kan ik wijzigingen aan een specifiek project in een opslagplaats met meerdere projecten filteren?
2. U kunt gebruik maken van de opdracht in PowerShell om de gewijzigde bestanden te filteren, zodat ze alleen de bestanden binnen het opgegeven oplossingspad bevatten.
3. Wat zijn Git-submodules en hoe helpen ze?
4. kunt u andere repository's in een repository opnemen, waardoor u betere controle krijgt over afhankelijkheden en projectscheiding.
5. Hoe helpen branchestrategieën bij het managen van veranderingen?
6. Door voor elke applicatie of groep applicaties aparte vertakkingen te maken, kunt u wijzigingen isoleren en voorkomen dat deze van invloed zijn op niet-gerelateerde projecten.
7. Wat is Git sparse-checkout?
8. Hiermee kunt u slechts een subset van de bestanden in de repository uitchecken, waardoor u zich gemakkelijker op specifieke projecten kunt concentreren.
9. Kan ik het Git Changes-venster in Visual Studio aanpassen?
10. Ja, je kunt het aanpassen met behulp van een Visual Studio-extensie geschreven in C# die inhaakt in het Git Changes-venster en aangepaste filterlogica toepast.
11. Hoe haal ik de huidige filiaalnaam op in een repository?
12. U kunt de opdracht gebruiken om de huidige filiaalnaam op te halen.
13. Hoe vermeld ik de namen van bestanden die in de huidige vertakking zijn gewijzigd?
14. Gebruik de opdracht om de namen weer te geven van bestanden die in de huidige vertakking zijn gewijzigd.
15. Wat is het doel van de methode Package.Initialize() in Visual Studio?
16. De methode wordt gebruikt om een ​​Visual Studio-pakket te initialiseren en aangepaste logica toe te voegen, zoals het filteren van het Git Changes-venster.
17. Hoe kan ik een toolvenster weergeven in Visual Studio?
18. U kunt gebruik maken van de methode om een ​​toolvenster in Visual Studio weer te geven.

Het beheren van Git-wijzigingen in meerdere projecten in Visual Studio kan een uitdaging zijn, vooral na de overstap naar Azure DevOps. De besproken oplossingen, waaronder PowerShell-scripts en Visual Studio-extensies, bieden effectieve manieren om wijzigingen te filteren en zich op specifieke projecten te concentreren. Het implementeren van filiaalstrategieën, Git-submodules en sparse-checkout kan de workflow verder stroomlijnen en de productiviteit verbeteren. Deze methoden helpen de duidelijkheid en organisatie te behouden en zorgen ervoor dat ontwikkelaars zich zonder onnodige afleiding kunnen concentreren op de veranderingen die het belangrijkst zijn voor hun huidige werk.