Namespace Cesil
Classes
AheadOfTimeTypeDescriber
An ITypeDescriber that use (de)serializer that was generated ahead of time by using Cesil.SourceGenerator.
CesilUtils
A collection of convenience methods for reading and writing using streams or files.
These methods are less flexible than directly using Configuration and are not as efficient as using IReader(T), IAsyncReader(T), IWriter(T) and IAsyncWriter(T), but they involve much less code.
Prefer them when the trade off for simplicity at the expense speed and flexibility makes sense.
ColumnIdentifier
Identifies a particular column, either by index or index and name.
A ColumnIdentifier is only valid for as long as the values used to construct it. Accordingly, you should be careful when storing ColumnIdentifiers that you did not create yourself as they may have been created with ReadOnlyMemory(char)s whose lifetime you do not control.
Configuration
Used to combine a type and an Options into an IBoundConfiguration(T), which can create readers and writers.
ConstructorInstanceProviderAttribute
Automatically attached to generated methods depending on runtime behavior.
You should not use this directly.
DefaultTypeDescriber
The default implementation of ITypeDescriber used to determine how to (de)serialize types and how to convert dynamic cells and rows.
It will serialize all public properties, any fields with a [DataMember], and will respect ShouldSerialize() methods.
It will deserialize all public properties, any fields with a [DataMember], and will call Reset() methods. Expects a public parameterless constructor for any deserialized types.
It will also deserialize records using their primary constructor. Names, Parsers, Resets, and Order may be customized with records but not Setters and MemberRequireds.
It will convert dynamic cells to most built-in types, and map dynamoc rows to POCOs, ValueTuples, Tuples, and IEnumerables.
This type is unsealed to allow for easy extension of it's behavior.
DeserializableMember
Represents a member of a type to use when deserializing.
DeserializerInstanceProviderAttribute
When using Cesil's Source Generator (see Nuget.org for Cesil.SourceGenerator) marks a constructor as the InstanceProvider for the containing type.
To use a method instead of a constructor, use the InstanceProviderType and InstanceProviderMethodName properties on [GenerateDeserializableAttribute].
DeserializerMemberAttribute
Attach this attribute to a method, field, property, or parameter to expose it as deserializable and configure it's "Parser", "MemberRequired", "Reset", and "Order" behaviors.
If attached to a property, the propery must have a setter and take no parameters.
If attached to a method it must return void.
If attached to a parameter, the parameter must be to a constructor, all parameters to the constructor must also be annotated, and the constructor itself must be annotated with DeserializerInstanceProviderAttribute.
If attached to a static method it may:
- take 1 parameter (the result of the parser) or
- take 2 parameters, the result of the parser and an
in ReadContext
or - take 2 parameters, the row type (which may be passed by ref), and the result of the parser or
- take 3 parameters, the row type (which may be passed by ref), the result of the parser, and
in ReadContext
If attached to an instance method it may:
- be on the row type, and take 1 parameter (the result of the parser) or
- be on the row type, and take 2 parameters, the result of the parser and an
in ReadContext
DoesNotEmitDefaultValueAttribute
Automatically attached to generated methods depending on runtime behavior.
You should not use this directly.
DynamicCellValue
Wrapper around a dynamic cell which is to be written by an I(Async)Writer.
DynamicRowConverter
Describes how to convert a dynamic row value into an instance of a type.
Conversions can implemented as constructors taking a single dynamic/object, constructors taking typed parameters, an empty constructor paired with setter methods, or static methods.
DynamicRowConverterDelegate<TOutput>
Delegate type for DynamicRowConverters.
DynamicRowDisposal
When a dynamic row returned by a IReader or IAsyncReader will be disposed.
EmitDefaultValue
Whether or not the default value for a member will be serialized.
ExtraColumnTreatment
How to handle extra columns when reading a row.
A column is "extra" is if it's index is beyond those found in the header (or first row, if no header is present) of the CSV being read.
Formatter
Represents code used to format a value into a IBufferWriter(char).
Wraps either a static method or a delegate.
FormatterDelegate<TValue>
Delegate type for formatters.
GenerateDeserializerAttribute
When using Cesil's Source Generator (see Nuget.org for Cesil.SourceGenerator) marks a class or struct as needing a deserializer generated at compile time.
InstanceProviderType and InstanceProviderMethodName are used to indicate how to obtain an instance of the annotated type from a method. If not set, the type's parameterless constructor is used by default. To use a constructor other than the parameterless, use the [DeserializerInstanceProvider].
When using the AheadOfTimeTypeDescriber, the created I(Async)Readers for this type will do no runtime code generation.
You can customize the behavior of the generated deserializer with [DataMemberAttribute], and [DeserializaerMemberAttribute] attributes.
Default behavior (with no additional attributes) closely follows DefaultTypeDescriver.
GeneratedSourceVersionAttribute
Automatically attached to generated types to track compatibility.
You should not use this directly.
GeneratedSourceVersionAttribute.GeneratedTypeKind
Used by GeneratedSourceVersionAttribute.
You should not use this directly.
GenerateSerializerAttribute
When using Cesil's Source Generator (see Nuget.org for Cesil.SourceGenerator) marks a class or struct as needing a serializer generated at compile time.
When using the AheadOfTimeTypeDescriber, the created I(Async)Writers for this type will do no runtime code generation.
You can customize the behavior of the generated serialize with [DataMemberAttribute], and [SerializerMemberAttribute] attributes.
Default behavior (with no additional attributes) closely follows DefaultTypeDescriver.
Getter
Represents code used to get a value from a type.
Wraps a static method, an instance method, a field, or a delegate.
GetterDelegate<TRow, TValue>
Delegate type for getters.
ImpossibleException
An exception that should never happen.
If it does, that indicates a bug in Cesil. Kindly report it on https://github.com/kevin-montrose/Cesil/issues/new.
InstanceProvider
Represents a way to obtain an instance of a type.
This can be backed by a zero-parameter constructor, a constructor taking typed parameters, a static method, or a delegate.
InstanceProviderDelegate<TInstance>
Delegate used to create InstanceProviders.
IsRequiredAttribute
Automatically attached to generated methods depending on runtime behavior.
You should not use this directly.
ManualTypeDescriber
An ITypeDescriber that takes lets you register explicit members to return when one of the EnumerateXXX() methods are called.
ManualTypeDescriberBuilder
Builder for creating a ManualTypeDescriber.
Creates ITypeDescribers explicitly registered members to return when one of the EnumerateXXX() methods are called.
ManualTypeDescriberFallbackBehavior
How to behave if a ManualTypeDescriber needs to describe a type that isn't explicitly configured.
MemberRequired
Whether or not a member is required during deserialization.
MemoryPoolProviders
Holds references to pre-allocated IMemoryPoolProviders.
Options
A set of options for reading and writing CSV files.
Combine with Configuration to bind to a particular type in a IBoundConfiguration(T) which can create readers and writers.
OptionsBuilder
Builder for Options.
Options itself is immutable, but OptionsBuilder is chainable and mutable.
Parser
Represents code used to parse values into concrete types.
Wraps a static method, a constructor taking a single ReadOnlySpan(char), a constuctor taking a ReadOnlySpan(char) and a ReadContext, or a delegate.
ParserDelegate<TOutput>
Delegate type for parsers.
ReadContext
Context object provided during read operations.
ReadContextMode
Indicates what a reader is doing when a ReadContext is created.
ReadHeader
Whether to expect a header row when deserializing.
This can be determined automatically with Detect.
ReadResult<TRow>
Represents the result of an attempted read operation.
ReadRowEnding
Which character sequence will end a row when reading rows.
This can be determined automatically with Detect.
ReadWithCommentResult<TRow>
Represents the result of an attempted read operation which supports comments.
ReadWithCommentResultType
Represents the type of a ReadWithCommentResult, either no value (end of records), having a value (of type T), or having a comment (always a string).
Reset
Represents code called before a setter is called or a field is set.
Wraps a static method, an instance method, or a delegate.
ResetByRefDelegate<TRow>
Delegate type for resets, where row is passed by ref.
ResetDelegate<TRow>
Delegate type for resets.
SerializableMember
Represents a member of a type to use when serializing.
SerializerMemberAttribute
Attach this attribute to a method, field, or property to expose it as serializable and configure it's "ShouldSerialize", "Formatter", "Order", and "EmitDefaultValue" behaviors.
If attached to a property, the propery must have a getter and take no parameters.
If attached to a method, the method must return a non-null value and either:
- be an instance method and
- take no parameters
- take one parameter, an in WriteContext
- be static and
- take no parameters
- take one parameter either
- an in WriteContext or
- a type to which the declaring type of this member can be assigned
- take two parameters
- a type to which the declaring type of this member can be assigned
- in WriteContext
Setter
Represents code used to set parsed values onto types.
Wraps a static method, an instance method, a delegate, a field, or a constructor parameter.
SetterBackedByConstructorParameterAttribute
Automatically attached to generated methods depending on runtime behavior.
You should not use this directly.
SetterBackedByInitOnlyPropertyAttribute
Automatically attached to generated methods depending on runtime behavior.
You should not use this directly.
SetterByRefDelegate<TRow, TValue>
Delegate type for setters, where instance is passed by ref.
SetterDelegate<TRow, TValue>
Delegate type for setters.
ShouldSerialize
Represents code used to determine whether or not to write a value.
Wraps a static method, an instance method, or a delegate.
ShouldSerializeDelegate<TRow>
Delegate type for 'should serialize'.
StaticGetterDelegate<TValue>
Delegate type for getters that doesn't take a row.
StaticResetDelegate
Delegate type for resets that don't take an instance of the row.
StaticSetterDelegate<TValue>
Delegate type for setters that don't take an instance.
StaticShouldSerializeDelegate
Delegate type for 'should serialize' that don't take a row.
SurrogateTypeDescriber
A ITypeDesciber that enumerates members on a surrogate type and maps them to another type.
Used when you don't control the type you need to (de)serialize - you markup the surrogate type and then the uncontrolled type is (de)serialized as if it were the surrogate type.
SurrogateTypeDescriberBuilder
Builder for creating a SurrogateTypeDescriber.
Creates ITypeDescribers that inspects one type to determine who to (de)serialize another type.
Used when you don't control the type you need to (de)serialize - you markup the surrogate type and then the uncontrolled type is (de)serialized as if it were the surrogate type.
SurrogateTypeDescriberFallbackBehavior
How to behave if a SurrogateTypeDescriber needs to describe a type that isn't explicitly configured.
TypeDescribers
Holds references to pre-allocated TypeDescibers.
WhitespaceTreatments
How to handle whitespace when encountered during parsing.
Allows for automatic removal of leading or trailing whitespace in or outside of values or headers, depending on whether in an escaped sequence.
WriteContext
Context object provided during write operations.
WriteContextMode
Indicates what a writer is doing when a WriteContext is created.
WriteHeader
Whether or not to write a header row when serializing.
WriteRowEnding
Which character sequence will end a row when writing rows.
Unlike with ReadRowEnding, this cannot be inferred.
WriteTrailingRowEnding
Whether or not their should be a trailing row ending after the last row when serializing.
Interfaces
IAsyncReader<TRow>
Interface for an asynchronous reader.
IAsyncWriter<TRow>
Interface for writing rows asynchronously.
IBoundConfiguration<TRow>
Represents and Options and Type pair.
Used to create readers and writers.
IMemoryPoolProvider
Interface used to obtain MemoryPools.
Cesil uses this during creation of IBoundConfigurations to determine where necessary allocations during read/writing will be placed.
IReader<TRow>
Interface for a synchronous reader.
ITypeDescriber
The interface used to discover the members to (de)serialize for a type.
DefaultTypeDescriber, ManualTypeDescriber, and SurrogateTypeDescriber all implement this interface and handle the most common desired configurations.
Note to implementors: All ITypeDescriber methods must be thread safe, as they are invoked as needed during operation with no guarantee about the calling thread(s).
IWriter<TRow>
Interface for synchronously writing rows.