👔 🌖 🧑🏽 WPF में डेटा वर्चुअलाइजेशन 🥧 🧗🏿 ◽️

शुभ दिन।

मैं लंबे समय से अपनी खुद की कक्षा को लिखने के लिए डेटाबेस से जानकारी को जानबूझकर लोड करने में रुचि रखता था, उदाहरण के लिए, जब रिकॉर्ड की संख्या 10 से अधिक रिकॉर्ड होती है।
सूचना के लोडिंग में देरी, कई डेटा स्रोतों का उपयोग, आदि।

मुझे हब पर इस विषय के लिए समर्पित एक पोस्ट नहीं मिला, इसलिए मैं आपको पॉल मैक्लेन द्वारा लेख के मेरे अनुवाद को प्रस्तुत करता हूं, जो कार्यों को हल करने में शुरुआती बिंदु बन गया।

मूल लेख: यहाँ
परियोजना स्रोत फ़ाइलें: यहाँ

पाठ में आगे मैं लेखक की ओर से लिखूंगा।

परिचय

डब्ल्यूपीएफ बड़े संग्रह के साथ कुशलता से काम करने के लिए कुछ दिलचस्प यूजर इंटरफेस वर्चुअलाइजेशन क्षमताएं प्रदान करता है, कम से कम यूजर इंटरफेस के नजरिए से, लेकिन डेटा वर्चुअलाइजेशन के लिए एक सामान्य तरीका प्रदान नहीं करता है। जबकि कई फ़ोरम पोस्ट में डेटा वर्चुअलाइज़ेशन की चर्चा है, किसी ने (जहाँ तक मुझे पता है) एक समाधान पोस्ट किया है। लेख इनमें से एक समाधान प्रस्तुत करता है।

आवश्यक शर्तें

यूआई वर्चुअलाइजेशन

जब WPF ItemControl नियंत्रण यूआई वर्चुअलाइजेशन के साथ स्रोत डेटा के एक बड़े संग्रह से जुड़ा होता है, तो नियंत्रण केवल दृश्य वस्तुओं के लिए दृश्य कंटेनर बनाता है (प्लस कुछ ऊपर और नीचे)। यह आमतौर पर मूल संग्रह का एक छोटा सा हिस्सा है। जब उपयोगकर्ता सूची के माध्यम से स्क्रॉल करता है, तो नए दृश्य कंटेनर बनाए जाते हैं जब तत्व दिखाई देते हैं, और पुराने कंटेनर उस क्षण नष्ट हो जाते हैं जब तत्व अदृश्य होते हैं। दृश्य कंटेनरों का पुन: उपयोग करते समय, हम वस्तुओं को बनाने और नष्ट करने के ओवरहेड को कम करते हैं।

उपयोगकर्ता इंटरफ़ेस के वर्चुअलाइजेशन का मतलब है कि नियंत्रण डेटा के एक बड़े संग्रह के साथ जुड़ा हो सकता है और एक ही समय में दृश्यमान कंटेनरों की कम संख्या के कारण कम मेमोरी लेता है।

डेटा वर्चुअलाइजेशन

डेटा वर्चुअलाइजेशन एक शब्द है जिसका अर्थ है कि एक वस्तु-वस्तु से जुड़ी डेटा ऑब्जेक्ट के लिए वर्चुअलाइजेशन प्राप्त करना। WPF में डेटा वर्चुअलाइजेशन प्रदान नहीं किया गया है। बेस ऑब्जेक्ट्स के अपेक्षाकृत छोटे संग्रह के लिए, मेमोरी की खपत कोई मायने नहीं रखती है। हालांकि, बड़े संग्रह के लिए, मेमोरी की खपत बहुत महत्वपूर्ण हो सकती है। इसके अलावा, डेटाबेस से जानकारी प्राप्त करना या ऑब्जेक्ट बनाना बहुत समय लग सकता है, खासकर नेटवर्क संचालन के दौरान। इन कारणों से, डेटा ऑब्जेक्ट्स की संख्या को सीमित करने के लिए कुछ प्रकार के डेटा वर्चुअलाइजेशन तंत्र का उपयोग करना उचित है जो स्रोत से पुनर्प्राप्त किया जाना चाहिए और मेमोरी में रखा जाना चाहिए।

निर्णय

सिंहावलोकन

यह समाधान इस तथ्य पर आधारित है कि जब ItemControl नियंत्रण IList कार्यान्वयन के साथ जुड़ा हुआ है और IEnumerable नहीं है, इसलिए, यह पूरी सूची को सूचीबद्ध नहीं करता है, बल्कि इसके बजाय प्रदर्शन के लिए आवश्यक वस्तुओं का चयन प्रदान करता है। यह स्क्रॉल बार के आकार को सेट करने के लिए, संग्रह का आकार निर्धारित करने के लिए गणना गुण का उपयोग करता है। भविष्य में, यह एक सूची अनुक्रमणिका के माध्यम से स्क्रीन आइटम पर पुनरावृति करेगा। इस प्रकार, एक IList बनाना संभव है जो रिपोर्ट कर सकता है कि इसमें बड़ी संख्या में तत्व हैं, और केवल आवश्यकतानुसार तत्व प्राप्त करते हैं।

IItemsProvider <T>

इस समाधान का उपयोग करने के लिए, आधार स्रोत संग्रह में तत्वों की संख्या के बारे में जानकारी प्रदान करने में सक्षम होना चाहिए, और पूरे संग्रह का एक छोटा हिस्सा (या पृष्ठ) प्रदान करना चाहिए। इन आवश्यकताओं को IItemsProvider इंटरफ़ेस में व्यक्त किया गया है।

/// <summary> ///     of collection details. /// </summary> /// <typeparam name="T">   </typeparam> public interface IItemsProvider<T> { /// <summary> ///      /// </summary> /// <returns></returns> int FetchCount(); /// <summary> ///    /// </summary> /// <param name="startIndex"> </param> /// <param name="count">   </param> /// <returns></returns> IList<T> FetchRange(int startIndex, int count); }

यदि अंतर्निहित डेटा स्रोत एक डेटाबेस क्वेरी है, तो अधिकांश डेटाबेस प्रदाताओं द्वारा प्रदान की गई COUNT () समग्र फ़ंक्शन, या OFFSET और LIMIT अभिव्यक्तियों का उपयोग करके IItemsProvider इंटरफ़ेस को लागू करना अपेक्षाकृत आसान है।

वर्चुअलाइज़िंगकरण <टी>

यह IList इंटरफ़ेस का एक कार्यान्वयन है जो डेटा वर्चुअलाइजेशन को लागू करता है। वर्चुअलाइज़िंग कॉलेक्शन <टी> पृष्ठों की एक श्रृंखला में पूरे संग्रह स्थान को विभाजित करता है। यदि आवश्यक हो, तो पृष्ठों को स्मृति में लोड किया जाता है, और अनावश्यक होने पर नष्ट कर दिया जाता है।

दिलचस्प बिंदुओं पर नीचे चर्चा की जाएगी। विवरण के लिए, कृपया इस लेख से जुड़े स्रोत कोड को देखें।

IList के कार्यान्वयन का पहला पहलू काउंट प्रॉपर्टी का कार्यान्वयन है। इसका उपयोग आइटमकंट्रोल द्वारा संग्रह के आकार का मूल्यांकन करने और स्क्रॉल बार खींचने के लिए किया जाता है।

 Private int _count = -1; public virtual int Count { get { if (_count == -1) { LoadCount(); } return _count; } protected set { _count = value; } } protected virtual void LoadCount() { Count = FetchCount(); } protected int FetchCount() { return ItemsProvider.FetchCount(); }

गणना संपत्ति आलसी लोड टेम्पलेट का उपयोग करके कार्यान्वित की जाती है। यह विशेष मूल्य -1 का उपयोग यह इंगित करने के लिए करता है कि मूल्य अभी तक लोड नहीं हुआ है। पहली कॉल पर, संपत्ति आइटम की वर्तमान संख्या को आइटमप्रॉइडर से लोड करेगी।

IList इंटरफ़ेस का एक अन्य महत्वपूर्ण पहलू इंडेक्सर का कार्यान्वयन है।

 public T this[int index] { get { //        int pageIndex = index / PageSize; int pageOffset = index % PageSize; //    RequestPage(pageIndex); //      50%     if ( pageOffset > PageSize/2 && pageIndex < Count / PageSize) RequestPage(pageIndex + 1); //      50%     if (pageOffset < PageSize/2 && pageIndex > 0) RequestPage(pageIndex - 1); //    CleanUpPages(); //       if (_pages[pageIndex] == null) return default(T); //    return _pages[pageIndex][pageOffset]; } set { throw new NotSupportedException(); } }

इंडेक्सर समाधान का सबसे अनूठा हिस्सा है। सबसे पहले, यह निर्धारित करना चाहिए कि पेज किस पेज का है (पेजइंडेक्स) और पेज के भीतर ऑफसेट (पेजऑफसेट)। फिर रिक्वेस्टपेज () विधि कहा जाता है, जो पृष्ठ को वापस करता है।

फिर अगला या पिछला पृष्ठ पेजऑफसेट चर के आधार पर लोड किया जाता है। यह इस धारणा पर आधारित है कि यदि उपयोगकर्ता पृष्ठ 0 देख रहे हैं, तो एक उच्च संभावना है कि वे पृष्ठ 1 को नीचे स्क्रॉल करेंगे। अग्रिम में डेटा प्राप्त करने पर स्क्रीन पर प्रदर्शित होने पर डेटा अंतराल नहीं होता है।

CleanUpPages () अप्रयुक्त पृष्ठों को साफ (या अनलोड) करने के लिए कहा जाता है।

अंत में, पृष्ठ की उपस्थिति के लिए एक सुरक्षात्मक जांच। जब आवश्यक AsyncVirtualizingCollection <T> वर्ग का उपयोग कर रहे हों, तो मामले की जांच जरूरी है कि RequstPage () विधि तुल्यकालिक मोड में काम नहीं करती है।

 private readonly Dictionary<int, IList<T>> _pages = new Dictionary<int, IList<T>>(); private readonly Dictionary<int, DateTime> _pageTouchTimes = new Dictionary<int, DateTime>(); protected virtual void RequestPage(int pageIndex) { if (!_pages.ContainsKey(pageIndex)) { _pages.Add(pageIndex, null); _pageTouchTimes.Add(pageIndex, DateTime.Now); LoadPage(pageIndex); } else { _pageTouchTimes[pageIndex] = DateTime.Now; } } protected virtual void PopulatePage(int pageIndex, IList<T> page) { if (_pages.ContainsKey(pageIndex)) _pages[pageIndex] = page; } public void CleanUpPages() { List<int> keys = new List<int>(_pageTouchTimes.Keys); foreach (int key in keys) { // page 0 is a special case, since the WPF ItemsControl // accesses the first item frequently if ( key != 0 && (DateTime.Now - _pageTouchTimes[key]).TotalMilliseconds > PageTimeout ) { _pages.Remove(key); _pageTouchTimes.Remove(key); } } }

पृष्ठों को एक शब्दकोश में संग्रहीत किया जाता है, जिसमें सूचकांक एक कुंजी के रूप में उपयोग किया जाता है। शब्दकोश का उपयोग अंतिम उपयोग के समय के बारे में जानकारी संग्रहीत करने के लिए भी किया जाता है। हर बार पृष्ठ तक पहुंचने के बाद यह समय अपडेट किया जाता है। इसका उपयोग CleanUpPages () विधि द्वारा उन पृष्ठों को हटाने के लिए किया जाता है, जो समय की एक महत्वपूर्ण राशि तक नहीं पहुंच पाए हैं।

 protected virtual void LoadPage(int pageIndex) { PopulatePage(pageIndex, FetchPage(pageIndex)); } protected IList<T> FetchPage(int pageIndex) { return ItemsProvider.FetchRange(pageIndex*PageSize, PageSize); }

अंत में, FetchPage () ItemProvider से पृष्ठ को पुनः प्राप्त करता है, और LoadPage () विधि पॉपुलेटपेज () विधि को कॉल करने का कार्य करती है, जो पृष्ठ को निर्दिष्ट सूचकांक के साथ शब्दकोश में रखती है।

ऐसा लग सकता है कि कोड में बहुत सारे गैर-आवश्यक तरीके हैं, लेकिन उन्हें कुछ कारणों से इस तरह से विकसित किया गया था। प्रत्येक विधि बिल्कुल एक कार्य करती है। यह कोड को पठनीय रखने में मदद करता है, और इससे व्युत्पन्न कक्षाओं में कार्यक्षमता का विस्तार करना और संशोधित करना भी आसान हो जाता है, जैसा कि बाद में देखा जाएगा।

VirtualizingCollection <T> वर्ग डेटा वर्चुअलाइजेशन के प्राथमिक लक्ष्य को प्राप्त करता है। दुर्भाग्य से, इस वर्ग का उपयोग करने की प्रक्रिया में एक महत्वपूर्ण दोष है - डेटा प्राप्त करने के सभी तरीकों को सिंक्रोनाइज़ किया जाता है। इसका मतलब है कि वे उपयोगकर्ता इंटरफ़ेस थ्रेड्स द्वारा शुरू किए गए हैं, जिसके परिणामस्वरूप संभावित रूप से एप्लिकेशन को बाधित किया जाता है।

AsyncVirtualizingCollection <T>

AsyncVirtualizingCollection <T> वर्ग VirtualizingCollection <T> से विरासत में मिला है, और अतुल्यकालिक डेटा लोडिंग को लागू करने के लिए लोड () विधि को ओवरराइड करता है। एक अतुल्यकालिक डेटा स्रोत की एक प्रमुख विशेषता यह है कि डेटा प्राप्त करने के समय, उसे अपने डेटा बाइंडिंग के माध्यम से उपयोगकर्ता इंटरफ़ेस को सूचित करना होगा। सामान्य वस्तुओं में, यह INotifyPropertyChanged इंटरफ़ेस का उपयोग करके हल किया जाता है। संग्रह को कार्यान्वित करने के लिए, आपको इसके करीबी रिश्तेदार INotifyCollectionChanged का उपयोग करना होगा। इस इंटरफ़ेस का उपयोग क्लास ऑब्जर्वेबल कॉलेक्शन <T> द्वारा किया जाता है

 public event NotifyCollectionChangedEventHandler CollectionChanged; protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e) { NotifyCollectionChangedEventHandler h = CollectionChanged; if (h != null) h(this, e); } private void FireCollectionReset() { NotifyCollectionChangedEventArgs e = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset); OnCollectionChanged(e); } public event PropertyChangedEventHandler PropertyChanged; protected virtual void OnPropertyChanged(PropertyChangedEventArgs e) { PropertyChangedEventHandler h = PropertyChanged; if (h != null) h(this, e); } private void FirePropertyChanged(string propertyName) { PropertyChangedEventArgs e = new PropertyChangedEventArgs(propertyName); OnPropertyChanged(e); }

AsyncVirtualizingCollection <T> वर्ग अधिकतम बंडल लचीलापन प्रदान करने के लिए INotifyPropertyChanged और INotifyCollectionChanged इंटरफेस दोनों को लागू करता है। इस कार्यान्वयन में नोट करने के लिए कुछ भी नहीं है।

 protected override void LoadCount() { Count = 0; IsLoading = true; ThreadPool.QueueUserWorkItem(LoadCountWork); } private void LoadCountWork(object args) { int count = FetchCount(); SynchronizationContext.Send(LoadCountCompleted, count); } private void LoadCountCompleted(object args) { Count = (int)args; IsLoading = false; FireCollectionReset(); }

ओवरराइड लोडकाउंट () विधि में, थ्रेडपूल के माध्यम से प्राप्त को अतुल्यकालिक रूप से कहा जाता है। पूरा होने पर, एक नई मात्रा सेट की जाएगी और InotifyCollectionChanged के माध्यम से उपयोगकर्ता इंटरफ़ेस को अपडेट करने के लिए FireCollectionReset () विधि को कॉल किया जाएगा। ध्यान दें कि LoadCountCompleted विधि को SynchronizationContext का उपयोग करके उपयोगकर्ता इंटरफ़ेस थ्रेड से कहा जाता है। SynchronizationContext प्रॉपर्टी को क्लास के कंस्ट्रक्टर में सेट किया जाता है, इस धारणा के साथ कि यूजर इंटरफेस स्ट्रीम में कलेक्शन इंस्टेंस बनाया जाएगा।

 protected override void LoadPage(int index) { IsLoading = true; ThreadPool.QueueUserWorkItem(LoadPageWork, index); } private void LoadPageWork(object args) { int pageIndex = (int)args; IList<T> page = FetchPage(pageIndex); SynchronizationContext.Send(LoadPageCompleted, new object[]{ pageIndex, page }); } private void LoadPageCompleted(object args) { int pageIndex = (int)((object[]) args)[0]; IList<T> page = (IList<T>)((object[])args)[1]; PopulatePage(pageIndex, page); IsLoading = false; FireCollectionReset(); }

पेज डेटा का अतुल्यकालिक लोडिंग एक ही नियम का पालन करता है, और फिर से उपयोगकर्ता इंटरफ़ेस को अपडेट करने के लिए FireCollectionReset () विधि का उपयोग किया जाता है।

हम इस्लोइंग प्रॉपर्टी पर भी ध्यान देते हैं। यह एक सरल ध्वज है जिसका उपयोग उपयोगकर्ता इंटरफ़ेस द्वारा संग्रह लोडिंग को इंगित करने के लिए किया जा सकता है। जब IsLading संपत्ति में परिवर्तन होता है, तो FirePropertyChanged () विधि उपयोगकर्ता इंटरफ़ेस को INotifyProperyChanged तंत्र के माध्यम से अद्यतन करने का कारण बनता है।

 public bool IsLoading { get { return _isLoading; } set { if ( value != _isLoading ) { _isLoading = value; FirePropertyChanged("IsLoading"); } } }

डेमो प्रोजेक्ट

इस समाधान को प्रदर्शित करने के लिए, मैंने एक सरल डेमो प्रोजेक्ट बनाया (प्रोजेक्ट के स्रोत कोड में शामिल)।

सबसे पहले, IItemsProvider वर्ग का एक कार्यान्वयन बनाया गया था, जो डिस्क या नेटवर्क से डेटा प्राप्त करने में देरी का अनुकरण करने के लिए एक स्ट्रीम स्टॉप के साथ डमी डेटा प्रदान करता है।

 public class DemoCustomerProvider : IItemsProvider<Customer> { private readonly int _count; private readonly int _fetchDelay; public DemoCustomerProvider(int count, int fetchDelay) { _count = count; _fetchDelay = fetchDelay; } public int FetchCount() { Thread.Sleep(_fetchDelay); return _count; } public IList<Customer> FetchRange(int startIndex, int count) { Thread.Sleep(_fetchDelay); List<Customer> list = new List<Customer>(); for( int i=startIndex; i<startIndex+count; i++ ) { Customer customer = new Customer {Id = i+1, Name = "Customer " + (i+1)}; list.Add(customer); } return list; } }

सर्वव्यापी ग्राहक ऑब्जेक्ट का उपयोग संग्रह आइटम के रूप में किया जाता है।

उपयोगकर्ता को विभिन्न सूची कार्यान्वयनों के साथ प्रयोग करने की अनुमति देने के लिए सूची दृश्य नियंत्रण के साथ एक साधारण WPF विंडो बनाई गई थी।

 <Window x:Class="DataVirtualization.DemoWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="Data Virtualization Demo - By Paul McClean" Height="600" Width="600"> <Window.Resources> <Style x:Key="lvStyle" TargetType="{x:Type ListView}"> <Setter Property="VirtualizingStackPanel.IsVirtualizing" Value="True"/> <Setter Property="VirtualizingStackPanel.VirtualizationMode" Value="Recycling"/> <Setter Property="ScrollViewer.IsDeferredScrollingEnabled" Value="True"/> <Setter Property="ListView.ItemsSource" Value="{Binding}"/> <Setter Property="ListView.View"> <Setter.Value> <GridView> <GridViewColumn Header="Id" Width="100"> <GridViewColumn.CellTemplate> <DataTemplate> <TextBlock Text="{Binding Id}"/> </DataTemplate> </GridViewColumn.CellTemplate> </GridViewColumn> <GridViewColumn Header="Name" Width="150"> <GridViewColumn.CellTemplate> <DataTemplate> <TextBlock Text="{Binding Name}"/> </DataTemplate> </GridViewColumn.CellTemplate> </GridViewColumn> </GridView> </Setter.Value> </Setter> <Style.Triggers> <DataTrigger Binding="{Binding IsLoading}" Value="True"> <Setter Property="ListView.Cursor" Value="Wait"/> <Setter Property="ListView.Background" Value="LightGray"/> </DataTrigger> </Style.Triggers> </Style> </Window.Resources> <Grid Margin="5"> <Grid.RowDefinitions> <RowDefinition Height="Auto"/> <RowDefinition Height="Auto"/> <RowDefinition Height="Auto"/> <RowDefinition Height="*"/> </Grid.RowDefinitions> <GroupBox Grid.Row="0" Header="ItemsProvider"> <StackPanel Orientation="Horizontal" Margin="0,2,0,0"> <TextBlock Text="Number of items:" Margin="5" TextAlignment="Right" VerticalAlignment="Center"/> <TextBox x:Name="tbNumItems" Margin="5" Text="1000000" Width="60" VerticalAlignment="Center"/> <TextBlock Text="Fetch Delay (ms):" Margin="5" TextAlignment="Right" VerticalAlignment="Center"/> <TextBox x:Name="tbFetchDelay" Margin="5" Text="1000" Width="60" VerticalAlignment="Center"/> </StackPanel> </GroupBox> <GroupBox Grid.Row="1" Header="Collection"> <StackPanel> <StackPanel Orientation="Horizontal" Margin="0,2,0,0"> <TextBlock Text="Type:" Margin="5" TextAlignment="Right" VerticalAlignment="Center"/> <RadioButton x:Name="rbNormal" GroupName="rbGroup" Margin="5" Content="List(T)" VerticalAlignment="Center"/> <RadioButton x:Name="rbVirtualizing" GroupName="rbGroup" Margin="5" Content="VirtualizingList(T)" VerticalAlignment="Center"/> <RadioButton x:Name="rbAsync" GroupName="rbGroup" Margin="5" Content="AsyncVirtualizingList(T)" IsChecked="True" VerticalAlignment="Center"/> </StackPanel> <StackPanel Orientation="Horizontal" Margin="0,2,0,0"> <TextBlock Text="Page size:" Margin="5" TextAlignment="Right" VerticalAlignment="Center"/> <TextBox x:Name="tbPageSize" Margin="5" Text="100" Width="60" VerticalAlignment="Center"/> <TextBlock Text="Page timeout (s):" Margin="5" TextAlignment="Right" VerticalAlignment="Center"/> <TextBox x:Name="tbPageTimeout" Margin="5" Text="30" Width="60" VerticalAlignment="Center"/> </StackPanel> </StackPanel> </GroupBox> <StackPanel Orientation="Horizontal" Grid.Row="2"> <TextBlock Text="Memory Usage:" Margin="5" VerticalAlignment="Center"/> <TextBlock x:Name="tbMemory" Margin="5" Width="80" VerticalAlignment="Center"/> <Button Content="Refresh" Click="Button_Click" Margin="5" Width="100" VerticalAlignment="Center"/> <Rectangle Name="rectangle" Width="20" Height="20" Fill="Blue" Margin="5" VerticalAlignment="Center"> <Rectangle.RenderTransform> <RotateTransform Angle="0" CenterX="10" CenterY="10"/> </Rectangle.RenderTransform> <Rectangle.Triggers> <EventTrigger RoutedEvent="Rectangle.Loaded"> <BeginStoryboard> <Storyboard> <DoubleAnimation Storyboard.TargetName="rectangle" Storyboard.TargetProperty= "(TextBlock.RenderTransform).(RotateTransform.Angle)" From="0" To="360" Duration="0:0:5" RepeatBehavior="Forever" /> </Storyboard> </BeginStoryboard> </EventTrigger> </Rectangle.Triggers> </Rectangle> <TextBlock Margin="5" VerticalAlignment="Center" FontStyle="Italic" Text="Pause in animation indicates UI thread stalled."/> </StackPanel> <ListView Grid.Row="3" Margin="5" Style="{DynamicResource lvStyle}"/> </Grid> </Window>

XAML विवरण में मत जाओ। ध्यान देने योग्य एकमात्र बात यह है कि निर्दिष्ट सूची दृश्य का उपयोग पृष्ठभूमि और माउस कर्सर को बदलने के लिए होता है, जो कि IsLading संपत्ति को बदलने के लिए होता है।

 public partial class DemoWindow { /// <summary> /// Initializes a new instance of the <see cref="DemoWindow"/> class. /// </summary> public DemoWindow() { InitializeComponent(); // use a timer to periodically update the memory usage DispatcherTimer timer = new DispatcherTimer(); timer.Interval = new TimeSpan(0, 0, 1); timer.Tick += timer_Tick; timer.Start(); } private void timer_Tick(object sender, EventArgs e) { tbMemory.Text = string.Format("{0:0.00} MB", GC.GetTotalMemory(true)/1024.0/1024.0); } private void Button_Click(object sender, RoutedEventArgs e) { // create the demo items provider according to specified parameters int numItems = int.Parse(tbNumItems.Text); int fetchDelay = int.Parse(tbFetchDelay.Text); DemoCustomerProvider customerProvider = new DemoCustomerProvider(numItems, fetchDelay); // create the collection according to specified parameters int pageSize = int.Parse(tbPageSize.Text); int pageTimeout = int.Parse(tbPageTimeout.Text); if ( rbNormal.IsChecked.Value ) { DataContext = new List<Customer>(customerProvider.FetchRange(0, customerProvider.FetchCount())); } else if ( rbVirtualizing.IsChecked.Value ) { DataContext = new VirtualizingCollection<Customer>(customerProvider, pageSize); } else if ( rbAsync.IsChecked.Value ) { DataContext = new AsyncVirtualizingCollection<Customer>(customerProvider, pageSize, pageTimeout*1000); } } }

विंडो लेआउट काफी सरल है, लेकिन समाधान प्रदर्शित करने के लिए पर्याप्त है।

उपयोगकर्ता DemoCustomerProvider उदाहरण और देरी सिम्युलेटर समय में तत्वों की संख्या को समायोजित कर सकता है।

डेमो उपयोगकर्ताओं को सूची (टी) के मानक कार्यान्वयन, तुल्यकालिक डेटा लोडिंग वर्चुअलाइज़िंगकॉलशन (टी) के साथ कार्यान्वयन और एसिंक्रोनस डेटा लोडिंग एसिंक्रोनसर्टलाइज़िंगकॉलिनेशन (टी) के साथ तुलना की अनुमति देता है। VirtualizingCollection (T) और AsyncVirtualizingCollection (T) का उपयोग करते समय, उपयोगकर्ता पृष्ठ का आकार और टाइमआउट सेट कर सकता है (उस समय को सेट करता है जिसके बाद पृष्ठ को मेमोरी से अनलोड किया जाना चाहिए)। उन्हें तत्व की विशेषताओं और उपयोग के अपेक्षित पैटर्न के अनुसार चुना जाना चाहिए।

विभिन्न प्रकार के संग्रहों की तुलना करने के लिए, विंडो उपयोग की गई मेमोरी की कुल मात्रा भी प्रदर्शित करती है। घूर्णन वर्ग एनीमेशन का उपयोग उपयोगकर्ता इंटरफ़ेस प्रवाह के ठहराव की कल्पना करने के लिए किया जाता है। पूरी तरह से अतुल्यकालिक समाधान में, एनीमेशन धीमा या बंद नहीं होना चाहिए।

WPF में डेटा वर्चुअलाइजेशन