mahalex/MatFileHandler
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects Releases 9 Wiki Activity

Enable .NET analyzers

Browse Source
This commit is contained in:
Alexander Luzgarev 2025-04-08 16:50:37 +02:00
parent 5080f35e69
commit 306992f969
14 changed files with 74 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
MatFileHandler/ChecksumCalculatingStream.cs
View File

@ -13,8 +13,8 @@ namespace MatFileHandler
{ {
private const uint BigPrime = 0xFFF1; private const uint BigPrime = 0xFFF1;
private readonly Stream _stream; private readonly Stream _stream;
private uint s1 = 1; private uint s1;
private uint s2 = 0; private uint s2;
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="ChecksumCalculatingStream"/> class. /// Initializes a new instance of the <see cref="ChecksumCalculatingStream"/> class.
@ -23,6 +23,8 @@ namespace MatFileHandler
public ChecksumCalculatingStream(Stream stream) public ChecksumCalculatingStream(Stream stream)
{ {
_stream = stream; _stream = stream;
s1 = 1;
s2 = 0;
} }
/// <inheritdoc /> /// <inheritdoc />

7
MatFileHandler/DataBuilder.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Numerics; using System.Numerics;
#pragma warning disable CA1822
namespace MatFileHandler namespace MatFileHandler
{ {
/// <summary> /// <summary>
@ -52,7 +53,7 @@ namespace MatFileHandler
{ {
if (data.Length != dimensions.NumberOfElements()) 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); return new MatNumericalArrayOf<T>(GetStandardFlags<T>(), dimensions, string.Empty, data);
} }
@ -157,7 +158,7 @@ namespace MatFileHandler
return new MatFile(variables); 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 return new ArrayFlags
{ {
@ -167,7 +168,7 @@ namespace MatFileHandler
}; };
} }
private ArrayFlags GetStandardFlags<T>() private static ArrayFlags GetStandardFlags<T>()
{ {
if (typeof(T) == typeof(sbyte)) if (typeof(T) == typeof(sbyte))
{ {

4
MatFileHandler/DataElementConverter.cs
View File

@ -71,9 +71,9 @@ namespace MatFileHandler
{ {
throw new NotSupportedException("Only 2-dimensional sparse arrays are supported"); 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 = var elements =
ConvertDataToSparseProperType<T>(data, flags.ArrayFlags.Variable.HasFlag(Variable.IsLogical)); ConvertDataToSparseProperType<T>(data, flags.ArrayFlags.Variable.HasFlag(Variable.IsLogical));

8
MatFileHandler/DataElementReader.cs
View File

@ -212,7 +212,7 @@ namespace MatFileHandler
} }
} }
private DataElement ContinueReadingCellArray( private MatCellArray ContinueReadingCellArray(
BinaryReader reader, BinaryReader reader,
ArrayFlags flags, ArrayFlags flags,
int[] dimensions, int[] dimensions,
@ -258,11 +258,11 @@ namespace MatFileHandler
} }
else 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, BinaryReader reader,
DataElement firstElement, DataElement firstElement,
int[] dimensions, int[] dimensions,
@ -313,7 +313,7 @@ namespace MatFileHandler
} }
} }
private DataElement ContinueReadingStructure( private MatStructureArray ContinueReadingStructure(
BinaryReader reader, BinaryReader reader,
ArrayFlags flags, ArrayFlags flags,
int[] dimensions, int[] dimensions,

10
MatFileHandler/FakeWriter.cs
View File

@ -202,24 +202,24 @@ namespace MatFileHandler
WriteDataElement(buffer); WriteDataElement(buffer);
} }
private unsafe int GetLengthOfByteArray<T>(int dataLength) private static unsafe int GetLengthOfByteArray<T>(int dataLength)
where T : unmanaged where T : unmanaged
{ {
return dataLength * sizeof(T); return dataLength * sizeof(T);
} }
private unsafe int GetLengthOfPairOfByteArrays<T>(ComplexOf<T>[] data) private static unsafe int GetLengthOfPairOfByteArrays<T>(ComplexOf<T>[] data)
where T : unmanaged where T : unmanaged
{ {
return data.Length * sizeof(T); return data.Length * sizeof(T);
} }
private unsafe int GetLengthOfPairOfByteArrays(Complex[] data) private static unsafe int GetLengthOfPairOfByteArrays(Complex[] data)
{ {
return data.Length * sizeof(double); return data.Length * sizeof(double);
} }
private int CalculatePadding(int length) private static int CalculatePadding(int length)
{ {
var rem = length % 8; var rem = length % 8;
if (rem == 0) 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) ISparseArrayOf<T> array)
where T : struct, IEquatable<T> where T : struct, IEquatable<T>
{ {

2
MatFileHandler/ICharArray.cs
View File

@ -10,6 +10,8 @@ namespace MatFileHandler
/// <summary> /// <summary>
/// Gets the contained string. /// Gets the contained string.
/// </summary> /// </summary>
#pragma warning disable CA1716, CA1720
string String { get; } string String { get; }
#pragma warning restore CA1716, CA1720
} }
} }

2
MatFileHandler/MatArray.cs
View File

@ -51,7 +51,7 @@ namespace MatFileHandler
/// <returns>Empty array.</returns> /// <returns>Empty array.</returns>
public static MatArray Empty() 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 /> /// <inheritdoc />

21
MatFileHandler/MatFileHandler.csproj
View File

@ -23,30 +23,21 @@
<EmbedUntrackedSources>true</EmbedUntrackedSources> <EmbedUntrackedSources>true</EmbedUntrackedSources>
<SymbolPackageFormat>snupkg</SymbolPackageFormat> <SymbolPackageFormat>snupkg</SymbolPackageFormat>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks> <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<AnalysisLevel>latest-Recommended</AnalysisLevel>
</PropertyGroup> </PropertyGroup>
<ItemGroup>
<PackageReference Include="System.ValueTuple" Version="4.4.0" Condition="'$(TargetFramework)' == 'net461'" />
</ItemGroup>
<ItemGroup> <ItemGroup>
<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" /> <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
</ItemGroup> </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> <ItemGroup>
<None Include="..\README.md" Pack="true" PackagePath="\"/> <None Include="..\README.md" Pack="true" PackagePath="\"/>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<InternalsVisibleTo Include="MatFileHandler.Tests" /> <InternalsVisibleTo Include="MatFileHandler.Tests" />
</ItemGroup> </ItemGroup>

2
MatFileHandler/MatFileReader.cs
View File

@ -88,7 +88,7 @@ namespace MatFileHandler
return ReadRawVariables(reader, subsystemDataOffset, subsystemData); return ReadRawVariables(reader, subsystemDataOffset, subsystemData);
} }
private static IMatFile Read(BinaryReader reader) private static MatFile Read(BinaryReader reader)
{ {
var header = ReadHeader(reader); var header = ReadHeader(reader);
var rawVariables = ReadRawVariables(reader, header.SubsystemDataOffset); var rawVariables = ReadRawVariables(reader, header.SubsystemDataOffset);

63
MatFileHandler/MatFileWriter.cs
View File

@ -69,7 +69,7 @@ namespace MatFileHandler
WriteVariable(writer, variable); WriteVariable(writer, variable);
break; break;
default: default:
throw new ArgumentOutOfRangeException(); throw new NotImplementedException();
} }
} }
} }
@ -98,7 +98,7 @@ namespace MatFileHandler
return (s2 << 16) | s1; 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(Encoding.UTF8.GetBytes(header.Text));
writer.Write(header.SubsystemDataOffset); writer.Write(header.SubsystemDataOffset);
@ -106,28 +106,19 @@ namespace MatFileHandler
writer.Write((short)19785); // Magic number, 'IM'. 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((int)tag.Type);
writer.Write(tag.Length); 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.Type);
writer.Write((short)tag.Length); writer.Write((short)tag.Length);
} }
private void WritePadding(BinaryWriter writer) private static void WriteDataElement(BinaryWriter writer, DataType type, byte[] data)
{
var positionMod8 = writer.BaseStream.Position % 8;
if (positionMod8 != 0)
{
writer.Write(new byte[8 - positionMod8]);
}
}
private void WriteDataElement(BinaryWriter writer, DataType type, byte[] data)
{ {
if (data.Length > 4) 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); var buffer = ConvertToByteArray(dimensions);
WriteDataElement(writer, DataType.MiInt32, buffer); WriteDataElement(writer, DataType.MiInt32, buffer);
} }
private byte[] ConvertToByteArray<T>(T[] data) private static byte[] ConvertToByteArray<T>(T[] data)
where T : struct where T : struct
{ {
int size; int size;
@ -211,26 +202,26 @@ namespace MatFileHandler
return buffer; 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 where T : struct
{ {
return (ConvertToByteArray(data.Select(x => x.Real).ToArray()), return (ConvertToByteArray(data.Select(x => x.Real).ToArray()),
ConvertToByteArray(data.Select(x => x.Imaginary).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()), return (ConvertToByteArray(data.Select(x => x.Real).ToArray()),
ConvertToByteArray(data.Select(x => x.Imaginary).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.real);
WriteDataElement(writer, type, data.complex); 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; var flag = (byte)flags.Variable;
WriteTag(writer, new Tag(DataType.MiUInt32, 8)); WriteTag(writer, new Tag(DataType.MiUInt32, 8));
@ -239,7 +230,7 @@ namespace MatFileHandler
writer.Write(new byte[] { 0, 0, 0, 0, 0, 0 }); 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; var flag = (byte)flags.ArrayFlags.Variable;
WriteTag(writer, new Tag(DataType.MiUInt32, 8)); WriteTag(writer, new Tag(DataType.MiUInt32, 8));
@ -249,13 +240,13 @@ namespace MatFileHandler
writer.Write(flags.NzMax); 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); var nameBytes = Encoding.ASCII.GetBytes(name);
WriteDataElement(writer, DataType.MiInt8, nameBytes); WriteDataElement(writer, DataType.MiInt8, nameBytes);
} }
private void WriteNumericalArrayValues(BinaryWriter writer, IArray value) private static void WriteNumericalArrayValues(BinaryWriter writer, IArray value)
{ {
switch (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; var variableFlags = isGlobal ? Variable.IsGlobal : 0;
switch (array) 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 where T : struct
{ {
var flags = GetArrayFlags(array, isGlobal); 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); return new ArrayFlags(ArrayType.MxChar, isGlobal ? Variable.IsGlobal : 0);
} }
private void WriteWrappingContents<T>( private static void WriteWrappingContents<T>(
BinaryWriter writer, BinaryWriter writer,
T array, T array,
Action<FakeWriter> lengthCalculator, Action<FakeWriter> lengthCalculator,
@ -426,7 +417,7 @@ namespace MatFileHandler
writeContents(writer); 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)); WriteArrayFlags(writer, GetArrayFlags(array, isGlobal));
WriteDimensions(writer, array.Dimensions); WriteDimensions(writer, array.Dimensions);
@ -434,7 +425,7 @@ namespace MatFileHandler
WriteNumericalArrayValues(writer, array); WriteNumericalArrayValues(writer, array);
} }
private void WriteNumericalArray( private static void WriteNumericalArray(
BinaryWriter writer, BinaryWriter writer,
IArray numericalArray, IArray numericalArray,
string name = "", string name = "",
@ -447,7 +438,7 @@ namespace MatFileHandler
contentsWriter => { WriteNumericalArrayContents(contentsWriter, numericalArray, name, isGlobal); }); 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)); WriteArrayFlags(writer, GetCharArrayFlags(isGlobal));
WriteDimensions(writer, charArray.Dimensions); WriteDimensions(writer, charArray.Dimensions);
@ -456,7 +447,7 @@ namespace MatFileHandler
WriteDataElement(writer, DataType.MiUtf16, ConvertToByteArray(array)); 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( WriteWrappingContents(
writer, writer,
@ -465,7 +456,7 @@ namespace MatFileHandler
contentsWriter => { WriteCharArrayContents(contentsWriter, charArray, name, isGlobal); }); contentsWriter => { WriteCharArrayContents(contentsWriter, charArray, name, isGlobal); });
} }
private void WriteSparseArrayValues<T>( private static void WriteSparseArrayValues<T>(
BinaryWriter writer, int[] rows, int[] columns, T[] data) BinaryWriter writer, int[] rows, int[] columns, T[] data)
where T : struct 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) ISparseArrayOf<T> array)
where T : struct, IEquatable<T> where T : struct, IEquatable<T>
{ {
@ -520,7 +511,7 @@ namespace MatFileHandler
return (rowIndexList.ToArray(), columnIndex, valuesList.ToArray(), (uint)rowIndexList.Count); return (rowIndexList.ToArray(), columnIndex, valuesList.ToArray(), (uint)rowIndexList.Count);
} }
private void WriteSparseArrayContents<T>( private static void WriteSparseArrayContents<T>(
BinaryWriter writer, BinaryWriter writer,
ISparseArrayOf<T> array, ISparseArrayOf<T> array,
string name, string name,
@ -534,7 +525,7 @@ namespace MatFileHandler
WriteSparseArrayValues(writer, rows, columns, data); 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> where T : unmanaged, IEquatable<T>
{ {
WriteWrappingContents( WriteWrappingContents(
@ -544,7 +535,7 @@ namespace MatFileHandler
contentsWriter => { WriteSparseArrayContents(contentsWriter, sparseArray, name, isGlobal); }); 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 fieldNamesArray = fieldNames.Select(name => Encoding.ASCII.GetBytes(name)).ToArray();
var maxFieldName = fieldNamesArray.Select(name => name.Length).Max() + 1; var maxFieldName = fieldNamesArray.Select(name => name.Length).Max() + 1;

6
MatFileHandler/MatSparseArrayOf.cs
View File

@ -49,7 +49,7 @@ namespace MatFileHandler
get get
{ {
var rowAndColumn = GetRowAndColumn(list); 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; set => DataDictionary[GetRowAndColumn(list)] = value;
} }
@ -61,7 +61,7 @@ namespace MatFileHandler
public override double[] ConvertToDoubleArray() public override double[] ConvertToDoubleArray()
{ {
var data = ((IArrayOf<T>)this).Data; 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 /> /// <inheritdoc />
@ -75,7 +75,7 @@ namespace MatFileHandler
var result = new double[Dimensions[0], Dimensions[1]]; var result = new double[Dimensions[0], Dimensions[1]];
foreach (var pair in Data) 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; return result;

2
MatFileHandler/MatStructureArray.cs
View File

@ -69,7 +69,7 @@ namespace MatFileHandler
"Cannot set structure elements via this[params int[]] indexer. Use this[string, int[]] instead."); "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); return new MatStructureArrayElement(this, i);
} }

4
MatFileHandler/OpaqueLink.cs
View File

@ -85,7 +85,7 @@ namespace MatFileHandler
return result!; return result!;
} }
throw new IndexOutOfRangeException(); throw new ArgumentOutOfRangeException(nameof(list));
} }
set => throw new NotImplementedException(); set => throw new NotImplementedException();
} }
@ -97,7 +97,7 @@ namespace MatFileHandler
set => throw new NotImplementedException(); set => throw new NotImplementedException();
} }
private IReadOnlyDictionary<string, IArray> ExtractObject(int i) private OpaqueObjectArrayElement ExtractObject(int i)
{ {
return new OpaqueObjectArrayElement(this, i); return new OpaqueObjectArrayElement(this, i);
} }

2
MatFileHandler/TableAdapter.cs
View File

@ -89,7 +89,7 @@ namespace MatFileHandler
.FirstOrDefault(); .FirstOrDefault();
if (!(maybeIndex is int index)) 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 var data = matObject["data"] as ICellArray