Squashed 'FSI.Lib/' content from commit 6aa4846

git-subtree-dir: FSI.Lib
git-subtree-split: 6aa48465a834a7bfdd9cbeae8d2e4f769d0c0ff8

FSI.Lib/EasyEncryption/EncryptionWriter.cs

@@ -0,0 +1,105 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+
+namespace FSI.Lib.EasyEncryption
+{
+    /// <summary>
+    /// Class that provides streaming encryption functionality.
+    /// </summary>
+    /// <remarks>
+    /// Using this class is the preferred way to encrypt values to a file or memory.
+    /// Other encryption methods defer to this class for actual encryption. Meta data
+    /// that must be stored with the encrypted result is only stored once for all
+    /// data in the stream.
+    /// </remarks>
+    public class EncryptionWriter : BinaryWriter, IDisposable
+    {
+        private readonly SymmetricAlgorithm Algorithm;
+        private readonly ICryptoTransform Encryptor;
+
+        internal EncryptionWriter(SymmetricAlgorithm algorithm, ICryptoTransform encryptor, Stream stream) : base(stream)
+        {
+            Algorithm = algorithm;
+            Encryptor = encryptor;
+        }
+
+        /// <summary>
+        /// Writes a <c>DateTime</c> value to the encrypted stream.
+        /// </summary>
+        /// <param name="value"><c>DateTime</c> value to write.</param>
+        public void Write(DateTime value)
+        {
+            Write(value.Ticks);
+        }
+
+        /// <summary>
+        /// Writes a <c>byte</c> array to the encrypted stream.
+        /// </summary>
+        /// <remarks>
+        /// Note: Hides <c>BinaryWriter.Write(byte[])</c>.
+        /// </remarks>
+        /// <param name="value"><c>byte[]</c> values to write.</param>
+        public new void Write(byte[] value)
+        {
+            Write(value.Length);
+            Write(value, 0, value.Length);
+        }
+
+        /// <summary>
+        /// Writes a <c>string</c> to the encrypted stream.
+        /// </summary>
+        /// <param name="value"><c>string[]</c> values to write.</param>
+        public void Write(string[] value)
+        {
+            Write(value.Length);
+            for (int i = 0; i < value.Length; i++)
+                Write(value[i]);
+        }
+
+        #region IDisposable implementation
+
+        private bool disposed = false; // To detect redundant calls
+
+        /// <summary>
+        /// Releases all resources used by the current instance of the <c>EncryptionWriter</c> class.
+        /// </summary>
+        public new void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases the unmanaged resources used by the <c>EncryptionWriter</c> class and optionally
+        /// releases the managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources;
+        /// <c>false</c> to release only unmanaged resources.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (!disposed)
+            {
+                disposed = true;
+                if (disposing)
+                {
+                    // Dispose managed objects
+                    base.Dispose(true);
+                    Encryptor.Dispose();
+                    Algorithm.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Destructs this instance of <c>EncryptionWriter</c>.
+        /// </summary>
+        ~EncryptionWriter()
+        {
+            Dispose(false);
+        }
+
+        #endregion
+
+    }
+}