Procedura dettagliata: creazione di un generatore di dati personalizzato che aggrega i generatori standard

Articolo
09/12/2008

Aggiornamento: novembre 2007

In Visual Studio Team System Database Edition è possibile creare istanze delle classi del generatore di dati standard nelle classi del generatore di dati personalizzato. Adottando questo approccio, è possibile ridurre la quantità di logica da includere nei generatori di dati personalizzati. Si potrebbe ad esempio scegliere di creare un generatore di dati casuali di tipo stringa che corrispondono a più di un modello complesso. È possibile creare un generatore di dati personalizzato che contiene la logica per gestire più modelli e utilizzare il generatore RegularExpression standard per gestire le corrispondenze tra modelli complessi.

In questa procedura dettagliata viene creato un generatore di dati personalizzato che aggrega il generatore DateTime standard. I dati generati rientrano in uno di due intervalli di date distinti. Il generatore accetta due intervalli distinti come input e genera una data casuale che appartiene a uno dei due intervalli.

Nota:
Per ulteriori informazioni sull'obiettivo di questo generatore di dati personalizzato e su come ottenere lo stesso obiettivo utilizzando la normale extensibility, vedere Procedura dettagliata: creazione di un generatore dati personalizzato per un vincolo CHECK.

In questa procedura dettagliata verranno eseguite le attività seguenti:

Creare una classe che eredita da Generator.
Creare le proprietà di input in modo che l'utente possa specificare i due intervalli di date.
Creare una proprietà di output da utilizzare come output del generatore.
Creare due istanze del generatore DateTime standard per rappresentare ognuno dei due intervalli possibili.
Eseguire l'override dei metodi Generator e, al loro interno, delegare il lavoro ai generatori standard.
Firmare il generatore con un nome sicuro.

Prerequisiti

Per completare questa procedura dettagliata, è necessario disporre dei seguenti elementi:

Database Edition

Creazione della classe del generatore di dati personalizzato

Per creare la classe del generatore di dati personalizzato

In Visual Studio creare un progetto Libreria di classi nel linguaggio desiderato e denominarlo GeneratorDateRanges2.
Scegliere Aggiungi riferimento dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi riferimento.
Fare clic sulla scheda .NET. Nell'elenco Nome componente fare clic su Microsoft.VisualStudio.TeamSystem.Data, quindi scegliere OK.
Scegliere Aggiungi riferimento dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi riferimento.
Fare clic sulla scheda Sfoglia e individuare il percorso ...\Programmi\Microsoft Visual Studio 9,0\DBPro\Extensions.
Fare clic su Microsoft.VisualStudio.TeamSystem.Data.Generators.dll, quindi scegliere OK.
(Facoltativo, solo in Visual Basic) In Esplora soluzioni fare clic su Mostra tutti i file ed espandere il nodo Riferimenti per verificare i nuovi riferimenti.

Nella parte superiore della finestra Codice aggiungere la seguente riga di codice prima della dichiarazione di classe:

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;

Rinominare la classe da Class1 a GeneratorDateRanges2 e specificare che eredita da Generator, come illustrato nell'esempio seguente.

Attenzione:
Per impostazione predefinita, il nome assegnato alla classe è quello che viene visualizzato nell'elenco della colonna Generatore nella finestra Dettagli colonna. Specificare un nome che non sia in conflitto con il nome di un generatore standard o di un altro generatore personalizzato.

Public Class GeneratorDateRanges2
    Inherits Generator

End Class

public class GeneratorDateRanges2: Generator
{
}

Scegliere Salva tutto dal menu File.

Aggiunta delle proprietà di input

Questo generatore di dati personalizzato accetta due intervalli di date come input. Per specificare ogni intervallo, l'utente imposta la data minima e la data massima per ciascuno di essi. Pertanto, è necessario creare quattro proprietà di input in totale: due date minime e due date massime.

Per aggiungere le proprietà di input

Creare quattro variabili membro per contenere le date minime e massime per i due intervalli di date, come illustrato nell'esempio seguente.

Dim range1MinValue As SqlDateTime
Dim range1MaxValue As SqlDateTime

Dim range2MinValue As SqlDateTime
Dim range2MaxValue As SqlDateTime

SqlDateTime range1MinValue;
SqlDateTime range1MaxValue;

SqlDateTime range2MinValue;
SqlDateTime range2MaxValue;

Creare quattro proprietà per impostare le date minime e massime per i due intervalli di date, come illustrato nell'esempio seguente. Le proprietà devono avere l'attributo InputAttribute affinché siano identificate come proprietà di input.

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

Scegliere Salva tutto dal menu File.

Aggiunta della proprietà di output

Questo generatore di dati personalizzato restituisce un'unica data casuale come output. Pertanto, è necessario creare un'unica proprietà di output.

Per aggiungere la proprietà di output

Creare una variabile membro per contenere la data casuale che costituisce l'output, come illustrato nell'esempio seguente.
```
Dim randomDateValue As SqlDateTime
```
```
SqlDateTime randomDateValue;
```

Creare una proprietà per restituire la data casuale come output, come illustrato nell'esempio seguente. La proprietà deve avere l'attributo OutputAttribute affinché sia identificata come proprietà di output.

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

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

Scegliere Salva tutto dal menu File.

Override del metodo OnInitialize

Per eseguire l'override del metodo OnInitialize

Creare una variabile membro per generare numeri casuali, come illustrato nell'esempio seguente. Questa variabile sceglie in modo casuale tra i due intervalli di date possibili.
```
Dim randomRange As Random
```
```
Random randomRange;
```

Creare due variabili membro e le relative istanze che corrispondono ai generatori DateTime standard, come illustrato nell'esempio seguente.

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

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

Eseguire l'override del metodo OnInitialize, come illustrato nell'esempio seguente. In questo metodo viene inizializzato l'oggetto Random e il generatore viene reso deterministico. Viene inoltre eseguita una chiamata al metodo Initialize dei generatori standard.

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

Scegliere Salva tutto dal menu File.

Override di altri metodi

Per eseguire l'override di altri metodi

Eseguire l'override del metodo OnSetInputValues, come illustrato nell'esempio seguente. Il parametro inputs di questo metodo è un oggetto IDictionary di tutte le proprietà del generatore standard impostate dall'utente, ad esempio Seed e Percentage Null. Viene eseguita una chiamata ai metodi SetInputValues dei generatori standard per passare tali valori. Vengono quindi impostate le proprietà Min e Max di ogni generatore standard con le proprietà di input personalizzate create in questo generatore di dati.

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

Eseguire l'override del metodo OnValidateInputs per convalidare gli input, come illustrato nell'esempio seguente.

Protected Overrides Sub OnValidateInputs()

    range1.ValidateInputs()
    range2.ValidateInputs()

    MyBase.OnValidateInputs()
End Sub

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

    base.OnValidateInputs();
}

Eseguire l'override del metodo Dispose(Boolean) per effettuare la pulitura dei generatori standard, come illustrato nell'esempio seguente.

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

Scegliere Salva tutto dal menu File.

Override del metodo OnGenerateNextValues

In Database Edition viene eseguita una chiamata al metodo OnGenerateNextValues del generatore per creare i dati necessari. È necessario eseguire l'override di questo metodo per fornire la logica che genera la data casuale per la proprietà di output. In questa procedura dettagliata la responsabilità della generazione della data casuale viene delegata al generatore DateTime standard.

Per eseguire l'override del metodo OnGenerateNextValues

Eseguire l'override del metodo OnGenerateNextValues, come illustrato nell'esempio seguente.

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

Scegliere Salva tutto dal menu File.

Definizione del convertitore di tipi

Per specificare le proprietà di input per il generatore di dati nella finestra Proprietà, è necessario fornire un convertitore di tipi che converta i valori di input nel tipo e dal tipo SqlDateTime.

Per creare la classe del convertitore di tipi SqlDateTime

Scegliere Aggiungi classe dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi nuovo elemento.
In Nome, digitare SqlDateTimeConverter.

Nella parte superiore della finestra Codice, aggiungere le seguenti righe di codice prima della dichiarazione di classe:

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

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

Rinominare la classe da Class1 a GeneratorDateRanges, quindi specificare che la classe eredita da TypeConverter.

Public Class SqlDateTimeConverter
    Inherits TypeConverter

End Class

public class SqlDateTimeConverter: TypeConverter
{
}

All'interno della dichiarazione di classe, aggiungere il costruttore della classe. Se si sta scrivendo la classe del convertitore di tipi in Visual Basic, procedere al passaggio 6.
```
public SqlDateTimeConverter()
{
}
```

Dopo il costruttore della classe, aggiungere un metodo in grado di verificare se il convertitore di tipi può eseguire una particolare conversione.

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

Infine, aggiungere i metodi del convertitore.

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

Scegliere Salva tutto dal menu File.

Firma del generatore

Prima della registrazione è necessario firmare tutti i generatori di dati personalizzati con un nome sicuro.

Per firmare il generatore con un nome sicuro

Scegliere Proprietà GeneratorDateRanges2 dal menu Progetto per aprire le proprietà del progetto.
Nella scheda Firma selezionare la casella di controllo Firma assembly.
Nella casella Scegli un file chiave con nome sicuro fare clic su <Nuovo...>.
Nella casella Nome file di chiave digitare GeneratorDateRanges2Key, immettere e confermare una password, quindi scegliere OK.

Quando viene generata la soluzione, il file di chiave verrà utilizzato per firmare l'assembly.
Scegliere Salva tutto dal menu File.
Scegliere Genera soluzione dal menu Genera.

Il generatore di dati è stato generato. A questo punto è necessario registrarlo sul computer in modo da poterlo utilizzare nei piani di generazione dati.

Sicurezza

Per ulteriori informazioni, vedere Protezione dei generatori di dati.

Passaggi successivi

Dopo aver creato il generatore di dati, è necessario registrarlo nel computer. Per ulteriori informazioni, vedere uno degli argomenti seguenti:

Vedere anche

Condividi tramite