We now use CFNCSVConverterOptions to specify all options for a CFNCSVConverter which makes code more readable and is more compatible with DI.

Author: RobThree

CFNReader.Tests/CFNCSVConverterTests.cs

@@ -7,13 +7,14 @@ public class CFNCSVConverterTests
     public async Task CFNCSVConverter_Converts_Correctly()
     {
         var fromtime = TimeSpan.FromSeconds(10.5);
-        var csvconverter = new CFNCSVConverter(
-            channels: [Channel.AccumulatedCapacity, Channel.VBusVoltage],
-            predicate: (dp) => dp.Time >= fromtime,
-            separator: "!",
-            includeUnit: true,
-            limitDataPoints: 2
-        );
+        var csvconverter = new CFNCSVConverter(new CFNCSVConverterOptions()
+        {
+            Channels = [Channel.AccumulatedCapacity, Channel.VBusVoltage],
+            Predicate = (dp) => dp.Time >= fromtime,
+            Separator = "!",
+            IncludeUnit = true,
+            LimitDataPoints = 2
+        });
 
         using var testfile = File.OpenRead("Testfiles/test.cfn");
         using var csvfile = new MemoryStream();

CFNReader/CFNCSVConverter.cs

@@ -1,64 +1,44 @@
-using System;
+using Microsoft.Extensions.Options;
+using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace CFNReader;
 
-public class CFNCSVConverter(
-    IEnumerable<Channel>? channels = null,
-    Func<Datapoint, bool>? predicate = null,
-    IFormatProvider? formatProvider = null,
-    string separator = ";",
-    Encoding? encoding = null,
-    string timeFormat = "G",
-    string valueFormat = "N4",
-    bool includeHeader = true,
-    bool includeTime = true,
-    bool includeUnit = false,
-    int limitDataPoints = int.MaxValue
-)
+public class CFNCSVConverter(IOptions<CFNCSVConverterOptions> options)
 {
-    private readonly IEnumerable<Channel>? _channels = channels;
-    private readonly Func<Datapoint, bool> _predicate = predicate ?? (_ => true);
-    private readonly IFormatProvider _formatprovider = formatProvider ?? CultureInfo.InvariantCulture;
-    private readonly string _separator = separator;
-    private readonly Encoding _encoding = encoding ?? Encoding.UTF8;
-    private readonly string _timeformat = timeFormat;
-    private readonly string _valueformat = valueFormat;
-    private readonly bool _includeheader = includeHeader;
-    private readonly bool _includetime = includeTime;
-    private readonly bool _includeunit = includeUnit;
-    private readonly int _maxdatapoints = limitDataPoints;
+    private readonly CFNCSVConverterOptions _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
+
+    public CFNCSVConverter(CFNCSVConverterOptions options)
+        : this(Options.Create(options)) { }
 
     public async Task ConvertToCSVAsync(Stream cnfStream, Stream csvStream, CancellationToken cancellationToken = default)
     {
         var cfnreader = new CFNStreamReader(cnfStream);
 
         var fileinfo = await cfnreader.ReadFileInfoAsync(cancellationToken);
 
-        var exportchannels = (_channels ?? fileinfo.Channels.Keys).Where(fileinfo.Channels.ContainsKey).ToArray();
+        var exportchannels = (_options.Channels ?? fileinfo.Channels.Keys).Where(fileinfo.Channels.ContainsKey).ToArray();
 
-        using var sw = new StreamWriter(csvStream, _encoding, -1, true);
+        using var sw = new StreamWriter(csvStream, _options.Encoding, -1, true);
 
-        if (_includeheader)
+        if (_options.IncludeHeader)
         {
-            await sw.WriteLineAsync(string.Join(_separator, GetHeaderNames(exportchannels)));
+            await sw.WriteLineAsync(string.Join(_options.Separator, GetHeaderNames(exportchannels)));
         }
 
-        await foreach (var dp in cfnreader.ReadDatapointsAsync(fileinfo, cancellationToken).Where(_predicate).Take(_maxdatapoints))
+        await foreach (var dp in cfnreader.ReadDatapointsAsync(fileinfo, cancellationToken).Where(_options.Predicate).Take(_options.LimitDataPoints))
         {
-            await sw.WriteLineAsync(string.Join(_separator, GetValues(exportchannels, dp)));
+            await sw.WriteLineAsync(string.Join(_options.Separator, GetValues(exportchannels, dp)));
         }
     }
 
     private IEnumerable<string> GetHeaderNames(Channel[] channels)
     {
-        if (_includetime)
+        if (_options.IncludeTime)
         {
             yield return nameof(Datapoint.Time);
         }
@@ -70,9 +50,9 @@ private IEnumerable<string> GetHeaderNames(Channel[] channels)
 
     private IEnumerable<string> GetValues(Channel[] channels, Datapoint datapoint)
     {
-        if (_includetime)
+        if (_options.IncludeTime)
         {
-            yield return datapoint.Time.ToString(_timeformat, _formatprovider);
+            yield return datapoint.Time.ToString(_options.TimeFormat, _options.FormatProvider);
         }
         foreach (var channel in channels)
         {
@@ -81,5 +61,5 @@ private IEnumerable<string> GetValues(Channel[] channels, Datapoint datapoint)
     }
 
     private string FormatValue(UnitValue value)
-        => $"{value.Value.ToString(_valueformat, _formatprovider)}{(_includeunit ? value.Unit : string.Empty)}";
+        => $"{value.Value.ToString(_options.ValueFormat, _options.FormatProvider)}{(_options.IncludeUnit ? value.Unit : string.Empty)}";
 }

CFNReader/CFNCSVConverterOptions.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+
+namespace CFNReader;
+
+public record CFNCSVConverterOptions
+{
+    public IEnumerable<Channel> Channels { get; init; } = DefaultChannels;
+    public Func<Datapoint, bool> Predicate { get; init; } = DefaultPredicate;
+    public IFormatProvider? FormatProvider { get; init; } = DefaultFormatProvider;
+    public string Separator { get; init; } = DefaultSeparator;
+    public Encoding? Encoding { get; init; } = DefaultEncoding;
+    public string TimeFormat { get; init; } = DefaultTimeFormat;
+    public string ValueFormat { get; init; } = DefaultValueFormat;
+    public bool IncludeHeader { get; init; } = DefaultIncludeHeader;
+    public bool IncludeTime { get; init; } = DefaultIncludeTime;
+    public bool IncludeUnit { get; init; } = DefaultIncludeUnit;
+    public int LimitDataPoints { get; init; } = DefaultLimitDataPoints;
+
+    public static readonly CFNCSVConverterOptions Default = new();
+
+    public static readonly IEnumerable<Channel> DefaultChannels = [Channel.VBusVoltage, Channel.VBusCurrent];
+    public static readonly Func<Datapoint, bool> DefaultPredicate = _ => true;
+    public static readonly IFormatProvider DefaultFormatProvider = CultureInfo.InvariantCulture;
+    public const string DefaultSeparator = ";";
+    public static readonly Encoding DefaultEncoding = Encoding.UTF8;
+    public const string DefaultTimeFormat = "G";
+    public const string DefaultValueFormat = "N4";
+    public const bool DefaultIncludeHeader = true;
+    public const bool DefaultIncludeTime = true;
+    public const bool DefaultIncludeUnit = false;
+    public const int DefaultLimitDataPoints = int.MaxValue;
+}

CFNReader/CFNReader.csproj

@@ -28,13 +28,14 @@
 	</ItemGroup>
 
 	<ItemGroup>
+		<PackageReference Include="Microsoft.Extensions.Options" Version="9.0.3" />
 		<PackageReference Include="System.Linq.Async" Version="6.0.1" />
-		<PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
-		<PackageReference Include="PolySharp" Version="1.14.1">
+		<PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="9.0.3" />
+		<PackageReference Include="PolySharp" Version="1.15.0">
 			<PrivateAssets>all</PrivateAssets>
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 		</PackageReference>
-		<PackageReference Include="System.Memory" Version="4.5.5" />
+		<PackageReference Include="System.Memory" Version="4.6.0" />
 	</ItemGroup>
 
 	<ItemGroup>

CFNReader/CFNStreamReader.cs

@@ -65,7 +65,7 @@ private static async Task<double[]> ReadDataAsync(Stream stream, byte[] buffer,
         var bytesread = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken);
         return bytesread != buffer.Length
             ? throw new MalformedRecordException(typeof(UnitValue[]), stream.Position, buffer.Length, bytesread)
-            : Enumerable.Range(0, count).Select(i => BitConverter.ToDouble(buffer, i * _doublesize)).ToArray();
+            : [.. Enumerable.Range(0, count).Select(i => BitConverter.ToDouble(buffer, i * _doublesize))];
     }
 
     private Task<HeaderRecord> ReadHeaderAsync(CancellationToken cancellationToken = default)