DataGridBoolColumn Osztály

Definíció

Névtér:

System.Windows.Forms

Szerelvény:

System.Windows.Forms.dll

Forrás:

DataGridBoolColumn.cs

Figyelemfelhívás

DataGrid is provided for binary compatibility with .NET Framework and is not intended to be used directly from your code. Use DataGridView instead.

Olyan oszlopot ad meg, amelyben minden cella tartalmaz egy logikai érték jelölésére szolgáló jelölőnégyzetet.

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

[System.ComponentModel.Browsable(false)]
[System.Obsolete("`DataGrid` is provided for binary compatibility with .NET Framework and is not intended to be used directly from your code. Use `DataGridView` instead.", false, DiagnosticId="WFDEV006", UrlFormat="https://aka.ms/winforms-warnings/{0}")]
public class DataGridBoolColumn : System.Windows.Forms.DataGridColumnStyle

[<System.ComponentModel.Browsable(false)>]
[<System.Obsolete("`DataGrid` is provided for binary compatibility with .NET Framework and is not intended to be used directly from your code. Use `DataGridView` instead.", false, DiagnosticId="WFDEV006", UrlFormat="https://aka.ms/winforms-warnings/{0}")>]
type DataGridBoolColumn = class
    inherit DataGridColumnStyle

Public Class DataGridBoolColumn
Inherits DataGridColumnStyle

Öröklődés

Object

MarshalByRefObject

Component

DataGridColumnStyle

DataGridBoolColumn

Attribútumok

BrowsableAttribute ObsoleteAttribute

Példák

Az alábbi példakód először létrehoz egy újatDataGridBoolColumn, és hozzáadja egy GridColumnStylesCollection .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

Megjegyzések

Az DataGridBoolColumn osztályból abstractDataGridColumnStyleszármazik. Futásidőben a DataGridBoolColumn jelölőnégyzetek minden olyan cellában szerepelnek, amelyek alapértelmezés szerint három állapottal rendelkeznek: bejelölve (true), bejelöletlenül (false) és Value. Kétállapotú jelölőnégyzetek használatához állítsa a tulajdonságot a AllowNull következőre false: .

Az osztályhoz hozzáadott tulajdonságok közé tartoznak a következők FalseValue: , NullValueés TrueValue. Ezek a tulajdonságok határozzák meg az oszlop egyes állapotainak alapjául szolgáló értéket.

Konstruktorok

Name	Description
DataGridBoolColumn()	Elavult. Inicializálja a DataGridBoolColumn osztály új példányát.
DataGridBoolColumn(PropertyDescriptor, Boolean)	Elavult. Inicializálja az DataGridBoolColumn osztály új példányát a megadottval PropertyDescriptor, és megadja, hogy az oszlopstílus alapértelmezett oszlop-e.
DataGridBoolColumn(PropertyDescriptor)	Elavult. Inicializálja az osztály új példányát DataGridBoolColumn a megadott PropertyDescriptor.

Tulajdonságok

Name	Description
Alignment	Elavult. Lekéri vagy beállítja a szöveg igazítását egy oszlopban. (Öröklődés forrása DataGridColumnStyle)
AllowNull	Elavult. Lekéri vagy beállít egy értéket, amely jelzi, hogy a null értékek engedélyezettek-e.
DataGridTableStyle	Elavult. Lekéri az DataGridTableStyle oszlopot. (Öröklődés forrása DataGridColumnStyle)
FalseValue	Elavult. Lekéri vagy beállítja az oszlop falseértékének beállításakor használt tényleges értéket.
FontHeight	Elavult. Lekéri az oszlop betűtípusának magasságát. (Öröklődés forrása DataGridColumnStyle)
HeaderAccessibleObject	Elavult. Lekéri az AccessibleObject oszlopot. (Öröklődés forrása DataGridColumnStyle)
HeaderText	Elavult. Lekéri vagy beállítja az oszlopfejléc szövegét. (Öröklődés forrása DataGridColumnStyle)
MappingName	Elavult. Lekéri vagy beállítja az adattag nevét az oszlopstílus leképezéséhez. (Öröklődés forrása DataGridColumnStyle)
NullText	Elavult. Lekéri vagy beállítja az oszlop tartalmakor nullmegjelenő szöveget. (Öröklődés forrása DataGridColumnStyle)
NullValue	Elavult. Lekéri vagy beállítja az oszlop Valueértékének beállításakor használt tényleges értéket.
PropertyDescriptor	Elavult. Lekéri vagy beállítja a /> által megjelenített adatok attribútumait meghatározó adatokat. (Öröklődés forrása DataGridColumnStyle)
ReadOnly	Elavult. Lekéri vagy beállít egy értéket, amely jelzi, hogy az oszlopban lévő adatok szerkeszthetők-e. (Öröklődés forrása DataGridColumnStyle)
TrueValue	Elavult. Lekéri vagy beállítja az oszlop trueértékének beállításakor használt tényleges értéket.
Width	Elavult. Lekéri vagy beállítja az oszlop szélességét. (Öröklődés forrása DataGridColumnStyle)

Metódusok

Name	Description
Abort(Int32)	Elavult. Egy szerkesztési eljárás megszakítására irányuló kérést kezdeményez.
BeginUpdate()	Elavult. Felfüggeszti az oszlop festését a metódus meghívásáig EndUpdate() . (Öröklődés forrása DataGridColumnStyle)
CheckValidDataSource(CurrencyManager)	Elavult. Kivételt okoz, ha az DataGrid adatforrás nem rendelkezik érvényes adatforrással, vagy ha ez az oszlop nincs megfeleltetve az adatforrás érvényes tulajdonságának. (Öröklődés forrása DataGridColumnStyle)
ColumnStartedEditing(Control)	Elavult. Tájékoztatja a DataGrid felhasználót, hogy megkezdte az oszlop szerkesztését. (Öröklődés forrása DataGridColumnStyle)
Commit(CurrencyManager, Int32)	Elavult. Szerkesztési eljárás befejezésére irányuló kérést kezdeményez.
ConcedeFocus()	Elavult. Értesíti az oszlopot, hogy vissza kell adnia a fókuszt az általa üzemeltetett vezérlőre. (Öröklődés forrása DataGridColumnStyle)
CreateHeaderAccessibleObject()	Elavult. Lekéri az AccessibleObject oszlopot. (Öröklődés forrása DataGridColumnStyle)
Edit(CurrencyManager, Int32, Rectangle, Boolean, String, Boolean)	Elavult. Előkészíti a cellát egy érték szerkesztésére.
Edit(CurrencyManager, Int32, Rectangle, Boolean, String)	Elavult. Előkészíti a cellát szerkesztésre a megadott CurrencyManager, sorszám és Rectangle paraméterek használatával. (Öröklődés forrása DataGridColumnStyle)
Edit(CurrencyManager, Int32, Rectangle, Boolean)	Elavult. Előkészít egy cellát szerkesztésre. (Öröklődés forrása DataGridColumnStyle)
EndUpdate()	Elavult. A metódus meghívásával folytatja a felfüggesztett oszlopok festését BeginUpdate() . (Öröklődés forrása DataGridColumnStyle)
EnterNullValue()	Elavult. Beír egy Value értéket az oszlopba. (Öröklődés forrása DataGridColumnStyle)
GetColumnValueAtRow(CurrencyManager, Int32)	Elavult. Lekéri a megadott sor értékét a megadott CurrencyManagersorból. (Öröklődés forrása DataGridColumnStyle)
GetMinimumHeight()	Elavult. Egy oszlopban lévő cella magasságát kapja meg.
GetPreferredHeight(Graphics, Object)	Elavult. Lekéri az oszlopok átméretezésekor használt magasságot.
GetPreferredSize(Graphics, Object)	Elavult. A cella optimális szélességét és magasságát adja meg egy adott érték alapján.
Invalidate()	Elavult. Újrarajzozza az oszlopot, és festéküzenetet küld a vezérlőnek. (Öröklődés forrása DataGridColumnStyle)
Paint(Graphics, Rectangle, CurrencyManager, Int32, Boolean)	Elavult. DataGridBoolColumn A megadott Graphics, sorszám Rectangleés igazítási beállításokkal rajzolja meg a elemet.
Paint(Graphics, Rectangle, CurrencyManager, Int32, Brush, Brush, Boolean)	Elavult. DataGridColumnStyle A megadott Graphics, , RectanglesorszámCurrencyManager, háttérszín, előtérszín és igazítás használatával fest. (Öröklődés forrása DataGridColumnStyle)
Paint(Graphics, Rectangle, CurrencyManager, Int32)	Elavult. DataGridBoolColumn A megadott Graphicsszámmal Rectangle és sorszámmal rajzolja meg a elemet.
ReleaseHostedControl()	Elavult. Lehetővé teszi, hogy az oszlop felszabadítsa az erőforrásokat, ha nincs szükség az általa üzemeltetett vezérlőre. (Öröklődés forrása DataGridColumnStyle)
ResetHeaderText()	Elavult. Alaphelyzetbe állítja az HeaderText alapértelmezett értéket. null (Öröklődés forrása DataGridColumnStyle)
SetColumnValueAtRow(CurrencyManager, Int32, Object)	Elavult. Egy megadott sor értékét egy megadott CurrencyManagersor értékével állítja be. (Öröklődés forrása DataGridColumnStyle)
SetDataGrid(DataGrid)	Elavult. Beállítja azt a DataGrid vezérlőelemet, amelyhez ez az oszlop tartozik. (Öröklődés forrása DataGridColumnStyle)
SetDataGridInColumn(DataGrid)	Elavult. Beállítja az DataGrid oszlopot. (Öröklődés forrása DataGridColumnStyle)
UpdateUI(CurrencyManager, Int32, String)	Elavult. Frissíti egy adott sor értékét a megadott szöveggel. (Öröklődés forrása DataGridColumnStyle)

esemény

Name	Description
AlignmentChanged	Elavult. Akkor fordul elő, ha a Alignment tulajdonság értéke megváltozik. (Öröklődés forrása DataGridColumnStyle)
AllowNullChanged	Elavult. A tulajdonság módosításakor AllowNull következik be.
FalseValueChanged	Elavult. A tulajdonság módosításakor FalseValue következik be.
FontChanged	Elavult. Akkor fordul elő, ha az oszlop betűtípusa megváltozik. (Öröklődés forrása DataGridColumnStyle)
HeaderTextChanged	Elavult. Akkor fordul elő, ha a HeaderText tulajdonság értéke megváltozik. (Öröklődés forrása DataGridColumnStyle)
MappingNameChanged	Elavult. Akkor fordul elő, ha az MappingName érték megváltozik. (Öröklődés forrása DataGridColumnStyle)
NullTextChanged	Elavult. Akkor fordul elő, ha az NullText érték megváltozik. (Öröklődés forrása DataGridColumnStyle)
PropertyDescriptorChanged	Elavult. Akkor fordul elő, ha a PropertyDescriptor tulajdonság értéke megváltozik. (Öröklődés forrása DataGridColumnStyle)
ReadOnlyChanged	Elavult. Akkor fordul elő, ha a ReadOnly tulajdonság értéke megváltozik. (Öröklődés forrása DataGridColumnStyle)
TrueValueChanged	Elavult. A tulajdonságérték módosításakor TrueValue következik be.
WidthChanged	Elavult. Akkor fordul elő, ha a Width tulajdonság értéke megváltozik. (Öröklődés forrása DataGridColumnStyle)

Explicit interfész-implementációk

Name	Description
IDataGridColumnStyleEditingNotificationService.ColumnStartedEditing(Control)	Elavult. Tájékoztatja a vezérlőt DataGrid , hogy a felhasználó megkezdte az oszlop szerkesztését. (Öröklődés forrása DataGridColumnStyle)

Lásd még

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