public CsvOutputFormatter(ICsvSerializer csvSerializationService)
{
_csvSerializationService = csvSerializationService;
var mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(MediaType);
SupportedMediaTypes.Add(mediaTypeHeaderValue);
SupportedEncodings.Add(Encoding.UTF8);
SupportedEncodings.Add(Encoding.Unicode);
}
/// <summary>
/// Creates a new CSV writer using the given <see cref="ICsvSerializer"/>.
/// </summary>
/// <param name="serializer">The serializer.</param>
public CsvWriter(ICsvSerializer serializer)
{
this.serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
if (!(this.serializer.Context is IWriterContext))
{
throw new InvalidOperationException("For ICsvSerializer to be used in CsvWriter, ICsvSerializer.Context must also implement IWriterContext.");
}
context = serializer.Context;
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <param name="disposing">True if the instance needs to be disposed of.</param>
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing && serializer != null)
{
serializer.Dispose();
}
disposed = true;
serializer = null;
}
/// <summary>
/// Creates a new CSV writer using the given <see cref="T:CsvHelper.ICsvSerializer" />.
/// </summary>
/// <param name="serializer">The serializer.</param>
public CsvWriter(ICsvSerializer serializer)
{
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
if (serializer.Configuration == null)
{
throw new CsvConfigurationException("The given serializer has no configuration.");
}
this.serializer = serializer;
configuration = serializer.Configuration;
}
/// <summary>
/// Creates a new CSV writer using the given <see cref="T:System.IO.TextWriter" />
/// and <see cref="T:CsvHelper.Configuration.CsvConfiguration" /> and <see cref="T:CsvHelper.CsvSerializer" />
/// as the default serializer.
/// </summary>
/// <param name="writer">The <see cref="T:System.IO.StreamWriter" /> use to write the CSV file.</param>
/// <param name="configuration">The configuration.</param>
public CsvWriter(TextWriter writer, CsvConfiguration configuration)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
this.configuration = configuration;
serializer = new CsvSerializer(writer, configuration);
}
public RealtimeCommand(ILogger <RealtimeCommand> log,
IClientWrapper client,
RealTimeBarsManager realTimeBarsManager,
RealtimeConfig config,
ICsvSerializer serializer)
{
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.client = client ?? throw new ArgumentNullException(nameof(client));
this.realTimeBarsManager =
realTimeBarsManager ?? throw new ArgumentNullException(nameof(realTimeBarsManager));
this.config = config ?? throw new ArgumentNullException(nameof(config));
this.serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
public HistoricCommand(ILogger <HistoricCommand> log,
IClientWrapper client,
HistoricalDataManager historicalDataManager,
HistoricConfig config,
ICsvSerializer serializer)
{
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.client = client ?? throw new ArgumentNullException(nameof(client));
this.historicalDataManager =
historicalDataManager ?? throw new ArgumentNullException(nameof(historicalDataManager));
this.config = config ?? throw new ArgumentNullException(nameof(config));
this.serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
/// <summary>
/// Creates a new CSV writer using the given <see cref="ICsvSerializer"/>.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="leaveOpen">true to leave the reader open after the CsvReader object is disposed, otherwise false.</param>
public CsvWriter(ICsvSerializer serializer, bool leaveOpen)
{
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (serializer.Configuration == null)
{
throw new CsvConfigurationException("The given serializer has no configuration.");
}
this.serializer = serializer;
configuration = serializer.Configuration;
this.leaveOpen = leaveOpen;
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <param name="disposing">True if the instance needs to be disposed of.</param>
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
serializer?.Dispose();
}
serializer = null;
context = null;
disposed = true;
}
private CsvDataService(ICsvSerializer csvSerializer)
{
_csvSerializer = csvSerializer;
ShopEntities = new List <ShopEntity>();
Transactions = new List <Transaction>();
if (!Directory.Exists(DataLocation))
{
Directory.CreateDirectory(DataLocation);
}
if (!Directory.Exists(TransactionsDataLocation))
{
Directory.CreateDirectory(TransactionsDataLocation);
}
}
/// <summary>
/// Creates a new CSV writer using the given <see cref="ICsvSerializer"/>.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="leaveOpen">true to leave the reader open after the CsvReader object is disposed, otherwise false.</param>
public CsvWriter(ICsvSerializer serializer, bool leaveOpen)
{
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (serializer.Configuration == null)
{
throw new CsvConfigurationException("The given serializer has no configuration.");
}
if (!(serializer.Configuration is ICsvWriterConfiguration))
{
throw new CsvConfigurationException("The given serializer does not have a configuration that works with the writer.");
}
this.serializer = serializer;
configuration = (ICsvWriterConfiguration)serializer.Configuration;
this.leaveOpen = leaveOpen;
}
/// <summary>
/// Creates a new CSV writer using the given <see cref="ICsvSerializer"/>.
/// </summary>
/// <param name="serializer">The serializer.</param>
public CsvWriter(ICsvSerializer serializer) : this(serializer, false)
{
}
/// <summary>
/// Builds the SQL parameter list.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="poco">The poco.</param>
/// <returns>List<DbParameter>.</returns>
public List <DbParameter> BuildDbParameterList <T>(T poco, Func <string, object, DbParameter> GetNewParameter, IXmlSerializer XmlSerializer, IJsonSerializer JsonSerializer, ICsvSerializer CsvSerializer) where T : class
{
var list = new List <DbParameter>()
{
};
ExtFastMember.GetAdvanceMembers(poco).ForEach(delegate(AdvanceMember p)
{
var validation = DataValidation.IsValidBasedOnSqlColumnAttributes(p);
if (!validation.Item1)
{
throw new InvalidDataException(string.Join(Environment.NewLine, validation.Item2));
}
object parameterValue = DBNull.Value;
if (p.SqlCustomAttritube.SerializableType != SerializableType.NONE)
{
if (p.Member.Type == typeof(string))
{
// assuming the string is already serialize and the developer don't know how this library works smh
parameterValue = ConvertToDatabaseValue(p.Member, p.Value);
}
else
{
if (p.Value == null)
{
parameterValue = DBNull.Value;
}
else
{
switch (p.SqlCustomAttritube.SerializableType)
{
case SerializableType.XML:
XmlSerializer.IsNullThrow(nameof(XmlSerializer),
new BadCodeException(
$"YOU FOOL!!! Your claiming the property {p.Member.Name} in the type {p.Member.Type.FullName} value is in XML Format but your not specifying how to deserialize/serialize it )"));
parameterValue = XmlSerializer.SerializeToString(p.Value);
break;
case SerializableType.JSON:
JsonSerializer.IsNullThrow(nameof(JsonSerializer),
new BadCodeException(
$"YOU FOOL!!! Your claiming the property {p.Member.Name} in the type {p.Member.Type.FullName} value is in JSON Format but your not specifying how to deserialize/serialize it )"));
parameterValue = JsonSerializer.SerializeToString(p.Value);
break;
case SerializableType.CSV:
CsvSerializer.IsNullThrow(nameof(CsvSerializer),
new BadCodeException(
$"YOU FOOL!!! Your claiming the property {p.Member.Name} in the type {p.Member.Type.FullName} value is in CSV Format but your not specifying how to deserialize/serialize it )"));
parameterValue = CsvSerializer.SerializeToString(p.Value);
break;
default:
throw new ArgumentOutOfRangeException();
}
//parameterValue = $"'{parameterValue.ToString().Replace("'", @"\'")}'";
}
}
}
else
{
parameterValue = ConvertToDatabaseValue(p.Member, p.Value);
}
// var command = GetNewCommand();
list.Add(GetNewParameter($"@{p.Member.Name}", parameterValue));
});
return(list);
}
private static void SetPocoProperteyValue <T>(T poco, IDataReader reader, AdvanceMember p, TypeAccessor accessor, IJsonSerializer jsonSerializer = null, IXmlSerializer xmlSerializer = null, ICsvSerializer csvSerializer = null)
{
var isDynamic = (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(typeof(T)));
var value = reader.GetValue(reader.GetOrdinal(p.GetActualMemberName()));
if (isDynamic)
{
DynamicObjectHelper.AddProperty(poco as ExpandoObject, p.GetActualMemberName(), value);
return;
}
if (value.GetType().Name != p.Member.Type.Name && value.GetType() != typeof(DBNull))
{
var type = p.Member.Type;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
type = Nullable.GetUnderlyingType(type);
}
if (type == null)
{
type = p.Member.Type;
}
if (p?.SqlCustomAttritube?.SerializableType != null && p?.SqlCustomAttritube?.SerializableType != SerializableType.NONE)
{
switch (p.SqlCustomAttritube.SerializableType)
{
case SerializableType.XML:
value = xmlSerializer?.DeserializeFromString(value.ToString(), type);
break;
case SerializableType.JSON:
value = jsonSerializer?.DeserializeFromString(value.ToString(), type);
break;
case SerializableType.CSV:
value = csvSerializer?.DeserializeFromString(value.ToString(), type);
break;
case SerializableType.NONE:
value = !type.IsEnum ? Convert.ChangeType(value, type, null) : System.Enum.Parse(type, value.ToString(), true);
break;
default:
break;
}
}
else
{
value = !type.IsEnum ? Convert.ChangeType(value, type, null) : System.Enum.Parse(type, value.ToString(), true);
}
}
try
{
accessor[poco, p.Member.Name] = value is DBNull ? null : value;
}
catch (Exception error)
{
// this property may not be settable
Console.WriteLine(error.Message);
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="reader"></param>
/// <param name="type"></param>
/// <returns></returns>
public static List <T> MapToList <T>(this IDataReader reader, IJsonSerializer jsonSerializer = null, IXmlSerializer xmlSerializer = null, ICsvSerializer csvSerializer = null) where T : class
{
if (reader == null || reader.IsClosed)
{
return(new List <T>()
{
});
}
var accessor = TypeAccessor.Create(typeof(T), true);
var pocoList = new List <T>();
// Cache the field names in the reader for use in our while loop for efficiency.
var readerFieldLookup = new Dictionary <string, int>(StringComparer.OrdinalIgnoreCase); // store name and ordinal
for (var i = 0; i < reader.FieldCount; i++)
{
readerFieldLookup.Add(reader.GetName(i), i);
}
if (typeof(T) == typeof(string))
{
while (reader.Read())
{
pocoList.Add(reader.GetString(0) as T);
}
reader.Close();
reader.Dispose();
return(pocoList);
}
while (reader.Read())
{
var clonedPoco = TypeExtension.New <T> .Instance();
var advanceMembers = ExtFastMember.GetAdvanceMembers(clonedPoco);
if (advanceMembers.IsNullOrEmpty() && typeof(IDynamicMetaObjectProvider).IsAssignableFrom(typeof(T)))
{
readerFieldLookup.ForEach(delegate(KeyValuePair <string, int> pair)
{
advanceMembers.Add(new AdvanceMember()
{
Member = new DynamicMember()
{
Name = pair.Key
}
});
});
}
advanceMembers.Where(p => readerFieldLookup.ContainsKey(p.GetActualMemberName())).ToList().ForEach(delegate(AdvanceMember p)
{
SetPocoProperteyValue(clonedPoco, reader, p, accessor, jsonSerializer, xmlSerializer, csvSerializer);
});
pocoList.Add(clonedPoco);
}
reader.Close();
reader.Dispose();
return(pocoList);
}
