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 git -C $repoPath rev-parse --abbrev-ref HEAD. Vervolgens worden de namen weergegeven van bestanden die in de huidige vertakking zijn gewijzigd met behulp van git -C $repoPath diff --name-only $branch. Het script filtert vervolgens deze gewijzigde bestanden zodat alleen de bestanden binnen het opgegeven oplossingspad worden opgenomen met behulp van Where-Object, 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 IVsWindowFrame klasse, die een raamkozijn in Visual Studio vertegenwoordigt. De belangrijkste logica van de extensie is ingekapseld in de Package.Initialize() 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.
Git-wijzigingen filteren op oplossing in Visual Studio
PowerShell-script gebruiken
# 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
Git-wijzigingen aanpassen in Visual Studio
Visual Studio-extensie gebruiken (C#)
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.
Veelgestelde vragen en oplossingen voor het beheren van Git-wijzigingen in Visual Studio
- Hoe kan ik wijzigingen aan een specifiek project in een opslagplaats met meerdere projecten filteren?
- U kunt gebruik maken van de Where-Object opdracht in PowerShell om de gewijzigde bestanden te filteren, zodat ze alleen de bestanden binnen het opgegeven oplossingspad bevatten.
- Wat zijn Git-submodules en hoe helpen ze?
- Git submodules kunt u andere repository's in een repository opnemen, waardoor u betere controle krijgt over afhankelijkheden en projectscheiding.
- Hoe helpen branchestrategieën bij het managen van veranderingen?
- 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.
- Wat is Git sparse-checkout?
- Git sparse-checkout Hiermee kunt u slechts een subset van de bestanden in de repository uitchecken, waardoor u zich gemakkelijker op specifieke projecten kunt concentreren.
- Kan ik het Git Changes-venster in Visual Studio aanpassen?
- 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.
- Hoe haal ik de huidige filiaalnaam op in een repository?
- U kunt de opdracht gebruiken git -C $repoPath rev-parse --abbrev-ref HEAD om de huidige filiaalnaam op te halen.
- Hoe vermeld ik de namen van bestanden die in de huidige vertakking zijn gewijzigd?
- Gebruik de opdracht git -C $repoPath diff --name-only $branch om de namen weer te geven van bestanden die in de huidige vertakking zijn gewijzigd.
- Wat is het doel van de methode Package.Initialize() in Visual Studio?
- De Package.Initialize() methode wordt gebruikt om een Visual Studio-pakket te initialiseren en aangepaste logica toe te voegen, zoals het filteren van het Git Changes-venster.
- Hoe kan ik een toolvenster weergeven in Visual Studio?
- U kunt gebruik maken van de IVsWindowFrame.Show() methode om een toolvenster in Visual Studio weer te geven.
Laatste gedachten over het beheren van Git-wijzigingen
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.