Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

ListView.VirtualMode propriété

 

Date de publication : novembre 2016

Obtient ou définit une valeur indiquant si vous avez fourni vos propres opérations de gestion de données pour le contrôle ListView.

Espace de noms:   System.Windows.Forms
Assembly:  System.Windows.Forms (dans System.Windows.Forms.dll)

public bool VirtualMode { get; set; }

Valeur de propriété

Type: System.Boolean

true Si ListView utilise des opérations de gestion de données que vous fournissez ; sinon, false. La valeur par défaut est false.

Exception Condition
InvalidOperationException

VirtualMode a la valeur true et l’une des conditions suivantes existe :

Définition de la VirtualMode propriété true place le ListView en mode virtuel. En mode virtuel, la normale Items collection n’est pas utilisée. Au lieu de cela, ListViewItem objets sont créés dynamiquement dès que la ListView a besoin.

Mode virtuel peut être utile dans de nombreuses situations. Si un ListView objet doit être rempli à partir d’une très grande collection déjà en mémoire, créer un ListViewItem de l’objet pour chaque entrée peut être inutile. En mode virtuel, seuls les éléments requis sont créés. Dans d’autres cas, les valeurs de la ListViewItem objets peuvent doivent être recalculées fréquemment, et cela pour la collection entière générerait performances inacceptables. En mode virtuel, seuls les éléments requis sont calculés.

Pour utiliser le mode virtuel, vous devez gérer le RetrieveVirtualItem événement qui est déclenché chaque fois que le ListView requiert un élément. Ce gestionnaire d’événements doit créer le ListViewItem objet appartient à l’index spécifié. En outre, le VirtualListSize propriété doit être définie à la taille de la liste virtuelle.

Gestion du SearchForVirtualItem événement permet les recherches en mode virtuel. Si cet événement n’est pas géré, le FindItemWithText et FindNearestItem méthodes retourneront null.

Vous pouvez gérer les CacheVirtualItems événement afin de maintenir un cache de ListViewItem objets. Si le calcul ou la recherche pour créer un ListViewItem objet est coûteux, le maintien d’un cache peut améliorer les performances.

Si la View est définie sur Tile, la valeur sera automatiquement remplacée par LargeIcon lorsque VirtualMode a la valeur true.

En mode virtuel, les Items collecte est désactivée. Tente d’y accéder entraîne une InvalidOperationException. Est de même de la CheckedItems collection et SelectedItems collection. Si vous souhaitez récupérer les éléments sélectionnés ou activés, utilisez le SelectedIndices et CheckedIndices collections à la place.

Cet exemple illustre une simple ListView dont le contenu est de 10 000 premiers carrés. Il gère la recherche et utilise un cache pour améliorer les performances.

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.
    }
}

.NET Framework
Disponible depuis 2.0
Retour au début
Afficher: