Procédure pas à pas : création d'un assembly de règle d'analyse du code statique personnalisé pour SQL

Article
08/15/2011

Cette rubrique pas à pas explique comment procéder pour créer une règle d'analyse du code SQL. La règle que vous aurez l'occasion de créer permet d'éviter l'utilisation d'instructions WAITFOR DELAY dans les procédures stockées, les déclencheurs et les fonctions.

Au cours de cette procédure pas à pas, vous allez définir une règle personnalisée d'analyse statique du code Transact-SQL à l'aide des processus suivants :

Créer une bibliothèque de classes, activer la signature pour ce projet et ajouter les références nécessaires.
Créer deux classes C# d'assistance.
Créer une classe C# de règle personnalisée.
Créer un fichier XML destiné à l'enregistrement de l'assembly.
Copier le fichier DLL et le fichier XML que vous venez de créer dans le répertoire Extensions en vue de leur enregistrement.
Vérifier si la nouvelle règle d'analyse du code est en place.

Composants requis

Pour effectuer cette procédure, il est indispensable d'installer Visual Studio Premium ou Visual Studio Ultimate.

Création d'une règle d'analyse du code personnalisée pour SQL

La première étape consiste à créer une bibliothèque de classes.

Pour créer une bibliothèque de classes

Dans le menu Fichier, cliquez sur Nouveau, puis sur Projet.
Dans la boîte de dialogue Nouveau projet, dans la liste des Modèles installés, cliquez sur Visual C#.
Dans le volet d'informations, sélectionnez Bibliothèque de classes.
Dans la zone de texte Nom, tapez SampleRules, puis cliquez sur OK.

Il convient ensuite de signer le projet.

Pour activer la signature pour le projet

Une fois le nœud de projet sélectionné dans l'Explorateur de solutions, dans le menu Projet, cliquez sur Propriétés (ou cliquez avec le bouton droit sur le nœud de projet dans l'Explorateur de solutions et sélectionnez Propriétés).
Cliquez sur l'onglet Signature.
Activez la case à cocher Signer l'assembly.
Spécifiez un nouveau fichier de clé. Dans la liste déroulante Choisir un fichier de clé de nom fort, sélectionnez <Nouveau...>.

La boîte de dialogue Créer une clé de nom fort s'affiche. Pour plus d'informations, consultez Créer une clé de nom fort, boîte de dialogue.
Dans la boîte de dialogue Créer une clé de nom fort, tapez SampleRulesKey dans la zone de texte Nom pour le nouveau fichier de clé. Vous n'avez pas à fournir de mot de passe pour cette procédure pas à pas. Pour plus d'informations, consultez Gestion d'assembly et signature de manifeste.

Vous allez, à présent, ajouter les références nécessaires à ce projet.

Pour ajouter les références applicables au projet

Dans l'Explorateur de solutions, sélectionnez le projet SampleRules.
Dans le menu Projet, cliquez sur Ajouter une référence.

La boîte de dialogue Ajouter une référence s'ouvre. Pour plus d'informations, consultez Comment : ajouter ou supprimer des références dans Visual Studio.
Sélectionnez l'onglet .NET.
Dans la colonne Nom du composant, repérez les composants suivants :
Notes

Pour sélectionner plusieurs composants, appuyez sur la touche CTRL et maintenez-la enfoncée pendant que vous cliquez sur chaque composant.
Cliquez sur OK lorsque vous avez sélectionné tous les composants requis.

Les références sélectionnées s'afficheront sous le nœud Références du projet dans l'Explorateur de solutions.

Création des classes de prise en charge de la règle d'analyse du code personnalisée

Avant de créer la classe pour la règle elle-même, vous allez ajouter une classe de visiteur et une classe d'assistance au projet.

Conseil

Ces classes peuvent être utiles pour la création de règles personnalisées supplémentaires.

La première classe que vous devez définir est la classe WaitForDelayVisitor, dérivée de TSqlConcreteFragmentVisitor. Cette classe fournit l'accès aux instructions WAITFOR DELAY dans le modèle.

Pour définir la classe WaitForDelayVisitor

Dans l'Explorateur de solutions, sélectionnez le projet SampleRules.
Dans le menu Projet, sélectionnez Ajouter une classe.

La boîte de dialogue Ajouter un nouvel élément s'affiche.
Dans la zone de texte Nom, tapez WaitForDelayVisitor.cs, puis cliquez sur le bouton Ajouter.

Le fichier WaitForDelayVisitor.cs est ajouté au projet dans l'Explorateur de solutions.

Ouvrez le fichier WaitForDelayVisitor.cs et mettez à jour le contenu pour le faire correspondre au code suivant :

using System.Collections.Generic;
using Microsoft.Data.Schema.ScriptDom.Sql;

namespace SampleRules
{
    class WaitForDelayVistor
    {
    }
}

Dans la déclaration de classe, changez le modificateur d'accès en classe interne et dérivez la classe de TSqlConcreteFragmentVisitor :
```
    internal class WaitForDelayVisitor : TSqlConcreteFragmentVisitor
    {
    }
```

Ajoutez le code suivant pour définir la variable de membre List :

        private List<WaitForStatement> _waitForDelayStatments;

Définissez le constructeur de classe en ajoutant le code suivant :

        #region ctor
        public WaitForDelayVisitor()
        {
            _waitForDelayStatments = new List<WaitForStatement>();
        }
        #endregion

Définissez la propriété WaitForDelayStatements en lecture seule en ajoutant le code suivant :

        #region properties
        public List<WaitForStatement> WaitForDelayStatements
        {
            get
            {
                return _waitForDelayStatments;
            }
        }
        #endregion

Substituez la méthode ExplicitVisit en ajoutant le code suivant :

        #region overrides
        public override void ExplicitVisit(WaitForStatement node)
        {
            // We are only interested in WAITFOR DELAY occurrences
            if (node.WaitForOption == WaitForOption.Delay)
            {
                _waitForDelayStatments.Add(node);
            }
        }
        #endregion

Cette méthode visite les instructions WAITFOR dans le modèle et ajoute celles pour qui l'option DELAY est spécifiée à la liste d'instructions WAITFOR DELAY. La classe clé référencée ici est WaitForStatement.

Dans le menu Fichier, cliquez sur Enregistrer.

La deuxième classe est SqlRuleUtils.cs. Celle-ci contient quelques méthodes utilitaires qui seront utilisées par la classe de règle d'analyse du code personnalisée que vous créerez plus tard au cours de cette procédure dans la section Création de la classe de règle d'analyse du code personnalisée. Les différentes méthodes incluent :

GetElementName Utilisée pour obtenir le nom qualifié complet placé dans une séquence d'échappement d'un élément de modèle
UpdateProblemPosition Utilisée pour calculer les informations de lignes et de colonnes.
ReadFileContent Utilisée pour lire le contenu d'un fichier.
GetElementSourceFile Utilisée pour acquérir le fichier source.
ComputeLineColumn Utilisée pour convertir l'offset de ScriptDom en ligne et colonne dans les fichiers de script.

Pour ajouter le fichier SqlRuleUtils.cs au projet

Dans l'Explorateur de solutions, sélectionnez le projet SampleRules.
Dans le menu Projet, sélectionnez Ajouter une classe.

La boîte de dialogue Ajouter un nouvel élément s'affiche.
Dans la zone de texte Nom, tapez SqlRuleUtils.cs, puis cliquez sur le bouton Ajouter.

Le fichier SqlRuleUtils.cs est ajouté au projet dans l'Explorateur de solutions.

Ouvrez le fichier SqlRuleUtils.cs et ajoutez les instructions Using suivantes au fichier :

using System;
using System.Diagnostics;
using System.IO;
using Microsoft.Data.Schema.SchemaModel;
using Microsoft.Data.Schema.Sql.SchemaModel;
using Microsoft.Data.Schema.StaticCodeAnalysis;
using Microsoft.Data.Schema;


namespace SampleRules
{
}

Dans la déclaration de classe SqlRuleUtils, changez le modificateur d'accès en classe statique publique :
```
    public static class SqlRuleUtils
    {
    }
```

Ajoutez le code suivant pour créer la méthode GetElementName, laquelle utilise SqlSchemaModel et ISqlModelElement comme paramètres d'entrée :

        /// <summary>
        /// Get escaped fully qualified name of a model element 
        /// </summary>
        /// <param name="sm">schema model</param>
        /// <param name="element">model element</param>
        /// <returns>name of the element</returns>
        public static string GetElementName(SqlSchemaModel sm, ISqlModelElement element)
        {
            return sm.DatabaseSchemaProvider.UserInteractionServices.GetElementName(element, ElementNameStyle.EscapedFullyQualifiedName);
        }

Ajoutez le code suivant pour créer la méthode ReadFileContent :

        /// <summary>
        /// Read file content from a file.
        /// </summary>
        /// <param name="filePath"> file path </param>
        /// <returns> file content in a string </returns>
        public static string ReadFileContent(string filePath)
        {
            //  Verify that the file exists first.
            if (!File.Exists(filePath))
            {
                Debug.WriteLine(string.Format("Cannot find the file: '{0}'", filePath));
                return string.Empty;
            }

            string content;
            using (StreamReader reader = new StreamReader(filePath))
            {
                content = reader.ReadToEnd();
                reader.Close();
            }
            return content;
        }

Ajoutez le code suivant pour créer la méthode GetElementSourceFile, laquelle utilise IModelElement comme paramètre d'entrée et String pour extraire le nom de fichier. La méthode effectue un cast d'IModelElement en IScriptSourcedModelElement, puis utilise ISourceInformation pour déterminer le chemin d'accès du fichier de script à partir de l'élément de modèle.

        /// <summary>
        /// Get the corresponding script file path from a model element.
        /// </summary>
        /// <param name="element">model element</param>
        /// <param name="fileName">file path of the scripts corresponding to the model element</param>
        /// <returns></returns>
        private static Boolean GetElementSourceFile(IModelElement element, out String fileName)
        {
            fileName = null;

            IScriptSourcedModelElement scriptSourcedElement = element as IScriptSourcedModelElement;
            if (scriptSourcedElement != null)
            {
                ISourceInformation elementSource = scriptSourcedElement.PrimarySource;
                if (elementSource != null)
                {
                    fileName = elementSource.SourceName;
                }
            }

            return String.IsNullOrEmpty(fileName) == false;
        }

Ajoutez le code suivant pour créer la méthode ComputeLineColumn :

        /// This method converts offset from ScriptDom to line\column in script files.
        /// A line is defined as a sequence of characters followed by a carriage return ("\r"), 
        /// a line feed ("\n"), or a carriage return immediately followed by a line feed. 
        public static bool ComputeLineColumn(string text, Int32 offset, Int32 length,
                                            out Int32 startLine, out Int32 startColumn, out Int32 endLine, out Int32 endColumn)
        {
            const char LF = '\n';
            const char CR = '\r';

            // Setting the initial value of line and column to 0 since VS auto-increments by 1.
            startLine = 0;
            startColumn = 0;
            endLine = 0;
            endColumn = 0;

            int textLength = text.Length;

            if (offset < 0 || length < 0 || offset + length > textLength)
            {
                return false;
            }

            for (int charIndex = 0; charIndex < length + offset; ++charIndex)
            {
                char currentChar = text[charIndex];
                Boolean afterOffset = charIndex >= offset;
                if (currentChar == LF)
                {
                    ++endLine;
                    endColumn = 0;
                    if (afterOffset == false)
                    {
                        ++startLine;
                        startColumn = 0;
                    }
                }
                else if (currentChar == CR)
                {
                    // CR/LF combination, consuming LF.
                    if ((charIndex + 1 < textLength) && (text[charIndex + 1] == LF))
                    {
                        ++charIndex;
                    }

                    ++endLine;
                    endColumn = 0;
                    if (afterOffset == false)
                    {
                        ++startLine;
                        startColumn = 0;
                    }
                }
                else
                {
                    ++endColumn;
                    if (afterOffset == false)
                    {
                        ++startColumn;
                    }
                }
            }

            return true;
        }

Ajoutez le code suivant pour créer la méthode UpdateProblemPosition, laquelle utilise DataRuleProblem comme paramètre d'entrée :

        /// <summary>
        /// Compute the start Line/Col and the end Line/Col to update problem info
        /// </summary>
        /// <param name="problem">problem found</param>
        /// <param name="offset">offset of the fragment having problem</param>
        /// <param name="length">length of the fragment having problem</param>
        public static void UpdateProblemPosition(DataRuleProblem problem, int offset, int length)
        {
            if (problem.ModelElement != null)
            {
                String fileName = null;
                int startLine = 0;
                int startColumn = 0;
                int endLine = 0;
                int endColumn = 0;

                bool ret = GetElementSourceFile(problem.ModelElement, out fileName);
                if (ret)
                {
                    string fullScript = ReadFileContent(fileName);

                    if (fullScript != null)
                    {
                        if (ComputeLineColumn(fullScript, offset, length, out startLine, out startColumn, out endLine, out endColumn))
                        {
                            problem.FileName = fileName;
                            problem.StartLine = startLine + 1;
                            problem.StartColumn = startColumn + 1;
                            problem.EndLine = endLine + 1;
                            problem.EndColumn = endColumn + 1;
                        }
                        else
                        {
                            Debug.WriteLine("Could not compute line and column");
                        }
                    }
                }
            }
        }

Dans le menu Fichier, cliquez sur Enregistrer.

Ensuite, vous ajoutez un fichier de ressources qui définira le nom de règle, la description de règle et la catégorie dans laquelle la règle apparaîtra dans l'interface de configuration de règle.

Pour ajouter un fichier de ressources et trois chaînes de ressources

Dans l'Explorateur de solutions, sélectionnez le projet SampleRules.
Dans le menu Projet, cliquez sur Ajouter un nouvel élément.

La boîte de dialogue Ajouter un nouvel élément s'affiche.
Dans la liste Modèles installés, cliquez sur Général.
Dans le volet d'informations, cliquez sur Fichier de ressources.
Dans Nom, tapez SampleRuleResource.resx.

L'éditeur de ressources apparaît, mais ne contient encore aucune ressource définie.

Définissez trois chaînes de ressources comme suit :

Nom	Valeur
AvoidWaitForDelay_ProblemDescription	L'instruction WAITFOR DELAY a été trouvée dans {0}.
AvoidWaitForDelay_RuleName	Évitez d'utiliser les instructions WaitFor Delay dans les procédures stockées, les fonctions et les déclencheurs.
CategorySamples	SamplesCategory

Dans le menu Fichier, cliquez sur Enregistrer SampleRuleResource.resx.

Ensuite, vous définissez une classe qui référence, dans le fichier de ressources, les ressources utilisées par Visual Studio pour afficher les informations à propos de votre règle dans l'interface utilisateur.

Pour définir la classe SampleConstants

Dans l'Explorateur de solutions, sélectionnez le projet SampleRules.
Dans le menu Projet, sélectionnez Ajouter une classe.

La boîte de dialogue Ajouter un nouvel élément s'affiche.
Dans la zone de texte Nom, tapez SampleRuleConstants.cs, puis cliquez sur le bouton Ajouter.

Le fichier SampleRuleConstants.cs est ajouté au projet dans l'Explorateur de solutions.

Ouvrez le fichier SampleRuleConstants.cs et ajoutez les instructions Using suivantes au fichier :

namespace SampleRules
{
    internal class SampleConstants
    {
        public const string NameSpace = "SamplesRules";
        public const string ResourceBaseName = "SampleRules.SampleRuleResource";
        public const string CategorySamples = "CategorySamples";

        public const string AvoidWaitForDelayRuleId = "SR1004";
        public const string AvoidWaitForDelay_RuleName = "AvoidWaitForDelay_RuleName";
        public const string AvoidWaitForDelay_ProblemDescription = "AvoidWaitForDelay_ProblemDescription";
    }
}

Dans le menu Fichier, cliquez sur Enregistrer.

Création de la classe de règle d'analyse du code personnalisée

Maintenant que vous avez ajouté les classes d'assistance destinées à la règle d'analyse du code personnalisée, vous allez créer une classe de règle personnalisée que vous appellerez AvoidWaitForDelayRule. La règle personnalisée AvoidWaitForDelayRule sera utilisée par les développeurs de bases de données pour éviter le recours aux instructions WAITFOR DELAY dans les procédures stockées, les déclencheurs et les fonctions.

Pour créer la classe AvoidWaitForDelayRule

Dans l'Explorateur de solutions, sélectionnez le projet SampleRules.
Dans le menu Projet, choisissez Nouveau dossier.
Un nouveau dossier apparaît dans l'Explorateur de solutions. Nommez le dossier AvoidWaitForDelayRule.
Dans l'Explorateur de solutions, assurez-vous que le dossier AvoidWaitForDelayRule est sélectionné.
Dans le menu Projet, sélectionnez Ajouter une classe.

La boîte de dialogue Ajouter un nouvel élément s'affiche.
Dans la zone de texte Nom, tapez AvoidWaitForDelayRule.cs, puis cliquez sur le bouton Ajouter.

Le fichier AvoidWaitForDelayRule.cs est ajouté au dossier AvoidWaitForDelayRule du projet dans l'Explorateur de solutions.

Ouvrez le fichier AvoidWaitForDelayRule.cs et ajoutez les instructions Using suivantes au fichier :

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using Microsoft.Data.Schema.Extensibility;
using Microsoft.Data.Schema.SchemaModel;
using Microsoft.Data.Schema.ScriptDom.Sql;
using Microsoft.Data.Schema.Sql.SchemaModel;
using Microsoft.Data.Schema.Sql;
using Microsoft.Data.Schema.StaticCodeAnalysis;
namespace SampleRules
{
    public class AvoidWaitForDelayRule
    {
    }
}

Notes

Vous devez remplacer le nom de l'espace de noms, SampleRules.AvoidWaitForDelayRule, par SampleRules.

Dans la déclaration de classe AvoidWaitForDelayRule, changez le modificateur d'accès en classe publique :

    /// <summary>
    /// This is a SQL rule which returns a warning message 
    /// whenever there is a WAITFOR DELAY statement appears inside a subroutine body. 
    /// This rule only applies to SQL stored procedures, functions and triggers.
    /// </summary>
    public class AvoidWaitForDelayRule

Dérivez la classe AvoidWaitForDelayRule de la classe de base StaticCodeAnalysisRule :
```
    public class AvoidWaitForDelayRule : StaticCodeAnalysisRule
```
Ajoutez les attributs DatabaseSchemaProviderCompatibilityAttribute, DataRuleAttribute et SupportedElementTypeAttribute à votre classe. Pour plus d'informations sur la compatibilité d'extension de fonctionnalité, consultez Extension des fonctionnalités de base de données de Visual Studio.
```
    [DatabaseSchemaProviderCompatibility(typeof(SqlDatabaseSchemaProvider))]
    [DataRuleAttribute(
        SampleConstants.NameSpace,
        SampleConstants.AvoidWaitForDelayRuleId,
        SampleConstants.ResourceBaseName,
        SampleConstants.AvoidWaitForDelay_RuleName,
        SampleConstants.CategorySamples,
        DescriptionResourceId = SampleConstants.AvoidWaitForDelay_ProblemDescription)]
    [SupportedElementType(typeof(ISqlProcedure))]
    [SupportedElementType(typeof(ISqlTrigger))]
    [SupportedElementType(typeof(ISqlFunction))]
    public class AvoidWaitForDelayRule : StaticCodeAnalysisRule
```
DataRuleAttribute spécifie des informations qui s'affichent dans Visual Studio lorsque vous configurez des règles d'analyse du code de base de données. SupportedElementTypeAttribute définit les types des éléments auxquels cette règle sera appliquée. Dans ce cas, la règle sera appliquée aux procédures stockées, aux déclencheurs et aux fonctions.

Ajoutez une substitution pour la méthode Analyze, qui utilise DataRuleSetting et DataRuleExecutionContext comme paramètres d'entrée. Cette méthode retourne une liste de problèmes potentiels.

La méthode obtient IModelElement et TSqlFragment du paramètre de contexte. Le SqlSchemaModel et l'ISqlModelElement sont obtenus de l'élément de modèle. La classe WaitForDelayVisitor est ensuite utilisée pour obtenir une liste de toutes les instructions WAITFOR DELAY dans le modèle.

Pour chaque WaitForStatement dans cette liste, un DataRuleProblem est créé.

        #region Overrides
        /// <summary>
        /// Analyze the model element
        /// </summary>
        public override IList<DataRuleProblem> Analyze(DataRuleSetting ruleSetting, DataRuleExecutionContext context)
        {
            List<DataRuleProblem> problems = new List<DataRuleProblem>();

            IModelElement modelElement = context.ModelElement;

            // this rule does not apply to inline table-valued function
            // we simply do not return any problem
            if (modelElement is ISqlInlineTableValuedFunction)
            {
                return problems;
            }

            // casting to SQL specific 
            SqlSchemaModel sqlSchemaModel = modelElement.Model as SqlSchemaModel;
            Debug.Assert(sqlSchemaModel!=null, "SqlSchemaModel is expected");

            ISqlModelElement sqlElement = modelElement as ISqlModelElement;
            Debug.Assert(sqlElement != null, "ISqlModelElement is expected");

            // Get ScriptDom for this model element
            TSqlFragment sqlFragment = context.ScriptFragment as TSqlFragment;
            Debug.Assert(sqlFragment != null, "TSqlFragment is expected");

            // visitor to get the ocurrences of WAITFOR DELAY statements
            WaitForDelayVisitor visitor = new WaitForDelayVisitor();
            sqlFragment.Accept(visitor);
            List<WaitForStatement> waitforDelayStatements = visitor.WaitForDelayStatements;

            // Create problems for each WAITFOR DELAY statement found 
            foreach (WaitForStatement waitForStatement in waitforDelayStatements)
            {
                DataRuleProblem problem = new DataRuleProblem(this,
                                            String.Format(CultureInfo.CurrentCulture, this.RuleProperties.Description, SqlRuleUtils.GetElementName(sqlSchemaModel, sqlElement)),
                                            sqlElement);

                SqlRuleUtils.UpdateProblemPosition(problem, waitForStatement.StartOffset, waitForStatement.FragmentLength);
                problems.Add(problem);
            }

            return problems;
        }

        #endregion

Dans le menu Fichier, cliquez sur Enregistrer.

Il est temps à présent de générer le projet.

Pour générer le projet

Dans le menu Générer, cliquez sur Générer la solution.

Vous allez, à présent, collecter les informations de l'assembly générées dans le projet, notamment la version, la culture et PublicKeyToken.

Pour collecter des informations de l'assembly

Dans le menu Affichage, cliquez sur Autres fenêtres, puis cliquez sur Fenêtre Commande pour ouvrir la fenêtre Commande.
Dans la fenêtre Commande, tapez le code suivant. Pour FilePath, substituez le chemin d'accès et le nom de votre fichier .dll compilé. Placez le chemin d'accès et le nom de fichier entre guillemets.

Notes

Par défaut, FilePath correspond à Projects\SampleRules\SampleRules\bin\Debug\VotreDLL ou à Projects\SampleRules\SampleRules \bin\Release \VotreDLL.
```
? System.Reflection.Assembly.LoadFrom(@"FilePath")
```
Appuyez sur ENTRÉE. La ligne doit ressembler à ce qui suit avec votre PublicKeyToken spécifique :
```
"SampleRules, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn"
```
Notez ou copiez les informations de cet assembly, car elles seront utilisées dans la procédure suivante.

Ensuite, vous créez un fichier XML en utilisant les informations d'assembly collectées lors de la procédure précédente.

Pour créer le fichier XML

Dans l'Explorateur de solutions, sélectionnez le projet SampleRules.
Dans le menu Projet, cliquez sur Ajouter un nouvel élément.
Dans le volet Modèles, recherchez et sélectionnez l'élément Fichier XML.
Dans la zone de texte Nom, tapez SampleRules.Extensions.xml, puis cliquez sur le bouton Ajouter.

Le fichier SampleRules.Extensions.xml est ajouté au projet dans l'Explorateur de solutions.

Ouvrez le fichier SampleRules.Extensions.xml et mettez-le à jour pour qu'il corresponde au fichier XML suivant. Remplacez les valeurs Version, Culture et PublicKeyToken par celles que vous avez extraites dans la procédure précédente.

<?xml version="1.0" encoding="utf-8"?>
<extensions assembly=""
            version="1" xmlns="urn:Microsoft.Data.Schema.Extensions"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="urn:Microsoft.Data.Schema.Extensions Microsoft.Data.Schema.Extensions.xsd">

  <extension type="SampleRules.AvoidWaitForDelayRule" assembly="SampleRules, Version=1.0.0.0, Culture=neutral, PublicKeyToken=b4deb9b383d021b0" enabled="true"/>
</extensions>

Dans le menu Fichier, cliquez sur Enregistrer.

L'étape suivante vous invite à copier les informations de l'assembly et le fichier XML dans le répertoire Extensions. Au démarrage de Visual Studio, celui-ci se charge d'identifier les extensions à l'intérieur du répertoire et des sous-répertoires Microsoft Visual Studio 10.0\VSTSDB\Extensions et de les enregistrer en vue de les utiliser au cours de la session.

Pour copier les informations de l'assembly et le fichier XML dans le répertoire Extensions

Créez un dossier appelé CustomRules dans le répertoire Microsoft Visual Studio 10.0\VSTSDB\Extensions\.
Copiez le fichier d'assembly SampleRules.dll du répertoire Projects\SampleRules\SampleRules\bin\Debug\ vers le répertoire Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomRules que vous avez créé.
Copiez le fichier SampleRules.Extensions.xml du répertoire Projects\SampleRules\SampleRules\ vers le répertoire Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomRules que vous avez créé.

Notes

Il est recommandé de placer vos assemblys d'extension dans un même dossier au sein du répertoire Microsoft Visual Studio 10.0\VSTSDB\Extensions. Ceci vous aidera à identifier les extensions incluses dans le produit et celles qui correspondent à vos créations personnalisées. Il est également recommandé d'utiliser des dossiers pour organiser vos extensions en catégories spécifiques.

Il convient ensuite de démarrer une nouvelle session Visual Studio et de créer un projet de base de données.

Pour démarrer une nouvelle session Visual Studio et créer un projet de base de données

Démarrez une deuxième session Visual Studio.
Dans le menu Fichier, cliquez sur Nouveau, puis sur Projet.
Dans la boîte de dialogue Nouveau projet, dans la liste de Modèles installés, développez le nœud Projets de base de données, puis cliquez sur SQL Server.
Dans le volet d'informations, sélectionnez Projet de base de données SQL Server 2008.
Dans la zone de texte Nom, tapez SampleRulesDB, puis cliquez sur OK.

Pour finir, vous allez consulter la nouvelle règle qui figure dans le projet SQL Server.

Pour afficher la nouvelle règle d'analyse du code AvoidWaitForRule

Dans l'Explorateur de solutions, sélectionnez le projet SampleRulesDB.
Dans le menu Projet, cliquez sur Propriétés.

La page de propriétés SampleRulesDB s'affiche.
Cliquez sur Analyse du code.

Une nouvelle catégorie appelée CategorySamples est visible.
Développez CategorySamples.

Le message suivant doit apparaître : SR1004: Évitez l'instruction WAITFOR DELAY dans les procédures stockées, les déclencheurs et les fonctions.

Voir aussi

Share via