Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Datengenerators, der Standardgeneratoren aggregiert

Artikel
09/03/2008

Aktualisiert: November 2007

Sie können in Visual Studio Team System Database Edition Instanzen der Standarddatengeneratorklassen in den benutzerdefinierten Datengeneratorklassen erstellen. Auf diese Weise können Sie bequem den Umfang der Logik verringern, die Sie in die benutzerdefinierten Generatoren einschließen müssen. Beispielsweise empfiehlt es sich eventuell, einen Generator erstellen, der zufällige Zeichenfolgendaten generiert, die mit mehreren komplexen Mustern übereinstimmen. Sie können einen benutzerdefinierten Datengenerator erstellen, der die Logik für die Behandlung mehrerer Muster enthält, und mit dem Standardgenerator für reguläre Ausdrücke können Sie den Vergleich komplexer Muster behandeln.

In dieser exemplarischen Vorgehensweise erstellen Sie einen benutzerdefinierten Datengenerator, der den DateTime-Standardgenerator aggregiert. Sie erstellen einen Generator, der Daten in einem von zwei verschiedenen Datumsbereichen generiert. Der Generator akzeptiert zwei verschiedene Bereiche als Eingabe und generiert ein zufälliges Datum, das in einem der beiden Bereiche liegt.

Hinweis:
Weitere Informationen über den Zweck dieses benutzerdefinierten Datengenerators und darüber, wie Sie denselben Zweck mit normaler Erweiterbarkeit erreichen, finden Sie unter Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten Datengenerators für eine CHECK-Einschränkung.

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
Erstellen von zwei Instanzen des DateTime-Standardgenerators, um jeden der beiden möglichen Bereiche darzustellen
Überschreiben der Generator-Methoden und Delegieren der Ausführung in diesen Methoden an die Standardgeneratoren
Signieren des Generators mit einem starken Namen

Vorbereitungsmaßnahmen

Zum Durchführen dieser exemplarischen Vorgehensweise benötigen Sie Folgendes:

Database Edition

Erstellen der benutzerdefinierten Datengeneratorklasse

So erstellen Sie die benutzerdefinierte Datengeneratorklasse

Erstellen Sie in Visual Studio ein Klassenbibliotheksprojekt in der gewünschten Sprache, und nennen Sie es GeneratorDateRanges2.
Klicken Sie im Menü Projekt auf Verweis hinzufügen.

Das Dialogfeld Verweis hinzufügen wird angezeigt.
Klicken Sie auf die Registerkarte .NET. Klicken Sie in der Liste Komponentenname auf Microsoft.VisualStudio.TeamSystem.Data und anschließend auf OK.
Klicken Sie im Menü Projekt auf Verweis hinzufügen.

Das Dialogfeld Verweis hinzufügen wird angezeigt.
Klicken Sie auf die Registerkarte Durchsuchen, und navigieren Sie zu dem Speicherort ...\Programme\Microsoft Visual Studio 9.0\DBPro\Extensions.
Klicken Sie auf Microsoft.VisualStudio.TeamSystem.Data.Generators.dll und anschließend auf OK.
(Optional, nur Visual Basic) Klicken Sie im Projektmappen-Explorer auf Alle Dateien anzeigen, und erweitern Sie den Knoten Verweise, um die neuen Verweise zu überprüfen.

Fügen Sie oben im Codefenster vor der Klassendeklaration die folgende Codezeile hinzu:

Imports Microsoft.VisualStudio.TeamSystem.Data.DataGenerator
Imports Microsoft.VisualStudio.TeamSystem.Data.Generators
Imports System.Data.SqlTypes

using Microsoft.VisualStudio.TeamSystem.Data.DataGenerator;
using Microsoft.VisualStudio.TeamSystem.Data.Generators;
using System.Data.SqlTypes;

Benennen Sie die Klasse von Class1 in GeneratorDateRanges2 um, und geben Sie an, dass die Klasse von Generator erbt, wie im folgenden Beispiel gezeigt.

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

Public Class GeneratorDateRanges2
    Inherits Generator

End Class

public class GeneratorDateRanges2: Generator
{
}

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

Erstellen Sie vier Membervariablen für das minimale und maximale Datum der beiden Datumsbereiche, wie im folgenden Beispiel gezeigt.

Dim range1MinValue As SqlDateTime
Dim range1MaxValue As SqlDateTime

Dim range2MinValue As SqlDateTime
Dim range2MaxValue As SqlDateTime

SqlDateTime range1MinValue;
SqlDateTime range1MaxValue;

SqlDateTime range2MinValue;
SqlDateTime range2MaxValue;

Erstellen Sie vier Eigenschaften, um das minimale und maximale Datum für die beiden Datumsbereiche festzulegen, wie im folgenden Beispiel gezeigt. Die Eigenschaften müssen über das InputAttribute verfügen, um sie als Eingabeeigenschaften zu kennzeichnen.

<Input(Visible:= true, TypeConverter:= GetType(SqlDateTimeConverter))> _
Public Property Range1Min() As SqlDateTime
    Set(ByVal value As SqlDateTime)
        range1MinValue = value
    End Set
    Get
        Return range1MinValue
    End Get
End Property

<Input(Visible:= true, TypeConverter:= GetType(SqlDateTimeConverter))> _
Public Property Range1Max() As SqlDateTime
    Set(ByVal value As SqlDateTime)
        range1MaxValue = value
    End Set
    Get
        Return range1MaxValue
    End Get
End Property

<Input(Visible:= true, TypeConverter:= GetType(SqlDateTimeConverter))> _
Public Property Range2Min() As SqlDateTime
    Set(ByVal value As SqlDateTime)
        range2MinValue = value
    End Set
    Get
        Return range2MinValue
    End Get
End Property

<Input(Visible:= true, TypeConverter:= GetType(SqlDateTimeConverter))> _
Public Property Range2Max() As SqlDateTime
    Set(ByVal value As SqlDateTime)
        range2MaxValue = value
    End Set
    Get
        Return range2MaxValue
    End Get
End Property

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

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

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

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

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

Erstellen Sie eine Membervariable für das zufällige Datum, das als Ausgabe verwendet wird, wie im folgenden Beispiel gezeigt:
```
Dim randomDateValue As SqlDateTime
```
```
SqlDateTime randomDateValue;
```
Erstellen Sie eine Eigenschaft, die das zufällige Datum als Ausgabe zurückgibt, wie im folgenden Beispiel gezeigt: 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;}
}
```
Klicken Sie im Menü Datei auf Alle speichern.

Überschreiben der OnInitialize-Methode

So überschreiben Sie die OnInitialize-Methode

Erstellen Sie eine Membervariable zum Generieren von zufälligen Zahlen, wie im folgenden Beispiel gezeigt. Für diese Variable wird einer der beiden möglichen Datumsbereiche nach dem Zufallsprinzip ausgewählt.
```
Dim randomRange As Random
```
```
Random randomRange;
```

Erstellen und instanziieren Sie zwei Membervariablen als DateTime-Standardgeneratoren, wie im folgenden Beispiel gezeigt.

Dim range1 As DatabaseDateTime = New DatabaseDateTime()
Dim range2 As DatabaseDateTime = New DatabaseDateTime()

DatabaseDateTime range1 = new DatabaseDateTime();
DatabaseDateTime range2 = new DatabaseDateTime();

Überschreiben Sie die OnInitialize-Methode, wie im folgenden Beispiel gezeigt. In dieser Methode geben Sie den Startwert des Random-Objekts an und legen den Generator als deterministisch fest. Sie rufen außerdem die Initialize-Methode der Standardgeneratoren auf.

Protected Overrides Sub OnInitialize(ByVal initInfo As GeneratorInit)

    randomRange = New Random(Me.Seed)  'deterministic

    range1.Initialize(initInfo)
    range2.Initialize(initInfo)

    MyBase.OnInitialize(initInfo)
End Sub

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

    range1.Initialize(initInfo);
    range2.Initialize(initInfo);

    base.OnInitialize(initInfo);
}

Klicken Sie im Menü Datei auf Alle speichern.

Überschreiben weiterer Methoden

So überschreiben Sie weitere Methoden

Überschreiben Sie OnSetInputValues, wie im folgenden Beispiel gezeigt. Der inputs-Parameter dieser Methode ist ein IDictionary aller Standardgeneratoreigenschaften, die vom Benutzer festgelegt werden, z. B. Startwert und Prozentualer NULL-Wert. Sie rufen die SetInputValues-Methoden der Standardgeneratoren auf, um diese Werte an sie zu übergeben. Anschließend legen Sie die Min-Eigenschaft und die Max-Eigenschaft jedes Standardgenerators mit den benutzerdefinierten Eingabeeigenschaften fest, die Sie in diesem Datengenerator erstellt haben.

Protected Overrides Sub OnSetInputValues(ByVal inputs As IDictionary(Of String, Object))

    'It is important to call MyBase.OnSetInputValues first to get the inputs
    'from the Properties window first.
    '--------------------------------------------------------------------------
    MyBase.OnSetInputValues(inputs)

    range1.SetInputValues(inputs)
    range2.SetInputValues(inputs)

    range1.Min = range1MinValue
    range1.Max = range1MaxValue
    range2.Min = range2MinValue
    range2.Max = range2MaxValue

    range1.Distribution = New Uniform()
    range2.Distribution = New Uniform()
End Sub

protected override void OnSetInputValues(IDictionary<string, object> inputs)
{
    //It is important to call base.OnSetInputValues first to get the inputs
    //from the Properties window first.
    //-------------------------------------------------------------------------
    base.OnSetInputValues(inputs);

    range1.SetInputValues(inputs);
    range2.SetInputValues(inputs);

    range1.Min = range1MinValue;
    range1.Max = range1MaxValue;
    range2.Min = range2MinValue;
    range2.Max = range2MaxValue;

    range1.Distribution = new Uniform();
    range2.Distribution = new Uniform();
}

Überschreiben Sie die OnValidateInputs, um die Eingaben zu überprüfen, wie im folgenden Beispiel gezeigt.

Protected Overrides Sub OnValidateInputs()

    range1.ValidateInputs()
    range2.ValidateInputs()

    MyBase.OnValidateInputs()
End Sub

protected override void OnValidateInputs()
{
    range1.ValidateInputs();
    range2.ValidateInputs();

    base.OnValidateInputs();
}

Überschreiben Sie die Dispose(Boolean)-Methode, um die Standardgeneratoren zu bereinigen, wie im folgenden Beispiel gezeigt.

Protected Overrides Sub Dispose(ByVal disposing As Boolean)

    range1.Dispose()
    range2.Dispose()

    MyBase.Dispose(disposing)
End Sub

protected override void Dispose(bool disposing)
{
    range1.Dispose();
    range2.Dispose();

    base.Dispose(disposing);
}

Klicken Sie im Menü Datei auf Alle speichern.

Überschreiben der OnGenerateNextValues-Methode

Database Edition 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. In dieser exemplarischen Vorgehensweise delegieren Sie das Generieren des zufälligen Datums an den DateTime-Standardgenerator.

So überschreiben Sie die OnGenerateNextValues-Methode

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

Protected Overrides Sub OnGenerateNextValues()

    '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

        'the standard generator does the work
        range1.GenerateNextValues()
        randomDateValue = range1.Result.Value
    Else
        'the standard generator does the work
        range2.GenerateNextValues()
        randomDateValue = range2.Result.Value
    End If

    MyBase.OnGenerateNextValues()
End Sub

protected override void OnGenerateNextValues()
{
    //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
    {
        //the standard generator does the work
        range1.GenerateNextValues();
        randomDateValue = range1.Result.Value;
    }
    else
    {
        //the standard generator does the work
        range2.GenerateNextValues();
        randomDateValue = range2.Result.Value;
    }

    base.OnGenerateNextValues();
}

Klicken Sie im Menü Datei auf Alle speichern.

Definieren des Typkonverters

Um die Eingabeeigenschaften für diesen Datengenerator im Fenster Eigenschaften 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

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

Das Dialogfeld Neues Element hinzufügen wird angezeigt.
Geben Sie für Name den Namen SqlDateTimeConverter ein.

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;

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

Public Class SqlDateTimeConverter
    Inherits TypeConverter

End Class

public class SqlDateTimeConverter: TypeConverter
{
}

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()
{
}
```

Fügen Sie nach dem Klassenkonstruktor eine Methode hinzu, die überprüft, ob dieser Typkonverter eine bestimmte Konvertierung ausführen kann.

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 override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
    bool result = false;
    if (sourceType == typeof(string))
    {
        result = true;
    }
    else
    {
        result = base.CanConvertFrom(context, sourceType);
    }
    return result;
}

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 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 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
        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 bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                return true;
            }
            return base.CanConvertTo(context, destinationType);
        }

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

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

Klicken Sie im Menü Projekt auf Eigenschaften von GeneratorDateRanges2, um die Projekteigenschaften zu öffnen.
Aktivieren Sie auf der Registerkarte Signierung das Kontrollkästchen Assembly signieren.
Klicken Sie im Feld Schlüsseldatei mit starkem Namen auswählen auf Neu.
Geben Sie im Feld Schlüsseldateiname die Zeichenfolge GeneratorDateRanges2Key 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.
Klicken Sie im Menü Datei auf Alle speichern.
Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

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

Sicherheit

Weitere Informationen finden Sie unter Sicherheit von Datengeneratoren.

Nächste Schritte

Nachdem der Datengenerator erstellt wurde, müssen Sie ihn auf dem Computer registrieren. Weitere Informationen finden Sie in den folgenden Themen:

Siehe auch

Freigeben über