Procedura dettagliata: creazione di un assembly di regole dell'analisi codice statica personalizzate per SQL

Articolo
08/15/2011

In questo argomento dettagliato viene illustrata la procedura utilizzata per creare una regola dell'analisi codice SQL. La regola creata in questa procedura dettagliata viene utilizzata per evitare le istruzioni WAITFOR DELAY in stored procedure, trigger e funzioni.

In questa procedura dettagliata si creerà una regola personalizzata per l'analisi codice statica Transact-SQL tramite i seguenti processi:

Creazione di una libreria di classi, abilitazione della firma per tale progetto e aggiunta dei riferimenti necessari.
Creazione di due classi C# di supporto.
Creazione di una classe di regole personalizzate C#.
Creazione di un file XML utilizzato per registrare l'assembly.
Copia dei file DLL e XML risultanti creati nella directory Extensions ai fini della registrazione.
Verifica della disponibilità della nuova regola dell'analisi codice.

Prerequisiti

Per completare questa procedura dettagliata è necessario disporre di Visual Studio Premium o Visual Studio Ultimate.

Creazione di una regola dell'analisi codice personalizzata per SQL

Per prima cosa si creerà una libreria di classi.

Per creare una libreria di classi

Scegliere Nuovo dal menu File, quindi fare clic su Progetto.
Nell'elenco Modelli installati della finestra di dialogo Nuovo progetto fare clic su Visual C#.
Nel riquadro dei dettagli selezionare Libreria di classi.
Nella casella di testo Nome digitare SampleRules e fare clic su OK.

Si firmerà quindi il progetto.

Per abilitare la firma per il progetto

Una volta selezionato il nodo del progetto SampleRules in Esplora soluzioni, scegliere Proprietà nel menu Progetto, oppure fare clic con il pulsante destro del mouse sul nodo del progetto in Esplora soluzioni, quindi scegliere Proprietà.
Fare clic sulla scheda Firma.
Selezionare la casella di controllo Firma assembly.
Specificare un nuovo file di chiave. Nell'elenco a discesa Scegli un file chiave con nome sicuro selezionare <Nuovo...>.

Verrà visualizzata la finestra di dialogo Crea chiave con nome sicuro. Per ulteriori informazioni, vedere Finestra di dialogo Crea chiave con nome sicuro.
Nella finestra di dialogo Crea chiave con nome sicuro digitare SampleRulesKey nella casella di testo Nome per il nuovo file di chiave. Per questa procedura dettagliata non è necessario fornire una password. Per ulteriori informazioni, vedere Gestione delle firme di assembly e manifesti.

Si aggiungeranno quindi i riferimenti necessari al progetto.

Per aggiungere i riferimenti applicabili al progetto

Selezionare il progetto SampleRules in Esplora soluzioni.
Scegliere Aggiungi riferimento dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi riferimento. Per ulteriori informazioni, vedere Procedura: aggiungere o rimuovere riferimenti in Visual Studio.
Selezionare la scheda .NET.
Nella colonna Nome componente individuare i seguenti componenti:
Nota

Tenere premuto il tasto CTRL e contemporaneamente fare clic per selezionare più componenti.
Scegliere OK dopo aver selezionato tutti i componenti necessari.

I riferimenti selezionati verranno visualizzati nel nodo Riferimenti del progetto in Esplora soluzioni.

Creazione delle classi di supporto della regola di analisi codice personalizzata

Prima di creare la classe per la regola, si aggiungeranno al progetto una classe visitatore e una classe di supporto.

Suggerimento
Queste classi possono rivelarsi utili per la creazione di regole personalizzate aggiuntive.

La prima classe che è necessario definire è la classe WaitForDelayVisitor, derivata da TSqlConcreteFragmentVisitor. Questa classe fornisce accesso alle istruzioni WAITFOR DELAY nel modello.

Per definire la classe WaitForDelayVisitor

Selezionare il progetto SampleRules in Esplora soluzioni.
Scegliere Aggiungi classe dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi nuovo elemento.
Nella casella di testo Nome digitare WaitForDelayVisitor.cs, quindi fare clic sul pulsante Aggiungi.

Il file WaitForDelayVisitor.cs verrà aggiunto al progetto in Esplora soluzioni.

Aprire il file WaitForDelayVisitor.cs e aggiornare il contenuto in modo che corrisponda al codice seguente:

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

namespace SampleRules
{
    class WaitForDelayVistor
    {
    }
}

Nella dichiarazione della classe impostare il modificatore di accesso su internal e derivare la classe da TSqlConcreteFragmentVisitor:
```
    internal class WaitForDelayVisitor : TSqlConcreteFragmentVisitor
    {
    }
```
Aggiungere il codice riportato di seguito per definire la variabile membro List:
```
        private List<WaitForStatement> _waitForDelayStatments;
```

Definire il costruttore della classe aggiungendo il seguente codice:

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

Definire la proprietà WaitForDelayStatements di sola lettura aggiungendo il codice seguente:

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

Eseguire l'override del metodo ExplicitVisit aggiungendo il codice seguente:

        #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

Questo metodo visita le istruzioni WAITFOR nel modello e aggiunge all'elenco di istruzioni WAITFOR DELAY quelle che dispongono dell'opzione DELAY specificata. In questo caso la classe principale di riferimento è WaitForStatement.

Scegliere Salva dal menu File.

La seconda classe è SqlRuleUtils.cs, che contiene alcuni metodi di utilità che verranno utilizzati dalla classe della regola di analisi codice personalizzata che si creerà più avanti in questa procedura dettagliata, nella sezione Creazione della classe della regola di analisi codice personalizzata. Tali modalità sono riportate di seguito:

GetElementName Utilizzato per ottenere il nome completo con caratteri di escape di un elemento di modello
UpdateProblemPosition Utilizzato per calcolare le informazioni su righe e colonne.
ReadFileContent Utilizzato per leggere il contenuto di un file.
GetElementSourceFile Utilizzato per acquisire il file di origine.
ComputeLineColumn Utilizzato per convertire l'offset da ScriptDom a riga e colonna nei file di script.

Per aggiungere il file SqlRuleUtils.cs al progetto

Selezionare il progetto SampleRules in Esplora soluzioni.
Scegliere Aggiungi classe dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi nuovo elemento.
Nella casella di testo Nome digitare SqlRuleUtils.cs, quindi fare clic sul pulsante Aggiungi.

Il file SqlRuleUtils.cs verrà aggiunto al progetto in Esplora soluzioni.

Aprire il file SqlRuleUtils.cs e aggiungere le seguenti istruzioni using al file:

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

Nella dichiarazione della classe SqlRuleUtils impostare il modificatore di accesso su public static:
```
    public static class SqlRuleUtils
    {
    }
```

Aggiungere il codice seguente per creare il metodo GetElementName, che utilizza SqlSchemaModel e ISqlModelElement come parametri di input:

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

Aggiungere il codice seguente per creare il metodo 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;
        }

Aggiungere il codice seguente per creare il metodo GetElementSourceFile, che utilizza IModelElement come parametro di input e String per recuperare il nome file. Il metodo esegue il cast di IModelElement come IScriptSourcedModelElement, quindi utilizza ISourceInformation per determinare il percorso del file di script dall'elemento del modello.

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

Aggiungere il codice seguente per creare il metodo 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;
        }

Aggiungere il codice seguente per creare il metodo UpdateProblemPosition, che utilizza DataRuleProblem come parametro di input:

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

Scegliere Salva dal menu File.

Si aggiunge quindi un file di risorse che definirà il nome della regola, la descrizione della regola e la categoria in cui la regola verrà visualizzata nell'interfaccia di configurazione della regola.

Per aggiungere un file di risorse e tre stringhe di risorse

Selezionare il progetto SampleRules in Esplora soluzioni.
Scegliere Aggiungi nuovo elemento dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi nuovo elemento.
Nell'elenco Modelli installati fare clic su Generale.
Nel riquadro dei dettagli fare clic su File di risorse.
In Nome digitare SampleRuleResource.resx.

Verrà visualizzato l'editor di risorse, senza nessuna risorsa già definita.

Definire tre stringhe di risorse come segue:

Nome	Valore
AvoidWaitForDelay_ProblemDescription	L'istruzione WAITFOR DELAY è stata trovata in {0}.
AvoidWaitForDelay_RuleName	Evitare di utilizzare istruzioni WaitFor Delay in stored procedure, funzioni e trigger.
CategorySamples	SamplesCategory

Scegliere Salva SampleRuleResource.resx dal menu File.

Si definisce quindi una classe che fa riferimento alle risorse nel file di risorse utilizzato da Visual Studio per visualizzare le informazioni sulla regola nell'interfaccia utente.

Per definire la classe SampleConstants

Selezionare il progetto SampleRules in Esplora soluzioni.
Scegliere Aggiungi classe dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi nuovo elemento.
Nella casella di testo Nome digitare SampleRuleConstants.cs, quindi fare clic sul pulsante Aggiungi.

Il file SampleRuleConstants.cs verrà aggiunto al progetto in Esplora soluzioni.

Aprire il file SampleRuleConstants.cs e aggiungere le seguenti istruzioni using al file:

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

Scegliere Salva dal menu File.

Creazione della classe della regola di analisi codice personalizzata

Dopo aver aggiunto le classi di supporto che verranno utilizzate dalla regola di analisi codice personalizzata, si creerà una classe della regola personalizzata e la si denominerà AvoidWaitForDelayRule. La regola personalizzata AvoidWaitForDelayRule verrà utilizzata per evitare che gli sviluppatori del database utilizzino istruzioni WAITFOR DELAY in stored procedure, trigger e funzioni.

Per creare la classe AvoidWaitForDelayRule

Selezionare il progetto SampleRules in Esplora soluzioni.
Selezionare Nuova cartella nel menu Progetto.
Una nuova cartella verrà visualizzata in Esplora soluzioni. Denominare la cartella AvoidWaitForDelayRule.
In Esplora soluzioni verificare che la cartella AvoidWaitForDelayRule sia selezionata.
Scegliere Aggiungi classe dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi nuovo elemento.
Nella casella di testo Nome digitare AvoidWaitForDelayRule.cs, quindi fare clic sul pulsante Aggiungi.

Il file AvoidWaitForDelayRule.cs verrà aggiunto alla cartella AvoidWaitForDelayRule del progetto in Esplora soluzioni.

Aprire il file AvoidWaitForDelayRule.cs e aggiungere le seguenti istruzioni using al file:

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

Nota

È necessario modificare il nome dello spazio dei nomi da SampleRules.AvoidWaitForDelayRule in SampleRules.

Nella dichiarazione della classe AvoidWaitForDelayRule, impostare il modificatore di accesso su public:

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

Derivare la classe AvoidWaitForDelayRule dalla classe base StaticCodeAnalysisRule:
```
    public class AvoidWaitForDelayRule : StaticCodeAnalysisRule
```

Aggiungere DatabaseSchemaProviderCompatibilityAttribute, DataRuleAttribute e SupportedElementTypeAttribute alla classe. Per ulteriori informazioni sulla compatibilità dell'estensione di funzionalità, vedere Estensione delle funzionalità di database di 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 specifica le informazioni visualizzate in Visual Studio quando si configurano le regole di analisi codice del database. SupportedElementTypeAttribute definisce i tipi di elementi ai quali verrà applicata questa regola. In questo caso, la regola verrà applicata a stored procedure, trigger e funzioni.

Aggiungere un override per il metodo Analyze, che utilizza DataRuleSetting e DataRuleExecutionContext come parametri di input. Questo metodo restituisce un elenco di problemi potenziali.

Il metodo ottiene IModelElement e TSqlFragment dal parametro di contesto. SqlSchemaModel e ISqlModelElement vengono ottenuti dall'elemento del modello. La classe WaitForDelayVisitor viene quindi utilizzata per ottenere un elenco di tutte le istruzioni WAITFOR DELAY nel modello.

Per ogni oggetto WaitForStatement in tale elenco, viene creato un oggetto DataRuleProblem.

        #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

Scegliere Salva dal menu File.

Si compilerà quindi il progetto.

Per compilare il progetto

Scegliere Compila soluzione dal menu Compila.

Si raccoglieranno quindi le informazioni sull'assembly generate nel progetto, inclusa la versione, le impostazioni cultura e PublicKeyToken.

Per raccogliere le informazioni sull'assembly

Dal menu Visualizza scegliere Altre finestre, quindi fare clic su Finestra di comando per aprire la finestra Comando.
Nella finestra Comando digitare il codice seguente. Sostituire FilePath con il percorso e il nome del file con estensione dll compilato. Racchiudere il percorso e il nome del file tra virgolette.

Nota

Per impostazione predefinita, FilePath è Progetti\SampleRules\SampleRules\bin\Debug\DLL oppure Progetti\SampleRules\SampleRulesbin\Release\DLL.
```
? System.Reflection.Assembly.LoadFrom(@"FilePath")
```
Premere INVIO. La riga dovrebbe assomigliare alla seguente, con il PublicKeyToken specifico:
```
"SampleRules, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn"
```
Annotare o copiare queste informazioni sull'assembly, che verranno utilizzate nella procedura descritta di seguito.

Verrà quindi creato un file XML utilizzando le informazioni sull'assembly raccolte nella procedura precedente.

Per creare il file XML

Selezionare il progetto SampleRules in Esplora soluzioni.
Scegliere Aggiungi nuovo elemento dal menu Progetto.
Nel riquadro Modelli individuare e selezionare l'elemento File XML.
Nella casella di testo Nome digitare SampleRules.Extensions.xml, quindi fare clic sul pulsante Aggiungi.

Il file SampleRules.Extensions.xml verrà aggiunto al progetto in Esplora soluzioni.

Aprire il file SampleRules.Extensions.xml e aggiornarlo in modo tale che corrisponda al codice XML seguente. Sostituire la versione, le impostazioni cultura e i valori PublicKeyToken con quelli recuperati nel corso della procedura precedente.

<?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>

Scegliere Salva dal menu File.

Si copieranno quindi le informazioni sull'assembly e il file XML nella directory Extensions. Quando Visual Studio verrà avviato, identificherà tutte le estensioni nella directory Microsoft Visual Studio 10.0\VSTSDB\Extensions e nelle sottodirectory e le registrerà per l'utilizzo nella sessione.

Per copiare le informazioni sull'assembly e il file XML nella directory Extensions

Creare una nuova cartella denominata CustomRules nella directory Microsoft Visual Studio 10.0\VSTSDB\Extensions\.
Copiare il file di assembly SampleRules.dll dalla directory Progetti\SampleRules\SampleRules\bin\Debug\ nella directory Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomRules creata.
Copiare il file SampleRules.Extensions.xml dalla directory Progetti\SampleRules\SampleRules\ nella directory Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomRules creata.

Nota

Si consiglia di collocare gli assembly di estensione in una cartella contenuta nella directory Microsoft Visual Studio 10.0\VSTSDB\Extensions. In questo modo sarà più facile identificare quali estensioni erano incluse con il prodotto e quali sono state create personalmente. Si consiglia inoltre l'utilizzo di cartelle per organizzare le estensioni in categorie specifiche.

Si avvierà quindi una nuova sessione di Visual Studio e si creerà un progetto di database.

Per avviare una nuova sessione di Visual Studio e creare un progetto di database

Avviare una seconda sessione di Visual Studio.
Scegliere Nuovo dal menu File, quindi fare clic su Progetto.
Nella finestra di dialogo Nuovo progetto, nell'elenco Modelli installati espandere il nodo Progetti di database, quindi fare clic su SQL Server.
Nel riquadro dei dettagli selezionare Progetto di database di SQL Server 2008.
Nella casella di testo Nome digitare SampleRulesDB e fare clic su OK.

Si vedrà infine la nuova regola visualizzata nel progetto di SQL Server.

Per visualizzare la nuova regola dell'analisi codice AvoidWaitForRule

Selezionare il progetto SampleRulesDB in Esplora soluzioni.
Scegliere Proprietà dal menu Progetto.

Verrà visualizzata la pagina delle proprietà di SampleRulesDB.
Fare clic su Analisi codice.

Dovrebbe comparire una nuova categoria denominata CategorySamples.
Espandere CategorySamples.

Dovrebbe comparire SR1004: Evita istruzione WAITFOR DELAY in stored procedure, trigger e funzioni.

Vedere anche