Procedura dettagliata: creazione di un generatore dati personalizzato per un vincolo CHECK

Articolo
09/12/2008

Aggiornamento: novembre 2007

È possibile utilizzare generatori di dati standard per riempire colonne con dati in Visual Studio Team System Database Edition. Se sulla colonna che si desidera riempire è stato definito un vincolo CHECK, i dati da utilizzare per riempire la colonna devono soddisfare tale vincolo. I generatori di dati standard consentono di generare dati che soddisfano molti vincoli CHECK. In presenza, ad esempio, di un vincolo CHECK che richiede l'utilizzo di una data compresa in un intervallo specifico, sarà possibile utilizzare il generatore DateTime standard e impostare le proprietà Min e Max per soddisfare il vincolo.

I generatori di dati standard non sono tuttavia in grado di soddisfare tutti i vincoli CHECK. Se ad esempio un vincolo CHECK richiede che una data sia compresa in uno di due intervalli distinti, non sarà possibile utilizzare il generatore DateTime standard. In questa procedura dettagliata viene creato un generatore di dati personalizzato in grado di soddisfare un tale vincolo. Il generatore accetta due intervalli come input e genera una data casuale compresa in uno di tali intervalli.

Nota:
È possibile adottare un altro approccio per la creazione di un generatore di dati personalizzato e ottenere lo stesso risultato tramite l'extensibility dell'aggregazione. Per ulteriori informazioni, vedere Procedura dettagliata: creazione di un generatore di dati personalizzato che aggrega i generatori standard.

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.
Eseguire l'override del metodo OnInitialize per inizializzare gli oggetti Random e rendere deterministico il generatore.
Eseguire l'override del metodo OnGenerateNextValues per generare i dati.
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 GeneratorDateRanges.
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.
(Facoltativo, solo Visual Basic) In Esplora soluzioni fare clic su Mostra tutti i file ed espandere il nodo Riferimenti per verificare il nuovo riferimento.

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

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

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

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

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 GeneratorDateRanges
    Inherits Generator

End Class

public class GeneratorDateRanges: 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.

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. Le proprietà devono avere l'attributo InputAttribute affinché siano identificate come proprietà di input.

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

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.
```
Dim randomDateValue As SqlDateTime
```
```
SqlDateTime randomDateValue;
```

Creare una proprietà per restituire la data casuale come output. 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

I dati casuali generati possono essere deterministici o non deterministici. Nei dati deterministici gli stessi dati vengono ripetuti ogni volta che vengono generati dallo stesso valore di inizializzazione. Per tutti i generatori di dati è disponibile una proprietà Seed impostabile dall'utente. È possibile eseguire l'override del metodo OnInitialize per inizializzare gli oggetti Random e rendere deterministico il generatore.

Per eseguire l'override del metodo OnInitialize

Creare due variabili membro per generare numeri casuali, come illustrato nell'esempio seguente. Una variabile consente di generare una data casuale, mentre l'altra consente di scegliere in modo casuale tra i due possibili intervalli di date.
```
Dim random As Random
Dim randomRange As Random
```
```
Random random;
Random randomRange;
```

Eseguire l'override del metodo OnInitialize.

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

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 sottoporre questo metodo a override per fornire la logica che genera la data casuale per la proprietà di output.

Per eseguire l'override del metodo OnGenerateNextValues

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

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

Scegliere Salva tutto dal menu File.

Definizione del convertitore di tipi

Per specificare le proprietà di input per il generatore di dati nel Visualizzatore 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.

 [Visual Basic]
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 una particolare conversione sia possibile con questo convertitore di tipi.

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

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 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 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à GeneratorDateRanges 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 GeneratorDateRangesKey, 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