Ampliar el control de versiones

Visual Studio Team Foundation Server 2010 representa un cambio en la arquitectura de Team Foundation Server. Antes de leer el código de ejemplo de este tema, debe entender la arquitectura de Team Foundation Server por lo menos en un muy de alto nivel, y la siguiente información debe ayudarle a entender el propósito de proyectos de equipo y colecciones de proyectos de equipo en una colección de proyectos. Este cambio de organización permite realizar operaciones de control de versiones en elementos relacionados en el contexto de una colección de proyectos de equipo.

La estructura organizativa principal en Team Foundation Server 2010 es la colección de proyectos de equipo. La colección de proyectos de equipo es una agrupación de proyectos de equipo en una estructura organizativa que se puede usar para definir y administrar un grupo de proyectos que recursos compartidos o una base de código. La ventaja de este tipo de jerarquía organizativa es que la administración de proyectos de equipo se vuelve más eficaz cuando se agrupan juntos y asignar recursos a ellos. Operaciones como bifurcación o combinación de código, seguridad y la restauración de datos, y enviar información de proyecto se hacen más fácil porque son específicas de una base de datos. Para obtener más información sobre las colecciones de proyectos de equipo en Team Foundation Server 2010, vea Organizing Your Server with Team Project Collections.

En este tema

• 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

Ejemplo: Elementos de acceso en el repositorio de control de versiones

El ejemplo siguiente utiliza el objeto de VersionControlServer para enumerar cada versión de cada archivo .xaml en el repositorio de control de versiones.

Para utilizar este ejemplo

1. Cree una aplicación de consola, y agregue referencias a los ensamblados siguientes:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.VersionControl.Client

2. Reemplace el contenido de Program.cs (o Module1.vb) con este ejemplo.

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

Ejemplo: Elementos de actualización en un área de trabajo

Puede ejecutar los archivos en un área de trabajo realizando operaciones como ventas, comprobación, y proteger mediante programación. El ejemplo siguiente se obtiene la versión más reciente de los archivos en un área de trabajo.

Para utilizar este ejemplo

1. En el ejemplo anterior, busque la sección de código que enumera los archivos .xaml, y reemplácelo con el código siguiente.

2. Reemplace WorkspaceName con el nombre del área de trabajo, que normalmente es igual que el nombre del equipo que contiene el área de trabajo.

3. Reemplace nombre de usuario con el nombre completo del usuario que posee el área de trabajo.

Para obtener más información, vea Workstation.GetLocalWorkspaceInfo y Crear y trabajar con áreas de trabajo.

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

También puede obtener un área de trabajo que está asignada a una carpeta en el equipo local pasando la ruta de acceso completa de la carpeta a Workstation.GetLocalWorkspaceInfo.

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

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

Ejemplo: Agregar elementos al repositorio de control de versiones

Puede crear un archivo y colocarlo con control de versiones con agregar y protección de los métodos.

En este ejemplo, llame a los métodos siguientes:

• Primero, identifique colecciones de proyectos en Team Foundation Server llamando a [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollection()] o [M:Microsoft.TeamFoundation.Client.RegisteredTfsConnections.GetProjectCollections()].

• Después de identificar las colecciones de proyectos, después identifica cada colección de proyectos de equipo llamando a [M:Microsoft.TeamFoundation.Client.TfsConfigurationServer.GetTeamProjectCollection()].

• Dentro de la colección de proyectos de equipo, identifique los proyectos de equipo individuales llamando a [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetAllTeamProjects()].

• Para cada proyecto de equipo, se obtiene el área de trabajo asociada a [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.GetWorkspace()] o [M:Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer.CreateWorkspace()], y se asigna el área de trabajo en la unidad local llamando a [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.CreateMapping()].

• Para copiar los archivos en una unidad local, se llama a [M:Microsoft.TeamFoundation.VersionControl.Client.Workspace.Get()] para el área de trabajo.

Puede agregar un archivo al control de versiones si tiene los permisos adecuados.

Para utilizar este ejemplo

1. Cree una aplicación de consola de C#, y agregue referencias a los siguientes ensamblados:

   • Microsoft.TeamFoundation.Client

   • Microsoft.TeamFoundation.Common

   • Microsoft.TeamFoundation.VersionControl.Client

2. Reemplace el contenido Program.cs con el código de ejemplo.

3. Cambie el valor de Uri al nombre del servidor de capa de aplicación en su entorno.

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

Ejemplo: Elementos de edición

Puede modificar un archivo existente bajo control de versiones mediante el código siguiente, que llama a los métodos de PendEdit y de CheckIn . Este ejemplo muestra cómo utilizar el modelo de objetos para editar y proteger un archivo existente. Modificará el ejemplo de código para crear un archivo y después reemplazará algunas líneas de código en ese ejemplo con el código de este ejemplo. Además, este ejemplo presenta las especificaciones del elemento, que se utiliza para agregar una propiedad personalizada en un archivo.

Para utilizar este ejemplo

• Abra la aplicación de consola de C# que creó en el ejemplo de Add a File to Version Control y, a continuación reemplaza el bloque interno intento con el código siguiente:

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

Puede agregar una propiedad al archivo que creó en este ejemplo. Llamando al método de SetVersionedItemProperty , puede establecer una propiedad de su elección en el archivo. En el ejemplo, utilizará el parámetro de itemSpec para especificar una ruta de acceso a archivos y carpetas. En este caso, especificará la ruta de acceso local, aunque también se pueden utilizar este parámetro para especificar una ruta de acceso en el repositorio. También definirá una propiedad y un valor.

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

Ejemplo: Crear bifurcaciones

Puede crear una bifurcación de un archivo existente bajo control de versiones mediante el código siguiente, que llama a los métodos de PendBranch y de CheckIn . En este ejemplo se compila en el ejemplo de Add a File to Version Control y muestra cómo utilizar el modelo de objetos para crear y proteja una bifurcación de un archivo existente. Puede modificar el ejemplo de código para crear un archivo y reemplazar algunas líneas de código en ese ejemplo con el código de este ejemplo. Después de aplicar estos cambios, puede crear una bifurcación de un archivo en el control de versiones.

Para utilizar este ejemplo

• Abra la aplicación de consola de C# que creó en el tema de Add a File to Version Control y, a continuación reemplaza el bloque interno intento con el código siguiente:

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

Puede agregar una especificación de versión cuando crea una bifurcación en lugar de simplemente utilizando la versión más reciente de un archivo. Por ejemplo, puede especificar un id. del conjunto de cambios y un nombre de usuario cuando se llama a PendBranch. Dado que varias clases se derivan de VersionSpec, puede utilizar una especificación de la versión como parámetro para obtener todos los archivos que coinciden con un id. del conjunto de cambios o que tienen una fecha o una etiqueta concreta. Para obtener más información, vea ChangeSetVersionSpec, DateVersionSpec o LabelVersionSpec.

En el ejemplo siguiente, se especifica un id. del conjunto de cambios para asociar al archivo bifurcado. Después de confirmar los cambios, el id. del conjunto de cambios del archivo bifurcado coincidirá con el valor especificado.

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

Ejemplo: Eliminar carpetas

Puede eliminar una carpeta de control de versiones utilizando el código siguiente, que llama a los métodos de PendDelete y de CheckIn . En este ejemplo se compila en el ejemplo de Add a File to Version Control y muestra cómo utilizar el modelo de objetos para eliminar una carpeta y luego para proteger ese cambio. Puede modificar el ejemplo de código para crear un archivo y reemplazar algunas líneas de código en ese ejemplo con el ejemplo siguiente. Después de aplicar los cambios, puede eliminar una carpeta de control de versiones.

Para utilizar este ejemplo

• Abra la aplicación de consola de C# que creó en el tema de Add a File to Version Control y, a continuación reemplaza el bloque interno intento del ejemplo original con el código siguiente:

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

Vea también

Conceptos

Ampliar Team Foundation

Otros recursos

Usar el control de versiones