Professional Visual Studio 2005 (2006) [eng]

Chapter 56

1.Start by creating a new Class Library project. The name of the project is not important, as it is not displayed when the rules are integrated into the IDE.

2.To access the code analysis information in your code, you need to add references to both the FXCop SDK library (FxCopSdk.dll) and the Microsoft.CCI library (Microsoft.Cci.dll). These are both found at C:\Program Files\Microsoft Visual Studio 8\Team Tools\Static Analysis Tools\FxCop.

3.For each code analysis rule you want to create, you need to add a class to your project. For example, you might want to have a rule that issues a warning when a method has more than 100 instructions, which would make it a good candidate for refactoring, so you might call the class LongMethod. Again, the name of this class is not important, as it is not displayed in the IDE.

4.The code analysis rule class needs to inherit from the BaseIntrospectionRule class and override one of the base methods — for example, the Check method, which is used to check a particular aspect of the library being analyzed.

5.The code analysis rule class also needs to implement a zero parameter constructor that calls the base class constructor, passing in the name of the rule class, the name of an XML resource descriptor file, and the assembly in which the rule class and XML resource file reside. The following example uses runtime information about the rule class, instead of strings, to make sure that any future changes to the assembly don’t break the functionality:

Imports Microsoft.Cci

Imports Microsoft.FxCop.Sdk

Imports Microsoft.FxCop.Sdk.Introspection

Imports System

Imports System.Globalization

Public Class LongMethods

Inherits BaseIntrospectionRule

Private Const cMaximumInstructions As Integer = 100

Public Sub New()

MyBase.New(GetType(LongMethods).Name, _

“NicksRules”, GetType(LongMethods).Assembly)

End Sub

Public Overrides Function Check(ByVal m As Member) As ProblemCollection ‘Check to ensure that this is a method Check

Dim mthd As Method = TryCast(m, Method) If (mthd Is Nothing) Then

Return Nothing End If

‘Check how many instructions this method has

If mthd.Instructions.Length > cMaximumInstructions Then ‘Add issue to the problems collection

Dim outputArray As String() = New String() _ {RuleUtilities.Format(m), _ mthd.Instructions.Length.ToString _

(CultureInfo.CurrentCulture), _ cMaximumInstructions.ToString(CultureInfo.CurrentCulture)}

MyBase.Problems.Add(New Problem(MyBase.GetResolution(outputArray))) End If

826

Visual Studio Team System

Return MyBase.Problems

End Function

End Class

6.In this example, we have made reference to an XML resource file called NicksRules.xml (the

.xml is omitted in the base constructor because it is inferred by the runtime engine). To ensure that your rule appears in Visual Studio 2005, you need to include NicksRules.xml as an embedded resource file in your project. The easiest way to do this is to include a file called NicksRules.xml in the project and set its Build Action to Embedded Resource.

Two words of caution here: First, if you have a default namespace specified in your project settings (such as SampleApplication), then the embedded resource will be SampleApplication

.NicksRules.xml. String matching is used to retrieve the XML resource file based on the resource name in the constructor, so in this case an error will be thrown, as the resource could not be located. Two solutions are possible: Either remove the default namespace or add the default namespace to the resource name in the constructor. Second, the XML file must end with Rules.xml, and this is case sensitive. If the XML file does not end with this string, the rules assembly will not be loaded correctly into Visual Studio 2005.

7.The XML resource file is made up of a list of the rules defined within the rules assembly. The first element in the XML block is the Rules tag. This denotes the category in which the rules will appear on the code analysis page within Visual Studio 2005. In the following example only a single code analysis rule is declared within the “Nicks Rules” category. Additional rules can be added by repeating the Rule XML block:

<?xml version=”1.0” encoding=”utf-8” ?> <Rules FriendlyName=”Nicks Rules”>

<Rule TypeName=”LongMethods” Category=”RefactorAlerts” CheckId=”RA1000”> <Name>Long methods are bad</Name>

<Description>Methods that are longer than 100 lines should most likely be refactored</Description>

<Owner>Nick Randolph</Owner> <Url></Url>

<Resolution>’{0}’ has {1} instructions. Refactor ‘{0}’ so that it calls fewer than {2} instructions.</Resolution>

<Email>nick@randomemail.com</Email>

<MessageLevel Certainty=”95”>Warning</MessageLevel> <FixCategories>NonBreaking</FixCategories>

</Rule>

</Rules>

Each rule needs to reference a Rule class using the TypeName attribute. The name of the Rule class specified in the XML file must match the class name exactly, including case. All the other attributes and elements of the rule are used to determine how the rule appears in Visual Studio. The CheckId and the Name appear in the code analysis window, while the Category, Description, and other attributes are used in the Error List window, as shown in Figure 56-35.

Figure 56-35

827

Chapter 56

8.The last thing to do is build the project and copy the Class Library assembly to the code analysis rules folder at C:\Program Files\Microsoft Visual Studio 8\Team Tools\Static Analysis Tools\FxCop\Rules. This automatically registers your code analysis rules within Visual Studio 2005 the next time it is loaded.

Customizing the Process Templates

Visual Studio Team System supports two models of extensibility. The first is geared toward third-party tools that integrate with and provide additional services to the development process. These make use of the core services provided by Team Foundation. The second model is the capability to customize the process to suit the way that a particular development team is organized. Although Microsoft has tried to provide a one-size-fits-all set of process templates, a development team will likely want to tweak the process, even if it is to change the terminology that is used. In this section, you’ll see how easy it is to take the process templates that ship with Visual Studio 2005 and export them, make changes, and then import them as a new process template.

The first step in customizing an existing process template is to export the process to a working folder by clicking Team Team Foundation Server Settings Process Template Manager. This opens a dialog similar to the one shown in Figure 56-36.

Figure 56-36

In earlier versions of the product, the buttons were labeled Import and Export, rather than the less obvious Upload and Download. This terminology reflects the process by which an existing process template can be downloaded from the server to a working folder. After changes have been made, the template can be uploaded to the server as a new process template. To make changes, select the MSF for Agile Development option and click Download. This prompts you to select a folder to which you can download the process template.

Figure 56-37 shows the folder structure of the process template after it has been exported. Each folder contains either XML documents or other template documents, such as reports, that will be included in a new project based on this template.

828

Visual Studio Team System

Figure 56-37

For example, in the Reports folder is the list of Reporting Services reports that will be included in the new project, such as All Work Items or Remaining Items. Another example is the VersionControl.xml file, which resides in the Version Control folder, and is shown in the following example code:

<?xml version=”1.0” encoding=”utf-8” ?> <tasks>

<task id=”VersionControlTask” name=”Create Version Control area”

plugin=”Microsoft.ProjectCreationWizard.VersionControl” completionMessage=”Version control Task completed.”>

<dependencies/>

<taskXml>

<permission allow=”Read, PendChange, Checkin, Label, Lock, ReviseOther,

UnlockOther, UndoOther, LabelOther, AdminProjectRights, CheckinOther” identity=”[$$PROJECTNAME$$]\Project Administrators”/>

<permission allow=”Read, PendChange, Checkin, Label, Lock” identity=”[$$PROJECTNAME$$]\Contributors”/>

<permission allow=”Read” identity=”[$$PROJECTNAME$$]\Readers”/> <permission allow=”Read, PendChange, Checkin, Label, Lock”

identity=”[$$PROJECTNAME$$]\Build Services”/>

<checkin_note label=”Code Reviewer” required=”false” order=”1”/>

829

Chapter 56

<checkin_note label=”Security Reviewer” required=”false” order=”2”/> <checkin_note label=”Performance Reviewer” required=”false” order=”3”/>

<exclusive_checkout required=”false”/> </taskXml>

</task>

</tasks>

This document outlines a number of things related to the version control requirements for the project, such as the permissions for various groups of users, what notes are required when checking in, and whether checkouts are exclusive. To make changes to the process, you can simply change this XML document. For example, you might want to ensure that all check-ins have notes from the Code, Security, and Performance reviewers. To do this you would change the required flag to true.

Once the required changes have been made, the new process template can be uploaded to the Team Foundation server via the Process Template Manager.

Summar y

This chapter presented a very brief overview of Visual Studio Team System. Team System extends Visual Studio beyond the individual developer, making it suitable for large-scale application development. Development teams ranging from one or two developers through to a team of hundreds of developers can use Team System to design, build, and deploy applications. More important, Team System can be used to manage, monitor, and report on the status of a project in real time.

Although organizations have their own development processes that may not align with any of the default process templates that ship with the product, Team System has been designed from the ground up to be extensible and customizable.

830

add-ins (continued)

832

833

binding, data (continued)

834

835