Rozšíření řízení verze

Visual Studio Team Foundation Server 2010představuje změnu v architektuře Team Foundation Server.Dříve, než si ukázkový kód v tomto tématu, měli byste pochopit architektura Team Foundation Server na nejméně na velmi vysoké úrovni a následující informace pomohou pochopit účel týmové projekty a kolekce týmu projektu v rámci projektu kolekce.Tato organizační změna umožňuje provádět operace řízení verze souvisejících položek v rámci kolekce týmu projektu.

Primární organizační struktury v Team Foundation Server 2010 je kolekce týmu projektu.Kolekce týmu projektu je seskupení týmové projekty do organizační struktury, můžete definovat a spravovat skupiny projektů, které sdílejí zdroje nebo základ kódu.Výhodou tohoto typu organizační hierarchie je, že řízení projektů týmu bude efektivnější jim přiřadit zdroje a seskupit.Operace, například větvení nebo slučování kódu, zálohování a obnovení dat a vykazování informací o projektu snadněji, protože jsou specifické pro databázi.Další informace o týmu projekt kolekcí v Team Foundation Server 2010, viz Organizing Your Server with Team Project Collections.

V tomto tématu

• 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

[!POZNÁMKA]

Můžete rozšířit Team Foundation – správa verzí přístupu a aktualizovat položky v úložišti správy verzí a v prostoru v místním počítači vytvořit vlastní zásady zaškrtnutí a aplikovat na týmu projektu.Využitím dědičnosti, nahraďte existující funkce vlastní provádění politiky, která se vztahuje k řízení verze.Další informace naleznete na následující stránce na webu společnosti Microsoft: jak: vytvoření vlastní změnami zásad.

Příklad: Přístup K položky v úložišti správy verzí

Následující ukázka použití VersionControlServer objektu seznamu každé verze každého souboru .xaml v úložišti správy verzí.

Chcete-li použít tento příklad

1. Vytvoření aplikace konzoly a přidat odkazy na následující sestavení:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.VersionControl.Client

2. V tomto příkladu nahradíte obsah Program.cs (nebo 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

Příklad: Aktualizace položek v pracovním prostoru

Práce se soubory v pracovním prostoru provedením operace, například get, rezervovat a změnami programově.Následující příklad načte poslední verze souborů v pracovním prostoru.

Chcete-li použít tento příklad

1. V předchozím příkladu v části kódu, který obsahuje seznam souborů .xaml najít a nahradit následující kód.

2. Nahradit WorkspaceName název pracovního prostoru, což je obvykle stejné jako název počítače, který obsahuje pracovní prostor.

3. Nahradit uživatelské jméno s plně kvalifikovaný název uživatele, který vlastní pracovní prostor.

Další informace naleznete v tématu Workstation.GetLocalWorkspaceInfo a Správa pracovních prostorů.

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

Můžete také získat prostoru, který je namapován do složky v místním počítači předáním úplnou cestu složky, aby Workstation.GetLocalWorkspaceInfo.

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

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

Příklad: Přidání položek do úložiště řízení verze

Můžete vytvořit soubor, místo za řízení verze pomocí přidání a metody pro kontrolu.

Upozornění
Kód vyvolají výjimku, pokud nemáte oprávnění číst a soubory pracovního prostoru.Tato oprávnění jsou oprávnění k řízení zdroj čtení a vrácení se změnami v Explorer ovládacího prvku zdrojového.

V tomto příkladu bude volat následující metody:

• Nejprve určete projekt kolekcí v Team Foundation Server voláním [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollection()] nebo [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollections()].

• Po identifikaci projektu kolekce pak identifikovat každý tým projektu kolekce voláním [M:Microsoft.TeamFoundation.Client.TfsConfigurationServer.GetTeamProjectCollection()].

• V rámci kolekce týmu projektu, identifikovat jednotlivé týmové projekty voláním [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetAllTeamProjects()].

• Pro každý projekt týmu získat přidružené prostoru voláním [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetWorkspace()] nebo [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.CreateWorkspace()], a pak mapovat prostoru na místní jednotku voláním [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.CreateMapping()].

• Zkopírovat soubory na místní jednotku, volání [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.Get()] pro pracovní prostor.

Pokud máte příslušná oprávnění, můžete přidat pak soubor verze ovládacího prvku.

Chcete-li použít tento příklad

1. Vytvoří aplikaci konzole C# a potom přidat odkazy na následující sestavení:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.Common

   • Microsoft.TeamFoundation.VersionControl.Client

2. Příklad kódu nahradíte obsah Program.cs.

3. Změňte hodnotu Uri na název serveru vrstva aplikace v prostředí.

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

Příklad: Úpravy položek

Existující soubor pod kontrolou verze můžete změnit pomocí následující kód, který volá PendEdit a CheckIn metod.Tento příklad ukazuje, jak upravit existující soubor a použít objektový model.Můžete změnit ukázku kódu pro vytvoření souboru a některé řádky v tomto příkladu kódu nahraďte kód v tomto příkladu.Tento příklad navíc zavádí specifikací zboží, které slouží k přidání vlastních vlastností do souboru.

Chcete-li použít tento příklad

• Otevření aplikace konzoly C#, který jste vytvořili v Add a File to Version Control příkladu a potom nahradit vnitřní akci bloku s následujícím kódem:

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

Soubor vytvořený v tomto příkladu můžete přidat vlastnost.Voláním SetVersionedItemProperty metodu, můžete nastavit vlastnost výběru souboru.V příkladu je použít itemSpec parametr určuje cestu k souborům a složkám.V tomto případě bude zadat místní cestu, přestože tento parametr můžete také zadat cestu úložiště.Pro něj bude také definovat vlastnosti a hodnoty.

Upozornění
Musíte být opatrní při použití místní cestu pro specifikaci zboží.Pokud zadáte neexistující také v úložišti mapování bude vyvolána výjimka.

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

Příklad: Vytvoření větví

Můžete větví pod kontrolou verze existující soubor pomocí následující kód, který volá PendBranch a CheckIn metod.Tento příklad vytvoří Add a File to Version Control vzorků a ukazuje, jak vytvořit a zkontrolovat ve větvi existujícího souboru použít objektový model.Můžete změnit ukázku kódu pro vytvoření souboru a nahradit některé řádky kódu v příkladu kódu v tomto příkladu.Po provedení těchto změn je pak vytvořit větev souboru v řízení verze.

Chcete-li použít tento příklad

• Otevření aplikace konzoly C#, který jste vytvořili v Add a File to Version Control téma a potom nahradit vnitřní akci bloku s následujícím kódem:

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

Specifikace verze můžete přidat při vytváření větve místo pouze nejnovější verzi souboru.Například můžete určit changeset ID a uživatelské jméno při volání PendBranch.Protože více tříd jsou odvozeny od VersionSpec, můžete jako parametr verze specifikace získat všechny soubory odpovídající changeset ID nebo které mají určité datum nebo popisek.For more information, see ChangeSetVersionSpec, DateVersionSpec, or LabelVersionSpec.

V následujícím příkladu zadejte ID changeset větvenou souboru přidružit.Po potvrzení změn ID changeset větvenou souboru bude odpovídat zadanou hodnotu.

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

Příklad: Odstranění složek

Složky můžete odstranit z verze ovládacího prvku pomocí následující kód, který volá PendDelete a CheckIn metod.Tento příklad vytvoří Add a File to Version Control vzorků a ukazuje, jak odstranit složku a potom tuto změnu použít objektový model.Můžete změnit ukázku kódu pro vytvoření souboru a nahradit některé řádky kódu v příkladu v následujícím příkladu.Po použití těchto změn pak můžete odstranit složku z verze ovládacího prvku.

Chcete-li použít tento příklad

• Otevření aplikace konzoly C#, který jste vytvořili v Add a File to Version Control téma a potom nahradit vnitřní akci blokovat původní příklad s následujícím kódem:

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

Viz také

Koncepty

Rozšíření Team Foundation

Další zdroje

Pomocí řízení verze