ListView.VirtualMode Propriedade

Definição

Obtém ou define um valor que indica se você forneceu suas próprias operações de gerenciamento de dados para o controle ListView .

public bool VirtualMode { get; set; }

Valor da propriedade

true se ListView usar operações de gerenciamento de dados fornecidos; caso contrário, false. O padrão é false.

Exceções

VirtualMode é definido como true e uma das seguintes condições existe:

Exemplos

Este exemplo ilustra um simples ListView cujo conteúdo são os primeiros dez mil quadrados. Ele manipula a pesquisa e usa um cache para aumentar o desempenho.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Text;
using System.Windows.Forms;

public class Form1 : Form
{
    private ListViewItem[] myCache; //array to cache items for the virtual list
    private int firstItem; //stores the index of the first item in the cache

    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }

    public Form1()
    {
        //Create a simple ListView.
        ListView listView1 = new ListView();
        listView1.View = View.SmallIcon;
        listView1.VirtualMode = true;
        listView1.VirtualListSize = 10000;

        //Hook up handlers for VirtualMode events.
        listView1.RetrieveVirtualItem += new RetrieveVirtualItemEventHandler(listView1_RetrieveVirtualItem);
        listView1.CacheVirtualItems += new CacheVirtualItemsEventHandler(listView1_CacheVirtualItems);
        listView1.SearchForVirtualItem += new SearchForVirtualItemEventHandler(listView1_SearchForVirtualItem);

        //Add ListView to the form.
        this.Controls.Add(listView1);

        //Search for a particular virtual item.
        //Notice that we never manually populate the collection!
        //If you leave out the SearchForVirtualItem handler, this will return null.
        ListViewItem lvi = listView1.FindItemWithText("111111");

        //Select the item found and scroll it into view.
        if (lvi != null)
        {
            listView1.SelectedIndices.Add(lvi.Index);
            listView1.EnsureVisible(lvi.Index);
        }
    }

    //The basic VirtualMode function.  Dynamically returns a ListViewItem
    //with the required properties; in this case, the square of the index.
    void listView1_RetrieveVirtualItem(object sender, RetrieveVirtualItemEventArgs e)
    {
        //Caching is not required but improves performance on large sets.
        //To leave out caching, don't connect the CacheVirtualItems event 
        //and make sure myCache is null.

        //check to see if the requested item is currently in the cache
        if (myCache != null && e.ItemIndex >= firstItem && e.ItemIndex < firstItem + myCache.Length)
        {
            //A cache hit, so get the ListViewItem from the cache instead of making a new one.
            e.Item = myCache[e.ItemIndex - firstItem];
        }
        else
        {
            //A cache miss, so create a new ListViewItem and pass it back.
            int x = e.ItemIndex * e.ItemIndex;
            e.Item = new ListViewItem(x.ToString());
        }
    }

    //Manages the cache.  ListView calls this when it might need a 
    //cache refresh.
    void listView1_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
    {
        //We've gotten a request to refresh the cache.
        //First check if it's really neccesary.
        if (myCache != null && e.StartIndex >= firstItem && e.EndIndex <= firstItem + myCache.Length)
        {
            //If the newly requested cache is a subset of the old cache, 
            //no need to rebuild everything, so do nothing.
            return;
        }

        //Now we need to rebuild the cache.
        firstItem = e.StartIndex;
        int length = e.EndIndex - e.StartIndex + 1; //indexes are inclusive
        myCache = new ListViewItem[length];
        
        //Fill the cache with the appropriate ListViewItems.
        int x = 0;
        for (int i = 0; i < length; i++)
        {
            x = (i + firstItem) * (i + firstItem);
            myCache[i] = new ListViewItem(x.ToString());
        }
    }

    //This event handler enables search functionality, and is called
    //for every search request when in Virtual mode.
    void listView1_SearchForVirtualItem(object sender, SearchForVirtualItemEventArgs e)
    {
        //We've gotten a search request.
        //In this example, finding the item is easy since it's
        //just the square of its index.  We'll take the square root
        //and round.
        double x = 0;
        if (Double.TryParse(e.Text, out x)) //check if this is a valid search
        {
            x = Math.Sqrt(x);
            x = Math.Round(x);
            e.Index = (int)x;
        }
        //If e.Index is not set, the search returns null.
        //Note that this only handles simple searches over the entire
        //list, ignoring any other settings.  Handling Direction, StartIndex,
        //and the other properties of SearchForVirtualItemEventArgs is up
        //to this handler.
    }
}

Comentários

Definir a VirtualMode propriedade como true coloca o ListView no modo virtual. No modo Virtual, a coleção normal Items não é utilizado. Em vez disso, ListViewItem os objetos são criados dinamicamente, pois o ListView os requer.

O modo virtual pode ser útil em muitas circunstâncias. Se um ListView objeto precisar ser preenchido de uma coleção muito grande já na memória, a criação de um ListViewItem objeto para cada entrada poderá ser um desperdício. No modo virtual, somente os itens necessários são criados. Em outros casos, os valores dos ListViewItem objetos podem precisar ser recalculados com frequência e fazer isso para toda a coleção produziria um desempenho inaceitável. No modo virtual, somente os itens necessários são calculados.

Para usar o modo virtual, você deve manipular o RetrieveVirtualItem evento , que é gerado sempre que o ListView requer um item. Esse manipulador de eventos deve criar o ListViewItem objeto que pertence ao índice especificado. Além disso, a VirtualListSize propriedade deve ser definida como o tamanho da lista virtual.

A manipulação do SearchForVirtualItem evento permite a pesquisa no modo virtual. Se esse evento não for tratado, os FindItemWithText métodos e FindNearestItem retornarão null.

Você pode manipular o CacheVirtualItems evento para manter um cache de ListViewItem objetos. Se o cálculo ou a pesquisa para criar um ListViewItem objeto for caro, manter um cache poderá melhorar o desempenho.

Se a View propriedade for definida Tilecomo , o valor será alterado automaticamente para LargeIcon quando VirtualMode for definido truecomo .

No modo virtual, a Items coleção está desabilitada. Tentar acessá-lo resulta em um InvalidOperationException. O mesmo se aplica à CheckedItems coleção e à SelectedItems coleção. Se você quiser recuperar os itens selecionados ou marcados, use as SelectedIndices coleções e CheckedIndices .

Aplica-se a

Produto Versões
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
Windows Desktop 3.0, 3.1, 5, 6, 7, 8, 9