Anleitung: Erweitern des Datenbankprojekt-Builds zum Generieren von Modellstatistiken

Sie können einen Buildmitwirkenden erstellen, um benutzerdefinierte Aktionen auszuführen, wenn Sie ein Datenbankprojekt erstellen. In dieser exemplarischen Vorgehensweise erstellen Sie einen Buildmitwirkenden mit dem Namen ModelStatistics, der Statistiken aus dem SQL-Datenbankmodell ausgibt, wenn Sie ein Datenbankprojekt erstellen. Da diese Build-Komponente während des Build-Prozesses Parameter verwendet, sind einige zusätzliche Schritte erforderlich.

In diesem Durchlauf führen Sie die folgenden wichtigen Aufgaben aus:

• Erstellen eines Erstellungs-Contributors
• Installieren des Erstellungs-Contributors
• Testen des Erstellungs-Contributors

Voraussetzungen

Sie benötigen die folgenden Komponenten, um diese Schritt-für-Schritt-Anleitung abzuschließen.

• Sie müssen eine Version von Visual Studio installiert haben, die SQL Server Data Tools (SSDT) enthält und die C#- oder Visual Basic-Entwicklung (VB) unterstützt.

• Sie müssen über ein SQL-Projekt verfügen, das SQL-Objekte enthält.

Hintergrund eines Mitwirkenden erstellen

Die Erstellungs-Contributors werden während des Projekterstellens und nach dem Generieren des Modells ausgeführt, das das Projekt darstellt, aber vor dem Speichern des Projekts auf dem Datenträger. Sie können für mehrere Szenarien verwendet werden, z. B.:

• Überprüfen der Modellinhalte und Melden von Überprüfungsfehlern an den Aufrufer. Dies kann durch Hinzufügen von Fehlern zu einer Liste erfolgen, die als Parameter an die OnExecute-Methode übergeben wird.

• Generieren von Modellstatistiken und Berichterstellung für den Benutzer. Dies ist das hier gezeigte Beispiel.

Der Haupteinstiegspunkt für Buildmitwirkende ist die OnExecute-Methode. Alle Klassen, die von BuildContributor erben, müssen diese Methode implementieren. Ein BuildContributorContext-Objekt wird an diese Methode übergeben – dies enthält alle relevanten Daten für den Build, z. B. ein Modell der Datenbank, Buildeigenschaften und Argumente/Dateien, die von Buildmitwirkenden verwendet werden sollen.

TSqlModel und die Datenbankmodell-API

Das nützlichste Objekt ist das Datenbankmodell, dargestellt durch ein TSqlModel-Objekt. Dies ist eine logische Darstellung einer Datenbank, einschließlich aller Tabellen, Ansichten und anderen Elemente sowie der Beziehungen zwischen ihnen. Es gibt ein stark typiertes Schema, das verwendet werden kann, um bestimmte Typen von Elementen abzufragen und interessante Beziehungen zu durchlaufen. Beispiele dafür, wie dies verwendet wird, finden Sie im Schritt-für-Schritt-Code.

Hier sind einige der Befehle, die vom Beispiel-Contributor in dieser exemplarischen Vorgehensweise verwendet werden:

Eindeutige Identifizierung Ihres Mitwirkenden

Während des Erstellungsprozesses werden benutzerdefinierte Contributors aus dem Standarderweiterungsverzeichnis geladen. Buildmitwirkende werden durch ein ExportBuildContributor Attribut identifiziert. Dieses Attribut ist erforderlich, damit Mitwirkende ermittelt werden können. Dieses Attribut sollte dem folgenden Code ähneln:

[ExportBuildContributor("ExampleContributors.ModelStatistics", "1.0.0.0")]

In diesem Fall sollte der erste Parameter für das Attribut ein eindeutiger Bezeichner sein – dies wird verwendet, um Ihren Mitwirkenden in Projektdateien zu identifizieren. Es wird empfohlen, den Namespace Ihrer Bibliothek (in dieser exemplarischen Vorgehensweise "ExampleContributors") mit dem Klassennamen (in dieser exemplarischen Vorgehensweise "ModelStatistics") zu kombinieren, um den Bezeichner zu erzeugen. Sie sehen, wie dieser Namespace verwendet wird, um anzugeben, dass der Mitwirkende später in der Anleitung ausgeführt werden soll.

Erstellen eines Build Contributors

Um einen Mitwirkenden für den Build-Prozess zu erstellen, müssen Sie die folgenden Aufgaben ausführen:

• Erstellen Sie ein Klassenbibliotheksprojekt, und fügen Sie erforderliche Verweise hinzu.

• Definieren Sie eine Klasse mit dem Namen ModelStatistics, die von BuildContributor-erbt.

• Überschreiben Sie die OnExecute-Methode.

• Fügen Sie einige private Hilfsmethoden hinzu.

• Erstellen Sie die resultierende Assembly.

Erstellen eines Klassenbibliotheksprojekts

1. Erstellen Sie ein Visual Basic- oder C#-Klassenbibliotheksprojekt mit dem Namen "MyBuildContributor".

2. Benennen Sie die Datei "Class1.cs" in "ModelStatistics.cs" um.

3. Klicken Sie im Projekt-Explorer mit der rechten Maustaste auf den Projektknoten und wählen dann "Verweis hinzufügen" aus.

4. Wählen Sie den Eintrag "System.ComponentModel.Composition" und dann "OK" aus.

5. Fügen Sie erforderliche SQL-Verweise hinzu: Klicken Sie mit der rechten Maustaste auf den Projektknoten, und wählen Sie dann "Verweis hinzufügen" aus. Wählen Sie die Schaltfläche "Durchsuchen" aus . Navigieren Sie zum Ordner C:\Program Files (x86)\Microsoft SQL Server\110\DAC\Bin. Wählen Sie die EinträgeMicrosoft.SqlServer.Dac.dll, Microsoft.SqlServer.Dac.Extensions.dllund Microsoft.Data.Tools.Schema.Sql.dll aus, und wählen Sie dann "OK" aus.

   Als Nächstes beginnen Sie mit dem Hinzufügen von Code zur Klasse.

Definieren der ModelStatistics-Klasse

1. Die ModelStatistics-Klasse verarbeitet das an die OnExecute-Methode übergebene Datenbankmodell und erzeugt und xml-Bericht, der den Inhalt des Modells enthält.

   Aktualisieren Sie im Code-Editor die ModelStatistics.cs Datei so, dass sie mit dem folgenden Code übereinstimmt:

   using System;
   using System.Collections.Generic;
   using System.IO;
   using System.Linq;
   using System.Xml.Linq;
   using Microsoft.Data.Schema;
   using Microsoft.Data.Schema.Build;
   using Microsoft.Data.Schema.Extensibility;
   using Microsoft.Data.Schema.SchemaModel;
   using Microsoft.Data.Schema.Sql;
   
   namespace ExampleContributors
   {
   /// <summary>
       /// A BuildContributor that generates statistics about a model and saves this to the output directory.
       /// Only runs if a "GenerateModelStatistics=true" contributor argument is set in the project file, or a targets file.
       /// Statistics can be sorted by "none, "name" or "value", with "none" being the default sort behavior.
       ///
       /// To set contributor arguments in a project file, add:
       ///
       /// <PropertyGroup>
       ///     <ContributorArguments Condition="'$(Configuration)' == 'Debug'">
       /// $(ContributorArguments);ModelStatistics.GenerateModelStatistics=true;ModelStatistics.SortModelStatisticsBy="name";
       ///     </ContributorArguments>
       /// <PropertyGroup>
       ///
       /// This generates model statistics when building in Debug mode only - remove the condition to generate in all build modes.
       /// </summary>
       [ExportBuildContributor("ExampleContributors.ModelStatistics", "1.0.0.0")]
       public class ModelStatistics : BuildContributor
       {
           public const string GenerateModelStatistics = "ModelStatistics.GenerateModelStatistics";
           public const string SortModelStatisticsBy = "ModelStatistics.SortModelStatisticsBy";
           public const string OutDir = "ModelStatistics.OutDir";
           public const string ModelStatisticsFilename = "ModelStatistics.xml";
           private enum SortBy { None, Name, Value };
           private static Dictionary<string, SortBy> SortByMap = new Dictionary<string, SortBy>(StringComparer.OrdinalIgnoreCase)
           {
               { "none", SortBy.None },
               { "name", SortBy.Name },
               { "value", SortBy.Value },
           };
   
           private SortBy _sortBy = SortBy.None;
   
           /// <summary>
           /// Override the OnExecute method to perform actions when you build a database project.
           /// </summary>
           protected override void OnExecute(BuildContributorContext context, IList<ExtensibilityError> errors)
           {
               // handle related arguments, passed in as part of
               // the context information.
               bool generateModelStatistics;
               ParseArguments(context.Arguments, errors, out generateModelStatistics);
   
               // Only generate statistics if requested to do so
               if (generateModelStatistics)
               {
                   // First, output model-wide information, such
                   // as the type of database schema provider (DSP)
                   // and the collation.
                   StringBuilder statisticsMsg = new StringBuilder();
                   statisticsMsg.AppendLine(" ")
                                .AppendLine("Model Statistics:")
                                .AppendLine("===")
                                .AppendLine(" ");
                   errors.Add(new ExtensibilityError(statisticsMsg.ToString(), Severity.Message));
   
                   var model = context.Model;
   
                   // Start building up the XML that is serialized later
                   var xRoot = new XElement("ModelStatistics");
   
                   SummarizeModelInfo(model, xRoot, errors);
   
                   // First, count the elements that are contained
                   // in this model.
                   IList<TSqlObject> elements = model.GetObjects(DacQueryScopes.UserDefined).ToList();
                   Summarize(elements, element => element.ObjectType.Name, "UserDefinedElements", xRoot, errors);
   
                   // Now, count the elements that are defined in
                   // another model. Examples include built-in types,
                   // roles, filegroups, assemblies, and any
                   // referenced objects from another database.
                   elements = model.GetObjects(DacQueryScopes.BuiltIn | DacQueryScopes.SameDatabase | DacQueryScopes.System).ToList();
                   Summarize(elements, element => element.ObjectType.Name, "OtherElements", xRoot, errors);
   
                   // Now, count the number of each type
                   // of relationship in the model.
                   SurveyRelationships(model, xRoot, errors);
   
                   // Determine where the user wants to save
                   // the serialized XML file.
                   string outDir;
                   if (context.Arguments.TryGetValue(OutDir, out outDir) == false)
                   {
                       outDir = ".";
                   }
                   string filePath = Path.Combine(outDir, ModelStatisticsFilename);
                   // Save the XML file and tell the user
                   // where it was saved.
                   xRoot.Save(filePath);
                   ExtensibilityError resultArg = new ExtensibilityError("Result was saved to " + filePath, Severity.Message);
                   errors.Add(resultArg);
               }
           }
   
           /// <summary>
           /// Examine the arguments provided by the user
           /// to determine if model statistics should be generated
           /// and, if so, how the results should be sorted.
           /// </summary>
           private void ParseArguments(IDictionary<string, string> arguments, IList<ExtensibilityError> errors, out bool generateModelStatistics)
           {
               // By default, we don't generate model statistics
               generateModelStatistics = false;
   
               // see if the user provided the GenerateModelStatistics
               // option and if so, what value was it given.
               string valueString;
               arguments.TryGetValue(GenerateModelStatistics, out valueString);
               if (string.IsNullOrWhiteSpace(valueString) == false)
               {
                   if (bool.TryParse(valueString, out generateModelStatistics) == false)
                   {
                       generateModelStatistics = false;
   
                       // The value was not valid from the end user
                       ExtensibilityError invalidArg = new ExtensibilityError(
                           GenerateModelStatistics + "=" + valueString + " was not valid.  It can be true or false", Severity.Error);
                       errors.Add(invalidArg);
                       return;
                   }
               }
   
               // Only worry about sort order if the user requested
               // that we generate model statistics.
               if (generateModelStatistics)
               {
                   // see if the user provided the sort option and
                   // if so, what value was provided.
                   arguments.TryGetValue(SortModelStatisticsBy, out valueString);
                   if (string.IsNullOrWhiteSpace(valueString) == false)
                   {
                       SortBy sortBy;
                       if (SortByMap.TryGetValue(valueString, out sortBy))
                       {
                           _sortBy = sortBy;
                       }
                       else
                       {
                           // The value was not valid from the end user
                           ExtensibilityError invalidArg = new ExtensibilityError(
                               SortModelStatisticsBy + "=" + valueString + " was not valid.  It can be none, name, or value", Severity.Error);
                           errors.Add(invalidArg);
                       }
                   }
               }
           }
   
           /// <summary>
           /// Retrieve the database schema provider for the
           /// model and the collation of that model.
           /// Results are output to the console and added to the XML
           /// being constructed.
           /// </summary>
           private static void SummarizeModelInfo(TSqlModel model, XElement xContainer, IList<ExtensibilityError> errors)
           {
               // use a Dictionary to accumulate the information
               // that is later output.
               var info = new Dictionary<string, string>();
   
               // Two things of interest: the database schema
               // provider for the model, and the language id and
               // case sensitivity of the collation of that
               // model
               info.Add("Version", model.Version.ToString());
   
               TSqlObject options = model.GetObjects(DacQueryScopes.UserDefined, DatabaseOptions.TypeClass).FirstOrDefault();
               if (options != null)
               {
                   info.Add("Collation", options.GetProperty<string>(DatabaseOptions.Collation));
               }
   
               // Output the accumulated information and add it to
               // the XML.
               OutputResult("Basic model info", info, xContainer, errors);
           }
   
           /// <summary>
           /// For a provided list of model elements, count the number
           /// of elements for each class name, sorted as specified
           /// by the user.
           /// Results are output to the console and added to the XML
           /// being constructed.
           /// </summary>
           private void Summarize<T>(IList<T> set, Func<T, string> groupValue, string category, XElement xContainer, IList<ExtensibilityError> errors)
           { // Use a Dictionary to keep all summarized information
               var statistics = new Dictionary<string, int>();
   
               // For each element in the provided list,
               // count items based on the specified grouping
               var groups =
                   from item in set
                   group item by groupValue(item) into g
                   select new { g.Key, Count = g.Count() };
   
               // order the groups as requested by the user
               if (this._sortBy == SortBy.Name)
               {
                   groups = groups.OrderBy(group => group.Key);
               }
               else if (this._sortBy == SortBy.Value)
               {
                   groups = groups.OrderBy(group => group.Count);
               }
   
               // build the Dictionary of accumulated statistics
               // that is passed along to the OutputResult method.
               foreach (var item in groups)
               {
                   statistics.Add(item.Key, item.Count);
               }
   
               statistics.Add("subtotal", set.Count);
               statistics.Add("total items", groups.Count());
   
               // output the results, and build up the XML
               OutputResult(category, statistics, xContainer, errors);
           }
   
           /// <summary>
           /// Iterate over all model elements, counting the
           /// styles and types for relationships that reference each
           /// element
           /// Results are output to the console and added to the XML
           /// being constructed.
           /// </summary>
           private static void SurveyRelationships(TSqlModel model, XElement xContainer, IList<ExtensibilityError> errors)
           {
               // get a list that contains all elements in the model
               var elements = model.GetObjects(DacQueryScopes.All);
               // We are interested in all relationships that
               // reference each element.
               var entries =
                   from element in elements
                   from entry in element.GetReferencedRelationshipInstances(DacExternalQueryScopes.All)
                   select entry;
   
               // initialize our counting buckets
               var composing = 0;
               var hierachical = 0;
               var peer = 0;
   
               // process each relationship, adding to the
               // appropriate bucket for style and type.
               foreach (var entry in entries)
               {
                   switch (entry.Relationship.Type)
                   {
                       case RelationshipType.Composing:
                           ++composing;
                           break;
                       case RelationshipType.Hierarchical:
                           ++hierachical;
                           break;
                       case RelationshipType.Peer:
                           ++peer;
                           break;
                       default:
                           break;
                   }
               }
   
               // build a dictionary of data to pass along
               // to the OutputResult method.
               var stat = new Dictionary<string, int>
               {
                   {"Composing", composing},
                   {"Hierarchical", hierachical},
                   {"Peer", peer},
                   {"subtotal", entries.Count()}
               };
   
               OutputResult("Relationships", stat, xContainer, errors);
           }
   
           /// <summary>
           /// Performs the actual output for this contributor,
           /// writing the specified set of statistics, and adding any
           /// output information to the XML being constructed.
           /// </summary>
           private static void OutputResult<T>(string category, Dictionary<string, T> statistics, XElement xContainer, IList<ExtensibilityError> errors)
           {
               var maxLen = statistics.Max(stat => stat.Key.Length) + 2;
               var format = string.Format("{{0, {0}}}: {{1}}", maxLen);
   
               StringBuilder resultMessage = new StringBuilder();
               //List<ExtensibilityError> args = new List<ExtensibilityError>();
               resultMessage.AppendLine(category);
               resultMessage.AppendLine("-----------------");
   
               // Remove any blank spaces from the category name
               var xCategory = new XElement(category.Replace(" ", ""));
               xContainer.Add(xCategory);
   
               foreach (var item in statistics)
               {
                   //Console.WriteLine(format, item.Key, item.Value);
                   var entry = string.Format(format, item.Key, item.Value);
                   resultMessage.AppendLine(entry);
                   // Replace any blank spaces in the element key with
                   // underscores.
                   xCategory.Add(new XElement(item.Key.Replace(' ', '_'), item.Value));
               }
               resultMessage.AppendLine(" ");
               errors.Add(new ExtensibilityError(resultMessage.ToString(), Severity.Message));
           }
       }
   }
   

   Als Nächstes erstellen Sie die Klassenbibliothek.

Signieren und Erstellen der Assembly

1. Wählen Sie im Menü "Projekt" die Option "MyBuildContributor-Eigenschaften" aus.

2. Wählen Sie die Registerkarte " Signieren" aus .

3. Wählen Sie "die Assembly signieren" aus.

4. Wählen Sie in "Wählen Sie eine Datei mit starkem Namenschlüssel" aus, und wählen Sie "Neu"< aus>.

5. Geben Sie im Dialogfeld Schlüssel für einen starken Namen erstellen unter SchlüsseldateinameMyRefKey ein.

6. (optional) Sie können ein Kennwort für die Strong-Name-Schlüsseldatei angeben.

7. Wählen Sie OK aus.

8. Wählen Sie im Menü "Datei " die Option "Alle speichern" aus.

9. Wählen Sie im Menü Erstellen die Option Lösung erstellen.

   Als Nächstes müssen Sie die Assembly installieren, damit sie beim Erstellen von SQL-Projekten geladen wird.

Installieren eines Buildmitwirkenden

Um einen Buildmitwirkenden zu installieren, müssen Sie die Assembly und die zugehörige .pdb Datei in den Ordner "Erweiterungen" kopieren.

Installieren der MyBuildContributor-Assembly

1. Als Nächstes kopieren Sie die Assemblyinformationen in das Verzeichnis "Erweiterungen". Wenn Visual Studio gestartet wird, werden alle Erweiterungen im %ProgramFiles%\Microsoft SQL Server\110\DAC\Bin\Extensions Verzeichnis und den Unterverzeichnissen identifiziert und zur Verwendung zur Verfügung gestellt.

2. Kopieren Sie die MyBuildContributor.dll Assemblydatei aus dem Ausgabeverzeichnis in das %ProgramFiles%\Microsoft SQL Server\110\DAC\Bin\Extensions Verzeichnis.

   Anmerkung

   Standardmäßig lautet der Pfad der kompilierten .dll Datei "YourSolutionPath\YourProjectPath\bin\Debug" oder "YourSolutionPath\YourProjectPath\bin\Release".

Ausführen oder Testen des Buildmitwirkenden

Um Ihren Build Contributor auszuführen oder zu testen, müssen Sie die folgenden Aufgaben durchführen:

• Fügen Sie der .sqlproj Datei, die Sie erstellen möchten, Eigenschaften hinzu.

• Erstellen Sie das Datenbankprojekt mithilfe von MSBuild, und stellen Sie die entsprechenden Parameter bereit.

Hinzufügen von Eigenschaften zur SQL-Projektdatei (SQLPROJ)

Sie müssen die SQL-Projektdatei immer aktualisieren, um die IDs der Mitwirkenden anzugeben, die Sie ausführen möchten. Da dieser Buildmitwirkender Befehlszeilenparameter von MSBuild akzeptiert, müssen Sie das SQL-Projekt ändern, damit Benutzer diese Parameter über MSBuild übergeben können.

Sie können dies auf eine von zwei Arten tun:

• Sie können die .sqlproj Datei manuell ändern, um die erforderlichen Argumente hinzuzufügen. Sie können dies tun, wenn Sie nicht beabsichtigen, den Buildmitwirkenden für eine große Anzahl von Projekten wiederzuverwenden. Wenn Sie diese Option auswählen, fügen Sie der Datei nach dem ersten Importknoten in der .sqlproj Datei die folgenden Anweisungen hinzu:

  <PropertyGroup>
      <BuildContributors>
          $(BuildContributors);ExampleContributors.ModelStatistics
      </BuildContributors>
      <ContributorArguments Condition="'$(Configuration)' == 'Debug'">
          $(ContributorArguments);ModelStatistics.GenerateModelStatistics=true;ModelStatistics.SortModelStatisticsBy=name;
      </ContributorArguments>
  </PropertyGroup>
  

• Die zweite Methode besteht darin, eine Zieldatei zu erstellen, die die erforderlichen Mitwirkendenargumente enthält. Dies ist nützlich, wenn Sie denselben Mitwirkenden für mehrere Projekte verwenden, da sie die Standardwerte enthält.

  Erstellen Sie in diesem Fall eine Zieldatei im MSBuild-Erweiterungspfad:

  1. Navigiere zu %ProgramFiles%\MSBuild.

  2. Erstellen Sie einen neuen Ordner "MyContributors", in dem Ihre Zieldateien gespeichert sind.

  3. Erstellen Sie eine neue Datei "MyContributors.targets" in diesem Verzeichnis, fügen Sie den folgenden Text hinzu, und speichern Sie dann die Datei:

     <?xml version="1.0" encoding="utf-8"?>
     
     <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
       <PropertyGroup>
         <BuildContributors>$(BuildContributors);ExampleContributors.ModelStatistics</BuildContributors>
         <ContributorArguments Condition="'$(Configuration)' == 'Debug'">$(ContributorArguments);ModelStatistics.GenerateModelStatistics=true;ModelStatistics.SortModelStatisticsBy=name;</ContributorArguments>
       </PropertyGroup>
     </Project>
     

  4. Importieren Sie innerhalb der .sqlproj Datei für jedes Projekt, das Sie Mitwirkende ausführen möchten, die Zieldatei, indem Sie die .sqlproj folgende Anweisung zur Datei nach dem <Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\SSDT\Microsoft.Data.Tools.Schema.SqlTasks.targets" /> Knoten in der Datei hinzufügen:

     <Import Project="$(MSBuildExtensionsPath)\MyContributors\MyContributors.targets " />
     

Nachdem Sie eine dieser Ansätze befolgt haben, können Sie MSBuild verwenden, um die Parameter für Befehlszeilenbuilds zu übergeben.

Erstellen des SQL-Projekts

Erstellen Sie Ihr Datenbankprojekt mithilfe von MSBuild neu, und generieren Sie Statistiken.

1. Klicken Sie in Visual Studio mit der rechten Maustaste auf Ihr Projekt, und wählen Sie "Neu erstellen" aus. Dadurch wird das Projekt neu erstellt, und Sie sollten die generierten Modellstatistiken sehen, wobei die Ausgabe in der Buildausgabe enthalten und in ModelStatistics.xmlgespeichert wurde. Möglicherweise müssen Sie "Alle Dateien im Projektmappen-Explorer anzeigen" auswählen, um die XML-Datei anzuzeigen.

2. Öffnen Sie eine Visual Studio-Eingabeaufforderung: Wählen Sie im Startmenü"Alle Programme" aus, wählen Sie "Microsoft Visual Studio Visual Studio-Version <">, dann "Visual Studio-Tools" und dann die Visual Studio-Eingabeaufforderung (<Visual Studio-Version>) aus.

3. Navigieren Sie an der Eingabeaufforderung zu dem Ordner, der Ihr SQL-Projekt enthält.

4. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

   MSBuild /t:Rebuild MyDatabaseProject.sqlproj /p:BuildContributors=$(BuildContributors);ExampleContributors.ModelStatistics /p:ContributorArguments=$(ContributorArguments);GenerateModelStatistics=true;SortModelStatisticsBy=name;OutDir=.\;
   

   Ersetzen Sie MyDatabaseProject durch den Namen des Datenbankprojekts, das Sie erstellen möchten. Wenn Sie das Projekt nach der letzten Erstellung geändert hätten, könnten Sie /t:Build anstelle von /t:Rebuild verwenden.

   In der Ausgabe sollten Buildinformationen wie das folgende Beispiel angezeigt werden:

   Model Statistics:
   ===
   
   Basic model info
   -----------------
       Version: Sql110
     Collation: SQL_Latin1_General_CP1_CI_AS
   
   UserDefinedElements
   -----------------
     DatabaseOptions: 1
            subtotal: 1
         total items: 1
   
   OtherElements
   -----------------
                   Assembly: 1
          BuiltInServerRole: 9
              ClrTypeMethod: 218
     ClrTypeMethodParameter: 197
            ClrTypeProperty: 20
                   Contract: 6
                   DataType: 34
                   Endpoint: 5
                  Filegroup: 1
                MessageType: 14
                      Queue: 3
                       Role: 10
                     Schema: 13
                    Service: 3
                       User: 4
            UserDefinedType: 3
                   subtotal: 541
                total items: 16
   
   Relationships
   -----------------
        Composing: 477
     Hierarchical: 6
             Peer: 19
         subtotal: 502
   

5. Öffnen Sie ModelStatistics.xml, und überprüfen Sie den Inhalt.

   Die gemeldeten Ergebnisse bleiben auch in der XML-Datei erhalten.

Verwandte Inhalte

• Anpassen des Datenbankbuilds und der Bereitstellung mithilfe von Build- und Bereitstellungsmitwirkenden
• Exemplarische Vorgehensweise: Bereitstellung des Datenbankprojekts erweitern, um den Bereitstellungsplan zu analysieren