Added BasePagedSourceProvider both Async and Sync.

Fixed Async bug where count could return 0
Fixed all Async to Sync calls so they cant hang.

Author: anagram4wander

AlphaChiTech.Virtualization/ActionVirtualizationWrapper.cs

@@ -5,10 +5,20 @@
 
 namespace AlphaChiTech.Virtualization
 {
+    /// <summary>
+    /// This is a VirtualAction that wraps an Action, optionally with a repeating schedule.
+    /// </summary>
     public class ActionVirtualizationWrapper : BaseRepeatableActionVirtualization
     {
         private Action _Action = null;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ActionVirtualizationWrapper"/> class.
+        /// </summary>
+        /// <param name="action">The action.</param>
+        /// <param name="threadModel">The thread model.</param>
+        /// <param name="isRepeating">if set to <c>true</c> [is repeating].</param>
+        /// <param name="repeatingSchedule">The repeating schedule.</param>
         public ActionVirtualizationWrapper(Action action,
             VirtualActionThreadModelEnum threadModel = VirtualActionThreadModelEnum.UseUIThread,
             bool isRepeating = false, TimeSpan? repeatingSchedule = null)
@@ -17,6 +27,9 @@ public ActionVirtualizationWrapper(Action action,
             _Action = action;
         }
 
+        /// <summary>
+        /// Does the action.
+        /// </summary>
         public override void DoAction()
         {
             var a = _Action;

AlphaChiTech.Virtualization/AlphaChiTech.Virtualization.csproj

@@ -45,6 +45,8 @@
   <ItemGroup>
     <Compile Include="ActionVirtualizationWrapper.cs" />
     <Compile Include="BaseActionVirtualization.cs" />
+    <Compile Include="BasePagedSourceProvider.cs" />
+    <Compile Include="PagedSourceProviderMakeSync.cs" />
     <Compile Include="BaseRepeatableActionVirtualization.cs" />
     <Compile Include="DateBasedPageExpiryComparer.cs" />
     <Compile Include="ExecuteResetWA.cs" />
@@ -63,6 +65,7 @@
     <Compile Include="IVirtualizationAction.cs" />
     <Compile Include="PageDelta.cs" />
     <Compile Include="PagedSourceItemsPacket.cs" />
+    <Compile Include="PagedSourceProviderMakeAsync.cs" />
     <Compile Include="PageFetchStateEnum.cs" />
     <Compile Include="PageReclaimOnTouched.cs" />
     <Compile Include="PaginationManager.cs" />

AlphaChiTech.Virtualization/BaseActionVirtualization.cs

@@ -5,10 +5,23 @@
 
 namespace AlphaChiTech.Virtualization
 {
+    /// <summary>
+    /// Base Class that does an action on the dispatcher thread. Simply implement the DoAction method.
+    /// </summary>
     public abstract class BaseActionVirtualization : IVirtualizationAction
     {
+        /// <summary>
+        /// Gets or sets the thread model.
+        /// </summary>
+        /// <value>
+        /// The thread model.
+        /// </value>
         public VirtualActionThreadModelEnum ThreadModel { get; set; }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseActionVirtualization"/> class.
+        /// </summary>
+        /// <param name="threadModel">The thread model.</param>
         public BaseActionVirtualization(VirtualActionThreadModelEnum threadModel)
         {
             this.ThreadModel = threadModel;

AlphaChiTech.Virtualization/BasePagedSourceProvider.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AlphaChiTech.Virtualization
+{
+    public class BasePagedSourceProvider<T> : IPagedSourceProvider<T>
+    {
+        public BasePagedSourceProvider()
+        {
+        }
+
+        public BasePagedSourceProvider(
+            Func<int, int, PagedSourceItemsPacket<T>> funcGetItemsAt = null,
+            Func<int> funcGetCount = null,
+            Func<T, int> funcIndexOf = null,
+            Action<int> actionOnReset = null
+            )
+        {
+            this.FuncGetItemsAt = funcGetItemsAt;
+            this.FuncGetCount = funcGetCount;
+            this.FuncIndexOf = funcIndexOf;
+            this.ActionOnReset = actionOnReset;
+        }
+
+        private Func<int, int, PagedSourceItemsPacket<T>> _FuncGetItemsAt = null;
+
+        public Func<int, int, PagedSourceItemsPacket<T>> FuncGetItemsAt
+        {
+            get { return _FuncGetItemsAt; }
+            set { _FuncGetItemsAt = value; }
+        }
+        private Func<int> _FuncGetCount = null;
+
+        public Func<int> FuncGetCount
+        {
+            get { return _FuncGetCount; }
+            set { _FuncGetCount = value; }
+        }
+        private Func<T, int> _FuncIndexOf = null;
+
+        public Func<T, int> FuncIndexOf
+        {
+            get { return _FuncIndexOf; }
+            set { _FuncIndexOf = value; }
+        }
+        private Action<int> _ActionOnReset = null;
+
+        public Action<int> ActionOnReset
+        {
+            get { return _ActionOnReset; }
+            set { _ActionOnReset = value; }
+        }
+
+        public virtual PagedSourceItemsPacket<T> GetItemsAt(int pageoffset, int count, bool usePlaceholder)
+        {
+            if (_FuncGetItemsAt != null) return _FuncGetItemsAt.Invoke(pageoffset, count);
+
+            return null;
+        }
+
+        public virtual int Count
+        {
+            get
+            {
+                int ret = 0;
+
+                if (_FuncGetCount != null) ret = _FuncGetCount.Invoke();
+
+                return ret;
+            }
+        }
+
+        public virtual int IndexOf(T item)
+        {
+            int ret = -1;
+
+            if (_FuncIndexOf != null) ret = _FuncIndexOf.Invoke(item);
+
+            return ret;
+        }
+
+        public virtual void OnReset(int count)
+        {
+            if (_ActionOnReset != null) _ActionOnReset.Invoke(count);
+        }
+    }
+}

AlphaChiTech.Virtualization/BaseRepeatableActionVirtualization.cs

@@ -5,11 +5,21 @@
 
 namespace AlphaChiTech.Virtualization
 {
+    /// <summary>
+    /// Base class there the Action repeats on a periodic basis (the RepeatingSchedule) like BaseActionVirtualization
+    /// simply implement the DoAction method.
+    /// </summary>
     public abstract class BaseRepeatableActionVirtualization : BaseActionVirtualization, IRepeatingVirtualizationAction
     {
         protected DateTime _LastRun = DateTime.MinValue;
         private TimeSpan _RepeatingSchedule = TimeSpan.FromSeconds(1);
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseRepeatableActionVirtualization"/> class.
+        /// </summary>
+        /// <param name="threadModel">The thread model.</param>
+        /// <param name="isRepeating">if set to <c>true</c> [is repeating].</param>
+        /// <param name="repeatingSchedule">The repeating schedule.</param>
         public BaseRepeatableActionVirtualization(VirtualActionThreadModelEnum threadModel = VirtualActionThreadModelEnum.UseUIThread,
             bool isRepeating = false, TimeSpan? repeatingSchedule = null)
             : base(threadModel)
@@ -21,6 +31,12 @@ public BaseRepeatableActionVirtualization(VirtualActionThreadModelEnum threadMod
             }
         }
 
+        /// <summary>
+        /// Gets or sets the repeating schedule.
+        /// </summary>
+        /// <value>
+        /// The repeating schedule.
+        /// </value>
         public TimeSpan RepeatingSchedule
         {
             get { return _RepeatingSchedule; }
@@ -29,17 +45,31 @@ public TimeSpan RepeatingSchedule
 
         private bool _IsRepeating = false;
 
+        /// <summary>
+        /// Gets or sets a value indicating whether [is repeating].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [is repeating]; otherwise, <c>false</c>.
+        /// </value>
         protected bool IsRepeating
         {
             get { return _IsRepeating; }
             set { _IsRepeating = value; }
         }
 
+        /// <summary>
+        /// check to see if the action should be kept.
+        /// </summary>
+        /// <returns></returns>
         public virtual bool KeepInActionsList()
         {
             return this.IsRepeating;
         }
 
+        /// <summary>
+        /// Determines whether [is due to run].
+        /// </summary>
+        /// <returns></returns>
         public virtual bool IsDueToRun()
         {
 

AlphaChiTech.Virtualization/DateBasedPageExpiryComparer.cs

@@ -5,11 +5,20 @@
 
 namespace AlphaChiTech.Virtualization
 {
+    /// <summary>
+    /// An implementation of a IPageExiryComparer that uses DateTime to see if the update should be applied
+    /// </summary>
     public class DateBasedPageExpiryComparer : IPageExpiryComparer
     {
 
         private static DateBasedPageExpiryComparer _Instance = new DateBasedPageExpiryComparer();
 
+        /// <summary>
+        /// Gets the default instance.
+        /// </summary>
+        /// <value>
+        /// The default instance.
+        /// </value>
         public static DateBasedPageExpiryComparer DefaultInstance
         {
             get
@@ -18,6 +27,12 @@ public static DateBasedPageExpiryComparer DefaultInstance
             }
         }
 
+        /// <summary>
+        /// Determines whether [is update valid] [the specified page based on the updateAt].
+        /// </summary>
+        /// <param name="pageUpdateAt">The page update at - null or a DateTime.</param>
+        /// <param name="updateAt">The update at - null or a DateTime.</param>
+        /// <returns></returns>
         public bool IsUpdateValid(object pageUpdateAt, object updateAt)
         {
             bool isStillValid = true;

AlphaChiTech.Virtualization/PageReclaimOnTouched.cs

@@ -5,6 +5,11 @@
 
 namespace AlphaChiTech.Virtualization
 {
+    /// <summary>
+    /// PageReclainOnTouched is a Page Reclaimer implementation that releases pages based on when
+    /// they where last touched.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public class PageReclaimOnTouched<T> : IPageReclaimer<T>
     {
 

AlphaChiTech.Virtualization/PagedSourceProviderMakeAsync.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AlphaChiTech.Virtualization
+{
+    public class PagedSourceProviderMakeAsync<T> : BasePagedSourceProvider<T>, IPagedSourceProviderAsync<T>
+    {
+        public PagedSourceProviderMakeAsync()
+        {
+        }
+
+        public PagedSourceProviderMakeAsync(
+            Func<int, int, PagedSourceItemsPacket<T>> funcGetItemsAt = null,
+            Func<int> funcGetCount = null,
+            Func<T, int> funcIndexOf = null,
+            Action<int> actionOnReset = null,
+            Func<int, int, int, T> funcGetPlaceHolder = null
+            )
+            : base(funcGetItemsAt, funcGetCount, funcIndexOf, actionOnReset)
+        {
+            this.FuncGetPlaceHolder = funcGetPlaceHolder;
+        }
+
+        private Func<int, int, int, T> _FuncGetPlaceHolder = null;
+
+        public Func<int, int, int, T> FuncGetPlaceHolder
+        {
+            get { return _FuncGetPlaceHolder; }
+            set { _FuncGetPlaceHolder = value; }
+        }
+
+        public Task<PagedSourceItemsPacket<T>> GetItemsAtAsync(int pageoffset, int count, bool usePlaceholder)
+        {
+            var tcs = new TaskCompletionSource<PagedSourceItemsPacket<T>>();
+
+            try
+            {
+                tcs.SetResult(this.GetItemsAt(pageoffset, count, usePlaceholder));
+            }
+            catch (Exception e)
+            {
+                tcs.SetException(e);
+            }
+
+            return tcs.Task;
+        }
+
+        public virtual T GetPlaceHolder(int index, int page, int offset)
+        {
+            T ret = default(T);
+
+            if (_FuncGetPlaceHolder != null)
+                ret = _FuncGetPlaceHolder.Invoke(index, page, offset);
+
+            return ret;
+        }
+
+        public Task<int> GetCountAsync()
+        {
+            var tcs = new TaskCompletionSource<int>();
+
+            try
+            {
+                tcs.SetResult(this.Count);
+            } catch(Exception e)
+            {
+                tcs.SetException(e);
+            }
+
+            return tcs.Task;
+        }
+    }
+}