Make all images implement IDisposable

src/ImageSharp.Processing/Processors/Convolution/Convolution2DProcessor.cs

@@ -54,9 +54,9 @@ namespace ImageSharp.Processing.Processors
             int maxY = endY - 1;
             int maxX = endX - 1;
 
-            TColor[] target = new TColor[source.Width * source.Height];
+            TColor[] target = PixelPool<TColor>.RentPixels(source.Width * source.Height);
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(source.Width, source.Height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(source.Width, source.Height))
             {
                 Parallel.For(
                 startY,

src/ImageSharp.Processing/Processors/Convolution/Convolution2PassProcessor.cs

@@ -45,14 +45,21 @@ namespace ImageSharp.Processing.Processors
             int width = source.Width;
             int height = source.Height;
 
-            TColor[] target = new TColor[width * height];
+            TColor[] target = PixelPool<TColor>.RentPixels(width * height);
-            TColor[] firstPass = new TColor[width * height];
+            TColor[] firstPass = PixelPool<TColor>.RentPixels(width * height);
 
+            try
+            {
                 this.ApplyConvolution(width, height, firstPass, source.Pixels, sourceRectangle, kernelX);
                 this.ApplyConvolution(width, height, target, firstPass, sourceRectangle, kernelY);
 
                 source.SetPixels(width, height, target);
             }
+            finally
+            {
+                PixelPool<TColor>.ReturnPixels(firstPass);
+            }
+        }
 
         /// <summary>
         /// Applies the process to the specified portion of the specified <see cref="ImageBase{TColor}"/> at the specified location
@@ -80,8 +87,8 @@ namespace ImageSharp.Processing.Processors
             int maxY = endY - 1;
             int maxX = endX - 1;
 
-            using (PixelAccessor<TColor> sourcePixels = source.Lock<TColor>(width, height))
+            using (PixelAccessor<TColor> sourcePixels = source.Lock(width, height))
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
             {
                 Parallel.For(
                 startY,

src/ImageSharp.Processing/Processors/Effects/OilPaintingProcessor.cs

@@ -67,9 +67,9 @@ namespace ImageSharp.Processing.Processors
                 startX = 0;
             }
 
-            TColor[] target = new TColor[source.Width * source.Height];
+            TColor[] target = PixelPool<TColor>.RentPixels(source.Width * source.Height);
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(source.Width, source.Height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(source.Width, source.Height))
             {
                 Parallel.For(
                     minY,

src/ImageSharp.Processing/Processors/Effects/PixelateProcessor.cs

@@ -63,10 +63,10 @@ namespace ImageSharp.Processing.Processors
 
             // Get the range on the y-plane to choose from.
             IEnumerable<int> range = EnumerableExtensions.SteppedRange(minY, i => i < maxY, size);
-            TColor[] target = new TColor[source.Width * source.Height];
+            TColor[] target = PixelPool<TColor>.RentPixels(source.Width * source.Height);
 
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(source.Width, source.Height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(source.Width, source.Height))
             {
                 Parallel.ForEach(
                     range,

src/ImageSharp.Processing/Processors/Transforms/CompandingResizeProcessor.cs

@@ -66,8 +66,11 @@ namespace ImageSharp.Processing.Processors
             int minY = Math.Max(0, startY);
             int maxY = Math.Min(height, endY);
 
-            TColor[] target = new TColor[width * height];
+            TColor[] firstPass = null;
 
+            try
+            {
+                TColor[] target = PixelPool<TColor>.RentPixels(width * height);
                 if (this.Sampler is NearestNeighborResampler)
                 {
                     // Scaling factors
@@ -75,7 +78,7 @@ namespace ImageSharp.Processing.Processors
                     float heightFactor = sourceRectangle.Height / (float)this.ResizeRectangle.Height;
 
                     using (PixelAccessor<TColor> sourcePixels = source.Lock())
-                using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+                    using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
                     {
                         Parallel.For(
                             minY,
@@ -103,10 +106,10 @@ namespace ImageSharp.Processing.Processors
                 // A 2-pass 1D algorithm appears to be faster than splitting a 1-pass 2D algorithm
                 // First process the columns. Since we are not using multiple threads startY and endY
                 // are the upper and lower bounds of the source rectangle.
-            TColor[] firstPass = new TColor[width * source.Height];
+                firstPass = PixelPool<TColor>.RentPixels(width * source.Height);
                 using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> firstPassPixels = firstPass.Lock<TColor>(width, source.Height))
+                using (PixelAccessor<TColor> firstPassPixels = firstPass.Lock(width, source.Height))
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+                using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
                 {
                     Parallel.For(
                         0,
@@ -164,5 +167,11 @@ namespace ImageSharp.Processing.Processors
 
                 source.SetPixels(width, height, target);
             }
+            finally
+            {
+                // We don't return target or source pixels as they are handled in the image itself.
+                PixelPool<TColor>.ReturnPixels(firstPass);
+            }
+        }
     }
 }

src/ImageSharp.Processing/Processors/Transforms/CropProcessor.cs

@@ -42,10 +42,10 @@ namespace ImageSharp.Processing.Processors
             int minX = Math.Max(this.CropRectangle.X, sourceRectangle.X);
             int maxX = Math.Min(this.CropRectangle.Right, sourceRectangle.Right);
 
-            TColor[] target = new TColor[this.CropRectangle.Width * this.CropRectangle.Height];
+            TColor[] target = PixelPool<TColor>.RentPixels(this.CropRectangle.Width * this.CropRectangle.Height);
 
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(this.CropRectangle.Width, this.CropRectangle.Height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(this.CropRectangle.Width, this.CropRectangle.Height))
             {
                 Parallel.For(
                     minY,

src/ImageSharp.Processing/Processors/Transforms/FlipProcessor.cs

@@ -55,10 +55,10 @@ namespace ImageSharp.Processing.Processors
             int height = source.Height;
             int halfHeight = (int)Math.Ceiling(source.Height * .5F);
 
-            TColor[] target = new TColor[width * height];
+            TColor[] target = PixelPool<TColor>.RentPixels(width * height);
 
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
             {
                 Parallel.For(
                     0,
@@ -89,10 +89,10 @@ namespace ImageSharp.Processing.Processors
             int height = source.Height;
             int halfWidth = (int)Math.Ceiling(width * .5F);
 
-            TColor[] target = new TColor[width * height];
+            TColor[] target = PixelPool<TColor>.RentPixels(width * height);
 
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
             {
                 Parallel.For(
                     0,

src/ImageSharp.Processing/Processors/Transforms/ResizeProcessor.cs

@@ -65,8 +65,11 @@ namespace ImageSharp.Processing.Processors
             int minY = Math.Max(0, startY);
             int maxY = Math.Min(height, endY);
 
-            TColor[] target = new TColor[width * height];
+            TColor[] firstPass = null;
 
+            try
+            {
+                TColor[] target = PixelPool<TColor>.RentPixels(width * height);
                 if (this.Sampler is NearestNeighborResampler)
                 {
                     // Scaling factors
@@ -74,7 +77,7 @@ namespace ImageSharp.Processing.Processors
                     float heightFactor = sourceRectangle.Height / (float)this.ResizeRectangle.Height;
 
                     using (PixelAccessor<TColor> sourcePixels = source.Lock())
-                using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+                    using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
                     {
                         Parallel.For(
                             minY,
@@ -102,10 +105,10 @@ namespace ImageSharp.Processing.Processors
                 // A 2-pass 1D algorithm appears to be faster than splitting a 1-pass 2D algorithm
                 // First process the columns. Since we are not using multiple threads startY and endY
                 // are the upper and lower bounds of the source rectangle.
-            TColor[] firstPass = new TColor[width * source.Height];
+                firstPass = PixelPool<TColor>.RentPixels(width * source.Height);
                 using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> firstPassPixels = firstPass.Lock<TColor>(width, source.Height))
+                using (PixelAccessor<TColor> firstPassPixels = firstPass.Lock(width, source.Height))
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+                using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
                 {
                     Parallel.For(
                         0,
@@ -163,5 +166,11 @@ namespace ImageSharp.Processing.Processors
 
                 source.SetPixels(width, height, target);
             }
+            finally
+            {
+                // We don't return target or source pixels as they are handled in the image itself.
+                PixelPool<TColor>.ReturnPixels(firstPass);
+            }
+        }
     }
 }

src/ImageSharp.Processing/Processors/Transforms/RotateProcessor.cs

@@ -42,10 +42,10 @@ namespace ImageSharp.Processing.Processors
             int height = this.CanvasRectangle.Height;
             int width = this.CanvasRectangle.Width;
             Matrix3x2 matrix = this.GetCenteredMatrix(source, this.processMatrix);
-            TColor[] target = new TColor[width * height];
+            TColor[] target = PixelPool<TColor>.RentPixels(width * height);
 
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
             {
                 Parallel.For(
                     0,
@@ -124,10 +124,10 @@ namespace ImageSharp.Processing.Processors
         {
             int width = source.Width;
             int height = source.Height;
-            TColor[] target = new TColor[width * height];
+            TColor[] target = PixelPool<TColor>.RentPixels(width * height);
 
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(height, width))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(height, width))
             {
                 Parallel.For(
                     0,
@@ -156,10 +156,10 @@ namespace ImageSharp.Processing.Processors
         {
             int width = source.Width;
             int height = source.Height;
-            TColor[] target = new TColor[width * height];
+            TColor[] target = PixelPool<TColor>.RentPixels(width * height);
 
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
             {
                 Parallel.For(
                     0,
@@ -187,10 +187,10 @@ namespace ImageSharp.Processing.Processors
         {
             int width = source.Width;
             int height = source.Height;
-            TColor[] target = new TColor[width * height];
+            TColor[] target = PixelPool<TColor>.RentPixels(width * height);
 
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(height, width))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(height, width))
             {
                 Parallel.For(
                     0,

src/ImageSharp.Processing/Processors/Transforms/SkewProcessor.cs

@@ -42,10 +42,10 @@ namespace ImageSharp.Processing.Processors
             int height = this.CanvasRectangle.Height;
             int width = this.CanvasRectangle.Width;
             Matrix3x2 matrix = this.GetCenteredMatrix(source, this.processMatrix);
-            TColor[] target = new TColor[width * height];
+            TColor[] target = PixelPool<TColor>.RentPixels(width * height);
 
             using (PixelAccessor<TColor> sourcePixels = source.Lock())
-            using (PixelAccessor<TColor> targetPixels = target.Lock<TColor>(width, height))
+            using (PixelAccessor<TColor> targetPixels = target.Lock(width, height))
             {
                 Parallel.For(
                     0,

src/ImageSharp/Image/IImageBase{TColor}.cs

@@ -11,11 +11,13 @@ namespace ImageSharp
     /// Encapsulates the basic properties and methods required to manipulate images in varying formats.
     /// </summary>
     /// <typeparam name="TColor">The pixel format.</typeparam>
-    public interface IImageBase<TColor> : IImageBase
+    public interface IImageBase<TColor> : IImageBase, IDisposable
         where TColor : struct, IPackedPixel, IEquatable<TColor>
     {
         /// <summary>
         /// Gets the pixels as an array of the given packed pixel format.
+        /// Important. Due to the nature in the way this is constructed do not rely on the length
+        /// of the array for calculations. Use Width * Height.
         /// </summary>
         TColor[] Pixels { get; }
 

src/ImageSharp/Image/ImageBase{TColor}.cs

@@ -6,6 +6,7 @@
 namespace ImageSharp
 {
     using System;
+    using System.Buffers;
     using System.Diagnostics;
 
     /// <summary>
@@ -14,14 +15,30 @@ namespace ImageSharp
     /// </summary>
     /// <typeparam name="TColor">The pixel format.</typeparam>
     [DebuggerDisplay("Image: {Width}x{Height}")]
-    public abstract class ImageBase<TColor> : IImageBase<TColor>
+    public abstract class ImageBase<TColor> : IImageBase<TColor> // IImageBase implements IDisposable
         where TColor : struct, IPackedPixel, IEquatable<TColor>
     {
+        /// <summary>
+        /// The <see cref="ArrayPool{TColor}"/> used to pool data. TODO: Choose sensible default size and count
+        /// </summary>
+        private static readonly ArrayPool<TColor> ArrayPool = ArrayPool<TColor>.Create(int.MaxValue, 50);
+
         /// <summary>
         /// The image pixels
         /// </summary>
         private TColor[] pixelBuffer;
 
+        /// <summary>
+        /// A value indicating whether this instance of the given entity has been disposed.
+        /// </summary>
+        /// <value><see langword="true"/> if this instance has been disposed; otherwise, <see langword="false"/>.</value>
+        /// <remarks>
+        /// If the entity is disposed, it must not be disposed a second time. The isDisposed field is set the first time the entity
+        /// is disposed. If the isDisposed field is true, then the Dispose() method will not dispose again. This help not to prolong the entity's
+        /// life in the Garbage Collector.
+        /// </remarks>
+        private bool isDisposed;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ImageBase{TColor}"/> class.
         /// </summary>
@@ -41,7 +58,7 @@ namespace ImageSharp
         /// <param name="configuration">
         /// The configuration providing initialization code which allows extending the library.
         /// </param>
-        /// <exception cref="System.ArgumentOutOfRangeException">
+        /// <exception cref="ArgumentOutOfRangeException">
         /// Thrown if either <paramref name="width"/> or <paramref name="height"/> are less than or equal to 0.
         /// </exception>
         protected ImageBase(int width, int height, Configuration configuration = null)
@@ -67,15 +84,24 @@ namespace ImageSharp
             this.Height = other.Height;
             this.CopyProperties(other);
 
-            // Copy the pixels. Unsafe.CopyBlock gives us a nice speed boost here.
+            // Rent then copy the pixels. Unsafe.CopyBlock gives us a nice speed boost here.
-            this.pixelBuffer = new TColor[this.Width * this.Height];
+            this.RentPixels();
             using (PixelAccessor<TColor> sourcePixels = other.Lock())
             using (PixelAccessor<TColor> target = this.Lock())
             {
+                // Check we can do this without crashing
                 sourcePixels.CopyTo(target);
             }
         }
 
+        /// <summary>
+        /// Finalizes an instance of the <see cref="ImageBase{TColor}"/> class.
+        /// </summary>
+        ~ImageBase()
+        {
+            this.Dispose(false);
+        }
+
         /// <inheritdoc/>
         public int MaxWidth { get; set; } = int.MaxValue;
 
@@ -108,6 +134,19 @@ namespace ImageSharp
         /// </summary>
         public Configuration Configuration { get; private set; }
 
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            this.Dispose(true);
+
+            // This object will be cleaned up by the Dispose method.
+            // Therefore, you should call GC.SuppressFinalize to
+            // take this object off the finalization queue
+            // and prevent finalization code for this object
+            // from executing a second time.
+            GC.SuppressFinalize(this);
+        }
+
         /// <inheritdoc/>
         public void InitPixels(int width, int height)
         {
@@ -116,7 +155,7 @@ namespace ImageSharp
 
             this.Width = width;
             this.Height = height;
-            this.pixelBuffer = new TColor[width * height];
+            this.RentPixels();
         }
 
         /// <inheritdoc/>
@@ -126,13 +165,15 @@ namespace ImageSharp
             Guard.MustBeGreaterThan(height, 0, nameof(height));
             Guard.NotNull(pixels, nameof(pixels));
 
-            if (pixels.Length != width * height)
+            if (!(pixels.Length >= width * height))
             {
-                throw new ArgumentException("Pixel array must have the length of Width * Height.");
+                throw new ArgumentException($"Pixel array must have the length of at least {width * height}.");
             }
 
             this.Width = width;
             this.Height = height;
+
+            this.ReturnPixels();
             this.pixelBuffer = pixels;
         }
 
@@ -143,17 +184,18 @@ namespace ImageSharp
             Guard.MustBeGreaterThan(height, 0, nameof(height));
             Guard.NotNull(pixels, nameof(pixels));
 
-            if (pixels.Length != width * height)
+            if (!(pixels.Length >= width * height))
             {
-                throw new ArgumentException("Pixel array must have the length of Width * Height.");
+                throw new ArgumentException($"Pixel array must have the length of at least {width * height}.");
             }
 
             this.Width = width;
             this.Height = height;
 
             // Copy the pixels. TODO: use Unsafe.Copy.
-            this.pixelBuffer = new TColor[pixels.Length];
+            this.ReturnPixels();
-            Array.Copy(pixels, this.pixelBuffer, pixels.Length);
+            this.RentPixels();
+            Array.Copy(pixels, this.pixelBuffer, width * height);
         }
 
         /// <inheritdoc/>
@@ -174,5 +216,52 @@ namespace ImageSharp
             this.Quality = other.Quality;
             this.FrameDelay = other.FrameDelay;
         }
+
+        /// <summary>
+        /// Releases any unmanaged resources from the inheriting class.
+        /// </summary>
+        protected virtual void ReleaseUnmanagedResources()
+        {
+            // TODO release unmanaged resources here
+        }
+
+        /// <summary>
+        /// Disposes the object and frees resources for the Garbage Collector.
+        /// </summary>
+        /// <param name="disposing">If true, the object gets disposed.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (this.isDisposed)
+            {
+                return;
+            }
+
+            this.ReleaseUnmanagedResources();
+
+            if (disposing)
+            {
+                this.ReturnPixels();
+            }
+
+            // Note disposing is done.
+            this.isDisposed = true;
+        }
+
+        /// <summary>
+        /// Rents the pixel array from the pool.
+        /// </summary>
+        private void RentPixels()
+        {
+            this.pixelBuffer = PixelPool<TColor>.RentPixels(this.Width * this.Height);
+        }
+
+        /// <summary>
+        /// Returns the rented pixel array back to the pool.
+        /// </summary>
+        private void ReturnPixels()
+        {
+            PixelPool<TColor>.ReturnPixels(this.pixelBuffer);
+            this.pixelBuffer = null;
+        }
     }
 }

src/ImageSharp/Image/Image{TColor}.cs

@@ -334,9 +334,9 @@ namespace ImageSharp
                 target.ExifProfile = new ExifProfile(this.ExifProfile);
             }
 
-            foreach (ImageFrame<TColor> frame in this.Frames)
+            for (int i = 0; i < this.Frames.Count; i++)
             {
-                target.Frames.Add(frame.To<TColor2>());
+                target.Frames.Add(this.Frames[i].To<TColor2>());
             }
 
             return target;
@@ -372,6 +372,18 @@ namespace ImageSharp
             return new ImageFrame<TColor>(this);
         }
 
+        /// <inheritdoc />
+        protected override void Dispose(bool disposing)
+        {
+            // ReSharper disable once ForCanBeConvertedToForeach
+            for (int i = 0; i < this.Frames.Count; i++)
+            {
+                this.Frames[i].Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+
         /// <summary>
         /// Loads the image from the given stream.
         /// </summary>

src/ImageSharp/Image/PixelAccessor{TColor}.cs

@@ -76,9 +76,9 @@ namespace ImageSharp
             Guard.MustBeGreaterThan(width, 0, nameof(width));
             Guard.MustBeGreaterThan(height, 0, nameof(height));
 
-            if (pixels.Length != width * height)
+            if (!(pixels.Length >= width * height))
             {
-                throw new ArgumentException("Pixel array must have the length of Width * Height.");
+                throw new ArgumentException($"Pixel array must have the length of at least {width * height}.");
             }
 
             this.Width = width;

src/ImageSharp/Image/PixelPool{TColor}.cs

@@ -0,0 +1,50 @@
+// <copyright file="PixelPool{TColor}.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp
+{
+    using System;
+    using System.Buffers;
+
+    /// <summary>
+    /// Provides a resource pool that enables reusing instances of type <see cref="T:TColor[]"/>.
+    /// </summary>
+    /// <typeparam name="TColor">The pixel format.</typeparam>
+    public static class PixelPool<TColor>
+        where TColor : struct, IPackedPixel, IEquatable<TColor>
+    {
+        /// <summary>
+        /// The <see cref="ArrayPool{T}"/> used to pool data. TODO: Choose sensible default size and count
+        /// </summary>
+        private static readonly ArrayPool<TColor> ArrayPool = ArrayPool<TColor>.Create(int.MaxValue, 50);
+
+        /// <summary>
+        /// Rents the pixel array from the pool.
+        /// </summary>
+        /// <param name="minimumLength">The minimum length of the array to return.</param>
+        /// <returns>The <see cref="T:TColor[]"/></returns>
+        public static TColor[] RentPixels(int minimumLength)
+        {
+            return ArrayPool.Rent(minimumLength);
+        }
+
+        /// <summary>
+        /// Returns the rented pixel array back to the pool.
+        /// </summary>
+        /// <param name="array">The array to return to the buffer pool.</param>
+        public static void ReturnPixels(TColor[] array)
+        {
+            try
+            {
+                ArrayPool.Return(array, true);
+            }
+            catch
+            {
+                // Do nothing.
+                // Hacky but it allows us to attempt to return non-pooled arrays and arrays that have already been returned
+            }
+        }
+    }
+}

tests/ImageSharp.Benchmarks/Drawing/DrawBeziers.cs

@@ -47,9 +47,12 @@ namespace ImageSharp.Benchmarks
         [Benchmark(Description = "ImageSharp Draw Beziers")]
         public void DrawLinesCore()
         {
-            CoreImage image = new CoreImage(800, 800);
+            using (CoreImage image = new CoreImage(800, 800))
-
+            {
-            image.DrawBeziers(CoreColor.HotPink, 10, new[] {
+                image.DrawBeziers(
+                    CoreColor.HotPink,
+                    10,
+                    new[] {
                         new Vector2(10, 500),
                         new Vector2(30, 10),
                         new Vector2(240, 30),
@@ -62,4 +65,5 @@ namespace ImageSharp.Benchmarks
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Drawing/DrawLines.cs

@@ -46,9 +46,12 @@ namespace ImageSharp.Benchmarks
         [Benchmark(Description = "ImageSharp Draw Lines")]
         public void DrawLinesCore()
         {
-            CoreImage image = new CoreImage(800, 800);
+            using (CoreImage image = new CoreImage(800, 800))
-
+            {
-            image.DrawLines(CoreColor.HotPink, 10, new[] {
+                image.DrawLines(
+                    CoreColor.HotPink,
+                    10,
+                    new[] {
                         new Vector2(10, 10),
                         new Vector2(550, 50),
                         new Vector2(200, 400)
@@ -60,4 +63,5 @@ namespace ImageSharp.Benchmarks
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Drawing/DrawPolygon.cs

@@ -45,9 +45,12 @@ namespace ImageSharp.Benchmarks
         [Benchmark(Description = "ImageSharp Draw Polygon")]
         public void DrawPolygonCore()
         {
-            CoreImage image = new CoreImage(800, 800);
+            using (CoreImage image = new CoreImage(800, 800))
-
+            {
-            image.DrawPolygon(CoreColor.HotPink, 10, new[] {
+                image.DrawPolygon(
+                    CoreColor.HotPink,
+                    10,
+                    new[] {
                         new Vector2(10, 10),
                         new Vector2(550, 50),
                         new Vector2(200, 400)
@@ -59,4 +62,5 @@ namespace ImageSharp.Benchmarks
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Drawing/FillPolygon.cs

@@ -44,8 +44,10 @@ namespace ImageSharp.Benchmarks
         [Benchmark(Description = "ImageSharp Fill Polygon")]
         public void DrawSolidPolygonCore()
         {
-            CoreImage image = new CoreImage(800, 800);
+            using (CoreImage image = new CoreImage(800, 800))
-            image.FillPolygon(CoreColor.HotPink,
+            {
+                image.FillPolygon(
+                    CoreColor.HotPink,
                     new[] {
                         new Vector2(10, 10),
                         new Vector2(550, 50),
@@ -58,4 +60,5 @@ namespace ImageSharp.Benchmarks
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Drawing/FillRectangle.cs

@@ -28,7 +28,6 @@ namespace ImageSharp.Benchmarks
                 {
                     graphics.InterpolationMode = InterpolationMode.Default;
                     graphics.SmoothingMode = SmoothingMode.AntiAlias;
-                    var pen = new Pen(Color.HotPink, 10);
                     graphics.FillRectangle(Brushes.HotPink, new Rectangle(10, 10, 190, 140));
                 }
                 return destination.Size;
@@ -38,19 +37,22 @@ namespace ImageSharp.Benchmarks
         [Benchmark(Description = "ImageSharp Fill Rectangle")]
         public CoreSize FillRactangleCore()
         {
-            CoreImage image = new CoreImage(800, 800);
+            using (CoreImage image = new CoreImage(800, 800))
-
+            {
                 image.Fill(CoreColor.HotPink, new ImageSharp.Drawing.Shapes.RectangularPolygon(new CoreRectangle(10, 10, 190, 140)));
 
                 return new CoreSize(image.Width, image.Height);
             }
+        }
 
         [Benchmark(Description = "ImageSharp Fill Rectangle - As Polygon")]
         public CoreSize FillPolygonCore()
         {
-            CoreImage image = new CoreImage(800, 800);
+            using (CoreImage image = new CoreImage(800, 800))
-
+            {
-            image.FillPolygon(CoreColor.HotPink, new[] {
+                image.FillPolygon(
+                    CoreColor.HotPink,
+                    new[] {
                 new Vector2(10, 10),
                 new Vector2(200, 10),
                 new Vector2(200, 150),
@@ -59,4 +61,5 @@ namespace ImageSharp.Benchmarks
                 return new CoreSize(image.Width, image.Height);
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Drawing/FillWithPattern.cs

@@ -38,7 +38,8 @@ namespace ImageSharp.Benchmarks
         [Benchmark(Description = "ImageSharp Fill with Pattern")]
         public void DrawPatternPolygon3Core()
         {
-            CoreImage image = new CoreImage(800, 800);
+            using (CoreImage image = new CoreImage(800, 800))
+            {
                 image.Fill(CoreBrushes.BackwardDiagonal(CoreColor.HotPink));
 
                 using (MemoryStream ms = new MemoryStream())
@@ -47,4 +48,5 @@ namespace ImageSharp.Benchmarks
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Image/CopyPixels.cs

@@ -17,8 +17,9 @@ namespace ImageSharp.Benchmarks.Image
         [Benchmark(Description = "Copy by Pixel")]
         public CoreColor CopyByPixel()
         {
-            CoreImage source = new CoreImage(1024, 768);
+            using (CoreImage source = new CoreImage(1024, 768))
-            CoreImage target = new CoreImage(1024, 768);
+            using (CoreImage target = new CoreImage(1024, 768))
+            {
                 using (PixelAccessor<CoreColor> sourcePixels = source.Lock())
                 using (PixelAccessor<CoreColor> targetPixels = target.Lock())
                 {
@@ -38,4 +39,5 @@ namespace ImageSharp.Benchmarks.Image
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Image/DecodeBmp.cs

@@ -43,9 +43,11 @@ namespace ImageSharp.Benchmarks.Image
         {
             using (MemoryStream memoryStream = new MemoryStream(this.bmpBytes))
             {
-                CoreImage image = new CoreImage(memoryStream);
+                using (CoreImage image = new CoreImage(memoryStream))
+                {
                     return new CoreSize(image.Width, image.Height);
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Image/DecodeFilteredPng.cs

@@ -29,37 +29,40 @@ namespace ImageSharp.Benchmarks.Image
             this.filter4 = new MemoryStream(File.ReadAllBytes("../ImageSharp.Tests/TestImages/Formats/Png/filter4.png"));
         }
 
-        private Image LoadPng(MemoryStream stream)
+        private Size LoadPng(MemoryStream stream)
         {
-            return new Image(stream);
+            using (Image image = new Image(stream))
+            {
+                return new Size(image.Width, image.Height);
+            }
         }
 
         [Benchmark(Baseline = true, Description = "None-filtered PNG file")]
-        public Image PngFilter0()
+        public Size PngFilter0()
         {
             return LoadPng(filter0);
         }
 
         [Benchmark(Description = "Sub-filtered PNG file")]
-        public Image PngFilter1()
+        public Size PngFilter1()
         {
             return LoadPng(filter1);
         }
 
         [Benchmark(Description = "Up-filtered PNG file")]
-        public Image PngFilter2()
+        public Size PngFilter2()
         {
             return LoadPng(filter2);
         }
 
         [Benchmark(Description = "Average-filtered PNG file")]
-        public Image PngFilter3()
+        public Size PngFilter3()
         {
             return LoadPng(filter3);
         }
 
         [Benchmark(Description = "Paeth-filtered PNG file")]
-        public Image PngFilter4()
+        public Size PngFilter4()
         {
             return LoadPng(filter4);
         }

tests/ImageSharp.Benchmarks/Image/DecodeGif.cs

@@ -43,9 +43,11 @@ namespace ImageSharp.Benchmarks.Image
         {
             using (MemoryStream memoryStream = new MemoryStream(this.gifBytes))
             {
-                CoreImage image = new CoreImage(memoryStream);
+                using (CoreImage image = new CoreImage(memoryStream))
+                {
                     return new CoreSize(image.Width, image.Height);
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Image/DecodeJpeg.cs

@@ -43,9 +43,11 @@ namespace ImageSharp.Benchmarks.Image
         {
             using (MemoryStream memoryStream = new MemoryStream(this.jpegBytes))
             {
-                CoreImage image = new CoreImage(memoryStream);
+                using (CoreImage image = new CoreImage(memoryStream))
+                {
                     return new CoreSize(image.Width, image.Height);
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Image/DecodePng.cs

@@ -43,9 +43,11 @@ namespace ImageSharp.Benchmarks.Image
         {
             using (MemoryStream memoryStream = new MemoryStream(this.pngBytes))
             {
-                CoreImage image = new CoreImage(memoryStream);
+                using (CoreImage image = new CoreImage(memoryStream))
+                {
                     return new CoreSize(image.Width, image.Height);
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Image/EncodeBmp.cs

@@ -31,6 +31,14 @@ namespace ImageSharp.Benchmarks.Image
             }
         }
 
+        [Cleanup]
+        public void Cleanup()
+        {
+            this.bmpStream.Dispose();
+            this.bmpCore.Dispose();
+            this.bmpDrawing.Dispose();
+        }
+
         [Benchmark(Baseline = true, Description = "System.Drawing Bmp")]
         public void BmpSystemDrawing()
         {

tests/ImageSharp.Benchmarks/Image/EncodeBmpMultiple.cs

@@ -18,7 +18,7 @@ namespace ImageSharp.Benchmarks.Image
         protected override IEnumerable<string> InputImageSubfoldersOrFiles => new[] { "Bmp/", "Jpg/baseline" };
 
         [Benchmark(Description = "EncodeBmpMultiple - ImageSharp")]
-        public void EncodeGifImageSharp()
+        public void EncodeBmpImageSharp()
         {
             this.ForEachImageSharpImage(
                 (img, ms) =>
@@ -29,7 +29,7 @@ namespace ImageSharp.Benchmarks.Image
         }
 
         [Benchmark(Baseline = true, Description = "EncodeBmpMultiple - System.Drawing")]
-        public void EncodeGifSystemDrawing()
+        public void EncodeBmpSystemDrawing()
         {
             this.ForEachSystemDrawingImage(
                 (img, ms) =>

tests/ImageSharp.Benchmarks/Image/EncodeGif.cs

@@ -31,6 +31,14 @@ namespace ImageSharp.Benchmarks.Image
             }
         }
 
+        [Cleanup]
+        public void Cleanup()
+        {
+            this.bmpStream.Dispose();
+            this.bmpCore.Dispose();
+            this.bmpDrawing.Dispose();
+        }
+
         [Benchmark(Baseline = true, Description = "System.Drawing Gif")]
         public void GifSystemDrawing()
         {

tests/ImageSharp.Benchmarks/Image/EncodeJpeg.cs

@@ -31,6 +31,14 @@ namespace ImageSharp.Benchmarks.Image
             }
         }
 
+        [Cleanup]
+        public void Cleanup()
+        {
+            this.bmpStream.Dispose();
+            this.bmpCore.Dispose();
+            this.bmpDrawing.Dispose();
+        }
+
         [Benchmark(Baseline = true, Description = "System.Drawing Jpeg")]
         public void JpegSystemDrawing()
         {

tests/ImageSharp.Benchmarks/Image/EncodePng.cs

@@ -31,6 +31,14 @@ namespace ImageSharp.Benchmarks.Image
             }
         }
 
+        [Cleanup]
+        public void Cleanup()
+        {
+            this.bmpStream.Dispose();
+            this.bmpCore.Dispose();
+            this.bmpDrawing.Dispose();
+        }
+
         [Benchmark(Baseline = true, Description = "System.Drawing Png")]
         public void PngSystemDrawing()
         {

tests/ImageSharp.Benchmarks/Image/GetSetPixel.cs

@@ -28,7 +28,8 @@ namespace ImageSharp.Benchmarks.Image
         [Benchmark(Description = "ImageSharp GetSet pixel")]
         public CoreColor ResizeCore()
         {
-            CoreImage image = new CoreImage(400, 400);
+            using (CoreImage image = new CoreImage(400, 400))
+            {
                 using (PixelAccessor<CoreColor> imagePixels = image.Lock())
                 {
                     imagePixels[200, 200] = CoreColor.White;
@@ -36,4 +37,5 @@ namespace ImageSharp.Benchmarks.Image
                 }
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Samplers/Crop.cs

@@ -38,9 +38,11 @@ namespace ImageSharp.Benchmarks
         [Benchmark(Description = "ImageSharp Crop")]
         public CoreSize CropResizeCore()
         {
-            CoreImage image = new CoreImage(800, 800);
+            using (CoreImage image = new CoreImage(800, 800))
+            {
                 image.Crop(100, 100);
                 return new CoreSize(image.Width, image.Height);
             }
         }
+    }
 }

tests/ImageSharp.Benchmarks/Samplers/DetectEdges.cs

@@ -28,6 +28,12 @@ namespace ImageSharp.Benchmarks
             }
         }
 
+        [Cleanup]
+        public void Cleanup()
+        {
+            this.image.Dispose();
+        }
+
         [Benchmark(Description = "ImageSharp DetectEdges")]
         public void ImageProcessorCoreDetectEdges()
         {

tests/ImageSharp.Benchmarks/Samplers/Resize.cs

@@ -37,17 +37,21 @@ namespace ImageSharp.Benchmarks
         [Benchmark(Description = "ImageSharp Resize")]
         public CoreSize ResizeCore()
         {
-            CoreImage image = new CoreImage(2000, 2000);
+            using (CoreImage image = new CoreImage(2000, 2000))
+            {
                 image.Resize(400, 400);
                 return new CoreSize(image.Width, image.Height);
             }
+        }
 
         [Benchmark(Description = "ImageSharp Compand Resize")]
         public CoreSize ResizeCoreCompand()
         {
-            CoreImage image = new CoreImage(2000, 2000);
+            using (CoreImage image = new CoreImage(2000, 2000))
+            {
                 image.Resize(400, 400, true);
                 return new CoreSize(image.Width, image.Height);
             }
         }
+    }
 }

tests/ImageSharp.Tests/Drawing/BeziersTests.cs

@@ -15,31 +15,29 @@ namespace ImageSharp.Tests.Drawing
 
     public class Beziers : FileTestBase
     {
-
-
         [Fact]
         public void ImageShouldBeOverlayedByBezierLine()
         {
-            string path = CreateOutputDirectory("Drawing","BezierLine");
+            string path = this.CreateOutputDirectory("Drawing", "BezierLine");
-var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
-using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
+                using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
-{
+                {
-    image
+                    image.BackgroundColor(Color.Blue)
-        .BackgroundColor(Color.Blue)
+                        .DrawBeziers(Color.HotPink, 5,
-        .DrawBeziers(Color.HotPink, 5, new[] {
+                            new[] {
                                 new Vector2(10, 400),
                                 new Vector2(30, 10),
                                 new Vector2(240, 30),
                                 new Vector2(300, 400)
                             })
                         .Save(output);
-}
+                }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     //top of curve
-                Assert.Equal(Color.HotPink, sourcePixels[138,115]);
+                    Assert.Equal(Color.HotPink, sourcePixels[138, 115]);
 
                     //start points
                     Assert.Equal(Color.HotPink, sourcePixels[10, 400]);
@@ -52,24 +50,25 @@ using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                     // inside shape should be empty
                     Assert.Equal(Color.Blue, sourcePixels[200, 250]);
                 }
-
+            }
         }
 
 
         [Fact]
         public void ImageShouldBeOverlayedBezierLineWithOpacity()
         {
-            string path = CreateOutputDirectory("Drawing", "BezierLine");
+            string path = this.CreateOutputDirectory("Drawing", "BezierLine");
-
-            var color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
 
-            var image = new Image(500, 500);
+            Color color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Opacity.png"))
                 {
-                image
+                    image.BackgroundColor(Color.Blue)
-                    .BackgroundColor(Color.Blue)
+                        .DrawBeziers(color,
-                    .DrawBeziers(color, 10, new[] {
+                        10,
+                        new[] {
                             new Vector2(10, 400),
                             new Vector2(30, 10),
                             new Vector2(240, 30),
@@ -79,9 +78,9 @@ using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                 }
 
                 //shift background color towards forground color by the opacity amount
-            var mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f/255f));
+                Color mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     //top of curve
                     Assert.Equal(mergedColor, sourcePixels[138, 115]);
@@ -98,6 +97,6 @@ using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                     Assert.Equal(Color.Blue, sourcePixels[200, 250]);
                 }
             }
-        
+        }
     }
 }

tests/ImageSharp.Tests/Drawing/DrawImageTest.cs

@@ -6,7 +6,6 @@
 namespace ImageSharp.Tests
 {
     using System.IO;
-    using System.Linq;
 
     using Xunit;
 
@@ -15,14 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyDrawImageFilter()
         {
-            string path = CreateOutputDirectory("Drawing", "DrawImage");
+            string path = this.CreateOutputDirectory("Drawing", "DrawImage");
-
-            Image blend = TestFile.Create(TestImages.Bmp.Car).CreateImage();
 
+            using (Image blend = TestFile.Create(TestImages.Bmp.Car).CreateImage())
+            {
                 foreach (TestFile file in Files)
                 {
-                Image image = file.CreateImage();
+                    using (Image image = file.CreateImage())
-
+                    {
                         using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                         {
                             image.DrawImage(blend, 75, new Size(image.Width / 2, image.Height / 2), new Point(image.Width / 4, image.Height / 4))
@@ -31,4 +30,6 @@ namespace ImageSharp.Tests
                     }
                 }
             }
+        }
+    }
 }

tests/ImageSharp.Tests/Drawing/DrawPathTests.cs

@@ -20,19 +20,19 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedByPath()
         {
-            string path = CreateOutputDirectory("Drawing", "Path");
+            string path = this.CreateOutputDirectory("Drawing", "Path");
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
-            var linerSegemnt = new LinearLineSegment(
+                LinearLineSegment linerSegemnt = new LinearLineSegment(
                     new Vector2(10, 10),
                     new Vector2(200, 150),
                     new Vector2(50, 300));
-            var bazierSegment = new BezierLineSegment(new Vector2(50, 300),
+                BezierLineSegment bazierSegment = new BezierLineSegment(new Vector2(50, 300),
                     new Vector2(500, 500),
                     new Vector2(60, 10),
                     new Vector2(10, 400));
 
-            var p = new CorePath(linerSegemnt, bazierSegment);
+                CorePath p = new CorePath(linerSegemnt, bazierSegment);
 
                 using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                 {
@@ -42,7 +42,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[9, 9]);
 
@@ -50,33 +50,33 @@ namespace ImageSharp.Tests.Drawing
 
                     Assert.Equal(Color.Blue, sourcePixels[50, 50]);
                 }
-
+            }
         }
 
 
         [Fact]
         public void ImageShouldBeOverlayedPathWithOpacity()
         {
-            string path = CreateOutputDirectory("Drawing", "Path");
+            string path = this.CreateOutputDirectory("Drawing", "Path");
 
-            var color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
+            Color color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
 
 
-            var linerSegemnt = new LinearLineSegment(
+            LinearLineSegment linerSegemnt = new LinearLineSegment(
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
                     );
-            var bazierSegment = new BezierLineSegment(new Vector2(50, 300),
+
+            BezierLineSegment bazierSegment = new BezierLineSegment(new Vector2(50, 300),
                 new Vector2(500, 500),
                 new Vector2(60, 10),
                 new Vector2(10, 400));
 
-            var p = new CorePath(linerSegemnt, bazierSegment);
+            CorePath p = new CorePath(linerSegemnt, bazierSegment);
-
-            var image = new Image(500, 500);
-
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Opacity.png"))
                 {
                     image
@@ -86,9 +86,9 @@ namespace ImageSharp.Tests.Drawing
                 }
 
                 //shift background color towards forground color by the opacity amount
-            var mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
+                Color mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(mergedColor, sourcePixels[9, 9]);
 
@@ -97,6 +97,7 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[50, 50]);
                 }
             }
+        }
 
     }
 }

tests/ImageSharp.Tests/Drawing/FillPatternTests.cs

@@ -15,10 +15,11 @@ namespace ImageSharp.Tests.Drawing
 
     public class FillPatternBrushTests : FileTestBase
     {
-        private Image Test(string name, Color background, IBrush<Color> brush, Color[,] expectedPattern)
+        private void Test(string name, Color background, IBrush<Color> brush, Color[,] expectedPattern)
+        {
+            string path = this.CreateOutputDirectory("Fill", "PatternBrush");
+            using (Image image = new Image(20, 20))
             {
-            string path = CreateOutputDirectory("Fill", "PatternBrush");
-            Image image = new Image(20, 20);
                 image
                     .Fill(background)
                     .Fill(brush);
@@ -27,22 +28,23 @@ namespace ImageSharp.Tests.Drawing
                 {
                     image.Save(output);
                 }
-            using (var sourcePixels = image.Lock())
+
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     // lets pick random spots to start checking
-                var r = new Random();
+                    Random r = new Random();
-                var xStride = expectedPattern.GetLength(1);
+                    int xStride = expectedPattern.GetLength(1);
-                var yStride = expectedPattern.GetLength(0);
+                    int yStride = expectedPattern.GetLength(0);
-                var offsetX = r.Next(image.Width / xStride) * xStride;
+                    int offsetX = r.Next(image.Width / xStride) * xStride;
-                var offsetY = r.Next(image.Height / yStride) * yStride;
+                    int offsetY = r.Next(image.Height / yStride) * yStride;
-                for (var x = 0; x < xStride; x++)
+                    for (int x = 0; x < xStride; x++)
-                {
+                    {
-                    for (var y = 0; y < yStride; y++)
+                        for (int y = 0; y < yStride; y++)
-                    {
+                        {
-                        var actualX = x + offsetX;
+                            int actualX = x + offsetX;
-                        var actualY = y + offsetY;
+                            int actualY = y + offsetY;
-                        var expected = expectedPattern[y, x]; // inverted pattern
+                            Color expected = expectedPattern[y, x]; // inverted pattern
-                        var actual = sourcePixels[actualX, actualY];
+                            Color actual = sourcePixels[actualX, actualY];
                             if (expected != actual)
                             {
                                 Assert.True(false, $"Expected {expected} but found {actual} at ({actualX},{actualY})");
@@ -54,16 +56,15 @@ namespace ImageSharp.Tests.Drawing
                 {
                     image.Resize(80, 80).Save(output);
                 }
-
+            }
-
-
-            return image;
         }
 
         [Fact]
         public void ImageShouldBeFloodFilledWithPercent10()
         {
-            Test("Percent10", Color.Blue, Brushes.Percent10(Color.HotPink, Color.LimeGreen), new Color[,] {
+            this.Test("Percent10", Color.Blue, Brushes.Percent10(Color.HotPink, Color.LimeGreen),
+                new[,]
+                {
                 { Color.HotPink , Color.LimeGreen, Color.LimeGreen, Color.LimeGreen},
                 { Color.LimeGreen, Color.LimeGreen, Color.LimeGreen, Color.LimeGreen},
                 { Color.LimeGreen, Color.LimeGreen, Color.HotPink , Color.LimeGreen},

tests/ImageSharp.Tests/Drawing/FillSolidBrushTests.cs

@@ -18,9 +18,9 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeFloodFilledWithColorOnDefaultBackground()
         {
-            string path = CreateOutputDirectory("Fill", "SolidBrush");
+            string path = this.CreateOutputDirectory("Fill", "SolidBrush");
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/DefaultBack.png"))
                 {
                     image
@@ -28,20 +28,21 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[9, 9]);
 
                     Assert.Equal(Color.HotPink, sourcePixels[199, 149]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeFloodFilledWithColor()
         {
-            string path = CreateOutputDirectory("Fill", "SolidBrush");
+            string path = this.CreateOutputDirectory("Fill", "SolidBrush");
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                 {
                     image
@@ -50,21 +51,22 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[9, 9]);
 
                     Assert.Equal(Color.HotPink, sourcePixels[199, 149]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeFloodFilledWithColorOpacity()
         {
-            string path = CreateOutputDirectory("Fill", "SolidBrush");
+            string path = this.CreateOutputDirectory("Fill", "SolidBrush");
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
-            var color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
+                Color color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
 
                 using (FileStream output = File.OpenWrite($"{path}/Opacity.png"))
                 {
@@ -74,15 +76,15 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
                 //shift background color towards forground color by the opacity amount
-            var mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
+                Color mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
 
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(mergedColor, sourcePixels[9, 9]);
                     Assert.Equal(mergedColor, sourcePixels[199, 149]);
                 }
-
+            }
         }
 
     }

tests/ImageSharp.Tests/Drawing/LineComplexPolygonTests.cs

@@ -5,12 +5,9 @@
 
 namespace ImageSharp.Tests.Drawing
 {
-    using System;
-    using System.Diagnostics.CodeAnalysis;
     using System.IO;
     using Xunit;
-    using Drawing;
+
-    using ImageSharp.Drawing;
     using System.Numerics;
     using ImageSharp.Drawing.Shapes;
     using ImageSharp.Drawing.Pens;
@@ -20,19 +17,19 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedByPolygonOutline()
         {
-            string path = CreateOutputDirectory("Drawing", "LineComplexPolygon");
+            string path = this.CreateOutputDirectory("Drawing", "LineComplexPolygon");
-            var simplePath = new LinearPolygon(
+            LinearPolygon simplePath = new LinearPolygon(
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300));
 
-            var hole1 = new LinearPolygon(
+            LinearPolygon hole1 = new LinearPolygon(
                             new Vector2(37, 85),
                             new Vector2(93, 85),
                             new Vector2(65, 137));
 
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                 {
                     image
@@ -41,7 +38,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[10, 10]);
 
@@ -65,23 +62,24 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[100, 192]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeOverlayedByPolygonOutlineNoOverlapping()
         {
-            string path = CreateOutputDirectory("Drawing", "LineComplexPolygon");
+            string path = this.CreateOutputDirectory("Drawing", "LineComplexPolygon");
-            var simplePath = new LinearPolygon(
+            LinearPolygon simplePath = new LinearPolygon(
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300));
 
-            var hole1 = new LinearPolygon(
+            LinearPolygon hole1 = new LinearPolygon(
                             new Vector2(207, 25),
                             new Vector2(263, 25),
                             new Vector2(235, 57));
 
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/SimpleVanishHole.png"))
                 {
                     image
@@ -90,7 +88,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[10, 10]);
 
@@ -114,24 +112,25 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[100, 192]);
                 }
             }
+        }
 
 
         [Fact]
         public void ImageShouldBeOverlayedByPolygonOutlineOverlapping()
         {
-            string path = CreateOutputDirectory("Drawing", "LineComplexPolygon");
+            string path = this.CreateOutputDirectory("Drawing", "LineComplexPolygon");
-            var simplePath = new LinearPolygon(
+            LinearPolygon simplePath = new LinearPolygon(
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300));
 
-            var hole1 = new LinearPolygon(
+            LinearPolygon hole1 = new LinearPolygon(
                             new Vector2(37, 85),
                             new Vector2(130, 40),
                             new Vector2(65, 137));
 
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/SimpleOverlapping.png"))
                 {
                     image
@@ -140,7 +139,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[10, 10]);
 
@@ -159,24 +158,25 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[100, 192]);
                 }
             }
+        }
 
 
         [Fact]
         public void ImageShouldBeOverlayedByPolygonOutlineDashed()
         {
-            string path = CreateOutputDirectory("Drawing", "LineComplexPolygon");
+            string path = this.CreateOutputDirectory("Drawing", "LineComplexPolygon");
-            var simplePath = new LinearPolygon(
+            LinearPolygon simplePath = new LinearPolygon(
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300));
 
-            var hole1 = new LinearPolygon(
+            LinearPolygon hole1 = new LinearPolygon(
                             new Vector2(37, 85),
                             new Vector2(93, 85),
                             new Vector2(65, 137));
 
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Dashed.png"))
                 {
                     image
@@ -185,25 +185,26 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
             }
+        }
 
 
         [Fact]
         public void ImageShouldBeOverlayedPolygonOutlineWithOpacity()
         {
-            string path = CreateOutputDirectory("Drawing", "LineComplexPolygon");
+            string path = this.CreateOutputDirectory("Drawing", "LineComplexPolygon");
-            var simplePath = new LinearPolygon(
+            LinearPolygon simplePath = new LinearPolygon(
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300));
 
-            var hole1 = new LinearPolygon(
+            LinearPolygon hole1 = new LinearPolygon(
                             new Vector2(37, 85),
                             new Vector2(93, 85),
                             new Vector2(65, 137));
-            var color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
+            Color color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
-
-            var image = new Image(500, 500);
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Opacity.png"))
                 {
                     image
@@ -213,9 +214,9 @@ namespace ImageSharp.Tests.Drawing
                 }
 
                 //shift background color towards forground color by the opacity amount
-            var mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
+                Color mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(mergedColor, sourcePixels[10, 10]);
 
@@ -241,4 +242,5 @@ namespace ImageSharp.Tests.Drawing
                 }
             }
         }
+    }
 }

tests/ImageSharp.Tests/Drawing/LineTests.cs

@@ -5,11 +5,9 @@
 
 namespace ImageSharp.Tests.Drawing
 {
-    using Drawing;
     using ImageSharp.Drawing;
     using ImageSharp.Drawing.Pens;
-    using System;
+
-    using System.Diagnostics.CodeAnalysis;
     using System.IO;
     using System.Numerics;
     using Xunit;
@@ -19,14 +17,15 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedByPath()
         {
-            string path = CreateOutputDirectory("Drawing", "Lines");
+            string path = this.CreateOutputDirectory("Drawing", "Lines");
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                 {
                     image
                         .BackgroundColor(Color.Blue)
-                    .DrawLines(Color.HotPink, 5, new[] {
+                        .DrawLines(Color.HotPink, 5,
+                        new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
@@ -34,7 +33,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[9, 9]);
 
@@ -43,26 +42,29 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[50, 50]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeOverlayedByPath_NoAntialias()
         {
-            string path = CreateOutputDirectory("Drawing", "Lines");
+            string path = this.CreateOutputDirectory("Drawing", "Lines");
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Simple_noantialias.png"))
                 {
                     image
                         .BackgroundColor(Color.Blue)
-                    .DrawLines(Color.HotPink, 5, new[] {
+                        .DrawLines(Color.HotPink, 5,
+                        new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
-                    }, new GraphicsOptions(false))
+                        },
+                        new GraphicsOptions(false))
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[9, 9]);
 
@@ -71,38 +73,41 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[50, 50]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeOverlayedByPathDashed()
         {
-            string path = CreateOutputDirectory("Drawing", "Lines");
+            string path = this.CreateOutputDirectory("Drawing", "Lines");
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Dashed.png"))
                 {
                     image
                         .BackgroundColor(Color.Blue)
-                    .DrawLines(Pens.Dash(Color.HotPink, 5), new[] {
+                        .DrawLines(Pens.Dash(Color.HotPink, 5),
+                        new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
                         })
                         .Save(output);
                 }
-
+            }
         }
 
         [Fact]
         public void ImageShouldBeOverlayedByPathDotted()
         {
-            string path = CreateOutputDirectory("Drawing", "Lines");
+            string path = this.CreateOutputDirectory("Drawing", "Lines");
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Dot.png"))
                 {
                     image
                         .BackgroundColor(Color.Blue)
-                    .DrawLines(Pens.Dot(Color.HotPink, 5), new[] {
+                        .DrawLines(Pens.Dot(Color.HotPink, 5),
+                        new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
@@ -110,32 +115,34 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeOverlayedByPathDashDot()
         {
-            string path = CreateOutputDirectory("Drawing", "Lines");
+            string path = this.CreateOutputDirectory("Drawing", "Lines");
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/DashDot.png"))
                 {
                     image
                         .BackgroundColor(Color.Blue)
-                    .DrawLines(Pens.DashDot(Color.HotPink, 5), new[] {
+                        .DrawLines(Pens.DashDot(Color.HotPink, 5),
+                        new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
                         })
                         .Save(output);
                 }
-
+            }
         }
 
         [Fact]
         public void ImageShouldBeOverlayedByPathDashDotDot()
         {
-            string path = CreateOutputDirectory("Drawing", "Lines");
+            string path = this.CreateOutputDirectory("Drawing", "Lines");
-            var image = new Image(500, 500);
+            Image image = new Image(500, 500);
 
             using (FileStream output = File.OpenWrite($"{path}/DashDotDot.png"))
             {
@@ -153,11 +160,11 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedPathWithOpacity()
         {
-            string path = CreateOutputDirectory("Drawing", "Lines");
+            string path = this.CreateOutputDirectory("Drawing", "Lines");
 
-            var color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
+            Color color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
 
-            var image = new Image(500, 500);
+            Image image = new Image(500, 500);
 
 
             using (FileStream output = File.OpenWrite($"{path}/Opacity.png"))
@@ -173,9 +180,9 @@ namespace ImageSharp.Tests.Drawing
             }
 
             //shift background color towards forground color by the opacity amount
-            var mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f/255f));
+            Color mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f/255f));
 
-            using (var sourcePixels = image.Lock())
+            using (PixelAccessor<Color> sourcePixels = image.Lock())
             {
                 Assert.Equal(mergedColor, sourcePixels[9, 9]);
 
@@ -188,9 +195,9 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedByPathOutline()
         {
-            string path = CreateOutputDirectory("Drawing", "Lines");
+            string path = this.CreateOutputDirectory("Drawing", "Lines");
 
-            var image = new Image(500, 500);
+            Image image = new Image(500, 500);
 
             using (FileStream output = File.OpenWrite($"{path}/Rectangle.png"))
             {
@@ -205,7 +212,7 @@ namespace ImageSharp.Tests.Drawing
                     .Save(output);
             }
 
-            using (var sourcePixels = image.Lock())
+            using (PixelAccessor<Color> sourcePixels = image.Lock())
             {
                 Assert.Equal(Color.HotPink, sourcePixels[8, 8]);
 

tests/ImageSharp.Tests/Drawing/PolygonTests.cs

@@ -18,15 +18,16 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedByPolygonOutline()
         {
-            string path = CreateOutputDirectory("Drawing", "Polygons");
+            string path = this.CreateOutputDirectory("Drawing", "Polygons");
-
-            var image = new Image(500, 500);
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                 {
                     image
                         .BackgroundColor(Color.Blue)
-                    .DrawPolygon(Color.HotPink, 5, new[] {
+                        .DrawPolygon(Color.HotPink, 5,
+                        new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
@@ -34,7 +35,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[9, 9]);
 
@@ -45,21 +46,22 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[2, 2]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeOverlayedPolygonOutlineWithOpacity()
         {
-            string path = CreateOutputDirectory("Drawing", "Polygons");
+            string path = this.CreateOutputDirectory("Drawing", "Polygons");
-            var simplePath = new[] {
+            Vector2[] simplePath = new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
             };
 
-            var color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
+            Color color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
-
-            var image = new Image(500, 500);
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Opacity.png"))
                 {
                     image
@@ -69,9 +71,9 @@ namespace ImageSharp.Tests.Drawing
                 }
 
                 //shift background color towards forground color by the opacity amount
-            var mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
+                Color mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(mergedColor, sourcePixels[9, 9]);
 
@@ -82,14 +84,15 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[2, 2]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeOverlayedByRectangleOutline()
         {
-            string path = CreateOutputDirectory("Drawing", "Polygons");
+            string path = this.CreateOutputDirectory("Drawing", "Polygons");
-
-            var image = new Image(500, 500);
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Rectangle.png"))
                 {
                     image
@@ -98,7 +101,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[8, 8]);
 
@@ -112,4 +115,5 @@ namespace ImageSharp.Tests.Drawing
                 }
             }
         }
+    }
 }

tests/ImageSharp.Tests/Drawing/RecolorImageTest.cs

@@ -16,14 +16,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldRecolorYellowToHotPink()
         {
-            string path = CreateOutputDirectory("Drawing", "RecolorImage");
+            string path = this.CreateOutputDirectory("Drawing", "RecolorImage");
 
-            var brush = new RecolorBrush(Color.Yellow, Color.HotPink, 0.2f);
+            RecolorBrush brush = new RecolorBrush(Color.Yellow, Color.HotPink, 0.2f);
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
+                {
                     using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                     {
                         image.Fill(brush)
@@ -31,25 +31,27 @@ namespace ImageSharp.Tests
                     }
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldRecolorYellowToHotPinkInARectangle()
         {
-            string path = CreateOutputDirectory("Drawing", "RecolorImage");
+            string path = this.CreateOutputDirectory("Drawing", "RecolorImage");
 
-            var brush = new RecolorBrush(Color.Yellow, Color.HotPink, 0.2f);
+            RecolorBrush brush = new RecolorBrush(Color.Yellow, Color.HotPink, 0.2f);
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
+                {
                     using (FileStream output = File.OpenWrite($"{path}/Shaped_{file.FileName}"))
                     {
-                    var imageHeight = image.Height;
+                        int imageHeight = image.Height;
                         image.Fill(brush, new Rectangle(0, imageHeight/2 - imageHeight/4, image.Width, imageHeight/2))
                             .Save(output);
                     }
                 }
             }
         }
+    }
 }

tests/ImageSharp.Tests/Drawing/SolidBezierTests.cs

@@ -5,11 +5,8 @@
 
 namespace ImageSharp.Tests.Drawing
 {
-    using Drawing;
-    using ImageSharp.Drawing;
     using ImageSharp.Drawing.Shapes;
-    using System;
+
-    using System.Diagnostics.CodeAnalysis;
     using System.IO;
     using System.Numerics;
     using Xunit;
@@ -19,15 +16,15 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedByFilledPolygon()
         {
-            string path = CreateOutputDirectory("Drawing", "FilledBezier");
+            string path = this.CreateOutputDirectory("Drawing", "FilledBezier");
-            var simplePath = new[] {
+            Vector2[] simplePath = new[] {
                         new Vector2(10, 400),
                         new Vector2(30, 10),
                         new Vector2(240, 30),
                         new Vector2(300, 400)
             };
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                 {
                     image
@@ -36,7 +33,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     //top of curve
                     Assert.Equal(Color.HotPink, sourcePixels[138, 116]);
@@ -53,21 +50,22 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.HotPink, sourcePixels[200, 250]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeOverlayedByFilledPolygonOpacity()
         {
-            string path = CreateOutputDirectory("Drawing", "FilledBezier");
+            string path = this.CreateOutputDirectory("Drawing", "FilledBezier");
-            var simplePath = new[] {
+            Vector2[] simplePath = new[] {
                         new Vector2(10, 400),
                         new Vector2(30, 10),
                         new Vector2(240, 30),
                         new Vector2(300, 400)
             };
-            var color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
+            Color color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
-
-            var image = new Image(500, 500);
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Opacity.png"))
                 {
                     image
@@ -77,9 +75,9 @@ namespace ImageSharp.Tests.Drawing
                 }
 
                 //shift background color towards forground color by the opacity amount
-            var mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
+                Color mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     //top of curve
                     Assert.Equal(mergedColor, sourcePixels[138, 116]);
@@ -96,6 +94,6 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(mergedColor, sourcePixels[200, 250]);
                 }
             }
-        
+        }
     }
 }

tests/ImageSharp.Tests/Drawing/SolidComplexPolygonTests.cs

@@ -5,12 +5,9 @@
 
 namespace ImageSharp.Tests.Drawing
 {
-    using System;
-    using System.Diagnostics.CodeAnalysis;
     using System.IO;
     using Xunit;
-    using Drawing;
+
-    using ImageSharp.Drawing;
     using System.Numerics;
     using ImageSharp.Drawing.Shapes;
 
@@ -19,19 +16,19 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedByPolygonOutline()
         {
-            string path = CreateOutputDirectory("Drawing", "ComplexPolygon");
+            string path = this.CreateOutputDirectory("Drawing", "ComplexPolygon");
-            var simplePath = new LinearPolygon(
+            LinearPolygon simplePath = new LinearPolygon(
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300));
 
-            var hole1 = new LinearPolygon(
+            LinearPolygon hole1 = new LinearPolygon(
                             new Vector2(37, 85),
                             new Vector2(93, 85),
                             new Vector2(65, 137));
 
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                 {
                     image
@@ -40,7 +37,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[11, 11]);
 
@@ -56,24 +53,25 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[57, 99]);
                 }
             }
+        }
 
 
         [Fact]
         public void ImageShouldBeOverlayedPolygonOutlineWithOverlap()
         {
-            string path = CreateOutputDirectory("Drawing", "ComplexPolygon");
+            string path = this.CreateOutputDirectory("Drawing", "ComplexPolygon");
-            var simplePath = new LinearPolygon(
+            LinearPolygon simplePath = new LinearPolygon(
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300));
 
-            var hole1 = new LinearPolygon(
+            LinearPolygon hole1 = new LinearPolygon(
                             new Vector2(37, 85),
                             new Vector2(130, 40),
                             new Vector2(65, 137));
 
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
+            {
                 using (FileStream output = File.OpenWrite($"{path}/SimpleOverlapping.png"))
                 {
                     image
@@ -82,7 +80,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[11, 11]);
 
@@ -98,24 +96,25 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[57, 99]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeOverlayedPolygonOutlineWithOpacity()
         {
-            string path = CreateOutputDirectory("Drawing", "ComplexPolygon");
+            string path = this.CreateOutputDirectory("Drawing", "ComplexPolygon");
-            var simplePath = new LinearPolygon(
+            LinearPolygon simplePath = new LinearPolygon(
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300));
 
-            var hole1 = new LinearPolygon(
+            LinearPolygon hole1 = new LinearPolygon(
                             new Vector2(37, 85),
                             new Vector2(93, 85),
                             new Vector2(65, 137));
-            var color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
+            Color color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
-
-            var image = new Image(500, 500);
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Opacity.png"))
                 {
                     image
@@ -125,9 +124,9 @@ namespace ImageSharp.Tests.Drawing
                 }
 
                 //shift background color towards forground color by the opacity amount
-            var mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
+                Color mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(mergedColor, sourcePixels[11, 11]);
 
@@ -144,4 +143,5 @@ namespace ImageSharp.Tests.Drawing
                 }
             }
         }
+    }
 }

tests/ImageSharp.Tests/Drawing/SolidPolygonTests.cs

@@ -5,10 +5,8 @@
 
 namespace ImageSharp.Tests.Drawing
 {
-    using Drawing;
     using ImageSharp.Drawing;
-    using System;
+
-    using System.Diagnostics.CodeAnalysis;
     using System.IO;
     using System.Numerics;
     using Xunit;
@@ -19,14 +17,15 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedByFilledPolygon()
         {
-            string path = CreateOutputDirectory("Drawing", "FilledPolygons");
+            string path = this.CreateOutputDirectory("Drawing", "FilledPolygons");
-            var simplePath = new[] {
+            Vector2[] simplePath = new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
             };
-            var image = new Image(500, 500);
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Simple.png"))
                 {
                     image
@@ -35,7 +34,7 @@ namespace ImageSharp.Tests.Drawing
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[11, 11]);
 
@@ -46,27 +45,27 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[2, 2]);
                 }
             }
+        }
 
         [Fact]
-        public void ImageShouldBeOverlayedByFilledPolygon_NoAntialias()
+        public void ImageShouldBeOverlayedByFilledPolygonNoAntialias()
         {
-            string path = CreateOutputDirectory("Drawing", "FilledPolygons");
+            string path = this.CreateOutputDirectory("Drawing", "FilledPolygons");
-            var simplePath = new[] {
+            Vector2[] simplePath = new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
             };
-            var image = new Image(500, 500);
 
+            using (Image image = new Image(500, 500))
             using (FileStream output = File.OpenWrite($"{path}/Simple_NoAntialias.png"))
             {
                 image
                     .BackgroundColor(Color.Blue)
                     .FillPolygon(Color.HotPink, simplePath, new GraphicsOptions(false))
                     .Save(output);
-            }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[11, 11]);
 
@@ -77,22 +76,24 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[2, 2]);
                 }
             }
+        }
 
         [Fact]
-        public void ImageShouldBeOverlayedByFilledPolygon_Image()
+        public void ImageShouldBeOverlayedByFilledPolygonImage()
         {
-            string path = CreateOutputDirectory("Drawing", "FilledPolygons");
+            string path = this.CreateOutputDirectory("Drawing", "FilledPolygons");
-            var simplePath = new[] {
+            Vector2[] simplePath = new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
             };
 
-            var brush = new ImageBrush(TestFile.Create(TestImages.Bmp.Car).CreateImage());
+            using (Image brushImage = TestFile.Create(TestImages.Bmp.Car).CreateImage())
-            var image = new Image(500, 500);
+            using (Image image = new Image(500, 500))
-
             using (FileStream output = File.OpenWrite($"{path}/Image.png"))
             {
+                ImageBrush brush = new ImageBrush(brushImage);
+
                 image
                 .BackgroundColor(Color.Blue)
                 .FillPolygon(brush, simplePath)
@@ -103,16 +104,16 @@ namespace ImageSharp.Tests.Drawing
         [Fact]
         public void ImageShouldBeOverlayedByFilledPolygonOpacity()
         {
-            string path = CreateOutputDirectory("Drawing", "FilledPolygons");
+            string path = this.CreateOutputDirectory("Drawing", "FilledPolygons");
-            var simplePath = new[] {
+            Vector2[] simplePath = new[] {
                             new Vector2(10, 10),
                             new Vector2(200, 150),
                             new Vector2(50, 300)
             };
-            var color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
+            Color color = new Color(Color.HotPink.R, Color.HotPink.G, Color.HotPink.B, 150);
-
-            var image = new Image(500, 500);
 
+            using (Image image = new Image(500, 500))
+            {
                 using (FileStream output = File.OpenWrite($"{path}/Opacity.png"))
                 {
                     image
@@ -122,9 +123,9 @@ namespace ImageSharp.Tests.Drawing
                 }
 
                 //shift background color towards forground color by the opacity amount
-            var mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
+                Color mergedColor = new Color(Vector4.Lerp(Color.Blue.ToVector4(), Color.HotPink.ToVector4(), 150f / 255f));
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(mergedColor, sourcePixels[11, 11]);
 
@@ -135,29 +136,23 @@ namespace ImageSharp.Tests.Drawing
                     Assert.Equal(Color.Blue, sourcePixels[2, 2]);
                 }
             }
+        }
 
         [Fact]
         public void ImageShouldBeOverlayedByFilledRectangle()
         {
-            string path = CreateOutputDirectory("Drawing", "FilledPolygons");
+            string path = this.CreateOutputDirectory("Drawing", "FilledPolygons");
-            var simplePath = new[] {
+            using (Image image = new Image(500, 500))
-                            new Vector2(10, 10),
+            {
-                            new Vector2(200, 10),
-                            new Vector2(200, 150),
-                            new Vector2(10, 150)
-                            };
-
-            var image = new Image(500, 500);
-
                 using (FileStream output = File.OpenWrite($"{path}/Rectangle.png"))
                 {
                     image
                         .BackgroundColor(Color.Blue)
-                    .Fill(Color.HotPink, new ImageSharp.Drawing.Shapes.RectangularPolygon(new Rectangle(10,10, 190, 140)))
+                        .Fill(Color.HotPink, new ImageSharp.Drawing.Shapes.RectangularPolygon(new Rectangle(10, 10, 190, 140)))
                         .Save(output);
                 }
 
-            using (var sourcePixels = image.Lock())
+                using (PixelAccessor<Color> sourcePixels = image.Lock())
                 {
                     Assert.Equal(Color.HotPink, sourcePixels[11, 11]);
 
@@ -171,4 +166,5 @@ namespace ImageSharp.Tests.Drawing
                 }
             }
         }
+    }
 }

tests/ImageSharp.Tests/Formats/Bmp/BitmapTests.cs

@@ -9,8 +9,6 @@ namespace ImageSharp.Tests
 {
     using System.IO;
 
-    using Formats;
-
     using Xunit;
 
     public class BitmapTests : FileTestBase
@@ -23,16 +21,16 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("BitsPerPixel")]
+        [MemberData(nameof(BitsPerPixel))]
         public void BitmapCanEncodeDifferentBitRates(BmpBitsPerPixel bitsPerPixel)
         {
-            string path = CreateOutputDirectory("Bmp");
+            string path = this.CreateOutputDirectory("Bmp");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileNameWithoutExtension(bitsPerPixel);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
+                {
                     using (FileStream output = File.OpenWrite($"{path}/{filename}.bmp"))
                     {
                         image.Save(output, new BmpEncoder { BitsPerPixel = bitsPerPixel });
@@ -40,4 +38,5 @@ namespace ImageSharp.Tests
                 }
             }
         }
+    }
 }

tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs

@@ -16,12 +16,12 @@ namespace ImageSharp.Tests
         [Fact]
         public void ResolutionShouldChange()
         {
-            string path = CreateOutputDirectory("Resolution");
+            string path = this.CreateOutputDirectory("Resolution");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
+                {
                     using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                     {
                         image.VerticalResolution = 150;
@@ -30,65 +30,51 @@ namespace ImageSharp.Tests
                     }
                 }
             }
+        }
 
         [Fact]
         public void ImageCanEncodeToString()
         {
-            string path = CreateOutputDirectory("ToString");
+            string path = this.CreateOutputDirectory("ToString");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
+                {
                     string filename = path + "/" + file.FileNameWithoutExtension + ".txt";
                     File.WriteAllText(filename, image.ToBase64String());
                 }
             }
+        }
 
         [Fact]
         public void DecodeThenEncodeImageFromStreamShouldSucceed()
         {
-            string path = CreateOutputDirectory("Encode");
+            string path = this.CreateOutputDirectory("Encode");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
+                {
-                //Image<Bgr565> image = file.CreateImage().To<Bgr565>();
-                //Image<Bgra4444> image = file.CreateImage().To<Bgra4444>();
-                //Image<Bgra5551> image = file.CreateImage().To<Bgra5551>();
-                //Image<Byte4> image = file.CreateImage().To<Byte4>();
-                //Image<HalfSingle> image = file.CreateImage().To<HalfSingle>();
-                //Image<HalfVector2> image = file.CreateImage().To<HalfVector2>();
-                //Image<HalfVector4> image = file.CreateImage().To<HalfVector4>();
-                //Image<Rg32> image = file.CreateImage().To<Rg32>();
-                //Image<Rgba1010102> image = file.CreateImage().To<Rgba1010102>();
-                //Image<Rgba64> image = file.CreateImage().To<Rgba64>();
-                //Image<NormalizedByte2> image = file.CreateImage().To<NormalizedByte2>();
-                //Image<NormalizedByte4> image = file.CreateImage().To<NormalizedByte4>();
-                //Image<NormalizedShort2> image = file.CreateImage().To<NormalizedShort2>();
-                //Image<NormalizedShort4> image = file.CreateImage().To<NormalizedShort4>();
-                //Image<Short2> image = file.CreateImage().To<Short2>();
-                //Image<Short4> image = file.CreateImage().To<Short4>();
                     using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                     {
                         image.Save(output);
                     }
                 }
             }
+        }
 
         [Fact]
         public void QuantizeImageShouldPreserveMaximumColorPrecision()
         {
-            string path = CreateOutputDirectory("Quantize");
+            string path = this.CreateOutputDirectory("Quantize");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
+                {
-                // Copy the original pixels to save decoding time.
                     Color[] pixels = new Color[image.Width * image.Height];
-                Array.Copy(image.Pixels, pixels, image.Pixels.Length);
+                    Array.Copy(image.Pixels, pixels, image.Width * image.Height);
 
                     using (FileStream output = File.OpenWrite($"{path}/Octree-{file.FileName}"))
                     {
@@ -112,11 +98,12 @@ namespace ImageSharp.Tests
                     }
                 }
             }
+        }
 
         [Fact]
         public void ImageCanConvertFormat()
         {
-            string path = CreateOutputDirectory("Format");
+            string path = this.CreateOutputDirectory("Format");
 
             foreach (TestFile file in Files)
             {
@@ -147,7 +134,7 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldPreservePixelByteOrderWhenSerialized()
         {
-            string path = CreateOutputDirectory("Serialized");
+            string path = this.CreateOutputDirectory("Serialized");
 
             foreach (TestFile file in Files)
             {

tests/ImageSharp.Tests/Formats/Jpg/BadEofJpegTests.cs

@@ -31,19 +31,23 @@ namespace ImageSharp.Tests
         public void LoadBaselineImage<TColor>(TestImageProvider<TColor> provider)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            var image = provider.GetImage();
+            using (Image<TColor> image = provider.GetImage())
+            {
                 Assert.NotNull(image);
                 provider.Utility.SaveTestOutputFile(image, "bmp");
             }
+        }
 
         [Theory] // TODO: #18
         [WithFile(TestImages.Jpeg.Progressive.Bad.BadEOF, PixelTypes.Color)]
         public void LoadProgressiveImage<TColor>(TestImageProvider<TColor> provider)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            var image = provider.GetImage();
+            using (Image<TColor> image = provider.GetImage())
+            {
                 Assert.NotNull(image);
                 provider.Utility.SaveTestOutputFile(image, "bmp");
             }
         }
+    }
 }

tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs

@@ -29,20 +29,22 @@ namespace ImageSharp.Tests
         public void OpenBaselineJpeg_SaveBmp<TColor>(TestImageProvider<TColor> provider)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            Image<TColor> image = provider.GetImage();
+            using (Image<TColor> image = provider.GetImage())
-
+            {
                 provider.Utility.SaveTestOutputFile(image, "bmp");
             }
+        }
 
         [Theory]
         [WithFileCollection(nameof(ProgressiveTestJpegs), PixelTypes.Color | PixelTypes.StandardImageClass | PixelTypes.Argb)]
         public void OpenProgressiveJpeg_SaveBmp<TColor>(TestImageProvider<TColor> provider)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            Image<TColor> image = provider.GetImage();
+            using (Image<TColor> image = provider.GetImage())
-
+            {
                 provider.Utility.SaveTestOutputFile(image, "bmp");
             }
+        }
 
         [Theory]
         [WithSolidFilledImages(16, 16, 255, 0, 0, PixelTypes.StandardImageClass, JpegSubsample.Ratio420, 75)]
@@ -56,15 +58,17 @@ namespace ImageSharp.Tests
             int quality)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            Image<TColor> image = provider.GetImage();
+            byte[] data;
-
+            using (Image<TColor> image = provider.GetImage())
+            {
                 JpegEncoder encoder = new JpegEncoder() { Subsample = subsample, Quality = quality };
 
-            byte[] data = new byte[65536];
+                data = new byte[65536];
                 using (MemoryStream ms = new MemoryStream(data))
                 {
                     image.Save(ms, encoder);
                 }
+            }
 
             // TODO: Automatic image comparers could help here a lot :P
             Image<TColor> mirror = provider.Factory.CreateImage(data);
@@ -78,8 +82,8 @@ namespace ImageSharp.Tests
             TestImageProvider<TColor> provider)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            Image<TColor> image = provider.GetImage();
+            using (Image<TColor> image = provider.GetImage())
-            
+            {
                 using (MemoryStream ms = new MemoryStream())
                 {
                     image.Save(ms, new JpegEncoder());
@@ -96,4 +100,5 @@ namespace ImageSharp.Tests
                 }
             }
         }
+    }
 }

tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs

@@ -34,12 +34,8 @@ namespace ImageSharp.Tests
         public void LoadResizeSave<TColor>(TestImageProvider<TColor> provider, int quality, JpegSubsample subsample)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            Image<TColor> image = provider.GetImage()
+            using (Image<TColor> image = provider.GetImage().Resize(new ResizeOptions { Size = new Size(150, 100), Mode = ResizeMode.Max }))
-                .Resize(new ResizeOptions
             {
-                    Size = new Size(150, 100),
-                    Mode = ResizeMode.Max
-                });
                 image.Quality = quality;
                 image.ExifProfile = null; // Reduce the size of the file
                 JpegEncoder encoder = new JpegEncoder { Subsample = subsample, Quality = quality };
@@ -48,6 +44,7 @@ namespace ImageSharp.Tests
                 provider.Utility.SaveTestOutputFile(image, "png");
                 provider.Utility.SaveTestOutputFile(image, "jpg", encoder);
             }
+        }
 
         [Theory]
         [WithFileCollection(nameof(AllBmpFiles), PixelTypes.Color | PixelTypes.StandardImageClass | PixelTypes.Argb, JpegSubsample.Ratio420, 75)]
@@ -55,14 +52,14 @@ namespace ImageSharp.Tests
         public void OpenBmp_SaveJpeg<TColor>(TestImageProvider<TColor> provider, JpegSubsample subSample, int quality)
            where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            Image<TColor> image = provider.GetImage();
+            using (Image<TColor> image = provider.GetImage())
-
+            {
                 ImagingTestCaseUtility utility = provider.Utility;
                 utility.TestName += "_" + subSample + "_Q" + quality;
 
-            using (var outputStream = File.OpenWrite(utility.GetTestOutputFileName("jpg")))
+                using (FileStream outputStream = File.OpenWrite(utility.GetTestOutputFileName("jpg")))
                 {
-                var encoder = new JpegEncoder()
+                    JpegEncoder encoder = new JpegEncoder()
                                               {
                                                   Subsample = subSample,
                                                   Quality = quality
@@ -72,4 +69,5 @@ namespace ImageSharp.Tests
                 }
             }
         }
+    }
 }

tests/ImageSharp.Tests/Formats/Jpg/JpegUtilsTests.cs

@@ -19,7 +19,6 @@ namespace ImageSharp.Tests
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
             Image<TColor> image = factory.CreateImage(10, 10);
-
             using (PixelAccessor<TColor> pixels = image.Lock())
             {
                 for (int i = 0; i < 10; i++)
@@ -35,6 +34,7 @@ namespace ImageSharp.Tests
                     }
                 }
             }
+
             return image;
         }
 
@@ -43,14 +43,11 @@ namespace ImageSharp.Tests
         public void CopyStretchedRGBTo_FromOrigo<TColor>(TestImageProvider<TColor> provider)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            Image<TColor> src = provider.GetImage();
+            using (Image<TColor> src = provider.GetImage())
-
+            using (Image<TColor> dest = provider.Factory.CreateImage(8, 8))
-            PixelArea<TColor> area = new PixelArea<TColor>(8, 8, ComponentOrder.Xyz);
+            using (PixelArea<TColor> area = new PixelArea<TColor>(8, 8, ComponentOrder.Xyz))
-            Image<TColor> dest = provider.Factory.CreateImage(8, 8);
+            using (PixelAccessor<TColor> s = src.Lock())
-
+            using (PixelAccessor<TColor> d = dest.Lock())
-            using (var s = src.Lock())
-            {
-                using (var d = dest.Lock())
             {
                 s.CopyRGBBytesStretchedTo(area, 0, 0);
                 d.CopyFrom(area, 0, 0);
@@ -60,7 +57,7 @@ namespace ImageSharp.Tests
                 Assert.Equal(s[0, 7], d[0, 7]);
                 Assert.Equal(s[7, 7], d[7, 7]);
             }
-            }
+
         }
 
         [Theory]
@@ -68,14 +65,11 @@ namespace ImageSharp.Tests
         public void CopyStretchedRGBTo_WithOffset<TColor>(TestImageProvider<TColor> provider)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            Image<TColor> src = provider.GetImage();
+            using (Image<TColor> src = provider.GetImage())
-
+            using (PixelArea<TColor> area = new PixelArea<TColor>(8, 8, ComponentOrder.Xyz))
-            PixelArea<TColor> area = new PixelArea<TColor>(8, 8, ComponentOrder.Xyz);
+            using (Image<TColor> dest = provider.Factory.CreateImage(8, 8))
-            Image<TColor> dest = provider.Factory.CreateImage(8, 8);
-
             using (PixelAccessor<TColor> s = src.Lock())
-            {
+            using (PixelAccessor<TColor> d = dest.Lock())
-                using (var d = dest.Lock())
             {
                 s.CopyRGBBytesStretchedTo(area, 7, 6);
                 d.CopyFrom(area, 0, 0);
@@ -109,5 +103,4 @@ namespace ImageSharp.Tests
             }
         }
     }
-    }
 }

tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.cs

@@ -6,8 +6,6 @@
 // ReSharper disable InconsistentNaming
 namespace ImageSharp.Tests.Formats.Jpg
 {
-    using System.Numerics;
-    using ImageSharp.Formats;
     using ImageSharp.Formats.Jpg;
 
     using Xunit;

tests/ImageSharp.Tests/Formats/Png/PngTests.cs

@@ -23,8 +23,8 @@ namespace ImageSharp.Tests
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
+                {
                     using (FileStream output = File.OpenWrite($"{path}/{file.FileNameWithoutExtension}.png"))
                     {
                         image.Quality = 256;
@@ -32,6 +32,7 @@ namespace ImageSharp.Tests
                     }
                 }
             }
+        }
 
         [Fact]
         public void ImageCanSavePngInParallel()
@@ -42,12 +43,13 @@ namespace ImageSharp.Tests
                 Files,
                 file =>
                     {
-                        Image image = file.CreateImage();
+                        using (Image image = file.CreateImage())
-
+                        {
                             using (FileStream output = File.OpenWrite($"{path}/{file.FileNameWithoutExtension}.png"))
                             {
                                 image.SaveAsPng(output);
                             }
+                        }
                     });
         }
     }

tests/ImageSharp.Tests/Image/ImageTests.cs

@@ -23,10 +23,11 @@ namespace ImageSharp.Tests
             });
 
             TestFile file = TestFile.Create(TestImages.Bmp.Car);
-            Image image = new Image(file.Bytes);
+            using (Image image = new Image(file.Bytes))
-
+            {
                 Assert.Equal(600, image.Width);
                 Assert.Equal(450, image.Height);
             }
         }
+    }
 }

tests/ImageSharp.Tests/Image/PixelAccessorTests.cs

@@ -19,8 +19,7 @@ namespace ImageSharp.Tests
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
             Image<TColor> image = factory.CreateImage(10, 10);
-
+            using (PixelAccessor<TColor> pixels = image.Lock())
-            using (var pixels = image.Lock())
             {
                 for (int i = 0; i < 10; i++)
                 {
@@ -47,18 +46,18 @@ namespace ImageSharp.Tests
         public void CopyTo_Then_CopyFrom_OnFullImageRect<TColor>(TestImageProvider<TColor> provider, ComponentOrder order)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            var src = provider.GetImage();
+            using (Image<TColor> src = provider.GetImage())
-
+            {
-            var dest = new Image<TColor>(src.Width, src.Height);
+                using (Image<TColor> dest = new Image<TColor>(src.Width, src.Height))
-
+                {
                     using (PixelArea<TColor> area = new PixelArea<TColor>(src.Width, src.Height, order))
                     {
-                using (var srcPixels = src.Lock())
+                        using (PixelAccessor<TColor> srcPixels = src.Lock())
                         {
                             srcPixels.CopyTo(area, 0, 0);
                         }
 
-                using (var destPixels = dest.Lock())
+                        using (PixelAccessor<TColor> destPixels = dest.Lock())
                         {
                             destPixels.CopyFrom(area, 0, 0);
                         }
@@ -66,12 +65,14 @@ namespace ImageSharp.Tests
 
                     Assert.True(src.IsEquivalentTo(dest, false));
                 }
+            }
+        }
 
         // TODO: Need a processor in the library with this signature
         private static void Fill<TColor>(Image<TColor> image, Rectangle region, TColor color)
              where TColor : struct, IPackedPixel, IEquatable<TColor>
         {
-            using (var pixels = image.Lock())
+            using (PixelAccessor<TColor> pixels = image.Lock())
             {
                 for (int y = region.Top; y < region.Bottom; y++)
                 {
@@ -88,87 +89,114 @@ namespace ImageSharp.Tests
         [WithBlankImages(16, 16, PixelTypes.All, ComponentOrder.Zyx)]
         [WithBlankImages(16, 16, PixelTypes.All, ComponentOrder.Xyzw)]
         [WithBlankImages(16, 16, PixelTypes.All, ComponentOrder.Zyxw)]
-        public void CopyTo_Then_CopyFrom_WithOffset<TColor>(TestImageProvider<TColor> provider, ComponentOrder order)
+        public void CopyToThenCopyFromWithOffset<TColor>(TestImageProvider<TColor> provider, ComponentOrder order)
             where TColor : struct, IPackedPixel, IEquatable<TColor>
 
         {
-            var srcImage = provider.GetImage();
+            using (Image<TColor> destImage = new Image<TColor>(8, 8))
-
+            {
-            var color = default(TColor);
+                TColor color;
+                using (Image<TColor> srcImage = provider.GetImage())
+                {
+                    color = default(TColor);
                     color.PackFromBytes(255, 0, 0, 255);
 
                     Fill(srcImage, new Rectangle(4, 4, 8, 8), color);
-
+                    using (PixelAccessor<TColor> srcPixels = srcImage.Lock())
-            var destImage = new Image<TColor>(8, 8);
-
-            using (var srcPixels = srcImage.Lock())
                     {
-                using (var area = new PixelArea<TColor>(8, 8, order))
+                        using (PixelArea<TColor> area = new PixelArea<TColor>(8, 8, order))
                         {
                             srcPixels.CopyTo(area, 4, 4);
 
-                    using (var destPixels = destImage.Lock())
+                            using (PixelAccessor<TColor> destPixels = destImage.Lock())
                             {
                                 destPixels.CopyFrom(area, 0, 0);
                             }
                         }
                     }
+                }
 
                 provider.Utility.SourceFileOrDescription = order.ToString();
                 provider.Utility.SaveTestOutputFile(destImage, "bmp");
 
-            var expectedImage = new Image<TColor>(8, 8).Fill(color);
+                using (Image<TColor> expectedImage = new Image<TColor>(8, 8).Fill(color))
-
+                {
                     Assert.True(destImage.IsEquivalentTo(expectedImage));
                 }
+            }
+        }
 
 
         [Fact]
         public void CopyFromZYX()
         {
-            CopyFromZYX(new Image(1, 1));
+            using (Image<Color> image = new Image<Color>(1, 1))
+            {
+                CopyFromZYX(image);
+            }
         }
 
         [Fact]
         public void CopyFromZYXOptimized()
         {
-            CopyFromZYX(new Image(1, 1));
+            using (Image image = new Image(1, 1))
+            {
+                CopyFromZYX(image);
+            }
         }
 
         [Fact]
         public void CopyFromZYXW()
         {
-            CopyFromZYXW(new Image(1, 1));
+            using (Image<Color> image = new Image<Color>(1, 1))
+            {
+                CopyFromZYXW(image);
+            }
         }
 
         [Fact]
         public void CopyFromZYXWOptimized()
         {
-            CopyFromZYXW(new Image(1, 1));
+            using (Image image = new Image(1, 1))
+            {
+                CopyFromZYXW(image);
+            }
         }
 
         [Fact]
         public void CopyToZYX()
         {
-            CopyToZYX(new Image(1, 1));
+            using (Image<Color> image = new Image<Color>(1, 1))
+            {
+                CopyToZYX(image);
+            }
         }
 
         [Fact]
         public void CopyToZYXOptimized()
         {
-            CopyToZYX(new Image(1, 1));
+            using (Image image = new Image(1, 1))
+            {
+                CopyToZYX(image);
+            }
         }
 
         [Fact]
         public void CopyToZYXW()
         {
-            CopyToZYXW(new Image(1, 1));
+            using (Image<Color> image = new Image<Color>(1, 1))
+            {
+                CopyToZYXW(image);
+            }
         }
 
         [Fact]
         public void CopyToZYXWOptimized()
         {
-            CopyToZYXW(new Image(1, 1));
+            using (Image image = new Image(1, 1))
+            {
+                CopyToZYXW(image);
+            }
         }
 
         private static void CopyFromZYX<TColor>(Image<TColor> image)

tests/ImageSharp.Tests/Processors/Filters/AlphaTest.cs

@@ -19,39 +19,35 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("AlphaValues")]
+        [MemberData(nameof(AlphaValues))]
         public void ImageShouldApplyAlphaFilter(int value)
         {
-            string path = CreateOutputDirectory("Alpha");
+            string path = this.CreateOutputDirectory("Alpha");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Alpha(value)
+                    image.Alpha(value).Save(output);
-                          .Save(output);
                 }
             }
         }
 
         [Theory]
-        [MemberData("AlphaValues")]
+        [MemberData(nameof(AlphaValues))]
         public void ImageShouldApplyAlphaFilterInBox(int value)
         {
-            string path = CreateOutputDirectory("Alpha");
+            string path = this.CreateOutputDirectory("Alpha");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Alpha(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2))
+                    image.Alpha(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/AutoOrientTests.cs

@@ -26,25 +26,22 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("OrientationValues")]
+        [MemberData(nameof(OrientationValues))]
         public void ImageShouldFlip(RotateType rotateType, FlipType flipType, ushort orientation)
         {
-            string path = CreateOutputDirectory("AutoOrient");
+            string path = this.CreateOutputDirectory("AutoOrient");
 
             TestFile file = TestFile.Create(TestImages.Bmp.F);
 
-            Image image = file.CreateImage();
+            using (Image image = file.CreateImage())
+            {
                 image.ExifProfile = new ExifProfile();
                 image.ExifProfile.SetValue(ExifTag.Orientation, orientation);
 
                 using (FileStream before = File.OpenWrite($"{path}/before-{file.FileName}"))
-            {
                 using (FileStream after = File.OpenWrite($"{path}/after-{file.FileName}"))
                 {
-                    image.RotateFlip(rotateType, flipType)
+                    image.RotateFlip(rotateType, flipType).Save(before).AutoOrient().Save(after);
-                          .Save(before)
-                          .AutoOrient()
-                          .Save(after);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/BackgroundColorTest.cs

@@ -14,16 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyBackgroundColorFilter()
         {
-            string path = CreateOutputDirectory("BackgroundColor");
+            string path = this.CreateOutputDirectory("BackgroundColor");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.BackgroundColor(Color.HotPink)
+                    image.BackgroundColor(Color.HotPink).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/BinaryThreshold.cs

@@ -19,20 +19,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("BinaryThresholdValues")]
+        [MemberData(nameof(BinaryThresholdValues))]
         public void ImageShouldApplyBinaryThresholdFilter(float value)
         {
-            string path = CreateOutputDirectory("BinaryThreshold");
+            string path = this.CreateOutputDirectory("BinaryThreshold");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.BinaryThreshold(value)
+                    image.BinaryThreshold(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/BlackWhiteTest.cs

@@ -14,16 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyBlackWhiteFilter()
         {
-            string path = CreateOutputDirectory("BlackWhite");
+            string path = this.CreateOutputDirectory("BlackWhite");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.BlackWhite()
+                    image.BlackWhite().Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/BoxBlurTest.cs

@@ -19,20 +19,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("BoxBlurValues")]
+        [MemberData(nameof(BoxBlurValues))]
         public void ImageShouldApplyBoxBlurFilter(int value)
         {
-            string path = CreateOutputDirectory("BoxBlur");
+            string path = this.CreateOutputDirectory("BoxBlur");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.BoxBlur(value)
+                    image.BoxBlur(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/BrightnessTest.cs

@@ -19,20 +19,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("BrightnessValues")]
+        [MemberData(nameof(BrightnessValues))]
         public void ImageShouldApplyBrightnessFilter(int value)
         {
-            string path = CreateOutputDirectory("Brightness");
+            string path = this.CreateOutputDirectory("Brightness");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Brightness(value)
+                    image.Brightness(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/ColorBlindnessTest.cs

@@ -26,20 +26,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("ColorBlindnessFilters")]
+        [MemberData(nameof(ColorBlindnessFilters))]
         public void ImageShouldApplyColorBlindnessFilter(ColorBlindness colorBlindness)
         {
-            string path = CreateOutputDirectory("ColorBlindness");
+            string path = this.CreateOutputDirectory("ColorBlindness");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(colorBlindness);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.ColorBlindness(colorBlindness)
+                    image.ColorBlindness(colorBlindness).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/ContrastTest.cs

@@ -19,19 +19,17 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("ContrastValues")]
+        [MemberData(nameof(ContrastValues))]
         public void ImageShouldApplyContrastFilter(int value)
         {
-            string path = CreateOutputDirectory("Contrast");
+            string path = this.CreateOutputDirectory("Contrast");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Contrast(value)
+                    image.Contrast(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/CropTest.cs

@@ -14,16 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyCropSampler()
         {
-            string path = CreateOutputDirectory("Crop");
+            string path = this.CreateOutputDirectory("Crop");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Crop(image.Width / 2, image.Height / 2)
+                    image.Crop(image.Width / 2, image.Height / 2).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/DetectEdgesTest.cs

@@ -31,32 +31,29 @@ namespace ImageSharp.Tests
         [MemberData(nameof(DetectEdgesFilters))]
         public void ImageShouldApplyDetectEdgesFilter(EdgeDetection detector)
         {
-            string path = CreateOutputDirectory("DetectEdges");
+            string path = this.CreateOutputDirectory("DetectEdges");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(detector);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.DetectEdges(detector)
+                    image.DetectEdges(detector).Save(output);
-                         .Save(output);
                 }
             }
         }
 
         [Theory]
-        [MemberData("DetectEdgesFilters")]
+        [MemberData(nameof(DetectEdgesFilters))]
         public void ImageShouldApplyDetectEdgesFilterInBox(EdgeDetection detector)
         {
-            string path = CreateOutputDirectory("DetectEdges");
+            string path = this.CreateOutputDirectory("DetectEdges");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(detector + "-InBox");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
                     image.DetectEdges(detector, new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2))

tests/ImageSharp.Tests/Processors/Filters/EntropyCropTest.cs

@@ -19,20 +19,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("EntropyCropValues")]
+        [MemberData(nameof(EntropyCropValues))]
         public void ImageShouldApplyEntropyCropSampler(float value)
         {
-            string path = CreateOutputDirectory("EntropyCrop");
+            string path = this.CreateOutputDirectory("EntropyCrop");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.EntropyCrop(value)
+                    image.EntropyCrop(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/FlipTests.cs

@@ -20,20 +20,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("FlipValues")]
+        [MemberData(nameof(FlipValues))]
         public void ImageShouldFlip(FlipType flipType)
         {
-            string path = CreateOutputDirectory("Flip");
+            string path = this.CreateOutputDirectory("Flip");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(flipType);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Flip(flipType)
+                    image.Flip(flipType).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/GaussianBlurTest.cs

@@ -19,20 +19,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("GaussianBlurValues")]
+        [MemberData(nameof(GaussianBlurValues))]
         public void ImageShouldApplyGaussianBlurFilter(int value)
         {
-            string path = CreateOutputDirectory("GaussianBlur");
+            string path = this.CreateOutputDirectory("GaussianBlur");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.GaussianBlur(value)
+                    image.GaussianBlur(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/GaussianSharpenTest.cs

@@ -19,20 +19,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("GaussianSharpenValues")]
+        [MemberData(nameof(GaussianSharpenValues))]
         public void ImageShouldApplyGaussianSharpenFilter(int value)
         {
-            string path = CreateOutputDirectory("GaussianSharpen");
+            string path = this.CreateOutputDirectory("GaussianSharpen");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.GaussianSharpen(value)
+                    image.GaussianSharpen(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/GlowTest.cs

@@ -14,16 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyGlowFilter()
         {
-            string path = CreateOutputDirectory("Glow");
+            string path = this.CreateOutputDirectory("Glow");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Glow()
+                    image.Glow().Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -31,17 +29,15 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyGlowFilterColor()
         {
-            string path = CreateOutputDirectory("Glow");
+            string path = this.CreateOutputDirectory("Glow");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName("Color");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Glow(Color.HotPink)
+                    image.Glow(Color.HotPink).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -49,17 +45,15 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyGlowFilterRadius()
         {
-            string path = CreateOutputDirectory("Glow");
+            string path = this.CreateOutputDirectory("Glow");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName("Radius");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Glow(image.Width / 4)
+                    image.Glow(image.Width / 4F).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -67,13 +61,12 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyGlowFilterInBox()
         {
-            string path = CreateOutputDirectory("Glow");
+            string path = this.CreateOutputDirectory("Glow");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName("InBox");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
                     image.Glow(new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2))

tests/ImageSharp.Tests/Processors/Filters/GrayscaleTest.cs

@@ -20,20 +20,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("GrayscaleValues")]
+        [MemberData(nameof(GrayscaleValues))]
         public void ImageShouldApplyGrayscaleFilter(GrayscaleMode value)
         {
-            string path = CreateOutputDirectory("Grayscale");
+            string path = this.CreateOutputDirectory("Grayscale");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Grayscale(value)
+                    image.Grayscale(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/HueTest.cs

@@ -19,20 +19,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("HueValues")]
+        [MemberData(nameof(HueValues))]
         public void ImageShouldApplyHueFilter(int value)
         {
-            string path = CreateOutputDirectory("Hue");
+            string path = this.CreateOutputDirectory("Hue");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Hue(value)
+                    image.Hue(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/InvertTest.cs

@@ -14,15 +14,13 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyInvertFilter()
         {
-            string path = CreateOutputDirectory("Invert");
+            string path = this.CreateOutputDirectory("Invert");
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Invert()
+                    image.Invert().Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -30,17 +28,15 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyInvertFilterInBox()
         {
-            string path = CreateOutputDirectory("Invert");
+            string path = this.CreateOutputDirectory("Invert");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName("InBox");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Invert(new Rectangle(10, 10, image.Width / 2, image.Height / 2))
+                    image.Invert(new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/KodachromeTest.cs

@@ -14,16 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyKodachromeFilter()
         {
-            string path = CreateOutputDirectory("Kodachrome");
+            string path = this.CreateOutputDirectory("Kodachrome");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Kodachrome()
+                    image.Kodachrome().Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/LomographTest.cs

@@ -14,16 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyLomographFilter()
         {
-            string path = CreateOutputDirectory("Lomograph");
+            string path = this.CreateOutputDirectory("Lomograph");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Lomograph()
+                    image.Lomograph().Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -31,13 +29,12 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyLomographFilterInBox()
         {
-            string path = CreateOutputDirectory("Lomograph");
+            string path = this.CreateOutputDirectory("Lomograph");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName("InBox");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
                     image.Lomograph(new Rectangle(image.Width / 4, image.Width / 4, image.Width / 2, image.Height / 2))

tests/ImageSharp.Tests/Processors/Filters/OilPaintTest.cs

@@ -23,19 +23,17 @@ namespace ImageSharp.Tests
         [MemberData(nameof(OilPaintValues))]
         public void ImageShouldApplyOilPaintFilter(Tuple<int, int> value)
         {
-            string path = CreateOutputDirectory("OilPaint");
+            string path = this.CreateOutputDirectory("OilPaint");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
                     if (image.Width > value.Item2 && image.Height > value.Item2)
                     {
-                        image.OilPaint(value.Item1, value.Item2)
+                        image.OilPaint(value.Item1, value.Item2).Save(output);
-                             .Save(output);
                     }
                 }
             }
@@ -45,13 +43,13 @@ namespace ImageSharp.Tests
         [MemberData(nameof(OilPaintValues))]
         public void ImageShouldApplyOilPaintFilterInBox(Tuple<int, int> value)
         {
-            string path = CreateOutputDirectory("OilPaint");
+            string path = this.CreateOutputDirectory("OilPaint");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value + "-InBox");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
+                {
                     if (image.Width > value.Item2 && image.Height > value.Item2)
                     {
                         using (FileStream output = File.OpenWrite($"{path}/{filename}"))
@@ -62,4 +60,5 @@ namespace ImageSharp.Tests
                 }
             }
         }
+    }
 }

tests/ImageSharp.Tests/Processors/Filters/PadTest.cs

@@ -14,16 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyPadSampler()
         {
-            string path = CreateOutputDirectory("Pad");
+            string path = this.CreateOutputDirectory("Pad");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Pad(image.Width + 50, image.Height + 50)
+                    image.Pad(image.Width + 50, image.Height + 50).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/PixelateTest.cs

@@ -41,17 +41,15 @@ namespace ImageSharp.Tests
         [MemberData(nameof(PixelateValues))]
         public void ImageShouldApplyPixelateFilterInBox(int value)
         {
-            string path = CreateOutputDirectory("Pixelate");
+            string path = this.CreateOutputDirectory("Pixelate");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value + "-InBox");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Pixelate(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2))
+                    image.Pixelate(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
-                         .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/PolaroidTest.cs

@@ -14,16 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyPolaroidFilter()
         {
-            string path = CreateOutputDirectory("Polaroid");
+            string path = this.CreateOutputDirectory("Polaroid");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Polaroid()
+                    image.Polaroid().Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/ResizeTests.cs

@@ -42,12 +42,10 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Resize(image.Width / 2, image.Height / 2, sampler, true)
+                    image.Resize(image.Width / 2, image.Height / 2, sampler, true).Save(output);
-                         .Save(output);
                 }
             }
         }
@@ -63,12 +61,10 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Resize(image.Width / 3, 0, sampler, false)
+                    image.Resize(image.Width / 3, 0, sampler, false).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -84,12 +80,10 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Resize(0, image.Height / 3, sampler, false)
+                    image.Resize(0, image.Height / 3, sampler, false).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -105,18 +99,16 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    ResizeOptions options = new ResizeOptions()
+                    ResizeOptions options = new ResizeOptions
                     {
                         Sampler = sampler,
                         Size = new Size(image.Width / 2, image.Height)
                     };
 
-                    image.Resize(options)
+                    image.Resize(options).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -132,18 +124,16 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    ResizeOptions options = new ResizeOptions()
+                    ResizeOptions options = new ResizeOptions
                     {
                         Sampler = sampler,
                         Size = new Size(image.Width, image.Height / 2)
                     };
 
-                    image.Resize(options)
+                    image.Resize(options).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -159,18 +149,16 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    ResizeOptions options = new ResizeOptions()
+                    ResizeOptions options = new ResizeOptions
                     {
                         Size = new Size(image.Width + 200, image.Height),
                         Mode = ResizeMode.Pad
                     };
 
-                    image.Resize(options)
+                    image.Resize(options).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -186,19 +174,17 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    ResizeOptions options = new ResizeOptions()
+                    ResizeOptions options = new ResizeOptions
                     {
                         Sampler = sampler,
                         Size = new Size(image.Width + 200, image.Height + 200),
                         Mode = ResizeMode.BoxPad
                     };
 
-                    image.Resize(options)
+                    image.Resize(options).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -214,19 +200,17 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    ResizeOptions options = new ResizeOptions()
+                    ResizeOptions options = new ResizeOptions
                     {
                         Sampler = sampler,
                         Size = new Size(300, 300),
                         Mode = ResizeMode.Max
                     };
 
-                    image.Resize(options)
+                    image.Resize(options).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -242,19 +226,17 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    ResizeOptions options = new ResizeOptions()
+                    ResizeOptions options = new ResizeOptions
                     {
                         Sampler = sampler,
-                        Size = new Size((int)Math.Round(image.Width * .75F), (int)Math.Round(image.Height * 95F)),
+                        Size = new Size((int)Math.Round(image.Width * .75F), (int)Math.Round(image.Height * .95F)),
                         Mode = ResizeMode.Min
                     };
 
-                    image.Resize(options)
+                    image.Resize(options).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -270,19 +252,17 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(name);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    ResizeOptions options = new ResizeOptions()
+                    ResizeOptions options = new ResizeOptions
                     {
                         Sampler = sampler,
                         Size = new Size(image.Width / 2, image.Height),
                         Mode = ResizeMode.Stretch
                     };
 
-                    image.Resize(options)
+                    image.Resize(options).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/RotateFlipTest.cs

@@ -22,20 +22,18 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("RotateFlipValues")]
+        [MemberData(nameof(RotateFlipValues))]
         public void ImageShouldRotateFlip(RotateType rotateType, FlipType flipType)
         {
-            string path = CreateOutputDirectory("RotateFlip");
+            string path = this.CreateOutputDirectory("RotateFlip");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(rotateType + "-" + flipType);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.RotateFlip(rotateType, flipType)
+                    image.RotateFlip(rotateType, flipType).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/RotateTest.cs

@@ -28,39 +28,35 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("RotateFloatValues")]
+        [MemberData(nameof(RotateFloatValues))]
         public void ImageShouldApplyRotateSampler(float value)
         {
-            string path = CreateOutputDirectory("Rotate");
+            string path = this.CreateOutputDirectory("Rotate");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Rotate(value)
+                    image.Rotate(value).Save(output);
-                          .Save(output);
                 }
             }
         }
 
         [Theory]
-        [MemberData("RotateEnumValues")]
+        [MemberData(nameof(RotateEnumValues))]
         public void ImageShouldApplyRotateSampler(RotateType value)
         {
-            string path = CreateOutputDirectory("Rotate");
+            string path = this.CreateOutputDirectory("Rotate");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Rotate(value)
+                    image.Rotate(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/SaturationTest.cs

@@ -19,7 +19,7 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("SaturationValues")]
+        [MemberData(nameof(SaturationValues))]
         public void ImageShouldApplySaturationFilter(int value)
         {
             string path = CreateOutputDirectory("Saturation");
@@ -27,12 +27,10 @@ namespace ImageSharp.Tests
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Saturation(value)
+                    image.Saturation(value).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/SepiaTest.cs

@@ -18,12 +18,10 @@ namespace ImageSharp.Tests
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Sepia()
+                    image.Sepia().Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/SkewTest.cs

@@ -19,22 +19,20 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData("SkewValues")]
+        [MemberData(nameof(SkewValues))]
         public void ImageShouldApplySkewSampler(float x, float y)
         {
-            string path = CreateOutputDirectory("Skew");
+            string path = this.CreateOutputDirectory("Skew");
 
             // Matches live example
             // http://www.w3schools.com/css/tryit.asp?filename=trycss3_transform_skew
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName(x + "-" + y);
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Skew(x, y)
+                    image.Skew(x, y).Save(output);
-                          .Save(output);
                 }
             }
         }

tests/ImageSharp.Tests/Processors/Filters/VignetteTest.cs

@@ -14,16 +14,14 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyVignetteFilter()
         {
-            string path = CreateOutputDirectory("Vignette");
+            string path = this.CreateOutputDirectory("Vignette");
 
             foreach (TestFile file in Files)
             {
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
-                    image.Vignette()
+                    image.Vignette().Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -31,17 +29,15 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyVignetteFilterColor()
         {
-            string path = CreateOutputDirectory("Vignette");
+            string path = this.CreateOutputDirectory("Vignette");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName("Color");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Vignette(Color.HotPink)
+                    image.Vignette(Color.HotPink).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -49,17 +45,15 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyVignetteFilterRadius()
         {
-            string path = CreateOutputDirectory("Vignette");
+            string path = this.CreateOutputDirectory("Vignette");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName("Radius");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
-                    image.Vignette(image.Width / 4, image.Height / 4)
+                    image.Vignette(image.Width / 4F, image.Height / 4F).Save(output);
-                          .Save(output);
                 }
             }
         }
@@ -67,13 +61,12 @@ namespace ImageSharp.Tests
         [Fact]
         public void ImageShouldApplyVignetteFilterInBox()
         {
-            string path = CreateOutputDirectory("Vignette");
+            string path = this.CreateOutputDirectory("Vignette");
 
             foreach (TestFile file in Files)
             {
                 string filename = file.GetFileName("InBox");
-                Image image = file.CreateImage();
+                using (Image image = file.CreateImage())
-
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
                     image.Vignette(new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2))

tests/ImageSharp.Tests/Profiles/Exif/ExifProfileTests.cs

@@ -31,6 +31,8 @@ namespace ImageSharp.Tests
 
             ExifValue value = image.ExifProfile.Values.FirstOrDefault(val => val.Tag == ExifTag.Copyright);
             TestValue(value, "Dirk Lemstra");
+
+
         }
 
         [Fact]
@@ -247,6 +249,7 @@ namespace ImageSharp.Tests
             using (MemoryStream memStream = new MemoryStream())
             {
                 image.SaveAsJpeg(memStream);
+                image.Dispose();
 
                 memStream.Position = 0;
                 return new Image(memStream);

tests/ImageSharp.Tests/Profiles/Exif/ExifTagDescriptionAttributeTests.cs

@@ -10,7 +10,7 @@ namespace ImageSharp.Tests
     public class ExifDescriptionAttributeTests
     {
         [Fact]
-        public void Test_ExifTag()
+        public void TestExifTag()
         {
             var exifProfile = new ExifProfile();
 

tests/ImageSharp.Tests/Profiles/Exif/ExifValueTests.cs

@@ -12,9 +12,12 @@ namespace ImageSharp.Tests
     {
         private static ExifValue GetExifValue()
         {
-            Image image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateImage();
+            ExifProfile profile;
+            using (Image image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateImage())
+            {
+                profile = image.ExifProfile;
+            }
 
-            ExifProfile profile = image.ExifProfile;
             Assert.NotNull(profile);
 
             return profile.Values.First();