Anteckning
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022 | Azure DevOps Server 2020
Visual Studio 2019 | Visual Studio 2022
När det finns flera deltagare i ett projekt bör du hålla din lokala Git-lagringsplats uppdaterad genom att ladda ned och integrera arbete som andra har laddat upp till projektets fjärrdatabas. Dessa Git-kommandon uppdaterar din lokala lagringsplats:
- Git fetch laddar ned alla nya incheckningar som andra har laddat upp till fjärrplatsen. Fjärrspårningsgrenarna i den lokala lagringsplatsens cache uppdateras – lokala grenar förblir oförändrade.
- Git merge integrerar kommandon från en eller flera källgrenar i en målgren.
- Git rebase konsoliderar ändringar från en källgren med en målgren, men använder en annan strategi än Git-sammanslagning.
- Git pull hämtar och utför sedan en sammanslagning eller ombasering för att integrera hämtade commits i din aktuella lokala gren.
Visual Studio använder en delmängd av dessa Git-kommandon när du synkroniserar din lokala lagringsplats med en fjärransluten lagringsplats.
En översikt över Git-arbetsflödet finns i Självstudie om Azure Repos Git.
Den här artikeln innehåller procedurer för följande uppgifter:
- Ladda ned ändringar med hämta
- Uppdatera grenar genom att sammanslå eller ombasera
- Hämta ändringar och uppdatera grenar med pull
Ladda ned ändringar med hämtning
Git fetch laddar ned fjärrgrenens commits och refererade filobjekt som inte finns i ditt lokala repository och uppdaterar fjärrspårningsgrenarna i cacheminnet för det lokala repositoryt. Fjärrspårningsgrenar är lokalt cachelagrade skrivskyddade kopior av fjärrgrenar och är inte dina lokala grenar. Git Fetch uppdaterar inte dina lokala grenar. Om till exempel ett fjärrrepo angivet av origin har en bugfix3-gren, så uppdaterar Git fetch fjärrspårningsgrenen vid namn origin/bugfix3 och inte din lokala bugfix3-gren. Du kan använda fjärrspårningsgrenar för att:
- Jämför en fjärrspårningsgren med en lokal gren för att granska hämtade ändringar.
- Slå samman en fjärrspårningsgren till en lokal gren.
- Skapa en ny lokal gren från en fjärrspårningsgren.
Visual Studio 2022 tillhandahåller en Git-versionskontroll med hjälp av Git-menyn , Git-ändringar och snabbmenyer i Solution Explorer. Visual Studio 2019 version 16.8 erbjuder även Användargränssnittet för Team Explorer Git. Mer information finns på fliken Visual Studio 2019 – Team Explorer .
I fönstret Git-ändringar väljer du Hämta. Välj sedan utgående/inkommande för att öppna Git-fönstret.
Du kan också välja Hämta på Git-menyn.
I fönstret Git-lagringsplats visas incheckningar som hämtats i avsnittet Inkommande. Välj ett hämtat commit för att se listan över ändrade filer i det. Välj en ändrad fil för att se en diff-vy över ändrat innehåll.
Tips/Råd
Fetch tar inte bort fjärrspårningsgrenar i din lokala cache för repot utan fjärrmotsvarighet. Konfigurera Visual Studio för att rensa inaktuella fjärrspårningsgrenar under en Hämtning:
- Välj Verktyg>Alternativ>Källkontroll>Globala inställningar för Git.
- Ange alternativet Rensa bort fjärrgrenar vid hämtning till
True.
Efter en Git-hämtning kan du jämföra en lokal gren med motsvarande fjärrspårningsgren för att se vad som har ändrats på fjärrgrenen. Om du bestämmer dig för att uppdatera din aktuella lokala gren med hämtade ändringar kan du utföra en Git-sammanslagning eller en ombasering. Eller så kan du köra Git Pull, som kombinerar en Git-hämtning med en Git-koppling eller en ombasering. Både Git-sammanslagning och Git-ombasering uppdaterar en målgren genom att tillämpa ändringar från en källgren. Git-sammanslagning och Git-ombasering använder dock olika strategier. Mer information finns i Uppdatera grenar med sammanslagning eller ombasering och När du ska ombaseras jämfört med sammanslagning.
Uppdatera grenar med sammanslagning eller ombasering
Git merge och Git rebase integrerar ändringar från en källgren till din nuvarande lokala gren (målgren). Git merge utför antingen en snabbspolning eller en utan snabbspolning koppling. Den snabbsnabba sammanfogningen kallas även för en trevägssammanslagning eller sann sammanslagning. Git rebase är en annan typ av sammanslagning. Dessa sammanslagningstyper visas i följande diagram.
Git-sammanslagning och Git-ombasering används i stor utsträckning i Git-arbetsflödet. När du arbetar med en lokal funktion eller en bugfix-gren är det vanligt att:
- Håll din lokala
maingren aktuell med fjärrmotsvarigheten genom att regelbundet hämta och sammanfoga fjärrincheckningar. - Integrera lokala
maingrenuppdateringar i din lokala funktionsgren med hjälp av en ombasering eller sammanslagning. - Säkerhetskopiera ditt arbete på den lokala funktionsgrenen genom att skicka det till motsvarande fjärrgren.
- När funktionen är klar, skapar du en pull request för att sammanfoga din funktionsgren med den fjärranslutna
maingrenen.
Den här metoden hjälper dig att:
- Håll dig medveten om andras senaste arbete som kan påverka ditt arbete.
- Lös omedelbart eventuella konflikter mellan ditt och andras arbete.
- Använd din nya funktion på up-to-date-projektets innehåll.
- Få en pull-begäran om granskning av ditt arbete.
Slå ihop
Om spetsen på målgrenen finns i källgrenen för Git-sammanslagning är standardsammanfogningstypen en snabbkoppling. Annars är standard-sammanfogningstypen en icke-snabbsammanfogning.
En snabbspolande Git-sammanslagning kan aldrig ha en sammanslagningskonflikt eftersom Git inte tillämpar en snabbspolande sammanslagning om spetsen på målgrenen har avvikit från källgrenen. Som standard använder Git en snabbkoppling när det är möjligt. Git tillämpar till exempel en snabbkoppling på en lokal gren som du bara uppdaterar genom att hämta från sin fjärrmotsvarighet.
En Git-sammanslagning utan snabb vidarebefordran genererar en ny "sammanfogningsåtagande" i målgrenen som integrerar ändringar i källgrenen med ändringar i målgrenen. De tillämpliga ändringarna är de som har gjorts efter den senaste commit som är gemensam för båda grenarna. I föregående diagram är commit C den sista gemensamma commit i båda grenarna. Om någon ändring av källgrenen står i konflikt med någon ändring av målgrenen uppmanar Git dig att lösa sammanslagningskonflikten. Sammanfognings-commit (L) innehåller ändringarna från den integrerade källgrenen och målgrenen. Ändarna för käll- och målgrenen (K och E) är föräldrar till sammanslagningskommittén. I grenens commit-historik är en sammanfognings-commit en användbar markör för en sammanfogning och visar tydligt vilka grenar som sammanfogades.
Git-sammanslagning ändrar endast målgrenen – källgrenen förblir oförändrad. När du stöter på en eller flera sammanslagningskonflikter måste du lösa dem för att slutföra sammanfogningen. Eller så kan du avbryta sammanslagningsåtgärden och returnera målgrenen till dess tidigare tillstånd.
Mer information om sammanslagningsalternativ och strategier finns i Git-referenshandboken och Git-sammanslagningsstrategier.
Tips/Råd
Om källgrenen är en fjärrspårningsgren kontrollerar du att grenen är up-to-date genom att köra en Git-hämtning före sammanfogningen.
Välj Git > Hantera grenar i menyraden för att öppna fönstret Git-lagringsplats .
I fönstret Git-lagringsplats högerklickar du på målgrenen och väljer Checkout.
Högerklicka på källgrenen och välj Sammanfoga <källgren> till <målgren>.
Visual Studio visar ett bekräftelsemeddelande efter en lyckad sammanslagning.
Om sammanfogningen stoppas på grund av sammanslagningskonflikter meddelar Visual Studio dig. Du kan antingen lösa konflikterna eller avbryta sammanfogningen och återgå till försammanfogningstillståndet.
Rebase
Git återställer incheckningshistoriken för målgrenen så att den innehåller alla källgrens incheckningar, följt av alla incheckningar av målgrenar sedan den senaste gemensamma incheckningen. Ett annat sätt att visa det är att en Git-ombas spelar upp ändringarna i målgrenen ovanpå källgrenens historik. Om någon ändring av källgrenen står i konflikt med någon ändring av målgrenen uppmanar Git dig att lösa sammanslagningskonflikten. Git rebase skapar inte någon merge commit. Noterbart ändrar Git rebase sekvensen av befintliga ändringar i målgrenen, vilket inte är fallet för de andra sammanslagningsstrategierna. I föregående diagram innehåller commit K samma ändringar som K, men har ett nytt inchecknings-ID eftersom det länkar tillbaka till incheckningen E i stället för C.
Git ändrar endast målgrenen – källgrenen förblir oförändrad. När du stöter på en eller flera sammanslagningskonflikter måste du lösa dem för att slutföra rebasen. Eller så kan du avbryta ombaseringen och returnera målgrenen till dess tidigare tillstånd.
Om du är den enda personen som arbetar med din funktion eller bugfix-gren kan du överväga att använda Git rebase för att integrera nya main incheckningar till grenen. Annars använder du Git-sammanslagning. Mer information om Git-ombasering och när du ska använda det finns i Använd ändringar med ombasering och Ombasera kontra slå samman.
Tips/Råd
Om källgrenen är en fjärrspårningsgren kontrollerar du att grenen är up-to-date genom att köra en Git-hämtning före ombasen.
Välj Git > Hantera grenar för att öppna Git-förrådsfönstret.
I fönstret Git-lagringsplats högerklickar du på målgrenen och väljer Checkout.
Högerklicka på källgrenen och välj Rebase <target-branch> på <source-branch>.
Visual Studio visar ett bekräftelsemeddelande efter en lyckad ombasering.
Om rebase-processen stoppas på grund av konflikter vid sammanslagning meddelar Visual Studio dig. Du kan antingen lösa konflikterna, eller avbryta rebasen och återgå till tillståndet före rebasen.
Ladda ned ändringar och uppdatera grenar med pull
Som standard kombinerar Git Pull en Git-hämtning och en Git-sammanslagning för att uppdatera din aktuella lokala gren från dess fjärrmotsvarighet. Om du vill kan Git Pull utföra en Git-rebase i stället för en Git-sammanslagning.
Till skillnad från Git fetch uppdaterar Git pull din aktuella lokala gren omedelbart efter nedladdning av nya commits från det fjärranslutna repositoriet. Använd Git Pull när du vet att du vill uppdatera din aktuella lokala gren direkt efter en Git-hämtning.
Tips/Råd
Så här konfigurerar du Visual Studio för att ombaseras i stället för sammanslagning när du hämtar:
- Från Git-menyn går du till Verktygsalternativ>>Källkontroll>, Globala Inställningar för Git.
- Ställ in alternativet Rebase lokal gren vid dragning till
True.
I fönstret Git-ändringar väljer du Dra.
Du kan också välja Hämta från Git-menyn.
Ett bekräftelsemeddelande visas när pull-åtgärden är klar.
Om det uppstår konflikter under sammanslagningsdelen av pull-åtgärden meddelar Visual Studio dig. Du kan antingen lösa konflikterna eller avbryta sammanfogningen och återgå till försammanfogningstillståndet.
Anmärkning
I Visual Studio utför Sync en Pull-överföring och sedan en push-överföring för att synkronisera en lokal gren och en fjärrgren. Mer information om Synkronisering finns i Använda git fetch, pull, push och sync för versionskontroll i Visual Studio.
