Estensione del controllo della versione

Visual Studio Team Foundation Server 2010 rappresenta una modifica nell'architettura Team Foundation Server.Prima di leggere il codice di esempio in questo argomento, è necessario comprendere l'architettura Team Foundation Server almeno su un livello elevato e le seguenti informazioni devono capire meglio lo scopo di progetti team e raccolte di progetti team in una raccolta di progetti.Questa modifica organizzativa consente di eseguire operazioni di controllo della versione sugli elementi correlati nel contesto di una raccolta di progetti team.

La struttura organizzativa primaria in Team Foundation Server 2010 è la raccolta di progetti team.La raccolta di progetti team è un raggruppamento di progetti team in una struttura organizzativa che è possibile utilizzare per definire e gestire un gruppo di progetti che condividono risorse o una codebase.Il vantaggio di questo tipo di struttura organizzativa che è la gestione dei progetti team diventa più efficiente quando vengono raggruppate e assegnare le risorse.Le operazioni come creare un ramo o l'unione del codice, il backup e il ripristino dei dati e segnalazione delle informazioni di progetto sono più facili perché sono specifiche di un database.Per ulteriori informazioni sulle raccolte di progetti team in Team Foundation Server 2010, vedere Organizing Your Server with Team Project Collections.

In questo argomento

• Example: Accessing Items in the Version-Control Repository

• Example: Updating Items in a Workspace

• Example: Adding Items to the Version-Control Repository

• Example: Editing Items

• Example: Creating Branches

• Example: Deleting Folders

[!NOTA]

È possibile estendere Controllo della versione di Team Foundation accesso e aggiornando gli elementi nel repository del controllo della versione e un'area di lavoro sul computer locale per creare criteri di archiviazione personalizzati e per applicarle a un progetto team.Sfruttando l'ereditarietà, sostituire la funzionalità esistente con la propriaimplementazione di criteri che si applica al controllo della versione.Per ulteriori informazioni, vedere la seguente pagina nel sito Web Microsoft: Procedura: Creare criteri di archiviazione personalizzati.

Esempio: Accedere agli elementi nel repository del controllo della versione

Nell'esempio seguente viene utilizzato l'oggetto VersionControlServer per elencare ogni versione di ogni file con estensione xaml nel repository del controllo della versione.

Per utilizzare questo esempio

1. Creare un'applicazione console e aggiungere riferimenti agli assembly seguenti:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.VersionControl.Client

2. Sostituire il contenuto Program.cs o Module1.vb) con questo esempio.

using System; 
using System.Text; 
using Microsoft.TeamFoundation.Client; 
using Microsoft.TeamFoundation.Framework; 
using Microsoft.TeamFoundation.VersionControl.Client; 

namespace VCSample
{
    class Program
    {
        static void Main(string[] args) 
        {
            // Connect to the team project collection and the server that hosts the version-control repository. 
            TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(
               new Uri("https://Server:8080/tfs/DefaultCollection"));
            VersionControlServer vcServer = tpc.GetService<VersionControlServer>(); 

            // List all of the .xaml files.
            ItemSet items = vcServer.GetItems("$/*.xaml", RecursionType.Full); 
            foreach(Item item in items.Items) 
            {
                Console.Write(item.ItemType.ToString());
                Console.Write(": ");
                Console.WriteLine(item.ServerItem.ToString());
            }
        }
    }
}

Imports System
Imports System.Text
Imports Microsoft.TeamFoundation.Client
Imports Microsoft.TeamFoundation.VersionControl.Client

Module Module1

    Sub Main()
        ' Connect to the team project collection and the server that hosts the version-control repository.
        Dim tfsUri As Uri
        tfsUri = New Uri("https://Server:8080/tfs/DefaultCollection")

        Dim tpc As New TfsTeamProjectCollection(tfsUri)

        Dim vcServer As VersionControlServer
        vcServer = tpc.GetService(Of VersionControlServer)()

        ' List all of the .xaml files.
        Dim items As ItemSet
        items = vcServer.GetItems("$/*.xaml", RecursionType.Full)
        Dim item As Item
        For Each item In items.Items
            System.Console.Write(item.ItemType.ToString())
            System.Console.Write(": ")
            System.Console.WriteLine(item.ServerItem.ToString())
        Next
    End Sub

End Module

Esempio: Elementi di aggiornamento in un'area di lavoro

È possibile utilizzare i file in un'area di lavoro eseguendo le operazioni ottenuto, estrarre e archiviare a livello di codice.L'esempio seguente consente di ottenere la versione più recente dei file in un'area di lavoro.

Per utilizzare questo esempio

1. Nell'esempio precedente, individuare la sezione di codice che elenca i file con estensione xaml e sostituirlo con il codice seguente.

2. WorkspaceName di sostituzione con il nome dell'area di lavoro, che in genere è la stessa del nome del computer che contiene l'area di lavoro.

3. nome utente di sostituzione con il nome completo dell'utente proprietario dell'area di lavoro.

Per ulteriori informazioni, vedere Workstation.GetLocalWorkspaceInfo e Gestire le aree di lavoro.

// Get the workspace that is mapped to c:\BuildProcessTemplate
WorkspaceInfo wsInfo = Workstation.Current.GetLocalWorkspaceInfo(
   vcServer, @"WorkspaceName", @"UserName");
Workspace ws = vcServer.GetWorkspace(wsInfo); 

// Update the workspace with most recent version of the files from the repository.
GetStatus status = ws.Get();
Console.Write("Conflicts: ");
Console.WriteLine(status.NumConflicts);

' Get the workspace that is mapped to c:\BuildProcessTemplate
Dim wsInfo As WorkspaceInfo
wsInfo = Workstation.Current.GetLocalWorkspaceInfo(vcServer, "WorkspaceName", "UserName")
Dim ws As Workspace
ws = vcServer.GetWorkspace(wsInfo)

' Update the workspace with the most recent version of the files from the repository.
Dim status As GetStatus
status = ws.Get
Console.Write("Conflicts: ")
Console.WriteLine(status.NumConflicts)

È inoltre possibile ottenere un'area di lavoro mappata a una cartella sul computer locale specificando il percorso completo della cartella in Workstation.GetLocalWorkspaceInfo.

WorkspaceInfo wsInfo = Workstation.Current.GetLocalWorkspaceInfo(@"c:\MyWorkspace");

Dim wsInfo As WorkspaceInfo
wsInfo = Workstation.Current.GetLocalWorkspaceInfo("c:\MyWorkspace")

Esempio: Aggiunta di elementi al repository del controllo della versione

È possibile creare un file e posizionarlo sotto il controllo della versione tramite aggiungere e archiviati i metodi.

Attenzione
Il codice genera un'eccezione se non si dispone di autorizzazioni dell'area di lavoro per leggere e archiviare i file.Queste autorizzazioni sono le autorizzazioni di controllo del codice sorgente per Lettura e controllo in Esplora controllo codice sorgente.

In questo esempio, si effettuano chiamate ai metodi seguenti:

• Innanzitutto, identificare le raccolte di progetti in Team Foundation Server chiamando [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollection()] o [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollections()].

• Dopo aver identificato le raccolte di progetti, quindi identificare ogni raccolta di progetti team chiamando [M:Microsoft.TeamFoundation.Client.TfsConfigurationServer.GetTeamProjectCollection()].

• All'interno della raccolta di progetti team, identificare i singoli progetti team chiamando [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetAllTeamProjects()].

• Per ogni progetto team, si ottiene l'area di lavoro collegato chiamando [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetWorkspace()] o [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.CreateWorkspace()]e si esegue il mapping dell'area di lavoro all'unità locale chiamando [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.CreateMapping()].

• Per copiare i file su un'unità locale, chiamare [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.Get()] per l'area di lavoro.

È quindi possibile aggiungere un file al controllo della versione se si dispone delle autorizzazioni appropriate.

Per utilizzare questo esempio

1. Creare un'applicazione console C# e quindi aggiungere riferimenti agli assembly seguenti:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.Common

   • Microsoft.TeamFoundation.VersionControl.Client

2. Sostituire il contenuto Program.cs con il codice di esempio.

3. Modificare il valore URI al nome del server a livello applicazione nell'ambiente.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.VersionControl.Client;

namespace VControl
{
    class Program
    {
        static void Main(string[] args)
        {
            List<RegisteredProjectCollection> projectCollections;

            if (args.Count() == 0)
            {
                // Try the default URI as the name of a registered project collection.
                projectCollections = new List<RegisteredProjectCollection> { RegisteredTfsConnections.GetProjectCollection(new Uri("https://Server:8080/tfs/DefaultCollection")) };   
            }
            else
            {
                // Get all registered project collections
                projectCollections = new List<RegisteredProjectCollection>(RegisteredTfsConnections.GetProjectCollections());
            }
            
            foreach (var registeredProjectCollection in projectCollections)
            {
                TfsTeamProjectCollection projectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(registeredProjectCollection);
                
                Workspace workspace = null;
                Boolean createdWorkspace = false;
                String newFolder = String.Empty;
                try
                {
                    VersionControlServer versionControl = projectCollection.GetService<VersionControlServer>();
                    
                    var teamProjects = new List<TeamProject>(versionControl.GetAllTeamProjects(false));
                    
                    if (teamProjects.Count < 1)
                        continue;
                    String workspaceName = String.Format("{0}-{1}", Environment.MachineName, "Test");
                    try
                    {
                        workspace = versionControl.GetWorkspace(workspaceName, versionControl.AuthorizedUser);
                    }
                    catch (WorkspaceNotFoundException)
                    {
                        workspace = versionControl.CreateWorkspace(workspaceName, versionControl.AuthorizedUser);
                        createdWorkspace = true;
                    }
                    var serverFolder = String.Format("$/{0}", teamProjects[0].Name);
                    var localFolder = Path.Combine(Path.GetTempPath(), "Test");
                    var workingFolder = new WorkingFolder(serverFolder, localFolder);

                    // Create a workspace mapping.
                    workspace.CreateMapping(workingFolder);

                    if (!workspace.HasReadPermission)
                    {
                        throw new SecurityException(
                            String.Format("{0} does not have read permission for {1}", versionControl.AuthorizedUser, serverFolder));
                    }
                    
                    // Get the files from the repository.
                    workspace.Get();

                    // Create a file
                    newFolder = Path.Combine(workspace.Folders[0].LocalItem, "For Test Purposes");
                    Directory.CreateDirectory(newFolder);
                    String newFilename = Path.Combine(newFolder, "Safe To Delete.txt");

                    // Determine whether the user has check-in permissions.
                    if (!workspace.HasCheckInPermission)
                    {
                        throw new SecurityException(
                            String.Format("{0} does not have check-in permission for workspace {1}", workspace.VersionControlServer.AuthorizedUser,
                            workspace.DisplayName));
                    }

                    try
                    {
                        // Create the file.
                        using (var streamWriter = new StreamWriter(newFilename))
                        {
                            streamWriter.WriteLine("Revision 1");
                        }

                        workspace.PendAdd(Path.GetDirectoryName(newFilename), true);

                        //  Create a list of pending changes.
                        var pendingAdds = new List<PendingChange>(workspace.GetPendingChanges());
                        
                        //  Enumerate the pending changes
                        pendingAdds.ForEach(add => Console.WriteLine("\t{0}: {1}", add.LocalItem,
                            PendingChange.GetLocalizedStringForChangeType(add.ChangeType)));
                        
                        // Check in the items that you added.
                        int changesetForAdd = workspace.CheckIn(pendingAdds.ToArray(), "Initial revision");
                        Console.WriteLine("Checked in changeset {0}", changesetForAdd);
                    }
                    catch (IOException ex)
                    {
                        Console.Error.WriteLine("Error writing {1}: {0}", ex.Message, newFilename);
                        throw;
                    }
                    catch (VersionControlException ex)
                    {
                        Console.Error.WriteLine("Error adding file: {0}", ex.Message);
                        throw;
                    }
                }
                finally 
                {
                    if ((workspace != null) && createdWorkspace)
                    {
                        workspace.Delete();
                    }
                    if (!String.IsNullOrEmpty(newFolder) && Directory.Exists(newFolder))
                    {
                        Directory.Delete(newFolder);
                    }
                }
                break;
            }
            
        }
    }
}

Esempio: elementi di modifica

È possibile modificare un file esistente nel controllo della versione tramite il codice seguente, che chiama i metodi CheckIn e PendEdit.In questo esempio viene illustrato come utilizzare il modello a oggetti per modificare e archiviare un file esistente.È possibile modificare l'esempio di codice per creare un file e quindi si sostituirà alcune righe di codice in tale esempio con il codice di questo esempio.Inoltre, in questo esempio vengono illustrate le specifiche dell'elemento, che consente di aggiungere una proprietà personalizzata a un file.

Per utilizzare questo esempio

• Aprire l'applicazione console C# creato nell'esempio Add a File to Version Control quindi sostituire il blocco interno prova con il codice seguente:

try
{
    // Check out and modify a file.
    workspace.PendEdit(newFilename);

    using (var streamWriter = new StreamWriter(newFilename))
    {
        streamWriter.WriteLine("Revision 2");
    }

    // Get the pending change, and check in the new revision.
    var pendingChanges = workspace.GetPendingChanges();
    int changesetForChange = workspace.CheckIn(pendingChanges, "Modified file contents");
    Console.WriteLine("Checked in changeset {0}", changesetForChange);
}

È possibile aggiungere una proprietà al file creato in questo esempio.Chiamando il metodo SetVersionedItemProperty, è possibile impostare una proprietà di propria scelta nel file.Nell'esempio, viene utilizzato il parametro itemSpec per specificare un percorso in cui file e cartelle.In questo caso, specificare il percorso locale, sebbene sia anche possibile utilizzare questo parametro per specificare un percorso nel repository.Anche verrà definita una proprietà e un valore per.

Attenzione
È necessario prestare attenzione quando si utilizzano un percorso locale per una specifica dell'elemento.Viene generata un'eccezione se si specifica un mapping che anche non esiste nel repository.

//Add a custom property to this file.
versionControl.SetVersionedItemProperty( new ItemSpec(“$/proj/Safe To Delete.txt”),VersionSpec.Latest,
    DeletedState.Any, ItemType.File,”MyProperty”, 24);

Esempio: Creare rami

È possibile creare un branch di un file esistente nel controllo della versione tramite il codice seguente, che chiama i metodi CheckIn e PendBranch.Compilazione di questo esempio in Add a File to Version Control vengono fornite e viene illustrato come utilizzare il modello a oggetti per creare e archiviare un ramo di un file esistente.È possibile modificare l'esempio di codice per creare un file e sostituire alcune righe di codice in tale esempio con il codice di questo esempio.Dopo avere applicato queste modifiche, è possibile creare un branch di un file nel controllo della versione.

Per utilizzare questo esempio

• Aprire l'applicazione console C# creato nell'argomento Add a File to Version Control quindi sostituire il blocco interno prova con il codice seguente:

String branchedFilename = Path.Combine(Path.GetDirectoryName(newFilename),
    Path.GetFileNameWithoutExtension(newFilename)) + "-branch" + Path.GetExtension(newFilename);

workspace.PendBranch(newFilename, branchedFilename, VersionSpec.Latest, LockLevel.Checkin, true);

var pendingChanges = workspace.GetPendingChanges();
int changesetForBranch = workspace.CheckIn(pendingChanges, "Branched file");
Console.WriteLine("Branched {0} to {1} in changeset {2}", newFilename, branchedFilename, changesetForBranch);

È possibile aggiungere una specifica della versione quando si crea un ramo anziché utilizzando la versione più recente di un file.Ad esempio, è possibile specificare un ID insieme di modifiche e un nome utente quando si chiama PendBranch.Poiché più classi che derivano da VersionSpec, è possibile utilizzare una specifica versione come parametro per recuperare tutti i file che corrispondono a un ID insieme di modifiche o con una data specifica o contrassegnano.Per ulteriori informazioni, vedere ChangeSetVersionSpec, DateVersionSpec o LabelVersionSpec.

Nell'esempio seguente, si specifica un ID insieme di modifiche per l'associazione con il file creato un branch.Dopo aver eseguito il commit delle modifiche, l'id insieme di modifiche del file creato un ramo corrisponderà al valore specificato.

VersionSpec versionSpec = VersionSpec.ParseSingleSpec(changesetId, username);
String branchedFilename = Path.Combine(Path.GetDirectoryName(newFilename),
    Path.GetFileNameWithoutExtension(newFilename)) + "-branch" + Path.GetExtension(newFilename);
// Use the version spec in the method call.
workspace.PendBranch(newFilename, branchedFilename, versionSpec, LockLevel.Checkin, true);

Esempio: Eliminare cartelle

È possibile eliminare una cartella dal controllo della versione tramite il codice seguente, che chiama i metodi CheckIn e PendDelete.Compilazione di questo esempio in Add a File to Version Control vengono fornite e viene illustrato come utilizzare il modello a oggetti per eliminare una cartella quindi archiviare tale modifica.È possibile modificare l'esempio di codice per creare un file e sostituire alcune righe di codice in tale esempio nel seguente esempio.Dopo avere applicato tali modifiche, è possibile eliminare una cartella dal controllo della versione.

Per utilizzare questo esempio

• Aprire l'applicazione console C# creato nell'argomento Add a File to Version Control quindi sostituire il blocco interno prova dell'esempio originale con il codice seguente:

try
{
    // Delete the items
    workspace.PendDelete(workspace.GetServerItemForLocalItem(newFolder), RecursionType.Full);
    var pendingDeletes = workspace.GetPendingChanges();

    if (pendingDeletes.Length > 0)
    {
        workspace.CheckIn(pendingDeletes, "Clean up!");
    }
}
catch (VersionControlException ex)
{
    Console.Error.WriteLine("Error deleting file: {0}", ex.Message);
    throw;
}

Vedere anche

Concetti

Estensione di Team Foundation

Altre risorse

Utilizzo del controllo della versione