It would be nice if you could just take a copy of the source files and remove the source control binding (in Visual Studio). Unfortunately I haven’t found a way to be able to do this. Even when Visual Studio says that all bindings have been removed, if you try to open up the solution you get an error message along the lines “The solution you are opening is bound to source control on the following Team Foundation Server …”

Under earlier versions of Visual Studio I had used Visual Source Safe for source control and had used a utility called VSSBindingRemover which did the job quite effectively. It removed all source control files with the solution and project directories and modified the solution and project files themselves to remove source binding information.

My search for a similar tool for Visual Studio 2012 / TFS resulted in a utility available on CodePlex called VSUnbindSourceControl.

The process for removing bindings is simple:

• Ensure you don’t have the solution/projects open in Visual Studio
• Copy your solution to a new directory (because the tool does modify files)
• Run the utility from the command line: VSUnbindSourceControl.exe d:\mysolution folder

Once the tool is finished, all the source control bindings have been removed from any solution and project files.

Grant Holliday has a good blog on using the test attachment cleaner to remove these big attachments – http://blogs.msdn.com/b/granth/archive/2011/02/12/tfs2010-test-attachment-cleaner-and-why-you-should-be-using-it.aspx

We used the tool to clean up a lot of database space. For preventing further growth of the database we also installed the hotfix (http://support.microsoft.com/kb/2608743) on all our build boxes.

The first part Trend Report shows how amount of work is changing for each «Support Section». We have capacity of 80 hours a month for each “Support section”.

The next part of the report is called Planning and Execution Quality:

• The report shows in hours:
  • Whether we do correct planning inside each support sections’ quotas (+-20%).
  • Whether we spend no more and not less hours for each section each month (+-20%).

We’re trying to spend exactly the promised amount of hours, as on the one side we have to support our business, but on the other side we have commitments to projects and have to meet deadlines. So it’s not good if we spend too little or too much time for each Support Section.

The next part of the report is called Move to production report. We cannot afford to keep tasks on the test or development environments for a long period of time; they must be developed, sent to test and moved to production ASAP (as soon as possible). Tasks that are not deployed can be cleaned off by environment restore, or they can block other tasks from implemented into production (if the same files were modified inside both tasks). This report is also used in addition to Aging report (http://borisfrolov.wordpress.com/2012/10/21/aging-report/) to get the complete picture of postponed requests.

• So this report shows how we move tasks to production in hours:
  • Active – tasks on all statuses except Finished, Tested, Closed.
  • Finished – tasks in status Finished, Tested.
  • Closed – tasks that were moved to production or cancelled.
• With the help of this report we can see if our work is not implemented into production environment.

Overview:

This course will provide an overview of the ‘Team Foundation Server 2012’. It will cover features and services of Team Foundation Server (TFS) 2012 including project management, source code control.

Duration: 2 Hour

Pre-Requisites for the course:

Participants should have

• Experience as Developers or Testers or project Leads and Project Manager

Course Contents

1. Visual Studio 2012 Overview                                                                                 1 Hour

2. Project Management features

• Introduction to the Project Management features
• Demonstration
  • Team Project Collection
  • Team Project Creation
  • Work item tracking
  • Traceability between work items
  • Agile Project Management features through Web Access
  • Team Portal
  • Reports
  • Storyboarding capabilities
  • Microsoft Feedback Client

3. Enterprise ready Source Code Control                                                    1 Hour

• Introduction to Enterprise ready Source Code Control
• Demonstration
  • Checkouts / Check-ins
  • Branch Visualization
  • Suspend and Resume
  • Check-in policies

Overview:

This course will provide an overview of the ‘Team Foundation Server 2012’. It will cover features and services of Team Foundation Server 2012 including project management, Version control, and team build.

Duration: 1 Day

Pre-Requisites for the course:

Participants should have

• Experience as Developers or Testers or project Leads and Project Manager

Course Contents

Day 1:

1. Visual Studio 2012 Overview

2. Project Management features

• Introduction to the Project Management features
• Demonstration
  • Team Project Collection
  • Team Project Creation
  • Work item tracking
  • Work item linking & hierarchy
  • Agile Project Management features through Web Access
  • Team Portal
  • Reports
  • Storyboarding capabilities
  • Microsoft Feedback Client

3. Enterprise ready Source Code Control

• Introduction to Enterprise ready Source Code Control
• Demonstration
  • Checkouts / Check-ins
  • Branch Visualization
  • Suspend and Resume
  • Check-in policies
  • Using the TFS Rollback command
  • Understanding Workspaces

4.  Team Build Features

• Introduction to Team Build features
• Demonstration
  • Configuring builds
  • Gated Check-in
  • Scheduling builds
  • Build agent pooling

5. TFS Report Features

• Introduction to TFS Report Features
• Demonstration
  • Built in reports
  • Accessing reports from various client tools

Overview:

This course will provide an overview of the ‘Team Foundation Server 2012’. It will cover features and services of Team Foundation Server (TFS) 2012 including project management, source code control, team build and reporting.

Duration: Half Day

Pre-Requisites for the course:

Participants should have

• Experience as Developers or Testers or project Leads and Project Manager

Course Contents

1. Visual Studio 2012 Overview

2. Project Management features

• Introduction to the Project Management features
• Demonstration
  • Team Project Collection
  • Team Project Creation
  • Work item tracking
  • Traceability between work items
  • Agile Project Management features through Web Access
  • Team Portal
  • Reports
  • Storyboarding capabilities
  • Microsoft Feedback Client

3. Enterprise ready Source Code Control

• Introduction to Enterprise ready Source Code Control
• Demonstration
  • Checkouts / Check-ins
  • Branch Visualization
  • Suspend and Resume
  • Check-in policies

4. Introduction to Team Build Features

• Introduction to Team Build features
• Demonstration
  • Configuring builds
  • Gated Check-in
  • Scheduling builds
  • Build agent pooling

Overview:

This course will provide an overview of the administration and configuration of ‘Visual Studio 2012’. It will cover introduction to VS 2012, Team Foundation Server (TFS) and VS 2012 administration namely installing and Configuring Microsoft Team Foundation Server, permission settings, creation of team project collection and team projects, configure Build and customize process template.

Duration: 3 Day

Pre-Requisites for the course:

Participants should have

• Experience using Virtual PC software, Visual Studio IDE, SharePoint Foundation, and SQL Reporting Services.

Course Contents

Day 1:

1.  Introducing Team Foundation Server 2012

• Overview of the Visual Studio 2012 family
• Overview of TFS architecture
• Installing and configuring TFS prerequisites
• Planning a TFS Deployment for different scenarios
• TFS 2012 Installation

2.  Migrating to TFS

• Overview of Migration Options
• Upgrading from previous versions of TFS
• Migrating from Visual SourceSafe

3.  Managing TFS instances

• Using the TFS Administration Console
• TFS Backup and Restore strategies
• Managing a TFS Instance
• Managing TFS Health and Availability
• Managing TFS service accounts

Day 2:

4.  Creating and managing Team Projects

• Creating Team Projects
• Understanding Team Project Collections
• Deleting Team Projects

5.  Managing Security and Permissions

• Overview of TFS security
• Configuring security using standard groups
• Understanding and configuring Teams
• Fine-grain security options
• Troubleshooting security

6.  Working with Work Items

• Overview of Work Item Tracking
• Creating custom work item queries
• Configuring alerts

7.  Source Control Configuration

• Create source control folder structures
• Setting team project wide source control settings
• Setup and manage workspaces
• Understanding branching and merging
• Using the TF command line utility
• Using the TFS Rollback command
• Backward compatibility using the MSSCCI provider

8.  Team Build

• Installing and configuring the Build Controller and Agents
• Understanding Build workflow
• Defining  and executing the Team Build

Day 3:

9.  Managing Process Templates

• Understanding project templates
• Basics of template customization
• Adding new fields to Work Item Types
• Adding new Work Item Types
• Adding new queries and reports
• Updating an upgraded Team Project

10.  Reporting

• Understanding the Reporting Architecture
• Adding new reports
• Creating ad-hoc reports using Excel
• TFS Warehouse and OLAP Cube overview

11.  Useful third party tools

• Power Tools
• Third party products

Overview:

This course will provide an overview of the administration and configuration of ‘Visual Studio 2012’. It will cover introduction to VS 2012, Team Foundation Server (TFS) and VS 2012 administration namely installing and Configuring Microsoft Team Foundation Server, permission settings, creation of team project collection and team projects, configure Build and customize process template.

Duration: 2 Day

Pre-Requisites for the course:

Participants should have

• Experience using Virtual PC software, Visual Studio IDE, SharePoint Foundation, and SQL Reporting Services.

Course Contents

Day 1:

1.  Introducing Team Foundation Server 2012

• Overview of the Visual Studio 2012 family
• Overview of TFS architecture
• Installing and configuring TFS prerequisites
• Planning a TFS Deployment for different scenarios
• TFS 2012 Installation

2.   Managing TFS instances

• Using the TFS Administration Console
• TFS Backup and Restore strategies
• Managing a TFS Instance
• Managing TFS Health and Availability
• Managing TFS service accounts

3.   Creating and managing Team Projects

• Creating Team Projects
• Understanding Team Project Collections
• Deleting Team Projects

4.   Managing Security and Permissions

• Overview of TFS security
• Configuring security using standard groups

Day 2:

5.   Working with Work Items

• Overview of Work Item Tracking
• Creating custom work item queries
• Configuring alerts

6.   Source Control Configuration

• Setup and manage workspaces
• Understanding branching and merging
• Using the TFS Rollback command
• Backward compatibility using the MSSCCI provider

7.   Team Build

• Installing and configuring the Build Controller and Agents
• Understanding Build workflow
• Defining  and executing the Team Build

8.   Managing Process Templates

• Understanding project templates
• Basics of template customization
• Adding new fields to Work Item Types
• Adding new Work Item Types

9.   Reporting

• Understanding the Reporting Architecture
• Adding new reports
• Creating ad-hoc reports using Excel

The report Hours Planned for Developers gives simple picture what workload developers have on each week:

• Whether there are hours that stay in the past.
• Whether developer does not have enough work to do
• Whether developer is overloaded

The report looks like the following:

The report is usually used together with Project Capacity report and they provide me with the full information of planning status in the team.

The last report is Triage report. This report is included in TFS 2008 pack, so I have just modify it a bit to fit my needs. The report shows how many tasks are not analyzed by IT (are not accepted by IT manager and do not have estimated number of planned hours).

We use the following control metrics:

• Not more than 5 Change Request must be triaged.
• Not more than 1 Error, 1 Support, 1 Data Edit and 1 Internal Request must be triaged.

This report helps me to have estimated amount of work in hours we have to do. So all reports that are based on amount of work we have to do are working correctly.

The next posts will be dedicated to planning and evaluation support process of existence systems.

Overview:

This course will provide an overview of the administration and configuration of ‘Visual Studio 2012’. It will cover introduction to VS 2012, Team Foundation Server (TFS) and VS 2012 administration namely installing and Configuring Microsoft Team Foundation Server, permission settings, creation of team project collection and team projects, configure Build and customize process template.

Duration: 1 Day

Pre-Requisites for the course:

Participants should have

• Experience using Virtual PC software, Visual Studio IDE, SharePoint Foundation, and SQL Reporting Services.

Course Contents

1. Visual Studio 2012 Overview

2. Installing and Configuring Microsoft Team Foundation Server (TFS)

• Planning a TFS Deployment
• Planning a TFS Installation
• Installing TFS
• Validating Installation
• Configuring TFS Components

3. Administering Team Foundation Server Instances and Team Projects

• Managing a TFS Instance
• Managing Team Projects
• Configuring Authorization and Security for TFS
• Managing TFS Users and Groups
• Managing TFS Health and Availability
• Managing TFS service accounts

4. Administering and Customizing Process Templates

• Exploring an Existing Process Template
• Customizing a Process Template
• Customizing Work Item Types

5. Administering Team Foundation Server Version Control

• Working with Team Foundation Version Control
• Advanced Functionality of Version Control
• Configuring Version Control Security

6. Administering Team Foundation Build

• Introducing Team Foundation Build
• Configuring Team Foundation Build Definitions
• Running a Team Build

Overview:

This course will provide an overview of the administration and configuration of ‘Visual Studio 2012’. It will cover introduction to VS 2012, Team Foundation Server (TFS) and VS 2012 administration namely installing and Configuring Microsoft Team Foundation Server, permission settings, creation of team project collection and team projects, configure Build and customize process template.

Duration: 1 Day

Course Contents

1. Visual Studio 2012 Overview

2. Installing and Configuring Microsoft Team Foundation Server (TFS)

• Planning a TFS Deployment
• Planning a TFS Installation
• Installing TFS
• Validating Installation
• Configuring TFS Components

3.  Administering Team Foundation Server Instances and Team Projects

• Managing a TFS Instance
• Managing Team Projects
• Configuring Authorization and Security for TFS
• Managing TFS Users and Groups
• Managing TFS Health and Availability
• Managing TFS service accounts

4.  Migration and Upgrade from older TFS version to TFS 2012

• Migrate\upgrade from TFS 2010 to TFS 2012
• Migrate\upgrade from TFS 2008 to TFS 2012
• Selecting a Disaster Recovery Plan for TFS (Back-up and Restore)
• Back and restore of individual Team Project Collection

About this Course:

This five-day instructor-led course provides candidates with the knowledge and skills to manage Microsoft Team Foundation Server 2012.  The course focuses on the technologies used in Team Foundation Server 2012 and the techniques used to deploy, manage and support Team Foundation Server 2012.

Audience Profile

This course is intended for novice experienced administrators with either a background in software development or a background in system administration.  This course is intended to provide administrators with knowledge to effectively manage and administer TFS 2012.

This course is not intended to provide developers with comprehensive knowledge covering how to use Team Foundation Server to support development, but instead provides administrators with the requisite knowledge to manage Team Foundation Server in a development environment

At Course Completion

After completing this course, candidates will be able to:

• Plan for and deploy Team Foundation Server.
• Manage Tam Foundation Server security and permissions.
• Configure and manage Team Foundation Server Build.
• Perform basic customization of Process Templates, work items and workflow.
• Support developers that use workspaces and shelvesets.
• Deploy Team Server Proxy.
• Backup, restore and monitor Team Foundation

This course contains Hands on Labs as well.

Duration: 5 Days

Course Contents

Day 1:

Introduction to Team Foundation Server Administration

This module introduces the candidate to the TFS administration process by explaining, in brief, the development process, how TFS supports a development environment and the role of the administrator in supporting the development process.  Application Lifecycle Management concepts will be explained and TFS specific terminology will be defined and explained. Candidates will be introduced to the responsibilities of administering TFS 2012

Lessons

• What is Application Lifecycle Management?
• Visual Studio and Application Lifecycle Management
• What is Team Foundation Server?
• Overview of the Development Process
• TFS Components and Terms
• Role of the Administrator in the Development Process
• TFS Administration Overview

Lab: Becoming Familiar with Hyper-V

• Candidates will be instructed in the use of Hyper-V and the corresponding lab images.

After completing this module, candidates will be able to:

• Describe the ALM Model
• Describe how TFS supports ALM
• Be able to identify the responsibilities and various tasks a TFS administrator performs in a development environment

Day 2 & 3:

Planning and Deploying TFS 2012

This module explains how to plan for, install and configure TFS.  Candidates will become familiar with the architectural requirements and options, installation steps and basic TFS topological and configuration options.  Instructors will cover the basic knowledge required to deploy TFS and supply foundational information that will be required for successful completion of other modules.

Lessons

• TFS Topologies
• Architectural requirements, Hardware considerations and Software considerations
• Networking requirements including firewall and ports
• Domain, Workgroup and Service accounts
• SQL Server and SharePoint requirements
• Topology considerations for small teams, single server, existing infrastructure or more than 1 server,      and server farms
• Planning for Version Control Proxy

Lab: Installing TFS

• Verifying IIS 7.0 is installed on Windows 7
• Preparing for Installing Team Foundation Server
• Installing SQL Express using the TFS Configuration Tool

Lab: Installing TFS

• Verifying IIS 7.0 is installed on Windows server 2008
• Preparing for Installing Team Foundation Server
• Installing SQL server 2008
• Installing and configuring TFS 2012 with Advanced option

After completing this module, candidates will be able to:

• Describe the various TFS Topologies
• Describe the architectural requirements, hardware and software considerations when planning to deploy      Team Foundation Server
• Plan for Domain and Workgroup service accounts for TFS
• Describe the SQL Server and SharePoint requirements for an effective TFS 2012 deployment
• Deploy TFS in a small environment
• Deploy TFS on a Single Server
• Describe the process for deploying TFS on various Topologies 

Configuration and Operations of TFS 2012

This module explains the basic principles of configuration and operation of TFS 2012.  Candidates will become familiar with the various TFS security groups and permissions, the practice of administering project collections and team projects, and the administrative knowledge required to support Build.  Candidates will also review administrative information on testing and configuring reporting and analysis services.

Lessons

• Default TFS Security groups and configuring permissions
• Managing team project collections and team projects
• Managing the TFS build System
• Configuring Reporting and Analysis Services 

Lab: Working with Team Project Collections and Team Projects

• Create a team project collection and team project
• Modify the root folder for report subfolders

Lab: Configuring Security and Permissions

• Configuring Security and Permissions
• Authorizing Access to a Team Foundation Server Projection
• Modifying SharePoint Services security
• Modifying SQL Server Reporting Services Security

Lab: Reconfiguring Reporting and Analysis Services

• Reconfiguring Reporting and Analysis Services

After completing this module, candidates will be able to:

• Work with TFS Security groups and TFS permissions
• Create and manage team project collections and team projects
• Manage the TFS build system
• Configure Reporting and Analysis services

Day 4:

Client Connectivity

This module covers the various clients that can be used to connect to Team Foundation Server 2012.  Candidates will connect to TFS 2012 with Team Explorer, Microsoft Office Excel 2012 and Team Web Access.  Candidates will review the different license requirements, different clients that can be used to connect to TFS and will be able to describe how to configure Visual Studio and Team Explorer for Team Server Proxy.

Lessons

• Client Connectivity License Requirements
• IDE Configuration for TFS Integration
• Team Explorer 2012
• Microsoft Office Connectivity
• Team Web Access
• Configuring Visual Studio and Team Explorer for Proxy Server
• Resolving TFS connectivity issues

Lab: Add Work Items Using Excel

• Add Work Items using Excel

Lab: Use Team Web Access to connect to TFS

• Use Team Web Access to connect to TFS

After completing this module, candidates will be able to:

• Describe the client connectivity license requirements
• Connect to Team Foundation Server using Team Explorer, Team Web Access and Excel
• Publish data to Team foundation Server using Excel
• Describe how to configure Team Server Proxy

Customization of Team Projects

This module explains how to customize team project workflow, work item features. Candidates will work with the Team Foundation Server Power Tools and modify the existing project workflow and work items.  Candidates will also create work item queries and modify work item templates.

Lessons

• Managing Work item Queries
• Customizing Work items and Workflow
• TFS Power tools
• Reporting

Lab: Working with Queries

• Creating a Query Folder, Subfolder and new Query
• Copying work Item Queries
• Renaming Work Item Queries
• Moving a Query 

Lab: Administering Work Items

• Create Add a new Work Item Type
• Create a New Global List
• Explore an existing process template
• Customize a process template
• Customize the fields of a work item
• Customize work item type

Lab: Setting up Alerts

• Setting up an Alert

After completing this module, candidates will be able to:

• Create, modify and manage Work Item Queries
• Create new Work Item Types
• Customize Work Items
• Create new Process Templates
• Create new global lists
• Setup alerts

Module 6: Administering Version Control

This module explains how to administer version control in Team Foundation Server.  Candidates will review the processes for managing workspaces, work with branching and merging, create shelve sets and discuss the 5 key scenarios for using shelvesets.

Lessons

• Managing Workspaces
• Administering Branching and Merging
• Managing Shelvesets

Lab: Administering Version Control

• Managing Workspaces
• Branching and Merging
• Version Policies and Settings
• Working with labels and Shelvesets

After completing this module, candidates will be able to:

• Create, modify and remove workspaces
• Describe what administrators need to know to administer workspaces
• Describe the use of cloaking and uncloaking folders
• Describe how to effectively manage workspaces
• Describe the effects branching and merging has on the server environment
• Describe the use of shelvesets and what administrators need to be aware of when working with shelvesets

Day 5:

Upgrading, Migrating, and Integration

This module covers the process of upgrading to Team Foundation Server, migrating data to Team Foundation Server and how to integrate Team Foundation Server with other Source Control systems.

Lessons

• Upgrading to TFS 2012
• Migrating to TFS 2012
• Visual Source Safe Migrations
• Integration with TFS

After completing this module, candidates will be able to:

• Describe the various methods for upgrading to TFS 2012
• Describe how to migrate to TFS 2012
• Describe the process for migrating from Visual Source Safe
• Describe integrating other systems with TFS 2012

Advanced Administration

This module explains several different advanced administration topics that expand on concepts covered in previous modules.  Candidates will review the process of installation validation, advanced management of TFS Application and Data Tiers, Rebuilding a warehouse, moving a TFS instance to a new server or new domain, and installing and configuring Team Foundation Server Proxy.

Lessons

• Validating an installation
• Manual configuration of SharePoint and reporting services post-installation
• Advanced management of TFS Application and Data Tiers
• Rebuilding the Warehouse
• Service Account management
• Version Control Proxy Deployment
• Fault Tolerant Solutions

Lab: Configuring Email Alerts

• Configuring SMTP for email alerts

Lab: Deploy and Configure a Version Control Proxy

• Deploy and configuring a Team Server Proxy

Lab: Deploy a new Build Controller

• Configuring a Build Machine
• Creating a Team Build

Lab: Deploy a new Application Tier

• Configuring a new Application Tier Server

After completing this module, candidates will be able to:

• Describe how to validate an installation
• Manually configure SharePoint and reporting services
• Deploy a new App-tier
• Deploy a new Build Controller
• Deploy and configure a Team Server Proxy
• Describe the various TFS Fault Tolerant Solutions

Backup, Restore and Monitoring TFS 2012

This module explains how backup and restore Team Foundation Server 2012 and the best practices for monitoring TFS 2012.  Candidates will review the various tools for monitoring TFS 2012 and will review the steps for backing up and restoring TFS in a disaster recovery situation.

Lessons

• Backing Up TFS 2012
• Restoring TFS 2012
• Monitoring TFS 2012

Lab: Monitoring TFS 2012

• Run the Best Practices Analyzer

After completing this module, candidates will be able to:

• Describe the process for Backing up and restoring TFS 2012
• Describe the various tools for monitoring TFS 2012
• Run the Best Practices Analyzer to monitor TFS 2012

Additional Reading

To help you prepare for this class, review the following resources:

• TFS Administration Guide
• TFS Installation Guide

Hereby I collected some editors which are available in .Net 4 or in TFS2010 assemblies. You can find some further help on usage below also.

“Built-in” Editors

These “out-of-the-box” editors can be used for your build arguments. They are part of TFS DLLs (and coming with Visual Studio), or part of .Net 4 framework.

File / Folder Browsing

* consider, that local pathes is not available from other computer obviously. For network pathes FQDN might be required dpending on network topolgy. Also enure sufficient permission to the build service user(s).

TFS Build Related Editors

Other Editors

Below editors (UITypeEditor child classes) are available in .Net4 – however I did not check whether they are really usable here or not (most probably you won’t need to specify a color for your build…). However you can try to get them worked, if you’d really like to.

Microsoft.TeamFoundation.Build.Controls.dll:
—–
Microsoft.TeamFoundation.Build.Controls.EnumPropertyEditor
Microsoft.TeamFoundation.Build.Controls.StringListEditor

System.Design.dll:
—–
System.ComponentModel.Design.CollectionEditor
System.ComponentModel.Design. BinaryEditor
System.ComponentModel.Design.DateTimeEditor
System.ComponentModel.Design.MultilineStringEditor
System.ComponentModel.Design.ObjectSelectorEditor
System.Windows.Forms.Design.FileNameEditor (+)
System.Windows.Forms.Design.FolderNameEditor (+)
System.Windows.Forms.Design.FormatStringEditor
System.Windows.Forms.Design.ImageIndexEditor (??)
System.Windows.Forms.Design.LinkAreaEditor
System.Windows.Forms.Design.MaskedTextBoxTextEditor
System.Windows.Forms.Design.MaskPropertyEditor
System.Windows.Forms.Design.ShortcutKeysEditor
System.Web.UI.Design.ConnectionStringEditor
System.Web.UI.Design.UrlEditor
System.Web.UI.Design.XmlFileEditor
System.Web.UI.Design.RegexTypeEditor
System.Web.UI.Design.SqlDataSourceQueryEditor

System.Drawing.Design.dll:
—–
System.Drawing.Design.ImageEditor
System.Drawing.Design.ColorEditor
System.Drawing.Design.ContentAlignmentEditor
System.Drawing.Design.CursorEditor
System.Drawing.Design.FontEditor
System.Drawing.Design.FontNameEditor
System.Drawing.Design.IconEditor

System.Workflow.Activities.dll:
—–
System.Workflow.Activities.WebServicePickerEditor
System.Workflow.Activities.StateDropDownEditor
System.Workflow.Activities.ImageBrowserEditor
System.Workflow.Activities.LogicalExpressionEditor

 Need more?

Oshry Horn explained in his blog, how to find further editors.

How to Use Custom Editors for Arguments?

There are two ways of doing this. One is to specify the editor for your property in the class definition with the EditorAttribute attribute:

public class MyClass {

  [Editor("Microsoft.TeamFoundation.Build.Controls.ServerFolderBrowserEditor," +
          "Microsoft.TeamFoundation.Build.Controls", typeof(UITypeEditor))]

  public string MySeverPath{ get; set; }
  // ...

}

The second way is if you specify a custom editor in the Metadata build workflow property. It is desribed in many blogs and books:

• TFS Build: using the built-in editors (Bart Wullems)
• Customize Team Build 2010 – Part 6: Use custom type for an argument (Ewald Hofman)
• Wrox’s Professional Team Foundation Server 2010 book (Chapter 16: Customizing The Build Process, Specifying Metadata, Page 392)

Write Your Own Editor

You can find pretty good example e.g. in Wrox’s Professional Team Foundation Server 2010 book (Chapter 16: Customizing The Build Process, Custom Editor Parameters, Page 394)  or in Ewald Hofman’s blog. Therefore I don’t repeat them here.

Just created report looks like follow:

In the column Person – the name of the developer, and in the column Review date the number of tasks that are proposed to be aged.

You can expand each developer and go to the list of tasks:

The report’s logic is based on the Pending Status bar of the Work Item.

Our team’s internal process of filling these fields is described below.

• When the task is assigned to developer and got Finished Date, the fields Review Date and Responsible are filled automatically from Finish Date and Assigned To fields accordingly.
• The Planning Manager has to set these fields manually to all new tasks that are not planned to be closed in several days.
• So responsible person has to assign this task till Review Date, or to prepare design and return the task to Planning Manager, or communicate with business to clarify something etc.

So the logic of report is the following:

• When Review date is missing more than 10 days – the tasks appears in the report.
• When Review date is missing more than 30 days – the task becomes red.

Also, team members can put down comments about why task dates are missed and what are the next steps to fix this situation. This simplifies communications with managers and saves time preventing every week refreshing of each task issue.

With the help of Aging Report I can see if we have problems with testing, if task cannot be deployed for a long time, or if task is not assigned to a developer. But its main advantage lies in the ability for developers themselves monitor their work items and take actions before tasks go red.

So it’s very useful. )))

Build Reason values

Build Reason is stored in an Enum with FlagsAttribute - so many values can be selected at he same type. There are some combination already set up as values.

Ok.. but what values shall I get when I start a build?

How to use Build Reason in the build workflow

• You can find the build reason in the BuildDetail variable of the default workflow.
• If you have something special, you can get this object with the GetBuildDetail activity, which returns with an IBuildDetail  instance, which has it in its Reason property.
• You can simply use the InvokeForReason activity if you want to execute some activities for some specific build reasons only.

Effects of the Build Reason

I have not tried all, just collecting the usages and side effects of it…

- In the default build process, the Drop Folder is not created, when the BuildReason is ValidateShelveset or None, even if droplocation is specified and Copy Outputs to Drop Folder is true. In other words, if you just build a shelveset, then it won’t have any drop folder, even if you are trying to write log file into it. (Obviously you can align your wokflow to solve this…)

If you are familiar with Microsoft Project and Gantе chart you will find much common between this tools and Task Capacity report, which looks like the following:

• The report spreads tasks the same way as Microsoft Project does:
  • It starts from the Planning date (Finish Date),
  • Checks how much percent of time developer must spend on this task (special field Units in Work Item)
  • If field Units is not filled, it considers the value is equal to 80%.
• Calculates hours for each day and each active task on developer.

As the result we have clear picture who is overloaded and who does not have enough workload. Why not to use MS Project for such activity? Because we have separate file for each project and it’s impossible to get whole picture in one place. And MS Project Server is rather expensive for start and support; also it will be too much for us. We are not so large team to have need for so complex and universal tool.

That’s why in order to have all developers’ workload in one place I decided to create this report, and I can say it works great. Now, to clarify how report works, I would like to post example of calculations:

• Developer has two tasks assigned to him (let say today is 18/07/2012):
  • Task 1: 16 hour task with finish date – 21/07/2012 and Unit does not filled (so report consider it 80%).
  • Task 2: 10 hour task with finish date – 19/07/2012 and Units = 50%.

• All cells that have value more than 8 hours or have values in the past – are marked as red.
• All hours in the past are summarize in one yesterday cell.
• If you click on any cell – the specification report will open, in which you would see the list of tasks that have created the day sum.

So there is one thing that is needed to make report works – somebody must fill units for all new tasks. In my team we have the following process:

• Planning manager on everyday basis checks all tasks assigned to developers that have not filled Units.
• Based on Scenario information and Business Priority of each task, he fills empty Units.

As there are no more than 5-10 tasks assigned each day in average, this activity takes no more than 2-3 minutes every day. Also great that TFS gives us possibility to do such work in MS Excel, so it’s quite easy. So it is not much for the report that gives me the possibility in one look see the current workload of my team.

(There are also many articles about this topic… I don’t want to repeat them – you can find links for some of them at the bottom.)

Project structure

Activities and Controls

Usually it is a good practice to keep the things together, and put your classes (activities, controls, argument classes) into a single assembly. Obviously in some cases it is not possible, or not preferrable – but in many cases makes your (and the config manager’s ) life easier. It is also elminates the issue of not loading an assembly when it is necessary.

However it is also a good practice to separate classes based on their function and level – so you can do it with namespaces. I’m using the below namespaces currently in order to separate my classes:

• MyProject
• MyProject.Controls
• MyProject.Activities
• MyProject.ViewModels

An exception is the assembly with the unit tests – obviously it is separated into another DLL, as it won’t get deployed to the productive TFS server.

Adding the Build Template (XAML)

Create a separate project (simple windows library) for the XAML files. (If it is in the same project as your activities, then VS may forgot to include the assembly explicitly when you import the namespace to the xaml. However don’t forget to add the required TFS and project references to the workflow project.

You can set the Build Action property of the xaml file to XamlAppDef – then VS will try to interpret it during the build, and may drive your attention to some error during the local build.

How the activity should look like

I will write details about the build activity types and their usages later on.

Testing and Debugging

Yes. The build runs on the Build Controller/Build Agent and not on the developer’s PC. To set up server environment on the dev PC might be too complex, sometimes maybe impossible, and testing on the server directly is not the most convenient way – but don’t worry, there are other possibilities also.

Unit Tests

Unit Tests are supported in most VS editions (if not in all). It runs locally, and can be debugged pretty easy. This can be automated also, so you can reuse your unit test to ensure that your code is always working. So let’s call your custom activity from a unit test, and mock the surrounding environment (or create a test environment). You can use the WorkflowInvoker for this.

        using Microsoft.VisualStudio.TestTools.UnitTesting;
        // ...

        [TestMethod]
        public void MyActivitytest()
        {
            var testObject = new object();
            var activityInputArguments = new Dictionary<string, object>
                                {
                                    {"Argument1", "Value1"},
                                    {"Argument2", testObject }
                                };
            var activityOutputArguments = WorkflowInvoker.Invoke(new MyCustomActivity(), activityInputArguments);

            var res = activityOutputArguments["Result"] as MyResultClass;

            Assert.IsNotNull(res, "Activity returned with null result.");
            //...
        }

Remote Debugging

Run a remote debugger (msvsmon.exe) on the Build Controller/Build Agent, and attach your Visual Studio to the remote TFS service process: TFSBuildServiceHost.exe. Then you can debug your code directly. Howevere unfortunatelly it does not always work, and may not stop at your breakpoint. (Any further suggestion, experience is welcomed.)

Old Times Are Back – Debug messages

When there is no other way you can use the old-style – add debug and trace output to your workflow/activity.

• On activity level you can simply use the out-of-the box WriteBuildMessage, WriteBuildWarning, WriteBuildError or WriteBuildInformation<> activities, which will write the output to the build log (according to log verbosity).
• On code level you can call the context.TrackBuildMessage(), TrackBuildWarning() and TrackBiuldError() methods:

using Microsoft.TeamFoundation.Build.Workflow.Activities;

public class MyCustomActivity : CodeActivity
{
    protected override void Execute(CodeActivityContext context)
    {
        // ...
        context.TrackBuildMessage("My build message");
        // ...
    }
}

Signing Custom Assemblies

When you sign your custom assembly (and check in to the custom assemblies folder…), you might receive the below error message:

TF215097: An error occurred while initializing a build for build definition \MyProject\MyBuild: Cannot create unknown type ‘{clr-namespace:MyProject.Activities;assembly=MyProject}MyTestActivity’.

Well. fancy message, and there is no other trace usually to pick up the root cause. If you google the error code (TF215097), you will find plenty of pages, where several scenarios are described with the same error code. A reason behind this in this case, that the assembly is not linked properly from your build template xaml. If you have a strong-named assembly, then you need to specify the assembly properly, including version number and the public key token.

The proper syntax in the xaml file is below:

<Activity  ...
  xmlns:mpa="clr-namespace:MyProject.Activities;assembly=MyProject, Version=1.0.0.0, Culture=neutral, PublicKeyToken=123456789abcdef0"
  ... >

After doing this, the build should work.

How custom DLLs are loaded

Hehh.. Maybe not as you’d expect… Assemblies are seached in the below order:

• Specified CustomAssemby Path (on Build controller)
• Visual Studio’s PrivateAssemblies folder
• Global Assembly Cache

When you run the build, TSF loads all the assemblies from the CustomAssemblies folder, that contains activity in the specific HostEnvironment. Other assemblies from the CustomAssemblies folder might be not loaded at all!

Assemblies from PrivateAssemblies folder and GAC can be loaded on-demand.

Best practice: custom build assemblies should be kept in CustomAssemblies folder, and not in e.g. GAC. Otherwise the maintenance of these assemblies will be more complex (e.g. you have to deploy your DLLs to each build controllers/agents separately, although when it is kept in CustomAssemblies folder, they will be updated automatically for all build servers).

Troubleshooting

Sometimes you may see, that locally everything is fine, however the build server does not work as expected. In this case this checklist can help to find, what has been dropped out of the “deployment workflow”:

• Always ensure that your workflow (xaml) and custom DLLs are checked in
• Ensure that the custom assembly folder has been set up properly on the build controller
• Ensure that assemblies are referenced properly in your xaml (with version and public key token for signed assemblies)
• Ensure that no older copy exists in the GAC and/or in VS PrivateAssemblies folder

Also you may experience, that sometimes an assembly is just cannot be loaded from the CustomAssemblies folder, although it is referenced properly from xaml. In such case defining a dummy activity in the assembly with attribute [BuildActivity(HostEnvironmentOption.All)] may solve the problem.

References

Here comes some pretty good articles about the topic.

• http://www.ewaldhofman.nl/post/2010/04/20/Customize-Team-Build-2010-e28093-Part-1-Introduction.aspx
• http://msmvps.com/blogs/rfennell/archive/2010/03/08/lessons-learnt-building-a-custom-activity-to-run-typemock-isolator-in-vs2010-team-build.aspx

Use Visual Studio 2010 instead. Visual studio 2012 won’t let you configure the build template. Adding projects to build in “Items to build” At process section will bombs up with “Property value is invalid” message. Changing the “Configurations to build” will throws up an “Unable to cast object of type ‘Microsoft.TeamFoundation.Build.Workflow.Activities.PlatformConfigurationList’ to type ‘System.Collections.Generic.List\1[Microsoft.TeamFoundation.Build.Workflow.Activities.PlatformConfiguration\].” error.

2. Change ”Copy outputs to drop folder” to false in Build Process Template if necessary.

If you choose not to copy output files to a drop folder in “Build Defaults” section (untick “This build copies output files to a drop folder”, do not forget to change the value of “Copy outputs to drop folder” in Process-Advanced as well. Otherwise, your build will failed with a “TF270006: The drop location for this build was empty. The build definition ‘NrwManualBuild’ (or the build request) must specify a valid UNC path as the drop location for the build. Update the build definition and try again.” message.

3. Change MSBuild version to x86

Sometimes, build process will fail and complains that it could not find Silverlight 4 SDK and you are 100% sure that you’ve installed this in the build machine. Change the MSBuildPlatform in Process-Advanced to x86.

4. Edit project file for all projects that configured with RIA Link.

If you have a problem with the build bombing out in the RIA’s auto generated files, it is because the build server somehow ignored the build order of the solution. To solve this:

add this to the <Project tag

“InitialTargets=”CustomWorkaroundBuildOrderBug”

then add this after last property group and before first item group :

<Target Name="CustomWorkaroundBuildOrderBug">
  <ItemGroup>
    <ProjectReference Include="..\X.Web\X.Web.csproj">
      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
    </ProjectReference>
  </ItemGroup>
</Target>

5.Remove all items from Silverlight applications’ tab in the web project’s setting.

If your build process fails because it complains that it can’t copy xap files, try to remove all items from Silverlight applications tab in the web projects’ setting. After doing this, make sure that you copy the file manually after building all the xaps:

<Copy SourceFiles="$(SolutionDir)"
<Project>
  \bin\$(Configuration)\$(XapFilename)"
  DestinationFolder="..\<WebProject>
    \ClientBin"
    Condition="Exists('$(SolutionDir)<Project>\bin\$(Configuration)\$(XapFilename)')"
/>

In web project, comment all the include tag like this one:

<Content Include="ClientBin\<fubar.xap>"  Condition="$(IsRelease) == true"  />

This is a massive hack (i.e would love to know if anyone else found a better way to do it). This will cause the xap file not to be copied if you click right on “Publish”. You can either do it manually or configure publishing profile.

I ended up making the build server to always build in “Debug” configuration and (obviously) release in “Release configuration” and change the include tag to :

<Content Include="ClientBin\<fubar.xap>"  Condition="$(IsRelease) == true"  />

· Defect management

· Excellent documentation skills including technical and functional documentation

· Knowledge of testing methodologies

· SDLC Process Knowledge

· Understanding of Release Engineering

· Code Testing including Unit Testing, UI Testing, Integration Testing

· Excellent English communication

Matric

· Degree/Diploma in IT

· 3+ years working experience in:

o Code Testing including Unit Testing, UI Testing, Integration Testing

o Release Engineering advantageous

· Understanding of C#

· Software Testing ISEB certification advantageous

· WPF and WCF services

· Windows WF Foundation

· Comfortable working with:

o Visual Studio 2010 Premium

o Microsoft’s CUIT (Coded User Interface Tests)

o MS Test

o Team Foundation Server (TFS)

Ownership and passionate about high quality software development

· High sense of urgency

· Team player

· Sense of humour

To apply for this position, click here:

Pré requis :

Systèmes d’exploitation: Windows 7 (x86 et x64), Windows 8 Release Preview (x86 et x64), Windows Server 2008 R2 (x64), Version finale candidate de Windows Server 2012 (x64).

Architectures : 32 bits (x86), 64 bits (x64).

Configuration matérielle : Processeur 2,2 GHz minimum, 1 Go de mémoire vive (RAM), 4 Go d’espace disque disponible.

Lien : http://www.microsoft.com/fr-fr/download/details.aspx?id=29919

Note :

1. Il est important d’installer le Service Pack 2 afin d’obtenir les mises à jour relatives à « Sql Server », ou bien réaliser un « Windows Update ».
2. Il est aussi important de lancer l’installation en tant qu’administrateur du poste.

Configuration

Une fois l’installation terminée, il est primordial de configurer le serveur.

Lancer la console d’administration

Sélectionner « Configure Installed Features » pour lancer l’installation.

Sélectionner « Start Wizard » pour lancer l’assistant de configuration.

Le serveur doit être installé avec les credentials de l’administrateur.

Sélectionner « Configure ».

Configuration du service de Build

Le service de « Build » est définit par rapport à la collection de projet : « defaultCollection ».

Il est important de sélectionner l’agent de « Build » permettant de construire l’application sur le serveur « Team Foundation » et le « controlleur de Build ».

L’agent de « Build » exécute les étapes de votre processus de construction qui sont contenues dans l’activité « AgentScope ». En règle générale, ces mesures comprennent les fichiers du contrôle de version, le pro-visionnement de l’espace de travail, la compilation du code, l’exécution des tests, et la fusion dans le contrôle de version.

Chaque agent de « Build » est piloté par un contrôleur, comme bonne pratique l’agent de « Build » est déployé sur un autre serveur.

Dans la console d’administration, vous pouvez accéder aux journaux de traçage pour parcourir le détail des différentes phases d’installation et de configuration.

Pour l’instant les environnements virtuels dédiés à  « Microsoft Test Management », n’ont pas encore été installés.

Some key moments of this type of planning are:

• The planning process consists of two parts:
  • Everyday activity of planning manager, to review current state of work, re-plan tasks that were overdue, to analyze new tasks from business and IT. Takes about 1.5 hours every day.
  • Weekly activity for detailed planning of what we have done during the week and assigning requests to developers for two week period. Takes 2-3 hours of work of planning manager and 1.5 hour of application leads to discuss results, review scenarios and make some corrections.
• For planning of projects’ activities we use Microsoft Project, so there is no need of additional tools for planning. But reports listed further can also be used to track whether we do correct planning process in Microsoft Project. We use a list of reports that shows the current project state, but they will be described in the next posts, when I come to projects’ planning.

So, the first point I have to start with – is Daily Management. My team is doing it on a whiteboard for the following reasons:

• We have a place where we’re gathering each morning and discuss what was done, who has perform yesterday’s plan, and who has not and why.
• Also we discuss everybody’s plan for today.
• We can make corrections immediately during the meeting. If we use monitor – we would not have such possibility.

The whiteboard is looks like the following:

The main features are:

• Tasks that were planned and where performed are marked in black.
• Tasks above plan – are marked as green (or if developer has done the task faster as it was planned).
• Tasks that were planned but were not done – are marked as red. And developer has to put down reasons why daily goal was not achieved.
• We also use colored points to mark project tasks. So it is very easy to see in what project the developer is participating.
• The everyday team meeting takes 5-10 minutes, but not longer than 15 minutes.
• We also have a whiteboard that indicates current statuses of all active projects, but I will return to it while posting about projects management.

To fill the whiteboard the planning manager of my team uses two reports: one that shows planned tasks for each developer and other that shows yesterday plan. Using these reports, it takes about 20 minutes for planning manager to fill all needed information on the whiteboard. Main features of these two reports are:

• These reports are very detailed and used only for Daily management purposes.
• They directly show what information must be put on whiteboard.

Report that show plan for the nearest future:

Report that show what was done yesterday: