虚拟模式是必要的,只有当你需要补充或更换绑定模式。 在绑定模式下,设置 数据源产权和控制自动加载数据从指定源和提交用户更改回去。 您可以控制显示哪些列绑定的,和数据源本身通常处理操作,如排序。

可以补充绑定模式通过显示的列的列。 这是有时被称为“混合模式”,是用于显示诸如计算值或用户界面(UI)控件。

因为未绑定列外的数据源,他们忽视了数据源的排序操作。 因此,当你在混合模式启用排序,您必须在本地缓存管理的数据和实现让虚拟模式DataGridView控制与之交互。

关于使用虚拟模式的更多信息维护未绑定列中的值,看到的例子 DataGridViewCheckBoxColumn 。 ThreeState财产和System.Windows.Forms 。 DataGridViewComboBoxColumn类引用主题。

如果绑定模式不能满足您的性能需求,您可以通过虚拟方式管理你所有的数据在一个自定义缓存事件处理程序。 例如,您可以使用虚拟模式来实现即时数据加载机制,从网络数据库检索只有尽可能多的数据作为最优性能是必要的。 这个场景是特别有用的在处理大量数据时在一个缓慢的网络连接或与客户端机器的数量有限的内存或者存储空间。

关于使用虚拟模式的更多信息在实时的情况下,看到的 实现虚拟模式的即时数据加载Windows窗体DataGridView控件。

如果您的数据是只读的, CellValueNeeded 事件可能是唯一事件需要处理。 额外的虚拟方式事件让你使特定功能用户编辑、添加和删除行,行级的事务。

一些标准 DataGridView事件(如当用户添加或删除行发生的事件,或当细胞值编辑,解析,验证,或格式化的)是有用的在虚拟模式,。 你也可以处理事件,让你保持值不是通常存储在一个绑定数据源,如细胞提示文本,细胞和行错误文本,细胞和行快捷菜单数据,和行高数据。

为更多的信息关于实现虚拟模式管理读/写数据行级提交范围,明白了 介绍:在Windows窗体DataGridView控件中实现虚拟模式。

为例,实现了虚拟模式具有承诺范围,看到 virtualmode属性引用主题。

只有当发生以下事件 virtualmode属性设置为 真正的 。

以下事件是有用的在虚拟模式,但可以不管 virtualmode属性设置。

如果你是实现虚拟模式,以有效地处理大量的数据,你也想确保高效的工作 DataGridView控制自己。 更多信息的有效利用细胞风格,自动分级,选择,和行共享,明白了 最佳实践扩展Windows窗体DataGridView控件。

实现虚拟模式

using System;

using System.Windows.Forms;

public class Form1 : Form

{

    private DataGridView dataGridView1 = new DataGridView();

    // Declare an ArrayList to serve as the data store.

    private System.Collections.ArrayList customers =

        new System.Collections.ArrayList();

    // Declare a Customer object to store data for a row being edited.

    private Customer customerInEdit;

    // Declare a variable to store the index of a row being edited.

    // A value of -1 indicates that there is no row currently in edit.

    private int rowInEdit = -;

    // Declare a variable to indicate the commit scope.

    // Set this value to false to use cell-level commit scope.

    private bool rowScopeCommit = true;

    [STAThreadAttribute()]

    public static void Main()

    {

        Application.Run(new Form1());

    }

    public Form1()

    {

        // Initialize the form.

        this.dataGridView1.Dock = DockStyle.Fill;

        this.Controls.Add(this.dataGridView1);

        this.Load += new EventHandler(Form1_Load);

        this.Text = "DataGridView virtual-mode demo (row-level commit scope)";

    }

...

}

private void Form1_Load(object sender, EventArgs e)

{

    // Enable virtual mode.

    this.dataGridView1.VirtualMode = true;

    // Connect the virtual-mode events to event handlers.

    this.dataGridView1.CellValueNeeded += new

        DataGridViewCellValueEventHandler(dataGridView1_CellValueNeeded);

    this.dataGridView1.CellValuePushed += new

        DataGridViewCellValueEventHandler(dataGridView1_CellValuePushed);

    this.dataGridView1.NewRowNeeded += new

        DataGridViewRowEventHandler(dataGridView1_NewRowNeeded);

    this.dataGridView1.RowValidated += new

        DataGridViewCellEventHandler(dataGridView1_RowValidated);

    this.dataGridView1.RowDirtyStateNeeded += new

        QuestionEventHandler(dataGridView1_RowDirtyStateNeeded);

    this.dataGridView1.CancelRowEdit += new

        QuestionEventHandler(dataGridView1_CancelRowEdit);

    this.dataGridView1.UserDeletingRow += new

        DataGridViewRowCancelEventHandler(dataGridView1_UserDeletingRow);

    // Add columns to the DataGridView.

    DataGridViewTextBoxColumn companyNameColumn = new

        DataGridViewTextBoxColumn();

    companyNameColumn.HeaderText = "Company Name";

    companyNameColumn.Name = "Company Name";

    DataGridViewTextBoxColumn contactNameColumn = new

        DataGridViewTextBoxColumn();

    contactNameColumn.HeaderText = "Contact Name";

    contactNameColumn.Name = "Contact Name";

    this.dataGridView1.Columns.Add(companyNameColumn);

    this.dataGridView1.Columns.Add(contactNameColumn);

    this.dataGridView1.AutoSizeColumnsMode =

        DataGridViewAutoSizeColumnsMode.AllCells;

    // Add some sample entries to the data store.

    this.customers.Add(new Customer(

        "Bon app'", "Laurence Lebihan"));

    this.customers.Add(new Customer(

        "Bottom-Dollar Markets", "Elizabeth Lincoln"));

    this.customers.Add(new Customer(

        "B's Beverages", "Victoria Ashworth"));

    // Set the row count, including the row for new records.

    this.dataGridView1.RowCount = ;

}

private void dataGridView1_CellValueNeeded(object sender,

    System.Windows.Forms.DataGridViewCellValueEventArgs e)

{

    // If this is the row for new records, no values are needed.

    if (e.RowIndex == this.dataGridView1.RowCount - ) return;

    Customer customerTmp = null;

    // Store a reference to the Customer object for the row being painted.

    if (e.RowIndex == rowInEdit)

    {

        customerTmp = this.customerInEdit;

    }

    else

    {

        customerTmp = (Customer)this.customers[e.RowIndex];

    }

    // Set the cell value to paint using the Customer object retrieved.

    switch (this.dataGridView1.Columns[e.ColumnIndex].Name)

    {

        case "Company Name":

            e.Value = customerTmp.CompanyName;

            break;

        case "Contact Name":

            e.Value = customerTmp.ContactName;

            break;

    }

}

private void dataGridView1_CellValuePushed(object sender,

    System.Windows.Forms.DataGridViewCellValueEventArgs e)

{

    Customer customerTmp = null;

    // Store a reference to the Customer object for the row being edited.

    if (e.RowIndex < this.customers.Count)

    {

        // If the user is editing a new row, create a new Customer object.

        if (this.customerInEdit == null)

        {

            this.customerInEdit = new Customer(

                ((Customer)this.customers[e.RowIndex]).CompanyName,

                ((Customer)this.customers[e.RowIndex]).ContactName);

        }

        customerTmp = this.customerInEdit;

        this.rowInEdit = e.RowIndex;

    }

    else

    {

        customerTmp = this.customerInEdit;

    }

    // Set the appropriate Customer property to the cell value entered.

    String newValue = e.Value as String;

    switch (this.dataGridView1.Columns[e.ColumnIndex].Name)

    {

        case "Company Name":

            customerTmp.CompanyName = newValue;

            break;

        case "Contact Name":

            customerTmp.ContactName = newValue;

            break;

    }

}

private void dataGridView1_NewRowNeeded(object sender,

    System.Windows.Forms.DataGridViewRowEventArgs e)

{

    // Create a new Customer object when the user edits

    // the row for new records.

    this.customerInEdit = new Customer();

    this.rowInEdit = this.dataGridView1.Rows.Count - ;

}

private void dataGridView1_RowValidated(object sender,

    System.Windows.Forms.DataGridViewCellEventArgs e)

{

    // Save row changes if any were made and release the edited

    // Customer object if there is one.

    if (e.RowIndex >= this.customers.Count &&

        e.RowIndex != this.dataGridView1.Rows.Count - )

    {

        // Add the new Customer object to the data store.

        this.customers.Add(this.customerInEdit);

        this.customerInEdit = null;

        this.rowInEdit = -;

    }

    else if (this.customerInEdit != null &&

        e.RowIndex < this.customers.Count)

    {

        // Save the modified Customer object in the data store.

        this.customers[e.RowIndex] = this.customerInEdit;

        this.customerInEdit = null;

        this.rowInEdit = -;

    }

    else if (this.dataGridView1.ContainsFocus)

    {

        this.customerInEdit = null;

        this.rowInEdit = -;

    }

}

private void dataGridView1_RowDirtyStateNeeded(object sender,

    System.Windows.Forms.QuestionEventArgs e)

{

    if (!rowScopeCommit)

    {

        // In cell-level commit scope, indicate whether the value

        // of the current cell has been modified.

        e.Response = this.dataGridView1.IsCurrentCellDirty;

    }

}

private void dataGridView1_CancelRowEdit(object sender,

    System.Windows.Forms.QuestionEventArgs e)

{

    if (this.rowInEdit == this.dataGridView1.Rows.Count -  &&

        this.rowInEdit == this.customers.Count)

    {

        // If the user has canceled the edit of a newly created row,

        // replace the corresponding Customer object with a new, empty one.

        this.customerInEdit = new Customer();

    }

    else

    {

        // If the user has canceled the edit of an existing row,

        // release the corresponding Customer object.

        this.customerInEdit = null;

        this.rowInEdit = -;

    }

}

private void dataGridView1_UserDeletingRow(object sender,

    System.Windows.Forms.DataGridViewRowCancelEventArgs e)

{

    if (e.Row.Index < this.customers.Count)

    {

        // If the user has deleted an existing row, remove the

        // corresponding Customer object from the data store.

        this.customers.RemoveAt(e.Row.Index);

    }

    if (e.Row.Index == this.rowInEdit)

    {

        // If the user has deleted a newly created row, release

        // the corresponding Customer object.

        this.rowInEdit = -;

        this.customerInEdit = null;

    }

}

public class Customer

{

    private String companyNameValue;

    private String contactNameValue;

    public Customer()

    {

        // Leave fields empty.

    }

    public Customer(String companyName, String contactName)

    {

        companyNameValue = companyName;

        contactNameValue = contactName;

    }

    public String CompanyName

    {

        get

        {

            return companyNameValue;

        }

        set

        {

            companyNameValue = value;

        }

    }

    public String ContactName

    {

        get

        {

            return contactNameValue;

        }

        set

        {

            contactNameValue = value;

        }

    }

}

 using System;

 using System.Data;

 using System.Data.SqlClient;

 using System.Drawing;

 using System.Windows.Forms;

 public class VirtualJustInTimeDemo : System.Windows.Forms.Form

 {

     private DataGridView dataGridView1 = new DataGridView();

     private Cache memoryCache;

     // Specify a connection string. Replace the given value with a

     // valid connection string for a Northwind SQL Server sample

     // database accessible to your system.

     private string connectionString =

         "Initial Catalog=NorthWind;Data Source=localhost;" +

         "Integrated Security=SSPI;Persist Security Info=False";

     private string table = "Orders";

     protected override void OnLoad(EventArgs e)

     {

         // Initialize the form.

         this.AutoSize = true;

         this.Controls.Add(this.dataGridView1);

         this.Text = "DataGridView virtual-mode just-in-time demo";

         // Complete the initialization of the DataGridView.

         this.dataGridView1.Size = new Size(, );

         this.dataGridView1.Dock = DockStyle.Fill;

         this.dataGridView1.VirtualMode = true;

         this.dataGridView1.ReadOnly = true;

         this.dataGridView1.AllowUserToAddRows = false;

         this.dataGridView1.AllowUserToOrderColumns = false;

         this.dataGridView1.SelectionMode =

             DataGridViewSelectionMode.FullRowSelect;

         this.dataGridView1.CellValueNeeded += new

             DataGridViewCellValueEventHandler(dataGridView1_CellValueNeeded);

         // Create a DataRetriever and use it to create a Cache object

         // and to initialize the DataGridView columns and rows.

         try

         {

             DataRetriever retriever =

                 new DataRetriever(connectionString, table);

             memoryCache = new Cache(retriever, );

             foreach (DataColumn column in retriever.Columns)

             {

                 dataGridView1.Columns.Add(

                     column.ColumnName, column.ColumnName);

             }

             this.dataGridView1.RowCount = retriever.RowCount;

         }

         catch (SqlException)

         {

             MessageBox.Show("Connection could not be established. " +

                 "Verify that the connection string is valid.");

             Application.Exit();

         }

         // Adjust the column widths based on the displayed values.

         this.dataGridView1.AutoResizeColumns(

             DataGridViewAutoSizeColumnsMode.DisplayedCells);

         base.OnLoad(e);

     }

     private void dataGridView1_CellValueNeeded(object sender,

         DataGridViewCellValueEventArgs e)

     {

         e.Value = memoryCache.RetrieveElement(e.RowIndex, e.ColumnIndex);

     }

     [STAThreadAttribute()]

     public static void Main()

     {

         Application.Run(new VirtualJustInTimeDemo());

     }

 }

 public interface IDataPageRetriever

 {

     DataTable SupplyPageOfData(int lowerPageBoundary, int rowsPerPage);

 }

 public class DataRetriever : IDataPageRetriever

 {

     private string tableName;

     private SqlCommand command;

     public DataRetriever(string connectionString, string tableName)

     {

         SqlConnection connection = new SqlConnection(connectionString);

         connection.Open();

         command = connection.CreateCommand();

         this.tableName = tableName;

     }

     private int rowCountValue = -;

     public int RowCount

     {

         get

         {

             // Return the existing value if it has already been determined.

             if (rowCountValue != -)

             {

                 return rowCountValue;

             }

             // Retrieve the row count from the database.

             command.CommandText = "SELECT COUNT(*) FROM " + tableName;

             rowCountValue = (int)command.ExecuteScalar();

             return rowCountValue;

         }

     }

     private DataColumnCollection columnsValue;

     public DataColumnCollection Columns

     {

         get

         {

             // Return the existing value if it has already been determined.

             if (columnsValue != null)

             {

                 return columnsValue;

             }

             // Retrieve the column information from the database.

             command.CommandText = "SELECT * FROM " + tableName;

             SqlDataAdapter adapter = new SqlDataAdapter();

             adapter.SelectCommand = command;

             DataTable table = new DataTable();

             table.Locale = System.Globalization.CultureInfo.InvariantCulture;

             adapter.FillSchema(table, SchemaType.Source);

             columnsValue = table.Columns;

             return columnsValue;

         }

     }

     private string commaSeparatedListOfColumnNamesValue = null;

     private string CommaSeparatedListOfColumnNames

     {

         get

         {

             // Return the existing value if it has already been determined.

             if (commaSeparatedListOfColumnNamesValue != null)

             {

                 return commaSeparatedListOfColumnNamesValue;

             }

             // Store a list of column names for use in the

             // SupplyPageOfData method.

             System.Text.StringBuilder commaSeparatedColumnNames =

                 new System.Text.StringBuilder();

             bool firstColumn = true;

             foreach (DataColumn column in Columns)

             {

                 if (!firstColumn)

                 {

                     commaSeparatedColumnNames.Append(", ");

                 }

                 commaSeparatedColumnNames.Append(column.ColumnName);

                 firstColumn = false;

             }

             commaSeparatedListOfColumnNamesValue =

                 commaSeparatedColumnNames.ToString();

             return commaSeparatedListOfColumnNamesValue;

         }

     }

     // Declare variables to be reused by the SupplyPageOfData method.

     private string columnToSortBy;

     private SqlDataAdapter adapter = new SqlDataAdapter();

     public DataTable SupplyPageOfData(int lowerPageBoundary, int rowsPerPage)

     {

         // Store the name of the ID column. This column must contain unique

         // values so the SQL below will work properly.

         if (columnToSortBy == null)

         {

             columnToSortBy = this.Columns[].ColumnName;

         }

         if (!this.Columns[columnToSortBy].Unique)

         {

             throw new InvalidOperationException(String.Format(

                 "Column {0} must contain unique values.", columnToSortBy));

         }

         // Retrieve the specified number of rows from the database, starting

         // with the row specified by the lowerPageBoundary parameter.

         command.CommandText = "Select Top " + rowsPerPage + " " +

             CommaSeparatedListOfColumnNames + " From " + tableName +

             " WHERE " + columnToSortBy + " NOT IN (SELECT TOP " +

             lowerPageBoundary + " " + columnToSortBy + " From " +

             tableName + " Order By " + columnToSortBy +

             ") Order By " + columnToSortBy;

         adapter.SelectCommand = command;

         DataTable table = new DataTable();

         table.Locale = System.Globalization.CultureInfo.InvariantCulture;

         adapter.Fill(table);

         return table;

     }

 }

 public class Cache

 {

     private static int RowsPerPage;

     // Represents one page of data.

     public struct DataPage

     {

         public DataTable table;

         private int lowestIndexValue;

         private int highestIndexValue;

         public DataPage(DataTable table, int rowIndex)

         {

             this.table = table;

             lowestIndexValue = MapToLowerBoundary(rowIndex);

             highestIndexValue = MapToUpperBoundary(rowIndex);

             System.Diagnostics.Debug.Assert(lowestIndexValue >= );

             System.Diagnostics.Debug.Assert(highestIndexValue >= );

         }

         public int LowestIndex

         {

             get

             {

                 return lowestIndexValue;

             }

         }

         public int HighestIndex

         {

             get

             {

                 return highestIndexValue;

             }

         }

         public static int MapToLowerBoundary(int rowIndex)

         {

             // Return the lowest index of a page containing the given index.

             return (rowIndex / RowsPerPage) * RowsPerPage;

         }

         private static int MapToUpperBoundary(int rowIndex)

         {

             // Return the highest index of a page containing the given index.

             return MapToLowerBoundary(rowIndex) + RowsPerPage - ;

         }

     }

     private DataPage[] cachePages;

     private IDataPageRetriever dataSupply;

     public Cache(IDataPageRetriever dataSupplier, int rowsPerPage)

     {

         dataSupply = dataSupplier;

         Cache.RowsPerPage = rowsPerPage;

         LoadFirstTwoPages();

     }

     // Sets the value of the element parameter if the value is in the cache.

     private bool IfPageCached_ThenSetElement(int rowIndex,

         int columnIndex, ref string element)

     {

         if (IsRowCachedInPage(, rowIndex))

         {

             element = cachePages[].table

                 .Rows[rowIndex % RowsPerPage][columnIndex].ToString();

             return true;

         }

         else if (IsRowCachedInPage(, rowIndex))

         {

             element = cachePages[].table

                 .Rows[rowIndex % RowsPerPage][columnIndex].ToString();

             return true;

         }

         return false;

     }

     public string RetrieveElement(int rowIndex, int columnIndex)

     {

         string element = null;

         if (IfPageCached_ThenSetElement(rowIndex, columnIndex, ref element))

         {

             return element;

         }

         else

         {

             return RetrieveData_CacheIt_ThenReturnElement(

                 rowIndex, columnIndex);

         }

     }

     private void LoadFirstTwoPages()

     {

         cachePages = new DataPage[]{

             new DataPage(dataSupply.SupplyPageOfData(

                 DataPage.MapToLowerBoundary(), RowsPerPage), ),

             new DataPage(dataSupply.SupplyPageOfData(

                 DataPage.MapToLowerBoundary(RowsPerPage),

                 RowsPerPage), RowsPerPage)};

     }

     private string RetrieveData_CacheIt_ThenReturnElement(

         int rowIndex, int columnIndex)

     {

         // Retrieve a page worth of data containing the requested value.

         DataTable table = dataSupply.SupplyPageOfData(

             DataPage.MapToLowerBoundary(rowIndex), RowsPerPage);

         // Replace the cached page furthest from the requested cell

         // with a new page containing the newly retrieved data.

         cachePages[GetIndexToUnusedPage(rowIndex)] = new DataPage(table, rowIndex);

         return RetrieveElement(rowIndex, columnIndex);

     }

     // Returns the index of the cached page most distant from the given index

     // and therefore least likely to be reused.

     private int GetIndexToUnusedPage(int rowIndex)

     {

         if (rowIndex > cachePages[].HighestIndex &&

             rowIndex > cachePages[].HighestIndex)

         {

             int offsetFromPage0 = rowIndex - cachePages[].HighestIndex;

             int offsetFromPage1 = rowIndex - cachePages[].HighestIndex;

             if (offsetFromPage0 < offsetFromPage1)

             {

                 return ;

             }

             return ;

         }

         else

         {

             int offsetFromPage0 = cachePages[].LowestIndex - rowIndex;

             int offsetFromPage1 = cachePages[].LowestIndex - rowIndex;

             if (offsetFromPage0 < offsetFromPage1)

             {

                 return ;

             }

             return ;

         }

     }

     // Returns a value indicating whether the given row index is contained

     // in the given DataPage.

     private bool IsRowCachedInPage(int pageNumber, int rowIndex)

     {

         return rowIndex <= cachePages[pageNumber].HighestIndex &&

             rowIndex >= cachePages[pageNumber].LowestIndex;

     }

 }