- caching of writer action for collections

snaumenko-st · snaumenko-st · commit 183d47b4b149 · 2024-04-19T18:21:41.000+04:00
- removed duplicate type resolving
- optimized Type HashCodes
- reduced memory allocation during writes
diff --git a/src/CsvHelper/CsvWriter.cs b/src/CsvHelper/CsvWriter.cs
@@ -331,7 +331,7 @@ public virtual void WriteRecord<T>(T record)
 		{
 			try
 			{
-				recordManager.Value.Write(record);
+				recordManager.Value.GetWriterAction<T>(GetTypeInfoForRecord(record))(record);
 			}
 			catch (TargetInvocationException ex)
 			{
@@ -362,6 +362,9 @@ public virtual void WriteRecords(IEnumerable records)
 					NextRecord();
 				}
 
+				Action<object> writerAction = null;
+				RecordTypeInfo writerActionType = default;
+
 				foreach (var record in records)
 				{
 					if (record == null)
@@ -371,7 +374,13 @@ public virtual void WriteRecords(IEnumerable records)
 						continue;
 					}
 
-					WriteRecord(record);
+					if (writerAction == null || writerActionType.RecordType != record.GetType())
+					{
+						writerActionType = GetTypeInfoForRecord(record);
+						writerAction = recordManager.Value.GetWriterAction<object>(writerActionType);
+					}
+
+					writerAction(record);
 					NextRecord();
 				}
 			}
@@ -393,9 +402,18 @@ public virtual void WriteRecords<T>(IEnumerable<T> records)
 					NextRecord();
 				}
 
+				Action<T> writerAction = null;
+				RecordTypeInfo writerActionType = default;
+
 				foreach (var record in records)
 				{
-					WriteRecord(record);
+					if (writerAction == null || (record != null && writerActionType.RecordType != record.GetType()))
+					{
+						writerActionType = GetTypeInfoForRecord(record);
+						writerAction = recordManager.Value.GetWriterAction<T>(writerActionType);
+					}
+
+					writerAction(record);
 					NextRecord();
 				}
 			}
@@ -420,11 +438,20 @@ public virtual async Task WriteRecordsAsync(IEnumerable records, CancellationTok
 					await NextRecordAsync().ConfigureAwait(false);
 				}
 
+				Action<object> writerAction = null;
+				RecordTypeInfo writerActionType = default;
+
 				foreach (var record in records)
 				{
 					cancellationToken.ThrowIfCancellationRequested();
 
-					WriteRecord(record);
+					if (writerAction == null || (record != null && writerActionType.RecordType != record.GetType()))
+					{
+						writerActionType = GetTypeInfoForRecord(record);
+						writerAction = recordManager.Value.GetWriterAction<object>(writerActionType);
+					}
+
+					writerAction(record);
 					await NextRecordAsync().ConfigureAwait(false);
 				}
 			}
@@ -449,11 +476,20 @@ public virtual async Task WriteRecordsAsync<T>(IEnumerable<T> records, Cancellat
 					await NextRecordAsync().ConfigureAwait(false);
 				}
 
+				Action<T> writerAction = null;
+				RecordTypeInfo writerActionType = default;
+
 				foreach (var record in records)
 				{
 					cancellationToken.ThrowIfCancellationRequested();
 
-					WriteRecord(record);
+					if (writerAction == null || (record != null && writerActionType.RecordType != record.GetType()))
+					{
+						writerActionType = GetTypeInfoForRecord(record);
+						writerAction = recordManager.Value.GetWriterAction<T>(writerActionType);
+					}
+
+					writerAction(record);
 					await NextRecordAsync().ConfigureAwait(false);
 				}
 			}
@@ -478,11 +514,20 @@ public virtual async Task WriteRecordsAsync<T>(IAsyncEnumerable<T> records, Canc
 					await NextRecordAsync().ConfigureAwait(false);
 				}
 
+				Action<T> writerAction = null;
+				RecordTypeInfo writerActionType = default;
+
 				await foreach (var record in records.ConfigureAwait(false))
 				{
 					cancellationToken.ThrowIfCancellationRequested();
 
-					WriteRecord(record);
+					if (writerAction == null || (record != null && writerActionType.RecordType != record.GetType()))
+					{
+						writerActionType = GetTypeInfoForRecord(record);
+						writerAction = recordManager.Value.GetWriterAction<T>(writerActionType);
+					}
+
+					writerAction(record);
 					await NextRecordAsync().ConfigureAwait(false);
 				}
 			}
@@ -576,15 +621,15 @@ public virtual bool CanWrite(MemberMap memberMap)
 		/// <typeparam name="T">The type of the record.</typeparam>
 		/// <param name="record">The record to determine the type of.</param>
 		/// <returns>The System.Type for the record.</returns>
-		public virtual Type GetTypeForRecord<T>(T record)
+		public virtual RecordTypeInfo GetTypeInfoForRecord<T>(T record)
 		{
 			var type = typeof(T);
 			if (type == typeof(object))
 			{
-				type = record.GetType();
+				return new RecordTypeInfo(record.GetType(), true);
 			}
 
-			return type;
+			return new RecordTypeInfo(type, false);
 		}
 
 		/// <summary>
diff --git a/src/CsvHelper/Expressions/DynamicRecordWriter.cs b/src/CsvHelper/Expressions/DynamicRecordWriter.cs
@@ -30,8 +30,8 @@ public DynamicRecordWriter(CsvWriter writer) : base(writer) { }
 		/// that will write the given record using the current writer row.
 		/// </summary>
 		/// <typeparam name="T">The record type.</typeparam>
-		/// <param name="record">The record.</param>
-		protected override Action<T> CreateWriteDelegate<T>(T record)
+		/// <param name="type">The type for the record.</param>
+		protected override Action<T> CreateWriteDelegate<T>(Type type)
 		{
 			// http://stackoverflow.com/a/14011692/68499
 
@@ -72,4 +72,4 @@ private object GetValue(string name, IDynamicMetaObjectProvider target)
 			return callSite.Target(callSite, target);
 		}
 	}
-}
+}
diff --git a/src/CsvHelper/Expressions/ExpandoObjectRecordWriter.cs b/src/CsvHelper/Expressions/ExpandoObjectRecordWriter.cs
@@ -24,8 +24,8 @@ public ExpandoObjectRecordWriter(CsvWriter writer) : base(writer) { }
 		/// that will write the given record using the current writer row.
 		/// </summary>
 		/// <typeparam name="T">The record type.</typeparam>
-		/// <param name="record">The record.</param>
-		protected override Action<T> CreateWriteDelegate<T>(T record)
+		/// <param name="type">The type for the record.</param>
+		protected override Action<T> CreateWriteDelegate<T>(Type type)
 		{
 			Action<T> action = r =>
 			{
@@ -46,4 +46,4 @@ protected override Action<T> CreateWriteDelegate<T>(T record)
 			return action;
 		}
 	}
-}
+}
diff --git a/src/CsvHelper/Expressions/ObjectRecordWriter.cs b/src/CsvHelper/Expressions/ObjectRecordWriter.cs
@@ -27,11 +27,9 @@ public ObjectRecordWriter(CsvWriter writer) : base(writer) { }
 		/// that will write the given record using the current writer row.
 		/// </summary>
 		/// <typeparam name="T">The record type.</typeparam>
-		/// <param name="record">The record.</param>
-		protected override Action<T> CreateWriteDelegate<T>(T record)
+		/// <param name="type">The type for the record.</param>
+		protected override Action<T> CreateWriteDelegate<T>(Type type)
 		{
-			var type = Writer.GetTypeForRecord(record);
-
 			if (Writer.Context.Maps[type] == null)
 			{
 				Writer.Context.Maps.Add(Writer.Context.AutoMap(type));
diff --git a/src/CsvHelper/Expressions/PrimitiveRecordWriter.cs b/src/CsvHelper/Expressions/PrimitiveRecordWriter.cs
@@ -25,11 +25,9 @@ public PrimitiveRecordWriter(CsvWriter writer) : base(writer) { }
 		/// that will write the given record using the current writer row.
 		/// </summary>
 		/// <typeparam name="T">The record type.</typeparam>
-		/// <param name="record">The record.</param>
-		protected override Action<T> CreateWriteDelegate<T>(T record)
+		/// <param name="type">The type for the record.</param>
+		protected override Action<T> CreateWriteDelegate<T>(Type type)
 		{
-			var type = Writer.GetTypeForRecord(record);
-
 			var recordParameter = Expression.Parameter(typeof(T), "record");
 
 			Expression fieldExpression = Expression.Convert(recordParameter, typeof(object));
diff --git a/src/CsvHelper/Expressions/RecordManager.cs b/src/CsvHelper/Expressions/RecordManager.cs
@@ -67,14 +67,15 @@ public void Hydrate<T>(T record)
 		}
 
 		/// <summary>
-		/// Writes the given record to the current writer row.
+		/// Gets Writer Action to write multiple rows faster
 		/// </summary>
-		/// <typeparam name="T">The type of the record.</typeparam>
-		/// <param name="record">The record.</param>
-		public void Write<T>(T record)
+		/// <param name="typeInfo"></param>
+		/// <typeparam name="T"></typeparam>
+		/// <returns></returns>
+		internal Action<T> GetWriterAction<T>(RecordTypeInfo typeInfo)
 		{
-			var recordWriter = recordWriterFactory.MakeRecordWriter(record);
-			recordWriter.Write(record);
+			var recordWriter = recordWriterFactory.MakeRecordWriter(typeInfo);
+			return recordWriter.GetWriteDelegate<T>(typeInfo);
 		}
 	}
 }
diff --git a/src/CsvHelper/Expressions/RecordWriter.cs b/src/CsvHelper/Expressions/RecordWriter.cs
@@ -66,7 +66,7 @@ public void Write<T>(T record)
 		/// </summary>
 		/// <typeparam name="T">The record type.</typeparam>
 		/// <param name="record">The record.</param>
-		protected Action<T> GetWriteDelegate<T>(T record)
+		protected internal Action<T> GetWriteDelegate<T>(T record)
 		{
 			var type = typeof(T);
 			var typeKeyName = type.AssemblyQualifiedName;
@@ -86,13 +86,44 @@ protected Action<T> GetWriteDelegate<T>(T record)
 			return (Action<T>)action;
 		}
 
+		/// <summary>
+		/// Gets the delegate to write the given record. 
+		/// If the delegate doesn't exist, one will be created and cached.
+		/// </summary>
+		/// <typeparam name="T">The record type.</typeparam>
+		/// <param name="typeInfo">The type for the record.</param>
+		protected internal Action<T> GetWriteDelegate<T>(RecordTypeInfo typeInfo)
+		{
+			var typeKey = typeInfo.RecordType.GetHashCode();
+
+			if (typeInfo.IsItemType)
+				typeKey = HashCode.Combine(17180427, typeKey);
+
+			if (!typeActions.TryGetValue(typeKey, out Delegate action))
+			{
+				typeActions[typeKey] = action = CreateWriteDelegate<T>(typeInfo.RecordType);
+			}
+
+			return (Action<T>)action;
+		}
+
 		/// <summary>
 		/// Creates a <see cref="Delegate"/> of type <see cref="Action{T}"/>
 		/// that will write the given record using the current writer row.
 		/// </summary>
 		/// <typeparam name="T">The record type.</typeparam>
 		/// <param name="record">The record.</param>
-		protected abstract Action<T> CreateWriteDelegate<T>(T record);
+		protected virtual Action<T> CreateWriteDelegate<T>(T record)
+		{
+			return CreateWriteDelegate<T>(Writer.GetTypeInfoForRecord(record).RecordType);
+		}
+
+		/// <summary>
+		/// Creates a <see cref="Delegate"/> of type <see cref="Action{T}"/>
+		/// that will write the given record using the current writer row.
+		/// </summary>
+		/// <param name="typeForRecord">The type for the record.</param>
+		protected abstract Action<T> CreateWriteDelegate<T>(Type typeForRecord);
 
 		/// <summary>
 		/// Combines the delegates into a single multicast delegate.
diff --git a/src/CsvHelper/Expressions/RecordWriterFactory.cs b/src/CsvHelper/Expressions/RecordWriterFactory.cs
@@ -2,8 +2,8 @@
 // This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
 // See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
 // https://github.com/JoshClose/CsvHelper
+
 using System.Dynamic;
-using System.Reflection;
 
 namespace CsvHelper.Expressions
 {
@@ -34,27 +34,23 @@ public RecordWriterFactory(CsvWriter writer)
 		/// <summary>
 		/// Creates a new record writer for the given record.
 		/// </summary>
-		/// <typeparam name="T">The type of the record.</typeparam>
-		/// <param name="record">The record.</param>
-		public virtual RecordWriter MakeRecordWriter<T>(T record)
+		/// <param name="typeInfo">The type of the record.</param>
+		public virtual RecordWriter MakeRecordWriter(RecordTypeInfo typeInfo)
 		{
-			var type = writer.GetTypeForRecord(record);
+			var type = typeInfo.RecordType;
 
-			if (record is ExpandoObject expandoObject)
+			if (type.IsPrimitive)
 			{
-				return expandoObjectRecordWriter;
+				return primitiveRecordWriter;
 			}
-
-			if (record is IDynamicMetaObjectProvider dynamicObject)
+			if (typeof(ExpandoObject).IsAssignableFrom(type))
 			{
-				return dynamicRecordWriter;
+				return expandoObjectRecordWriter;
 			}
-
-			if (type.GetTypeInfo().IsPrimitive)
+			if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(type))
 			{
-				return primitiveRecordWriter;
+				return dynamicRecordWriter;
 			}
-
 			return objectRecordWriter;
 		}
 	}
diff --git a/src/CsvHelper/RecordTypeInfo.cs b/src/CsvHelper/RecordTypeInfo.cs
@@ -0,0 +1,31 @@
+using System;
+
+namespace CsvHelper
+{
+	/// <summary>
+	/// Container for type info about written records
+	/// </summary>
+	public struct RecordTypeInfo
+	{
+		/// <summary>
+		/// .ctor
+		/// </summary>
+		/// <param name="recordType"></param>
+		/// <param name="isItemType"></param>
+		public RecordTypeInfo(Type recordType, bool isItemType)
+		{
+			RecordType = recordType;
+			IsItemType = isItemType;
+		}
+
+		/// <summary>
+		/// Final type of the record
+		/// </summary>
+		public Type RecordType { get; }
+
+		/// <summary>
+		/// Is this type from record item
+		/// </summary>
+		public bool IsItemType { get; }
+	}
+}

Original file line number	Diff line number	Diff line change
`@@ -331,7 +331,7 @@ public virtual void WriteRecord<T>(T record)`
`331`	`331`	`{`
`332`	`332`	`try`
`333`	`333`	`{`
`334`		`- recordManager.Value.Write(record);`
	`334`	`+ recordManager.Value.GetWriterAction<T>(GetTypeInfoForRecord(record))(record);`
`335`	`335`	`}`
`336`	`336`	`catch (TargetInvocationException ex)`
`337`	`337`	`{`
`@@ -362,6 +362,9 @@ public virtual void WriteRecords(IEnumerable records)`
`362`	`362`	`NextRecord();`
`363`	`363`	`}`
`364`	`364`
	`365`	`+ Action<object> writerAction = null;`
	`366`	`+ RecordTypeInfo writerActionType = default;`
	`367`	`+`
`365`	`368`	`foreach (var record in records)`
`366`	`369`	`{`
`367`	`370`	`if (record == null)`
`@@ -371,7 +374,13 @@ public virtual void WriteRecords(IEnumerable records)`
`371`	`374`	`continue;`
`372`	`375`	`}`
`373`	`376`
`374`		`- WriteRecord(record);`
	`377`	`+ if (writerAction == null \|\| writerActionType.RecordType != record.GetType())`
	`378`	`+ {`
	`379`	`+ writerActionType = GetTypeInfoForRecord(record);`
	`380`	`+ writerAction = recordManager.Value.GetWriterAction<object>(writerActionType);`
	`381`	`+ }`
	`382`	`+`
	`383`	`+ writerAction(record);`
`375`	`384`	`NextRecord();`
`376`	`385`	`}`
`377`	`386`	`}`
`@@ -393,9 +402,18 @@ public virtual void WriteRecords<T>(IEnumerable<T> records)`
`393`	`402`	`NextRecord();`
`394`	`403`	`}`
`395`	`404`
	`405`	`+ Action<T> writerAction = null;`
	`406`	`+ RecordTypeInfo writerActionType = default;`
	`407`	`+`
`396`	`408`	`foreach (var record in records)`
`397`	`409`	`{`
`398`		`- WriteRecord(record);`
	`410`	`+ if (writerAction == null \|\| (record != null && writerActionType.RecordType != record.GetType()))`
	`411`	`+ {`
	`412`	`+ writerActionType = GetTypeInfoForRecord(record);`
	`413`	`+ writerAction = recordManager.Value.GetWriterAction<T>(writerActionType);`
	`414`	`+ }`
	`415`	`+`
	`416`	`+ writerAction(record);`
`399`	`417`	`NextRecord();`
`400`	`418`	`}`
`401`	`419`	`}`
`@@ -420,11 +438,20 @@ public virtual async Task WriteRecordsAsync(IEnumerable records, CancellationTok`
`420`	`438`	`await NextRecordAsync().ConfigureAwait(false);`
`421`	`439`	`}`
`422`	`440`
	`441`	`+ Action<object> writerAction = null;`
	`442`	`+ RecordTypeInfo writerActionType = default;`
	`443`	`+`
`423`	`444`	`foreach (var record in records)`
`424`	`445`	`{`
`425`	`446`	`cancellationToken.ThrowIfCancellationRequested();`
`426`	`447`
`427`		`- WriteRecord(record);`
	`448`	`+ if (writerAction == null \|\| (record != null && writerActionType.RecordType != record.GetType()))`
	`449`	`+ {`
	`450`	`+ writerActionType = GetTypeInfoForRecord(record);`
	`451`	`+ writerAction = recordManager.Value.GetWriterAction<object>(writerActionType);`
	`452`	`+ }`
	`453`	`+`
	`454`	`+ writerAction(record);`
`428`	`455`	`await NextRecordAsync().ConfigureAwait(false);`
`429`	`456`	`}`
`430`	`457`	`}`
`@@ -449,11 +476,20 @@ public virtual async Task WriteRecordsAsync<T>(IEnumerable<T> records, Cancellat`
`449`	`476`	`await NextRecordAsync().ConfigureAwait(false);`
`450`	`477`	`}`
`451`	`478`
	`479`	`+ Action<T> writerAction = null;`
	`480`	`+ RecordTypeInfo writerActionType = default;`
	`481`	`+`
`452`	`482`	`foreach (var record in records)`
`453`	`483`	`{`
`454`	`484`	`cancellationToken.ThrowIfCancellationRequested();`
`455`	`485`
`456`		`- WriteRecord(record);`
	`486`	`+ if (writerAction == null \|\| (record != null && writerActionType.RecordType != record.GetType()))`
	`487`	`+ {`
	`488`	`+ writerActionType = GetTypeInfoForRecord(record);`
	`489`	`+ writerAction = recordManager.Value.GetWriterAction<T>(writerActionType);`
	`490`	`+ }`
	`491`	`+`
	`492`	`+ writerAction(record);`
`457`	`493`	`await NextRecordAsync().ConfigureAwait(false);`
`458`	`494`	`}`
`459`	`495`	`}`
`@@ -478,11 +514,20 @@ public virtual async Task WriteRecordsAsync<T>(IAsyncEnumerable<T> records, Canc`
`478`	`514`	`await NextRecordAsync().ConfigureAwait(false);`
`479`	`515`	`}`
`480`	`516`
	`517`	`+ Action<T> writerAction = null;`
	`518`	`+ RecordTypeInfo writerActionType = default;`
	`519`	`+`
`481`	`520`	`await foreach (var record in records.ConfigureAwait(false))`
`482`	`521`	`{`
`483`	`522`	`cancellationToken.ThrowIfCancellationRequested();`
`484`	`523`
`485`		`- WriteRecord(record);`
	`524`	`+ if (writerAction == null \|\| (record != null && writerActionType.RecordType != record.GetType()))`
	`525`	`+ {`
	`526`	`+ writerActionType = GetTypeInfoForRecord(record);`
	`527`	`+ writerAction = recordManager.Value.GetWriterAction<T>(writerActionType);`
	`528`	`+ }`
	`529`	`+`
	`530`	`+ writerAction(record);`
`486`	`531`	`await NextRecordAsync().ConfigureAwait(false);`
`487`	`532`	`}`
`488`	`533`	`}`
`@@ -576,15 +621,15 @@ public virtual bool CanWrite(MemberMap memberMap)`
`576`	`621`	`/// <typeparam name="T">The type of the record.</typeparam>`
`577`	`622`	`/// <param name="record">The record to determine the type of.</param>`
`578`	`623`	`/// <returns>The System.Type for the record.</returns>`
`579`		`- public virtual Type GetTypeForRecord<T>(T record)`
	`624`	`+ public virtual RecordTypeInfo GetTypeInfoForRecord<T>(T record)`
`580`	`625`	`{`
`581`	`626`	`var type = typeof(T);`
`582`	`627`	`if (type == typeof(object))`
`583`	`628`	`{`
`584`		`- type = record.GetType();`
	`629`	`+ return new RecordTypeInfo(record.GetType(), true);`
`585`	`630`	`}`
`586`	`631`
`587`		`- return type;`
	`632`	`+ return new RecordTypeInfo(type, false);`
`588`	`633`	`}`
`589`	`634`
`590`	`635`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,8 @@ public DynamicRecordWriter(CsvWriter writer) : base(writer) { }`
`30`	`30`	`/// that will write the given record using the current writer row.`
`31`	`31`	`/// </summary>`
`32`	`32`	`/// <typeparam name="T">The record type.</typeparam>`
`33`		`- /// <param name="record">The record.</param>`
`34`		`- protected override Action<T> CreateWriteDelegate<T>(T record)`
	`33`	`+ /// <param name="type">The type for the record.</param>`
	`34`	`+ protected override Action<T> CreateWriteDelegate<T>(Type type)`
`35`	`35`	`{`
`36`	`36`	`// http://stackoverflow.com/a/14011692/68499`
`37`	`37`
`@@ -72,4 +72,4 @@ private object GetValue(string name, IDynamicMetaObjectProvider target)`
`72`	`72`	`return callSite.Target(callSite, target);`
`73`	`73`	`}`
`74`	`74`	`}`
`75`		`-}`
	`75`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@ public ExpandoObjectRecordWriter(CsvWriter writer) : base(writer) { }`
`24`	`24`	`/// that will write the given record using the current writer row.`
`25`	`25`	`/// </summary>`
`26`	`26`	`/// <typeparam name="T">The record type.</typeparam>`
`27`		`- /// <param name="record">The record.</param>`
`28`		`- protected override Action<T> CreateWriteDelegate<T>(T record)`
	`27`	`+ /// <param name="type">The type for the record.</param>`
	`28`	`+ protected override Action<T> CreateWriteDelegate<T>(Type type)`
`29`	`29`	`{`
`30`	`30`	`Action<T> action = r =>`
`31`	`31`	`{`
`@@ -46,4 +46,4 @@ protected override Action<T> CreateWriteDelegate<T>(T record)`
`46`	`46`	`return action;`
`47`	`47`	`}`
`48`	`48`	`}`
`49`		`-}`
	`49`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -27,11 +27,9 @@ public ObjectRecordWriter(CsvWriter writer) : base(writer) { }`
`27`	`27`	`/// that will write the given record using the current writer row.`
`28`	`28`	`/// </summary>`
`29`	`29`	`/// <typeparam name="T">The record type.</typeparam>`
`30`		`- /// <param name="record">The record.</param>`
`31`		`- protected override Action<T> CreateWriteDelegate<T>(T record)`
	`30`	`+ /// <param name="type">The type for the record.</param>`
	`31`	`+ protected override Action<T> CreateWriteDelegate<T>(Type type)`
`32`	`32`	`{`
`33`		`- var type = Writer.GetTypeForRecord(record);`
`34`		`-`
`35`	`33`	`if (Writer.Context.Maps[type] == null)`
`36`	`34`	`{`
`37`	`35`	`Writer.Context.Maps.Add(Writer.Context.AutoMap(type));`
Original file line number	Diff line number	Diff line change
`@@ -67,14 +67,15 @@ public void Hydrate<T>(T record)`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`/// <summary>`
`70`		`- /// Writes the given record to the current writer row.`
	`70`	`+ /// Gets Writer Action to write multiple rows faster`
`71`	`71`	`/// </summary>`
`72`		`- /// <typeparam name="T">The type of the record.</typeparam>`
`73`		`- /// <param name="record">The record.</param>`
`74`		`- public void Write<T>(T record)`
	`72`	`+ /// <param name="typeInfo"></param>`
	`73`	`+ /// <typeparam name="T"></typeparam>`
	`74`	`+ /// <returns></returns>`
	`75`	`+ internal Action<T> GetWriterAction<T>(RecordTypeInfo typeInfo)`
`75`	`76`	`{`
`76`		`- var recordWriter = recordWriterFactory.MakeRecordWriter(record);`
`77`		`- recordWriter.Write(record);`
	`77`	`+ var recordWriter = recordWriterFactory.MakeRecordWriter(typeInfo);`
	`78`	`+ return recordWriter.GetWriteDelegate<T>(typeInfo);`
`78`	`79`	`}`
`79`	`80`	`}`
`80`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,8 @@`
`2`	`2`	`// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.`
`3`	`3`	`// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.`
`4`	`4`	`// https://github.com/JoshClose/CsvHelper`
	`5`	`+`
`5`	`6`	`using System.Dynamic;`
`6`		`-using System.Reflection;`
`7`	`7`
`8`	`8`	`namespace CsvHelper.Expressions`
`9`	`9`	`{`
`@@ -34,27 +34,23 @@ public RecordWriterFactory(CsvWriter writer)`
`34`	`34`	`/// <summary>`
`35`	`35`	`/// Creates a new record writer for the given record.`
`36`	`36`	`/// </summary>`
`37`		`- /// <typeparam name="T">The type of the record.</typeparam>`
`38`		`- /// <param name="record">The record.</param>`
`39`		`- public virtual RecordWriter MakeRecordWriter<T>(T record)`
	`37`	`+ /// <param name="typeInfo">The type of the record.</param>`
	`38`	`+ public virtual RecordWriter MakeRecordWriter(RecordTypeInfo typeInfo)`
`40`	`39`	`{`
`41`		`- var type = writer.GetTypeForRecord(record);`
	`40`	`+ var type = typeInfo.RecordType;`
`42`	`41`
`43`		`- if (record is ExpandoObject expandoObject)`
	`42`	`+ if (type.IsPrimitive)`
`44`	`43`	`{`
`45`		`- return expandoObjectRecordWriter;`
	`44`	`+ return primitiveRecordWriter;`
`46`	`45`	`}`
`47`		`-`
`48`		`- if (record is IDynamicMetaObjectProvider dynamicObject)`
	`46`	`+ if (typeof(ExpandoObject).IsAssignableFrom(type))`
`49`	`47`	`{`
`50`		`- return dynamicRecordWriter;`
	`48`	`+ return expandoObjectRecordWriter;`
`51`	`49`	`}`
`52`		`-`
`53`		`- if (type.GetTypeInfo().IsPrimitive)`
	`50`	`+ if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(type))`
`54`	`51`	`{`
`55`		`- return primitiveRecordWriter;`
	`52`	`+ return dynamicRecordWriter;`
`56`	`53`	`}`
`57`		`-`
`58`	`54`	`return objectRecordWriter;`
`59`	`55`	`}`
`60`	`56`	`}`