diff --git a/73_Reverse/csharp/Reverse/Reverse.Tests/ReverserTests.cs b/73_Reverse/csharp/Reverse/Reverse.Tests/ReverserTests.cs
index a6beeeb3..9df7d3d5 100644
--- a/73_Reverse/csharp/Reverse/Reverse.Tests/ReverserTests.cs
+++ b/73_Reverse/csharp/Reverse/Reverse.Tests/ReverserTests.cs
@@ -7,15 +7,45 @@ namespace Reverse.Tests
 {
     public class ReverserTests
     {
+        [Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
+        public void Constructor_CreatesRandomArrayOfSpecifiedLength(int size)
+        {
+            var sut = new TestReverser(size);
+
+            Assert.Equal(size, sut.GetArray().Length);
+        }
+
+        [Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
+        public void ConstructorArray_MaxElementValueIsEqualToSize(int size)
+        {
+            var sut = new TestReverser(size);
+
+            Assert.Equal(size, sut.GetArray().Max());
+        }
+
+        [Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
+        public void ConstructorArray_ReturnsRandomArrayWithDistinctElements(int size)
+        {
+            var sut = new TestReverser(size);
+            var array = sut.GetArray();
+            var arrayGroup = array.GroupBy(x => x);
+            var duplicateFound = arrayGroup.Any(x => x.Count() > 1);
+
+            Assert.False(duplicateFound);
+        }
+
         [Theory]
         [InlineData(new int[] { 1 }, new int[] { 1 })]
         [InlineData(new int[] { 1, 2 }, new int[] { 2, 1 })]
         [InlineData(new int[] { 1, 2, 3 }, new int[] { 3, 2, 1 })]
         public void Reverse_WillReverseEntireArray(int[] input, int[] output)
         {
-            Reverser.Reverse(input, input.Length);
+            var sut = new TestReverser(1);
+            sut.SetArray(input);
 
-            Assert.True(input.SequenceEqual(output));
+            sut.Reverse(input.Length);
+
+            Assert.True(sut.GetArray().SequenceEqual(output));
         }
 
         [Fact]
@@ -23,10 +53,12 @@ namespace Reverse.Tests
         {
             var input = new int[] { 1, 2, 3, 4 };
             var output = new int[] { 2, 1, 3, 4 };
+            var sut = new TestReverser(1);
+            sut.SetArray(input);
 
-            Reverser.Reverse(input, 2);
+            sut.Reverse(2);
 
-            Assert.True(input.SequenceEqual(output));
+            Assert.True(sut.GetArray().SequenceEqual(output));
         }
 
         [Fact]
@@ -34,10 +66,12 @@ namespace Reverse.Tests
         {
             var input = new int[] { 1, 2 };
             var output = new int[] { 1, 2 };
+            var sut = new TestReverser(1);
+            sut.SetArray(input);
 
-            Reverser.Reverse(input, 1);
+            sut.Reverse(1);
 
-            Assert.True(input.SequenceEqual(output));
+            Assert.True(sut.GetArray().SequenceEqual(output));
         }
 
         [Fact]
@@ -45,37 +79,12 @@ namespace Reverse.Tests
         {
             var input = new int[] { 1, 2 };
             var output = new int[] { 1, 2 };
+            var sut = new TestReverser(1);
+            sut.SetArray(input);
 
-            Reverser.Reverse(input, input.Length + 1);
+            sut.Reverse(sut.GetArray().Length + 1);
 
-            Assert.True(input.SequenceEqual(output));
-        }
-
-        [Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
-        public void CreateRandomArray_ReturnsRandomArrayOfSpecifiedLength()
-        {
-            var result = Reverser.CreateRandomArray(5);
-
-            Assert.Equal(5, result.Length);
-        }
-
-        [Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
-        public void CreateRandomArray_MaxElementValueIsEqualToSize(int size)
-        {
-            var result = Reverser.CreateRandomArray(size);
-
-            Assert.Equal(size, result.Max());
-        }
-
-        [Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
-        public void CreateRandomArray_ReturnsRandomArrayWithDistinctElements(int size)
-        {
-            var array = Reverser.CreateRandomArray(size);
-
-            var arrayGroup = array.GroupBy(x => x);
-            var duplicateFound = arrayGroup.Any(x => x.Count() > 1);
-
-            Assert.False(duplicateFound);
+            Assert.True(sut.GetArray().SequenceEqual(output));
         }
 
         [Theory]
@@ -84,7 +93,10 @@ namespace Reverse.Tests
         [InlineData(new int[] { 1, 1 })]
         public void IsArrayInAscendingOrder_WhenArrayElementsAreInNumericAscendingOrder_ReturnsTrue(int[] input)
         {
-            var result = Reverser.IsArrayInAscendingOrder(input);
+            var sut = new TestReverser(1);
+            sut.SetArray(input);
+
+            var result = sut.IsArrayInAscendingOrder();
 
             Assert.True(result);
         }
@@ -92,7 +104,10 @@ namespace Reverse.Tests
         [Fact]
         public void IsArrayInOrder_WhenArrayElementsAreNotInNumericAscendingOrder_ReturnsFalse()
         {
-            var result = Reverser.IsArrayInAscendingOrder(new int[] { 2, 1 });
+            var sut = new TestReverser(1);
+            sut.SetArray(new int[] { 2, 1 });
+
+            var result = sut.IsArrayInAscendingOrder();
 
             Assert.False(result);
         }
diff --git a/73_Reverse/csharp/Reverse/Reverse.Tests/TestReverser.cs b/73_Reverse/csharp/Reverse/Reverse.Tests/TestReverser.cs
new file mode 100644
index 00000000..a53004e1
--- /dev/null
+++ b/73_Reverse/csharp/Reverse/Reverse.Tests/TestReverser.cs
@@ -0,0 +1,17 @@
+namespace Reverse.Tests
+{
+    internal class TestReverser : Reverser
+    {
+        public TestReverser(int arraySize) : base(arraySize) { }
+
+        public int[] GetArray()
+        {
+            return _array;
+        }
+
+        public void SetArray(int[] array)
+        {
+            _array = array;
+        }
+    }
+}
diff --git a/73_Reverse/csharp/Reverse/Reverse/Reverser.cs b/73_Reverse/csharp/Reverse/Reverse/Reverser.cs
index 62db79f1..426713c4 100644
--- a/73_Reverse/csharp/Reverse/Reverse/Reverser.cs
+++ b/73_Reverse/csharp/Reverse/Reverse/Reverser.cs
@@ -4,6 +4,23 @@ namespace Reverse
 {
     public class Reverser
     {
+        protected int[] _array;
+
+        public Reverser(int arraySize)
+        {
+            _array = CreateRandomArray(arraySize);
+        }
+
+        public void Reverse(int index)
+        {
+            Reverse(_array, index);
+        }
+
+        public bool IsArrayInAscendingOrder()
+        {
+            return IsArrayInAscendingOrder(_array);
+        }
+
         public static void Reverse(int[] arrayToReverse, int indexToReverseTo)
         {
             if (indexToReverseTo > arrayToReverse.Length)