CsvHelper by Josh Close

<PackageReference Include="CsvHelper" Version="32.0.1" />

---

API Diff between 32.0.1 and 3.0.0-chi02

1195 Additions 152 Removals

CsvHelper

• public static class ArrayHelper
  • public static bool Contains(char[] array, ref char c)
  • public static void Trim(char[] buffer, ref int start, ref int length, char[] trimChars)
• public class BadDataException : CsvHelperException
  • public readonly string Field
  • public readonly string RawRecord
  • public BadDataException(string field, string rawRecord, CsvContext context)
  • public BadDataException(string field, string rawRecord, CsvContext context, string message)
  • public BadDataException(string field, string rawRecord, CsvContext context, string message, Exception innerException)
• public sealed delegate BadDataFound : MulticastDelegate
  • public BadDataFound(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(BadDataFoundArgs args, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(BadDataFoundArgs args)
• public struct BadDataFoundArgs
  • public readonly CsvContext Context
  • public readonly string Field
  • public readonly string RawRecord
  • public BadDataFoundArgs(string field, string rawRecord, CsvContext context)
• public class CsvBadDataException : CsvHelperException
• public class CsvFactory : ICsvFactory
• public sealed delegate ConvertFromString<TMember> : MulticastDelegate
  • public ConvertFromString(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ConvertFromStringArgs args, AsyncCallback callback, object object)
  • public virtual TMember EndInvoke(IAsyncResult result)
  • public virtual TMember Invoke(ConvertFromStringArgs args)
• public struct ConvertFromStringArgs
  • public readonly IReaderRow Row
  • public ConvertFromStringArgs(IReaderRow row)
• public sealed delegate ConvertToString<TClass> : MulticastDelegate
  • public ConvertToString(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ConvertToStringArgs<TClass> args, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(ConvertToStringArgs<TClass> args)
• public struct ConvertToStringArgs<TClass>
  • public readonly TClass Value
  • public ConvertToStringArgs(TClass value)
• public class CsvContext
  • public CsvConfiguration Configuration { get; }
  • public virtual ClassMapCollection Maps { get; }
  • public IParser Parser { get; }
  • public IReader Reader { get; }
  • public virtual TypeConverterCache TypeConverterCache { get; set; }
  • public virtual TypeConverterOptionsCache TypeConverterOptionsCache { get; set; }
  • public IWriter Writer { get; }
  • public CsvContext(IReader reader)
  • public CsvContext(IParser parser)
  • public CsvContext(IWriter writer)
  • public CsvContext(CsvConfiguration configuration)
  • public virtual ClassMap<T> AutoMap<T>()
  • public virtual ClassMap AutoMap(Type type)
  • public virtual TMap RegisterClassMap<TMap>() where TMap : ClassMap
  • public virtual ClassMap RegisterClassMap(Type classMapType)
  • public virtual void RegisterClassMap(ClassMap map)
  • public virtual void UnregisterClassMap<TMap>() where TMap : ClassMap
  • public virtual void UnregisterClassMap(Type classMapType)
  • public virtual void UnregisterClassMap()
• public class CsvDataReader : IDataReader, IDataRecord, IDisposable
  • public int Depth { get; }
  • public int FieldCount { get; }
  • public bool IsClosed { get; }
  • public object this[int i] { get; }
  • public object this[string name] { get; }
  • public int RecordsAffected { get; }
  • public CsvDataReader(CsvReader csv, DataTable schemaTable = null)
  • public void Close()
  • public void Dispose()
  • public bool GetBoolean(int i)
  • public byte GetByte(int i)
  • public long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length)
  • public char GetChar(int i)
  • public long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length)
  • public IDataReader GetData(int i)
  • public string GetDataTypeName(int i)
  • public DateTime GetDateTime(int i)
  • public decimal GetDecimal(int i)
  • public double GetDouble(int i)
  • public Type GetFieldType(int i)
  • public float GetFloat(int i)
  • public Guid GetGuid(int i)
  • public short GetInt16(int i)
  • public int GetInt32(int i)
  • public long GetInt64(int i)
  • public string GetName(int i)
  • public int GetOrdinal(string name)
  • public DataTable GetSchemaTable()
  • public string GetString(int i)
  • public object GetValue(int i)
  • public int GetValues(object[] values)
  • public bool IsDBNull(int i)
  • public bool NextResult()
  • public bool Read()
• public class CsvHelperException : Exception
  • public int FieldIndex { get; set; }
  • public string FieldName { get; set; }
  • public string FieldValue { get; set; }
  • public int Row { get; set; }
  • public Type Type { get; set; }
  • public CsvHelperException()
  • public CsvHelperException(string message)
  • public CsvHelperException(string message, Exception innerException)
  • public CsvContext Context { get; }
  • public CsvHelperException(CsvContext context)
  • public CsvHelperException(CsvContext context, string message)
  • public CsvHelperException(CsvContext context, string message, Exception innerException)
• public class CsvMissingFieldException : CsvReaderException
• public enum CsvMode
  • Escape = 1
  • NoEscape = 2
  • RFC4180 = 0
• public class CsvParser : IParser, IDisposable
  • public virtual long BytePosition { get; }
  • public virtual long CharPosition { get; }
  • public virtual ICsvParserConfiguration Configuration { get; }
  • protected struct ProcessedField
  • public long ByteCount { get; }
  • public long CharCount { get; }
  • public IParserConfiguration Configuration { get; }
  • public CsvContext Context { get; }
  • public int Count { get; }
  • public string Delimiter { get; }
  • public string this[int index] { get; }
  • public string[] Record { get; }
  • public virtual TextReader TextReader { get; }
  • public CsvParser(TextReader reader)
  • public CsvParser(TextReader reader, bool leaveOpen)
  • public CsvParser(TextReader reader, ICsvParserConfiguration configuration)
  • public CsvParser(TextReader reader, ICsvParserConfiguration configuration, bool leaveOpen)
  • public CsvParser(TextReader reader, CultureInfo culture, bool leaveOpen = false)
  • public CsvParser(TextReader reader, IParserConfiguration configuration, bool leaveOpen = false)
  • public virtual string[] Read()
  • protected virtual void ReadBlankLine()
  • protected virtual bool ReadDelimiter()
  • protected virtual bool ReadExcelLeadingZerosField()
  • protected virtual void ReadExcelSeparator()
  • protected virtual bool ReadField()
  • protected virtual string[] ReadLine()
  • protected virtual int ReadLineEnding()
  • protected virtual bool ReadQuotedField()
  • protected ProcessedField ProcessEscapeField(int start, int length)
  • protected ProcessedField ProcessNoEscapeField(int start, int length)
  • protected ProcessedField ProcessRFC4180BadField(int start, int length)
  • protected ProcessedField ProcessRFC4180Field(int start, int length, int quoteCount)
  • public bool Read()
  • public Task<bool> ReadAsync()
• public class CsvParserException : CsvHelperException
• public class CsvReader : IReader, IReaderRow, IDisposable
  • public virtual ICsvReaderConfiguration Configuration { get; }
  • public virtual string[] CurrentRecord { get; }
  • public virtual string[] FieldHeaders { get; }
  • public virtual int ColumnCount { get; }
  • public virtual IReaderConfiguration Configuration { get; }
  • public virtual CsvContext Context { get; }
  • public virtual int CurrentIndex { get; }
  • public virtual string[] HeaderRecord { get; }
  • public virtual ICsvParser Parser { get; }
  • public int Row { get; }
  • public CsvReader(TextReader reader)
  • public CsvReader(TextReader reader, bool leaveOpen)
  • public CsvReader(TextReader reader, CsvConfiguration configuration)
  • public CsvReader(TextReader reader, CsvConfiguration configuration, bool leaveOpen)
  • public CsvReader(ICsvParser parser)
  • public CsvReader(ICsvParser parser, bool leaveOpen)
  • protected virtual void AddPropertyBindings(CsvPropertyMapCollection members, List<MemberBinding> bindings)
  • protected virtual bool CanRead(CsvPropertyMap propertyMap)
  • protected virtual bool CanRead(CsvPropertyReferenceMap propertyReferenceMap)
  • public virtual IParser Parser { get; }
  • public CsvReader(TextReader reader, CultureInfo culture, bool leaveOpen = false)
  • public CsvReader(TextReader reader, IReaderConfiguration configuration, bool leaveOpen = false)
  • public CsvReader(IParser parser)
  • public virtual bool CanRead(MemberMap memberMap)
  • public virtual bool CanRead(MemberReferenceMap memberReferenceMap)
  • public virtual void ClearRecordCache<T>()
  • public virtual void ClearRecordCache(Type type)
  • public virtual void ClearRecordCache()
  • protected virtual object CreateDynamic()
  • protected virtual void CreateFuncForObject(Type recordType)
  • protected virtual void CreateFuncForPrimitive(Type recordType)
  • protected virtual void CreatePropertyBindingsForMapping(CsvClassMap mapping, Type recordType, List<MemberBinding> bindings)
  • protected virtual void CreateReadRecordFunc(Type recordType)
  • protected virtual T CreateRecord<T>()
  • protected virtual object CreateRecord(Type type)
  • protected virtual Func<string, bool> GetEmtpyStringMethod()
  • public virtual IEnumerable<T> EnumerateRecords<T>(T record)
  • public virtual IAsyncEnumerable<T> EnumerateRecordsAsync<T>(T record, CancellationToken cancellationToken = default)
  • protected virtual int GetFieldIndex(string[] names, int index = 0, bool isTryGet = false)
  • protected virtual Func<T> GetReadRecordFunc<T>()
  • protected virtual Delegate GetReadRecordFunc(Type recordType)
  • public virtual int GetFieldIndex(IEnumerable<string> names, int index = 0, bool isTryGet = false, bool isOptional = false)
  • public virtual T GetRecord<T>(T anonymousTypeDefinition)
  • public virtual IEnumerable<T> GetRecords<T>(T anonymousTypeDefinition)
  • public virtual bool IsRecordEmpty()
  • protected virtual bool IsRecordEmpty(bool checkHasBeenRead)
  • public virtual IAsyncEnumerable<T> GetRecordsAsync<T>(CancellationToken cancellationToken = default)
  • public virtual IAsyncEnumerable<T> GetRecordsAsync<T>(T anonymousTypeDefinition, CancellationToken cancellationToken = default)
  • public virtual IAsyncEnumerable<object> GetRecordsAsync(Type type, CancellationToken cancellationToken = default)
  • public virtual Task<bool> ReadAsync()
  • protected virtual bool ShouldSkipRecord()
  • public virtual void ValidateHeader<T>()
  • public virtual void ValidateHeader(Type type)
  • protected virtual void ValidateHeader(ClassMap map, List<InvalidHeader> invalidHeaders)
• public class CsvReaderException : CsvHelperException
• public class CsvSerializer : ICsvSerializer, IDisposable
• public class CsvWriter : IWriter, IWriterRow, IDisposable, IAsyncDisposable
  • public virtual ICsvWriterConfiguration Configuration { get; }
  • public virtual List<string> CurrentRecord { get; }
  • public virtual IWriterConfiguration Configuration { get; }
  • public virtual CsvContext Context { get; }
  • public virtual string[] HeaderRecord { get; }
  • public virtual int Index { get; }
  • public virtual ICsvSerializer Serializer { get; }
  • public CsvWriter(TextWriter writer)
  • public CsvWriter(TextWriter writer, bool leaveOpen)
  • public CsvWriter(TextWriter writer, ICsvWriterConfiguration configuration)
  • public CsvWriter(ICsvSerializer serializer)
  • public CsvWriter(ICsvSerializer serializer, bool leaveOpen)
  • protected virtual void AddProperties(CsvPropertyMapCollection properties, CsvClassMap mapping)
  • protected virtual bool CanWrite(CsvPropertyMap propertyMap)
  • public virtual void ClearRecordCache<T>()
  • public virtual void ClearRecordCache(Type type)
  • public virtual void ClearRecordCache()
  • protected virtual Delegate CombineDelegates(IEnumerable<Delegate> delegates)
  • protected virtual Delegate CreateActionForDynamic(IDynamicMetaObjectProvider provider)
  • protected virtual Delegate CreateActionForExpandoObject(ExpandoObject obj)
  • protected virtual Delegate CreateActionForObject(Type type)
  • protected virtual Delegate CreateActionForPrimitive(Type type)
  • protected virtual Expression CreatePropertyExpression(Expression recordExpression, CsvClassMap mapping, CsvPropertyMap propertyMap)
  • protected virtual Delegate CreateWriteRecordAction<T>(Type type, T record)
  • public CsvWriter(TextWriter writer, CultureInfo culture, bool leaveOpen = false)
  • public CsvWriter(TextWriter writer, IWriterConfiguration configuration, bool leaveOpen = false)
  • public virtual bool CanWrite(MemberMap memberMap)
  • protected virtual Delegate GetWriteRecordAction<T>(T record)
  • public ValueTask DisposeAsync()
  • protected virtual ValueTask DisposeAsync(bool disposing)
  • public virtual void Flush()
  • public virtual Task FlushAsync()
  • protected virtual void FlushBuffer()
  • protected virtual Task FlushBufferAsync()
  • public virtual RecordTypeInfo GetTypeInfoForRecord<T>(T record)
  • public virtual Task NextRecordAsync()
  • protected virtual string SanitizeForInjection(string field)
  • public virtual void WriteConvertedField(string field)
  • public virtual void WriteConvertedField(string field, Type fieldType)
  • public virtual void WriteExcelSeparator()
  • public virtual void WriteRecords<T>(IEnumerable<T> records)
  • public virtual Task WriteRecordsAsync(IEnumerable records, CancellationToken cancellationToken = default)
  • public virtual Task WriteRecordsAsync<T>(IEnumerable<T> records, CancellationToken cancellationToken = default)
  • public virtual Task WriteRecordsAsync<T>(IAsyncEnumerable<T> records, CancellationToken cancellationToken = default)
  • protected void WriteToBuffer(string value)
• public class CsvWriterException : CsvHelperException
• public class FieldReader : IDisposable
• public interface ICsvFactory
• public interface ICsvParser : IDisposable
• public interface ICsvReader : ICsvReaderRow, IDisposable
• public interface ICsvReaderRow
• public interface ICsvSerializer : IDisposable
• public interface ICsvWriter : ICsvWriterRow, IDisposable
• public interface ICsvWriterRow
• public class RecordBuilder
• public class Factory : IFactory
  • public Factory()
  • public IHasMap<T> CreateClassMapBuilder<T>()
  • public virtual IParser CreateParser(TextReader reader, CsvConfiguration configuration)
  • public virtual IParser CreateParser(TextReader reader, CultureInfo cultureInfo)
  • public virtual IReader CreateReader(TextReader reader, CsvConfiguration configuration)
  • public virtual IReader CreateReader(TextReader reader, CultureInfo cultureInfo)
  • public virtual IReader CreateReader(IParser parser)
  • public virtual IWriter CreateWriter(TextWriter writer, CsvConfiguration configuration)
  • public virtual IWriter CreateWriter(TextWriter writer, CultureInfo cultureInfo)
• public class FieldValidationException : ValidationException
  • public string Field { get; }
  • public FieldValidationException(CsvContext context, string field)
  • public FieldValidationException(CsvContext context, string field, string message)
  • public FieldValidationException(CsvContext context, string field, string message, Exception innerException)
• public sealed delegate GetConstructor : MulticastDelegate
  • public GetConstructor(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(GetConstructorArgs args, AsyncCallback callback, object object)
  • public virtual ConstructorInfo EndInvoke(IAsyncResult result)
  • public virtual ConstructorInfo Invoke(GetConstructorArgs args)
• public struct GetConstructorArgs
  • public readonly Type ClassType
  • public GetConstructorArgs(Type classType)
• public sealed delegate GetDynamicPropertyName : MulticastDelegate
  • public GetDynamicPropertyName(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(GetDynamicPropertyNameArgs args, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(GetDynamicPropertyNameArgs args)
• public struct GetDynamicPropertyNameArgs
  • public readonly CsvContext Context
  • public readonly int FieldIndex
  • public GetDynamicPropertyNameArgs(int fieldIndex, CsvContext context)
• public sealed delegate HeaderValidated : MulticastDelegate
  • public HeaderValidated(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(HeaderValidatedArgs args, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(HeaderValidatedArgs args)
• public struct HeaderValidatedArgs
  • public readonly CsvContext Context
  • public readonly InvalidHeader[] InvalidHeaders
  • public HeaderValidatedArgs(InvalidHeader[] invalidHeaders, CsvContext context)
• public class HeaderValidationException : ValidationException
  • public InvalidHeader[] InvalidHeaders { get; }
  • public HeaderValidationException(CsvContext context, InvalidHeader[] invalidHeaders)
  • public HeaderValidationException(CsvContext context, InvalidHeader[] invalidHeaders, string message)
  • public HeaderValidationException(CsvContext context, InvalidHeader[] invalidHeaders, string message, Exception innerException)
• public interface IFactory
  • IHasMap<T> CreateClassMapBuilder<T>()
  • IParser CreateParser(TextReader reader, CsvConfiguration configuration)
  • IParser CreateParser(TextReader reader, CultureInfo cultureInfo)
  • IReader CreateReader(TextReader reader, CsvConfiguration configuration)
  • IReader CreateReader(TextReader reader, CultureInfo cultureInfo)
  • IReader CreateReader(IParser parser)
  • IWriter CreateWriter(TextWriter writer, CsvConfiguration configuration)
  • IWriter CreateWriter(TextWriter writer, CultureInfo cultureInfo)
• public class InvalidHeader
  • public int Index { get; set; }
  • public List<string> Names { get; set; }
  • public InvalidHeader()
• public interface IObjectResolver
  • Func<Type, bool> CanResolve { get; }
  • Func<Type, object[], object> ResolveFunction { get; }
  • bool UseFallback { get; }
  • object Resolve(Type type, object[] constructorArgs)
  • T Resolve<T>(object[] constructorArgs)
• public interface IParser : IDisposable
  • long ByteCount { get; }
  • long CharCount { get; }
  • IParserConfiguration Configuration { get; }
  • CsvContext Context { get; }
  • int Count { get; }
  • string Delimiter { get; }
  • string this[int index] { get; }
  • string RawRecord { get; }
  • int RawRow { get; }
  • string[] Record { get; }
  • int Row { get; }
  • bool Read()
  • Task<bool> ReadAsync()
• public interface IReader : IReaderRow, IDisposable
  • IEnumerable<T> EnumerateRecords<T>(T record)
  • IAsyncEnumerable<T> EnumerateRecordsAsync<T>(T record, CancellationToken cancellationToken = default)
  • IEnumerable<T> GetRecords<T>()
  • IEnumerable<T> GetRecords<T>(T anonymousTypeDefinition)
  • IEnumerable<object> GetRecords(Type type)
  • IAsyncEnumerable<T> GetRecordsAsync<T>(CancellationToken cancellationToken = default)
  • IAsyncEnumerable<T> GetRecordsAsync<T>(T anonymousTypeDefinition, CancellationToken cancellationToken = default)
  • IAsyncEnumerable<object> GetRecordsAsync(Type type, CancellationToken cancellationToken = default)
  • bool Read()
  • Task<bool> ReadAsync()
  • bool ReadHeader()
• public interface IReaderRow
  • int ColumnCount { get; }
  • IReaderConfiguration Configuration { get; }
  • CsvContext Context { get; }
  • int CurrentIndex { get; }
  • string[] HeaderRecord { get; }
  • string this[int index] { get; }
  • string this[string name] { get; }
  • string this[string name, int index] { get; }
  • IParser Parser { get; }
  • string GetField(int index)
  • string GetField(string name)
  • string GetField(string name, int index)
  • object GetField(Type type, int index)
  • object GetField(Type type, string name)
  • object GetField(Type type, string name, int index)
  • object GetField(Type type, int index, ITypeConverter converter)
  • object GetField(Type type, string name, ITypeConverter converter)
  • object GetField(Type type, string name, int index, ITypeConverter converter)
  • T GetField<T>(int index)
  • T GetField<T>(string name)
  • T GetField<T>(string name, int index)
  • T GetField<T>(int index, ITypeConverter converter)
  • T GetField<T>(string name, ITypeConverter converter)
  • T GetField<T>(string name, int index, ITypeConverter converter)
  • T GetField<T, TConverter>(int index) where TConverter : ITypeConverter
  • T GetField<T, TConverter>(string name) where TConverter : ITypeConverter
  • T GetField<T, TConverter>(string name, int index) where TConverter : ITypeConverter
  • T GetRecord<T>()
  • T GetRecord<T>(T anonymousTypeDefinition)
  • object GetRecord(Type type)
  • bool TryGetField(Type type, int index, out object field)
  • bool TryGetField(Type type, string name, out object field)
  • bool TryGetField(Type type, string name, int index, out object field)
  • bool TryGetField(Type type, int index, ITypeConverter converter, out object field)
  • bool TryGetField(Type type, string name, ITypeConverter converter, out object field)
  • bool TryGetField(Type type, string name, int index, ITypeConverter converter, out object field)
  • bool TryGetField<T>(int index, out T field)
  • bool TryGetField<T>(string name, out T field)
  • bool TryGetField<T>(string name, int index, out T field)
  • bool TryGetField<T>(int index, ITypeConverter converter, out T field)
  • bool TryGetField<T>(string name, ITypeConverter converter, out T field)
  • bool TryGetField<T>(string name, int index, ITypeConverter converter, out T field)
  • bool TryGetField<T, TConverter>(int index, out T field) where TConverter : ITypeConverter
  • bool TryGetField<T, TConverter>(string name, out T field) where TConverter : ITypeConverter
  • bool TryGetField<T, TConverter>(string name, int index, out T field) where TConverter : ITypeConverter
• public interface IWriter : IWriterRow, IDisposable, IAsyncDisposable
  • void Flush()
  • Task FlushAsync()
  • void NextRecord()
  • Task NextRecordAsync()
  • void WriteRecords(IEnumerable records)
  • void WriteRecords<T>(IEnumerable<T> records)
  • Task WriteRecordsAsync(IEnumerable records, CancellationToken cancellationToken = default)
  • Task WriteRecordsAsync<T>(IEnumerable<T> records, CancellationToken cancellationToken = default)
  • Task WriteRecordsAsync<T>(IAsyncEnumerable<T> records, CancellationToken cancellationToken = default)
• public interface IWriterRow
  • IWriterConfiguration Configuration { get; }
  • CsvContext Context { get; }
  • string[] HeaderRecord { get; }
  • int Index { get; }
  • int Row { get; }
  • void WriteComment(string comment)
  • void WriteConvertedField(string field, Type fieldType)
  • void WriteField(string field)
  • void WriteField(string field, bool shouldQuote)
  • void WriteField<T>(T field)
  • void WriteField<T>(T field, ITypeConverter converter)
  • void WriteField<T, TConverter>(T field)
  • void WriteHeader<T>()
  • void WriteHeader(Type type)
  • void WriteRecord<T>(T record)
• public class MaxFieldSizeException : CsvHelperException
  • public MaxFieldSizeException(CsvContext context)
  • public MaxFieldSizeException(CsvContext context, string message)
  • public MaxFieldSizeException(CsvContext context, string message, Exception innerException)
• public class MissingFieldException : ReaderException
  • public MissingFieldException(CsvContext context)
  • public MissingFieldException(CsvContext context, string message)
  • public MissingFieldException(CsvContext context, string message, Exception innerException)
• public sealed delegate MissingFieldFound : MulticastDelegate
  • public MissingFieldFound(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(MissingFieldFoundArgs args, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(MissingFieldFoundArgs args)
• public struct MissingFieldFoundArgs
  • public readonly CsvContext Context
  • public readonly string[] HeaderNames
  • public readonly int Index
  • public MissingFieldFoundArgs(string[] headerNames, int index, CsvContext context)
• public class ObjectCreator
  • public ObjectCreator()
  • public T CreateInstance<T>(object[] args)
  • public object CreateInstance(Type type, object[] args)
• public class ObjectResolver : IObjectResolver
  • public static IObjectResolver Current { get; set; }
  • public Func<Type, bool> CanResolve { get; }
  • public Func<Type, object[], object> ResolveFunction { get; }
  • public bool UseFallback { get; }
  • public ObjectResolver()
  • public ObjectResolver(Func<Type, bool> canResolve, Func<Type, object[], object> resolveFunction, bool useFallback = true)
  • public object Resolve(Type type, object[] constructorArgs)
  • public T Resolve<T>(object[] constructorArgs)
• public class ParserException : CsvHelperException
  • public ParserException(CsvContext context)
  • public ParserException(CsvContext context, string message)
  • public ParserException(CsvContext context, string message, Exception innerException)
• public sealed delegate PrepareHeaderForMatch : MulticastDelegate
  • public PrepareHeaderForMatch(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(PrepareHeaderForMatchArgs args, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(PrepareHeaderForMatchArgs args)
• public struct PrepareHeaderForMatchArgs
  • public readonly int FieldIndex
  • public readonly string Header
  • public PrepareHeaderForMatchArgs(string header, int fieldIndex)
• public class ReaderException : CsvHelperException
  • public ReaderException(CsvContext context)
  • public ReaderException(CsvContext context, string message)
  • public ReaderException(CsvContext context, string message, Exception innerException)
• public sealed delegate ReadingExceptionOccurred : MulticastDelegate
  • public ReadingExceptionOccurred(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ReadingExceptionOccurredArgs args, AsyncCallback callback, object object)
  • public virtual bool EndInvoke(IAsyncResult result)
  • public virtual bool Invoke(ReadingExceptionOccurredArgs args)
• public struct ReadingExceptionOccurredArgs
  • public readonly CsvHelperException Exception
  • public ReadingExceptionOccurredArgs(CsvHelperException exception)
• public struct RecordTypeInfo
  • public int HashCode { get; }
  • public bool IsObject { get; }
  • public Type RecordType { get; }
  • public RecordTypeInfo(Type recordType, bool isObject)
• public sealed delegate ReferenceHeaderPrefix : MulticastDelegate
  • public ReferenceHeaderPrefix(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ReferenceHeaderPrefixArgs args, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(ReferenceHeaderPrefixArgs args)
• public struct ReferenceHeaderPrefixArgs
  • public readonly string MemberName
  • public readonly Type MemberType
  • public ReferenceHeaderPrefixArgs(Type memberType, string memberName)
• public static class ReflectionExtensions
  • public static ConstructorInfo GetConstructorWithMostParameters(this Type type)
  • public static string GetDefinition(this ConstructorInfo constructor)
  • public static string GetDefinition(this ParameterInfo parameter)
  • public static bool HasConstructor(this Type type)
  • public static bool HasParameterlessConstructor(this Type type)
  • public static bool IsAnonymous(this Type type)
  • public static bool IsUserDefinedStruct(this Type type)
• public sealed delegate ShouldQuote : MulticastDelegate
  • public ShouldQuote(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ShouldQuoteArgs args, AsyncCallback callback, object object)
  • public virtual bool EndInvoke(IAsyncResult result)
  • public virtual bool Invoke(ShouldQuoteArgs args)
• public struct ShouldQuoteArgs
  • public readonly string Field
  • public readonly Type FieldType
  • public readonly IWriterRow Row
  • public ShouldQuoteArgs(string field, Type fieldType, IWriterRow row)
• public sealed delegate ShouldSkipRecord : MulticastDelegate
  • public ShouldSkipRecord(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ShouldSkipRecordArgs args, AsyncCallback callback, object object)
  • public virtual bool EndInvoke(IAsyncResult result)
  • public virtual bool Invoke(ShouldSkipRecordArgs args)
• public struct ShouldSkipRecordArgs
  • public readonly IReaderRow Row
  • public ShouldSkipRecordArgs(IReaderRow row)
• public sealed delegate ShouldUseConstructorParameters : MulticastDelegate
  • public ShouldUseConstructorParameters(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ShouldUseConstructorParametersArgs args, AsyncCallback callback, object object)
  • public virtual bool EndInvoke(IAsyncResult result)
  • public virtual bool Invoke(ShouldUseConstructorParametersArgs args)
• public struct ShouldUseConstructorParametersArgs
  • public readonly Type ParameterType
  • public ShouldUseConstructorParametersArgs(Type parameterType)
• public sealed delegate Validate : MulticastDelegate
  • public Validate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ValidateArgs args, AsyncCallback callback, object object)
  • public virtual bool EndInvoke(IAsyncResult result)
  • public virtual bool Invoke(ValidateArgs args)
• public struct ValidateArgs
  • public readonly string Field
  • public readonly IReaderRow Row
  • public ValidateArgs(string field, IReaderRow row)
• public sealed delegate ValidateMessage : MulticastDelegate
  • public ValidateMessage(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ValidateArgs args, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(ValidateArgs args)
• public abstract class ValidationException : CsvHelperException
  • public ValidationException(CsvContext context)
  • public ValidationException(CsvContext context, string message)
  • public ValidationException(CsvContext context, string message, Exception innerException)
• public class WriterException : CsvHelperException
  • public WriterException(CsvContext context)
  • public WriterException(CsvContext context, string message)
  • public WriterException(CsvContext context, string message, Exception innerException)

CsvHelper.Configuration

• public class AutoMapOptions
• public abstract class CsvClassMap
• public abstract class CsvClassMap<T> : CsvClassMap
• public class CsvClassMapCollection
• public abstract class ClassMap
  • public virtual Type ClassType { get; }
  • public virtual MemberMapCollection MemberMaps { get; }
  • public virtual List<ParameterMap> ParameterMaps { get; }
  • public virtual MemberReferenceMapCollection ReferenceMaps { get; }
  • protected virtual void ApplyAttributes(ParameterMap parameterMap)
  • protected virtual void ApplyAttributes(ParameterReferenceMap referenceMap)
  • protected virtual void ApplyAttributes(MemberMap memberMap)
  • protected virtual void ApplyAttributes(MemberReferenceMap referenceMap)
  • public virtual void AutoMap(CultureInfo culture)
  • public virtual void AutoMap(CsvConfiguration configuration)
  • public virtual void AutoMap(CsvContext context)
  • protected virtual void AutoMapConstructorParameters(ClassMap map, CsvContext context, LinkedList<Type> mapParents, int indexStart = 0)
  • protected virtual void AutoMapMembers(ClassMap map, CsvContext context, LinkedList<Type> mapParents, int indexStart = 0)
  • protected virtual bool CheckForCircularReference(Type type, LinkedList<Type> mapParents)
  • protected virtual Type GetGenericType()
  • public virtual int GetMaxIndex(bool isParameter = false)
  • public MemberMap Map(Type classType, MemberInfo member, bool useExistingMap = true)
  • public virtual MemberMap<object, object> Map()
  • public virtual ParameterMap Parameter(string name)
  • public virtual ParameterMap Parameter(Func<ConstructorInfo> getConstructor, string name)
  • public virtual ParameterMap Parameter(ConstructorInfo constructor, ParameterInfo parameter)
  • public virtual MemberReferenceMap References(Type classMapType, MemberInfo member, object[] constructorArgs)
  • public virtual int ReIndex(int indexStart = 0)
• public abstract class ClassMap<TClass> : ClassMap
  • public ClassMap()
  • public virtual MemberMap<TClass, TMember> Map<TMember>(Expression<Func<TClass, TMember>> expression, bool useExistingMap = true)
  • public virtual MemberMap Map<T>(Expression<Func<T, object>> expression, bool useExistingMap = true)
  • public virtual MemberReferenceMap References<TClassMap>(Expression<Func<TClass, object>> expression, object[] constructorArgs) where TClassMap : ClassMap
• public class ClassMapCollection
  • public virtual ClassMap this[Type type] { get; }
  • public ClassMapCollection(CsvContext context)
  • public virtual ClassMap<T> Find<T>()
• public class ConfigurationException : CsvHelperException
  • public ConfigurationException()
  • public ConfigurationException(string message)
  • public ConfigurationException(string message, Exception innerException)
• public static class ConfigurationFunctions
  • public static void BadDataFound(BadDataFoundArgs args)
  • public static ConstructorInfo GetConstructor(GetConstructorArgs args)
  • public static string GetDelimiter(GetDelimiterArgs args)
  • public static string GetDynamicPropertyName(GetDynamicPropertyNameArgs args)
  • public static void HeaderValidated(HeaderValidatedArgs args)
  • public static void MissingFieldFound(MissingFieldFoundArgs args)
  • public static string PrepareHeaderForMatch(PrepareHeaderForMatchArgs args)
  • public static bool ReadingExceptionOccurred(ReadingExceptionOccurredArgs args)
  • public static bool ShouldQuote(ShouldQuoteArgs args)
  • public static bool ShouldUseConstructorParameters(ShouldUseConstructorParametersArgs args)
• public class CsvConfiguration : IReaderConfiguration, IParserConfiguration, IWriterConfiguration, IEquatable<CsvConfiguration>
  • public virtual Action<string> BadDataCallback { get; set; }
  • public virtual BadDataFound BadDataFound { get; set; }
  • public virtual bool CacheFields { get; set; }
  • public virtual string DoubleQuoteString { get; }
  • public virtual bool DetectDelimiter { get; set; }
  • public virtual string[] DetectDelimiterValues { get; set; }
  • public virtual IComparer<string> DynamicPropertySort { get; set; }
  • public virtual bool HasExcelSeparator { get; set; }
  • protected virtual Type EqualityContract { get; }
  • public virtual char Escape { get; set; }
  • public virtual bool ExceptionMessagesContainRawData { get; set; }
  • public virtual GetConstructor GetConstructor { get; set; }
  • public virtual GetDelimiter GetDelimiter { get; set; }
  • public virtual GetDynamicPropertyName GetDynamicPropertyName { get; set; }
  • public virtual HeaderValidated HeaderValidated { get; set; }
  • public virtual bool IgnoreQuotes { get; set; }
  • public virtual bool IgnoreReadingExceptions { get; set; }
  • public virtual CsvClassMapCollection Maps { get; }
  • public virtual char[] InjectionCharacters { get; set; }
  • public virtual char InjectionEscapeCharacter { get; set; }
  • public virtual InjectionOptions InjectionOptions { get; set; }
  • public bool IsNewLineSet { get; }
  • public virtual bool LineBreakInQuotedFieldIsBadData { get; set; }
  • public double MaxFieldSize { get; set; }
  • public virtual bool PrefixReferenceHeaders { get; set; }
  • public virtual Func<string, string> PrepareHeaderForMatch { get; set; }
  • public virtual MissingFieldFound MissingFieldFound { get; set; }
  • public virtual CsvMode Mode { get; set; }
  • public virtual string NewLine { get; set; }
  • public virtual PrepareHeaderForMatch PrepareHeaderForMatch { get; set; }
  • public virtual int ProcessFieldBufferSize { get; set; }
  • public virtual bool QuoteAllFields { get; set; }
  • public virtual bool QuoteNoFields { get; set; }
  • public virtual char[] QuoteRequiredChars { get; }
  • public virtual string QuoteString { get; }
  • public virtual Action<CsvHelperException, ICsvReader> ReadingExceptionCallback { get; set; }
  • public virtual Func<string[], bool> ShouldSkipRecord { get; set; }
  • public virtual bool SkipEmptyRecords { get; set; }
  • public virtual bool ThrowOnBadData { get; set; }
  • public virtual bool TrimFields { get; set; }
  • public virtual TypeConverterOptionsFactory TypeConverterOptionsFactory { get; set; }
  • public virtual bool UseExcelLeadingZerosFormatForNumerics { get; set; }
  • public virtual ReadingExceptionOccurred ReadingExceptionOccurred { get; set; }
  • public virtual ReferenceHeaderPrefix ReferenceHeaderPrefix { get; set; }
  • public ShouldQuote ShouldQuote { get; set; }
  • public virtual ShouldSkipRecord ShouldSkipRecord { get; set; }
  • public virtual ShouldUseConstructorParameters ShouldUseConstructorParameters { get; set; }
  • public virtual TrimOptions TrimOptions { get; set; }
  • public virtual bool WillThrowOnMissingField { get; set; }
  • public CsvConfiguration()
  • public virtual CsvClassMap AutoMap<T>()
  • public virtual CsvClassMap AutoMap(Type type)
  • public virtual TMap RegisterClassMap<TMap>() where TMap : CsvClassMap
  • public virtual CsvClassMap RegisterClassMap(Type classMapType)
  • public virtual void RegisterClassMap(CsvClassMap map)
  • public virtual void UnregisterClassMap<TMap>() where TMap : CsvClassMap
  • public virtual void UnregisterClassMap(Type classMapType)
  • public virtual void UnregisterClassMap()
  • public virtual char[] WhiteSpaceChars { get; set; }
  • public CsvConfiguration(CultureInfo cultureInfo)
  • public CsvConfiguration(CultureInfo cultureInfo, Type attributesType)
  • protected CsvConfiguration(CsvConfiguration original)
  • public static CsvConfiguration FromAttributes<T>()
  • public static CsvConfiguration FromAttributes<T>(CultureInfo cultureInfo)
  • public static CsvConfiguration FromAttributes(Type type)
  • public static CsvConfiguration FromAttributes(Type type, CultureInfo cultureInfo)
  • public static bool op_Equality(CsvConfiguration left, CsvConfiguration right)
  • public static bool op_Inequality(CsvConfiguration left, CsvConfiguration right)
  • public virtual CsvConfiguration <Clone>$()
  • public CsvConfiguration ApplyAttributes<T>()
  • public CsvConfiguration ApplyAttributes(Type type)
  • public virtual bool Equals(CsvConfiguration other)
  • protected virtual bool PrintMembers(StringBuilder builder)
  • public void Validate()
• public class CsvConfigurationException : CsvHelperException
• public class CsvPropertyMap
• public class CsvPropertyMapCollection : IList<CsvPropertyMap>, ICollection<CsvPropertyMap>, IEnumerable<CsvPropertyMap>, IEnumerable
• public class CsvPropertyMapData
• public class CsvPropertyNameCollection : IEnumerable<string>, IEnumerable
• public class CsvPropertyReferenceMap
• public class CsvPropertyReferenceMapCollection : IList<CsvPropertyReferenceMap>, ICollection<CsvPropertyReferenceMap>, IEnumerable<CsvPropertyReferenceMap>, IEnumerable
• public class CsvPropertyReferenceMapData
• public class DefaultCsvClassMap<T> : CsvClassMap<T>
• public interface ICsvParserConfiguration
• public interface ICsvReaderConfiguration : ICsvParserConfiguration
• public interface ICsvSerializerConfiguration
• public interface ICsvWriterConfiguration : ICsvSerializerConfiguration
• public class MapTypeConverterOption
• public class DefaultClassMap<T> : ClassMap<T>
  • public DefaultClassMap()
• public interface IBuildableClass<TClass>
  • ClassMap<TClass> Build()
• public interface IHasConstant<TClass, TMember> : IBuildableClass<TClass>
  • IHasMap<TClass> Constant(TMember value)
• public interface IHasConvertUsing<TClass, TMember> : IBuildableClass<TClass>
  • IHasMap<TClass> ConvertUsing(ConvertFromString<TMember> convertExpression)
  • IHasMap<TClass> ConvertUsing(ConvertToString<TClass> convertExpression)
• public interface IHasDefault<TClass, TMember> : IBuildableClass<TClass>
  • IHasDefaultOptions<TClass, TMember> Default(TMember defaultValue)
  • IHasDefaultOptions<TClass, TMember> Default(string defaultValue)
• public interface IHasDefaultOptions<TClass, TMember> : IHasMap<TClass>, IBuildableClass<TClass>, IHasValidate<TClass, TMember>
• public interface IHasIndex<TClass, TMember> : IBuildableClass<TClass>
  • IHasIndexOptions<TClass, TMember> Index(int index, int indexEnd = -1)
• public interface IHasIndexOptions<TClass, TMember> : IHasMap<TClass>, IBuildableClass<TClass>, IHasTypeConverter<TClass, TMember>, IHasName<TClass, TMember>, IHasDefault<TClass, TMember>, IHasValidate<TClass, TMember>
• public interface IHasMap<TClass> : IBuildableClass<TClass>
  • IHasMapOptions<TClass, TMember> Map<TMember>(Expression<Func<TClass, TMember>> expression, bool useExistingMap = true)
• public interface IHasMapOptions<TClass, TMember> : IHasMap<TClass>, IBuildableClass<TClass>, IHasTypeConverter<TClass, TMember>, IHasIndex<TClass, TMember>, IHasName<TClass, TMember>, IHasOptional<TClass, TMember>, IHasConvertUsing<TClass, TMember>, IHasDefault<TClass, TMember>, IHasConstant<TClass, TMember>, IHasValidate<TClass, TMember>
• public interface IHasName<TClass, TMember> : IBuildableClass<TClass>
  • IHasNameOptions<TClass, TMember> Name(string[] names)
• public interface IHasNameIndex<TClass, TMember> : IBuildableClass<TClass>
  • IHasNameIndexOptions<TClass, TMember> NameIndex(int index)
• public interface IHasNameIndexOptions<TClass, TMember> : IHasMap<TClass>, IBuildableClass<TClass>, IHasTypeConverter<TClass, TMember>, IHasDefault<TClass, TMember>, IHasValidate<TClass, TMember>
• public interface IHasNameOptions<TClass, TMember> : IHasMap<TClass>, IBuildableClass<TClass>, IHasTypeConverter<TClass, TMember>, IHasNameIndex<TClass, TMember>, IHasDefault<TClass, TMember>, IHasValidate<TClass, TMember>
• public interface IHasOptional<TClass, TMember> : IBuildableClass<TClass>
  • IHasOptionalOptions<TClass, TMember> Optional()
• public interface IHasOptionalOptions<TClass, TMember> : IHasMap<TClass>, IBuildableClass<TClass>, IHasTypeConverter<TClass, TMember>, IHasName<TClass, TMember>, IHasDefault<TClass, TMember>, IHasValidate<TClass, TMember>
• public interface IHasTypeConverter<TClass, TMember> : IBuildableClass<TClass>
  • IHasTypeConverterOptions<TClass, TMember> TypeConverter(ITypeConverter typeConverter)
  • IHasTypeConverterOptions<TClass, TMember> TypeConverter<TConverter>() where TConverter : ITypeConverter
• public interface IHasTypeConverterOptions<TClass, TMember> : IHasMap<TClass>, IBuildableClass<TClass>, IHasDefault<TClass, TMember>, IHasValidate<TClass, TMember>
• public interface IHasValidate<TClass, TMember> : IBuildableClass<TClass>
  • IHasMap<TClass> Validate(Validate validateExpression)
• public enum InjectionOptions
  • Escape = 1
  • Exception = 3
  • None = 0
  • Strip = 2
• public interface IParserConfiguration
  • bool AllowComments { get; }
  • BadDataFound BadDataFound { get; }
  • int BufferSize { get; }
  • bool CacheFields { get; }
  • char Comment { get; }
  • bool CountBytes { get; }
  • CultureInfo CultureInfo { get; }
  • string Delimiter { get; }
  • bool DetectDelimiter { get; }
  • string[] DetectDelimiterValues { get; }
  • Encoding Encoding { get; }
  • char Escape { get; }
  • bool ExceptionMessagesContainRawData { get; }
  • GetDelimiter GetDelimiter { get; }
  • bool IgnoreBlankLines { get; }
  • bool IsNewLineSet { get; }
  • bool LineBreakInQuotedFieldIsBadData { get; }
  • double MaxFieldSize { get; }
  • CsvMode Mode { get; }
  • string NewLine { get; }
  • int ProcessFieldBufferSize { get; }
  • char Quote { get; }
  • TrimOptions TrimOptions { get; }
  • char[] WhiteSpaceChars { get; }
  • void Validate()
• public interface IReaderConfiguration : IParserConfiguration
  • bool DetectColumnCountChanges { get; }
  • GetConstructor GetConstructor { get; }
  • GetDynamicPropertyName GetDynamicPropertyName { get; }
  • bool HasHeaderRecord { get; }
  • HeaderValidated HeaderValidated { get; }
  • bool IgnoreReferences { get; }
  • bool IncludePrivateMembers { get; }
  • MemberTypes MemberTypes { get; }
  • MissingFieldFound MissingFieldFound { get; }
  • PrepareHeaderForMatch PrepareHeaderForMatch { get; }
  • ReadingExceptionOccurred ReadingExceptionOccurred { get; }
  • ReferenceHeaderPrefix ReferenceHeaderPrefix { get; }
  • ShouldSkipRecord ShouldSkipRecord { get; }
  • ShouldUseConstructorParameters ShouldUseConstructorParameters { get; }
• public interface IWriterConfiguration
  • bool AllowComments { get; }
  • int BufferSize { get; }
  • char Comment { get; }
  • CultureInfo CultureInfo { get; }
  • string Delimiter { get; }
  • IComparer<string> DynamicPropertySort { get; }
  • char Escape { get; }
  • bool ExceptionMessagesContainRawData { get; }
  • bool HasHeaderRecord { get; }
  • bool IgnoreReferences { get; }
  • bool IncludePrivateMembers { get; }
  • char[] InjectionCharacters { get; }
  • char InjectionEscapeCharacter { get; }
  • InjectionOptions InjectionOptions { get; }
  • bool IsNewLineSet { get; }
  • MemberTypes MemberTypes { get; }
  • CsvMode Mode { get; }
  • string NewLine { get; }
  • char Quote { get; }
  • ReferenceHeaderPrefix ReferenceHeaderPrefix { get; }
  • ShouldQuote ShouldQuote { get; }
  • TrimOptions TrimOptions { get; }
  • bool UseNewObjectForNullReferenceMembers { get; }
  • void Validate()
• public abstract class MemberMap
  • public virtual MemberMapData Data { get; protected set; }
  • public virtual MemberMapTypeConverterOption TypeConverterOption { get; protected set; }
  • protected MemberMap()
  • public static MemberMap CreateGeneric(Type classType, MemberInfo member)
  • public virtual MemberMap Constant(object constantValue)
  • public virtual MemberMap Default(object defaultValue, bool useOnConversionFailure = false)
  • public virtual MemberMap Ignore()
  • public virtual MemberMap Ignore(bool ignore)
  • public virtual MemberMap Index(int index, int indexEnd = -1)
  • public virtual MemberMap Name(string[] names)
  • public virtual MemberMap NameIndex(int index)
  • public virtual MemberMap Optional()
  • public virtual MemberMap TypeConverter(ITypeConverter typeConverter)
  • public virtual MemberMap TypeConverter<TConverter>() where TConverter : ITypeConverter
  • public virtual MemberMap Validate(Validate validateExpression)
  • public virtual MemberMap Validate(Validate validateExpression, ValidateMessage validateMessageExpression)
• public class MemberMap<TClass, TMember> : MemberMap
  • public MemberMap(MemberInfo member)
  • public virtual MemberMap<TClass, TMember> Constant(TMember constantValue)
  • public virtual MemberMap<TClass, TMember> Convert(ConvertFromString<TMember> convertFromStringFunction)
  • public virtual MemberMap<TClass, TMember> Convert(ConvertToString<TClass> convertToStringFunction)
  • public virtual MemberMap<TClass, TMember> Default(TMember defaultValue, bool useOnConversionFailure = false)
  • public virtual MemberMap<TClass, TMember> Default(string defaultValue, bool useOnConversionFailure = false)
  • public virtual MemberMap<TClass, TMember> Ignore()
  • public virtual MemberMap<TClass, TMember> Ignore(bool ignore)
  • public virtual MemberMap<TClass, TMember> Index(int index, int indexEnd = -1)
  • public virtual MemberMap<TClass, TMember> Name(string[] names)
  • public virtual MemberMap<TClass, TMember> NameIndex(int index)
  • public virtual MemberMap<TClass, TMember> Optional()
  • public virtual MemberMap<TClass, TMember> TypeConverter(ITypeConverter typeConverter)
  • public virtual MemberMap<TClass, TMember> TypeConverter<TConverter>() where TConverter : ITypeConverter
  • public virtual MemberMap<TClass, TMember> Validate(Validate validateExpression)
  • public virtual MemberMap<TClass, TMember> Validate(Validate validateExpression, ValidateMessage validateMessageExpression)
• public class MemberMapCollection : IList<MemberMap>, ICollection<MemberMap>, IEnumerable<MemberMap>, IEnumerable
  • public virtual int Count { get; }
  • public virtual bool IsReadOnly { get; }
  • public virtual MemberMap this[int index] { get; set; }
  • public MemberMapCollection()
  • public MemberMapCollection(IComparer<MemberMap> comparer)
  • public virtual void Add(MemberMap item)
  • public virtual void AddMembers(ClassMap mapping)
  • public virtual void AddRange(ICollection<MemberMap> collection)
  • public virtual void Clear()
  • public virtual bool Contains(MemberMap item)
  • public virtual void CopyTo(MemberMap[] array, int arrayIndex)
  • public virtual MemberMap Find<T>(Expression<Func<T, object>> expression)
  • public virtual MemberMap Find(MemberInfo member)
  • public virtual IEnumerator<MemberMap> GetEnumerator()
  • public virtual int IndexOf(MemberMap item)
  • public virtual void Insert(int index, MemberMap item)
  • public virtual bool Remove(MemberMap item)
  • public virtual void RemoveAt(int index)
• public class MemberMapData
  • public virtual object Constant { get; set; }
  • public virtual object Default { get; set; }
  • public virtual bool Ignore { get; set; }
  • public virtual int Index { get; set; }
  • public virtual int IndexEnd { get; set; }
  • public virtual bool IsConstantSet { get; set; }
  • public virtual bool IsDefaultSet { get; set; }
  • public virtual bool IsIndexSet { get; set; }
  • public virtual bool IsNameSet { get; set; }
  • public virtual bool IsOptional { get; set; }
  • public virtual MemberInfo Member { get; }
  • public virtual int NameIndex { get; set; }
  • public virtual MemberNameCollection Names { get; }
  • public virtual Expression ReadingConvertExpression { get; set; }
  • public virtual Type Type { get; }
  • public virtual ITypeConverter TypeConverter { get; set; }
  • public virtual TypeConverterOptions TypeConverterOptions { get; set; }
  • public virtual bool UseDefaultOnConversionFailure { get; set; }
  • public virtual Expression ValidateExpression { get; set; }
  • public virtual Expression ValidateMessageExpression { get; set; }
  • public virtual Expression WritingConvertExpression { get; set; }
  • public MemberMapData(MemberInfo member)
• public class MemberMapTypeConverterOption
  • public MemberMapTypeConverterOption(MemberMap memberMap)
  • public virtual MemberMap BooleanValues(bool isTrue, bool clearValues = true, string[] booleanValues)
  • public virtual MemberMap CultureInfo(CultureInfo cultureInfo)
  • public virtual MemberMap DateTimeStyles(DateTimeStyles dateTimeStyle)
  • public virtual MemberMap EnumIgnoreCase(bool ignoreCase = true)
  • public virtual MemberMap Format(string[] formats)
  • public virtual MemberMap NullValues(string[] nullValues)
  • public virtual MemberMap NullValues(bool clearValues, string[] nullValues)
  • public virtual MemberMap NumberStyles(NumberStyles numberStyle)
  • public virtual MemberMap TimespanStyles(TimeSpanStyles timeSpanStyles)
  • public virtual MemberMap UriKind(UriKind uriKind)
• public class MemberNameCollection : IEnumerable<string>, IEnumerable
  • public int Count { get; }
  • public string this[int index] { get; set; }
  • public List<string> Names { get; }
  • public string Prefix { get; set; }
  • public MemberNameCollection()
  • public void Add(string name)
  • public void AddRange(IEnumerable<string> names)
  • public void Clear()
  • public IEnumerator<string> GetEnumerator()
• public class MemberReferenceMap
  • public MemberReferenceMapData Data { get; }
  • public MemberReferenceMap(MemberInfo member, ClassMap mapping)
  • public MemberReferenceMap Prefix(string prefix = null, bool inherit = false)
• public class MemberReferenceMapCollection : IList<MemberReferenceMap>, ICollection<MemberReferenceMap>, IEnumerable<MemberReferenceMap>, IEnumerable
  • public virtual int Count { get; }
  • public virtual bool IsReadOnly { get; }
  • public virtual MemberReferenceMap this[int index] { get; set; }
  • public MemberReferenceMapCollection()
  • public virtual void Add(MemberReferenceMap item)
  • public virtual void Clear()
  • public virtual bool Contains(MemberReferenceMap item)
  • public virtual void CopyTo(MemberReferenceMap[] array, int arrayIndex)
  • public virtual MemberReferenceMap Find<T>(Expression<Func<T, object>> expression)
  • public virtual MemberReferenceMap Find(MemberInfo member)
  • public virtual IEnumerator<MemberReferenceMap> GetEnumerator()
  • public virtual int IndexOf(MemberReferenceMap item)
  • public virtual void Insert(int index, MemberReferenceMap item)
  • public virtual bool Remove(MemberReferenceMap item)
  • public virtual void RemoveAt(int index)
• public class MemberReferenceMapData
  • public virtual bool Inherit { get; set; }
  • public ClassMap Mapping { get; }
  • public virtual MemberInfo Member { get; }
  • public virtual string Prefix { get; set; }
  • public MemberReferenceMapData(MemberInfo member, ClassMap mapping)
• public class ParameterMap
  • public virtual ClassMap ConstructorTypeMap { get; set; }
  • public virtual ParameterMapData Data { get; protected set; }
  • public virtual ParameterReferenceMap ReferenceMap { get; set; }
  • public virtual ParameterMapTypeConverterOption TypeConverterOption { get; protected set; }
  • public ParameterMap(ParameterInfo parameter)
  • public virtual ParameterMap Constant(object constantValue)
  • public virtual ParameterMap Default(object defaultValue)
  • public virtual ParameterMap Ignore()
  • public virtual ParameterMap Ignore(bool ignore)
  • public virtual ParameterMap Index(int index)
  • public virtual ParameterMap Name(string[] names)
  • public virtual ParameterMap NameIndex(int index)
  • public virtual ParameterMap Optional()
  • public virtual ParameterMap TypeConverter(ITypeConverter typeConverter)
  • public virtual ParameterMap TypeConverter<TConverter>() where TConverter : ITypeConverter
• public class ParameterMapData
  • public virtual object Constant { get; set; }
  • public virtual object Default { get; set; }
  • public virtual bool Ignore { get; set; }
  • public virtual int Index { get; set; }
  • public virtual bool IsConstantSet { get; set; }
  • public virtual bool IsDefaultSet { get; set; }
  • public virtual bool IsIndexSet { get; set; }
  • public virtual bool IsNameSet { get; set; }
  • public virtual bool IsOptional { get; set; }
  • public virtual int NameIndex { get; set; }
  • public virtual MemberNameCollection Names { get; }
  • public virtual ParameterInfo Parameter { get; }
  • public virtual ITypeConverter TypeConverter { get; set; }
  • public virtual TypeConverterOptions TypeConverterOptions { get; set; }
  • public ParameterMapData(ParameterInfo parameter)
• public class ParameterMapTypeConverterOption
  • public ParameterMapTypeConverterOption(ParameterMap parameterMap)
  • public virtual ParameterMap BooleanValues(bool isTrue, bool clearValues = true, string[] booleanValues)
  • public virtual ParameterMap CultureInfo(CultureInfo cultureInfo)
  • public virtual ParameterMap DateTimeStyles(DateTimeStyles dateTimeStyle)
  • public virtual ParameterMap Format(string[] formats)
  • public virtual ParameterMap NullValues(string[] nullValues)
  • public virtual ParameterMap NullValues(bool clearValues, string[] nullValues)
  • public virtual ParameterMap NumberStyles(NumberStyles numberStyle)
  • public virtual ParameterMap TimespanStyles(TimeSpanStyles timeSpanStyles)
  • public virtual ParameterMap UriKind(UriKind uriKind)
• public class ParameterReferenceMap
  • public ParameterReferenceMapData Data { get; }
  • public ParameterReferenceMap(ParameterInfo parameter, ClassMap mapping)
  • public ParameterReferenceMap Prefix(string prefix = null, bool inherit = false)
• public class ParameterReferenceMapData
  • public virtual bool Inherit { get; set; }
  • public ClassMap Mapping { get; }
  • public virtual ParameterInfo Parameter { get; }
  • public virtual string Prefix { get; set; }
  • public ParameterReferenceMapData(ParameterInfo parameter, ClassMap mapping)
• public enum TrimOptions
  • InsideQuotes = 2
  • None = 0
  • Trim = 1

CsvHelper.Configuration.Attributes

• public class AllowCommentsAttribute : Attribute, IClassMapper
  • public bool AllowComments { get; }
  • public AllowCommentsAttribute(bool allowComments = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class BooleanFalseValuesAttribute : Attribute, IMemberMapper, IParameterMapper
  • public string[] FalseValues { get; }
  • public BooleanFalseValuesAttribute(string falseValue)
  • public BooleanFalseValuesAttribute(string[] falseValues)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class BooleanTrueValuesAttribute : Attribute, IMemberMapper, IParameterMapper
  • public string[] TrueValues { get; }
  • public BooleanTrueValuesAttribute(string trueValue)
  • public BooleanTrueValuesAttribute(string[] trueValues)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class BufferSizeAttribute : Attribute, IClassMapper
  • public int BufferSize { get; }
  • public BufferSizeAttribute(int bufferSize)
  • public void ApplyTo(CsvConfiguration configuration)
• public class CacheFieldsAttribute : Attribute, IClassMapper
  • public bool CacheFields { get; }
  • public CacheFieldsAttribute(bool cacheFields = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class CommentAttribute : Attribute, IClassMapper
  • public char Comment { get; }
  • public CommentAttribute(char comment)
  • public void ApplyTo(CsvConfiguration configuration)
• public class ConstantAttribute : Attribute, IMemberMapper, IParameterMapper
  • public object Constant { get; }
  • public ConstantAttribute(object constant)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class CountBytesAttribute : Attribute, IClassMapper
  • public bool CountBytes { get; }
  • public CountBytesAttribute(bool countBytes = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class CultureInfoAttribute : Attribute, IClassMapper, IMemberMapper, IParameterMapper
  • public CultureInfo CultureInfo { get; }
  • public CultureInfoAttribute(string name)
  • public void ApplyTo(CsvConfiguration configuration)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class DateTimeStylesAttribute : Attribute, IMemberMapper, IParameterMapper
  • public DateTimeStyles DateTimeStyles { get; }
  • public DateTimeStylesAttribute(DateTimeStyles dateTimeStyles)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class DefaultAttribute : Attribute, IMemberMapper, IParameterMapper
  • public object Default { get; }
  • public DefaultAttribute(object defaultValue)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class DelimiterAttribute : Attribute, IClassMapper
  • public string Delimiter { get; }
  • public DelimiterAttribute(string delimiter)
  • public void ApplyTo(CsvConfiguration configuration)
• public class DetectColumnCountChangesAttribute : Attribute, IClassMapper
  • public bool DetectColumnCountChanges { get; }
  • public DetectColumnCountChangesAttribute(bool detectColumnCountChanges = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class DetectDelimiterAttribute : Attribute, IClassMapper
  • public bool DetectDelimiter { get; }
  • public DetectDelimiterAttribute(bool detectDelimiter = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class DetectDelimiterValuesAttribute : Attribute, IClassMapper
  • public string[] DetectDelimiterValues { get; }
  • public DetectDelimiterValuesAttribute(string detectDelimiterValues)
  • public void ApplyTo(CsvConfiguration configuration)
• public class EncodingAttribute : Attribute, IClassMapper
  • public Encoding Encoding { get; }
  • public EncodingAttribute(string name)
  • public EncodingAttribute(int codepage)
  • public void ApplyTo(CsvConfiguration configuration)
• public class EnumIgnoreCaseAttribute : Attribute, IMemberMapper, IMemberReferenceMapper, IParameterMapper
  • public EnumIgnoreCaseAttribute()
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(MemberReferenceMap referenceMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class EscapeAttribute : Attribute, IClassMapper
  • public char Escape { get; }
  • public EscapeAttribute(char escape)
  • public void ApplyTo(CsvConfiguration configuration)
• public class ExceptionMessagesContainRawDataAttribute : Attribute, IClassMapper
  • public bool ExceptionMessagesContainRawData { get; }
  • public ExceptionMessagesContainRawDataAttribute(bool exceptionMessagesContainRawData = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class FormatAttribute : Attribute, IMemberMapper, IParameterMapper
  • public string[] Formats { get; }
  • public FormatAttribute(string format)
  • public FormatAttribute(string[] formats)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class HasHeaderRecordAttribute : Attribute, IClassMapper
  • public bool HasHeaderRecord { get; }
  • public HasHeaderRecordAttribute(bool hasHeaderRecord = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class HeaderPrefixAttribute : Attribute, IMemberReferenceMapper, IParameterReferenceMapper
  • public bool Inherit { get; }
  • public string Prefix { get; }
  • public HeaderPrefixAttribute()
  • public HeaderPrefixAttribute(string prefix)
  • public HeaderPrefixAttribute(bool inherit)
  • public HeaderPrefixAttribute(string prefix, bool inherit)
  • public void ApplyTo(MemberReferenceMap referenceMap)
  • public void ApplyTo(ParameterReferenceMap referenceMap)
• public interface IClassMapper
  • void ApplyTo(CsvConfiguration configuration)
• public class IgnoreAttribute : Attribute, IMemberMapper, IMemberReferenceMapper, IParameterMapper
  • public IgnoreAttribute()
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(MemberReferenceMap referenceMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class IgnoreBaseAttribute : Attribute
  • public IgnoreBaseAttribute()
• public class IgnoreBlankLinesAttribute : Attribute, IClassMapper
  • public bool IgnoreBlankLines { get; }
  • public IgnoreBlankLinesAttribute(bool ignoreBlankLines = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class IgnoreReferencesAttribute : Attribute, IClassMapper
  • public bool IgnoreReferences { get; }
  • public IgnoreReferencesAttribute(bool ignoreReferences = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public interface IMemberMapper
  • void ApplyTo(MemberMap memberMap)
• public interface IMemberReferenceMapper
  • void ApplyTo(MemberReferenceMap referenceMap)
• public class IncludePrivateMembersAttribute : Attribute, IClassMapper
  • public bool IncludePrivateMembers { get; }
  • public IncludePrivateMembersAttribute(bool includePrivateMembers = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class IndexAttribute : Attribute, IMemberMapper, IParameterMapper
  • public int Index { get; }
  • public int IndexEnd { get; }
  • public IndexAttribute(int index, int indexEnd = -1)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class InjectionCharactersAttribute : Attribute, IClassMapper
  • public char[] InjectionCharacters { get; }
  • public InjectionCharactersAttribute(string injectionCharacters)
  • public void ApplyTo(CsvConfiguration configuration)
• public class InjectionEscapeCharacterAttribute : Attribute, IClassMapper
  • public char InjectionEscapeCharacter { get; }
  • public InjectionEscapeCharacterAttribute(char injectionEscapeCharacter)
  • public void ApplyTo(CsvConfiguration configuration)
• public class InjectionOptionsAttribute : Attribute, IClassMapper
  • public InjectionOptions InjectionOptions { get; }
  • public InjectionOptionsAttribute(InjectionOptions injectionOptions)
  • public void ApplyTo(CsvConfiguration configuration)
• public interface IParameterMapper
  • void ApplyTo(ParameterMap parameterMap)
• public interface IParameterReferenceMapper
  • void ApplyTo(ParameterReferenceMap referenceMap)
• public class LineBreakInQuotedFieldIsBadDataAttribute : Attribute, IClassMapper
  • public bool LineBreakInQuotedFieldIsBadData { get; }
  • public LineBreakInQuotedFieldIsBadDataAttribute(bool lineBreakInQuotedFieldIsBadData = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class MaxFieldSizeAttribute : Attribute, IClassMapper
  • public double MaxFieldSize { get; }
  • public MaxFieldSizeAttribute(double maxFieldSize)
  • public void ApplyTo(CsvConfiguration configuration)
• public class MemberTypesAttribute : Attribute, IClassMapper
  • public MemberTypes MemberTypes { get; }
  • public MemberTypesAttribute(MemberTypes memberTypes)
  • public void ApplyTo(CsvConfiguration configuration)
• public class ModeAttribute : Attribute, IClassMapper
  • public CsvMode Mode { get; }
  • public ModeAttribute(CsvMode mode)
  • public void ApplyTo(CsvConfiguration configuration)
• public class NameAttribute : Attribute, IMemberMapper, IParameterMapper
  • public string[] Names { get; }
  • public NameAttribute(string name)
  • public NameAttribute(string[] names)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class NameIndexAttribute : Attribute, IMemberMapper, IParameterMapper
  • public int NameIndex { get; }
  • public NameIndexAttribute(int nameIndex)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class NewLineAttribute : Attribute, IClassMapper
  • public string NewLine { get; }
  • public NewLineAttribute(string newLine)
  • public void ApplyTo(CsvConfiguration configuration)
• public class NullValuesAttribute : Attribute, IMemberMapper, IParameterMapper
  • public string[] NullValues { get; }
  • public NullValuesAttribute(string nullValue)
  • public NullValuesAttribute(string[] nullValues)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class NumberStylesAttribute : Attribute, IMemberMapper, IParameterMapper
  • public NumberStyles NumberStyles { get; }
  • public NumberStylesAttribute(NumberStyles numberStyles)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class OptionalAttribute : Attribute, IMemberMapper, IParameterMapper
  • public OptionalAttribute()
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class ProcessFieldBufferSizeAttribute : Attribute, IClassMapper
  • public int ProcessFieldBufferSize { get; }
  • public ProcessFieldBufferSizeAttribute(int processFieldBufferSize)
  • public void ApplyTo(CsvConfiguration configuration)
• public class QuoteAttribute : Attribute, IClassMapper
  • public char Quote { get; }
  • public QuoteAttribute(char quote)
  • public void ApplyTo(CsvConfiguration configuration)
• public class TrimOptionsAttribute : Attribute, IClassMapper
  • public TrimOptions TrimOptions { get; }
  • public TrimOptionsAttribute(TrimOptions trimOptions)
  • public void ApplyTo(CsvConfiguration configuration)
• public class TypeConverterAttribute : Attribute, IMemberMapper, IParameterMapper
  • public ITypeConverter TypeConverter { get; }
  • public TypeConverterAttribute(Type typeConverterType)
  • public TypeConverterAttribute(Type typeConverterType, object[] constructorArgs)
  • public void ApplyTo(MemberMap memberMap)
  • public void ApplyTo(ParameterMap parameterMap)
• public class UseNewObjectForNullReferenceMembersAttribute : Attribute, IClassMapper
  • public bool UseNewObjectForNullReferenceMembers { get; }
  • public UseNewObjectForNullReferenceMembersAttribute(bool useNewObjectForNullReferenceMembers = true)
  • public void ApplyTo(CsvConfiguration configuration)
• public class WhiteSpaceCharsAttribute : Attribute, IClassMapper
  • public char[] WhiteSpaceChars { get; }
  • public WhiteSpaceCharsAttribute(string whiteSpaceChars)
  • public void ApplyTo(CsvConfiguration configuration)

CsvHelper.Delegates

• public sealed delegate GetDelimiter : MulticastDelegate
  • public GetDelimiter(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(GetDelimiterArgs args, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(GetDelimiterArgs args)
• public struct GetDelimiterArgs
  • public readonly IParserConfiguration Configuration
  • public readonly string Text
  • public GetDelimiterArgs(string text, IParserConfiguration configuration)

CsvHelper.Expressions

• public class DynamicRecordCreator : RecordCreator
  • public DynamicRecordCreator(CsvReader reader)
  • protected virtual object CreateDynamicRecord()
• public class DynamicRecordWriter : RecordWriter
  • public DynamicRecordWriter(CsvWriter writer)
• public class ExpandoObjectRecordWriter : RecordWriter
  • public ExpandoObjectRecordWriter(CsvWriter writer)
• public class ExpressionManager
  • public ExpressionManager(CsvReader reader)
  • public ExpressionManager(CsvWriter writer)
  • public virtual void CreateConstructorArgumentExpressionsForMapping(ClassMap map, List<Expression> argumentExpressions)
  • public virtual Expression CreateDefaultExpression(MemberMap memberMap, Expression fieldExpression)
  • public virtual Expression CreateDefaultExpression(ParameterMap parameterMap, Expression fieldExpression)
  • public virtual Expression CreateGetFieldExpression(MemberMap memberMap)
  • public virtual Expression CreateGetMemberExpression(Expression recordExpression, ClassMap mapping, MemberMap memberMap)
  • public virtual BlockExpression CreateInstanceAndAssignMembers(Type recordType, List<MemberAssignment> assignments)
  • public virtual void CreateMemberAssignmentsForMapping(ClassMap mapping, List<MemberAssignment> assignments)
  • public virtual Expression CreateTypeConverterExpression(MemberMap memberMap, Expression fieldExpression)
  • public virtual Expression CreateTypeConverterExpression(ParameterMap parameterMap, Expression fieldExpression)
• public class ObjectRecordCreator : RecordCreator
  • public ObjectRecordCreator(CsvReader reader)
• public class ObjectRecordWriter : RecordWriter
  • public ObjectRecordWriter(CsvWriter writer)
• public class PrimitiveRecordCreator : RecordCreator
  • public PrimitiveRecordCreator(CsvReader reader)
• public class PrimitiveRecordWriter : RecordWriter
  • public PrimitiveRecordWriter(CsvWriter writer)
• public abstract class RecordCreator
  • protected ExpressionManager ExpressionManager { get; }
  • protected CsvReader Reader { get; }
  • public RecordCreator(CsvReader reader)
  • protected abstract Delegate CreateCreateRecordDelegate(Type recordType)
  • public virtual Func<T> GetCreateRecordDelegate<T>(Type recordType)
• public class RecordCreatorFactory
  • public RecordCreatorFactory(CsvReader reader)
  • public virtual RecordCreator MakeRecordCreator(Type recordType)
• public class RecordHydrator
  • public RecordHydrator(CsvReader reader)
  • protected virtual Action<T> CreateHydrateRecordAction<T>()
  • protected virtual Action<T> GetHydrateRecordAction<T>()
  • public void Hydrate<T>(T record)
• public class RecordManager
  • public RecordManager(CsvReader reader)
  • public RecordManager(CsvWriter writer)
  • public Func<T> GetReadDelegate<T>(Type recordType)
  • public Action<T> GetWriteDelegate<T>(RecordTypeInfo typeInfo)
  • public void Hydrate<T>(T record)
• public abstract class RecordWriter
  • protected ExpressionManager ExpressionManager { get; }
  • protected CsvWriter Writer { get; }
  • public RecordWriter(CsvWriter writer)
  • protected virtual Action<T> CombineDelegates<T>(IEnumerable<Action<T>> delegates)
  • protected virtual Action<T> CreateWriteDelegate<T>(T record)
  • protected abstract Action<T> CreateWriteDelegate<T>(Type recordType)
  • public virtual Action<T> GetWriteDelegate<T>(RecordTypeInfo typeInfo)
• public class RecordWriterFactory
  • public RecordWriterFactory(CsvWriter writer)
  • public virtual RecordWriter MakeRecordWriter(Type recordType)

CsvHelper.TypeConversion

• public class BigIntegerConverter : DefaultTypeConverter
  • public BigIntegerConverter()
• public class ByteArrayConverter : DefaultTypeConverter
  • public ByteArrayConverter(ByteArrayConverterOptions options = 9)
• public enum ByteArrayConverterOptions
  • Base64 = 2
  • Hexadecimal = 1
  • HexDashes = 4
  • HexInclude0x = 8
  • None = 0
• public class CollectionConverterFactory : ITypeConverterFactory
  • public CollectionConverterFactory()
  • public bool CanCreate(Type type)
  • public bool Create(Type type, TypeConverterCache cache, out ITypeConverter typeConverter)
• public class CsvTypeConverterException : CsvHelperException
• public class DefaultTypeConverter : ITypeConverter
  • public virtual object ConvertFromString(string text, ICsvReaderRow row, CsvPropertyMapData propertyMapData)
  • public virtual string ConvertToString(object value, ICsvWriterRow row, CsvPropertyMapData propertyMapData)
  • public virtual object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
  • public virtual string ConvertToString(object value, IWriterRow row, MemberMapData memberMapData)
• public class EnumConverterFactory : ITypeConverterFactory
  • public EnumConverterFactory()
  • public bool CanCreate(Type type)
  • public bool Create(Type type, TypeConverterCache cache, out ITypeConverter typeConverter)
• public interface ITypeConverter
  • object ConvertFromString(string text, ICsvReaderRow row, CsvPropertyMapData propertyMapData)
  • string ConvertToString(object value, ICsvWriterRow row, CsvPropertyMapData propertyMapData)
  • object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
  • string ConvertToString(object value, IWriterRow row, MemberMapData memberMapData)
• public interface ITypeConverterFactory
  • bool CanCreate(Type type)
  • bool Create(Type type, TypeConverterCache cache, out ITypeConverter typeConverter)
• public class NotSupportedTypeConverter<T> : TypeConverter<T>
  • public NotSupportedTypeConverter()
• public class NullableConverter : DefaultTypeConverter
  • public NullableConverter(Type type)
  • public NullableConverter(Type type, TypeConverterCache typeConverterFactory)
• public class NullableConverterFactory : ITypeConverterFactory
  • public NullableConverterFactory()
  • public bool CanCreate(Type type)
  • public bool Create(Type type, TypeConverterCache cache, out ITypeConverter typeConverter)
• public static class TypeConverterFactory
• public abstract class TypeConverter<T> : ITypeConverter
  • protected TypeConverter()
  • public abstract T ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
  • public abstract string ConvertToString(T value, IWriterRow row, MemberMapData memberMapData)
• public class TypeConverterCache
  • public TypeConverterCache()
  • public void AddConverter(Type type, ITypeConverter typeConverter)
  • public void AddConverter<T>(TypeConverter<T> typeConverter)
  • public void AddConverter<T>(ITypeConverter typeConverter)
  • public void AddConverter(ITypeConverter typeConverter)
  • public void AddConverterFactory(ITypeConverterFactory typeConverterFactory)
  • public bool Contains(Type type)
  • public ITypeConverter GetConverter(Type type)
  • public ITypeConverter GetConverter(MemberInfo member)
  • public ITypeConverter GetConverter<T>()
  • public void RemoveConverter(Type type)
  • public void RemoveConverter<T>()
  • public void RemoveConverterFactory(ITypeConverterFactory typeConverterFactory)
• public class TypeConverterException : CsvHelperException
  • public MemberMapData MemberMapData { get; }
  • public string Text { get; }
  • public ITypeConverter TypeConverter { get; }
  • public object Value { get; }
  • public TypeConverterException(ITypeConverter typeConverter, MemberMapData memberMapData, string text, CsvContext context)
  • public TypeConverterException(ITypeConverter typeConverter, MemberMapData memberMapData, object value, CsvContext context)
  • public TypeConverterException(ITypeConverter typeConverter, MemberMapData memberMapData, string text, CsvContext context, string message)
  • public TypeConverterException(ITypeConverter typeConverter, MemberMapData memberMapData, object value, CsvContext context, string message)
  • public TypeConverterException(ITypeConverter typeConverter, MemberMapData memberMapData, string text, CsvContext context, string message, Exception innerException)
  • public TypeConverterException(ITypeConverter typeConverter, MemberMapData memberMapData, object value, CsvContext context, string message, Exception innerException)
• public class TypeConverterOptions
  • public string Format { get; set; }
  • public bool? EnumIgnoreCase { get; set; }
  • public string[] Formats { get; set; }
  • public NumberStyles? NumberStyle { get; set; }
  • public NumberStyles? NumberStyles { get; set; }
  • public UriKind? UriKind { get; set; }
• public class TypeConverterOptionsFactory
• public class TypeConverterOptionsCache
  • public TypeConverterOptionsCache()
  • public void AddOptions(Type type, TypeConverterOptions options)
  • public void AddOptions<T>(TypeConverterOptions options)
  • public void AddOptions(TypeConverterOptions options)
  • public TypeConverterOptions GetOptions(Type type)
  • public TypeConverterOptions GetOptions<T>()
  • public void RemoveOptions(Type type)
  • public void RemoveOptions<T>()
• public class UriConverter : DefaultTypeConverter
  • public UriConverter()