DataGridView.CellParsing Evento

Definición

Se produce cuando una celda cuyo valor ha sido modificado deja de estar en modo de edición.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 

Ejemplos

En el ejemplo de código siguiente se muestra cómo controlar el evento CellParsing.The following code example shows how to handle the CellParsing event. También se muestra cómo usar la clase DataGridViewCellParsingEventArgs.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

Comentarios

De forma predeterminada, el control DataGridView intentará convertir un valor especificado por el usuario que se muestra en una celda en un valor de celda subyacente real en el tipo especificado por la propiedad de la celda ValueType.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. Esta conversión usa las propiedades de formato del estilo de celda devuelto por la propiedad Cell InheritedStyle.This conversion uses the formatting properties of the cell style returned by the cell InheritedStyle property.

Si la conversión estándar no satisface sus necesidades, controle el evento CellParsing para proporcionar una conversión de valor personalizada al tipo requerido.If the standard conversion does not meet your needs, handle the CellParsing event to provide custom value conversion to the required type.

Los usuarios pueden entrar en el modo de edición mediante el método especificado por la propiedad EditMode, y pueden dejar el modo de edición, confirmar los cambios en una celda, desplazarse a otra celda o presionando entrar.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. Si presiona ESC, se revertirán los cambios realizados en el valor antes de que se confirme y no se producirá el evento CellParsing.Pressing ESC will revert any changes to the value before it is committed, and the CellParsing event will not occur. El evento CellParsing solo se produce si el valor de la celda se ha modificado realmente, aunque el valor final sea el mismo que el valor original.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. También se produce cuando se llama al método CommitEdit.It also occurs when the CommitEdit method is called.

Al controlar el evento CellParsing, puede convertir el valor usted mismo o puede personalizar la conversión predeterminada.When you handle the CellParsing event, you can convert the value yourself or you can customize the default conversion. Por ejemplo, puede convertir el valor mediante el método Cell ParseFormattedValue con convertidores de tipos de su elección.For example, you can convert the value yourself using the cell ParseFormattedValue method with type converters of your choosing. Como alternativa, puede permitir que los convertidores de tipos predeterminados analicen el valor, pero modifiquen las propiedades NullValue, DataSourceNullValue y FormatProvider del objeto devuelto por la propiedad DataGridViewCellParsingEventArgs.InheritedCellStyle, que se inicializa mediante la propiedad de la celda InheritedStyle.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.

Al convertir el valor usted mismo, reemplace el valor con formato inicial de la propiedad ConvertEventArgs.Value por el valor convertido en el tipo especificado por la propiedad de la celda ValueType.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. Para indicar que no es necesario realizar más análisis, establezca la propiedad DataGridViewCellParsingEventArgs.ParsingApplied en true.To indicate that no further parsing is necessary, set the DataGridViewCellParsingEventArgs.ParsingApplied property to true.

Cuando el controlador de eventos se completa, si el ConvertEventArgs.Value es null o no es del tipo correcto, o la propiedad DataGridViewCellParsingEventArgs.ParsingApplied es false, Value se analiza con el método ParseFormattedValue de la celda con convertidores de tipos predeterminados.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. La implementación predeterminada de este método analiza el valor utilizando las propiedades NullValue, DataSourceNullValue y FormatProvider del estilo de celda pasado.The default implementation of this method parses the value using the NullValue, DataSourceNullValue, and FormatProvider properties of the cell style passed in. Si el valor no es igual a NullValue, el valor se analiza utilizando la propiedad FormatProvider y los convertidores de tipos pasados.If the value is not equal to NullValue, the value is parsed using the FormatProvider property and the type converters passed in.

Para personalizar la conversión de un valor de celda en un valor con formato para su presentación, controle el evento CellFormatting.To customize the conversion of a cell value into a formatted value for display, handle the CellFormatting event.

Para obtener más información acerca de cómo controlar eventos, vea controlar y provocar eventos.For more information about how to handle events, see Handling and Raising Events.

Se aplica a

Consulte también: