Aggiornare il codice con recupero, unione e pull

Azure DevOps Services | Azure DevOps Server 2022 - Azure DevOps Server 2019

Visual Studio 2019 | Visual Studio 2022

Quando sono presenti diversi collaboratori a un progetto, mantenere aggiornato il repository Git locale scaricando e integrando il lavoro caricato da altri nel repository remoto del progetto. Questi comandi Git aggiornano il repository locale:

  • Il recupero git scarica tutti i nuovi commit caricati da altri utenti nel repository remoto. I rami di rilevamento remoto nella cache dei repository locali vengono aggiornati. I rami locali rimangono invariati.
  • L'unione Git integra i commit da uno o più rami di origine in un ramo di destinazione.
  • Git rebase integra i commit da un ramo di origine in un ramo di destinazione, ma usa una strategia diversa rispetto all'unione Git.
  • Git pull esegue un recupero e quindi un merge o una rebase per integrare i commit recuperati nel ramo locale corrente.

Visual Studio usa un subset di questi comandi Git quando si sincronizza il repository locale con un repository remoto.

Per una panoramica del flusso di lavoro Git, vedere Esercitazione su Git di Azure Repos.

Questo articolo illustra le procedure per le attività seguenti:

  • Scaricare le modifiche con recupero
  • Aggiornare i rami con merge o rebase
  • Scaricare le modifiche e aggiornare i rami con pull

Scaricare le modifiche con recupero

Il recupero git scarica i commit dei rami remoti e gli oggetti file a cui si fa riferimento che non esistono nel repository locale e aggiorna i rami di rilevamento remoto nella cache del repository locale. I rami di rilevamento remoto sono copie di sola lettura memorizzate nella cache locale di rami remoti e non sono rami locali. Il recupero Git non aggiorna i rami locali. Ad esempio, se un repository remoto designato da ha un bugfix3 ramo, il recupero Git aggiornerà il ramo di rilevamento remoto denominato origin/bugfix3 e non il ramo localebugfix3.origin È possibile usare rami di rilevamento remoto per:

  • Confrontare un ramo di rilevamento remoto con un ramo locale per esaminare le modifiche recuperate.
  • Unire un ramo di rilevamento remoto in un ramo locale.
  • Creare un nuovo ramo locale da un ramo di rilevamento remoto.

Visual Studio 2022 offre un'esperienza di controllo della versione Git usando il menu Git, Le modifiche Git e tramite i menu di scelta rapida in Esplora soluzioni. Visual Studio 2019 versione 16.8 offre anche l'interfaccia utente Git di Team Explorer . Per altre informazioni, vedere la scheda Visual Studio 2019 - Team Explorer .

  1. Nella finestra Modifiche Git scegliere Recupera. Selezionare quindi in uscita/in ingresso per aprire la finestra Repository Git.

    Screenshot dei pulsanti fetch e del collegamento In ingresso nella finestra Modifiche Git di Visual Studio 2019.

    È anche possibile scegliere Recupera dal menu Git.

    Screenshot dell'opzione Recupera nel menu Git in Visual Studio 2019.

  2. Nella finestra Repository Git i commit recuperati vengono visualizzati nella sezione In ingresso. Selezionare un commit recuperato per visualizzare l'elenco dei file modificati in tale commit. Selezionare un file modificato per visualizzare una visualizzazione delle differenze del contenuto modificato.

    Screenshot del menu Repository Git in Visual Studio 2019.

Suggerimento

Il recupero non eliminerà i rami di rilevamento remoto nella cache del repository locale che non hanno più una controparte remota. Per configurare Visual Studio per eliminare rami di rilevamento remoto non aggiornati durante un recupero:

  • Selezionare Strumenti>Opzioni>controllo del codice>sorgente Git Global Impostazioni.
  • Impostare l'opzione Elimina rami remoti durante il recupero su True.

Dopo un recupero Git, è possibile confrontare un ramo locale con il ramo di rilevamento remoto corrispondente per verificare le modifiche apportate al ramo remoto. Se si decide di aggiornare il ramo locale corrente con le modifiche recuperate, è possibile eseguire un'operazione di merge o rebase Git. In alternativa, è possibile eseguire il pull git, che combina un recupero Git con un'operazione di merge o rebase Git. Sia git merge che git rebase aggiornano un ramo di destinazione applicando i commit da un ramo di origine al ramo. Tuttavia, git merge e git rebase usano strategie diverse. Per altre informazioni, vedere Aggiornare i rami con merge o rebase e Quando eseguire la ribase rispetto all'unione.

Aggiornare i rami con merge o rebase

Git merge e Git rebase integrano i commit da un ramo di origine nel ramo locale corrente (ramo di destinazione). L'unione Git esegue un'operazione di merge fast forward o no-fast-forward. L'unione senza inoltro rapido è nota anche come unione a tre vie o vera unione. La rebase Git è un altro tipo di merge. Questi tipi di unione sono illustrati nel diagramma seguente.

Diagramma che mostra i commit prima e dopo quando si usano il merge e la ribase.

L'unione git e la rebase Git vengono ampiamente usate nel flusso di lavoro Git. Quando si lavora su una funzionalità locale o un ramo di correzione di bug, è pratica comune:

  1. Mantenere aggiornato il ramo locale main con la controparte remota eseguendo periodicamente il pull per recuperare e unire i commit remoti.
  2. Integrare gli aggiornamenti del ramo locale main nel ramo di funzionalità locale usando una ribase o unisci.
  3. Eseguire il backup del lavoro nel ramo di funzionalità locale eseguendo il push nel ramo remoto corrispondente.
  4. Al termine della funzionalità, creare una richiesta pull per unire il ramo di funzionalità remoto nel ramo remoto main .

Questo approccio consente di:

  • Tieniti a conoscenza del lavoro recente da parte di altri utenti che potrebbero influire sul tuo lavoro.
  • Risolvere tempestivamente eventuali conflitti tra il lavoro e quello degli altri.
  • Applicare la nuova funzionalità al contenuto del progetto aggiornato.
  • Ottenere una revisione della richiesta pull del lavoro.

Unire

Per l'unione Git, se il suggerimento del ramo di destinazione esiste all'interno del ramo di origine, il tipo di unione predefinito sarà un merge con inoltro rapido. In caso contrario, il tipo di unione predefinito sarà un'unione senza inoltro rapido.

Un'unione Git con inoltro rapido non può mai avere un conflitto di merge perché Git non applicherà un merge rapido se la punta del ramo di destinazione si è discosta dal ramo di origine. Per impostazione predefinita, Git usa un'unione rapida ogni volta che possibile. Ad esempio, Git applicherà un merge fast forward in un ramo locale che viene aggiornato solo eseguendo il pull dal ramo controparte remota.

Un'unione Git no-fast-forward genera un nuovo "commit di merge" del ramo di destinazione che integra le modifiche del ramo di origine con le modifiche del ramo di destinazione. Le modifiche applicabili sono quelle apportate dopo l'ultimo commit comune a entrambi i rami. Nel diagramma precedente il commit C è l'ultimo commit comune in entrambi i rami. Se una modifica del ramo di origine è in conflitto con qualsiasi modifica del ramo di destinazione, Git chiederà di risolvere il conflitto di merge. Il commit di merge (L) contiene le modifiche del ramo di origine integrato e del ramo di destinazione. I suggerimenti per il ramo di origine e di destinazione (K e E) sono gli elementi padre del commit di merge. Nella cronologia dei commit del ramo, un commit di merge è un indicatore utile per un'operazione di merge e mostra chiaramente quali rami sono stati uniti.

L'unione Git modifica solo il ramo di destinazione. Il ramo di origine rimane invariato. Quando si verificano uno o più conflitti di unione, è necessario risolverli per completare l'unione. In alternativa, è possibile annullare l'operazione di merge e restituire il ramo di destinazione allo stato precedente.

Per altre informazioni sulle opzioni e sulle strategie di merge, vedere le strategie di riferimento git manuali e Git merge.

Suggerimento

Se il ramo di origine è un ramo di rilevamento remoto, assicurarsi che il ramo sia aggiornato eseguendo un recupero Git prima dell'unione.

  1. Scegliere Git Manage Branch (Gestisci rami Git>) dalla barra dei menu per aprire la finestra Repository Git.

    Screenshot dell'opzione Gestisci rami nel menu Git di Visual Studio 2019.

  2. Nella finestra Repository Git fare clic con il pulsante destro del mouse sul ramo di destinazione e scegliere Checkout (Checkout).

    Screenshot dell'opzione Checkout nella finestra Repository Git di Visual Studio 2019.

  3. Fare clic con il pulsante destro del mouse sul ramo di origine e selezionare Merge source-branch into target-branch (Merge <source-branch into target-branch).<>>

    Screenshot dell'opzione Merge nella finestra Repository Git di Visual Studio 2019.

  4. Visual Studio visualizzerà un messaggio di conferma dopo un'unione completata.

    Screenshot del messaggio di conferma unione nella finestra Repository Git di Visual Studio 2019.

    Se l'unione viene interrotta a causa di conflitti di merge, Visual Studio invierà una notifica. È possibile risolvere i conflitti oppure annullare l'unione e tornare allo stato di pre-unione.

    Screenshot del messaggio di conflitto di merge nella finestra Repository Git di Visual Studio 2019.

Ribase

Git esegue nuovamente la ribase della cronologia dei commit del ramo di destinazione in modo che contenga tutti i commit del ramo di origine, seguiti da tutti i commit del ramo di destinazione dall'ultimo commit comune. Un altro modo per visualizzare è che una riesecuzione della base Git riproduce le modifiche nel ramo di destinazione sopra la cronologia dei rami di origine. Se una modifica del ramo di origine è in conflitto con qualsiasi modifica del ramo di destinazione, Git chiederà di risolvere il conflitto di merge. La rebase Git non crea un commit di merge. In particolare, git rebase modifica la sequenza dei commit del ramo di destinazione esistente, che non è il caso per le altre strategie di merge. Nel diagramma precedente, commit K' contiene le stesse modifiche di K, ma ha un nuovo ID commit perché si collega di nuovo al commit E invece di C.

Git rebase modifica solo il ramo di destinazione. Il ramo di origine rimane invariato. Quando si verificano uno o più conflitti di unione, è necessario risolverli per completare la rebase. In alternativa, è possibile annullare l'operazione di ribase e restituire il ramo di destinazione allo stato precedente.

Se si è l'unica persona che lavora sulla funzionalità o sul ramo di correzione di bug, è consigliabile usare git rebase per integrare nuovi main commit del ramo. In caso contrario, usare l'unione Git. Per altre informazioni su Git rebase e su quando usarlo, vedere Applicare modifiche con rebase e Rebase vs merge.

Suggerimento

Se il ramo di origine è un ramo di rilevamento remoto, assicurarsi che il ramo sia aggiornato eseguendo un recupero Git prima della rebase.

  1. Scegliere Git Manage Branch (Gestisci rami Git>) per aprire la finestra Repository Git.

    Screenshot dell'opzione Gestisci rami nel menu Git di Visual Studio 2019.

  2. Nella finestra Repository Git fare clic con il pulsante destro del mouse sul ramo di destinazione e scegliere Checkout (Checkout).

    Screenshot dell'opzione Checkout nel menu di scelta rapida del ramo nella finestra Repository Git di Visual Studio 2019.

  3. Fare clic con il pulsante destro del mouse sul ramo di origine e selezionare Rebase target-branch in <source-branch>>.<

    Screenshot dell'opzione Rebase nel menu di scelta rapida del ramo nella finestra Repository Git di Visual Studio 2019.

  4. Visual Studio visualizzerà un messaggio di conferma dopo una ribase riuscita.

    Screenshot del messaggio di conferma della ribase nella finestra Repository Git di Visual Studio 2019.

    Se la rebase viene interrotta a causa di conflitti di merge, Visual Studio invierà una notifica. È possibile risolvere i conflitti oppure annullare la ribase e tornare allo stato di pre-ribase.

    Screenshot del messaggio di conflitto di ribase nella finestra Repository Git di Visual Studio 2019.

Scaricare le modifiche e aggiornare i rami con pull

Per impostazione predefinita, Git pull combina un recupero Git e un'unione Git per aggiornare il ramo locale corrente dalla controparte remota. Facoltativamente, git pull può eseguire una rebase Git anziché un'unione Git.

A differenza del recupero Git, git pull aggiornerà il ramo locale corrente immediatamente dopo il download di nuovi commit dal repository remoto. Usare git pull quando si sa di voler aggiornare il ramo locale corrente subito dopo un recupero Git.

Suggerimento

Per configurare Visual Studio per eseguire nuovamente la ribase anziché eseguire il merge quando si esegue il pull:

  1. Dal menu Git passare a Strumenti>Opzioni>controllo del codice>sorgente Git Global Impostazioni.
  2. Impostare il ramo locale di Rebase quando si esegue il pull suTrue.
  1. Nella finestra Modifiche Git scegliere Pull.

    Screenshot del pulsante Pull nella finestra Modifiche Git di Visual Studio 2019.

    È anche possibile scegliere Pull dal menu Git.

    Screenshot dell'opzione Pull nel menu Git in Visual Studio 2019.

  2. Al termine dell'operazione pull viene visualizzato un messaggio di conferma.

    Screenshot del messaggio di conferma pull nella finestra Modifiche Git in Visual Studio 2019.

    In caso di conflitti durante la parte di merge dell'operazione pull, Visual Studio invierà una notifica. È possibile risolvere i conflitti oppure annullare l'unione e tornare allo stato di pre-unione.

    Screenshot del messaggio di conflitto pull nella finestra Modifiche Git in Visual Studio 2019.

Nota

In Visual Studio la sincronizzazione esegue un pull e quindi un push per sincronizzare un ramo locale e remoto. Per altre informazioni sulla sincronizzazione, vedere Usare git fetch, pull, push e sincronizzazione per il controllo della versione in Visual Studio.

Passaggi successivi