原理：

实现了ISupportIncrementalLoading 接口

完成了增量加载，

针对于本地对象无法释放的情况 增加了 相关的Func

同时 通过VisualTree 拿到了GridView中 HorizontalBar 来对滚动条的位置进行捕捉 与计算

通过计算后 来执行 虚化操作

如需 转载请声明博客作者

以下是源码：

IncrementalLoadingCollection 对象：

 public class IncrementalLoadingCollection<T> : ObservableCollection<T>, ISupportIncrementalLoading
    {
        // 是否正在异步加载中
        private bool _isBusy = false;

        // 提供数据的 Func
        // 第一个参数：增量加载的起始索引；第二个参数：需要获取的数据量；第三个参数：获取到的数据集合
        private Func<int, int, List<T>> _funcGetData;
        // 最大可显示的数据量
        private uint _totalCount = 0;

        private Func<T, T> _actDisposeData;

        public int PageIndex = 0;

        public uint perCount = 0;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="totalCount">最大可显示的数据量</param>
        /// <param name="getDataFunc">提供数据的 Func</param>
        public IncrementalLoadingCollection(uint totalCount, Func<int, int, List<T>> getDataFunc, Func<T, T> actDisposeData)
        {
            _funcGetData = getDataFunc;
            _totalCount = totalCount;
            _actDisposeData = actDisposeData;
        }

        /// <summary>
        /// 是否还有更多的数据
        /// </summary>
        public bool HasMoreItems
        {
            get { return this.Count < _totalCount; }
        }

        /// <summary>
        /// 异步加载数据（增量加载）
        /// </summary>
        /// <param name="count">需要加载的数据量</param>
        /// <returns></returns>
        public IAsyncOperation<LoadMoreItemsResult> LoadMoreItemsAsync(uint count)
        {
            perCount = count;
            if (_isBusy)
            {
                return AsyncInfo.Run((token) => Task.Run<LoadMoreItemsResult>(() =>
                {
                    return new LoadMoreItemsResult { Count = (uint)this.Count };

                }, token));
            }
            _isBusy = true;

            var dispatcher = Window.Current.Dispatcher;

            return AsyncInfo.Run(
                (token) =>
                    Task.Run<LoadMoreItemsResult>(
                       async () =>
                       {
                           try
                           {
                               //// 模拟长时任务
                               await Task.Delay(100);

                               // 增量加载的起始索引
                               var startIndex = this.Count;

                               await dispatcher.RunAsync(
                                    CoreDispatcherPriority.Normal,
                                    () =>
                                    {
                                        PageIndex++;
                                        // 通过 Func 获取增量数据
                                        var items = _funcGetData(startIndex, (int)count);
                                        if (items != null)
                                            foreach (var item in items)
                                            {
                                                this.Add(item);
                                            }
                                    });

                               // Count - 实际已加载的数据量
                               return new LoadMoreItemsResult { Count = (uint)this.Count };
                           }
                           finally
                           {
                               _isBusy = false;
                           }
                       },
                       token));
        }

        public void DisposeItemByStartAndEnd(long start, long end)
        {
            for (long i = start; i < end; i++)
            {
                _actDisposeData(this.Items[(int)i]);
            }
        }

        public void RemoveItemByRange(long start, long end)
        {
            for (long i = start; i < end; i++)
            {
                if (this.Items.Count > i)
                {
                    this.RemoveItem((int)i);
                }
            }
        }

        public void Reset()
        {
            this.OnCollectionChanged(new System.Collections.Specialized.NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction.Reset));
        }
    }

IncrementalLoadingGridView：

  public class IncrementalLoadingGridView : GridView
    {
        #region Member Variables
        private ScrollBar _HorizontalScrollBar;
        private Dictionary<int, int> _pageOffsetDict = new Dictionary<int, int>();
        private Dictionary<int, bool> _pageVirtualizingDict = new Dictionary<int, bool>();
        private dynamic _filelist;
        #endregion

        #region Constants
        const string HORIZONTALSCROLLBAR_PARTNAME = "HorizontalScrollBar";
        #endregion

        public IncrementalLoadingGridView()
        {
            this.Loaded += ((sender, e) =>
            {
                this.OnApplyTemplate();
            });
            this.Unloaded += ((sender, e) =>
            {
                _HorizontalScrollBar = Pollute.FindVisualChildByName<ScrollBar>(this, HORIZONTALSCROLLBAR_PARTNAME);
                if (null != _HorizontalScrollBar)
                    _HorizontalScrollBar.ValueChanged -= ValueChanged;
            });

        }

        protected override async void OnApplyTemplate()
        {
            base.OnApplyTemplate();

            await this.WaitForLayoutUpdateAsync();
            _HorizontalScrollBar = Pollute.FindVisualChildByName<ScrollBar>(this, HORIZONTALSCROLLBAR_PARTNAME);
            if (null != _HorizontalScrollBar)
            {
                _HorizontalScrollBar.ValueChanged += ValueChanged;
            }
        }

        protected override async void OnItemsChanged(object e)
        {
            if (null != this.ItemsSource)
            {
                InitPositionByValue();
            }

            base.OnItemsChanged(e);
            if (null == this.ItemsSource)
            {
                await this.WaitForLoadedAsync();
                InitPositionByValue();
            }
        }

        private void InitPositionByValue()
        {
            _filelist = this.ItemsSource;
            CompositionTarget.Rendering += ((obj, args) =>
            {
                var newValue = Convert.ToInt32(_HorizontalScrollBar.Value);
                int currentPageIndex = _filelist.PageIndex - 2;
                if (!_pageOffsetDict.ContainsKey(currentPageIndex))
                {
                    _pageOffsetDict[currentPageIndex] = newValue;
                    _pageVirtualizingDict[currentPageIndex] = false;
                }
            });
        }

        private int preIndex = 0;
        private int maxPageIndex = 0;
        private int minOffset;
        private async void ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (null == this.ItemsSource) return;
            var newValue = Convert.ToInt32(e.NewValue);
            var oldValue = Convert.ToInt32(e.OldValue);
            if (newValue == oldValue) return;
            Debug.WriteLine("坐标:" + newValue);
            int currentPageIndex;
            if (null == _filelist) _filelist = this.ItemsSource;
            if (e.NewValue < 1.0)
            {
                await Task.Run(async () =>
                {
                    string text = "滑到头了 开始释放 释放前个数:" + _filelist.Count.ToString();
                    Debug.WriteLine(text);
                    for (int i = 3; i < maxPageIndex; i++)
                    {
                        _pageVirtualizingDict[i] = true;
                        var start = (i - 1) * _filelist.perCount;
                        var end = i * _filelist.perCount - 1;
                        await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
                        {
                            if (_filelist.Count > end)
                            {
                                _filelist.DisposeItemByStartAndEnd(start, end);
                                _filelist.RemoveItemByRange(start, end);
                            }
                            await Task.Delay(500);
                            _filelist.Reset();
                        });
                    }
                    _filelist.PageIndex = 2;
                    text = "滑到头了 释放完毕 释放后个数:" + _filelist.Count;

                    Debug.WriteLine(text);
                });
            }
            else
                await Task.Run(() =>
                {
                    if (newValue > oldValue)
                    {
                        //lock (_pageOffsetDict)
                        //{
                        var horiOffset = newValue - oldValue;
                        if (minOffset > horiOffset) minOffset = horiOffset;
                        currentPageIndex = _filelist.PageIndex - 2;
                        //_pageOffsetDict[currentPageIndex] = newValue;
                        maxPageIndex = Convert.ToInt32(_filelist.Count) / Convert.ToInt32(_filelist.perCount);

                        //}
                        if (preIndex != currentPageIndex && _pageOffsetDict.ContainsValue(newValue))
                        {
                            Debug.WriteLine("坐标:" + newValue + " 上一页:" + preIndex + " 当前页:" + currentPageIndex);
                            if (_pageVirtualizingDict.ContainsKey(preIndex))
                            {
                                _pageVirtualizingDict[preIndex] = false;
                                Debug.WriteLine("@@@@@@@@@@@@@@@@@@@@@@@@@需要向后虚化:" + preIndex + "@@@@@@@@@@@@@@@@@@@@@@" + _pageVirtualizingDict[preIndex]);
                                if (!_pageVirtualizingDict[preIndex] && preIndex > 3)
                                {
                                    int i = preIndex;
                                    while (i > 3)
                                    {
                                        //if (!_pageVirtualizingDict.ContainsKey(i))
                                        //{
                                        //    _pageVirtualizingDict[i] = false;
                                        //    _pageOffsetDict[i] = oldValue -= minOffset;
                                        //}
                                        if (_pageVirtualizingDict.ContainsKey(i) && !_pageVirtualizingDict[i])
                                        {
                                            var start = (i - 3) * _filelist.perCount;
                                            var end = (i - 2) * _filelist.perCount - 1;
                                            _filelist.DisposeItemByStartAndEnd(start, end);
                                            _pageVirtualizingDict[i] = true;
                                            Debug.WriteLine("虚化完毕:" + i);
                                        }
                                        i--;
                                    }
                                }
                            }
                            preIndex = currentPageIndex;
                        }
                        _pageVirtualizingDict[currentPageIndex] = false;
                    }
                    else if (newValue < oldValue)
                    {
                        if (_pageOffsetDict.ContainsValue(newValue))
                        {
                            currentPageIndex = _pageOffsetDict.GetKey(newValue).FirstOrDefault();
                            Debug.WriteLine("当前页:" + currentPageIndex + " 坐标:" + newValue);
                            var offset = 3;
                            if (preIndex - offset > currentPageIndex && currentPageIndex > 0)
                            {
                                _pageVirtualizingDict[preIndex] = false;
                                if (!_pageVirtualizingDict[preIndex])
                                {
                                    Debug.WriteLine("@@@@@@@@@@@@@@@@@@@@@@@@@虚化 After页:" + preIndex + " 是否虚化" + _pageVirtualizingDict[preIndex]);
                                    int i = preIndex - offset;
                                    while (i <= maxPageIndex)
                                    {
                                        //if (!_pageVirtualizingDict.ContainsKey(i))
                                        //{
                                        //    _pageVirtualizingDict[i] = false;
                                        //    _pageOffsetDict[i] = oldValue += minOffset;
                                        //}
                                        if (_pageVirtualizingDict.ContainsKey(i) && !_pageVirtualizingDict[i])
                                        {
                                            Debug.WriteLine("开始释放第:" + i + "页");
                                            int count = _filelist.Count;
                                            Debug.WriteLine("虚化前个数:" + count);
                                            var start = (i - 1) * _filelist.perCount;
                                            var end = i * _filelist.perCount - 1;
                                            if (end < _filelist.Count)
                                            {
                                                _filelist.DisposeItemByStartAndEnd(start, end);
                                            }
                                            string writeLine = "虚化after完毕 虚化位Start:" + start + " End:" + end + " Page:" + i + " 虚化后个数:" + count;
                                            Debug.WriteLine(writeLine);
                                            _pageVirtualizingDict[i] = true;
                                        }
                                        i++;
                                    }
                                }
                                _pageVirtualizingDict[currentPageIndex] = false;
                                //_pageVirtualizingDict[currentPageIndex - 1] = false;
                                //_pageVirtualizingDict[currentPageIndex - 2] = false;
                                //_pageVirtualizingDict[currentPageIndex - 3] = false;
                                preIndex = currentPageIndex;
                            }
                            _pageVirtualizingDict[currentPageIndex] = false;
                        }
                    }

                });
            if (e.NewValue == _HorizontalScrollBar.Maximum)
            {
                this.IsHitTestVisible = false;
                await Task.Delay(500);
                this.IsHitTestVisible = true;
            }
        }
    }

使用方式：

    <toolkit:IncrementalLoadingGridView x:Name="gvMain"
                      Visibility="{Binding IsLeafLevel, Converter={StaticResource BooleanToVisibilityConverter}}"
                      Padding="140,40,0,0"
                      SelectionMode="None"
                      ItemsSource="{Binding ImageItemsSource, Mode=TwoWay}"
                      IncrementalLoadingThreshold="0.5" DataFetchSize="0.5"
                      IsItemClickEnabled="True"
                      PointerMoved="gvMain_PointerMoved"
                      ItemClick="gvMain_ItemClick"
                     ItemTemplateSelector="{StaticResource imageDataTemplateSelector}">
                <GridView.ItemsPanel>
                    <ItemsPanelTemplate>
                        <WrapGrid VirtualizingStackPanel.VirtualizationMode="Recycling"></WrapGrid>
                    </ItemsPanelTemplate>
                </GridView.ItemsPanel>
            </toolkit:IncrementalLoadingGridView>

IncrementalLoadingThreshold="0.5" DataFetchSize="0.5" 这2个阀值设定的比较低 这样虚化起来效率会高一些

需要binding 的列表对象

Dispose方法 需要binding对象继承IDispose 释放本地流

_filelist = new IncrementalLoadingCollection<FileItem>((uint)_currentfiles.Count, (startIndex, Count) =>
            {
                SetLoadingState(true);
                if (_currentfiles == null || _currentfiles.Count <= startIndex) return null;
                List<FileItem> list = new List<FileItem>();
                foreach (var file in _currentfiles.Skip(startIndex).Take(Count))
                {
                    FileItem item = new FileItem();
                    item.File = file;
                    item.Name = file.DisplayName;
                    if (folder.Name.EndsWith("zhx")) item.Name = "zhx" + item.Name;
                    list.Add(item);
                }
                SetLoadingState(false);
                return list;
            }, (o) =>
            {
                o.Dispose();
                return o;
            });

当增量滚动时 我会针对 触发增量加载事件同时 记录 需要虚化的offset 在回滚的同时 进行释放操作,以保证内存在较低的负载。

在超宽屏幕上的使用效果， 载入了大量本地图片

前篇：《MyGui笔记（3）控件对齐方式和所在层》
本篇：记录下渲染的过程。
环境：MyGui3.2.0(OpenGL平台)

        MyGui的渲染过程比较复杂，这里仅记录一下一些要点，如有错误的地方，还请指出。在第一篇有提到在BaseManager::run函数里面进行每一帧的绘制，调用的是drawOneFrame()方法，这个方法代码如下： 

调用的是OpenGLRenderManager的drawOneFrame()方法，代码如下： 

在这里进行每一帧事件的触发，和每一帧的渲染，渲染调用其onRenderToTarget方法，代码如下： 

可以看到在这里调用的是LayerManager层管理器来进行绘制，具体代码如下： 

对mLayerNodes里的所有层依次进行调用渲染，故定义在MyGUI_Layers.xml文件最上面的层，将会最先开始渲染，顺序如Wallpaper→Back→Overlapped→……。具体的渲染方法是根据不同的层类型来进行的，代码分别如下： 

在这里可以看到SharedLayer只进行了一次渲染，而OverlappedLayer对附加的根控件节点依次进行渲染，最终调用的都是LayerNode::renderToTarget方法，代码如下： 

渲染调用的方法为RenderItem::renderToTarget，代码如下：

注释是俄语的，谷歌翻译成汉语，可能会有错误，还请指出。最后的渲染即调用OpenGLRenderManager::doRender方法，代码如下：

6~7. Bit Organization，表示数据有多少bit，这里是08，则表示数据为8bit，四片拼起来，数据线就是32位。

8. # of Internal Banks，表示多少Bank，这里是4，表示为8个Banks
9. Interface, VDD, VDDQ，这里解释一下这两个电压的意思
VDD：北桥芯片供电电压或者存储芯片的输入缓冲和核心逻辑的供电电压。
VDDQ:存储芯片的输出缓冲供电电压。
Q : SSTL_18, 1.8V, 1.8V，根据芯片手册得出这两个电压为1.8V
10. Generation
F : F-die，这是什么意思？？？
芯片上型号K4T1G084QF，再往上看，会看到有四个BCF7的字母，接着看代表什么意思
12. Package
B : FBGA (Lead-Free & Halogen-Free, Flip Chip)，表示这FBGA封装,FBGA是Fine-Pitch Ball Grid Array（意译为“细间距球栅阵列”）的缩写
13. Temp, Power
C : Commercial Temp.(0°C ~ 85°C), Normal Power，表示工作的温度范围和供电
14~15. Speed (Wafer/Chip Biz/BGD: 00)
F7 : DDR2-800 (400MHz@CL=6, tRCD=6, tRP=6)，表示为DDR2-800的内存
分析完成，开发板上共有4片这样的内存芯片，总容量就是128M*4=512M

2.分析硬件原理图
2.1 从芯片角度
地址线:
A0-A13 14根
BA0，BA1，BA2
3根BA线表示这个芯片被分成了2^3=8个Bank，每个Bank则为128M/8=16M

这里出现一个问题，为什么128M里面还要划分出8个Bank？
前面在Nand Flash的时候，我曾经分析过，由于DDR是不自备充电电路的，所以，每隔一段时间，内存控制器就会刷新一次电路，也就是要充一次电，如果只有一个Bank，那么结果就是在某一时刻，要么都充电，要么都不充电。

像上面这样分成了8个Bank，当我对000充电的时候，我还可以在010或是剩下的别的Bank中读取数据，这样就减小了等待的时间，不用说当电路刷新时，不能读取数据了。
数据线：DQ0-DQ7*4 = 8bit * 4chips = 32bit
控制线：nCS，nRAS，nCAS
nCS：片选信号，当这个芯片被片选后，这个芯片就使能了，如果这芯片地址线上有地址，那么基本上数据线上就要出数据了。
地址线是A0-A13，是14根线，2^14=16K (128M = 2^27)，所以地址线上地址要发两次，一次发行地址，一次发列地址，这就是行列地址复用--nRAS，nCAS这两根线的作用。
14 + 14 = 28根 + BA0/BA1/BA2 = 2^31=2G，最大支持2G的内存
128M = 2^27，27 - 3 = 24，行地址14根，所以，发过来的列地址是24-14=10
所以说，这个操作顺序是，先片选，CS拉低，然后，当RAS拉低时，表示传过的是行地址，是A0-A13，14位；当CAS拉低时，表示传过来的是列地址，是A0-A9，那列地址多的几位怎么办呢？很简单，用来扩展内存，谁说一片内存芯片就只能128M了？

2.2 从处理器角度
地址线 Xm1ADDR0-Xm1ADDR13
Xm1BA0, Xm1BA1, Xm1CSn1/BA2
数据线 Xm1DATA0-Xm1DATA31
控制线 Xm1CSn0, Xm1RASn, Xm1CASn  
对于地址线前面的Xm1，可以参看核心板的原理图中内存的总图，整个内存分为三块，Memory Port0/Memory Port1/Memory Port2，Memory Port1/Memory Port2分别对应于芯片手册P29页中Memory Map中的DRAM0/DRAM1，可以分别接两组不同的DDR内存

而Memory Port0接的是SRAM，他的地址线是0~15，没有行地址，列地址，没有复用，所以他的容量就是2^16=64K

2.3DDR芯片手册
前面在查看芯片的型号命名规则时最后两位，我们的板子上是F7
14~15. Speed (Wafer/Chip Biz/BGD: 00)
F7 : DDR2-800 (400MHz@CL=6, tRCD=6, tRP=6)，表示为DDR2-800的内存

打开K4T1G084QF.pdf的DDR芯片手册，P4的Key Features，由此我们得知，我们要看的是DDR2-800 6-6-6

这里又多出和几个我们不认识的东西----CL,tRCD,tRP，看字面意思，大概来猜应该是一些时间，从芯片手册的命名规则上特意用一个字母代号来标识这三个东西，这肯定是非常重要的影响内存性能的某些时间参数。这里，有必要把DDR的工作原理重新梳理一下，这样，才能理解这些参数的意义。