changed to extension methods

README.md

@@ -30,7 +30,8 @@ Example:
        }
 ```
 
-This offers you the granular control over each element. In addition you can also use `Parse<T>()` and `TryParse<T>(out var val)` on Col
+This offers you the granular control over each element. The API offers a list of extension Methods for the `Col` struct which allows
+you to Parse to any given type; `ParseInt()`, `ParseLong()`, `ParseFloat()`, `ParseDateTime()` etc.
 
 Example:
 ```c#
@@ -42,7 +43,7 @@ Example:
        {
             foreach (var col in row.Cols)
             {
-                sum += col.Parse<int>();
+                sum += col.ParseInt();
             }
        }
 ```
@@ -108,27 +109,23 @@ Behind the curtains Kafa is using `KafaPooledWriter` a pooled IBufferWriter to w
             {
                 new CsvData{ Date = DateTime.Parse("10/10/2023 4:08:38 PM"), Open=12.45, Close=12.99, High=13.00, Low=12.1, Name="AMZN", Volume=1233435512},
                 new CsvData{ Date = DateTime.Parse("10/10/2023 4:08:38 PM"), Open=12.45, Close=12.99, High=13.00, Low=12.1, Name="AMZN", Volume=1233435512}
-            };
-
+            };    
             // get a ReadOnlySpan<bytes>
             var spanOfbytes = await Kafa.Write<CsvData>(csvs);
-            string result = Encoding.UTF8.GetString(spanOfbytes);
+            string result = Encoding.UTF8.GetString(spanOfbytes);    
 
             // or 
-            // write to an Stream
-
-            using var stream = await Kafa.WriteToStreamAsync<CsvData>(csvs);
+            // write to an Stream    
+            using var stream = await Kafa.WriteToStreamAsync<CsvData>(csvs);  
 
             // or 
-            // Write to a IBufferWriter<byte> for zero allocation writes
-
+            // Write to a IBufferWriter<byte> for zero allocation writes    
             var arrayWriter = new ArrayBufferWriter<byte>();
             Kafa.Write<CsvData>(arrayWriter, csvs);
-            var str = Encoding.UTF8.GetString(arrayWriter.WrittenSpan);
-
+            var str = Encoding.UTF8.GetString(arrayWriter.WrittenSpan);    
+            
             // or
-            // write directly to a file
-
+            // write directly to a file    
             await Kafa.WriteToFileAsync<CsvData>(csvs,@"C:\Users\ADMIN\Documents");
 
 ```

src/Kafa/Kafa.Span.cs

@@ -19,8 +19,7 @@ public static IEnumerable<T> Read<T>(string content, KafaOptions? options = null
         {
             ArgumentNullException.ThrowIfNullOrEmpty(content, nameof(content));
             var rows = Read(content.AsSpan(), options);
-            var typeInfo = new KafaTypeInfo(typeof(T), options);
-            var reflection = new KafaReflection(typeInfo);
+            var reflection = SetupOptions<T>(options);
             return reflection.SetProperties<T>(rows);
         }
 

src/Kafa/Kafa.Stream.cs

@@ -31,8 +31,7 @@ public static RowEnumerable Read(Stream ioStream, KafaOptions? options = null)
         public static IEnumerable<T> Read<T>(Stream ioStream, KafaOptions? options = null)
         {
             var rowEnumerable = Read(ioStream, options);
-            var typeInfo = new KafaTypeInfo(typeof(T), options);
-            var reflection = new KafaReflection(typeInfo);
+            var reflection = SetupOptions<T>(options);
             return reflection.SetProperties<T>(rowEnumerable);
         }
 
@@ -64,8 +63,7 @@ public static async ValueTask<RowEnumerable> ReadAsync(Stream ioStream, KafaOpti
         public static async ValueTask<IEnumerable<T>> ReadAsync<T>(Stream ioStream, KafaOptions? options = null, CancellationToken cancellationToken = default)
         {
             var rows = await ReadAsync(ioStream, options, cancellationToken).ConfigureAwait(false);
-            var typeInfo = new KafaTypeInfo(typeof(T), options);
-            var reflection = new KafaReflection(typeInfo);
+            var reflection = SetupOptions<T>(options);
             return reflection.SetProperties<T>(rows);
         }
 

src/Kafa/Kafa.csproj

@@ -7,8 +7,4 @@
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     <CompilerGeneratedFilesOutputPath>Generated</CompilerGeneratedFilesOutputPath>
   </PropertyGroup>
-
-  <ItemGroup> 
-    <Folder Include="Reader\" />
-  </ItemGroup>
 </Project>

src/Kafa/Reader/ColParser.cs

@@ -0,0 +1,48 @@
+namespace nyingi.Kafa.Reader;
+
+public static class ColParser
+{
+    public static bool? ParseBool(this KafaReader.Col col)
+    {
+        return bool.Parse(col.Value);
+    }
+    public static int? ParseInt(this KafaReader.Col col, IFormatProvider? formatProvider=null)
+    {
+        return int.Parse(col.Value, formatProvider);
+    }
+
+    public static long? ParseLong(this KafaReader.Col col, IFormatProvider? formatProvider=null)
+    {
+        return long.Parse(col.Value, formatProvider);
+    }
+
+    public static float? ParseFloat(this KafaReader.Col col, IFormatProvider? formatProvider=null)
+    {
+        return float.Parse(col.Value, formatProvider);
+    }
+
+    public static double? ParseDouble(this KafaReader.Col col, IFormatProvider? formatProvider=null)
+    {
+        return double.Parse(col.Value, formatProvider);
+    }
+
+    public static decimal? ParseDecimal(this KafaReader.Col col, IFormatProvider? formatProvider=null)
+    {
+        return decimal.Parse(col.Value, formatProvider);
+    }
+
+    public static DateTime? ParseDateTime(this KafaReader.Col col, IFormatProvider? formatProvider=null)
+    {
+        return DateTime.Parse(col.Value, formatProvider);
+    }
+
+    public static DateTimeOffset? ParseDateTimeOffSet(this KafaReader.Col col, IFormatProvider? formatProvider=null)
+    {
+        return DateTimeOffset.Parse(col.Value, formatProvider);
+    }
+
+    public static Guid? ParseGuid(this KafaReader.Col col, IFormatProvider? formatProvider=null)
+    {
+        return Guid.Parse(col.Value, formatProvider);
+    }
+}

src/Kafa/Reader/KafaReader.Col.cs

@@ -30,14 +30,7 @@ public Col(ColEnumerable colEnumerable, string columnName)
                 int index = _colEnumerable.ReadColByHeader(columnName);
                 Value = _colEnumerable.ReadColAsSpan(index);
             }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public T Parse<T>() where T : ISpanParsable<T> => _colEnumerable.Parse<T>(Value);
-
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool TryParse<T>(out T? result) where T : ISpanParsable<T> => _colEnumerable.TryParse(Value, out result);
-
+
             public override string ToString()
             {
                 return $"{Value}";
@@ -95,17 +88,6 @@ public ReadOnlySpan<char> ReadColAsSpan(int index)
                 return mem.Span;
             } 
 
-
-            public readonly T Parse<T>(ReadOnlySpan<char> scanSpan) where T : ISpanParsable<T>
-            {
-                return T.Parse(scanSpan, _reader.cultureInfo);
-            }
-
-            public readonly bool TryParse<T>(ReadOnlySpan<char> colValue, out T? result) where T : ISpanParsable<T>
-            {
-                return T.TryParse(colValue, _reader.cultureInfo, out result);
-            }
-
             public Enumerator GetEnumerator() => new Enumerator(this);
 
 

src/Kafa/Reflection/KafaReflection.Writer.cs

@@ -1,6 +1,7 @@
 using System.Collections.Specialized;
+using System.Globalization;
 using System.Reflection;
-using System.Reflection.PortableExecutable;
+using nyingi.Kafa.Reader;
 using static nyingi.Kafa.Reader.KafaReader;
 
 namespace nyingi.Kafa.Reflection
@@ -10,10 +11,12 @@ internal partial class KafaReflection
         private Dictionary<int, PropertyInfo> properties= default;
 
         public readonly KafaTypeInfo TypeInfo;
+        private readonly CultureInfo? _cultureInfo;
         public KafaReflection(KafaTypeInfo typeInfo) 
         {
             // match propertyName with header
             TypeInfo = typeInfo;
+            _cultureInfo = TypeInfo.KafaOptions.CultureInfo;
         }
 
         private void ReadHeader(OrderedDictionary headers = null)
@@ -88,47 +91,51 @@ public IEnumerable<T> SetProperties<T>(RowEnumerable rows)
 
             return instance;
         }
-
-
-
         private object? TypeResolver(Type type, Col col)
         {
-
             if (type == typeof(string))
             {
-                return col.Value.ToString();
+                return col.ToString();
             }
             else if (type == typeof(int))
             {
-                return col.Parse<int>();
+                return col.ParseInt(_cultureInfo);
             }
             else if(type == typeof(long))
             {
-                return col.Parse<long>();
+                return col.ParseLong(_cultureInfo);
             }
             else if(type == typeof(float))
             {
-                return col.Parse<float>();
+                return col.ParseFloat(_cultureInfo);
             }
             else if(type == typeof(double))
             {
-                return col.Parse<double>();
+                return col.ParseDouble(_cultureInfo);
             }
             else if(type == typeof(decimal))
             {
-                return col.Parse<decimal>();
+                return col.ParseDecimal(_cultureInfo);
+            }
+            else if(type == typeof(bool))
+            {
+                return col.ParseBool();
             }
             else if(type == typeof(DateTime))
             {
-                return col.Parse<DateTime>();
+                return col.ParseDateTime(_cultureInfo);
             }
             else if(type == typeof(DateTimeOffset))
             {
-                return col.Parse<DateTimeOffset>();
+                return col.ParseDateTimeOffSet(_cultureInfo);
+            }
+            else if (type == typeof(Guid))
+            {
+                return col.ParseGuid(_cultureInfo);
             }
             else
             {
-                return default;
+                return null;
             }
 
         }