Erweitern der Versionskontrolle

Visual Studio Team Foundation Server 2010 stellt eine Änderung in der Architektur von Team Foundation Server dar.Bevor Sie den Beispielcode in diesem Thema lesen, sollten Sie die Architektur von Team Foundation Server an einem sehr auf hoher Ebene mindestens verstehen, und die folgenden Informationen können Ihnen helfen, den Zweck der Teamprojekte und der Teamprojektsammlungen in einer Projektauflistung zu verstehen.Diese Organisationsänderung ermöglicht es Ihnen, Versionskontrollvorgänge auf zugehörigen übergeordneten im Kontext einer Teamprojektsammlung auszuführen.

Die primäre Organisationsstruktur in Team Foundation Server 2010 ist die Teamprojektsammlung.Die Teamprojektsammlung ist eine Gruppe von Teamprojekten in eine Organisationsstruktur, die Sie verwenden können, um eine Gruppe Projekte zu definieren und zu verwalten, die Ressourcen oder eine CodeBase freigeben.Der Vorteil dieses Typs der Organisationshierarchie ist, dass Verwaltung von Teamprojekten effizienter wird, wenn Sie diese gruppieren und ihnen Ressourcen zuweisen.Vorgänge wie Verzweigen und Zusammenführen von Code, Sichern und Wiederherstellen von Daten und von übertragbaren Projektinformationen werden vereinfacht, da sie zu einer Datenbank spezifisch sind.Weitere Informationen über Teamprojektsammlungen in Team Foundation Server 2010, finden Sie unter Organizing Your Server with Team Project Collections.

In diesem Thema

• 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

Hinweis

Sie können Team Foundation-Versionskontrolle erweitern, indem Sie auf Elemente im Repository der Versionskontrolle und in einem Arbeitsbereich auf dem lokalen Computer zugreifen und aktualisieren, um benutzerdefinierte Eincheckrichtlinien zu erstellen und an einem Teamprojekt zu übernehmen.Durch Vererbung nutzen, ersetzen Sie vorhandene Funktion durch eine eigene Implementierung der Richtlinie, während sie auf Versionskontrolle gilt.Weitere Informationen finden Sie auf der folgenden Seite der Microsoft-Website: Gewusst wie: Erstellen Sie benutzerdefinierte Eincheckrichtlinien.

Beispiel: Zugreifen auf Elemente im Versionskontrollen-Repository

Im folgenden Beispiel wird das VersionControlServer-Objekt, um jede Version jeder XAML-Datei im Repository der Versionskontrolle aufzulisten.

So verwenden Sie dieses Beispiel

1. Erstellen Sie eine Konsolenanwendung und fügen Sie Verweise auf die folgenden Assemblys hinzu:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.VersionControl.Client

2. Ersetzen Sie den Inhalt von Program.cs (oder Module1.vb) durch dieses Beispiel.

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

Beispiel: Update-Elemente in einem Arbeitsbereich

Sie können mit Dateien in einem Arbeitsbereich umgehen, indem Sie Vorgänge wie ausführen, erhalten, prüfen auschecken und checken programmgesteuert.Im folgenden Beispiel wird die aktuelle Version der Dateien in einem Arbeitsbereich ab.

So verwenden Sie dieses Beispiel

1. Im vorherigen Beispiel suchen Sie den Codeabschnitt, der die .xaml-Dateien auflistet, und ersetzen Sie ihn durch den folgenden Code.

2. Ersetzen Sie WorkspaceName durch den Namen des Arbeitsbereichs, der in der Regel der selbe wie der Name des Computers ist, der den Arbeitsbereich enthält.

3. Ersetzen Sie Benutzername durch den vollqualifizierten Namen des Benutzers, der den Arbeitsbereich besitzt.

Weitere Informationen finden Sie unter Workstation.GetLocalWorkspaceInfo und Verwalten der Arbeitsbereiche.

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

Sie können einen Arbeitsbereich auch abrufen, der auf einen Ordner auf dem lokalen Computer zugeordnet ist, indem Sie den vollständigen Pfad dieses Ordners zu Workstation.GetLocalWorkspaceInfo übergibt.

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

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

Beispiel: Hinzufügen von Elementen zum Versionskontrollen-Repository

Sie können eine Datei erstellen und es unter Versionskontrolle zu platzieren, indem Sie verwenden, fügen Sie hinzu und checken Sie Methoden ein.

Vorsicht
Der Code löst eine Ausnahme aus, wenn Sie nicht über die Berechtigungen verfügen, im Arbeitsbereich zu lesen und einzuchecken anwendbar.Diese Berechtigungen sind die Quellcodeverwaltungs-Berechtigungen für Lesen und Einchecken in Quellcodeverwaltungs-Explorer.

In diesem Beispiel rufen Sie die folgenden Methoden auf:

• Zuerst identifizieren Sie Projektauflistungen Team Foundation Server, indem Sie [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollection()] oder [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollections()] aufrufen.

• Nachdem Sie die Projektauflistungen identifizieren, identifizieren Sie dann jede Teamprojektsammlung, indem Sie [M:Microsoft.TeamFoundation.Client.TfsConfigurationServer.GetTeamProjectCollection()] aufrufen.

• Innerhalb der Teamprojektsammlung identifizieren Sie einzelne Teamprojekte, indem Sie [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetAllTeamProjects()] aufrufen.

• Für jedes Teamprojekt rufen Sie den zugeordneten Arbeitsbereich ab, indem Sie [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetWorkspace()] oder [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.CreateWorkspace()] aufrufen, und dann wird Sie den Arbeitsbereich auf dem lokalen Laufwerk zu, indem Sie [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.CreateMapping()] aufrufen.

• Um die Dateien auf einem lokalen Laufwerk zu kopieren, rufen Sie [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.Get()] für den Arbeitsbereich auf.

Sie können eine Datei Versionskontrolle hinzufügen, wenn Sie die entsprechenden Berechtigungen.

So verwenden Sie dieses Beispiel

1. Erstellen Sie eine C#-Konsolenanwendung, und fügen Sie dann Verweise auf die folgenden Assemblys hinzu:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.Common

   • Microsoft.TeamFoundation.VersionControl.Client

2. Ersetzen Sie den Inhalt von Program.cs durch den Beispielcode.

3. Ändern Sie den Wert von URI auf den Namen des Anwendungsebenenservers in der Umgebung.

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

Beispiel: Bearbeitungs-Elemente

Sie können eine vorhandene Datei unter Versionskontrolle ändern, indem Sie den folgenden Code verwenden, der die PendEdit und CheckIn-Methoden aufruft.Dieses Beispiel zeigt, wie das Objektmodell verwendet, um eine vorhandene Datei in zu bearbeiten und zu überprüfen.Sie ändern das Codebeispiel für das Erstellen einer Datei und ersetzen dann einige Codezeilen in diesem Beispiel durch den Code in diesem Beispiel.Außerdem stellt dieses Beispiel Elementspezifikation vor, die Sie verwenden, um eine benutzerdefinierte Eigenschaft einer Datei hinzuzufügen.

So verwenden Sie dieses Beispiel

• Öffnen Sie die C#-Konsolenanwendung, die Sie im Add a File to Version Control Beispiel erstellt haben, und ersetzen Sie den inneren Versuch-Block durch folgenden Code:

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

Sie können eine Eigenschaft der Datei hinzufügen, die Sie in diesem Beispiel erstellt haben.Mithilfe der SetVersionedItemProperty-Methode aufrufen, können Sie eine Eigenschaft der Auswahl auf der Datei festlegen.Im Beispiel verwenden Sie den itemSpec-Parameter, um einen Pfad zu den Dateien und Ordnern anzugeben.In diesem Fall geben Sie den lokalen Pfad, obwohl Sie diesen Parameter auch verwenden können, um einen Pfad auf dem Repository anzugeben.Sie definieren auch eine Eigenschaft und einen Wert dafür.

Vorsicht
Sie müssen vorsichtig sein, wenn Sie einen lokalen Pfad für eine Elementspezifikation verwenden.Eine Ausnahme wird ausgelöst, wenn Sie eine Zuordnung angeben, die nicht auch im Repository vorhanden ist.

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

Beispiel: Erstellen von Verzweigungen

Sie können eine vorhandene Datei unter Versionskontrolle verzweigen, indem Sie den folgenden Code verwenden, der die PendBranch und CheckIn-Methoden aufruft.Builds dieses Beispiels auf Add a File to Version Control überprüfen und zeigen, wie das Objektmodell verwendet, um eine Verzweigung einer vorhandenen Datei in zu erstellen und zu überprüfen.Sie können das Codebeispiel für das Erstellen einer Datei ändern und einige Codezeilen in diesem Beispiel durch den Code in diesem Beispiel ersetzen.Nachdem Sie diese Änderungen anwenden, können Sie eine Verzweigung einer Datei in der Versionskontrolle dann erstellen.

So verwenden Sie dieses Beispiel

• Öffnen Sie die C#-Konsolenanwendung, die Sie im Add a File to Version Control Thema erstellt haben, und ersetzen Sie den inneren Versuch-Block durch folgenden Code:

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

Sie können eine Versionsspezifikation hinzufügen, wenn Sie eine Verzweigung statt nur mit der neuesten Version einer Datei erstellen.Beispielsweise können Sie eine Changeset ID und einen Benutzernamen angeben, wenn Sie PendBranch aufrufen.Da mehrere Klassen von VersionSpec abgeleitet werden, können Sie eine Versionsspezifikation als Parameter verwenden, um alle Dateien, die eine Changeset ID übereinstimmen, oder die ein bestimmtes Datum oder eine Bezeichnung aufweisen.Weitere Informationen finden Sie unter ChangeSetVersionSpec, DateVersionSpec oder LabelVersionSpec.

Im folgenden Beispiel geben Sie eine Changeset IDs, die mit der verzweigten Datei zuzuordnen.Nachdem Sie die Änderungen übernehmen, entspricht die Changeset ID der verzweigten Datei den Wert von angegeben ab.

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

Beispiel: Löschen von Ordnern

Sie können einen Ordner aus der Versionskontrolle löschen, indem Sie den folgenden Code verwenden, der die PendDelete und CheckIn-Methoden aufruft.Builds dieses Beispiels auf Add a File to Version Control überprüfen und zeigen, wie das Objektmodell verwendet, um einen Ordner löschen und dann diese Änderung einzuchecken.Sie können das Codebeispiel für das Erstellen einer Datei ändern und einige Codezeilen in diesem Beispiel durch das folgende Beispiel ersetzen.Nachdem Sie diese Änderungen anwenden, können Sie einen Ordner aus der Versionskontrolle anschließend gelöscht.

So verwenden Sie dieses Beispiel

• Öffnen Sie die C#-Konsolenanwendung, die Sie im Add a File to Version Control Thema erstellt haben, und ersetzen Sie den inneren Versuch-Block im ursprünglichen Beispiel durch folgenden Code:

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

Siehe auch

Konzepte

Erweitern von Team Foundation Server

Weitere Ressourcen

Verwenden der Versionskontrolle