diff options
Diffstat (limited to 'ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterTests.cs')
| -rw-r--r-- | ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterTests.cs | 1030 |
1 files changed, 1030 insertions, 0 deletions
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterTests.cs new file mode 100644 index 0000000..2309ef7 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterTests.cs @@ -0,0 +1,1030 @@ +// Copyright 2009-2022 Josh Close +// 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; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Text; +using CsvHelper.Configuration; +using CsvHelper.TypeConversion; +using Int32Converter = CsvHelper.TypeConversion.Int32Converter; +using System.Dynamic; +using Xunit; +using System.Threading; + +namespace CsvHelper.Tests +{ + + public class CsvWriterTests + { + public CsvWriterTests() + { + Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); + } + + [Fact] + public void WriteFieldTest() + { + var stream = new MemoryStream(); + var writer = new StreamWriter(stream) { AutoFlush = true }; + + var csv = new CsvWriter(writer, CultureInfo.InvariantCulture); + + var date = DateTime.Now.ToString(); + var guid = Guid.NewGuid().ToString(); + csv.WriteField("one"); + csv.WriteField("one, two"); + csv.WriteField("one \"two\" three"); + csv.WriteField(" one "); + csv.WriteField(date); + csv.WriteField((short)1); + csv.WriteField(2); + csv.WriteField((long)3); + csv.WriteField((float)4); + csv.WriteField((double)5); + csv.WriteField(guid); + csv.NextRecord(); + + var reader = new StreamReader(stream); + stream.Position = 0; + var data = reader.ReadToEnd(); + + Assert.Equal("one,\"one, two\",\"one \"\"two\"\" three\",\" one \"," + date + ",1,2,3,4,5," + guid + "\r\n", data); + } + + [Fact] + public void WriteRecordTest() + { + var record = new TestRecord + { + IntColumn = 1, + StringColumn = "string column", + IgnoredColumn = "ignored column", + FirstColumn = "first column", + }; + + var stream = new MemoryStream(); + var writer = new StreamWriter(stream) { AutoFlush = true }; + var csv = new CsvWriter(writer, CultureInfo.InvariantCulture); + csv.Context.RegisterClassMap<TestRecordMap>(); + + csv.WriteRecord(record); + csv.NextRecord(); + + stream.Position = 0; + var reader = new StreamReader(stream); + var csvFile = reader.ReadToEnd(); + var expected = "first column,1,string column,test\r\n"; + + Assert.Equal(expected, csvFile); + } + + [Fact] + public void WriteRecordNoIndexesTest() + { + var record = new TestRecordNoIndexes + { + IntColumn = 1, + StringColumn = "string column", + IgnoredColumn = "ignored column", + FirstColumn = "first column", + }; + + using (var stream = new MemoryStream()) + using (var writer = new StreamWriter(stream) { AutoFlush = true }) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + csv.Context.RegisterClassMap<TestRecordNoIndexesMap>(); + + csv.WriteRecord(record); + csv.NextRecord(); + + stream.Position = 0; + var reader = new StreamReader(stream); + var csvFile = reader.ReadToEnd(); + + var expected = "1,string column,first column,test\r\n"; + + Assert.Equal(expected, csvFile); + } + } + + [Fact] + public void WriteRecordsTest() + { + var records = new List<TestRecord> + { + new TestRecord + { + IntColumn = 1, + StringColumn = "string column", + IgnoredColumn = "ignored column", + FirstColumn = "first column", + }, + new TestRecord + { + IntColumn = 2, + StringColumn = "string column 2", + IgnoredColumn = "ignored column 2", + FirstColumn = "first column 2", + }, + }; + + var stream = new MemoryStream(); + var writer = new StreamWriter(stream) { AutoFlush = true }; + var csv = new CsvWriter(writer, CultureInfo.InvariantCulture); + csv.Context.RegisterClassMap<TestRecordMap>(); + + csv.WriteRecords(records); + + stream.Position = 0; + var reader = new StreamReader(stream); + var csvFile = reader.ReadToEnd(); + var expected = "FirstColumn,Int Column,StringColumn,TypeConvertedColumn\r\n"; + expected += "first column,1,string column,test\r\n"; + expected += "first column 2,2,string column 2,test\r\n"; + + Assert.Equal(expected, csvFile); + } + + [Fact] + public void WriteEmptyArrayTest() + { + var records = new TestRecord[] { }; + + var stream = new MemoryStream(); + var writer = new StreamWriter(stream) { AutoFlush = true }; + var csv = new CsvWriter(writer, CultureInfo.InvariantCulture); + csv.Context.RegisterClassMap<TestRecordMap>(); + + csv.WriteRecords(records); + + stream.Position = 0; + var reader = new StreamReader(stream); + var csvFile = reader.ReadToEnd(); + var expected = "FirstColumn,Int Column,StringColumn,TypeConvertedColumn\r\n"; + + Assert.Equal(expected, csvFile); + } + + [Fact] + public void WriteRecordsCalledWithTwoParametersTest() + { + var records = new List<object> + { + new TestRecord + { + IntColumn = 1, + StringColumn = "string column", + IgnoredColumn = "ignored column", + FirstColumn = "first column", + }, + new TestRecord + { + IntColumn = 2, + StringColumn = "string column 2", + IgnoredColumn = "ignored column 2", + FirstColumn = "first column 2", + }, + }; + + var stream = new MemoryStream(); + var writer = new StreamWriter(stream) { AutoFlush = true }; + var csv = new CsvWriter(writer, CultureInfo.InvariantCulture); + csv.Context.RegisterClassMap<TestRecordMap>(); + + csv.WriteRecords(records); + + stream.Position = 0; + var reader = new StreamReader(stream); + var csvFile = reader.ReadToEnd(); + var expected = "FirstColumn,Int Column,StringColumn,TypeConvertedColumn\r\n"; + expected += "first column,1,string column,test\r\n"; + expected += "first column 2,2,string column 2,test\r\n"; + + Assert.Equal(expected, csvFile); + } + + [Fact] + public void WriteRecordNoHeaderTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + var stream = new MemoryStream(); + var writer = new StreamWriter(stream) { AutoFlush = true }; + var csv = new CsvWriter(writer, config); + csv.Context.RegisterClassMap<TestRecordMap>(); + csv.WriteRecord(new TestRecord()); + csv.NextRecord(); + + stream.Position = 0; + var reader = new StreamReader(stream); + var csvFile = reader.ReadToEnd(); + + Assert.Equal(",0,,test\r\n", csvFile); + } + + [Fact] + public void WriteRecordWithNullRecordTest() + { + var record = new TestRecord + { + IntColumn = 1, + StringColumn = "string column", + IgnoredColumn = "ignored column", + FirstColumn = "first column", + }; + + var stream = new MemoryStream(); + var writer = new StreamWriter(stream) { AutoFlush = true }; + var csv = new CsvWriter(writer, CultureInfo.InvariantCulture); + csv.Context.RegisterClassMap<TestRecordMap>(); + + csv.WriteRecord(record); + csv.NextRecord(); + csv.WriteRecord((TestRecord)null); + csv.NextRecord(); + csv.WriteRecord(record); + csv.NextRecord(); + + stream.Position = 0; + var reader = new StreamReader(stream); + var csvFile = reader.ReadToEnd(); + var expected = new TestStringBuilder(csv.Configuration.NewLine); + expected.AppendLine("first column,1,string column,test"); + expected.AppendLine(",,,"); + expected.AppendLine("first column,1,string column,test"); + + Assert.Equal(expected, csvFile); + } + + [Fact] + public void WriteRecordWithReferencesTest() + { + var record = new Person + { + FirstName = "First Name", + LastName = "Last Name", + HomeAddress = new Address + { + Street = "Home Street", + City = "Home City", + State = "Home State", + Zip = "Home Zip", + }, + WorkAddress = new Address + { + Street = "Work Street", + City = "Work City", + State = "Work State", + Zip = "Work Zip", + } + }; + + var stream = new MemoryStream(); + var writer = new StreamWriter(stream) { AutoFlush = true }; + var csv = new CsvWriter(writer, CultureInfo.InvariantCulture); + csv.Context.RegisterClassMap<PersonMap>(); + + csv.WriteRecord(record); + csv.NextRecord(); + + stream.Position = 0; + var reader = new StreamReader(stream); + var csvFile = reader.ReadToEnd(); + + var expected = "First Name,Last Name,Home Street,Home City,Home State,Home Zip,Work Street,Work City,Work State,Work Zip\r\n"; + + Assert.Equal(expected, csvFile); + } + + [Fact] + public void WriteRecordsAllFieldsQuotedTest() + { + var record = new TestRecord + { + IntColumn = 1, + StringColumn = "string column", + IgnoredColumn = "ignored column", + FirstColumn = "first column", + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ShouldQuote = _ => true, + }; + + string csv; + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csvWriter = new CsvWriter(writer, config)) + { + csvWriter.Context.RegisterClassMap<TestRecordMap>(); + csvWriter.WriteRecord(record); + csvWriter.NextRecord(); + + writer.Flush(); + stream.Position = 0; + + csv = reader.ReadToEnd(); + } + + var expected = "\"first column\",\"1\",\"string column\",\"test\"\r\n"; + + Assert.Equal(expected, csv); + } + + [Fact] + public void WriteRecordsNoFieldsQuotedTest() + { + var record = new TestRecord + { + IntColumn = 1, + StringColumn = "string \" column", + IgnoredColumn = "ignored column", + FirstColumn = "first, column", + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ShouldQuote = _ => false, + }; + string csv; + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csvWriter = new CsvWriter(writer, config)) + { + csvWriter.Context.RegisterClassMap<TestRecordMap>(); + csvWriter.WriteRecord(record); + csvWriter.NextRecord(); + + writer.Flush(); + stream.Position = 0; + + csv = reader.ReadToEnd(); + } + + var expected = "first, column,1,string \" column,test\r\n"; + + Assert.Equal(expected, csv); + } + + [Fact] + public void WriteHeaderTest() + { + string csv; + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csvWriter = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + csvWriter.Context.RegisterClassMap<TestRecordMap>(); + csvWriter.WriteHeader(typeof(TestRecord)); + csvWriter.NextRecord(); + + writer.Flush(); + stream.Position = 0; + + csv = reader.ReadToEnd(); + } + + const string Expected = "FirstColumn,Int Column,StringColumn,TypeConvertedColumn\r\n"; + Assert.Equal(Expected, csv); + } + + [Fact] + public void WriteRecordWithDelimiterInFieldTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var record = new TestSinglePropertyRecord + { + Name = "one,two" + }; + csv.WriteRecord(record); + csv.NextRecord(); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + + Assert.Equal("\"one,two\"\r\n", text); + } + } + + [Fact] + public void WriteRecordWithQuoteInFieldTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var record = new TestSinglePropertyRecord + { + Name = "one\"two" + }; + csv.WriteRecord(record); + csv.NextRecord(); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + + Assert.Equal("\"one\"\"two\"\r\n", text); + } + } + + [Fact] + public void WriteRecordWithQuoteAllFieldsOnAndDelimiterInFieldTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ShouldQuote = _ => true, + }; + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, config)) + { + var record = new TestSinglePropertyRecord + { + Name = "one,two" + }; + csv.WriteRecord(record); + csv.NextRecord(); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + + Assert.Equal("\"one,two\"\r\n", text); + } + } + + [Fact] + public void WriteRecordWithQuoteAllFieldsOnAndQuoteInFieldTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ShouldQuote = _ => true, + }; + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, config)) + { + var record = new TestSinglePropertyRecord + { + Name = "one\"two" + }; + csv.WriteRecord(record); + csv.NextRecord(); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + + Assert.Equal("\"one\"\"two\"\r\n", text); + } + } + + [Fact] + public void WriteRecordsWithInvariantCultureTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + csv.Context.RegisterClassMap<TestRecordMap>(); + + var record = new TestRecord + { + IntColumn = 1, + FirstColumn = "first column", + IgnoredColumn = "ignored column", + StringColumn = "string column", + }; + + csv.WriteRecord(record); + writer.Flush(); + stream.Position = 0; + + var csvString = reader.ReadToEnd(); + } + } + + [Fact] + public void WriteNoGetterTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<TestPrivateGet> + { + new TestPrivateGet + { + Id = 1, + Name = "one" + } + }; + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var data = reader.ReadToEnd(); + var expected = new TestStringBuilder(csv.Configuration.NewLine); + expected.AppendLine("Id"); + expected.AppendLine("1"); + + Assert.Equal(expected.ToString(), data); + } + } + + [Fact] + public void WriteDynamicTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + csv.WriteRecord(new { Id = 1, Name = "one" }); + csv.NextRecord(); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + Assert.Equal("1,one\r\n", text); + } + } + + [Fact] + public void WritePrimitivesRecordsHasHeaderTrueTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<int> { 1, 2, 3 }; + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + + Assert.Equal("1\r\n2\r\n3\r\n", text); + } + } + + [Fact] + public void WritePrimitivesRecordsHasHeaderFalseTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, config)) + { + var list = new List<int> { 1, 2, 3 }; + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + + Assert.Equal("1\r\n2\r\n3\r\n", text); + } + } + + [Fact] + public void WriteStructRecordsTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<TestStruct> + { + new TestStruct { Id = 1, Name = "one" }, + new TestStruct { Id = 2, Name = "two" }, + }; + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + + Assert.Equal("Id,Name\r\n1,one\r\n2,two\r\n", text); + } + } + + [Fact] + public void WriteStructReferenceRecordsTest() + { + var list = new List<TestStructParent> + { + new TestStructParent + { + Test = new TestStruct + { + Id = 1, + Name = "one", + }, + }, + }; + + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + csv.Context.RegisterClassMap<TestStructParentMap>(); + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var data = reader.ReadToEnd(); + Assert.Equal("Id,Name\r\n1,one\r\n", data); + } + } + + [Fact] + public void WriteNestedHeadersTest() + { + var list = new List<Person> + { + new Person + { + FirstName = "first", + LastName = "last", + HomeAddress = new Address + { + City = "home city", + State = "home state", + Street = "home street", + Zip = "home zip", + }, + WorkAddress = new Address + { + City = "work city", + State = "work state", + Street = "work street", + Zip = "work zip", + }, + }, + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ReferenceHeaderPrefix = args => $"{args.MemberName}." + }; + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, config)) + { + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + var expected = new TestStringBuilder(csv.Configuration.NewLine); + expected.AppendLine("FirstName,LastName,HomeAddress.Street,HomeAddress.City,HomeAddress.State,HomeAddress.Zip,WorkAddress.Street,WorkAddress.City,WorkAddress.State,WorkAddress.Zip"); + expected.AppendLine("first,last,home street,home city,home state,home zip,work street,work city,work state,work zip"); + Assert.Equal(expected.ToString(), text); + } + } + + [Fact] + public void WriteEmptyListTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<TestRecord>(); + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var data = reader.ReadToEnd(); + Assert.False(string.IsNullOrWhiteSpace(data)); + } + } + + [Fact] + public void ClassWithStaticAutoMappingTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + TestWithStatic.Name = "one"; + var records = new List<TestWithStatic> + { + new TestWithStatic + { + Id = 1 + }, + }; + + csv.WriteRecords(records); + } + } + + [Fact] + public void ClassWithStaticUsingMappingTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + csv.Context.RegisterClassMap<TestWithStaticMap>(); + + TestWithStatic.Name = "one"; + var records = new List<TestWithStatic> + { + new TestWithStatic + { + Id = 1 + }, + }; + + csv.WriteRecords(records); + } + } + + [Fact] + public void WriteDynamicListTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<dynamic>(); + dynamic record = new { Id = 1, Name = "one" }; + list.Add(record); + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + Assert.Equal("Id,Name\r\n1,one\r\n", text); + } + } + + [Fact] + public void WriteExpandoListTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<dynamic>(); + dynamic record = new ExpandoObject(); + record.Id = 1; + record.Name = "one"; + list.Add(record); + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + Assert.Equal("Id,Name\r\n1,one\r\n", text); + } + } + + + [Fact] + public void WriteInternalConstructorClassTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + csv.WriteRecords(new List<GetOnly>()); + writer.Flush(); + stream.Position = 0; + + var text = reader.ReadToEnd(); + Assert.Equal("One\r\n", text); + } + } + + private class GetOnly + { + internal GetOnly(string someParam) + { + } + + public int One { get; } + } + + private class TestWithStatic + { + public int Id { get; set; } + + public static string Name { get; set; } + } + + private sealed class TestWithStaticMap : ClassMap<TestWithStatic> + { + public TestWithStaticMap() + { + Map(m => m.Id); + } + } + + private class TestStructParent + { + public TestStruct Test { get; set; } + } + + private sealed class TestStructParentMap : ClassMap<TestStructParent> + { + public TestStructParentMap() + { + References<TestStructMap>(m => m.Test); + } + } + + private struct TestStruct + { + public int Id { get; set; } + + public string Name { get; set; } + } + + private sealed class TestStructMap : ClassMap<TestStruct> + { + public TestStructMap() + { + Map(m => m.Id); + Map(m => m.Name); + } + } + + private class TestPrivateGet + { + public int Id { get; set; } + + public string Name { private get; set; } + } + + private class TestSinglePropertyRecord + { + public string Name { get; set; } + } + + private class TestRecord + { + public int IntColumn { get; set; } + + public string StringColumn { get; set; } + + public string IgnoredColumn { get; set; } + + public string FirstColumn { get; set; } + + public string TypeConvertedColumn { get; set; } + } + + private sealed class TestRecordMap : ClassMap<TestRecord> + { + public TestRecordMap() + { + Map(m => m.IntColumn).Name("Int Column").Index(1).TypeConverter<Int32Converter>(); + Map(m => m.StringColumn); + Map(m => m.FirstColumn).Index(0); + Map(m => m.TypeConvertedColumn).TypeConverter<TestTypeConverter>(); + } + } + + private class TestRecordNoIndexes + { + public int IntColumn { get; set; } + + public string StringColumn { get; set; } + + public string IgnoredColumn { get; set; } + + public string FirstColumn { get; set; } + + public string TypeConvertedColumn { get; set; } + } + + private sealed class TestRecordNoIndexesMap : ClassMap<TestRecordNoIndexes> + { + public TestRecordNoIndexesMap() + { + Map(m => m.IntColumn).Name("Int Column").TypeConverter<Int32Converter>(); + Map(m => m.StringColumn); + Map(m => m.FirstColumn); + Map(m => m.TypeConvertedColumn).TypeConverter<TestTypeConverter>(); + } + } + + private class TestTypeConverter : ITypeConverter + { + public string ConvertToString(object value, IWriterRow row, MemberMapData propertyMapData) + { + return "test"; + } + + public object ConvertFromString(string text, IReaderRow row, MemberMapData propertyMapData) + { + throw new NotImplementedException(); + } + + public bool CanConvertFrom(Type type) + { + throw new NotImplementedException(); + } + + public bool CanConvertTo(Type type) + { + return true; + } + } + + private class Person + { + public string FirstName { get; set; } + + public string LastName { get; set; } + + public Address HomeAddress { get; set; } + + public Address WorkAddress { get; set; } + } + + private class Address + { + public string Street { get; set; } + + public string City { get; set; } + + public string State { get; set; } + + public string Zip { get; set; } + } + + private sealed class PersonMap : ClassMap<Person> + { + public PersonMap() + { + Map(m => m.FirstName); + Map(m => m.LastName); + References<HomeAddressMap>(m => m.HomeAddress); + References<WorkAddressMap>(m => m.WorkAddress); + } + } + + private sealed class HomeAddressMap : ClassMap<Address> + { + public HomeAddressMap() + { + Map(m => m.Street).Name("HomeStreet"); + Map(m => m.City).Name("HomeCity"); + Map(m => m.State).Name("HomeState"); + Map(m => m.Zip).Name("HomeZip"); + } + } + + private sealed class WorkAddressMap : ClassMap<Address> + { + public WorkAddressMap() + { + Map(m => m.Street).Name("WorkStreet"); + Map(m => m.City).Name("WorkCity"); + Map(m => m.State).Name("WorkState"); + Map(m => m.Zip).Name("WorkZip"); + } + } + + } +} |