Freigeben über

Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Daten-Generators für eine CHECK-Einschränkung

  • Artikel

Sie können in Visual Studio Premium oder Visual Studio Ultimate Standarddatengeneratoren verwenden, um Spalten mit Daten zu füllen. Wenn für die zu füllende Spalte eine CHECK-Einschränkung festgelegt ist, müssen die Daten, mit denen Sie die Spalte füllen, der CHECK-Einschränkung entsprechen. Die Standarddatengeneratoren können Daten generieren, die zahlreichen CHECK-Einschränkungen entsprechen. Wenn z. B. eine CHECK-Einschränkung erfordert, dass ein Datum in einem bestimmten Bereich liegt, können Sie den DateTime-Standardgenerator verwenden und die Min-Eigenschaft sowie die Max-Eigenschaft entsprechend dieser CHECK-Einschränkung festlegen.

Die Standarddatengeneratoren können jedoch nicht allen CHECK-Einschränkungen entsprechen. Wenn z. B. eine CHECK-Einschränkung erfordert, dass ein Datum in einem von zwei verschiedenen Bereichen liegt, können Sie nicht den DateTime-Standardgenerator verwenden. In dieser exemplarischen Vorgehensweise erstellen Sie einen benutzerdefinierten Datengenerator, der einer solchen Einschränkung entspricht. Der Generator akzeptiert zwei Bereiche als Eingabe und generiert ein zufälliges Datum, das in einem dieser Bereiche liegt.

Im Verlauf dieser exemplarischen Vorgehensweise führen Sie folgende Aufgaben aus:

  • Erstellen Sie eine Klasse, die von Generator erbt.

  • Erstellen von Eingabeeigenschaften, sodass der Benutzer die beiden Datumsbereiche angeben kann

  • Erstellen einer Ausgabeeigenschaft für die Verwendung als Generatorausgabe

  • Überschreiben der OnInitialize-Methode, um einen Startwert für die Random-Objekte anzugeben und den Generator als deterministisch festzulegen

  • Überschreiben der OnGenerateNextValues-Methode, um die Daten zu generieren

  • Signieren des Generators mit einem starken Namen

Vorbereitungsmaßnahmen

Sie können diese exemplarische Vorgehensweise nur ausführen, wenn Visual Studio Premium oder Visual Studio Ultimate installiert ist.

Erstellen der benutzerdefinierten Datengeneratorklasse

Beginnen Sie mit der Erstellung des benutzerdefinierten Datengenerators, indem Sie eine Klassenbibliothek erstellen.

So erstellen Sie die benutzerdefinierte Datengeneratorklasse

  1. Erstellen Sie in Visual Studio ein Klassenbibliotheksprojekt in der gewünschten Sprache, und benennen Sie es mit "GeneratorDateRanges".

  2. Klicken Sie im Menü Projekt auf Verweis hinzufügen.

  3. Wählen Sie die Registerkarte .NET aus.

  4. Suchen Sie in der Spalte Komponentenname die folgenden Komponenten:

    • [Microsoft.Data.Schema]

    • [Microsoft.Data.Schema.Sql]

    • [Microsoft.Data.Schema.Tools]

    Tipp

    Halten Sie STRG gedrückt, während Sie nacheinander auf mehrere Komponenten klicken, um sie auszuwählen.

  5. Klicken Sie auf OK, nachdem Sie alle erforderlichen Komponenten ausgewählt haben.

    Die ausgewählten Verweise werden im Projektmappen-Explorer unter dem Knoten Verweise des Projekts angezeigt.

  6. (Optional, nur Visual Basic) Klicken Sie im Projektmappen-Explorer auf Alle Dateien anzeigen, und erweitern Sie den Knoten Verweise, um den neuen Verweis zu überprüfen.

  7. Öffnen Sie die Datei Class1, und fügen Sie oben im Fenster Code vor der Klassendeklaration die folgenden Codezeilen ein:

    Imports System.Data.SqlTypes
Imports Microsoft.Data.Schema.Tools.DataGenerator
Imports Microsoft.Data.Schema.Extensibility
Imports Microsoft.Data.Schema
Imports Microsoft.Data.Schema.Sql

    using System.Data.SqlTypes;
using Microsoft.Data.Schema.Tools.DataGenerator;
using Microsoft.Data.Schema.Extensibility;
using Microsoft.Data.Schema;
using Microsoft.Data.Schema.Sql;

  8. Benennen Sie die Klasse von Class1 in GeneratorDateRanges um, und geben Sie an, dass die Klasse von Generator erbt.

    Warnung

    Der Name, den Sie für die Klasse festlegen, wird standardmäßig im Fenster Spaltendetails in der Liste der Spalte Generator angezeigt. Legen Sie einen Namen fest, der nicht zu einem Konflikt mit dem Namen eines Standardgenerators oder eines anderen benutzerdefinierten Generators führt.

    Public Class GeneratorDateRanges
    Inherits Generator

End Class

    public class GeneratorDateRanges: Generator
{
}

  9. Fügen Sie das DatabaseSchemaProviderCompatibilityAttribute hinzu, wie im folgenden Beispiel gezeigt:

    <DatabaseSchemaProviderCompatibility(GetType(SqlDatabaseSchemaProvider))> _
Public Class GeneratorDateRanges
    Inherits Generator

End Class

    [DatabaseSchemaProviderCompatibility(typeof(SqlDatabaseSchemaProvider))]
public class GeneratorDateRanges  : Generator
{
}

    Weitere Informationen zum Erweiterungskompatibilitätsattribut finden Sie unter Erweitern der Datenbankfunktionen von Visual Studio.

  10. Klicken Sie im Menü Datei auf Alle speichern.

Hinzufügen der Eingabeeigenschaften

Dieser benutzerdefinierte Datengenerator akzeptiert zwei Datumsbereiche als Eingabe. Um die einzelnen Bereiche festzulegen, gibt der Benutzer das minimale und maximale Datum für jeden Bereich an. Darum müssen Sie insgesamt vier Eingabeeigenschaften erstellen: zwei minimale Datumsangaben und zwei maximale Datumsangaben.

So fügen Sie die Eingabeeigenschaften hinzu

  1. Erstellen Sie vier Membervariablen für das minimale und maximale Datum der beiden Datumsbereiche:

    Dim range1MinValue As SqlDateTime
Dim range1MaxValue As SqlDateTime

Dim range2MinValue As SqlDateTime
Dim range2MaxValue As SqlDateTime

    SqlDateTime range1MinValue;
SqlDateTime range1MaxValue;

SqlDateTime range2MinValue;
SqlDateTime range2MaxValue;

  2. Erstellen Sie vier Eigenschaften, um das minimale und maximale Datum der beiden Datumsbereiche festzulegen. Die Eigenschaften müssen über das InputAttribute verfügen, um sie als Eingabeeigenschaften zu kennzeichnen.

    Tipp

    Um die Eingabeeigenschaften für diesen Datengenerator im Eigenschaftenfenster anzugeben, müssen Sie einen Typkonverter angeben, der die Eingabewerte aus dem und in den SqlDateTime-Typ konvertiert. Hierzu fügen Sie im weiteren Verlauf dieser exemplarischen Vorgehensweise eine unterstützende SqlDateTimeConverter-Klasse hinzu.

    <Input(TypeConverter:=GetType(SqlDateTimeConverter))> _
Public Property Range1Min() as SqlDateTime

<Input(TypeConverter:=GetType(SqlDateTimeConverter))> _
Public Property Range1Max() as SqlDateTime 

<Input(TypeConverter:=GetType(SqlDateTimeConverter))> _
Public Property Range2Min() as SqlDateTime 

<Input(TypeConverter:=GetType(SqlDateTimeConverter))> _
Public Property Range2Max() as SqlDateTime 

    [Input(TypeConverter = typeof(SqlDateTimeConverter))]
public SqlDateTime Range1Min
{
    set {range1MinValue = value;}
    get {return range1MinValue;}
}

[Input(TypeConverter = typeof(SqlDateTimeConverter))]
public SqlDateTime Range1Max
{
    set {range1MaxValue = value;}
    get {return range1MaxValue;}
}

[Input(TypeConverter = typeof(SqlDateTimeConverter))]
public SqlDateTime Range2Min
{
    set {range2MinValue = value;}
    get {return range2MinValue;}
}

[Input(TypeConverter = typeof(SqlDateTimeConverter))]
public SqlDateTime Range2Max
{
    set {range2MaxValue = value;}
    get {return range2MaxValue;}
}

  3. Klicken Sie im Menü Datei auf Alle speichern.

Hinzufügen der Ausgabeeigenschaft

Dieser benutzerdefinierte Datengenerator gibt ein zufälliges Datum als Ausgabe zurück. Daher müssen Sie eine Ausgabeeigenschaft erstellen.

So fügen Sie die Ausgabeeigenschaft hinzu

  1. Erstellen Sie eine Membervariable für das zufällige Datum, das als Ausgabe verwendet wird:

    Dim randomDateValue As SqlDateTime

    SqlDateTime randomDateValue;

  2. Erstellen Sie eine Eigenschaft, die das zufällige Datum als Ausgabe zurückgibt. Die Eigenschaft muss über das OutputAttribute verfügen, um sie als Ausgabeeigenschaft zu kennzeichnen.

    <Output()> _
Public ReadOnly Property RandomDate() As SqlDateTime
    Get
        Return randomDateValue
    End Get
End Property

    [Output]
public SqlDateTime RandomDate
{
    get {return randomDateValue;}
}

  3. Klicken Sie im Menü Datei auf Alle speichern.

Überschreiben der OnInitialize-Methode

Beim Generieren von zufälligen Daten können diese deterministisch oder nicht deterministisch sein. Wenn die Daten deterministisch sind, werden bei Verwendung desselben Startwerts immer die gleichen Daten erzeugt. Alle Datengeneratoren verfügen über eine Seed-Eigenschaft, die der Benutzer festlegen kann. Sie können die OnInitialize-Methode überschreiben, um einen Startwert für die Random-Objekte anzugeben und den Generator als deterministisch festzulegen.

So überschreiben Sie die OnInitialize-Methode

  1. Erstellen Sie zwei Membervariablen zum Generieren von zufälligen Zahlen, wie im folgenden Beispiel gezeigt. Eine Variable generiert ein zufälliges Datum. Für die andere Variable wird einer der beiden möglichen Datumsbereiche nach dem Zufallsprinzip ausgewählt.

    Dim random As Random
Dim randomRange As Random

    Random random;
Random randomRange;

  2. Überschreiben Sie die OnInitialize-Methode:

    Protected Overrides Sub OnInitialize(ByVal initInfo As GeneratorInit)

    random = New Random(Me.Seed)       'deterministic
    randomRange = New Random(Me.Seed)  'deterministic

    'random = New Random()              'non-deterministic
    'randomRange = New Random()         'non-deterministic

    MyBase.OnInitialize(initInfo)
End Sub

    protected override void OnInitialize(GeneratorInit initInfo)
{
    random = new Random(this.Seed);       //deterministic
    randomRange = new Random(this.Seed);  //deterministic

    //random = new Random();                //non-deterministic
    //randomRange = new Random();           //non-deterministic

    base.OnInitialize(initInfo);
}

  3. Klicken Sie im Menü Datei auf Alle speichern.

Überschreiben der OnGenerateNextValues-Methode

Visual Studio Premium ruft die OnGenerateNextValues-Methode des Generators auf, um die erforderlichen Daten zu generieren. Sie müssen diese Methode überschreiben, um die Logik bereitzustellen, mit der das zufällige Datum für die Ausgabeeigenschaft generiert wird.

So überschreiben Sie die OnGenerateNextValues-Methode

  1. Überschreiben Sie die OnGenerateNextValues-Methode, wie im folgenden Beispiel gezeigt:

    Protected Overrides Sub OnGenerateNextValues()

    Dim min As SqlDateTime
    Dim max As SqlDateTime

    'Generate a random date from either range 1 or range 2.
    'Randomly select either range 1 or range 2 by randomly 
    'generating an odd or an even random number.
    '------------------------------------------------------------
    If randomRange.Next() Mod 2 = 0 Then  'check for odd or even
        min = range1MinValue
        max = range1MaxValue
    Else
        min = range2MinValue
        max = range2MaxValue
    End If

    'The formula for creating a random number in a specific range is:
    'start of range + (size of range * random number between 0 and 1)

    'size of range
    Dim range As TimeSpan = max.Value - min.Value

    '(size of range * random number between 0 and 1)
    Dim randomNumber As TimeSpan = New TimeSpan(CLng(range.Ticks * random.NextDouble()))

    'start of range + (size of range * random number between 0 and 1)
    randomDateValue = min + randomNumber

End Sub

    protected override void OnGenerateNextValues()
{
    SqlDateTime min;
    SqlDateTime max;

    //Generate a random date from either range 1 or range 2.
    //Randomly select either range 1 or range 2 by randomly 
    //generating an odd or an even random number.
    //------------------------------------------------------------
    if (randomRange.Next() % 2 == 0)  //check for odd or even
    {
        min = range1MinValue;
        max = range1MaxValue;
    }
    else
    {
        min = range2MinValue;
        max = range2MaxValue;
    }

    //The formula for creating a random number in a specific range is:
    //start of range + (size of range * random number between 0 and 1)

    //size of range
    TimeSpan range = max.Value - min.Value;

    //(size of range * random number between 0 and 1)
    TimeSpan randomNumber = new TimeSpan((long)(range.Ticks * random.NextDouble()));

    //start of range + (size of range * random number between 0 and 1)
    randomDateValue = min + randomNumber;
}

  2. Klicken Sie im Menü Datei auf Alle speichern.

Definieren des Typkonverters

Um die Eingabeeigenschaften für diesen Datengenerator im Eigenschaftenfenster anzugeben, müssen Sie einen Typkonverter angeben, der die Eingabewerte aus dem und in den SqlDateTime-Typ konvertiert.

So erstellen Sie die Konverterklasse des SqlDateTime-Typs

  1. Klicken Sie im Menü Projekt auf Klasse hinzufügen.

    Das Dialogfeld Neues Element hinzufügen wird angezeigt.

  2. Geben Sie für Name den Namen "SqlDateTimeConverter" ein.

  3. Fügen Sie oben im Fenster Code vor der Klassendeklaration die folgenden Codezeilen hinzu:

    Imports System.ComponentModel
Imports System.Data.SqlTypes
Imports System.Globalization

    using System.ComponentModel;
using System.Data.SqlTypes;
using System.Globalization;

  4. Geben Sie an, dass die Klasse von TypeConverter erbt:

    Public Class SqlDateTimeConverter
    Inherits TypeConverter

End Class

    public class SqlDateTimeConverter: TypeConverter
{
}

  5. Fügen Sie innerhalb der Klassendeklaration den Klassenkonstruktor hinzu. Wenn Sie die Typkonverterklasse in Visual Basic einfügen, fahren Sie mit Schritt 6 fort.

    public SqlDateTimeConverter()
{
}

  6. Fügen Sie nach dem Klassenkonstruktor eine Methode hinzu, die überprüft, ob eine bestimmte Konvertierung über diesen Typkonverter möglich ist:

    Public Overrides Function CanConvertFrom(ByVal context As ITypeDescriptorContext, ByVal sourceType As Type) As Boolean
    Dim result As Boolean
    result = False
    If (sourceType Is GetType(System.String)) Then
        result = True
    Else
        result = MyBase.CanConvertFrom(context, sourceType)
    End If
    Return result
End Function 

Public Overrides Function CanConvertTo(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal destinationType As System.Type) As Boolean
    If (destinationType Is GetType(System.String)) Then
        Return True
    End If
    Return MyBase.CanConvertTo(context, destinationType)
End Function

    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
    bool result = false;
    if (sourceType == typeof(string))
    {
        result = true;
    }
    else
    {
        result = base.CanConvertFrom(context, sourceType);
    }
    return result;
}

public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
    if (destinationType == typeof(string))
    {
        return true;
    }
    return base.CanConvertTo(context, destinationType);
}

  7. Fügen Sie abschließend die Konvertermethoden hinzu:

    Public Overrides Function ConvertFrom(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal culture As System.Globalization.CultureInfo, ByVal value As Object) As Object
    Dim dateTimeString As String
    dateTimeString = value.ToString
    If (dateTimeString.Length > 0) Then
        Dim dateTime As Date
        dateTime = Date.Parse(dateTimeString, culture)
        Return New SqlDateTime(dateTime)
    End If
    Return MyBase.ConvertFrom(context, culture, value)
End Function

Public Overrides Function ConvertTo(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal culture As System.Globalization.CultureInfo, ByVal value As Object, ByVal destinationType As System.Type) As Object
    If (destinationType Is GetType(System.String)) Then
        Dim dateTime As Date
        dateTime = CType(value, SqlDateTime).Value
        Return dateTime.ToString(culture)
    End If
    Return MyBase.ConvertTo(context, culture, value, destinationType)
End Function

            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            string dateTimeString = value as string;
            if (dateTimeString != null)
            {
                DateTime dateTime = DateTime.Parse(dateTimeString, culture);
                return new SqlDateTime(dateTime);
            }
            return base.ConvertFrom(context, culture, value);
        }

        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                DateTime dateTime = ((SqlDateTime)value).Value;
                return dateTime.ToString(culture);
            }
            return base.ConvertTo(context, culture, value, destinationType);
        }

  8. Klicken Sie im Menü Datei auf Alle speichern.

Signieren des Generators

Alle benutzerdefinierten Datengeneratoren müssen mit einem starken Namen signiert werden, bevor sie registriert werden.

So signieren Sie den Generator mit einem starken Namen

  1. Klicken Sie im Menü Projekt auf Eigenschaften von GeneratorDateRanges, um die Projekteigenschaften zu öffnen.

  2. Aktivieren Sie auf der Registerkarte Signierung das Kontrollkästchen Assembly signieren.

  3. Klicken Sie im Feld Schlüsseldatei mit starkem Namen auswählen auf Neu.

  4. Geben Sie im Feld Schlüsseldateiname die Zeichenfolge "GeneratorDateRangesKey" ein, geben Sie ein Kennwort ein, bestätigen Sie das Kennwort, und klicken Sie dann auf OK.

    Wenn Sie die Projektmappe erstellen, wird die Assembly mit der Schlüsseldatei signiert.

  5. Klicken Sie im Menü Datei auf Alle speichern.

  6. Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

    Der Datengenerator wurde jetzt erstellt. Anschließend müssen Sie den Datengenerator auf dem Computer registrieren, damit Sie ihn in Datengenerierungsplänen verwenden können.

Registrieren des Generators

Der nächste Schritt nach dem Signieren und Kompilieren der Assembly besteht im Erfassen der im Projekt generierten Assemblyinformationen, einschließlich der Version, der Kultur und des PublicKeyToken, um das Registrieren der Generatorassembly zu ermöglichen.

So erfassen Sie Assemblyinformationen

  1. Klicken Sie im Menü Ansicht auf Weitere Fenster, und klicken Sie dann auf Befehlsfenster, um das Befehlsfenster zu öffnen.

  2. Geben Sie im Befehlsfenster folgenden Code ein. Ersetzen Sie FilePath durch den Pfad und Dateinamen der kompilierten DLL-Datei. Schließen Sie Pfad und Dateiname in Anführungszeichen ein.

    Tipp

    Der Pfad der kompilierten DLL-Datei ist standardmäßig SampleGenerator\bin\Debug.

    ? System.Reflection.Assembly.LoadFrom("FilePath").FullName

    ? System.Reflection.Assembly.LoadFrom(@"FilePath").FullName

  3. Drücken Sie die EINGABETASTE. Die Zeile sollte mit Ihrem entsprechenden PublicKeyToken etwa folgendermaßen aussehen:

    " GeneratorDateRanges, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn"

    Notieren oder kopieren Sie diese Assemblyinformationen, da Sie sie für das nächste Verfahren benötigen.

    Danach erstellen Sie eine XML-Datei mit den Assemblyinformationen, die Sie im vorhergehenden Verfahren erfasst haben.

So erstellen Sie die XML-Datei

  1. Wählen Sie im Projektmappen-Explorer das "GeneratorDateRanges" aus.

  2. Klicken Sie im Menü Projekt auf Neues Element hinzufügen.

  3. Suchen Sie im Bereich Vorlagen das Element XML-Datei, und wählen Sie es aus.

  4. Geben Sie im Textfeld Name den Namen der Datei GeneratorDateRanges.Extensions.xml ein, und klicken Sie auf die Schaltfläche Hinzufügen.

    Dem Projekt wird im Projektmappen-Explorer die Datei GeneratorDateRanges.Extensions.xml hinzugefügt.

    Tipp

    Für die ordnungsgemäße Registrierung der Assembly müssen Sie den Namen der DLL (in diesem Fall, "GeneratorDateRanges", gefolgt von ".Extensions.xml") verwenden.

  5. Öffnen Sie die Datei GeneratorDateRanges.Extensions.xml, und aktualisieren Sie diese so, dass sie mit dem folgenden XML übereinstimmt. Ersetzen Sie die Version, die Kultur und das PublicKeyToken der Assembly, die Sie im vorherigen Verfahren abgerufen haben.

    Tipp

    Der Erweiterungstyp muss den vollqualifizierten Namen der Klasse verwenden. In diesem Fall gilt: Erweiterungstyp = "GeneratorDateRanges.GeneratorDateRanges".

    <?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="GeneratorDateRanges.GeneratorDateRanges" assembly=" GeneratorDateRanges, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn" enabled="true"/>

</extensions>

  6. Klicken Sie im Menü Datei auf Alle speichern.

Danach kopieren Sie die Assembly und die XML-Datei in das Erweiterungsverzeichnis. Beim Start von Visual Studio Premium werden sämtliche Erweiterungen im Verzeichnis %Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions und in den Unterverzeichnissen identifiziert und für die Verwendung in der Sitzung registriert.

So kopieren Sie die Assembly und die XML-Datei in das Erweiterungsverzeichnis und registrieren sie

  1. Erstellen Sie im Verzeichnis %Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\ den neuen Ordner CustomGenerators.

  2. Kopieren Sie die Assemblydatei GeneratorDateRanges.dll aus dem Verzeichnis Projektordner\GeneratorDateRanges\GeneratorDateRanges\bin\Debug\ in das Verzeichnis %Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomGenerators, das Sie erstellt haben.

  3. Kopieren Sie die Assemblydatei GeneratorDateRanges.Extensions.xml aus dem Verzeichnis Projektordner\GeneratorDateRanges\GeneratorDateRanges\bin\Debug\ in das Verzeichnis %Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomGenerators, das Sie erstellt haben.

    Tipp

    Als Vorgehensweise wird empfohlen, die Erweiterungsassemblys in einem Ordner im Verzeichnis %Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions einzufügen. So können Sie leichter ermitteln, welche Erweiterungen im Produkt enthalten waren und welche Sie benutzerdefiniert erstellt haben. Sie sollten auch in Erwägung ziehen, die Erweiterungen in kategoriespezifischen Ordnern zu organisieren.

Testen des Datumsbereichsgenerators

Nachdem Sie den Datengenerator für Datumsbereiche erstellt haben, müssen Sie eine neue Instanz von Visual Studio starten. Wenn Visual Studio gestartet wird, wird die GeneratorDateRanges-Assembly registriert, die Sie dem Verzeichnis %Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomGenerators hinzugefügt haben.

Danach erstellen Sie ein Datenbankprojekt, in dem Sie überprüfen können, dass der Datengenerator für Datumsbereiche ordnungsgemäß funktioniert.

So erstellen Sie das Datenbankprojekt

  1. Starten Sie eine neue Instanz von Visual Studio, die die Assembly GeneratorDateRanges.dll erkennt und registriert.

  2. Zeigen Sie im Menü Datei auf Neu, und klicken Sie auf Projekt.

    Das Dialogfeld Neues Projekt wird angezeigt.

  3. Erweitern Sie in der Liste Installierte Vorlagen den Eintrag Datenbank, und klicken Sie auf SQL Server.

  4. Klicken Sie in Vorlagen auf SQL Server 2008-Assistent.

  5. Geben Sie unter Name den Namen SampleGeneratorDB ein.

    Tipp

    Wenn Sie bereits alle Schritte in Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Daten-Generators ausgeführt haben, haben Sie das SampleGeneratorDB-Projekt schon erstellt, und Sie können mit dem nächsten Verfahren So fügen Sie dem Datenbankprojekt eine Tabelle hinzu fortfahren.

  6. Aktivieren Sie das Kontrollkästchen Projektmappenverzeichnis erstellen.

  7. Übernehmen Sie die Standardwerte für Speicherort, Projektmappenname und Zur Quellcodeverwaltung hinzufügen, und klicken Sie auf OK.

  8. Klicken Sie auf Fertig stellen. Wenn die Ausführung des Assistenten abgeschlossen ist, klicken Sie wieder auf Fertig stellen.

    Das neue Datenbankprojekt SampleGeneratorDB wird im Projektmappen-Explorer angezeigt.

  9. Klicken Sie im Menü Ansicht auf Schemaansicht der Datenbank.

    Die Schemaansicht wird angezeigt, wenn dies nicht bereits der Fall ist.

    Anschließend fügen Sie dem Projekt eine einfache Tabelle mit einer einzelnen Spalte und einem DateRange-SQL-Typ hinzu.

So fügen Sie dem Datenbankprojekt eine Tabelle hinzu

  1. Erweitern Sie in der Schemaansicht den Knoten SampleGeneratorDB. Erweitern Sie dann den Knoten Schemas und den Knoten dbo, und klicken Sie auf den Knoten Tabellen.

  2. Klicken Sie im Menü Projekt auf Neues Element hinzufügen.

    Tipp

    Sie können auch in der Schemaansicht mit der rechten Maustaste auf das Projekt SampleGeneratorDB klicken, auf Hinzufügen zeigen und auf Tabelle klicken.

  3. Klicken Sie in Vorlagen auf Tabelle.

    Tipp

    In der Liste Kategorien können Sie auf Tabellen und Ansichten klicken, um die Vorlage für eine Tabelle leichter zu finden.

  4. Geben Sie unter Name als Namen für die neue Tabelle TableDates ein.

  5. Klicken Sie auf Hinzufügen, um die Tabelle dem Datenbankprojekt hinzuzufügen.

    Im Projektmappen-Explorer wird im Datenbankprojekt die neue Datei für die Tabelle angezeigt. In der Schemaansicht wird das neue Tabellenobjekt angezeigt. Der Transact-SQL-Editor wird geöffnet und zeigt die Definition für die neue Tabelle an.

  6. Ändern Sie im Transact-SQL-Editor die Tabellendefinition anhand des folgenden Beispiels:

    CREATE TABLE [dbo].[TableDates]
(
dates DateTime
)

  7. Klicken Sie im Menü Datei auf TableDates.table.sql speichern.

Nachdem Sie die Tabelle erstellt haben, fügen Sie jetzt eine CHECK-Einschränkung hinzu, um zu überprüfen, ob die verwendeten Datumsbereiche gültig sind.

Tipp

Entsprechende Werte für die benutzerdefinierten Eigenschaftswerte des Datengenerators für Datumsbereiche werden in einem anderen Verfahren eingegeben. Weitere Informationen finden Sie unter Erstellen und Konfigurieren des Datengenerierungsplans.

So fügen Sie der Tabelle eine CHECK-Einschränkung hinzu

  1. Erweitern Sie in der Schemaansicht den Knoten Tabellen, und klicken Sie auf die Tabelle TableDates.

  2. Klicken Sie im Menü Projekt auf Neues Element hinzufügen.

  3. Klicken Sie in Vorlagen auf CHECK-Einschränkung.

    Tipp

    Sie können auch in der Schemaansicht mit der rechten Maustaste auf die Datumstabelle klicken, auf Hinzufügen zeigen und dann auf die Check-Einschränkung klicken.

  4. Geben Sie in Name als Namen für die neue CHECK-Einschränkung CheckConstraintDateRanges ein.

  5. Klicken Sie auf Hinzufügen, um die CHECK-Einschränkung dem Datenbankprojekt hinzuzufügen.

    Im Projektmappen-Explorer wird die neue Datei für die CHECK-Einschränkung im Datenbankprojekt angezeigt. In der Schemaansicht wird das neue CHECK-Einschränkungsobjekt angezeigt. Der Transact-SQL-Editor wird geöffnet und zeigt die Definition für die neue CHECK-Einschränkung an.

  6. Ändern Sie im Transact-SQL-Editor die CHECK-Einschränkung entsprechend dem folgenden Beispiel:

    ALTER TABLE [dbo].[TableDates]
ADD CONSTRAINT [CheckConstraintDateRanges] 
CHECK ((dates BETWEEN '1/1/1800' AND '1/1/1900')OR(dates BETWEEN '1/1/1979' AND '12/31/2008'))

  7. Klicken Sie im Menü Datei auf Dates.CheckConstraintDateRanges.chkconst.sql speichern.

    Tipp

    Wenn Sie bereits alle Schritte in Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Daten-Generators ausgeführt haben, können Sie zum Abschnitt Erstellen und Konfigurieren des Datengenerierungsplans übergehen.

Nachdem Sie die Tabelle und die CHECK-Einschränkung erstellt haben, können Sie jetzt die Datenbank für die Bereitstellung konfigurieren.

So konfigurieren Sie die Bereitstellungseinstellungen des Projekts

  1. Klicken Sie im Projektmappen-Explorer auf SampleGeneratorDB (das Projekt, nicht die Projektmappe).

  2. Klicken Sie im Menü Projekt auf Eigenschaften von SampleGeneratorDB.

    Das Projekteigenschaftenfenster wird angezeigt.

    Tipp

    Sie können auch im Projektmappen-Explorer mit der rechten Maustaste auf SampleGeneratorDB klicken und dann auf Eigenschaften klicken.

  3. Klicken Sie auf die Registerkarte Bereitstellen.

  4. Klicken Sie in der Liste Bereitstellungsvorgang auf Bereitstellungsskript erstellen und in Datenbank bereitstellen (.sql).

  5. Klicken Sie auf die Schaltfläche Bearbeiten, um die Zielverbindung anzugeben.

  6. Geben Sie die Informationen für das Herstellen einer Verbindung mit dem Datenbankserver an, auf dem Sie die Datenbank SampleGeneratorDB bereitstellen möchten.

  7. Geben Sie unter Wählen Sie einen Datenbanknamen aus, oder geben Sie ihn ein den Namen SampleGeneratorDB ein.

  8. Klicken Sie auf OK.

    Zielverbindung wird mit der Verbindungszeichenfolge aufgefüllt. Der Zieldatenbankname ist auf SampleGeneratorDB festgelegt.

  9. Übernehmen Sie die Standardwerte für die anderen Optionen.

  10. Klicken Sie im Menü Datei auf Ausgewählte Elemente speichern.

    Die Projektbuildeinstellungen werden gespeichert.

    Als Nächstes erstellen Sie das Datenbankprojekt.

So erstellen Sie das Datenbankprojekt

  • Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

    Das Datenbankprojekt wird erstellt. Bei einem erfolgreichen Abschluss wird in der Statusleiste "Der Buildvorgang war erfolgreich" angezeigt. Außerdem werden im Ausgabefenster die Buildergebnisse angezeigt.

    Danach stellen Sie das Datenbankprojekt bereit.

So stellen Sie das Datenbankprojekt auf dem Datenbankserver bereit

  1. Klicken Sie im Projektmappen-Explorer auf SampleGeneratorDB (das Projekt, nicht die Projektmappe).

  2. Klicken Sie im Menü Erstellen auf SampleGeneratorDB bereitstellen.

    Das Datenbankprojekt wird mithilfe der Verbindung bereitgestellt, die Sie in der Buildkonfiguration angegeben haben. Wenn erfolgreich, wird die Meldung "Die Bereitstellung war erfolgreich" in der Statusleiste und im Ausgabefenster angezeigt.

Erstellen und Konfigurieren des Datengenerierungsplans

Nun erstellen Sie den Datengenerierungsplan. Der Datengenerierungsplan enthält Informationen über die Tabellen und Spalten, die Sie mit Daten füllen möchten. Weitere Informationen finden Sie unter Gewusst wie: Erstellen von Datengenerierungsplänen.

So erstellen und konfigurieren Sie den Datengenerierungsplan

  1. Wählen Sie im Projektmappen-Explorer den Knoten Datengenerierungspläne aus.

  2. Klicken Sie im Menü Projekt auf Neues Element hinzufügen.

  3. Klicken Sie im Bereich Kategorien auf Datengenerierungsplan.

  4. Klicken Sie im Bereich Vorlagen auf Datengenerierungsplan.

  5. Geben Sie im Textfeld Name den Namen SampleGenerator.dgen ein.

  6. Klicken Sie auf Hinzufügen.

    Der Datengenerierungsplan wird erstellt. Der Datengenerierungsplan und das Fenster Vorschau für Datengenerierung werden angezeigt. Das Datengenerierungsplanfenster ist horizontal in zwei Bereiche unterteilt. Im oberen Bereich werden die Tabellen aufgeführt, die im Datenbankprojektschema definiert wurden; hier: die Tabelle dbo.TableDates. Im unteren Bereich werden Spaltendetails für die im oberen Bereich hervorgehobene Tabelle angezeigt; hier: die Adressspalte.

    Tipp

    Wenn das Fenster Vorschau für Datengenerierung nicht geöffnet ist, können Sie es öffnen, indem Sie im Menü Daten auf Datengenerator zeigen und dann auf Datengenerierungsvorschau anzeigen klicken. Standardmäßig ist das Fenster Vorschau für Datengenerierung unten im Fenster mit dem Datengenerierungsplan angedockt und als Registerkarte verfügbar. Um die Ansicht zu erweitern, klicken Sie auf das Fenster, und klicken Sie dann im Menü Fenster auf Dokument im Registerkartenformat. Sie können auch mit der rechten Maustaste auf die Titelleiste klicken und dann auf Als Dokument im Registerkartenformat andocken klicken.

  7. Überprüfen Sie im Designer SampleGenerator.dgen, dass die Tabelle dbo.TableDates und die Spalte Datumsangaben aktiviert sind.

  8. Ändern Sie in der Tabelle den Wert unter Einzufügende Zeilen in 500.

  9. Wählen Sie im Designer SampleGenerator.dgen die Spalte Datumsangaben aus, und klicken Sie auf die Dropdownliste Generator, und wählen Sie GeneratorDateRanges aus.

  10. Geben Sie nach Auswählen der Datumsangabenspalte im Eigenschaftenfenster Werte für die beiden Datumsbereichseingaben ein:

    • Range1Max 31.12.2008 00:00:00

    • Range1Min 1.1.1979 00:00:00

    • Range2Max 1.1.1900 00:00:00

    • Range2Max 1.1.1800 00:00:00

    Der benutzerdefinierte Adressgenerator ist jetzt ordnungsgemäß konfiguriert.

  11. Klicken Sie im Menü Datei auf Alle speichern.

Ausführen des Datengenerierungsplans, zum Generieren von Datumsbereichsdaten

Abschließend führen Sie den Datengenerierungsplan aus und sehen den Datengenerator für Datumsbereiche in Aktion.

So führen Sie den Plan zur Datengenerierung aus

  1. Klicken Sie im Projektmappen-Explorer auf SampleGenerator.dgen.

    Tipp

    Der Datengenerierungsplan muss geöffnet sein. Sollte dies nicht der Fall sein, öffnen Sie den Plan zunächst.

  2. Zeigen Sie im Menü Daten auf Datengenerator, und klicken Sie dann auf Daten generieren.

    Das Dialogfeld Verbindung zur Datenbank herstellen wird angezeigt.

  3. Klicken Sie in der Liste Verbindungsinformationen zur Datengenerierung auf die Datenbank SampleGeneratorDB und dann auf OK.

  4. Wenn Sie aufgefordert werden, den Inhalt der Tabellen vor dem Einfügen von neuen Zeilen zu löschen, klicken Sie auf Ja.

    Die Daten werden generiert. Im Fenster Auffüllung wird die Statusspalte mit dem Status der Datengenerierung aktualisiert. Auf der Statusleiste wird die Datengenerierung für alle Tabellen zusammengefasst.

  5. (Optional) Verwenden Sie ein anderes Tool, um sich bei der Datenbank anzumelden. Für diesen Schritt können Sie den in Visual Studio Premium bereitgestellten Transact-SQL-Editor verwenden. Weitere Informationen finden Sie auf der Microsoft-Website unter Editing Database Scripts and Objects with the Transact-SQL Editor. Zeigen Sie die neuen Daten an, indem Sie die folgende Abfrage ausführen:

    use SampleGeneratorDB

select * from dbo.TableDates

    Auf der Registerkarte Ergebnisse sollten nun die resultierenden 500 Datumsangaben angezeigt werden.

  6. (Optional) Ändern Sie Im Eigenschaftenfenster den Wert von Range1Max in 31.12.3000 00:00:00, und führen Sie den Datengenerator erneut aus, indem Sie Schritt 2 bis 5 wiederholen.

    Im Fenster Fehlerliste wird ein Fehler angezeigt, der aufgrund eines Verstoßes gegen die CHECK-Einschränkung generiert wird. Die Ursache für den Fehler besteht darin, dass der Datumsbereich außerhalb des zulässigen Bereichs geändert wurde.

Siehe auch

Aufgaben

Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Daten-Generators

Gewusst wie: Registrieren und Verwalten von Funktionserweiterungen

Referenz

Microsoft.Data.Schema.Tools.DataGenerator

Konzepte

Generieren spezialisierter Testdaten mit einem benutzerdefinierten Daten-Generator

Übersicht über die Erweiterbarkeit von Daten-Generatoren

Angeben von Details zur Datengenerierung für eine Spalte

Weitere Ressourcen

Problembehandlung bei Funktionserweiterungen

Änderungsprotokoll

Datum

Versionsgeschichte

Grund

Dezember 2010

Fehler im Code korrigiert, um auf Kundenfeedback zu reagieren.

Kundenfeedback.