Changed name of CsvConfiguration.FromType to FromAttributes.

src/CsvHelper/Configuration/Attributes/CultureInfoAttribute.cs

@@ -11,7 +11,7 @@ namespace CsvHelper.Configuration.Attributes
 	/// When applied to a member, specifies the <see cref="System.Globalization.CultureInfo"/>
 	/// used when type converting the member. When applied to a type, the value of
 	/// <see cref="CsvConfiguration.CultureInfo"/> in the <see cref="CsvConfiguration"/>
-	/// returned by <see cref="CsvConfiguration.FromType{T}()"/>
+	/// returned by <see cref="CsvConfiguration.FromAttributes{T}()"/>
 	/// </summary>
 	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
 	public class CultureInfoAttribute : Attribute, IClassMapper, IMemberMapper, IParameterMapper

src/CsvHelper/Configuration/CsvConfiguration.cs

@@ -264,31 +264,31 @@ public CsvConfiguration ApplyAttributes(Type type)
 		/// <exception cref="ConfigurationException">If <typeparamref name="T"/> is not annotated with <see cref="CultureInfoAttribute"/>.</exception>
 		/// <exception cref="ArgumentNullException">If the argument to the <see cref="CultureInfoAttribute"/> is <see langword="null"/>.</exception>
 		/// <exception cref="CultureNotFoundException">If the argument to the <see cref="CultureInfoAttribute"/> does not specify a supported culture.</exception>
-		public static CsvConfiguration FromType<T>()
+		public static CsvConfiguration FromAttributes<T>()
 		{
-			return FromType(typeof(T));
+			return FromAttributes(typeof(T));
 		}
 
 		/// <summary>
 		/// Creates a <see cref="CsvConfiguration"/> instance configured using <paramref name="cultureInfo"/>
 		/// and CsvHelper attributes applied to <typeparamref name="T"/> at the type-level.
 		/// This method ignores any <see cref="CultureInfoAttribute"/> applied to <typeparamref name="T"/>.
 		/// </summary>
-		/// <typeparam name="T"><inheritdoc cref="FromType{T}()"/></typeparam>
+		/// <typeparam name="T"><inheritdoc cref="FromAttributes{T}()"/></typeparam>
 		/// <param name="cultureInfo">The <see cref="CultureInfo"/> to configure the returned <see cref="CsvConfiguration"/> with.</param>
 		/// <returns>A new <see cref="CsvConfiguration"/> instance configured with <paramref name="cultureInfo"/> and attributes applied to <typeparamref name="T"/>.</returns>
-		/// <remarks><inheritdoc cref="FromType{T}()"/></remarks>
-		public static CsvConfiguration FromType<T>(CultureInfo cultureInfo)
+		/// <remarks><inheritdoc cref="FromAttributes{T}()"/></remarks>
+		public static CsvConfiguration FromAttributes<T>(CultureInfo cultureInfo)
 		{
-			return FromType(typeof(T), cultureInfo);
+			return FromAttributes(typeof(T), cultureInfo);
 		}
 
 		/// <summary>
 		/// Creates a <see cref="CsvConfiguration"/> instance configured using CsvHelper attributes applied
 		/// to <paramref name="type"/> at the type-level. This method requires <paramref name="type"/> to
 		/// be annotated with <see cref="CultureInfoAttribute"/> (or to sub-class a type which is).
 		/// </summary>
-		/// <param name="type"><inheritdoc cref="FromType{T}()" path="/typeparam"/></param>
+		/// <param name="type"><inheritdoc cref="FromAttributes{T}()" path="/typeparam"/></param>
 		/// <returns>A new <see cref="CsvConfiguration"/> instance configured with attributes applied to <paramref name="type"/>.</returns>
 		/// <remarks>
 		/// CsvHelper attributes applied to members and parameters do not influence the return value of this method.
@@ -298,7 +298,7 @@ public static CsvConfiguration FromType<T>(CultureInfo cultureInfo)
 		/// <exception cref="ConfigurationException">If <paramref name="type"/> is not annotated with <see cref="CultureInfoAttribute"/>.</exception>
 		/// <exception cref="ArgumentNullException">If the argument to the <see cref="CultureInfoAttribute"/> is <see langword="null"/>.</exception>
 		/// <exception cref="CultureNotFoundException">If the argument to the <see cref="CultureInfoAttribute"/> does not specify a supported culture.</exception>
-		public static CsvConfiguration FromType(Type type)
+		public static CsvConfiguration FromAttributes(Type type)
 		{
 			var cultureInfoAttribute = (CultureInfoAttribute)Attribute.GetCustomAttribute(type, typeof(CultureInfoAttribute));
 			if (cultureInfoAttribute == null)
@@ -317,11 +317,11 @@ public static CsvConfiguration FromType(Type type)
 		/// and CsvHelper attributes applied to <paramref name="type"/> at the type-level.
 		/// This method ignores any <see cref="CultureInfoAttribute"/> applied to <paramref name="type"/>.
 		/// </summary>
-		/// <param name="type"><inheritdoc cref="FromType{T}()" path="/typeparam"/></param>
-		/// <param name="cultureInfo"><inheritdoc cref="FromType{T}(CultureInfo)"/></param>
+		/// <param name="type"><inheritdoc cref="FromAttributes{T}()" path="/typeparam"/></param>
+		/// <param name="cultureInfo"><inheritdoc cref="FromAttributes{T}(CultureInfo)"/></param>
 		/// <returns>A new <see cref="CsvConfiguration"/> instance configured with <paramref name="cultureInfo"/> and attributes applied to <paramref name="type"/></returns>
-		/// <remarks><inheritdoc cref="FromType{T}()"/></remarks>
-		public static CsvConfiguration FromType(Type type, CultureInfo cultureInfo)
+		/// <remarks><inheritdoc cref="FromAttributes{T}()"/></remarks>
+		public static CsvConfiguration FromAttributes(Type type, CultureInfo cultureInfo)
 		{
 			var config = new CsvConfiguration(cultureInfo);
 			config.ApplyAttributes(type);

tests/CsvHelper.Tests/Mappings/Attribute/AllowCommentsTests.cs

@@ -14,8 +14,8 @@ public class AllowCommentsTests
 		[Fact]
 		public void AllowCommentsTest()
 		{
-			Assert.True(CsvConfiguration.FromType<AllowCommentsTrueTestClass>(CultureInfo.InvariantCulture).AllowComments);
-			Assert.False(CsvConfiguration.FromType<AllowCommentsFalseTestClass>(CultureInfo.InvariantCulture).AllowComments);
+			Assert.True(CsvConfiguration.FromAttributes<AllowCommentsTrueTestClass>(CultureInfo.InvariantCulture).AllowComments);
+			Assert.False(CsvConfiguration.FromAttributes<AllowCommentsFalseTestClass>(CultureInfo.InvariantCulture).AllowComments);
 		}
 
 		[AllowComments]

tests/CsvHelper.Tests/Mappings/Attribute/BufferSizeTests.cs

@@ -19,7 +19,7 @@ public class BufferSizeTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal(2, config.BufferSize);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/CacheFieldsTests.cs

@@ -14,8 +14,8 @@ public class CacheFieldsTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			Assert.True(CsvConfiguration.FromType<FooTrue>(CultureInfo.InvariantCulture).CacheFields);
-			Assert.False(CsvConfiguration.FromType<FooFalse>(CultureInfo.InvariantCulture).CacheFields);
+			Assert.True(CsvConfiguration.FromAttributes<FooTrue>(CultureInfo.InvariantCulture).CacheFields);
+			Assert.False(CsvConfiguration.FromAttributes<FooFalse>(CultureInfo.InvariantCulture).CacheFields);
 		}
 
 		[CacheFields]

tests/CsvHelper.Tests/Mappings/Attribute/CommentTests.cs

@@ -16,7 +16,7 @@ public class CommentTests
         [Fact]
         public void CommentTest()
         {
-			var config = CsvConfiguration.FromType<CommentTestClass>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<CommentTestClass>(CultureInfo.InvariantCulture);
             Assert.Equal('x', config.Comment);
         }
 

tests/CsvHelper.Tests/Mappings/Attribute/CountBytesTest.cs

@@ -14,8 +14,8 @@ public class CountBytesTest
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			Assert.True(CsvConfiguration.FromType<FooTrue>(CultureInfo.InvariantCulture).CountBytes);
-			Assert.False(CsvConfiguration.FromType<FooFalse>(CultureInfo.InvariantCulture).CountBytes);
+			Assert.True(CsvConfiguration.FromAttributes<FooTrue>(CultureInfo.InvariantCulture).CountBytes);
+			Assert.False(CsvConfiguration.FromAttributes<FooFalse>(CultureInfo.InvariantCulture).CountBytes);
 		}
 
 		[CountBytes]

tests/CsvHelper.Tests/Mappings/Attribute/DelimiterTests.cs

@@ -16,7 +16,7 @@ public class DelimiterTests
 		[Fact]
 		public void DelimiterReaderTest()
 		{
-			var configuration = CsvConfiguration.FromType<DelimiterTestClass>(CultureInfo.InvariantCulture);
+			var configuration = CsvConfiguration.FromAttributes<DelimiterTestClass>(CultureInfo.InvariantCulture);
 
 			Assert.Equal("§", configuration.Delimiter);
 		}

tests/CsvHelper.Tests/Mappings/Attribute/DetectColumnCountChangesTests.cs

@@ -14,8 +14,8 @@ public class DetectColumnCountChangesTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			Assert.True(CsvConfiguration.FromType<FooTrue>(CultureInfo.InvariantCulture).DetectColumnCountChanges);
-			Assert.False(CsvConfiguration.FromType<FooFalse>(CultureInfo.InvariantCulture).DetectColumnCountChanges);
+			Assert.True(CsvConfiguration.FromAttributes<FooTrue>(CultureInfo.InvariantCulture).DetectColumnCountChanges);
+			Assert.False(CsvConfiguration.FromAttributes<FooFalse>(CultureInfo.InvariantCulture).DetectColumnCountChanges);
 		}
 
 		[DetectColumnCountChanges]

tests/CsvHelper.Tests/Mappings/Attribute/DetectDelimiterTests.cs

@@ -14,8 +14,8 @@ public class DetectDelimiterTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			Assert.True(CsvConfiguration.FromType<FooTrue>(CultureInfo.InvariantCulture).DetectDelimiter);
-			Assert.False(CsvConfiguration.FromType<FooFalse>(CultureInfo.InvariantCulture).DetectDelimiter);
+			Assert.True(CsvConfiguration.FromAttributes<FooTrue>(CultureInfo.InvariantCulture).DetectDelimiter);
+			Assert.False(CsvConfiguration.FromAttributes<FooFalse>(CultureInfo.InvariantCulture).DetectDelimiter);
 		}
 
 		[DetectDelimiter]

tests/CsvHelper.Tests/Mappings/Attribute/DetectDelimiterValuesTests.cs

@@ -19,7 +19,7 @@ public class DetectDelimiterValuesTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal(new[] { "a", "b" }, config.DetectDelimiterValues);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/EncodingTests.cs

@@ -15,8 +15,8 @@ public class EncodingTests
 		[Fact]
 		public void EncodingTest()
 		{
-			Assert.Equal(Encoding.ASCII, CsvConfiguration.FromType<EncodingNameTestClass>(CultureInfo.InvariantCulture).Encoding);
-			Assert.Equal(Encoding.ASCII, CsvConfiguration.FromType<EncodingCodepageTestClass>(CultureInfo.InvariantCulture).Encoding);
+			Assert.Equal(Encoding.ASCII, CsvConfiguration.FromAttributes<EncodingNameTestClass>(CultureInfo.InvariantCulture).Encoding);
+			Assert.Equal(Encoding.ASCII, CsvConfiguration.FromAttributes<EncodingCodepageTestClass>(CultureInfo.InvariantCulture).Encoding);
 		}
 
 		[Encoding("ASCII")]

tests/CsvHelper.Tests/Mappings/Attribute/EscapeTests.cs

@@ -16,7 +16,7 @@ public class EscapeTests
 		[Fact]
 		public void EscapeTest()
 		{
-			var config = CsvConfiguration.FromType<EscapeTestClass>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<EscapeTestClass>(CultureInfo.InvariantCulture);
 
 			Assert.Equal('x', config.Escape);
 		}

tests/CsvHelper.Tests/Mappings/Attribute/ExceptionMessagesContainRawDataTests.cs

@@ -14,8 +14,8 @@ public class ExceptionMessagesContainRawDataTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			Assert.True(CsvConfiguration.FromType<FooTrue>(CultureInfo.InvariantCulture).ExceptionMessagesContainRawData);
-			Assert.False(CsvConfiguration.FromType<FooFalse>(CultureInfo.InvariantCulture).ExceptionMessagesContainRawData);
+			Assert.True(CsvConfiguration.FromAttributes<FooTrue>(CultureInfo.InvariantCulture).ExceptionMessagesContainRawData);
+			Assert.False(CsvConfiguration.FromAttributes<FooFalse>(CultureInfo.InvariantCulture).ExceptionMessagesContainRawData);
 		}
 
 		[ExceptionMessagesContainRawData]

tests/CsvHelper.Tests/Mappings/Attribute/HasHeaderRecordTests.cs

@@ -14,8 +14,8 @@ public class HasHeaderRecordTests
 		[Fact]
 		public void HasHeaderRecordTest()
 		{
-			Assert.True(CsvConfiguration.FromType<HasHeaderRecordTrueTestClass>(CultureInfo.InvariantCulture).HasHeaderRecord);
-			Assert.False(CsvConfiguration.FromType<HasHeaderRecordFalseTestClass>(CultureInfo.InvariantCulture).HasHeaderRecord);
+			Assert.True(CsvConfiguration.FromAttributes<HasHeaderRecordTrueTestClass>(CultureInfo.InvariantCulture).HasHeaderRecord);
+			Assert.False(CsvConfiguration.FromAttributes<HasHeaderRecordFalseTestClass>(CultureInfo.InvariantCulture).HasHeaderRecord);
 		}
 
 		[HasHeaderRecord]

tests/CsvHelper.Tests/Mappings/Attribute/IgnoreBlankLinesTests.cs

@@ -14,8 +14,8 @@ public class IgnoreBlankLinesTests
 		[Fact]
 		public void IgnoreBlankLinesTest()
 		{
-			Assert.True(CsvConfiguration.FromType<IgnoreBlankLinesTrueTestClass>(CultureInfo.InvariantCulture).IgnoreBlankLines);
-			Assert.False(CsvConfiguration.FromType<IgnoreBlankLinesFalseTestClass>(CultureInfo.InvariantCulture).IgnoreBlankLines);
+			Assert.True(CsvConfiguration.FromAttributes<IgnoreBlankLinesTrueTestClass>(CultureInfo.InvariantCulture).IgnoreBlankLines);
+			Assert.False(CsvConfiguration.FromAttributes<IgnoreBlankLinesFalseTestClass>(CultureInfo.InvariantCulture).IgnoreBlankLines);
 		}
 
 		[IgnoreBlankLines]

tests/CsvHelper.Tests/Mappings/Attribute/IgnoreReferencesTests.cs

@@ -14,8 +14,8 @@ public class IgnoreReferencesTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			Assert.True(CsvConfiguration.FromType<FooTrue>(CultureInfo.InvariantCulture).IgnoreReferences);
-			Assert.False(CsvConfiguration.FromType<FooFalse>(CultureInfo.InvariantCulture).IgnoreReferences);
+			Assert.True(CsvConfiguration.FromAttributes<FooTrue>(CultureInfo.InvariantCulture).IgnoreReferences);
+			Assert.False(CsvConfiguration.FromAttributes<FooFalse>(CultureInfo.InvariantCulture).IgnoreReferences);
 		}
 
 		[IgnoreReferences]

tests/CsvHelper.Tests/Mappings/Attribute/IncludePrivateMembersTests.cs

@@ -14,8 +14,8 @@ public class IncludePrivateMembersTests
 		[Fact]
 		public void IncludePrivateMembersTest()
 		{
-			Assert.True(CsvConfiguration.FromType<IncludePrivateMembersTrueTestClass>(CultureInfo.InvariantCulture).IncludePrivateMembers);
-			Assert.False(CsvConfiguration.FromType<IncludePrivateMembersFalseTestClass>(CultureInfo.InvariantCulture).IncludePrivateMembers);
+			Assert.True(CsvConfiguration.FromAttributes<IncludePrivateMembersTrueTestClass>(CultureInfo.InvariantCulture).IncludePrivateMembers);
+			Assert.False(CsvConfiguration.FromAttributes<IncludePrivateMembersFalseTestClass>(CultureInfo.InvariantCulture).IncludePrivateMembers);
 		}
 
 		[IncludePrivateMembers]

tests/CsvHelper.Tests/Mappings/Attribute/InjectionCharactersTests.cs

@@ -19,7 +19,7 @@ public class InjectionCharactersTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal(new[] { 'a', 'b' }, config.InjectionCharacters);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/InjectionEscapeCharacterTests.cs

@@ -19,7 +19,7 @@ public class InjectionEscapeCharacterTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal('a', config.InjectionEscapeCharacter);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/InjectionOptionsTests.cs

@@ -19,7 +19,7 @@ public class InjectionOptionsTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal(InjectionOptions.Escape, config.InjectionOptions);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/LineBreakInQuotedFieldIsBadDataTests.cs

@@ -14,8 +14,8 @@ public class LineBreakInQuotedFieldIsBadDataTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			Assert.True(CsvConfiguration.FromType<FooTrue>(CultureInfo.InvariantCulture).LineBreakInQuotedFieldIsBadData);
-			Assert.False(CsvConfiguration.FromType<FooFalse>(CultureInfo.InvariantCulture).LineBreakInQuotedFieldIsBadData);
+			Assert.True(CsvConfiguration.FromAttributes<FooTrue>(CultureInfo.InvariantCulture).LineBreakInQuotedFieldIsBadData);
+			Assert.False(CsvConfiguration.FromAttributes<FooFalse>(CultureInfo.InvariantCulture).LineBreakInQuotedFieldIsBadData);
 		}
 
 		[LineBreakInQuotedFieldIsBadData]

tests/CsvHelper.Tests/Mappings/Attribute/MaxFieldSizeTests.cs

@@ -14,7 +14,7 @@ public class MaxFieldSizeTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal(2, config.MaxFieldSize);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/MemberTypesTests.cs

@@ -14,7 +14,7 @@ public class MemberTypesTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal(MemberTypes.Fields, config.MemberTypes);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/ModeTests.cs

@@ -14,7 +14,7 @@ public class ModeTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal(CsvMode.Escape, config.Mode);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/NewLineTests.cs

@@ -14,7 +14,7 @@ public class NewLineTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal("a", config.NewLine);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/ProcessFieldBufferSizeTests.cs

@@ -14,7 +14,7 @@ public class ProcessFieldBufferSizeTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal(2, config.ProcessFieldBufferSize);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/QuoteTests.cs

@@ -14,7 +14,7 @@ public class QuoteTests
 		[Fact]
 		public void QuoteTest()
 		{
-			var config = CsvConfiguration.FromType<QuoteTestClass>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<QuoteTestClass>(CultureInfo.InvariantCulture);
 			Assert.Equal('x', config.Quote);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/TrimOptionsTests.cs

@@ -16,7 +16,7 @@ public class TrimOptionsTests
 		[Fact]
 		public void TrimOptionsTest()
 		{
-			var config = CsvConfiguration.FromType<TrimOptionsTestClass>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<TrimOptionsTestClass>(CultureInfo.InvariantCulture);
 			Assert.Equal(TrimOptions.InsideQuotes, config.TrimOptions);
 		}
 

tests/CsvHelper.Tests/Mappings/Attribute/UseNewObjectForNullReferenceMembersTests.cs

@@ -14,8 +14,8 @@ public class UseNewObjectForNullReferenceMembersTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			Assert.True(CsvConfiguration.FromType<FooTrue>(CultureInfo.InvariantCulture).UseNewObjectForNullReferenceMembers);
-			Assert.False(CsvConfiguration.FromType<FooFalse>(CultureInfo.InvariantCulture).UseNewObjectForNullReferenceMembers);
+			Assert.True(CsvConfiguration.FromAttributes<FooTrue>(CultureInfo.InvariantCulture).UseNewObjectForNullReferenceMembers);
+			Assert.False(CsvConfiguration.FromAttributes<FooFalse>(CultureInfo.InvariantCulture).UseNewObjectForNullReferenceMembers);
 		}
 
 		[UseNewObjectForNullReferenceMembers]

tests/CsvHelper.Tests/Mappings/Attribute/WhiteSpaceCharsTests.cs

@@ -14,7 +14,7 @@ public class WhiteSpaceCharsTests
 		[Fact]
 		public void ConstructorAttributeTest()
 		{
-			var config = CsvConfiguration.FromType<Foo>(CultureInfo.InvariantCulture);
+			var config = CsvConfiguration.FromAttributes<Foo>(CultureInfo.InvariantCulture);
 			Assert.Equal(new[] { 'a', 'b' }, config.WhiteSpaceChars);
 		}