Dans l'écran "Reporting Service" indiquer le serveur de rapports et les URL
Dans l'écran "Sharepoint" cochez la case pour configurer SharePoint pour TFS
Dans l'écran "Setting" vérifier les informations de connection à WSS si comme moi vous aviez installé WSS avant TFS. Cela permet également de ce connecter sur un MOSS.
Dans l'écran "Project Collection" indiquez la collection de projets que vous souhaitez. Ceci est une nouveauté et me sera personnellement très utile. 
Une fois vérifié vous pouvez lancer la configuration, nous ne parlons pas d'installation mais bien de configuration. Pour l'installation voyez l'article de Florent.
Dans la Leçon 2 nous avions vue comment récupérer des éléments (fichiers, répertoires) dans TFS pour un projet donné.
Dans cette leçon, nous allons voir comment mettre ces éléments dans un TreeView.
Etape 1 : Création du TreeView
Rien de bien compliqué.
| TreeView trvItem = new TreeView(); |
Etape 2 : Création d'une méthode de base
Nous allons créer une première méthode que l'on pourra appeler de n'importe où.
Elle prend 3 arguments:
| private void GetAllItem(VersionControlServer vcs, string path, TreeView trvItem) { GetAllItem(vcs, path, trvItem.Nodes.Add("$")); } |
Etape 3: Création d'une méthode récursive
Méthode récursive permettant de parcourir niveau par niveau les éléments.
| private void GetAllItem(VersionControlServer vcs,string path,TreeNode trnParent) { |
Code Complet :
| TreeView trvItem = new TreeView();
private void GetAllItem(VersionControlServer vcs, string path, TreeView trvItem) { GetAllItem(vcs, path, trvItem.Nodes.Add("$")); } private void GetAllItem(VersionControlServer vcs,string path,TreeNode trnParent) { //Récupération des éléments du niveau en cours //Utilisation de RecursionType.OneLevel pour n'avoir que le niveau en cour //Cela permet de connaitre la hiérarchie ItemSet itemSet = vcs.GetItems(path, RecursionType.OneLevel); //Parcour des éléments trouvé foreach (Item item in itemSet.Items) { //Vérification du type d'item //Un répertoire peut avoir des sous éléments mais pas un fichier if (item.ItemType == ItemType.Folder) { //Ajout du noeud en cours TreeNode trn = trnParent.Nodes.Add(item.ServerItem.Replace(path, string.Empty)); //Récursion sur la méthode pour la récupération des éléments GetAllItem(vcs, item.ServerItem, trn); } else { //Pour un fichier ajout du noeud trnParent.Nodes.Add(item.ServerItem.Replace(path, string.Empty)); } } } |
Pour ajouter un fichier ou plusieurs il est nécéssaire de passer par VersionControlServer (Voir Leçon 2).Workspace workspace = versionControl.CreateWorkspace(Guid.NewGuid().ToString(), versionControl.AuthenticatedUser); |
| workspace.Map(Target, tmp); |
| workspace.Get(); |
| workspace.PendEdit(fileTarget); |
| workspace.PendAdd(fileTarget); |
| File.Copy(_s, fileTarget, true); |
| workspace.PendAdd(fileTarget, (Recursion == RecursionType.Full)); |
| PendingChange[] pendingChanges = workspace.GetPendingChanges(); |
| foreach (PendingChange pendingChange in pendingChanges) { Console.WhritLine(" path: " + pendingChange.LocalItem + ", change: " + PendingChange.GetLocalizedStringForChangeType(pendingChange.ChangeType)); } |
| int changesetNumber = workspace.CheckIn(pendingChanges, Description); |
Team Foundation Server permet de gérer le code source d'une application (Projet) et son historique.
Que représente l'historique ?
Ligne de temps d'un projet
--------------->--------------------->----------------->------------------>------------------------>------------------------>-------...
Initialisation du projet | Modification du code n°123 | Modification du code n°127 | Modification du code n°168 | Modification du code n°201 | Modification du code n°309 |
Chaque modification de code se nomme "ChangeSet". A chaque archivage de code d'un développeur un "ChangeSet" est créé avec l'ensemble des éléments qui ont été modifiés.
Les API de TFS permettent de récupérer les fichiers qui sont donc les stocker dans le contrôler de version et leurs modifications.
Etape 1: Les "USING"
Pour utiliser les éléments il faut les using suivant:
using Microsoft.TeamFoundation.Client; using Microsoft.TeamFoundation.VersionControl.Client; |
Etape 2: Connexion au contrôler de version
Pour la connexion au serveur veuillez voir la leçon 1.
L'objet "Tfs" est l'objet TeamFoundationServer permettant la connexion au serveur.
VersionControlServer vcs = (VersionControlServer)Tfs.GetService(typeof(VersionControlServer)); |
La méthode "GetService" de l'objet "TeamFoundationServer" permet de récupérer un type de service. Nous verrons dans les prochaines leçons qu'il existe plusieurs services possibles. Dans le cadre de cette leçon nous nous pencherons sur le service "VersionControlServer" permettant de travailler avec les éléments (fichiers, répertoires, historique…).
Etape 3: Récupérer les éléments d'un projet
"VersionControlServer" contient une méthode nommé "GetItems" qui permet la récupération des éléments. Elle prend deux paramètres, un chemin (Ex: $/MonProjet) et un type de recrutions (Ex: RecursionType.Full), Full permet de récupérer l'ensemble des éléments de tous les répertoires et sous-répertoires.
| ItemSet itemSet = vcs.GetItems("$/MonProjet", RecursionType.Full); |
Tout chemin doit commencer par "$/" c'est comme pour le disque dur qui lui commence par exemple par "C:/".
L'objet "ItemSet" contient une collection d' "Items" qui représente chaque élément.
ATTENTION, si vous utilisez l'argument "RecursionType.Full" les items ne sont dans récupérés avec cette notion de hiérarchie.
Exemple :
Si dans mon contrôler de version j'ai :
$/MonProjet/ ----------------DEV/ ----------------------Fichier.cs ----------------------Image.jpg ----------------DEV2/ ----------------------Fichier2.cs ----------------------Image2.jpg |
Ma collection d' "Items" pourrais être représenté de cette manière:
Items[0].ServerItem = $/MonProjet/ Items[1].ServerItem = $/MonProjet/DEV/ Items[2].ServerItem = $/MonProjet/DEV/Fichier.cs Items[3].ServerItem = $/MonProjet/DEV/Image.jpg Items[4].ServerItem = $/MonProjet/DEV2/ Items[5].ServerItem = $/MonProjet/DEV2/Fichier2.cs Items[6].ServerItem = $/MonProjet/DEV2/Image2.jpg |
Vous l'aurez compris la propriété "ServerItem" permet de récupérer le nom et chemin de l'item. Mais cela ne nous permet pas de récupérer facilement, sous forme de treeview par exemple, le contenu de notre projet. Nous verons dans la prochaine leçon comment faire.
Dans ce cas de figure il n'est pas facile de savoir ce qui est un fichier et ce qui est un répertoire. Pour ce faire un item contient également la propriété "ItemType" permettant de le savoir.
Etape 4 : Récupérer l'historique d'un fichier.
Dans l'exemple suivant nous allons récupérer l'historique du fichier
IEnumerable cs = versionControl.QueryHistory("$/MonProjet/Dev/Fichier.cs", VersionSpec.Latest, 0, RecursionType.Full, null, null, null, Int32.MaxValue, true, true);
foreach (Changeset c in cs) { if (c.Changes.Length > 0) { foreach (Change ch in c.Changes) { Item i = ch.Item; ChangeType t = ch.ChangeType; if (t == ChangeType.Add) MessageBox.Show("Fichier ajouté"); } } } |
Connextion au serveur via l'instance:
| TeamFoundationServer monTFS = TeamFoundationServerFactory.GetService("http://TFS:8080"); |
Cette méthode récupére l'instance du serveur en cours.
Il est possible de s'authentifier, pour ce faire soit il faut passer un objet ICredentialsProvider soit affichier la fenêtre d'authetification.
| TeamFoundationServer monTFS = TeamFoundationServerFactory.GetService("http://TFS:8080", new UICredentialsProvider()); |
Instanciation d'un objet TeamFoundationServer.
| TeamFoundationServer monTFS = new TeamFoundationServer("http://TFS:8080"); |
Il est également, comme dans la première manière, possible de s'authentifier. Pour ce faire soit il faut passer un objet ICredentialsProvider soit affichier la fenêtre d'authetification.
| TeamFoundationServer monTFS = new TeamFoundationServer("http://TFS:8080", new UICredentialsProvider()); |
Conseil : Par rapport à des projets j'ai préféré la 2 manière.
