Version v1.11.426.305 released

Additions in this release:

• Introduced CSharpTest.Net.BPlusTree.dll – a fairly full featured IDictionary<K,V> implementation backed by a B+Tree on disk.
• Collections.LListNode<T> – a doubly linked list implementation that can support asynchronous iteration.
• Collections.SynchronizedDictionary/SynchronizedList to support synchronization of a list/dictionary given a locking strategy from the Synchronization namespace.
• IO.ClampedStream to provide an IO stream aggregation for a subset of the provided stream.
• IO.Crc32 to provide calculation of a CRC32 value from bytes or strings.
• IO.FileStreamFactory an IFactory<Stream> producer of streams for a given file.
• IO.FragmentedFile an underpinning of the B+Tree implementation that provides sub-allocations within a single file.
• IO.SharedMemoryStream a block allocating memory stream that can be simultaneously used by multiple threads at the same time.
• IO.StreamCache a pool of open file streams that a thread can open and close without the overhead of actually opening or closing the underlying file streams.
• Interfaces.IFactory<T> provides a simple generic factory interface for supplying instances of type T.
• Interfaces.ITransactable provides a simple transaction interface.
• IpcChannel.IpcEventChannel provides a cross domain/process connectionless communication built on events.  see this SO post.
• Serialization.ISerializer<T> provides a simple interface for an object that can read and write an instance of type T to and from a stream.
• Serialization.PrimitiveSerializer provides basic implementation of the ISerializer<T> interface for the primitive types.
• Serialization.VariantNumberSerializer provides a protobuffer-like encoding for numeric types.
• Threading.WaitAndContinueList a work list based on WaitHandles and resulting actions so that multiple activities can be performed on a single thread.
• Threading.WaitAndContinueWorker a single worker thread that processes a WaitAndContinueList.
• WorkQueue and WorkQueue<T> provide simple thread pool processing of tasks that the caller can wait for completion on.
• Utils.ObjectKeepAlive a simple object to track references to other instances to avoid garbage collection.
• Utils.WeakReference<T> a derivation of WeakReference that is type-safe.
• Synchronization classes are newly rewritten.

• The Synchronization namespace has undergone a complete overhaul.  If your currently depending upon it’s interfaces or implementation you may want to stay with the version you have until you can determine the impact.  Some simple uses of the previous classes may still work, but this a complete rewrite.  Why?  Simply put the last version was junk.  The added cost of the abstraction layer was more than the lock itself.  I’ve retooled it to avoid new instances on lock, removed the use of TimeSpan, removed the upgrade locks, and simplified the interfaces.  The end result is a very clean interface that is easy to use and fast.