/// <summary> /// Initializes a new instance. /// </summary> /// <param name="reader">The reader.</param> /// <param name="configuration">The configuration.</param> /// <param name="leaveOpen">A value indicating if the TextReader should be left open when disposing.</param> public ReadingContext(TextReader reader, Configuration.Configuration configuration, bool leaveOpen) { //Reader = reader ?? throw new ArgumentNullException( nameof( reader ) ); Reader = CSharp6Extension.GetArgumentOrThrowException <TextReader>(reader, nameof(reader)); // ?? throw new ArgumentNullException( nameof( reader ) ); //this.configuration = configuration ?? throw new ArgumentNullException( nameof( configuration ) ); this.configuration = CSharp6Extension.GetArgumentOrThrowException <Configuration.Configuration>(configuration, nameof(configuration)); //configuration ?? throw new ArgumentNullException( nameof( configuration ) ); LeaveOpen = leaveOpen; Buffer = new char[0]; }
/// <summary> /// Creates a new CSV writer using the given <see cref="ISerializer"/>. /// </summary> /// <param name="serializer">The serializer.</param> public CsvWriter(ISerializer serializer) { //this.serializer = serializer ?? throw new ArgumentNullException( nameof( serializer ) ); this.serializer = CSharp6Extension.GetArgumentOrThrowException <ISerializer>(serializer, nameof(serializer)); //context = serializer.Context as WritingContext ?? throw new InvalidOperationException( $"For {nameof( ISerializer )} to be used in {nameof( CsvWriter )}, {nameof( ISerializer.Context )} must also implement {nameof( WritingContext )}." ); context = serializer.Context as WritingContext; if (context == null) { throw new InvalidOperationException($"For {nameof( ISerializer )} to be used in {nameof( CsvWriter )}, {nameof( ISerializer.Context )} must also implement {nameof( WritingContext )}."); } recordManager = ObjectResolver.Current.Resolve <RecordManager>(this); }
/// <summary> /// Creates a new parser using the given <see cref="FieldReader"/>. /// </summary> /// <param name="fieldReader">The field reader.</param> public CsvParser(IFieldReader fieldReader) { //this.fieldReader = fieldReader ?? throw new ArgumentNullException( nameof( fieldReader ) ); this.fieldReader = CSharp6Extension.GetArgumentOrThrowException <IFieldReader>(fieldReader, nameof(fieldReader)); //context = fieldReader.Context as ReadingContext ?? throw new InvalidOperationException( $"For {nameof( FieldReader )} to be used in {nameof( CsvParser )}, {nameof( FieldReader.Context )} must also implement {nameof( ReadingContext )}." ); context = fieldReader.Context as ReadingContext; if (context == null) { throw new InvalidOperationException($"For {nameof( FieldReader )} to be used in {nameof( CsvParser )}, {nameof( FieldReader.Context )} must also implement {nameof( ReadingContext )}."); } }
/// <summary> /// Writes the field to the CSV file. /// When all fields are written for a record, /// <see cref="IWriter.NextRecord" /> must be called /// to complete writing of the current record. /// </summary> /// <typeparam name="T">The type of the field.</typeparam> /// <param name="field">The field to write.</param> /// <param name="converter">The converter used to convert the field into a string.</param> public virtual void WriteField <T>(T field, ITypeConverter converter) { var type = field == null ? typeof(string) : field.GetType(); context.ReusableMemberMapData.TypeConverter = converter; //if( !context.TypeConverterOptionsCache.TryGetValue( type, out TypeConverterOptions typeConverterOptions ) ) TypeConverterOptions typeConverterOptions = CSharp6Extension.TryGetValue <Type, TypeConverterOptions>(context.TypeConverterOptionsCache, type); if (typeConverterOptions == default(TypeConverterOptions)) { typeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions { CultureInfo = context.WriterConfiguration.CultureInfo }, context.WriterConfiguration.TypeConverterOptionsCache.GetOptions(type)); context.TypeConverterOptionsCache.Add(type, typeConverterOptions); } context.ReusableMemberMapData.TypeConverterOptions = typeConverterOptions; var fieldString = converter.ConvertToString(field, this, context.ReusableMemberMapData); WriteConvertedField(fieldString); }
/// <summary> /// Gets the delegate to write the given record. /// If the delegate doesn't exist, one will be created and cached. /// </summary> /// <typeparam name="T">The record type.</typeparam> /// <param name="record">The record.</param> protected Action <T> GetWriteDelegate <T>(T record) { var type = typeof(T); var typeKeyName = type.AssemblyQualifiedName; if (type == typeof(object)) { type = record.GetType(); typeKeyName += $"|{type.AssemblyQualifiedName}"; } int typeKey = typeKeyName.GetHashCode(); Delegate action = CSharp6Extension.TryGetValue <int, Delegate>(Writer.Context.TypeActions, typeKey); //if( !Writer.Context.TypeActions.TryGetValue( typeKey, out Delegate action ) ) if (action == default(Delegate)) { Writer.Context.TypeActions[typeKey] = action = CreateWriteDelegate(record); } return((Action <T>)action); }
/// <summary> /// Gets the converter for the given <see cref="System.Type"/>. /// </summary> /// <param name="type">The type to get the converter for.</param> /// <returns>The <see cref="ITypeConverter"/> for the given <see cref="System.Type"/>.</returns> public ITypeConverter GetConverter(Type type) { if (type == null) { throw new ArgumentNullException(nameof(type)); } ITypeConverter typeConverter = CSharp6Extension.TryGetValue <Type, ITypeConverter>(typeConverters, type); //if( typeConverters.TryGetValue( type, out ITypeConverter typeConverter ) ) if (typeConverter != default(ITypeConverter)) { return(typeConverter); } if (typeof(Enum).IsAssignableFrom(type)) { AddConverter(type, new EnumConverter(type)); return(GetConverter(type)); } if (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == typeof(Nullable <>)) { AddConverter(type, new NullableConverter(type, this)); return(GetConverter(type)); } if (type.IsArray) { AddConverter(type, new ArrayConverter()); return(GetConverter(type)); } if (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == typeof(Dictionary <,>)) { AddConverter(type, new IDictionaryGenericConverter()); return(GetConverter(type)); } if (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == typeof(IDictionary <,>)) { AddConverter(type, new IDictionaryGenericConverter()); return(GetConverter(type)); } if (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == typeof(List <>)) { AddConverter(type, new CollectionGenericConverter()); return(GetConverter(type)); } if (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == typeof(Collection <>)) { AddConverter(type, new CollectionGenericConverter()); return(GetConverter(type)); } if (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == typeof(IList <>)) { AddConverter(type, new IEnumerableGenericConverter()); return(GetConverter(type)); } if (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == typeof(ICollection <>)) { AddConverter(type, new IEnumerableGenericConverter()); return(GetConverter(type)); } if (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == typeof(IEnumerable <>)) { AddConverter(type, new IEnumerableGenericConverter()); return(GetConverter(type)); } // A specific IEnumerable converter doesn't exist. if (typeof(IEnumerable).IsAssignableFrom(type)) { return(new EnumerableConverter()); } return(new DefaultTypeConverter()); }