diff --git a/MatFileHandler/ChecksumCalculatingStream.cs b/MatFileHandler/ChecksumCalculatingStream.cs
index e0278f0..761e9e0 100644
--- a/MatFileHandler/ChecksumCalculatingStream.cs
+++ b/MatFileHandler/ChecksumCalculatingStream.cs
@@ -13,8 +13,8 @@ namespace MatFileHandler
     {
         private const uint BigPrime = 0xFFF1;
         private readonly Stream _stream;
-        private uint s1 = 1;
-        private uint s2 = 0;
+        private uint s1;
+        private uint s2;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ChecksumCalculatingStream"/> class.
@@ -23,6 +23,8 @@ namespace MatFileHandler
         public ChecksumCalculatingStream(Stream stream)
         {
             _stream = stream;
+            s1 = 1;
+            s2 = 0;
         }
 
         /// <inheritdoc />
@@ -89,4 +91,4 @@ namespace MatFileHandler
             return (s2 << 16) | s1;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/DataBuilder.cs b/MatFileHandler/DataBuilder.cs
index 88042b1..fcc980b 100755
--- a/MatFileHandler/DataBuilder.cs
+++ b/MatFileHandler/DataBuilder.cs
@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
 
+#pragma warning disable CA1822
 namespace MatFileHandler
 {
     /// <summary>
@@ -52,7 +53,7 @@ namespace MatFileHandler
         {
             if (data.Length != dimensions.NumberOfElements())
             {
-                throw new ArgumentException("Data size does not match the specified dimensions", "data");
+                throw new ArgumentException("Data size does not match the specified dimensions", nameof(data));
             }
             return new MatNumericalArrayOf<T>(GetStandardFlags<T>(), dimensions, string.Empty, data);
         }
@@ -157,7 +158,7 @@ namespace MatFileHandler
             return new MatFile(variables);
         }
 
-        private ArrayFlags ConstructArrayFlags(ArrayType class_, bool isComplex = false, bool isLogical = false)
+        private static ArrayFlags ConstructArrayFlags(ArrayType class_, bool isComplex = false, bool isLogical = false)
         {
             return new ArrayFlags
             {
@@ -167,7 +168,7 @@ namespace MatFileHandler
             };
         }
 
-        private ArrayFlags GetStandardFlags<T>()
+        private static ArrayFlags GetStandardFlags<T>()
         {
             if (typeof(T) == typeof(sbyte))
             {
@@ -266,4 +267,4 @@ namespace MatFileHandler
             };
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/DataElementConverter.cs b/MatFileHandler/DataElementConverter.cs
index 0aceeb6..040f2ec 100755
--- a/MatFileHandler/DataElementConverter.cs
+++ b/MatFileHandler/DataElementConverter.cs
@@ -71,9 +71,9 @@ namespace MatFileHandler
             {
                 throw new NotSupportedException("Only 2-dimensional sparse arrays are supported");
             }
-            if (data == null)
+            if (data is null)
             {
-                throw new ArgumentException("Null data found.", "data");
+                throw new ArgumentException("Null data found.", nameof(data));
             }
             var elements =
                 ConvertDataToSparseProperType<T>(data, flags.ArrayFlags.Variable.HasFlag(Variable.IsLogical));
@@ -243,4 +243,4 @@ namespace MatFileHandler
             };
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/DataElementReader.cs b/MatFileHandler/DataElementReader.cs
index 9da8ab6..a5b280f 100755
--- a/MatFileHandler/DataElementReader.cs
+++ b/MatFileHandler/DataElementReader.cs
@@ -212,7 +212,7 @@ namespace MatFileHandler
             }
         }
 
-        private DataElement ContinueReadingCellArray(
+        private MatCellArray ContinueReadingCellArray(
             BinaryReader reader,
             ArrayFlags flags,
             int[] dimensions,
@@ -258,11 +258,11 @@ namespace MatFileHandler
             }
             else
             {
-                return new Opaque(name, typeDescription, className, new int[] { }, data, subsystemData);
+                return new Opaque(name, typeDescription, className, Array.Empty<int>(), data, subsystemData);
             }
         }
 
-        private DataElement ContinueReadingSparseArray(
+        private MatArray ContinueReadingSparseArray(
             BinaryReader reader,
             DataElement firstElement,
             int[] dimensions,
@@ -313,7 +313,7 @@ namespace MatFileHandler
             }
         }
 
-        private DataElement ContinueReadingStructure(
+        private MatStructureArray ContinueReadingStructure(
             BinaryReader reader,
             ArrayFlags flags,
             int[] dimensions,
@@ -526,4 +526,4 @@ namespace MatFileHandler
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/FakeWriter.cs b/MatFileHandler/FakeWriter.cs
index 6e83fdf..e00e974 100644
--- a/MatFileHandler/FakeWriter.cs
+++ b/MatFileHandler/FakeWriter.cs
@@ -202,24 +202,24 @@ namespace MatFileHandler
             WriteDataElement(buffer);
         }
 
-        private unsafe int GetLengthOfByteArray<T>(int dataLength)
+        private static unsafe int GetLengthOfByteArray<T>(int dataLength)
             where T : unmanaged
         {
             return dataLength * sizeof(T);
         }
 
-        private unsafe int GetLengthOfPairOfByteArrays<T>(ComplexOf<T>[] data)
+        private static unsafe int GetLengthOfPairOfByteArrays<T>(ComplexOf<T>[] data)
             where T : unmanaged
         {
             return data.Length * sizeof(T);
         }
 
-        private unsafe int GetLengthOfPairOfByteArrays(Complex[] data)
+        private static unsafe int GetLengthOfPairOfByteArrays(Complex[] data)
         {
             return data.Length * sizeof(double);
         }
 
-        private int CalculatePadding(int length)
+        private static int CalculatePadding(int length)
         {
             var rem = length % 8;
             if (rem == 0)
@@ -275,7 +275,7 @@ namespace MatFileHandler
             }
         }
 
-        private (int rowIndexLength, int columnIndexLength, int dataLength, uint nonZero) PrepareSparseArrayData<T>(
+        private static (int rowIndexLength, int columnIndexLength, int dataLength, uint nonZero) PrepareSparseArrayData<T>(
             ISparseArrayOf<T> array)
             where T : struct, IEquatable<T>
         {
@@ -395,4 +395,4 @@ namespace MatFileHandler
                 fakeWriter => fakeWriter.WriteNumericalArrayContents(numericalArray, name));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/ICharArray.cs b/MatFileHandler/ICharArray.cs
index bcd1763..fb1b1c4 100755
--- a/MatFileHandler/ICharArray.cs
+++ b/MatFileHandler/ICharArray.cs
@@ -10,6 +10,8 @@ namespace MatFileHandler
         /// <summary>
         /// Gets the contained string.
         /// </summary>
+#pragma warning disable CA1716, CA1720
         string String { get; }
+#pragma warning restore CA1716, CA1720
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/MatArray.cs b/MatFileHandler/MatArray.cs
index ea5cfeb..3a35133 100755
--- a/MatFileHandler/MatArray.cs
+++ b/MatFileHandler/MatArray.cs
@@ -51,7 +51,7 @@ namespace MatFileHandler
         /// <returns>Empty array.</returns>
         public static MatArray Empty()
         {
-            return new MatArray(new ArrayFlags { Class = ArrayType.MxCell, Variable = 0 }, new int[] { }, string.Empty);
+            return new MatArray(new ArrayFlags { Class = ArrayType.MxCell, Variable = 0 }, Array.Empty<int>(), string.Empty);
         }
 
         /// <inheritdoc />
@@ -78,4 +78,4 @@ namespace MatFileHandler
             return null;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/MatFileHandler.csproj b/MatFileHandler/MatFileHandler.csproj
index ffa8e5f..cdb1070 100755
--- a/MatFileHandler/MatFileHandler.csproj
+++ b/MatFileHandler/MatFileHandler.csproj
@@ -23,30 +23,21 @@
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <AnalysisLevel>latest-Recommended</AnalysisLevel>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="System.ValueTuple" Version="4.4.0" Condition="'$(TargetFramework)' == 'net461'" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <CodeAnalysisRuleSet>..\MatFileHandler.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <CodeAnalysisRuleSet>..\MatFileHandler.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <ItemGroup>
-    <AdditionalFiles Include="..\stylecop.json" />
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.66">
-            <PrivateAssets>All</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="System.ValueTuple" Version="4.4.0" Condition="'$(TargetFramework)' == 'net461'" />
-  </ItemGroup>
   <ItemGroup>
     <None Include="..\README.md" Pack="true" PackagePath="\"/>
   </ItemGroup>
+
   <ItemGroup>
     <InternalsVisibleTo Include="MatFileHandler.Tests" />
   </ItemGroup>
diff --git a/MatFileHandler/MatFileReader.cs b/MatFileHandler/MatFileReader.cs
index adc29ac..8feb9ef 100755
--- a/MatFileHandler/MatFileReader.cs
+++ b/MatFileHandler/MatFileReader.cs
@@ -88,7 +88,7 @@ namespace MatFileHandler
             return ReadRawVariables(reader, subsystemDataOffset, subsystemData);
         }
 
-        private static IMatFile Read(BinaryReader reader)
+        private static MatFile Read(BinaryReader reader)
         {
             var header = ReadHeader(reader);
             var rawVariables = ReadRawVariables(reader, header.SubsystemDataOffset);
@@ -120,4 +120,4 @@ namespace MatFileHandler
             return SubsystemDataReader.Read(bytes, subsystemData);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/MatFileWriter.cs b/MatFileHandler/MatFileWriter.cs
index b6077a1..3d32afb 100755
--- a/MatFileHandler/MatFileWriter.cs
+++ b/MatFileHandler/MatFileWriter.cs
@@ -69,7 +69,7 @@ namespace MatFileHandler
                             WriteVariable(writer, variable);
                             break;
                         default:
-                            throw new ArgumentOutOfRangeException();
+                            throw new NotImplementedException();
                     }
                 }
             }
@@ -98,7 +98,7 @@ namespace MatFileHandler
             return (s2 << 16) | s1;
         }
 
-        private void WriteHeader(BinaryWriter writer, Header header)
+        private static void WriteHeader(BinaryWriter writer, Header header)
         {
             writer.Write(Encoding.UTF8.GetBytes(header.Text));
             writer.Write(header.SubsystemDataOffset);
@@ -106,28 +106,19 @@ namespace MatFileHandler
             writer.Write((short)19785); // Magic number, 'IM'.
         }
 
-        private void WriteTag(BinaryWriter writer, Tag tag)
+        private static void WriteTag(BinaryWriter writer, Tag tag)
         {
             writer.Write((int)tag.Type);
             writer.Write(tag.Length);
         }
 
-        private void WriteShortTag(BinaryWriter writer, Tag tag)
+        private static void WriteShortTag(BinaryWriter writer, Tag tag)
         {
             writer.Write((short)tag.Type);
             writer.Write((short)tag.Length);
         }
 
-        private void WritePadding(BinaryWriter writer)
-        {
-            var positionMod8 = writer.BaseStream.Position % 8;
-            if (positionMod8 != 0)
-            {
-                writer.Write(new byte[8 - positionMod8]);
-            }
-        }
-
-        private void WriteDataElement(BinaryWriter writer, DataType type, byte[] data)
+        private static void WriteDataElement(BinaryWriter writer, DataType type, byte[] data)
         {
             if (data.Length > 4)
             {
@@ -152,13 +143,13 @@ namespace MatFileHandler
             }
         }
 
-        private void WriteDimensions(BinaryWriter writer, int[] dimensions)
+        private static void WriteDimensions(BinaryWriter writer, int[] dimensions)
         {
             var buffer = ConvertToByteArray(dimensions);
             WriteDataElement(writer, DataType.MiInt32, buffer);
         }
 
-        private byte[] ConvertToByteArray<T>(T[] data)
+        private static byte[] ConvertToByteArray<T>(T[] data)
           where T : struct
         {
             int size;
@@ -211,26 +202,26 @@ namespace MatFileHandler
             return buffer;
         }
 
-        private (byte[] real, byte[] imaginary) ConvertToPairOfByteArrays<T>(ComplexOf<T>[] data)
+        private static (byte[] real, byte[] imaginary) ConvertToPairOfByteArrays<T>(ComplexOf<T>[] data)
           where T : struct
         {
             return (ConvertToByteArray(data.Select(x => x.Real).ToArray()),
                 ConvertToByteArray(data.Select(x => x.Imaginary).ToArray()));
         }
 
-        private (byte[] real, byte[] imaginary) ConvertToPairOfByteArrays(Complex[] data)
+        private static (byte[] real, byte[] imaginary) ConvertToPairOfByteArrays(Complex[] data)
         {
             return (ConvertToByteArray(data.Select(x => x.Real).ToArray()),
                 ConvertToByteArray(data.Select(x => x.Imaginary).ToArray()));
         }
 
-        private void WriteComplexValues(BinaryWriter writer, DataType type, (byte[] real, byte[] complex) data)
+        private static void WriteComplexValues(BinaryWriter writer, DataType type, (byte[] real, byte[] complex) data)
         {
             WriteDataElement(writer, type, data.real);
             WriteDataElement(writer, type, data.complex);
         }
 
-        private void WriteArrayFlags(BinaryWriter writer, ArrayFlags flags)
+        private static void WriteArrayFlags(BinaryWriter writer, ArrayFlags flags)
         {
             var flag = (byte)flags.Variable;
             WriteTag(writer, new Tag(DataType.MiUInt32, 8));
@@ -239,7 +230,7 @@ namespace MatFileHandler
             writer.Write(new byte[] { 0, 0, 0, 0, 0, 0 });
         }
 
-        private void WriteSparseArrayFlags(BinaryWriter writer, SparseArrayFlags flags)
+        private static void WriteSparseArrayFlags(BinaryWriter writer, SparseArrayFlags flags)
         {
             var flag = (byte)flags.ArrayFlags.Variable;
             WriteTag(writer, new Tag(DataType.MiUInt32, 8));
@@ -249,13 +240,13 @@ namespace MatFileHandler
             writer.Write(flags.NzMax);
         }
 
-        private void WriteName(BinaryWriter writer, string name)
+        private static void WriteName(BinaryWriter writer, string name)
         {
             var nameBytes = Encoding.ASCII.GetBytes(name);
             WriteDataElement(writer, DataType.MiInt8, nameBytes);
         }
 
-        private void WriteNumericalArrayValues(BinaryWriter writer, IArray value)
+        private static void WriteNumericalArrayValues(BinaryWriter writer, IArray value)
         {
             switch (value)
             {
@@ -330,7 +321,7 @@ namespace MatFileHandler
             }
         }
 
-        private ArrayFlags GetArrayFlags(IArray array, bool isGlobal)
+        private static ArrayFlags GetArrayFlags(IArray array, bool isGlobal)
         {
             var variableFlags = isGlobal ? Variable.IsGlobal : 0;
             switch (array)
@@ -386,7 +377,7 @@ namespace MatFileHandler
             }
         }
 
-        private SparseArrayFlags GetSparseArrayFlags<T>(ISparseArrayOf<T> array, bool isGlobal, uint nonZero)
+        private static SparseArrayFlags GetSparseArrayFlags<T>(ISparseArrayOf<T> array, bool isGlobal, uint nonZero)
             where T : struct
         {
             var flags = GetArrayFlags(array, isGlobal);
@@ -401,12 +392,12 @@ namespace MatFileHandler
             };
         }
 
-        private ArrayFlags GetCharArrayFlags(bool isGlobal)
+        private static ArrayFlags GetCharArrayFlags(bool isGlobal)
         {
             return new ArrayFlags(ArrayType.MxChar, isGlobal ? Variable.IsGlobal : 0);
         }
 
-        private void WriteWrappingContents<T>(
+        private static void WriteWrappingContents<T>(
             BinaryWriter writer,
             T array,
             Action<FakeWriter> lengthCalculator,
@@ -426,7 +417,7 @@ namespace MatFileHandler
             writeContents(writer);
         }
 
-        private void WriteNumericalArrayContents(BinaryWriter writer, IArray array, string name, bool isGlobal)
+        private static void WriteNumericalArrayContents(BinaryWriter writer, IArray array, string name, bool isGlobal)
         {
             WriteArrayFlags(writer, GetArrayFlags(array, isGlobal));
             WriteDimensions(writer, array.Dimensions);
@@ -434,7 +425,7 @@ namespace MatFileHandler
             WriteNumericalArrayValues(writer, array);
         }
 
-        private void WriteNumericalArray(
+        private static void WriteNumericalArray(
             BinaryWriter writer,
             IArray numericalArray,
             string name = "",
@@ -447,7 +438,7 @@ namespace MatFileHandler
                 contentsWriter => { WriteNumericalArrayContents(contentsWriter, numericalArray, name, isGlobal); });
         }
 
-        private void WriteCharArrayContents(BinaryWriter writer, ICharArray charArray, string name, bool isGlobal)
+        private static void WriteCharArrayContents(BinaryWriter writer, ICharArray charArray, string name, bool isGlobal)
         {
             WriteArrayFlags(writer, GetCharArrayFlags(isGlobal));
             WriteDimensions(writer, charArray.Dimensions);
@@ -456,7 +447,7 @@ namespace MatFileHandler
             WriteDataElement(writer, DataType.MiUtf16, ConvertToByteArray(array));
         }
 
-        private void WriteCharArray(BinaryWriter writer, ICharArray charArray, string name, bool isGlobal)
+        private static void WriteCharArray(BinaryWriter writer, ICharArray charArray, string name, bool isGlobal)
         {
             WriteWrappingContents(
                 writer,
@@ -465,7 +456,7 @@ namespace MatFileHandler
                 contentsWriter => { WriteCharArrayContents(contentsWriter, charArray, name, isGlobal); });
         }
 
-        private void WriteSparseArrayValues<T>(
+        private static void WriteSparseArrayValues<T>(
             BinaryWriter writer, int[] rows, int[] columns, T[] data)
           where T : struct
         {
@@ -497,7 +488,7 @@ namespace MatFileHandler
             }
         }
 
-        private (int[] rowIndex, int[] columnIndex, T[] data, uint nonZero) PrepareSparseArrayData<T>(
+        private static (int[] rowIndex, int[] columnIndex, T[] data, uint nonZero) PrepareSparseArrayData<T>(
             ISparseArrayOf<T> array)
             where T : struct, IEquatable<T>
         {
@@ -520,7 +511,7 @@ namespace MatFileHandler
             return (rowIndexList.ToArray(), columnIndex, valuesList.ToArray(), (uint)rowIndexList.Count);
         }
 
-        private void WriteSparseArrayContents<T>(
+        private static void WriteSparseArrayContents<T>(
             BinaryWriter writer,
             ISparseArrayOf<T> array,
             string name,
@@ -534,7 +525,7 @@ namespace MatFileHandler
             WriteSparseArrayValues(writer, rows, columns, data);
         }
 
-        private void WriteSparseArray<T>(BinaryWriter writer, ISparseArrayOf<T> sparseArray, string name, bool isGlobal)
+        private static void WriteSparseArray<T>(BinaryWriter writer, ISparseArrayOf<T> sparseArray, string name, bool isGlobal)
             where T : unmanaged, IEquatable<T>
         {
             WriteWrappingContents(
@@ -544,7 +535,7 @@ namespace MatFileHandler
                 contentsWriter => { WriteSparseArrayContents(contentsWriter, sparseArray, name, isGlobal); });
         }
 
-        private void WriteFieldNames(BinaryWriter writer, IEnumerable<string> fieldNames)
+        private static void WriteFieldNames(BinaryWriter writer, IEnumerable<string> fieldNames)
         {
             var fieldNamesArray = fieldNames.Select(name => Encoding.ASCII.GetBytes(name)).ToArray();
             var maxFieldName = fieldNamesArray.Select(name => name.Length).Max() + 1;
@@ -708,4 +699,4 @@ namespace MatFileHandler
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/MatSparseArrayOf.cs b/MatFileHandler/MatSparseArrayOf.cs
index acd34d5..4cc8fa8 100755
--- a/MatFileHandler/MatSparseArrayOf.cs
+++ b/MatFileHandler/MatSparseArrayOf.cs
@@ -49,7 +49,7 @@ namespace MatFileHandler
             get
             {
                 var rowAndColumn = GetRowAndColumn(list);
-                return DataDictionary.ContainsKey(rowAndColumn) ? DataDictionary[rowAndColumn] : default(T);
+                return DataDictionary.TryGetValue(rowAndColumn, out var result) ? result : default;
             }
             set => DataDictionary[GetRowAndColumn(list)] = value;
         }
@@ -61,7 +61,7 @@ namespace MatFileHandler
         public override double[] ConvertToDoubleArray()
         {
             var data = ((IArrayOf<T>)this).Data;
-            return data as double[] ?? data.Select(x => Convert.ToDouble(x)).ToArray();
+            return data as double[] ?? data.Select(x => Convert.ToDouble(x, System.Globalization.CultureInfo.InvariantCulture)).ToArray();
         }
 
         /// <inheritdoc />
@@ -75,7 +75,7 @@ namespace MatFileHandler
             var result = new double[Dimensions[0], Dimensions[1]];
             foreach (var pair in Data)
             {
-                result[pair.Key.row, pair.Key.column] = Convert.ToDouble(pair.Value);
+                result[pair.Key.row, pair.Key.column] = Convert.ToDouble(pair.Value, System.Globalization.CultureInfo.InvariantCulture);
             }
 
             return result;
@@ -104,4 +104,4 @@ namespace MatFileHandler
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MatFileHandler/MatStructureArray.cs b/MatFileHandler/MatStructureArray.cs
index a111bcd..b97c0c7 100755
--- a/MatFileHandler/MatStructureArray.cs
+++ b/MatFileHandler/MatStructureArray.cs
@@ -69,7 +69,7 @@ namespace MatFileHandler
                 "Cannot set structure elements via this[params int[]] indexer. Use this[string, int[]] instead.");
         }
 
-        private IReadOnlyDictionary<string, IArray> ExtractStructure(int i)
+        private MatStructureArrayElement ExtractStructure(int i)
         {
             return new MatStructureArrayElement(this, i);
         }
diff --git a/MatFileHandler/OpaqueLink.cs b/MatFileHandler/OpaqueLink.cs
index 803048d..c94a53e 100644
--- a/MatFileHandler/OpaqueLink.cs
+++ b/MatFileHandler/OpaqueLink.cs
@@ -85,7 +85,7 @@ namespace MatFileHandler
                     return result!;
                 }
 
-                throw new IndexOutOfRangeException();
+                throw new ArgumentOutOfRangeException(nameof(list));
             }
             set => throw new NotImplementedException();
         }
@@ -97,7 +97,7 @@ namespace MatFileHandler
             set => throw new NotImplementedException();
         }
 
-        private IReadOnlyDictionary<string, IArray> ExtractObject(int i)
+        private OpaqueObjectArrayElement ExtractObject(int i)
         {
             return new OpaqueObjectArrayElement(this, i);
         }
diff --git a/MatFileHandler/TableAdapter.cs b/MatFileHandler/TableAdapter.cs
index 1c4d44d..c506133 100644
--- a/MatFileHandler/TableAdapter.cs
+++ b/MatFileHandler/TableAdapter.cs
@@ -89,7 +89,7 @@ namespace MatFileHandler
                     .FirstOrDefault();
                 if (!(maybeIndex is int index))
                 {
-                    throw new IndexOutOfRangeException($"Variable '{variableName}' not found.");
+                    throw new ArgumentOutOfRangeException(nameof(variableName), $"Variable '{variableName}' not found.");
                 }
 
                 var data = matObject["data"] as ICellArray
@@ -98,4 +98,4 @@ namespace MatFileHandler
             }
         }
     }
-}
\ No newline at end of file
+}