DataGridView.CellParsing DataGridView.CellParsing DataGridView.CellParsing DataGridView.CellParsing Event

Definition

Tritt ein, wenn eine Zelle den Bearbeitungsmodus verlässt und der Zellwert geändert wurde.Occurs when a cell leaves edit mode if the cell value has been modified.

public:
 event System::Windows::Forms::DataGridViewCellParsingEventHandler ^ CellParsing;
public event System.Windows.Forms.DataGridViewCellParsingEventHandler CellParsing;
member this.CellParsing : System.Windows.Forms.DataGridViewCellParsingEventHandler 
Public Custom Event CellParsing As DataGridViewCellParsingEventHandler 

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie das CellParsing -Ereignis behandelt wird.The following code example shows how to handle the CellParsing event. Außerdem wird gezeigt, wie die DataGridViewCellParsingEventArgs -Klasse verwendet wird.It also shows how to use the DataGridViewCellParsingEventArgs class.

// Handling CellParsing allows one to accept user input, then map it to a different
// internal representation.
void dataGridView1_CellParsing( Object^ /*sender*/, DataGridViewCellParsingEventArgs^ e )
{
   if ( this->dataGridView1->Columns[ e->ColumnIndex ]->Name->Equals( "Release Date" ) )
   {
      if ( e != nullptr )
      {
         if ( e->Value != nullptr )
         {
            try
            {
               // Map what the user typed into UTC.
               e->Value = DateTime::Parse( e->Value->ToString() ).ToUniversalTime();

               // Set the ParsingApplied property to 
               // Show the event is handled.
               e->ParsingApplied = true;
            }
            catch ( FormatException^ /*ex*/ ) 
            {
               // Set to false in case another CellParsing handler
               // wants to try to parse this DataGridViewCellParsingEventArgs instance.
               e->ParsingApplied = false;
            }
         }
      }
   }
}
// Handling CellParsing allows one to accept user input, then map it to a different
// internal representation.
private void dataGridView1_CellParsing(object sender, DataGridViewCellParsingEventArgs e)
{
    if (this.dataGridView1.Columns[e.ColumnIndex].Name == "Release Date")
    {
        if (e != null)
        {
            if (e.Value != null)
            {
                try
                {
                    // Map what the user typed into UTC.
                    e.Value = DateTime.Parse(e.Value.ToString()).ToUniversalTime();
                    // Set the ParsingApplied property to 
                    // Show the event is handled.
                    e.ParsingApplied = true;

                }
                catch (FormatException)
                {
                    // Set to false in case another CellParsing handler
                    // wants to try to parse this DataGridViewCellParsingEventArgs instance.
                    e.ParsingApplied = false;
                }
            }
        }
    }
}
' Handling CellParsing allows one to accept user input, then map it to a different
' internal representation.
Private Sub dataGridView1_CellParsing(ByVal sender As Object, _
    ByVal e As DataGridViewCellParsingEventArgs) _
    Handles dataGridView1.CellParsing

    If Me.dataGridView1.Columns(e.ColumnIndex).Name = _
        "Release Date" Then
        If e IsNot Nothing Then
            If e.Value IsNot Nothing Then
                Try
                    ' Map what the user typed into UTC.
                    e.Value = _
                    DateTime.Parse(e.Value.ToString()).ToUniversalTime()
                    ' Set the ParsingApplied property to 
                    ' Show the event is handled.
                    e.ParsingApplied = True

                Catch ex As FormatException
                    ' Set to false in case another CellParsing handler
                    ' wants to try to parse this DataGridViewCellParsingEventArgs instance.
                    e.ParsingApplied = False
                End Try
            End If
        End If
    End If
End Sub

Hinweise

Standardmäßig versucht das DataGridView Steuerelement, einen vom Benutzer angegebenen Wert, der in einer Zelle angezeigt wird, in einen tatsächlichen zugrunde liegenden Zellwert in dem von der ValueType Cell-Eigenschaft angegebenen Typ zu konvertieren.By default, the DataGridView control will attempt to convert a user-specified value displayed in a cell to an actual underlying cell value in the type specified by the cell ValueType property. Diese Konvertierung verwendet die Formatierungs Eigenschaften des Zellstils, der von der InheritedStyle Cell-Eigenschaft zurückgegeben wird.This conversion uses the formatting properties of the cell style returned by the cell InheritedStyle property.

Wenn die Standard Konvertierung nicht Ihren Anforderungen entspricht, behandeln Sie das CellParsing -Ereignis, um eine benutzerdefinierte Wert Konvertierung in den erforderlichen Typ zu ermöglichen.If the standard conversion does not meet your needs, handle the CellParsing event to provide custom value conversion to the required type.

Benutzer können mithilfe der Methode, die von der EditMode -Eigenschaft angegeben wird, in den Bearbeitungsmodus wechseln und den Bearbeitungsmodus verlassen, Änderungen an einer Zelle ausführen, indem Sie in eine andere Zelle verschieben oder die EINGABETASTE drücken.Users can enter edit mode using the method specified by the EditMode property, and can leave edit mode, committing any changes to a cell, by moving to another cell or by pressing ENTER. Durch Drücken von ESC werden alle Änderungen an dem Wert zurückgesetzt, bevor ein Commit CellParsing ausgeführt wird, und das Ereignis tritt nicht auf.Pressing ESC will revert any changes to the value before it is committed, and the CellParsing event will not occur. Das CellParsing Ereignis tritt nur auf, wenn der Zellwert tatsächlich geändert wurde, auch wenn der endgültige Wert mit dem ursprünglichen Wert übereinstimmt.The CellParsing event occurs only if the cell value has actually been modified, even if the final value is the same as the original value. Sie tritt auch auf, CommitEdit wenn die-Methode aufgerufen wird.It also occurs when the CommitEdit method is called.

Wenn Sie das CellParsing -Ereignis behandeln, können Sie den Wert selbst konvertieren, oder Sie können die Standard Konvertierung anpassen.When you handle the CellParsing event, you can convert the value yourself or you can customize the default conversion. Beispielsweise können Sie den Wert selbst mithilfe der Cell ParseFormattedValue -Methode mit Typkonvertern Ihrer Wahl konvertieren.For example, you can convert the value yourself using the cell ParseFormattedValue method with type converters of your choosing. Alternativ können Sie den Standardtypkonverter den Wert analysieren NullValuelassen, aber die Eigenschaften, DataSourceNullValueund FormatProvider des Objekts ändern, das von der DataGridViewCellParsingEventArgs.InheritedCellStyle Eigenschaft zurückgegeben wird, die mithilfe der Zelle InheritedStyle initialisiert wird. Property.Alternatively, you can let the default type converters parse the value, but modify the NullValue, DataSourceNullValue, and FormatProvider properties of the object returned by the DataGridViewCellParsingEventArgs.InheritedCellStyle property, which is initialized using the cell InheritedStyle property.

Wenn Sie den Wert selbst konvertieren, ersetzen Sie den anfänglichen formatierten Wert der ConvertEventArgs.Value -Eigenschaft durch den konvertierten Wert in dem von der Cell ValueType -Eigenschaft angegebenen Typ.When you convert the value yourself, replace the initial, formatted value of the ConvertEventArgs.Value property with the converted value in the type specified by the cell ValueType property. Legen Sie die DataGridViewCellParsingEventArgs.ParsingApplied -Eigenschaft auf truefest, um anzugeben, dass keine weitere-Verarbeitung erforderlich ist.To indicate that no further parsing is necessary, set the DataGridViewCellParsingEventArgs.ParsingApplied property to true.

Wenn der-Ereignishandler abgeschlossen wird, ConvertEventArgs.Value Wenn null der oder der nicht der richtige Typ ist oder die DataGridViewCellParsingEventArgs.ParsingApplied -Eigenschaft falseist, Value wird der mithilfe der Cell ParseFormattedValue -Methode mit Standardtypkonvertern analysiert.When the event handler completes, if the ConvertEventArgs.Value is null or is not of the correct type, or the DataGridViewCellParsingEventArgs.ParsingApplied property is false, the Value is parsed using the cell ParseFormattedValue method with default type converters. Die Standard Implementierung dieser Methode analysiert den Wert mithilfe der NullValueEigenschaften, und DataSourceNullValue FormatProvider des Zellstils, der übertragen wird.The default implementation of this method parses the value using the NullValue, DataSourceNullValue, and FormatProvider properties of the cell style passed in. Wenn der Wert nicht gleich NullValueist, wird der Wert mithilfe der FormatProvider -Eigenschaft und der Übergabe der Typkonverter analysiert.If the value is not equal to NullValue, the value is parsed using the FormatProvider property and the type converters passed in.

Um die Konvertierung eines Zellwerts in einen formatierten Wert für die Anzeige anzupassen, behandeln CellFormatting Sie das-Ereignis.To customize the conversion of a cell value into a formatted value for display, handle the CellFormatting event.

Weitere Informationen zum Behandeln von Ereignissen finden Sie unter behandeln und Auslösen von Ereignissen.For more information about how to handle events, see Handling and Raising Events.

Gilt für:

Siehe auch