Added support to List all the items in the queue so that it could be …

src/DiskQueue/IPersistentQueue.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace DiskQueue
 {
@@ -21,10 +22,10 @@ public interface IPersistentQueue : IDisposable
 		/// </summary>
 		int EstimatedCountOfItemsInQueue { get; }
 
-		/// <summary>
-		/// Advanced adjustable settings. Use with caution. Read the source code.
-		/// </summary>
-		IPersistentQueueImpl Internals { get; }
+        /// <summary>
+        /// Advanced adjustable settings. Use with caution. Read the source code.
+        /// </summary>
+        IPersistentQueueImpl Internals { get; }
 
 		/// <summary>
 		/// Maximum size of files in queue. New files will be rolled-out if this is exceeded.

src/DiskQueue/Implementation/PersistentQueueImpl.cs

@@ -348,10 +348,31 @@ private IFileStream WaitForTransactionLog(byte[] transactionBuffer)
 			}
 		}
 
-		/// <summary>
-		/// Assumes that entries has at least one entry. Should be called inside a lock.
-		/// </summary>
-		private bool ReadAhead()
+        public List<Entry> ToList()
+        {
+            lock (_entries)
+            {
+                var last = _entries.Last;
+                if (last == null) return new List<Entry>();
+
+                var entry = last.Value;
+                if (entry == null) throw new Exception("Entry queue was in an invalid state: null entry");
+
+                if (entry.Data == null)
+                {
+                    var ok = ReadAhead();
+                    if (!ok) return new List<Entry>();
+                }
+
+                var entryList = _entries.ToList();
+				return entryList;
+            }
+        }
+
+        /// <summary>
+        /// Assumes that entries has at least one entry. Should be called inside a lock.
+        /// </summary>
+        private bool ReadAhead()
 		{
 			long currentBufferSize = 0;
 

src/DiskQueue/Implementation/PersistentQueueSession.cs

@@ -139,6 +139,23 @@ private void OnReplaceStream(IFileStream newStream)
 			return entry.Data;
 		}
 
+        /// <summary>
+        /// Try to pull data all from the queue. Data is not removed from the queue
+        /// </summary>
+        public List<byte[]> ToList()
+		{
+			var retList = new List<byte[]>();
+			var entries = _queue.ToList();
+			foreach(var entry in entries)
+			{
+				if( entry.Data != null )
+				{
+                    retList.Add(entry.Data);
+                }
+            }
+			return retList;
+		}
+
 		/// <summary>
 		/// Commit actions taken in this session since last flush.
 		/// If the session is disposed with no flush, actions are not persisted 

src/DiskQueue/Implementation/PersistentQueueSessionT.cs

@@ -1,4 +1,6 @@
-namespace DiskQueue.Implementation
+using System.Collections.Generic;
+
+namespace DiskQueue.Implementation
 {
     /// <inheritdoc cref="IPersistentQueueSession{T}"/>
     public class PersistentQueueSession<T> : PersistentQueueSession, IPersistentQueueSession<T>
@@ -30,5 +32,23 @@ public void Enqueue(T data)
                 Enqueue(bytes);
             }
         }
+
+        /// <summary>
+        /// Try to pull data all from the queue. Data is not removed from the queue
+        /// </summary>
+        public new List<T> ToList()
+        {
+            var typedList = new List<T>();
+            List<byte[]> dataList = base.ToList();
+            foreach (byte[] data in dataList)
+            {
+                T? obj = SerializationStrategy.Deserialize(data);
+                if( obj != null )
+                {
+                    typedList.Add(obj);
+                }
+            }
+            return typedList;
+        }
     }
 }

src/DiskQueue/PublicInterfaces/IPersistentQueueImpl.cs

@@ -34,6 +34,11 @@ public interface IPersistentQueueImpl : IDisposable
 		/// </summary>
 		Entry? Dequeue();
 
+        /// <summary>
+        /// List data, returning all storage entry as list
+        /// </summary>
+        List<Entry> ToList();
+
 		/// <summary>
 		/// <para>UNSAFE. Incorrect use will result in data loss.</para>
 		/// <para>Undo Enqueue and Dequeue operations.</para>

src/DiskQueue/PublicInterfaces/IPersistentQueueSession.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace DiskQueue
 {
@@ -20,10 +21,15 @@ public interface IPersistentQueueSession : IDisposable
 		byte[]? Dequeue();
 
 		/// <summary>
-		/// Commit actions taken in this session since last flush.
-		/// If the session is disposed with no flush, actions are not persisted 
-		/// to the queue (Enqueues are not written, dequeues are left on the queue)
+		/// Try to pull data all from the queue. Data is not removed from the queue
 		/// </summary>
-		void Flush();
+		public List<byte[]> ToList();
+
+        /// <summary>
+        /// Commit actions taken in this session since last flush.
+        /// If the session is disposed with no flush, actions are not persisted 
+        /// to the queue (Enqueues are not written, dequeues are left on the queue)
+        /// </summary>
+        void Flush();
 	}
 }

src/DiskQueue/PublicInterfaces/IPersistentQueueSessionT.cs

@@ -1,4 +1,5 @@
-using DiskQueue.Implementation;
+using System.Collections.Generic;
+using DiskQueue.Implementation;
 
 namespace DiskQueue
 {
@@ -15,6 +16,11 @@ public interface IPersistentQueueSession<T> : IPersistentQueueSession
         /// </summary>
         new T? Dequeue();
 
+        /// <summary>
+        /// Try to pull data all from the queue. Data is not removed from the queue
+        /// </summary>
+        new List<T> ToList();
+
         /// <summary>
         /// This class performs the serialization of the object to be queued into a byte array suitable for queueing.
         /// It defaults to <see cref="DefaultSerializationStrategy{T}"/>, but you are free to implement your own and inject it in.