Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais

Extension du contrôle de version

Visual Studio Team Foundation Server 2010 représente une modification de l'architecture d' Team Foundation Server. Avant de lire l'exemple de code dans cette rubrique, vous devez comprendre l'architecture d' Team Foundation Server au moins un niveau très élevé, et les informations suivantes doivent vous aider à comprendre l'objectif des projets d'équipe et collections de projets d'équipe dans une collection de projets. Cette modification d'organisation vous permet d'exécuter des opérations de service sur les éléments connexes dans le contexte d'une collection de projets d'équipe.

La structure d'organisation principale dans Team Foundation Server 2010 est la collection de projets d'équipe. La collection de projets d'équipe est un regroupement de projets d'équipe dans une structure d'organisation que vous pouvez utiliser pour définir et gérer un groupe de projets qui partagent des ressources ou une base de code. L'avantage de ce type de hiérarchie d'organisation est que la gestion des projets d'équipe est plus efficace lorsque vous les regrouper ensemble et leur assigner des ressources. Les opérations telles que la branche ou fusionner du code, enregistrer et restaurer les données, et stocker les informations du projet sont plus faciles car elles sont spécifiques à une base de données. Pour plus d'informations sur les collections de projets d'équipe dans Team Foundation Server 2010, consultez l' Organizing Your Server with Team Project Collections.

Dans cette rubrique

Remarque Remarque

Vous pouvez étendre contrôle de version Team Foundation en accédant et en mettant à jour à des éléments dans le référentiel de contrôle de version et dans un espace de travail sur l'ordinateur local pour créer des stratégies d'archivage personnalisées et de les appliquer à un projet d'équipe. En tirant parti de l'héritage, remplacez la fonctionnalité existante par votre propre implémentation de stratégie à mesure qu'elle applique au contrôle de version. Pour plus d'informations, consultez la page suivante sur le site Web Microsoft : Comment : Créez des stratégies d'archivage personnalisées.

L'exemple suivant utilise l'objet d' VersionControlServer pour répertorier chaque version de chaque fichier .xaml dans le référentiel de contrôle de version.

Pour utiliser cet exemple

  1. Créez une application console, puis ajoutez des références aux assemblys suivants :

  2. Remplacez le contenu (Program.cs ou Module1.vb) par cet exemple.

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("http://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());
            }
        }
    }
}

Vous pouvez utiliser les fichiers dans un espace de travail en extrayant d'effectuer des opérations telles que le get, contrôle, puis archivez par programme. l'exemple suivant obtient la dernière version des fichiers dans un espace de travail.

Pour utiliser cet exemple

  1. Dans l'exemple précédent, recherchez la section du code qui répertorie les fichiers .xaml, puis remplacez -la par le code suivant.

  2. Remplacez WorkspaceName par le nom de l'espace de travail, qui est généralement identique au nom de l'ordinateur qui contient l'espace de travail.

  3. Remplacez nom d'utilisateur par le nom qualifié complet de l'utilisateur qui possède l'espace de travail.

Pour plus d'informations, consultez Workstation.GetLocalWorkspaceInfo et Créer et utiliser des espaces de travail.

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

Vous pouvez également obtenir un espace de travail mappé à un dossier sur l'ordinateur local en passant le chemin d'accès complet de ce dossier à Workstation.GetLocalWorkspaceInfo.

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

Vous pouvez créer un fichier et le placer sous contrôle de version en utilisant ajoutez et arrivez les méthodes.

Mise en garde Attention

Le code lèvera une exception si vous ne disposez pas des autorisations dans l'espace de travail de lire et signer classe. Ces autorisations sont les autorisations de contrôle de code source pour Lecture et Checkin dans Explorateur du contrôle de code source.

Dans cet exemple, vous appellerez les méthodes suivantes :

  • D'abord, vous identifiez les collections de projets dans Team Foundation Server en appelant [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollection()] ou [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollections()].

  • Après avoir identifié les collections de projets, vous identifiez chaque collection de projets d'équipe en appelant [M:Microsoft.TeamFoundation.Client.TfsConfigurationServer.GetTeamProjectCollection()].

  • Dans la collection de projets d'équipe, vous identifiez des projets d'équipe en appelant [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetAllTeamProjects()].

  • Pour chaque projet d'équipe, vous obtenez l'espace de travail associé en appelant [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetWorkspace()] ou [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.CreateWorkspace()], puis vous mappez l'espace de travail au lecteur local en appelant [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.CreateMapping()].

  • Pour copier les fichiers vers un lecteur local, vous appelez [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.Get()] de l'espace de travail.

Vous pouvez ensuite ajouter un fichier au contrôle de version si vous disposez des autorisations appropriées.

Pour utiliser cet exemple

  1. Créez une application console C#, puis ajoutez des références aux assemblys suivants :

  2. Remplacez le contenu de Program.cs par l'exemple de code.

  3. Modifiez la valeur d' URI par le nom du serveur de couche Application dans votre environnement.

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("http://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;
            }
            
        }
    }
}

Vous pouvez modifier un fichier existant sous contrôle de version en utilisant le code suivant, qui appelle les méthodes d' PendEdit et d' CheckIn . Cet exemple indique comment utiliser le modèle objet pour modifier et signer un fichier existant. Vous modifierez l'exemple de code permettant de créer un fichier puis remplacerez quelques lignes de code dans cet exemple par le code de cet exemple. De plus, cet exemple présente les caractéristiques d'élément, que vous utilisez pour ajouter une propriété personnalisée à un fichier.

Pour utiliser cet exemple

  • Ouvrez l'application console C# que vous avez créée dans l'exemple de Add a File to Version Control , puis remplacez le bloc interne test par le code suivant :

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

Vous pouvez ajouter une propriété au fichier que vous avez créé dans cet exemple. En appelant la méthode d' SetVersionedItemProperty , vous pouvez définir une propriété de votre choix dans le fichier. Dans l'exemple, vous utiliserez le paramètre d' itemSpec pour spécifier un chemin d'accès aux fichiers et dossiers. Dans ce cas, vous spécifier le chemin d'accès local, bien que vous puissiez également utiliser ce paramètre pour spécifier un chemin sur la base de données de référentiel. Vous définirez également une propriété et une valeur pour celui-ci.

Mise en gardeAttention

Vous devez être prudent lorsque vous utilisez un chemin d'accès local avec une spécification d'élément. Une exception est levée si vous spécifiez un mappage qui n'existe pas dans le référentiel.

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

Vous pouvez créer une branche pour un fichier existant sous contrôle de version en utilisant le code suivant, qui appelle les méthodes d' PendBranch et d' CheckIn . Cet exemple génère dans l'exemple de Add a File to Version Control et explique comment utiliser le modèle objet pour créer et signer une branche d'un fichier existant. Vous pouvez modifier l'exemple de code permettant de créer un fichier et remplacer certaines lignes de code dans cet exemple par le code de cet exemple. Après avoir appliqué ces modifications, vous pouvez créer une branche d'un fichier dans le contrôle de version.

Pour utiliser cet exemple

  • Ouvrez l'application console C# que vous avez créée dans la rubrique d' Add a File to Version Control , puis remplacez le bloc interne test par le code suivant :

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

Vous pouvez ajouter une spécification de version lorsque vous créez une branche au lieu de simplement à l'aide de la dernière version d'un fichier. Par exemple, vous pouvez spécifier un ID de l'ensemble de modifications et un nom d'utilisateur lorsque vous appelez PendBranch. Étant donné que plusieurs classes dérivées de VersionSpec, vous pouvez utiliser une spécification de version en tant que paramètre pour obtenir tous les fichiers qui correspondent à un ID d'ensemble de modifications ou qui ont une date spécifique ou l'à étiquetage automatique. Pour plus d'informations, consultez ChangeSetVersionSpec, DateVersionSpec ou LabelVersionSpec.

Dans l'exemple suivant, vous spécifiez un ID de l'ensemble de modifications à associer au fichier avec des branches. Après avoir valider les modifications, l'ID de l'ensemble de modifications du fichier avec des branches correspondra à la valeur que vous avez spécifiée.

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

Vous pouvez supprimer un dossier de contrôle de version en utilisant le code suivant, qui appelle les méthodes d' PendDelete et d' CheckIn . Cet exemple génère dans l'exemple de Add a File to Version Control et explique comment utiliser le modèle objet pour supprimer un dossier puis pour signer cette modification. Vous pouvez modifier l'exemple de code permettant de créer un fichier et remplacer certaines lignes de code dans cet exemple par l'exemple suivant. Après avoir appliqué ces modifications, vous pouvez ensuite supprimer un dossier de contrôle de version.

Pour utiliser cet exemple

  • Ouvrez l'application console C# que vous avez créée dans la rubrique d' Add a File to Version Control , puis remplacez le bloc interne test dans l'exemple d'origine par le code suivant :

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

Ajouts de la communauté

Afficher: