Erstellen von benutzerdefinierten Codeanalyseregeln

Artikel
10/16/2024

Gilt für: SQL Server Azure SQL-Datenbank Azure SQL Managed Instance

Diese exemplarische Vorgehensweise veranschaulicht die erforderlichen Schritte zum Erstellen einer SQL Server-Codeanalyseregel. Mithilfe der in dieser exemplarischen Vorgehensweise erstellten Regel werden WAITFOR DELAY-Anweisungen in gespeicherten Prozeduren, Triggern und Funktionen vermieden.

In dieser exemplarischen Vorgehensweise erstellen Sie mithilfe der folgenden Schritte eine benutzerdefinierte Regel für die statische Codeanalyse von Transact-SQL:

Erstellen eines Klassenbibliothek-Projektes, Aktivieren von Signaturen für das betreffende Projekt und Hinzufügen der erforderlichen Verweise.
Erstellen von zwei C#-Hilfsklassen.
Erstellen einer benutzerdefinierten C#-Regelklasse.
Erstellen Sie das Klassenbibliotheksprojekt.
Installieren und testen Sie die neue Codeanalyseregel.

Mit Ausnahme der Visual Studio-Anweisungen (SQL Server Data Tools) konzentriert sich das Handbuch auf SQL-Projekte im SDK-Stil.

Voraussetzungen

Zum Abschließen dieser exemplarischen Vorgehensweise benötigen Sie Folgendes:

Es muss eine Version von Visual Studio installiert sein, die SQL Server Data Tools enthält und die .NET-Framework-Entwicklung in C# unterstützt.
Ein SQL Server-Projekt, das SQL Server-Objekte enthält.
Eine Instanz von SQL Server, auf der Sie ein Datenbankprojekt bereitstellen können.

Diese exemplarische Vorgehensweise ist für Benutzer gedacht, die bereits mit den SQL Server-Funktionen von SQL Server Data Tools vertraut sind. Sie sollten mit den Visual Studio-Konzepten vertraut sind, wie etwa dem Erstellen einer Klassenbibliothek, dem Hinzufügen von NuGet-Paketen und dem Hinzufügen von Code zu einer Klasse mit dem Code-Editor.

Hinweis

Aufgrund der Vorschaueinschränkungen von SQL Server Data Tools im SDK-Stil sind mehrere Visual Studio-Installationen erforderlich, um diese exemplarische Vorgehensweise abzuschließen. Die erste Installation ist erforderlich, um das Klassenbibliotheksprojekt zu erstellen, die zweite Installation ist erforderlich, um das SQL-Datenbankprojekt im SDK-Stil zu erstellen.

.NET 8 SDK
Visual Studio 2022 Community, Professional oder Enterprise
SQL Server Data Tools, SDK-Format (Vorschau) installiert in Visual Studio 2022
Es muss eine Version von Visual Studio installiert sein, die .NET-Framework-Entwicklung in C# unterstützt.
Ein SQL Server-Projekt, das SQL Server-Objekte enthält.

Eine Version von Visual Studio Code installiert, die die Erweiterung SQL Database Projects enthält.
Ein SQL-Datenbankprojekt, das SQL-Objekte enthält.
.NET 8 SDK
Empfohlen: C#Dev Kit-Erweiterung für VS-Code

Diese exemplarische Vorgehensweise richtet sich an Benutzer, die bereits mit der Erweiterung SQL Database Projects in Visual Studio Code vertraut sind. Sie sollten mit den Entwicklungskonzepten vertraut sein, wie etwa dem Erstellen einer Klassenbibliothek, dem Hinzufügen von Paketen und wie Sie den Code-Editor verwenden, um Code zu bearbeiten.

Ein Texteditor, z. B. der Datei-Editor in Visual Studio Code.
Ein SQL-Datenbankprojekt, das SQL-Objekte enthält.
.NET 8 SDK

Diese exemplarische Vorgehensweise ist für Benutzer gedacht, die bereits mit SQL-Projekten vertraut sind. Sie sollten mit den Entwicklungskonzepten vertraut sein, wie etwa dem Erstellen einer Klassenbibliothek, dem Hinzufügen von Paketen und wie Sie den Code-Editor verwenden, um Code zu bearbeiten.

Schritt 1: Erstellen eines Klassenbibliotheksprojekt

Erstellen Sie zunächst eine Klassenbibliothek. So erstellen Sie ein Klassenbibliotheksprojekt:

Erstellen Sie ein C# (.NET Framework)-Klassenbibliotheksprojekt mit dem Namen SampleRules.
Benennen Sie die Datei Class1.cs in AvoidWaitForDelayRule.cs um.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten. Wählen Sie anschließend Hinzufügen und Verweis aus.
Wählen Sie auf der Registerkarte Assemblys\Frameworks die Option System.ComponentModel.Composition aus.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den neuen Projektknoten, und wählen Sie dann NuGet-Pakete verwalten aus. Suchen Sie nach dem NuGet-Paket Microsoft.SqlServer.DacFx, und installieren Sie es. Bei Visual Studio 2022 muss die ausgewählte Version 162.x.x sein (z. B 162.2.111).

Als Nächstes fügen Sie die Unterstützungsklassen hinzu, die von der Regel verwendet werden.

Erstellen Sie zunächst eine Klassenbibliothek. So erstellen Sie ein Klassenbibliotheksprojekt:

Erstellen Sie ein C# (.NET Framework)-Klassenbibliotheksprojekt mit dem Namen SampleRules.
Benennen Sie die Datei Class1.cs in AvoidWaitForDelayRule.cs um.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten. Wählen Sie anschließend Hinzufügen und Verweis aus.
Wählen Sie auf der Registerkarte Assemblys\Frameworks die Option System.ComponentModel.Composition aus.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den neuen Projektknoten, und wählen Sie dann NuGet-Pakete verwalten aus. Suchen Sie nach dem NuGet-Paket Microsoft.SqlServer.DacFx, und installieren Sie es. Bei Visual Studio 2022 muss die ausgewählte Version 162.x.x sein (z. B 162.2.111).

Als Nächstes fügen Sie die Unterstützungsklassen hinzu, die von der Regel verwendet werden.

Starten Sie Visual Studio Code und öffnen Sie den Ordner, in dem Sie das Projekt erstellen möchten.
Öffnen Sie in Visual Studio Code ein Terminal-Fenster, indem Sie das Menü Anzeigen und dann Terminal wählen.

Geben Sie im integrierten Terminal die folgenden Befehle ein, um eine neue Lösung und ein Projekt zu erstellen:

dotnet new sln
dotnet new classlib -n SampleRules -o SampleRules
dotnet sln add SampleRules/SampleRules.csproj

Wechseln Sie in das Verzeichnis SampleRules:
```
cd SampleRules
```

Hinzufügen des erforderlichen NuGet-Pakets:

dotnet add package Microsoft.SqlServer.DacFx

Als Nächstes fügen Sie die Unterstützungsklassen hinzu, die von der Regel verwendet werden.

Öffnen Sie ein Eingabeaufforderungs- oder Terminalfenster, und navigieren Sie zu dem Ordner, in dem Sie das Projekt erstellen möchten.

Geben Sie im integrierten Terminal die folgenden Befehle ein, um eine neue Lösung und ein Projekt zu erstellen:

dotnet new sln
dotnet new classlib -n SampleRules -o SampleRules
dotnet sln add SampleRules/SampleRules.csproj

Wechseln Sie in das Verzeichnis SampleRules:
```
cd SampleRules
```

Hinzufügen des erforderlichen NuGet-Pakets:

dotnet add package Microsoft.SqlServer.DacFx

Schritt 2: Erstellen benutzerdefinierter Regelhilfsprogrammklassen

Bevor Sie die Klasse für die eigentliche Regel erstellen, fügen Sie dem Projekt eine Besucherklasse und eine Attributklasse hinzu. Diese Klassen können zum Erstellen weiterer benutzerdefinierter Regeln nützlich sein.

Schritt 2.1: Definieren der Klasse WaitForDelayVisitor

Als erste Klasse müssen Sie die Klasse WaitForDelayVisitor definieren, die aus TSqlConcreteFragmentVisitor abgeleitet ist. Diese Klasse ermöglicht den Zugriff auf die WAITFOR DELAY-Anweisungen im Modell. Besucherklassen verwenden die ScriptDom-APIs, die von SQL Server bereitgestellt werden. In dieser API ist Transact-SQL-Code als abstrakte Syntaxstruktur (Abstract Syntax Tree, AST) dargestellt. Besucherklassen können nützlich sein, wenn Sie bestimmte Syntaxobjekte finden möchten, wie etwa WAITFOR DELAY-Anweisungen. Diese Anweisungen sind anhand des Objektmodells unter Umständen schwierig zu finden, da sie keiner bestimmten Objekteigenschaft oder -beziehung zugeordnet sind. Doch mithilfe des Besuchermusters und der ScriptDom-API sind sie aufspürbar.

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus.
Wählen Sie im Menü Projekt den Eintrag Klasse hinzufügen aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt. Geben Sie im Feldfeld Name den Namen WaitForDelayVisitor.cs ein, und wählen Sie dann die Schaltfläche Hinzufügen aus. Daraufhin wird die Datei WaitForDelayVisitor.cs dem Projekt im Projektmappen-Explorer hinzugefügt.

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus.
Wählen Sie im Menü Projekt den Eintrag Klasse hinzufügen aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt. Geben Sie im Feldfeld Name den Namen WaitForDelayVisitor.cs ein, und wählen Sie dann die Schaltfläche Hinzufügen aus. Daraufhin wird die Datei WaitForDelayVisitor.cs dem Projekt im Projektmappen-Explorer hinzugefügt.

Öffnen Sie die Explorer-Ansicht in Visual Studio Code.
Erstellen Sie eine neue Datei mit dem Namen WaitForDelayVisitor.cs im Ordner SampleRules.

Navigieren Sie zum Verzeichnis SampleRules.
Erstelle eine neue Datei mit dem Namen WaitForDelayVisitor.cs.

Öffnen Sie die Datei WaitForDelayVisitor.cs, und aktualisieren Sie den Inhalt, sodass er dem folgenden Code entspricht:

using System.Collections.Generic;
using Microsoft.SqlServer.TransactSql.ScriptDom;
namespace SampleRules {
    class WaitForDelayVistor {}
}

Ändern Sie in der Klassendeklaration den Zugriffsmodifizierer auf intern, und leiten Sie die Klasse aus TSqlConcreteFragmentVisitor ab:
```
internal class WaitForDelayVisitor : TSqlConcreteFragmentVisitor {}
```
Fügen Sie den folgenden Code hinzu, um die Listenmitgliedsvariable zu definieren:
```
public IList<WaitForStatement> WaitForDelayStatements { get; private set; }
```

Definieren Sie den Klassenkonstruktor durch Hinzufügen des folgenden Codes:

public WaitForDelayVisitor() {
   WaitForDelayStatements = new List<WaitForStatement>();
}

Überschreiben Sie die Methode ExplicitVisit, indem Sie den folgenden Code hinzufügen:
```
public override void ExplicitVisit(WaitForStatement node) {
   // We are only interested in WAITFOR DELAY occurrences
   if (node.WaitForOption == WaitForOption.Delay)
      WaitForDelayStatements.Add(node);
}
```
Diese Methode besucht die WAITFOR-Anweisungen im Modell und fügt Anweisungen, für die die Option DELAY angegeben ist, der Liste der WAITFOR DELAY-Anweisungen hinzu. Die Schlüsselklasse, auf die verwiesen wird, ist WaitForStatement.
Klicken Sie im Menü File (Datei) auf Save (Speichern).

Schritt 2.2: Definieren der Klasse LocalizedExportCodeAnalysisRuleAttribute

Die zweite Klasse lautet LocalizedExportCodeAnalysisRuleAttribute.cs. Hierbei handelt es sich um eine Erweiterung des vom Framework bereitgestellten integrierten Microsoft.SqlServer.Dac.CodeAnalysis.ExportCodeAnalysisRuleAttribute. Sie unterstützt das Lesen des von der Regel verwendeten DisplayName und der Description aus einer Ressourcendatei. Dies ist eine nützliche Regel, wenn Sie sich jemals dafür entscheiden, Ihre Regeln in mehreren Sprachen zu verwenden.

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus.
Wählen Sie im Menü Projekt den Eintrag Klasse hinzufügen aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt. Geben Sie im Feldfeld Name den Namen LocalizedExportCodeAnalysisRuleAttribute.cs ein, und wählen Sie dann die Schaltfläche Hinzufügen aus. Die Datei wird dem Projekt im Projektmappen-Explorer hinzugefügt.

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus.
Wählen Sie im Menü Projekt den Eintrag Klasse hinzufügen aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt. Geben Sie im Feldfeld Name den Namen LocalizedExportCodeAnalysisRuleAttribute.cs ein, und wählen Sie dann die Schaltfläche Hinzufügen aus. Die Datei wird dem Projekt im Projektmappen-Explorer hinzugefügt.

Navigieren Sie zu dem SampleRules-Verzeichnis in der Explorer-Ansicht in Visual Studio Code.
Erstelle eine neue Datei mit dem Namen LocalizedExportCodeAnalysisRuleAttribute.cs.

Navigieren Sie zum Verzeichnis SampleRules.
Erstelle eine neue Datei mit dem Namen LocalizedExportCodeAnalysisRuleAttribute.cs.

Öffnen Sie die Datei , und aktualisieren Sie den Inhalt, sodass er dem folgenden Code entspricht:

using Microsoft.SqlServer.Dac.CodeAnalysis;
using System;
using System.Globalization;
using System.Reflection;
using System.Resources;

namespace SampleRules
{

    internal class LocalizedExportCodeAnalysisRuleAttribute : ExportCodeAnalysisRuleAttribute
    {
        private readonly string _resourceBaseName;
        private readonly string _displayNameResourceId;
        private readonly string _descriptionResourceId;

        private ResourceManager _resourceManager;
        private string _displayName;
        private string _descriptionValue;

        /// <summary>
        /// Creates the attribute, with the specified rule ID, the fully qualified
        /// name of the resource file that will be used for looking up display name
        /// and description, and the Ids of those resources inside the resource file.
        /// </summary>
        public LocalizedExportCodeAnalysisRuleAttribute(
            string id,
            string resourceBaseName,
            string displayNameResourceId,
            string descriptionResourceId)
            : base(id, null)
        {
            _resourceBaseName = resourceBaseName;
            _displayNameResourceId = displayNameResourceId;
            _descriptionResourceId = descriptionResourceId;
        }

        /// <summary>
        /// Rules in a different assembly would need to overwrite this
        /// </summary>
        /// <returns></returns>
        protected virtual Assembly GetAssembly()
        {
            return GetType().Assembly;
        }

        private void EnsureResourceManagerInitialized()
        {
            var resourceAssembly = GetAssembly();

            try
            {
                _resourceManager = new ResourceManager(_resourceBaseName, resourceAssembly);
            }
            catch (Exception ex)
            {
                var msg = String.Format(CultureInfo.CurrentCulture, RuleResources.CannotCreateResourceManager, _resourceBaseName, resourceAssembly);
                throw new RuleException(msg, ex);
            }
        }

        private string GetResourceString(string resourceId)
        {
            EnsureResourceManagerInitialized();
            return _resourceManager.GetString(resourceId, CultureInfo.CurrentUICulture);
        }

        /// <summary>
        /// Overrides the standard DisplayName and looks up its value inside a resources file
        /// </summary>
        public override string DisplayName
        {
            get
            {
                if (_displayName == null)
                {
                    _displayName = GetResourceString(_displayNameResourceId);
                }
                return _displayName;
            }
        }

        /// <summary>
        /// Overrides the standard Description and looks up its value inside a resources file
        /// </summary>
        public override string Description
        {
            get
            {
                if (_descriptionValue == null)
                {
                    _descriptionValue = GetResourceString(_descriptionResourceId);
                }
                return _descriptionValue;
            }
        }
    }
}

Schritt 2.3: Hinzufügen einer Ressourcendatei und dreier Ressourcenzeichenfolgen

Als Nächstes fügen Sie eine Ressourcendatei hinzu, die den Regelnamen, die Regelbeschreibung und die Kategorie definiert, unter denen die Regel auf der Oberfläche zur Regelkonfiguration angezeigt wird.

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus. Wählen Sie im Menü Projekt erst Hinzufügen und dann Neues Element aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt.
Wählen Sie in der Liste Installierte Vorlagen den Eintrag Allgemein aus. Wählen Sie im Detailbereich Ressourcendatei aus.
Geben Sie in Nameden Namen RuleResources.resxein. Der Ressourcen-Editor wird ohne definierte Ressourcen angezeigt.

Definieren Sie wie folgt vier Ressourcenzeichenfolgen:

Name	Wert
`AvoidWaitForDelay_ProblemDescription`	`WAITFOR DELAY statement was found in {0}.`
`AvoidWaitForDelay_RuleName`	`Avoid using WaitFor Delay statements in stored procedures, functions and triggers.`
`CategorySamples`	`SamplesCategory`
`CannotCreateResourceManager`	`Can't create ResourceManager for {0} from {1}.`

Wählen Sie im Menü Datei die Option RuleResources.resx speichern aus.

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus. Wählen Sie im Menü Projekt erst Hinzufügen und dann Neues Element aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt.
Wählen Sie in der Liste Installierte Vorlagen den Eintrag Allgemein aus. Wählen Sie im Detailbereich Ressourcendatei aus.
Geben Sie in Nameden Namen RuleResources.resxein. Der Ressourcen-Editor wird ohne definierte Ressourcen angezeigt.

Definieren Sie wie folgt vier Ressourcenzeichenfolgen:

Name	Wert
`AvoidWaitForDelay_ProblemDescription`	`WAITFOR DELAY statement was found in {0}.`
`AvoidWaitForDelay_RuleName`	`Avoid using WaitFor Delay statements in stored procedures, functions and triggers.`
`CategorySamples`	`SamplesCategory`
`CannotCreateResourceManager`	`Can't create ResourceManager for {0} from {1}.`

Wählen Sie im Menü Datei die Option RuleResources.resx speichern aus.

Erstellen Sie im Verzeichnis SampleRules eine neue Datei namens RuleResources.resx.

Öffnen Sie die Datei RuleResources.resx, und fügen Sie den folgenden Code hinzu:

<?xml version="1.0" encoding="utf-8"?>
<root>
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="AvoidWaitForDelay_ProblemDescription" xml:space="preserve">
    <value>WAITFOR DELAY statement was found in {0}</value>
  </data>
  <data name="AvoidWaitFormDelay_RuleName" xml:space="preserve">
    <value>Avoid using WaitFor Delay statements in stored procedures, functions and triggers.</value>
  </data>
  <data name="CategorySamples" xml:space="preserve">
    <value>SamplesCategory</value>
  </data>
  <data name="CannotCreateResourceManager" xml:space="preserve">
    <value>Can't create ResourceManager for {0} from {1}</value>
  </data>
</root>

Speichern Sie die Datei RuleResources.resx.

Öffnen Sie die SampleRules.csproj-Datei, und fügen Sie den folgenden Code hinzu, um den Ressourceninhalt im Projekt zu aktualisieren und einzuschließen:

<ItemGroup>
  <Compile Update="RuleResources.Designer.cs">
    <DesignTime>True</DesignTime>
    <AutoGen>True</AutoGen>
    <DependentUpon>RuleResources.resx</DependentUpon>
  </Compile>
</ItemGroup>
<ItemGroup>
  <EmbeddedResource Include="RuleResources.resx">
    <Generator>PublicResXFileCodeGenerator</Generator>
    <LastGenOutput>RuleResources.Designer.cs</LastGenOutput>
  </EmbeddedResource>
</ItemGroup>

Speichern Sie die Datei SampleRules.csproj.

Erstellen Sie im Verzeichnis SampleRules eine neue Datei namens RuleResources.resx.

Öffnen Sie die Datei RuleResources.resx, und fügen Sie den folgenden Code hinzu:

<?xml version="1.0" encoding="utf-8"?>
<root>
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="AvoidWaitForDelay_ProblemDescription" xml:space="preserve">
    <value>WAITFOR DELAY statement was found in {0}</value>
  </data>
  <data name="AvoidWaitFormDelay_RuleName" xml:space="preserve">
    <value>Avoid using WaitFor Delay statements in stored procedures, functions and triggers.</value>
  </data>
  <data name="CategorySamples" xml:space="preserve">
    <value>SamplesCategory</value>
  </data>
  <data name="CannotCreateResourceManager" xml:space="preserve">
    <value>Can't create ResourceManager for {0} from {1}</value>
  </data>
</root>

Speichern Sie die Datei RuleResources.resx.

Öffnen Sie die SampleRules.csproj-Datei, und fügen Sie den folgenden Code hinzu, um den Ressourceninhalt im Projekt zu aktualisieren und einzuschließen:

<ItemGroup>
  <Compile Update="RuleResources.Designer.cs">
    <DesignTime>True</DesignTime>
    <AutoGen>True</AutoGen>
    <DependentUpon>RuleResources.resx</DependentUpon>
  </Compile>
</ItemGroup>
<ItemGroup>
  <EmbeddedResource Include="RuleResources.resx">
    <Generator>PublicResXFileCodeGenerator</Generator>
    <LastGenOutput>RuleResources.Designer.cs</LastGenOutput>
  </EmbeddedResource>
</ItemGroup>

Speichern Sie die Datei SampleRules.csproj.

Schritt 2.4: Definieren der Klasse SampleConstants

Im nächsten Schritt definieren Sie eine Klasse, die auf die Ressourcen in der Ressourcendatei verweist, die von Visual Studio zum Anzeigen von Informationen über Ihre Regel auf der Benutzeroberfläche verwendet werden.

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus.
Wählen Sie im Menü Projekt erst Hinzufügen und dann Klasse aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt. Geben Sie im Textfeld Name den Namen SampleRuleConstants.cs ein, und wählen Sie die Schaltfläche Hinzufügen aus. Daraufhin wird die Datei SampleRuleConstants.cs dem Projekt im Projektmappen-Explorer hinzugefügt.

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus.
Wählen Sie im Menü Projekt erst Hinzufügen und dann Klasse aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt. Geben Sie im Textfeld Name den Namen SampleRuleConstants.cs ein, und wählen Sie die Schaltfläche Hinzufügen aus. Daraufhin wird die Datei SampleRuleConstants.cs dem Projekt im Projektmappen-Explorer hinzugefügt.

Navigieren Sie zu dem SampleRules-Verzeichnis in der Explorer-Ansicht in Visual Studio Code.
Erstelle eine neue Datei mit dem Namen SampleRuleConstants.cs.

Navigieren Sie zum Verzeichnis SampleRules.
Erstelle eine neue Datei mit dem Namen SampleRuleConstants.cs.

Öffnen Sie die Datei SampleRuleConstants.cs, und fügen Sie der Datei mit Anweisungen Folgendes hinzu:

namespace SampleRules
{
    internal static class RuleConstants
    {
        /// <summary>
        /// The name of the resources file to use when looking up rule resources
        /// </summary>
        public const string ResourceBaseName = "Public.Dac.Samples.Rules.RuleResources";

        /// <summary>
        /// Lookup name inside the resources file for the select asterisk rule name
        /// </summary>
        public const string AvoidWaitForDelay_RuleName = "AvoidWaitForDelay_RuleName";
        /// <summary>
        /// Lookup ID inside the resources file for the select asterisk description
        /// </summary>
        public const string AvoidWaitForDelay_ProblemDescription = "AvoidWaitForDelay_ProblemDescription";

        /// <summary>
        /// The design category (should not be localized)
        /// </summary>
        public const string CategoryDesign = "Design";

        /// <summary>
        /// The performance category (should not be localized)
        /// </summary>
        public const string CategoryPerformance = "Design";
    }
}

Klicken Sie im Menü File (Datei) auf Save (Speichern).

Schritt 3: Erstellen einer benutzerdefinierten -Regelklasse

Nachdem Sie die Hilfsklassen hinzugefügt haben, die von der benutzerdefinierten Codeanalyseregel verwendet werden, erstellen Sie eine benutzerdefinierte Regelklasse, die Sie AvoidWaitForDelayRule nennen. Die benutzerdefinierte Regel AvoidWaitForDelayRule trägt dazu bei, dass bei der Datenbankentwicklung WAITFOR DELAY-Anweisungen in gespeicherten Prozeduren, Triggern und Funktionen vermieden werden.

Schritt 3.1: Erstellen der Klasse AvoidWaitForDelayRule

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus.
Wählen Sie im Menü Projekt erst Hinzufügen und dann Klasse aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt. Geben Sie im Textfeld Name den Namen AvoidWaitForDelayRule.cs ein, und wählen Sie dann Hinzufügen aus. Daraufhin wird die Datei AvoidWaitForDelayRule.cs dem Projekt im Projektmappen-Explorer hinzugefügt.

Wählen Sie im Projektmappen-Explorer das SampleRules-Projekt aus.
Wählen Sie im Menü Projekt erst Hinzufügen und dann Klasse aus. Das Dialogfeld Neues Element hinzufügen wird angezeigt. Geben Sie im Textfeld Name den Namen AvoidWaitForDelayRule.cs ein, und wählen Sie dann Hinzufügen aus. Daraufhin wird die Datei AvoidWaitForDelayRule.cs dem Projekt im Projektmappen-Explorer hinzugefügt.

Navigieren Sie zu dem SampleRules-Verzeichnis in der Explorer-Ansicht in Visual Studio Code.
Erstelle eine neue Datei mit dem Namen AvoidWaitForDelayRule.cs.

Navigieren Sie zum Verzeichnis SampleRules.
Erstelle eine neue Datei mit dem Namen AvoidWaitForDelayRule.cs.

Öffnen Sie die Datei AvoidWaitForDelayRule.cs, und fügen Sie der Datei mit Anweisungen Folgendes hinzu:

using Microsoft.SqlServer.Dac.CodeAnalysis;
using Microsoft.SqlServer.Dac.Model;
using Microsoft.SqlServer.TransactSql.ScriptDom;
using System;
using System.Collections.Generic;
using System.Globalization;
namespace SampleRules {
    class AvoidWaitForDelayRule {}
}

Ändern Sie in der Deklaration der Klasse AvoidWaitForDelayRule den Zugriffsmodifizierer in öffentlich:

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

Leiten Sie die Klasse AvoidWaitForDelayRule aus der Basisklasse Microsoft.SqlServer.Dac.CodeAnalysis.SqlCodeAnalysisRule ab:
```
public sealed class AvoidWaitForDelayRule : SqlCodeAnalysisRule
```
Fügen Sie Ihrer Klasse den LocalizedExportCodeAnalysisRuleAttribute hinzu.

Mithilfe von LocalizedExportCodeAnalysisRuleAttribute kann der Codeanalysedienst benutzerdefinierte Codeanalyseregeln erkennen. Nur Klassen, die mit dem ExportCodeAnalysisRuleAttribute (oder einem Attribut, das von diesem erbt) gekennzeichnet sind, können in der Codeanalyse verwendet werden.

LocalizedExportCodeAnalysisRuleAttribute stellt einige erforderliche Metadaten bereit, die vom Dienst genutzt werden. Dazu gehören eine eindeutige ID für diese Regel, ein Anzeigenamen, der in der Visual Studio-Benutzeroberfläche angezeigt wird, und eine Description, die von der Regel beim Identifizieren von Problemen verwendet werden kann.
```
[LocalizedExportCodeAnalysisRule(AvoidWaitForDelayRule.RuleId,
    RuleConstants.ResourceBaseName,
    RuleConstants.AvoidWaitForDelay_RuleName,
    RuleConstants.AvoidWaitForDelay_ProblemDescription
    Category = RuleConstants.CategoryPerformance,
    RuleScope = SqlRuleScope.Element)]
public sealed class AvoidWaitForDelayRule : SqlCodeAnalysisRule
{
   /// <summary>
   /// The Rule ID should resemble a fully-qualified class name. In the Visual Studio UI
   /// rules are grouped by "Namespace + Category", and each rule is shown using "Short ID: DisplayName".
   /// For this rule, that means the grouping will be "Public.Dac.Samples.Performance", with the rule
   /// shown as "SR1004: Avoid using WaitFor Delay statements in stored procedures, functions and triggers."
   /// </summary>
   public const string RuleId = "RuleSamples.SR1004";
}
```
Die Eigenschaft RuleScope sollte Microsoft.SqlServer.Dac.CodeAnalysis.SqlRuleScope.Element lauten, da diese Regel bestimmte Elemente analysiert. Die Regel wird für jedes passende Element im Modell ein Mal aufgerufen. Wenn Sie ein gesamtes Modell analysieren möchten, können Sie stattdessen Microsoft.SqlServer.Dac.CodeAnalysis.SqlRuleScope.Model verwenden.

Fügen Sie einen Konstruktor hinzu, der Microsoft.SqlServer.Dac.CodeAnalysis.SqlAnalysisRule.SupportedElementTypes einrichtet. Dies ist für Regeln mit einem Gültigkeitsbereich auf Elementebene erforderlich. Er definiert die Arten von Elementen, auf die diese Regel angewendet wird. In diesem Fall wird die Regel auf gespeicherte Prozeduren, Trigger und Funktionen angewendet. Die Klasse Microsoft.SqlServer.Dac.Model.ModelSchema listet alle verfügbaren Arten von Elementen auf, die analysiert werden können.

public AvoidWaitForDelayRule()
{
   // This rule supports Procedures, Functions and Triggers. Only those objects will be passed to the Analyze method
   SupportedElementTypes = new[]
   {
      // Note: can use the ModelSchema definitions, or access the TypeClass for any of these types
      ModelSchema.ExtendedProcedure,
      ModelSchema.Procedure,
      ModelSchema.TableValuedFunction,
      ModelSchema.ScalarFunction,

      ModelSchema.DatabaseDdlTrigger,
      ModelSchema.DmlTrigger,
      ModelSchema.ServerDdlTrigger
   };
}

Fügen Sie eine Außerkraftsetzung für die Methode Microsoft.SqlServer.Dac.CodeAnalysis.SqlAnalysisRule.Analyze (Microsoft.SqlServer.Dac.CodeAnalysis.SqlRuleExecutionContext) hinzu, die Microsoft.SqlServer.Dac.CodeAnalysis.SqlRuleExecutionContext als Eingabeparameter nutzt. Diese Methode gibt eine Liste der potenziellen Probleme zurück.

Die Methode ruft Microsoft.SqlServer.Dac.Model.TSqlModel, Microsoft.SqlServer.Dac.Model.TSqlObject und TSqlFragment aus dem Kontextparameter ab. Anschließend wird mithilfe der Klasse WaitForDelayVisitor eine Liste aller WAITFOR DELAY-Anweisungen im Modell abgerufen.

Für jede WaitForStatement in dieser Liste wird eine Microsoft.SqlServer.Dac.CodeAnalysis.SqlRuleProblem erstellt.

/// <summary>
/// For element-scoped rules the Analyze method is executed once for every matching
/// object in the model.
/// </summary>
/// <param name="ruleExecutionContext">The context object contains the TSqlObject being
/// analyzed, a TSqlFragment
/// that's the AST representation of the object, the current rule's descriptor, and a
/// reference to the model being
/// analyzed.
/// </param>
/// <returns>A list of problems should be returned. These will be displayed in the Visual
/// Studio error list</returns>
public override IList<SqlRuleProblem> Analyze(
    SqlRuleExecutionContext ruleExecutionContext)
{
     IList<SqlRuleProblem> problems = new List<SqlRuleProblem>();

     TSqlObject modelElement = ruleExecutionContext.ModelElement;

     // this rule does not apply to inline table-valued function
     // we simply do not return any problem in that case.
     if (IsInlineTableValuedFunction(modelElement))
     {
         return problems;
     }

     string elementName = GetElementName(ruleExecutionContext, modelElement);

     // The rule execution context has all the objects we'll need, including the
     // fragment representing the object,
     // and a descriptor that lets us access rule metadata
     TSqlFragment fragment = ruleExecutionContext.ScriptFragment;
     RuleDescriptor ruleDescriptor = ruleExecutionContext.RuleDescriptor;

     // To process the fragment and identify WAITFOR DELAY statements we will use a
     // visitor
     WaitForDelayVisitor visitor = new WaitForDelayVisitor();
     fragment.Accept(visitor);
     IList<WaitForStatement> waitforDelayStatements = visitor.WaitForDelayStatements;

     // Create problems for each WAITFOR DELAY statement found
     // When creating a rule problem, always include the TSqlObject being analyzed. This
     // is used to determine
     // the name of the source this problem was found in and a best guess as to the
     // line/column the problem was found at.
     //
     // In addition if you have a specific TSqlFragment that is related to the problem
     //also include this
     // since the most accurate source position information (start line and column) will
     // be read from the fragment
     foreach (WaitForStatement waitForStatement in waitforDelayStatements)
     {
        SqlRuleProblem problem = new SqlRuleProblem(
            String.Format(CultureInfo.CurrentCulture,
                ruleDescriptor.DisplayDescription, elementName),
            modelElement,
            waitForStatement);
        problems.Add(problem);
    }
    return problems;
}

private static string GetElementName(
    SqlRuleExecutionContext ruleExecutionContext,
    TSqlObject modelElement)
{
    // Get the element name using the built in DisplayServices. This provides a number of
    // useful formatting options to
    // make a name user-readable
    var displayServices = ruleExecutionContext.SchemaModel.DisplayServices;
    string elementName = displayServices.GetElementName(
        modelElement, ElementNameStyle.EscapedFullyQualifiedName);
    return elementName;
}

private static bool IsInlineTableValuedFunction(TSqlObject modelElement)
{
    return TableValuedFunction.TypeClass.Equals(modelElement.ObjectType)
                   && FunctionType.InlineTableValuedFunction ==
        modelElement.GetMetadata<FunctionType>(TableValuedFunction.FunctionType);
}

Wählen Sie im Menü Datei die Option Speichernaus.

Schritt 4: Erstellen der Klassenbibliothek

Wählen Sie im Menü Projekt die Eigenschaften von SampleRules aus.
Wählen Sie die Registerkarte Signieren aus.
Wählen Sie Assembly signieren aus.
Wählen Sie in Schlüsseldatei mit starkem Namen auswählen die Option <Neu> aus.
Geben Sie im Dialogfeld Schlüssel mit starkem Namen erstellen unter Schlüsseldateiname den Namen MyRefKey ein.
(optional) Sie können ein Kennwort für Ihre Schlüsseldatei mit starkem Namen angeben.
Wählen Sie OK aus.
Wählen Sie im Menü Datei den Befehl Alle speichern aus.
Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

Wählen Sie im Menü Projekt die Eigenschaften von SampleRules aus.
Wählen Sie die Registerkarte Signieren aus.
Wählen Sie Assembly signieren aus.
Wählen Sie in Schlüsseldatei mit starkem Namen auswählen die Option <Neu> aus.
Geben Sie im Dialogfeld Schlüssel mit starkem Namen erstellen unter Schlüsseldateiname den Namen MyRefKey ein.
(optional) Sie können ein Kennwort für Ihre Schlüsseldatei mit starkem Namen angeben.
Wählen Sie OK aus.
Wählen Sie im Menü Datei den Befehl Alle speichern aus.
Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

Öffnen Sie in Visual Studio Code das Terminal-Fenster, indem Sie das Menü Anzeigen und dann Terminal wählen.
Geben Sie im Terminal den folgenden Befehl ein, um das Projekt zu erstellen:
```
dotnet build /p:Configuration=Release
```

Navigieren Sie zum Verzeichnis SampleRules.
Führen Sie den folgenden Befehl aus, um das Projekt zu erstellen:
```
dotnet build /p:Configuration=Release
```

Schritt 5: Installieren und Testen der neuen Codeanalyseregel

Als Nächstes müssen Sie die Assembly installieren, damit sie geladen wird, wenn Sie ein SQL-Datenbankprojekt erstellen.

Um eine Regel zu installieren, die beim Erstellen eines ursprünglichen SQL-Projekts mit Visual Studio ausgeführt wird, müssen Sie die Assembly und die zugeordnete .pdb-Datei in den Ordner „Erweiterungen“ kopieren.

Schritt 5.1: Installieren der SampleRules-Assembly

Als Nächstes kopieren Sie die Assembly-Informationen in das Verzeichnis „Erweiterungen“. Beim Start von Visual Studio werden alle Erweiterungen im Verzeichnis <Visual Studio Install Dir>\Common7\IDE\Extensions\Microsoft\SQLDB\DAC\Extensions und in den zugehörigen Unterverzeichnissen identifiziert und für die Nutzung zur Verfügung gestellt.

Für Visual Studio 2022 lautet das <Visual Studio Install Dir> in der Regel C:\Program Files\Microsoft Visual Studio\2022\Enterprise. Ersetzen Sie Enterprise abhängig von der installierten Visual Studio-Edition durch Professional oder Community.

Kopieren Sie die Assembly-Datei SampleRules.dll aus dem Ausgabeverzeichnis in das <Visual Studio Install Dir>\Common7\IDE\Extensions\Microsoft\SQLDB\DAC\Extensions-Verzeichnis. Standardmäßig lautet der Pfad der kompilierten .dll-Datei YourSolutionPath\YourProjectPath\bin\Debugoder YourSolutionPath\YourProjectPath\bin\Release.

Hinweis

Möglicherweise müssen Sie das Verzeichnis Extensions erstellen.

Die Regel sollte jetzt installiert sein und angezeigt werden, wenn Sie Visual Studio neu starten. Als Nächstes starten Sie eine neue Visual Studio-Sitzung und erstellen ein Datenbankprojekt.

Schritt 5.2: Starten einer neuen Visual Studio-Sitzung und Erstellen eines Datenbankprojekts

Starten Sie eine zweite Visual Studio-Sitzung.
Wählen Sie Datei>Neu>Projekt aus.
Suchen Sie im Dialogfeld Neues Projekt nach SQL Server-Datenbankprojekt, und wählen Sie das Projekt aus.
Geben Sie im Textfeld Name den Namen SampleRulesDB ein, und wählen Sie OK aus.

Schritt 5.3: Aktivieren der Codeanalyseregel „AvoidWaitForRule“

Wählen Sie im Projektmappen-Explorer das SampleRulesDB-Projekt aus.
Wählen Sie im Menü Projekt die Option Eigenschaften aus. Daraufhin wird die Eigenschaftenseite von SampleRulesDB angezeigt.
Wählen Sie Code Analysis aus. Es sollte eine neue Kategorie mit dem Namen RuleSamples.CategorySamples angezeigt werden.
Erweitern Sie RuleSamples.CategorySamples. Es sollte SR1004: Avoid WAITFOR DELAY statement in stored procedures, triggers, and functions angezeigt werden.
Aktivieren Sie diese Regel, indem Sie das Kontrollkästchen neben dem Regelnamen und dem Kontrollkästchen für die Codeanalyse beim Build aktivieren. Weitere Informationen zum Aktivieren der Codeanalyse finden Sie in der Übersicht über die Codeanalyse.
Wenn die Projekt-Build-Aktion verwendet wird, wird die Regel ausgeführt, und alle gefundenen WAITFOR DELAY-Anweisungen werden als Warnungen gemeldet.

Schritt 5.1: Installieren der SampleRules-Assembly

Hinweis

Möglicherweise müssen Sie das Verzeichnis Extensions erstellen.

Die Regel sollte jetzt installiert sein und angezeigt werden, wenn Sie Visual Studio neu starten. Als Nächstes starten Sie eine neue Visual Studio-Sitzung und erstellen ein Datenbankprojekt.

Schritt 5.2: Starten einer neuen Visual Studio-Sitzung und Erstellen eines Datenbankprojekts

Starten Sie eine zweite Visual Studio-Sitzung.
Wählen Sie Datei>Neu>Projekt aus.
Suchen Sie im Dialogfeld Neues Projekt nach SQL Server-Datenbankprojekt, SDK-Stil (Vorschau), und wählen Sie das Projekt aus.
Geben Sie im Textfeld Name den Namen SampleRulesDB ein, und wählen Sie OK aus.

Schritt 5.3: Aktivieren der Codeanalyseregel „AvoidWaitForRule“

Wählen Sie im Projektmappen-Explorer das SampleRulesDB-Projekt aus.
Doppelklicken auf den Projektknoten, um die Projektdatei zu öffnen. Die SampleRulesDB-Projektdatei wird in einem Text-Editor angezeigt.
Aktivieren Sie die Codeanalyse beim Erstellen in der SQL-Projektdatei, indem Sie die RunSqlCodeAnalysis-Eigenschaft auf true festlegen.
Wenn die Projekt-Build-Aktion verwendet wird, wird die Regel ausgeführt, und alle gefundenen WAITFOR DELAY-Anweisungen werden als Warnungen gemeldet.

Eine Problemumgehung ist für SDK-Projekte verfügbar, um benutzerdefinierte Regeln zu installieren, bis Paketverweise unterstützt werden.

Führen Sie die Ausführung dotnet restore aus, um die Projektabhängigkeiten für das SQL-Projekt wiederherzustellen, und stellen Sie sicher, dass der lokale NuGet-Paketcache Microsoft.Build.Sql enthält.
Beachten Sie die Version von Microsoft.Build.Sql, die in der SQL-Projektdatei verwendet wird, z. B. 0.1.19-preview.
Kopieren Sie die Assembly-Datei SampleRules.dll aus dem Ausgabeverzeichnis in das ~/.nuget/packages/microsoft.build.sql/0.1.19-preview/tools/netstandard2.1-Verzeichnis. Der genaue Verzeichnispfad kann je nach Version von Microsoft.Build.Sql variieren, die in der SQL-Projektdatei verwendet wird.
Aktivieren Sie die Codeanalyse beim Erstellen in der SQL-Projektdatei, indem Sie die RunSqlCodeAnalysis-Eigenschaft auf true festlegen.
Führen Sie dotnet build zum Erstellen des SQL-Projekts aus und führen Sie die benutzerdefinierte Regel aus.

Eine Problemumgehung ist für SDK-Projekte verfügbar, um benutzerdefinierte Regeln zu installieren, bis Paketverweise unterstützt werden.

Führen Sie die Ausführung dotnet restore aus, um die Projektabhängigkeiten für das SQL-Projekt wiederherzustellen, und stellen Sie sicher, dass der lokale NuGet-Paketcache Microsoft.Build.Sql enthält.
Beachten Sie die Version von Microsoft.Build.Sql, die in der SQL-Projektdatei verwendet wird, z. B. 0.1.19-preview.
Kopieren Sie die Assembly-Datei SampleRules.dll aus dem Ausgabeverzeichnis in das ~/.nuget/packages/microsoft.build.sql/0.1.19-preview/tools/netstandard2.1-Verzeichnis. Der genaue Verzeichnispfad kann je nach Version von Microsoft.Build.Sql variieren, die in der SQL-Projektdatei verwendet wird.
Aktivieren Sie die Codeanalyse beim Erstellen in der SQL-Projektdatei, indem Sie die RunSqlCodeAnalysis-Eigenschaft auf true festlegen.
Führen Sie dotnet build zum Erstellen des SQL-Projekts aus und führen Sie die benutzerdefinierte Regel aus.

Freigeben über

Erstellen von benutzerdefinierten Codeanalyseregeln

Voraussetzungen

Schritt 1: Erstellen eines Klassenbibliotheksprojekt

Schritt 2: Erstellen benutzerdefinierter Regelhilfsprogrammklassen

Schritt 2.1: Definieren der Klasse WaitForDelayVisitor

Schritt 2.2: Definieren der Klasse LocalizedExportCodeAnalysisRuleAttribute

Schritt 2.3: Hinzufügen einer Ressourcendatei und dreier Ressourcenzeichenfolgen

Schritt 2.4: Definieren der Klasse SampleConstants

Schritt 3: Erstellen einer benutzerdefinierten -Regelklasse

Schritt 3.1: Erstellen der Klasse AvoidWaitForDelayRule

Schritt 4: Erstellen der Klassenbibliothek

Schritt 5: Installieren und Testen der neuen Codeanalyseregel

Schritt 5.1: Installieren der SampleRules-Assembly

Schritt 5.2: Starten einer neuen Visual Studio-Sitzung und Erstellen eines Datenbankprojekts

Schritt 5.3: Aktivieren der Codeanalyseregel „AvoidWaitForRule“

Schritt 5.1: Installieren der SampleRules-Assembly

Schritt 5.2: Starten einer neuen Visual Studio-Sitzung und Erstellen eines Datenbankprojekts

Schritt 5.3: Aktivieren der Codeanalyseregel „AvoidWaitForRule“

Feedback

Zusätzliche Ressourcen

Freigeben über

Erstellen von benutzerdefinierten Codeanalyseregeln

Voraussetzungen

Schritt 1: Erstellen eines Klassenbibliotheksprojekt

Schritt 2: Erstellen benutzerdefinierter Regelhilfsprogrammklassen

Schritt 2.1: Definieren der Klasse WaitForDelayVisitor

Schritt 2.2: Definieren der Klasse LocalizedExportCodeAnalysisRuleAttribute

Schritt 2.3: Hinzufügen einer Ressourcendatei und dreier Ressourcenzeichenfolgen

Schritt 2.4: Definieren der Klasse SampleConstants

Schritt 3: Erstellen einer benutzerdefinierten -Regelklasse

Schritt 3.1: Erstellen der Klasse AvoidWaitForDelayRule

Schritt 4: Erstellen der Klassenbibliothek

Schritt 5: Installieren und Testen der neuen Codeanalyseregel

Schritt 5.1: Installieren der SampleRules-Assembly

Schritt 5.2: Starten einer neuen Visual Studio-Sitzung und Erstellen eines Datenbankprojekts

Schritt 5.3: Aktivieren der Codeanalyseregel „AvoidWaitForRule“

Schritt 5.1: Installieren der SampleRules-Assembly

Schritt 5.2: Starten einer neuen Visual Studio-Sitzung und Erstellen eines Datenbankprojekts

Schritt 5.3: Aktivieren der Codeanalyseregel „AvoidWaitForRule“

Zugehöriger Inhalt

Feedback

Zusätzliche Ressourcen