Rozszerzenie kontroli wersji

Visual Studio Team Foundation Server 2010reprezentuje zmianę architektury Team Foundation Server.Przed przeczytaniem przykładowy kod w tym temacie, należy zrozumieć Architektura Team Foundation Server na najmniej bardzo wysoki poziom i następujące informacje powinny ułatwić zrozumienie celu projektów zespołu i zespołu projektu kolekcji w obrębie zbioru projektu.Tej zmiany organizacyjnej umożliwia wykonywanie operacji kontroli wersji na powiązanych elementów w ramach zbioru zespołu projektu.

Podstawowej struktury organizacyjnej w Team Foundation Server 2010 jest zbiorem zespołu projektu.Kolekcja zespołu projektu jest pogrupować struktury organizacyjnej można używać do definiowania i zarządzać grupy projektów, które współużytkują zasoby lub base kod zespołu projektów.Zaletą tego rodzaju hierarchii organizacyjnej jest zarządzanie projektami zespołu staje bardziej efektywne, gdy grupować i przypisywać im zasobów.Łatwiej operacji rozgałęzianie lub scalanie kodu, wykonywanie kopii zapasowych i przywracanie danych i raportowanie informacji o projekcie, ponieważ są specyficzne dla bazy danych.Aby uzyskać więcej informacji dotyczących zespołu projektu kolekcje w Team Foundation Server 2010, zobacz Organizing Your Server with Team Project Collections.

W tym temacie

• 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

[!UWAGA]

Można rozszerzyć Kontrola wersji programu Team Foundation przez dostęp i aktualizowanie elementów w repozytorium kontroli wersji i obszar roboczy na komputerze lokalnym, aby utworzyć niestandardowe zasady wyboru i zastosować je do zespołu projektu.Dzięki wykorzystaniu dziedziczenia, możesz zastąpić istniejące funkcje implementacji zasad do kontroli wersji.Aby uzyskać więcej informacji, zobacz następujące strony w witrynie sieci Web firmy Microsoft: jak: Tworzenie niestandardowych zasad ewidencjonowania.

Przykład: Dostęp do elementów w repozytorium kontroli wersji

Następujące przykładowe zastosowania VersionControlServer obiektu listy każda wersja każdego pliku .xaml w repozytorium kontroli wersji.

Aby wykorzystać ten przykład

1. Tworzy aplikację konsoli i dodaj odwołania do następujących zespołów:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.VersionControl.Client

2. W tym przykładzie należy zastąpić zawartość plik Program.cs (lub Module1.vb).

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

Przykład: Aktualizacja elementów w obszarze roboczym

Można pracować z plikami w obszarze roboczym, wykonując operacje takie jak get, wyewidencjonować i zaewidencjonować programowo.Poniższy przykład pobiera najnowszą wersję plików w obszarze roboczym.

Aby wykorzystać ten przykład

1. W poprzednim przykładzie Znajdź sekcję kodu, który zawiera listę plików .xaml i zamień następujący kod.

2. Zamień WorkspaceName nazwę obszaru roboczego, który jest zwykle taka sama jak nazwa komputera, który zawiera obszaru roboczego.

3. Zamień nazwa_użytkownika z w pełni kwalifikowaną nazwę użytkownika, który jest właścicielem obszaru roboczego.

Aby uzyskać więcej informacji, zobacz Workstation.GetLocalWorkspaceInfo i Zarządzaj obszarami roboczymi.

// 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)

Można także uzyskać obszaru roboczego, który jest mapowany do folderu na komputerze lokalnym, przekazując pełną ścieżkę do folderu Workstation.GetLocalWorkspaceInfo.

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

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

Przykład: Dodawanie elementów do repozytorium kontroli wersji

Można utworzyć plik i dodać go pod kontrolą wersji przy użyciu miejsca i metod.

Przestroga
Kod wygeneruje wyjątek, jeśli nie masz uprawnienia obszaru roboczego do odczytu i odkładanie plików.Uprawnienia te są uprawnienia kontroli źródła dla odczytu i zaewidencjonowania w Explorer kontroli źródła.

W tym przykładzie będzie wywoływać następujące metody:

• Najpierw należy zidentyfikować kolekcje projektu w Team Foundation Server przez wywołanie [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollection()] lub [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollections()].

• Po zidentyfikowaniu kolekcje projektu można zidentyfikować każdego zespołu projektu zbierania przez wywołanie [M:Microsoft.TeamFoundation.Client.TfsConfigurationServer.GetTeamProjectCollection()].

• W kolekcji zespołu projektu, identyfikowania poszczególnych zespołów projektów przez wywołanie [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetAllTeamProjects()].

• Dla każdego projektu zespołu get skojarzone obszaru roboczego przez wywołanie [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetWorkspace()] lub [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.CreateWorkspace()], a następnie zamapować obszaru roboczego na dysku lokalnym, wywołując [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.CreateMapping()].

• Aby skopiować pliki na dysku lokalnym, należy wywołać [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.Get()] dla obszaru roboczego.

Następnie można dodać pliku do kontroli wersji, jeśli masz odpowiednie uprawnienia.

Aby wykorzystać ten przykład

1. Tworzy aplikację konsoli C#, a następnie dodaj odwołania do następujących zestawów:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.Common

   • Microsoft.TeamFoundation.VersionControl.Client

2. Zastąp zawartość plik Program.cs przykładowy kod.

3. Zmień wartość Uri do nazwy serwera warstwy aplikacji w środowisku.

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;
            }
            
        }
    }
}

Przykład: Edytowanie elementów

Można zmodyfikować istniejący plik pod kontrolą wersji za pomocą następujący kod, który wywołuje PendEdit i CheckIn metody.Ten przykład pokazuje sposób użycia modelu obiektów do edycji i sprawdź w istniejącym pliku.Będzie zmodyfikować kod przykładowy tworzenia pliku i zamienić niektóre wiersze kodu w tym przykładzie kodu w tym przykładzie.Ponadto w tym przykładzie wprowadza element specyfikacji, które umożliwia dodawanie niestandardowych właściwości pliku.

Aby wykorzystać ten przykład

• Otwórz aplikację konsoli C#, utworzony w Add a File to Version Control przykład, a następnie zamień wewnętrzne Spróbuj bloku następującym kodem:

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);
}

Można dodać właściwości do pliku utworzonego w tym przykładzie.Wywołując SetVersionedItemProperty metody, można ustawić właściwości wybierania na pliku.W przykładzie będzie używać itemSpec parametr określić ścieżkę do plików i folderów.W takim przypadku będzie określić ścieżkę lokalną, chociaż tego parametru można używać także określić ścieżkę repozytorium.Będzie również zdefiniować właściwość i wartość dla niego.

Przestroga
Należy zachować ostrożność przy użyciu ścieżki lokalnej dla specyfikacji elementu.Wyjątek będzie generowany Jeśli określić mapowanie nie istnieje również w repozytorium.

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

Przykład: Tworzenie oddziałów

Można oddział pod kontrolą wersji istniejącego pliku przy użyciu następujący kod, który wywołuje PendBranch i CheckIn metody.W tym przykładzie opiera się na Add a File to Version Control próbki i przedstawiono sposób użycia modelu obiektów do tworzenia i sprawdzić w gałęzi istniejącego pliku.Można zmodyfikować kod przykładowy tworzenia pliku i zamienić niektóre wiersze kodu w tym przykładzie kodu w tym przykładzie.Po zastosowaniu tych zmian można następnie utworzyć oddział pliku w kontroli wersji.

Aby wykorzystać ten przykład

• Otwórz aplikację konsoli C#, utworzony w Add a File to Version Control tematu, a następnie zamień wewnętrzne Spróbuj bloku następującym kodem:

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);

Specyfikacja wersji można dodać podczas tworzenia oddziału, a nie tylko za pomocą najnowszej wersji pliku.Na przykład, można określić identyfikator changeset i nazwa użytkownika podczas wywołania PendBranch.Ponieważ wiele klas pochodzą z VersionSpec, można użyć wersji specyfikacji jako parametr uzyskać wszystkie pliki pasujące identyfikator changeset lub mają określonej daty lub etykiety.For more information, see ChangeSetVersionSpec, DateVersionSpec, or LabelVersionSpec.

W poniższym przykładzie określić identyfikator changeset skojarzyć z plikiem rozgałęziony.Po zatwierdzeniu zmiany identyfikator changeset rozgałęziony pliku będzie odpowiadać podanej wartości.

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);

Przykład: Usuwanie folderów

Można usunąć folder z kontroli wersji za pomocą następujący kod, który wywołuje PendDelete i CheckIn metody.W tym przykładzie opiera się na Add a File to Version Control próbki i przedstawiono sposób użycia modelu obiektów, aby usunąć folder, a następnie sprawdź w tej zmiany.Można zmodyfikować kod przykładowy tworzenia pliku i niektóre wiersze kodu w tym przykładzie należy zastąpić następującym przykładzie.Po zastosowaniu tych zmian można następnie usunąć folder ze kontroli wersji.

Aby wykorzystać ten przykład

• Otwórz aplikację konsoli C#, utworzony w Add a File to Version Control tematu, a następnie zamień wewnętrzne Spróbuj zablokować w oryginalnym przykład następujący kod:

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;
}

Zobacz też

Koncepcje

Rozszerzanie Team Foundation

Inne zasoby

Za pomocą kontroli wersji