DataGridBoolColumn Klasa

Definicja

Przestrzeń nazw:

System.Windows.Forms

Zestaw:

System.Windows.Forms.dll

Określa kolumnę, w której każda komórka zawiera pole wyboru reprezentujące wartość logiczną.

public ref class DataGridBoolColumn : System::Windows::Forms::DataGridColumnStyle

public class DataGridBoolColumn : System.Windows.Forms.DataGridColumnStyle

type DataGridBoolColumn = class
    inherit DataGridColumnStyle

Public Class DataGridBoolColumn
Inherits DataGridColumnStyle

Dziedziczenie

Object

MarshalByRefObject

Component

DataGridColumnStyle

DataGridBoolColumn

Przykłady

Poniższy przykład kodu najpierw tworzy nowy DataGridBoolColumn element i dodaje go do GridColumnStylesCollection obiektu DataGridTableStyle.

using namespace System;
using namespace System::Data;
using namespace System::Windows::Forms;
using namespace System::Drawing;
using namespace System::ComponentModel;

public ref class DataGridBoolColumnInherit: public DataGridBoolColumn
{
private:
   SolidBrush^ trueBrush;
   SolidBrush^ falseBrush;
   DataColumn^ expressionColumn;
   static int count = 0;

public:
   DataGridBoolColumnInherit()
      : DataGridBoolColumn()
   {
      trueBrush = dynamic_cast<SolidBrush^>(Brushes::Blue);
      falseBrush = dynamic_cast<SolidBrush^>(Brushes::Yellow);
      expressionColumn = nullptr;
      count++;
   }

   property Color FalseColor 
   {
      Color get()
      {
         return falseBrush->Color;
      }

      void set( Color value )
      {
         falseBrush = gcnew System::Drawing::SolidBrush( value );
         Invalidate();
      }
   }

   property Color TrueColor 
   {
      Color get()
      {
         return trueBrush->Color;
      }

      void set( Color value )
      {
         trueBrush = gcnew System::Drawing::SolidBrush( value );
         Invalidate();
      }
   }

   property String^ Expression 
   {
      // This will work only with a DataSet or DataTable.
      // The code is not compatible with IBindingList* implementations.
      String^ get()
      {
         return this->expressionColumn == nullptr ? String::Empty : this->expressionColumn->Expression;
      }

      void set( String^ value )
      {
         if ( expressionColumn == nullptr )
                  AddExpressionColumn( value );
         else
                  expressionColumn->Expression = value;

         if ( expressionColumn != nullptr && expressionColumn->Expression->Equals( value ) )
                  return;

         Invalidate();
      }
   }

private:
   void AddExpressionColumn( String^ value )
   {
      // Get the grid's data source. First check for a 0 
      // table or data grid.
      if ( this->DataGridTableStyle == nullptr || this->DataGridTableStyle->DataGrid == nullptr )
            return;

      DataGrid^ myGrid = this->DataGridTableStyle->DataGrid;
      DataView^ myDataView = dynamic_cast<DataView^>((dynamic_cast<CurrencyManager^>(myGrid->BindingContext[ myGrid->DataSource,myGrid->DataMember ]))->List);

      // This works only with System::Data::DataTable.
      if ( myDataView == nullptr )
            return;

      // If the user already added a column with the name 
      // then exit. Otherwise, add the column and set the 
      // expression to the value passed to this function.
      DataColumn^ col = myDataView->Table->Columns[ "__Computed__Column__" ];
      if ( col != nullptr )
            return;

      col = gcnew DataColumn( String::Concat( "__Computed__Column__", count ) );
      myDataView->Table->Columns->Add( col );
      col->Expression = value;
      expressionColumn = col;
   }

   //  the OnPaint method to paint the cell based on the expression.
protected:
   virtual void Paint( Graphics^ g, Rectangle bounds, CurrencyManager^ source, int rowNum, Brush^ backBrush, Brush^ foreBrush, bool alignToRight ) override
   {
      bool trueExpression = false;
      bool hasExpression = false;
      DataRowView^ drv = dynamic_cast<DataRowView^>(source->List[ rowNum ]);
      hasExpression = this->expressionColumn != nullptr && this->expressionColumn->Expression != nullptr &&  !this->expressionColumn->Expression->Equals( String::Empty );
      Console::WriteLine( String::Format( "hasExpressionValue {0}", hasExpression ) );

      // Get the value from the expression column.
      // For simplicity, we assume a True/False value for the 
      // expression column.
      if ( hasExpression )
      {
         Object^ expr = drv->Row[ expressionColumn->ColumnName ];
         trueExpression = expr->Equals( "True" );
      }

      // Let the DataGridBoolColumn do the painting.
      if (  !hasExpression )
            DataGridBoolColumn::Paint( g, bounds, source, rowNum, backBrush, foreBrush, alignToRight );

      // Paint using the expression color for true or false, as calculated.
      if ( trueExpression )
            DataGridBoolColumn::Paint( g, bounds, source, rowNum, trueBrush, foreBrush, alignToRight );
      else
            DataGridBoolColumn::Paint( g, bounds, source, rowNum, falseBrush, foreBrush, alignToRight );
   }
};

public ref class MyForm: public Form
{
private:
   DataTable^ myTable;
   DataGrid^ myGrid;

public:
   MyForm()
   {
      myGrid = gcnew DataGrid;
      try
      {
         InitializeComponent();
         myTable = gcnew DataTable( "NamesTable" );
         myTable->Columns->Add( gcnew DataColumn( "Name" ) );
         DataColumn^ column = gcnew DataColumn( "id",Int32::typeid );
         myTable->Columns->Add( column );
         myTable->Columns->Add( gcnew DataColumn( "calculatedField",bool::typeid ) );
         DataSet^ namesDataSet = gcnew DataSet;
         namesDataSet->Tables->Add( myTable );
         myGrid->SetDataBinding( namesDataSet, "NamesTable" );
         AddTableStyle();
         AddData();
      }
      catch ( System::Exception^ exc ) 
      {
         Console::WriteLine( exc );
      }
   }

private:
   void grid_Enter( Object^ sender, EventArgs^ e )
   {
      myGrid->CurrentCell = DataGridCell(2,2);
   }

   void AddTableStyle()
   {
      // Map a new  TableStyle to the DataTable. Then 
      // add DataGridColumnStyle objects to the collection
      // of column styles with appropriate mappings.
      DataGridTableStyle^ dgt = gcnew DataGridTableStyle;
      dgt->MappingName = "NamesTable";
      DataGridTextBoxColumn^ dgtbc = gcnew DataGridTextBoxColumn;
      dgtbc->MappingName = "Name";
      dgtbc->HeaderText = "Name";
      dgt->GridColumnStyles->Add( dgtbc );
      dgtbc = gcnew DataGridTextBoxColumn;
      dgtbc->MappingName = "id";
      dgtbc->HeaderText = "id";
      dgt->GridColumnStyles->Add( dgtbc );
      DataGridBoolColumnInherit^ db = gcnew DataGridBoolColumnInherit;
      db->HeaderText = "less than 1000 = blue";
      db->Width = 150;
      db->MappingName = "calculatedField";
      dgt->GridColumnStyles->Add( db );
      myGrid->TableStyles->Add( dgt );

      // This expression instructs the grid to change
      // the color of the inherited DataGridBoolColumn
      // according to the value of the id field. If it's
      // less than 1000, the row is blue. Otherwise,
      // the color is yellow.
      db->Expression = "id < 1000";
   }

   void AddData()
   {
      // Add data with varying numbers for the id field.
      // If the number is over 1000, the cell will paint
      // yellow. Otherwise, it will be blue.
      DataRow^ dRow = myTable->NewRow();
      dRow[ "Name" ] = "name 1 ";
      dRow[ "id" ] = 999;
      myTable->Rows->Add( dRow );
      dRow = myTable->NewRow();
      dRow[ "Name" ] = "name 2";
      dRow[ "id" ] = 2300;
      myTable->Rows->Add( dRow );
      dRow = myTable->NewRow();
      dRow[ "Name" ] = "name 3";
      dRow[ "id" ] = 120;
      myTable->Rows->Add( dRow );
      dRow = myTable->NewRow();
      dRow[ "Name" ] = "name 4";
      dRow[ "id" ] = 4023;
      myTable->Rows->Add( dRow );
      dRow = myTable->NewRow();
      dRow[ "Name" ] = "name 5";
      dRow[ "id" ] = 2345;
      myTable->Rows->Add( dRow );
      myTable->AcceptChanges();
   }

   void InitializeComponent()
   {
      this->Size = System::Drawing::Size( 500, 500 );
      myGrid->Size = System::Drawing::Size( 350, 250 );
      myGrid->TabStop = true;
      myGrid->TabIndex = 1;
      this->StartPosition = FormStartPosition::CenterScreen;
      this->Controls->Add( myGrid );
   }
};

[STAThread]
int main()
{
   Application::Run( gcnew MyForm );
}

using System;
using System.Data;
using System.Windows.Forms;
using System.Drawing;
using System.ComponentModel;

public class MyForm : Form 
{
    private DataTable myTable;
    private DataGrid myGrid = new DataGrid();
    
    public MyForm() : base() 
    {
        try
        {
            InitializeComponent();

            myTable = new DataTable("NamesTable");
            myTable.Columns.Add(new DataColumn("Name"));
            DataColumn column = new DataColumn
                ("id", typeof(System.Int32));
            myTable.Columns.Add(column);
            myTable.Columns.Add(new 
                DataColumn("calculatedField", typeof(bool)));
            DataSet namesDataSet = new DataSet();
            namesDataSet.Tables.Add(myTable);
            myGrid.SetDataBinding(namesDataSet, "NamesTable");
        
            AddTableStyle();
            AddData();
        }
        catch (System.Exception exc)
        {
            Console.WriteLine(exc.ToString());
        }
    }

    private void grid_Enter(object sender, EventArgs e) 
    {
        myGrid.CurrentCell = new DataGridCell(2,2);
    }

    private void AddTableStyle()
    {
        // Map a new  TableStyle to the DataTable. Then 
        // add DataGridColumnStyle objects to the collection
        // of column styles with appropriate mappings.
        DataGridTableStyle dgt = new DataGridTableStyle();
        dgt.MappingName = "NamesTable";

        DataGridTextBoxColumn dgtbc = new DataGridTextBoxColumn();
        dgtbc.MappingName = "Name";
        dgtbc.HeaderText= "Name";
        dgt.GridColumnStyles.Add(dgtbc);

        dgtbc = new DataGridTextBoxColumn();
        dgtbc.MappingName = "id";
        dgtbc.HeaderText= "id";
        dgt.GridColumnStyles.Add(dgtbc);

        DataGridBoolColumnInherit db = 
            new DataGridBoolColumnInherit();
        db.HeaderText= "less than 1000 = blue";
        db.Width= 150;
        db.MappingName = "calculatedField";
        dgt.GridColumnStyles.Add(db);

        myGrid.TableStyles.Add(dgt);

        // This expression instructs the grid to change
        // the color of the inherited DataGridBoolColumn
        // according to the value of the id field. If it's
        // less than 1000, the row is blue. Otherwise,
        // the color is yellow.
        db.Expression = "id < 1000";
    }

    private void AddData() 
    {
        // Add data with varying numbers for the id field.
        // If the number is over 1000, the cell will paint
        // yellow. Otherwise, it will be blue.
        DataRow dRow = myTable.NewRow();

        dRow["Name"] = "name 1 ";
        dRow["id"] = 999;
        myTable.Rows.Add(dRow);

        dRow = myTable.NewRow();
        dRow["Name"] = "name 2";
        dRow["id"] = 2300;
        myTable.Rows.Add(dRow);

        dRow = myTable.NewRow();
        dRow["Name"] = "name 3";
        dRow["id"] = 120;
        myTable.Rows.Add(dRow);

        dRow = myTable.NewRow();
        dRow["Name"] = "name 4";
        dRow["id"] = 4023;
        myTable.Rows.Add(dRow);

        dRow = myTable.NewRow();
        dRow["Name"] = "name 5";
        dRow["id"] = 2345;
        myTable.Rows.Add(dRow);

        myTable.AcceptChanges();
    }

    private void InitializeComponent() 
    {
        this.Size = new Size(500, 500);
        myGrid.Size = new Size(350, 250);
        myGrid.TabStop = true;
        myGrid.TabIndex = 1;
      
        this.StartPosition = FormStartPosition.CenterScreen;
        this.Controls.Add(myGrid);
      }
    [STAThread]
    public static void Main() 
    {
        Application.Run(new MyForm());
    }
}

public class DataGridBoolColumnInherit : DataGridBoolColumn 
{
    private SolidBrush trueBrush = Brushes.Blue as SolidBrush;
    private SolidBrush falseBrush = Brushes.Yellow as SolidBrush;
    private DataColumn expressionColumn = null;
    private static int count = 0;

    public Color FalseColor 
    {
        get 
        {
            return falseBrush.Color;
        }
        set 
        {
            falseBrush = new SolidBrush(value);
            Invalidate();
        }
    }

    public Color TrueColor 
    {
        get 
        {
            return trueBrush.Color;
        }
        set 
        {
            trueBrush = new SolidBrush(value);
            Invalidate();
        }
    }

    public DataGridBoolColumnInherit() : base () 
    {
        count ++;
    }

    // This will work only with a DataSet or DataTable.
    // The code is not compatible with IBindingList implementations.
    public string Expression 
    {
        get 
        {
            return this.expressionColumn == null ? String.Empty : 
                this.expressionColumn.Expression;
        }
        set 
        {
            if (expressionColumn == null)
                AddExpressionColumn(value);
            else 
                expressionColumn.Expression = value;
            if (expressionColumn != null && 
                expressionColumn.Expression.Equals(value))
                return;
            Invalidate();
        }
    }

    private void AddExpressionColumn(string value) 
    {
        // Get the grid's data source. First check for a null 
        // table or data grid.
        if (this.DataGridTableStyle == null || 
            this.DataGridTableStyle.DataGrid == null)
            return;

        DataGrid myGrid = this.DataGridTableStyle.DataGrid;
        DataView myDataView = ((CurrencyManager) 
            myGrid.BindingContext[myGrid.DataSource, 
            myGrid.DataMember]).List 
            as DataView;

        // This works only with System.Data.DataTable.
        if (myDataView == null)
            return;

        // If the user already added a column with the name 
        // then exit. Otherwise, add the column and set the 
        // expression to the value passed to this function.
        DataColumn col = myDataView.Table.Columns["__Computed__Column__"];
        if (col != null)
            return;
        col = new DataColumn("__Computed__Column__" + count.ToString());

        myDataView.Table.Columns.Add(col);
        col.Expression = value;
        expressionColumn = col;
    }

    // override the OnPaint method to paint the cell based on the expression.
    protected override void Paint(Graphics g, Rectangle bounds,
        CurrencyManager source, int rowNum,
        Brush backBrush, Brush foreBrush,
        bool alignToRight) 
    {
        bool trueExpression = false;
        bool hasExpression = false;
        DataRowView drv = source.List[rowNum] as DataRowView;

        hasExpression = this.expressionColumn != null && 
            this.expressionColumn.Expression != null && 
            !this.expressionColumn.Expression.Equals(String.Empty);

        Console.WriteLine(string.Format("hasExpressionValue {0}",hasExpression));
        // Get the value from the expression column.
        // For simplicity, we assume a True/False value for the 
        // expression column.
        if (hasExpression) 
        {
            object expr = drv.Row[expressionColumn.ColumnName];
            trueExpression = expr.Equals("True");
        }

        // Let the DataGridBoolColumn do the painting.
        if (!hasExpression)
            base.Paint(g, bounds, source, rowNum, 
                backBrush, foreBrush, alignToRight);

        // Paint using the expression color for true or false, as calculated.
        if (trueExpression)
            base.Paint(g, bounds, source, rowNum, 
                trueBrush, foreBrush, alignToRight);
        else
            base.Paint(g, bounds, source, rowNum, 
                falseBrush, foreBrush, alignToRight);
    }
}

Imports System.Data
Imports System.Windows.Forms
Imports System.Drawing
Imports System.ComponentModel

Public Class MyForm
    Inherits System.Windows.Forms.Form
    Private components As System.ComponentModel.Container
    Private myTable As DataTable
    Private myGrid As DataGrid = New DataGrid()

    Public Shared Sub Main()
        Application.Run(New MyForm())
    End Sub

    Public Sub New()
        Try
            InitializeComponent()
            myTable = New DataTable("NamesTable")
            myTable.Columns.Add(New DataColumn("Name"))
            Dim column As DataColumn = New DataColumn _
            ("id", GetType(System.Int32))
            myTable.Columns.Add(column)
            myTable.Columns.Add(New DataColumn _
            ("calculatedField", GetType(Boolean)))
            Dim namesDataSet As DataSet = New DataSet("myDataSet")
            namesDataSet.Tables.Add(myTable)
            myGrid.SetDataBinding(namesDataSet, "NamesTable")
            AddData()
            AddTableStyle()

        Catch exc As System.Exception
            Console.WriteLine(exc.ToString)
        End Try
    End Sub

    Private Sub AddTableStyle()
        ' Map a new  TableStyle to the DataTable. Then 
        ' add DataGridColumnStyle objects to the collection
        ' of column styles with appropriate mappings.
        Dim dgt As DataGridTableStyle = New DataGridTableStyle()
        dgt.MappingName = "NamesTable"

        Dim dgtbc As DataGridTextBoxColumn = _
        New DataGridTextBoxColumn()
        dgtbc.MappingName = "Name"
        dgtbc.HeaderText = "Name"
        dgt.GridColumnStyles.Add(dgtbc)

        dgtbc = New DataGridTextBoxColumn()
        dgtbc.MappingName = "id"
        dgtbc.HeaderText = "id"
        dgt.GridColumnStyles.Add(dgtbc)

        Dim db As DataGridBoolColumnInherit = _
        New DataGridBoolColumnInherit()
        db.HeaderText = "less than 1000 = blue"
        db.Width = 150
        db.MappingName = "calculatedField"
        dgt.GridColumnStyles.Add(db)

        myGrid.TableStyles.Add(dgt)

        ' This expression instructs the grid to change
        ' the color of the inherited DataGridBoolColumn
        ' according to the value of the id field. If it's
        ' less than 1000, the row is blue. Otherwise,
        ' the color is yellow.
        db.Expression = "id < 1000"
    End Sub

    Private Sub AddData()

        ' Add data with varying numbers for the id field.
        ' If the number is over 1000, the cell will paint
        ' yellow. Otherwise, it will be blue.
        Dim dRow As DataRow

        dRow = myTable.NewRow()
        dRow("Name") = "name 1"
        dRow("id") = 999
        myTable.Rows.Add(dRow)

        dRow = myTable.NewRow()
        dRow("Name") = "name 2"
        dRow("id") = 2300
        myTable.Rows.Add(dRow)

        dRow = myTable.NewRow()
        dRow("Name") = "name 3"
        dRow("id") = 120
        myTable.Rows.Add(dRow)

        dRow = myTable.NewRow()
        dRow("Name") = "name 4"
        dRow("id") = 4023
        myTable.Rows.Add(dRow)

        dRow = myTable.NewRow()
        dRow("Name") = "name 5"
        dRow("id") = 2345
        myTable.Rows.Add(dRow)

        myTable.AcceptChanges()
    End Sub

    Private Sub InitializeComponent()
        Me.Size = New Size(500, 500)
        myGrid.Size = New Size(350, 250)
        myGrid.TabStop = True
        myGrid.TabIndex = 1
        Me.StartPosition = FormStartPosition.CenterScreen
        Me.Controls.Add(myGrid)
    End Sub

End Class


Public Class DataGridBoolColumnInherit
    Inherits DataGridBoolColumn

    Private trueBrush As SolidBrush = Brushes.Blue
    Private falseBrush As SolidBrush = Brushes.Yellow
    Private expressionColumn As DataColumn = Nothing
    Shared count As Int32 = 0

    Public Property FalseColor() As Color
        Get
            Return falseBrush.Color
        End Get

        Set(ByVal Value As Color)

            falseBrush = New SolidBrush(Value)
            Invalidate()
        End Set
    End Property

    Public Property TrueColor() As Color
        Get
            Return trueBrush.Color
        End Get

        Set(ByVal Value As Color)

            trueBrush = New SolidBrush(Value)
            Invalidate()
        End Set
    End Property

    Public Sub New()
        count += 1
    End Sub

    ' This will work only with a DataSet or DataTable.
    ' The code is not compatible with IBindingList implementations.
    Public Property Expression() As String
        Get
            If Me.expressionColumn Is Nothing Then
                Return String.Empty
            Else
                Return Me.expressionColumn.Expression
            End If
        End Get
        Set(ByVal Value As String)
            If expressionColumn Is Nothing Then
                AddExpressionColumn(Value)
            Else
                expressionColumn.Expression = Value
            End If
            If (expressionColumn IsNot Nothing) And expressionColumn.Expression.Equals(Value) Then
                Return
            End If
            Invalidate()
        End Set
    End Property

    Private Sub AddExpressionColumn(ByVal value As String)
        ' Get the grid's data source. First check for a null 
        ' table or data grid.
        If Me.DataGridTableStyle Is Nothing Or _
        Me.DataGridTableStyle.DataGrid Is Nothing Then
            Return
        End If

        Dim dg As DataGrid = Me.DataGridTableStyle.DataGrid
        Dim dv As DataView = CType(dg.BindingContext(dg.DataSource, dg.DataMember), CurrencyManager).List

        ' This works only with System.Data.DataTable.
        If dv Is Nothing Then
            Return
        End If

        ' If the user already added a column with the name 
        ' then exit. Otherwise, add the column and set the 
        ' expression to the value passed to this function.
        Dim col As DataColumn = dv.Table.Columns("__Computed__Column__")
        If (col IsNot Nothing) Then
            Return
        End If
        col = New DataColumn("__Computed__Column__" + count.ToString())

        dv.Table.Columns.Add(col)

        col.Expression = value
        expressionColumn = col
    End Sub


    ' Override the OnPaint method to paint the cell based on the expression.
    Protected Overloads Overrides Sub Paint _
    (ByVal g As Graphics, _
    ByVal bounds As Rectangle, _
    ByVal [source] As CurrencyManager, _
    ByVal rowNum As Integer, _
    ByVal backBrush As Brush, _
    ByVal foreBrush As Brush, _
    ByVal alignToRight As Boolean)
        Dim trueExpression As Boolean = False
        Dim hasExpression As Boolean = False
        Dim drv As DataRowView = [source].List(rowNum)
        hasExpression = (Me.expressionColumn IsNot Nothing) And (Me.expressionColumn.Expression IsNot Nothing) And Not Me.expressionColumn.Expression.Equals([String].Empty)

        ' Get the value from the expression column.
        ' For simplicity, we assume a True/False value for the 
        ' expression column.
        If hasExpression Then
            Dim expr As Object = drv.Row(expressionColumn.ColumnName)
            trueExpression = expr.Equals("True")
        End If

        ' Let the DataGridBoolColumn do the painting.
        If Not hasExpression Then
            MyBase.Paint(g, bounds, [source], rowNum, backBrush, foreBrush, alignToRight)
        End If

        ' Paint using the expression color for true or false, as calculated.
        If trueExpression Then
            MyBase.Paint(g, bounds, [source], rowNum, trueBrush, foreBrush, alignToRight)
        Else
            MyBase.Paint(g, bounds, [source], rowNum, falseBrush, foreBrush, alignToRight)
        End If
    End Sub
End Class

Uwagi

Element DataGridBoolColumn pochodzi z abstract klasy DataGridColumnStyle. W czasie wykonywania pola DataGridBoolColumn wyboru zawierają pola wyboru w każdej komórce, które mają domyślnie trzy stany: zaznaczone (true), niezaznaczone (false) i Value. Aby użyć dwustanowych pól wyboru, ustaw AllowNull właściwość na falsewartość .

Właściwości dodane do klasy to FalseValue, NullValuei TrueValue. Te właściwości określają wartość leżącą u podstaw każdego ze stanów kolumny.

Konstruktory

DataGridBoolColumn()	Inicjuje nowe wystąpienie klasy DataGridBoolColumn.
DataGridBoolColumn(PropertyDescriptor)	Inicjuje DataGridBoolColumn nowe wystąpienie klasy z określonym PropertyDescriptorelementem .
DataGridBoolColumn(PropertyDescriptor, Boolean)	Inicjuje DataGridBoolColumn nowe wystąpienie klasy z określoną wartością PropertyDescriptori określa, czy styl kolumny jest kolumną domyślną.

Właściwości

Alignment	Pobiera lub ustawia wyrównanie tekstu w kolumnie. (Odziedziczone po DataGridColumnStyle)
AllowNull	Pobiera lub ustawia wartość wskazującą, czy wartości null są dozwolone.
CanRaiseEvents	Pobiera wartość wskazującą, czy składnik może zgłosić zdarzenie. (Odziedziczone po Component)
Container	Pobiera element IContainer zawierający element Component. (Odziedziczone po Component)
DataGridTableStyle	Pobiera wartość DataGridTableStyle dla kolumny . (Odziedziczone po DataGridColumnStyle)
DesignMode	Pobiera wartość wskazującą, czy Component element jest obecnie w trybie projektowania. (Odziedziczone po Component)
Events	Pobiera listę programów obsługi zdarzeń dołączonych do tego Componentelementu . (Odziedziczone po Component)
FalseValue	Pobiera lub ustawia rzeczywistą wartość używaną podczas ustawiania wartości kolumny na false.
FontHeight	Pobiera wysokość czcionki kolumny. (Odziedziczone po DataGridColumnStyle)
HeaderAccessibleObject	Pobiera wartość AccessibleObject dla kolumny . (Odziedziczone po DataGridColumnStyle)
HeaderText	Pobiera lub ustawia tekst nagłówka kolumny. (Odziedziczone po DataGridColumnStyle)
MappingName	Pobiera lub ustawia nazwę elementu członkowskiego danych, aby zamapować styl kolumny na . (Odziedziczone po DataGridColumnStyle)
NullText	Pobiera lub ustawia tekst wyświetlany, gdy kolumna zawiera nullwartość . (Odziedziczone po DataGridColumnStyle)
NullValue	Pobiera lub ustawia rzeczywistą wartość używaną podczas ustawiania wartości kolumny na Value.
PropertyDescriptor	Pobiera lub ustawia PropertyDescriptor atrybuty danych wyświetlanych przez element DataGridColumnStyle. (Odziedziczone po DataGridColumnStyle)
ReadOnly	Pobiera lub ustawia wartość wskazującą, czy dane w kolumnie można edytować. (Odziedziczone po DataGridColumnStyle)
Site	Pobiera lub ustawia wartość ISite .Component (Odziedziczone po Component)
TrueValue	Pobiera lub ustawia rzeczywistą wartość używaną podczas ustawiania wartości kolumny na true.
Width	Pobiera lub ustawia szerokość kolumny. (Odziedziczone po DataGridColumnStyle)

Metody

Abort(Int32)	Inicjuje żądanie przerwania procedury edycji.
BeginUpdate()	Zawiesza obraz kolumny do momentu wywołania EndUpdate() metody . (Odziedziczone po DataGridColumnStyle)
CheckValidDataSource(CurrencyManager)	Zgłasza wyjątek, jeśli obiekt DataGrid nie ma prawidłowego źródła danych lub jeśli ta kolumna nie jest mapowana na prawidłową właściwość w źródle danych. (Odziedziczone po DataGridColumnStyle)
ColumnStartedEditing(Control)	DataGrid Informuje o rozpoczęciu edytowania kolumny przez użytkownika. (Odziedziczone po DataGridColumnStyle)
Commit(CurrencyManager, Int32)	Inicjuje żądanie ukończenia procedury edycji.
ConcedeFocus()	Powiadamia kolumnę, że musi zrezygnować z fokusu dla kontrolki, którą hostuje.
CreateHeaderAccessibleObject()	Pobiera wartość AccessibleObject dla kolumny . (Odziedziczone po DataGridColumnStyle)
CreateObjRef(Type)	Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym. (Odziedziczone po MarshalByRefObject)
Dispose()	Zwalnia wszelkie zasoby używane przez element Component. (Odziedziczone po Component)
Dispose(Boolean)	Zwalnia zasoby niezarządzane używane przez element Component i opcjonalnie zwalnia zasoby zarządzane. (Odziedziczone po Component)
Edit(CurrencyManager, Int32, Rectangle, Boolean)	Przygotowuje komórkę do edycji. (Odziedziczone po DataGridColumnStyle)
Edit(CurrencyManager, Int32, Rectangle, Boolean, String)	Przygotowuje komórkę do edycji przy użyciu określonego CurrencyManager, numeru wiersza i Rectangle parametrów. (Odziedziczone po DataGridColumnStyle)
Edit(CurrencyManager, Int32, Rectangle, Boolean, String, Boolean)	Przygotowuje komórkę do edycji wartości.
EndUpdate()	Wznawia malowanie kolumn zawieszonych przez wywołanie BeginUpdate() metody . (Odziedziczone po DataGridColumnStyle)
EnterNullValue()	Wprowadza element Value w kolumnie .
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetColumnValueAtRow(CurrencyManager, Int32)	Pobiera wartość w określonym wierszu.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetLifetimeService()	Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
GetMinimumHeight()	Pobiera wysokość komórki w kolumnie.
GetPreferredHeight(Graphics, Object)	Pobiera wysokość używaną podczas zmiany rozmiaru kolumn.
GetPreferredSize(Graphics, Object)	Pobiera optymalną szerokość i wysokość komórki, która ma zawierać określoną wartość.
GetService(Type)	Zwraca obiekt, który reprezentuje usługę dostarczaną przez Component obiekt lub przez element Container. (Odziedziczone po Component)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
InitializeLifetimeService()	Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
Invalidate()	Ponownie rysuje kolumnę i powoduje wysłanie komunikatu malowania do kontrolki. (Odziedziczone po DataGridColumnStyle)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
MemberwiseClone(Boolean)	Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu. (Odziedziczone po MarshalByRefObject)
Paint(Graphics, Rectangle, CurrencyManager, Int32)	Rysuje element DataGridBoolColumn z podanym RectangleGraphicsnumerem wiersza i .
Paint(Graphics, Rectangle, CurrencyManager, Int32, Boolean)	Rysuje element DataGridBoolColumn z podanymi Graphicsustawieniami , Rectangle, numer wiersza i wyrównania.
Paint(Graphics, Rectangle, CurrencyManager, Int32, Brush, Brush, Boolean)	Rysuje element DataGridBoolColumn z podanymi Graphicswartościami , Rectangle, numerem wiersza, Brushi Color.
ReleaseHostedControl()	Zezwala kolumnie na zwalnianie zasobów, gdy kontrolka, która jest hostem, nie jest potrzebna. (Odziedziczone po DataGridColumnStyle)
ResetHeaderText()	Resetuje wartość domyślną HeaderTextnull, . (Odziedziczone po DataGridColumnStyle)
SetColumnValueAtRow(CurrencyManager, Int32, Object)	Ustawia wartość określonego wiersza.
SetDataGrid(DataGrid)	Ustawia kontrolkę DataGrid , do którego należy ta kolumna. (Odziedziczone po DataGridColumnStyle)
SetDataGridInColumn(DataGrid)	Ustawia wartość DataGrid dla kolumny . (Odziedziczone po DataGridColumnStyle)
ToString()	Zwraca wartość String zawierającą nazwę Componentobiektu , jeśli istnieje. Ta metoda nie powinna być zastępowana. (Odziedziczone po Component)
UpdateUI(CurrencyManager, Int32, String)	Aktualizacje wartość określonego wiersza z danym tekstem. (Odziedziczone po DataGridColumnStyle)

Zdarzenia

AlignmentChanged	Występuje, gdy Alignment wartość właściwości się zmienia. (Odziedziczone po DataGridColumnStyle)
AllowNullChanged	Występuje, gdy właściwość zostanie zmieniona AllowNull .
Disposed	Występuje, gdy składnik jest usuwany przez wywołanie Dispose() metody . (Odziedziczone po Component)
FalseValueChanged	Występuje, gdy właściwość zostanie zmieniona FalseValue .
FontChanged	Występuje, gdy zmienia się czcionka kolumny. (Odziedziczone po DataGridColumnStyle)
HeaderTextChanged	Występuje, gdy HeaderText wartość właściwości się zmienia. (Odziedziczone po DataGridColumnStyle)
MappingNameChanged	Występuje, gdy MappingName wartość się zmienia. (Odziedziczone po DataGridColumnStyle)
NullTextChanged	Występuje, gdy NullText wartość się zmienia. (Odziedziczone po DataGridColumnStyle)
PropertyDescriptorChanged	Występuje, gdy PropertyDescriptor wartość właściwości się zmienia. (Odziedziczone po DataGridColumnStyle)
ReadOnlyChanged	Występuje, gdy ReadOnly wartość właściwości się zmienia. (Odziedziczone po DataGridColumnStyle)
TrueValueChanged	Występuje, gdy wartość właściwości zostanie zmieniona TrueValue .
WidthChanged	Występuje, gdy Width wartość właściwości się zmienia. (Odziedziczone po DataGridColumnStyle)

Jawne implementacje interfejsu

IDataGridColumnStyleEditingNotificationService.ColumnStartedEditing(Control)

Informuje kontrolkę DataGrid o rozpoczęciu edytowania kolumny przez użytkownika. (Odziedziczone po DataGridColumnStyle)

Zobacz też

• DataColumn
• DataGrid
• DataGridColumnStyle
• GridColumnStylesCollection
• GetType()
• Type