Usare Visual C# per associare un controllo DataGrid a una matrice di oggetti o strutture

Articolo
03/20/2024

Questo articolo fornisce informazioni su come associare una matrice di oggetti a un controllo DataGrid.

Versione originale del prodotto: Oggetto visivo C#
Numero KB originale: 315786

Riepilogo

L'esempio in questo articolo è costituito da un Windows Form con un controllo DataGrid per visualizzare i valori delle proprietà dell'oggetto e quattro pulsanti di comando per esplorare le righe del controllo DataGrid.

Requisiti

Questo articolo presuppone che si abbia familiarità con gli argomenti seguenti:

Concetti di programmazione di Visual C#
Visual C# .NET

Progettare la classe

Una classe da associare a un controllo deve avere funzioni di accesso alle proprietà. Qualsiasi proprietà da associare deve avere il metodo della proprietà Set e il metodo della proprietà Get . La classe di esempio usata in questo articolo include tre membri. In questo articolo viene descritto un solo membro. È stato fornito anche un costruttore con parametri. Tuttavia, non è un requisito.

public class guitar
{
    private string make;
    private string model;
    private short year;

    public guitar()
    {
    }

    public guitar(string make, string model, short year)
    {
        Make=make;
        Model=model;
        Year=year;
    }

    public string Make
    {
        get
        {
            return make;
        }
        set
        {
            make = value;
        }
    }
}

Aggiungere istanze di classe a una matrice

Per creare istanze e aggiungerle alla matrice, seguire questa procedura:

Dichiarare una matrice.

Creare istanze della classe e quindi aggiungere le istanze alla matrice.

private guitar[] arr=new guitar[3];
arr[0] = new guitar("Gibson", "Les Paul", 1958);
arr[1] = new guitar("Fender", "Jazz Bass", 1964);
arr[2] = new guitar("Guild", "Bluesbird", 1971);

Associare la matrice al controllo DataGrid

Dopo aver popolato la matrice, impostare la proprietà DataSource del controllo DataGrid sulla matrice. Le colonne nel controllo DataGrid vengono popolate in base alle proprietà per cui sono presenti funzioni di accesso alle proprietà nell'ambito.

dataGrid1.DataSource=arr;

Fornire un mezzo per esplorare la matrice

È possibile usare CurrencyManager per esplorare la matrice. A tale scopo, associare CurrencyManager all'oggetto BindingContext del controllo , in questo caso la matrice .

private CurrencyManager currencyManager=null;
currencyManager = (CurrencyManager)dataGrid1.BindingContext[arr];

La CurrencyManager classe ha una Position proprietà che è possibile modificare per eseguire l'iterazione sui membri della matrice. Aggiungendo o sottraendo da il valore corrente di Position, è possibile esplorare le righe del DataGrid controllo.

//Move forward one element.
currencyManager.Position++;
//Move back one element.
currencyManager.Position--;
//Move to the beginning.
currencyManager.Position = 0;
//Move to the end.
currencyManager.Position = arr.Length - 1;

Esempio dettagliato

In Visual C# .NET creare un nuovo progetto applicazione Windows. Form1 viene creato per impostazione predefinita.
Aggiungere una classe al progetto.

Sostituire il codice in Class1.cs con il codice seguente.

public class guitar
{
    private string make;
    private string model;
    private short year;

    public guitar()
    {
    }

    public guitar(string Make, string Model, short Year)
    {
        make=Make;
        model=Model;
        year=Year;
    }

    public string Make
    {
        get
        {
            return make;
        }
        set
        {
            make = value;
        }
    }

    public string Model
    {
        get
        {
            return model;
        }
        set
        {
            model = value;
        }
    }

    public short Year
    {
        get
        {
            return year;
        }
        set
        {
            year = value;
        }
    }
}

Chiudere la finestra del codice Class1.cs e quindi passare alla Designer Modulo.
Aggiungere un controllo DataGrid a Form1. Ridimensionare il controllo DataGrid in modo da contenere quattro colonne e tre righe.
Aggiungere quattro controlli Button a Form1 e quindi disporre i pulsanti orizzontalmente.
Modificare la proprietà Text di Button1 su Avanti.
Modificare la proprietà Text di Button2 su Previous.Change the Text property of Button2 to Previous.
Modificare la proprietà Text di Button3 in First.
Modificare la proprietà Text di Button4 in Last.Change the Text property of Button4 to Last.

Aggiungere il codice seguente alla classe Form1.

private guitar[] arr=new guitar[3];
private CurrencyManager currencyManager=null;

Passare alla Designer Modulo, fare clic con il pulsante destro del mouse sul modulo e quindi scegliere Proprietà.
Fare clic sull'icona Eventi e quindi fare doppio clic sull'evento di caricamento per aggiungere l'evento Form1_Load al codice.

Aggiungere il codice seguente all'evento Form1_Load .

arr[0] = new guitar("Gibson", "Les Paul", 1958);
arr[1] = new guitar("Fender", "Jazz Bass", 1964);
arr[2] = new guitar("Guild", "Bluesbird", 1971);
currencyManager = (CurrencyManager)dataGrid1.BindingContext[arr];
dataGrid1.DataSource=arr;

Passare a per visualizzare la Designer Modulo.
Fare doppio clic su Avanti e quindi aggiungere il codice seguente all'evento button1_Click .
```
currencyManager.Position++;
```
Fare doppio clic su Indietro e quindi aggiungere il codice seguente all'evento button2_Click .
```
currencyManager.Position--;
```
Fare doppio clic su First (Prima) e quindi aggiungere il codice seguente all'evento button3_Click .
```
currencyManager.Position = 0;
```
Fare doppio clic su Last (Ultimo) e quindi aggiungere il codice seguente all'evento button4_Click .
```
currencyManager.Position = arr.Length - 1;
```
Compilare ed eseguire il progetto.
Fare clic sui pulsanti di comando per spostarsi tra le righe del controllo DataGrid.

Nota

Se lo si desidera, è possibile modificare i valori degli oggetti.

Usare una struttura anziché una classe

Le regole per l'associazione di una struttura sono le stesse delle regole per l'associazione di un oggetto. La proprietà che è funzioni di accesso ai membri è obbligatoria. Una struttura creata a questo scopo è simile a una classe .

Per eseguire l'associazione a una matrice di strutture, seguire questa procedura.

Modificare la definizione del modulo di classe Class1.cs nell'esempio da
```
public class guitar
```
all'esempio seguente:
```
public struct guitar
```
Impostare come commento il costruttore predefinito, come indicato di seguito.
```
//public guitar()
//{
//}
```
Compilare ed eseguire di nuovo il programma di esempio e verificare che funzioni con una matrice di strutture.

Riferimenti

Per altre informazioni, vedere l'argomento Consumer of Data on Windows Forms nella Guida di Visual Studio .NET Online.