Verwenden von Visual C# zum Binden eines DataGrid-Steuerelements an ein Array von Objekten oder Strukturen

Artikel
07/17/2023

Dieser Artikel enthält Informationen zum Binden eines Arrays von Objekten an ein DataGrid-Steuerelement.

Ursprüngliche Produktversion: Visual C#
Ursprüngliche KB-Nummer: 315786

Zusammenfassung

Das Beispiel in diesem Artikel besteht aus einem Windows-Formular mit einem DataGrid-Steuerelement zum Anzeigen von Objekteigenschaftenwerten und vier Befehlsschaltflächen zum Durchsuchen der Zeilen des DataGrid-Steuerelements.

Anforderungen

In diesem Artikel wird davon ausgegangen, dass Sie mit den folgenden Themen vertraut sind:

Visual C#-Programmierkonzepte
Visual C# .NET

Entwerfen der Klasse

Eine Klasse, die an ein Steuerelement gebunden werden soll, muss über Eigenschaftenaccessoren verfügen. Jede Eigenschaft, die gebunden werden soll, muss über die -Eigenschaftsmethode Set und die -Eigenschaftsmethode Get verfügen. Die in diesem Artikel verwendete Beispielklasse verfügt über drei Member. In diesem Artikel wird nur ein Mitglied beschrieben. Ein parametrisierter Konstruktor wurde ebenfalls bereitgestellt. Dies ist jedoch keine Voraussetzung.

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

Hinzufügen von Klasseninstanzen zu einem Array

Führen Sie die folgenden Schritte aus, um Instanzen zu erstellen und sie dem Array hinzuzufügen:

Deklarieren Sie ein Array.

Erstellen Sie Instanzen der -Klasse, und fügen Sie die Instanzen dann dem Array hinzu.

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

Binden des Arrays an das DataGrid-Steuerelement

Nachdem das Array aufgefüllt wurde, legen Sie die DataSource-Eigenschaft des DataGrid-Steuerelements auf das Array fest. Die Spalten im DataGrid-Steuerelement werden basierend auf den Eigenschaften aufgefüllt, für die bereichsinterne Eigenschaftenaccessoren vorhanden sind.

dataGrid1.DataSource=arr;

Bereitstellen einer Möglichkeit zum Durchsuchen des Arrays

Sie können verwenden CurrencyManager , um das Array zu durchsuchen. Ordnen Sie CurrencyManager dazu dem BindingContext des -Steuerelements zu, in diesem Fall dem -Array.

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

Die CurrencyManager -Klasse verfügt über eine Position -Eigenschaft, die Sie bearbeiten können, um die Member des Arrays zu durchlaufen. Durch Hinzufügen oder Subtrahieren des aktuellen Werts von Positionkönnen Sie die Zeilen des DataGrid Steuerelements durchsuchen.

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

Schritt-für-Schritt-Beispiel

Erstellen Sie in Visual C# .NET ein neues Windows-Anwendungsprojekt. Form1 wird standardmäßig erstellt.
Fügen Sie dem Projekt eine Klasse hinzu.

Ersetzen Sie den Code in Class1.cs durch den folgenden Code.

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

Schließen Sie das Class1.cs Codefenster, und wechseln Sie dann zum formular-Designer.
Hinzufügen eines DataGrid-Steuerelements zu Form1. Größe des DataGrid-Steuerelements für vier Spalten und drei Zeilen.
Fügen Sie form1 vier Schaltflächen-Steuerelemente hinzu, und ordnen Sie die Schaltflächen dann horizontal an.
Ändern Sie die Text-Eigenschaft von Button1 in Weiter.
Ändern Sie die Text-Eigenschaft von Button2 in Zurück.
Ändern Sie die Text-Eigenschaft von Button3 in First.
Ändern Sie die Text-Eigenschaft von Button4 in Last.

Fügen Sie der Form1-Klasse den folgenden Code hinzu.

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

Wechseln Sie zum formularbasierten Designer, klicken Sie mit der rechten Maustaste auf das Formular, und klicken Sie dann auf Eigenschaften.
Klicken Sie auf das Symbol Ereignisse , und doppelklicken Sie dann auf das Ladeereignis, um das Form1_Load Ereignis ihrem Code hinzuzufügen.

Fügen Sie dem Ereignis den Form1_Load folgenden Code hinzu.

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;

Wechseln Sie zum Anzeigen des formular-Designer.
Doppelklicken Sie auf Weiter, und fügen Sie dann dem Ereignis den button1_Click folgenden Code hinzu.
```
currencyManager.Position++;
```
Doppelklicken Sie auf Zurück, und fügen Sie dem Ereignis den folgenden Code hinzu button2_Click .
```
currencyManager.Position--;
```
Doppelklicken Sie auf First, und fügen Sie dann dem Ereignis den button3_Click folgenden Code hinzu.
```
currencyManager.Position = 0;
```
Doppelklicken Sie auf Zuletzt, und fügen Sie dann dem Ereignis den button4_Click folgenden Code hinzu.
```
currencyManager.Position = arr.Length - 1;
```
Erstellen Sie das Projekt, und führen Sie es aus.
Klicken Sie auf die Befehlsschaltflächen, um zwischen den Zeilen des DataGrid-Steuerelements zu wechseln.

Hinweis

Sie können die Werte der Objekte bei Bedarf bearbeiten.

Verwenden einer -Struktur anstelle einer Klasse

Die Regeln zum Binden einer Struktur sind identisch mit den Regeln zum Binden eines Objekts. Die Eigenschaft, die Memberaccessoren ist, ist erforderlich. Eine -Struktur, die zu diesem Zweck erstellt wird, ähnelt einer Klasse.

Führen Sie die folgenden Schritte aus, um eine Bindung an ein Array von Strukturen zu erstellen.

Ändern Sie die Definition des Class1.cs-Klassenmoduls im Beispiel von
```
public class guitar
```
im folgenden Beispiel:
```
public struct guitar
```
Kommentieren Sie den Standardkonstruktor wie folgt aus.
```
//public guitar()
//{
//}
```
Erstellen Sie das Beispielprogramm, führen Sie es erneut aus, und überprüfen Sie, ob es mit einem Array von Strukturen funktioniert.

References

Weitere Informationen finden Sie im Thema Consumer von Daten auf Windows Forms in der Visual Studio .NET-Onlinehilfe.