private void btnSaveUploaders_Click(object sender, RoutedEventArgs e)
{
SaveFileDialog dlg = new SaveFileDialog();
dlg.CheckPathExists = true;
dlg.DefaultExt = ".csv";
dlg.Filter = "CSV File(*.csv)|*.csv";
dlg.Title = "Save";
var result = dlg.ShowDialog();
if (result ?? false)
{
var streamwriter = new System.IO.StreamWriter(dlg.FileName);
CsvHelper.CsvWriter writer = new CsvHelper.CsvWriter(streamwriter);
var records = new List <dynamic>();
dynamic record = new ExpandoObject();
writer.WriteRecords(uploadersViewModel.ToList());
streamwriter.Close();
}
}
public void Write_List_Test()
{
var count = 10000;
var names = RandomHelper.GenStringList(RandomHelper.CharSchemeEnum.Char, 10, count);
var ages = RandomHelper.GenNumberList(1, 99, count);
var genders = RandomHelper.GenBoolean(count);
var records = new List <dynamic>();
for (int i = 0; i < count; i++)
{
dynamic o = new ExpandoObject();
o.name = names[i];
o.age = ages[i];
o.gender = genders[i];
records.Add(o);
}
using (TextWriter writer = File.CreateText("c:\\TextWriter.csv"))
{
var csv = new CsvHelper.CsvWriter(writer);
csv.WriteRecords(records);
}
}
private void Button_TestConfiguration_Click(object sender, RoutedEventArgs e)
{
var dialog = new ConfigurationSelectionDialog();
if (dialog.ShowDialog() != true || SelectedDataSet == null)
{
return;
}
var caibration_mode = Helpers.GetCalibrationMode(dialog.GetSelectedConfiguration());
var calibration_manager = Helpers.SetupCalibrationManager(caibration_mode);
int avg_time;
var result = Helpers.RunPerfTest(
calibration_manager,
SelectedDataSet.data_points,
caibration_mode.additional_dimensions_configuration,
out avg_time);
calibration_manager.SaveInDirectory(Utils.DataFolder);
using (var writer = new StreamWriter(
System.IO.Path.Combine(SelectedDataSet.DataSetResultsFolder,
(dialog.GetSelectedConfiguration() ?? "User Data") + ".csv")))
{
using (var csv = new CsvHelper.CsvWriter(writer, System.Globalization.CultureInfo.InvariantCulture))
{
csv.WriteRecords(result.errors);
}
}
MessageBox.Show(
"Configuration: " + (dialog.GetSelectedConfiguration() ?? "User Data") + ". " + result.ToString() +
". \nAvg time:" + avg_time);
}
public void Cesevear(List <Seccion> seccions, string estado)
{
var ceseves = new List <PuntoCsv>();
foreach (var seccion in seccions)
{
foreach (var subseccion in seccion.Subsecciones)
{
var csv = new PuntoCsv()
{
Seccion = seccion.IdSeccion,
Direccion = subseccion.Domicilio,
TipoDeCasillas = subseccion.Titulo,
Casillas = subseccion.Titulo.Split(',').Count(),
Ubicacion = subseccion.Ubicacion,
Lng = subseccion.Punto.Coordinates[0],
Lat = subseccion.Punto.Coordinates[1],
};
ceseves.Add(csv);
}
}
var ruta = @"C:\Users\sgt0pimienta\Desktop\INvEstigate Output\" + estado + "-puntos.csv";
using (TextWriter wr = File.CreateText(ruta))
{
var csv = new CsvHelper.CsvWriter(wr);
csv.WriteRecords(ceseves);
}
}
public static void Write <T>(string path, IEnumerable <T> records)
where T : ICsvModel
{
using var writer = new StreamWriter(path, false, EncodesResolver.Resolve <T>());
using var csvWriter = new CsvHelper.CsvWriter(writer, CultureInfo.InvariantCulture);
csvWriter.WriteRecords(records);
}
public static void ExportByPropertyNames <T>(IEnumerable <T> objs, IEnumerable <PropertyInfo> properties, string path, Encoding encoding)
{
if (!File.Exists(path))
{
using (File.Create(path)) { }
}
//List<string> title = properties.Select(p => p.Name).ToList();
List <dynamic> list = new List <dynamic>();
foreach (var obj in objs)
{
dynamic target = new ExpandoObject();
foreach (var prop in properties)
{
object value = prop.GetValue(obj);
(target as IDictionary <string, object>).Add(prop.Name, value);
}
list.Add(target);
}
using (StreamWriter stream = new StreamWriter(File.Open(path, FileMode.Create), encoding))
{
CsvHelper.CsvWriter writer = new CsvHelper.CsvWriter(stream, CultureInfo.InvariantCulture);
writer.WriteRecords(list);
}
}
/// <summary>
/// Application entry point.
/// Opens USDA Nutrient database (revision 26), denormalizes it using UsdaDenormalizer library
/// and writes result to a CSV file with a specified name.
/// </summary>
/// <param name="args">
/// [0] path to the directory containing ASCII version of database
/// [1] path to the output CSV file
/// </param>
static void Main(string[] args)
{
// check if input is valid
if (args.Length > 1)
{
string inputDirectoryPath = args[0];
string outputCsvPath = args[1];
if (System.IO.Directory.Exists(inputDirectoryPath))
{
// read nutrient data from files in filesystem to object model in memory
DirectoryDataProvider dataProvider = new DirectoryDataProvider(inputDirectoryPath, 26, new WindowsTextReader());
DatabaseRepresentation dbModel = new DatabaseRepresentation(dataProvider);
// create denormalized (flat) model based using database data
DenormalizedModel denormalizedModel = new DenormalizedModel(dbModel);
// write flat model into CSV file as one big table
using (var writer = System.IO.File.CreateText(outputCsvPath))
{
CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(writer);
csvWriter.WriteRecords(denormalizedModel.FoodItems);
}
}
else
{
throw new ArgumentException("Specified directory does not exist or you don't have an access to it: " + inputDirectoryPath);
}
}
else
{
throw new ArgumentException("No arguments were provided.");
}
}
public async Task <IActionResult> OnPostExportToCsv(GetSubmissions.Query query)
{
query.PageNo = 1;
query.PageSize = int.MaxValue;
var submissions = await _engine.Query(query);
using (var stream = new System.IO.MemoryStream())
using (var writer = new System.IO.StreamWriter(stream))
using (var csv = new CsvHelper.CsvWriter(writer, new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentUICulture)))
{
csv.WriteRecords(submissions.Select(x => new {
Timestamp = x.Timestamp.ToString(),
FirstName = x.FirstName,
LastName = x.LastName,
FullName = x.FullName,
EmailAddress = x.Email.ToString(),
PhoneNumber = x.PhoneNumber.ToString(),
Region = x.Region,
HasLecturerRights = x.HasLecturerRights,
HasResigned = x.HasResignedPermanently || x.HasResignedTemporarily
}));
csv.Flush();
writer.Flush();
return(File(stream.ToArray(), "text/csv", "enrollments.csv"));
}
}
public static void ExtractToCSV(Course[] courses)
{
using (context = new Context())
using (System.IO.StreamWriter writer = new System.IO.StreamWriter("ExportedFiles/file.csv"))
using (CsvHelper.CsvWriter csv = new CsvHelper.CsvWriter(writer, System.Globalization.CultureInfo.InvariantCulture))
csv.WriteRecords(courses);
}
public static void Test()
{
Console.WriteLine("CSV: CsvHelper.CsvReader|CsvWriter");
// CsvHelper.CsvReader 只支持流
var source = "Name,Age,Sex\r\nWagsn,23,True\r\nBruce,25,True\r\n";
using (CsvHelper.CsvReader reader = new CsvHelper.CsvReader(new System.IO.StreamReader(ConvertHelper.ConvertToStream(source))))
{
foreach (var per in reader.GetRecords <Person>())
{
Console.WriteLine($"deserialize: name: {per?.Name}, age: {per?.Age}, sex: {per?.Sex}");
}
}
var path = "./CSV/person.csv";
using (CsvHelper.CsvWriter writer = new CsvHelper.CsvWriter(new System.IO.StreamWriter(System.IO.File.OpenWrite(path))))
{
var per = new Person {
Name = "Wagsn", Age = 23, Sex = true
};
writer.WriteRecords(new List <Person> {
per
});
}
}
public FileStreamResult EcrireCsvDansMemoire <T>(IEnumerable <T> records, string fileName, string filtre)
{
using (var memoryStream = new MemoryStream())
{
using (var streamWriter = new StreamWriter(memoryStream))
{
if (!string.IsNullOrEmpty(filtre))
{
streamWriter.WriteLine($"Filtre : {filtre}");
streamWriter.WriteLine();
}
using (var csvWriter = new CsvHelper.CsvWriter(streamWriter))
{
csvWriter.Configuration.Delimiter = ";";
csvWriter.WriteRecords(records);
streamWriter.Flush();
}
}
return(new FileStreamResult(new MemoryStream(memoryStream.ToArray()), "text/csv")
{
FileDownloadName = fileName
});
}
}
private void CreateEmptyBookingFile(string file)
{
using (var f = File.OpenWrite(file))
using (var s = new StreamWriter(f))
using (var csv = new CsvHelper.CsvWriter(s, CultureInfo.InvariantCulture))
{
csv.Configuration.TypeConverterOptionsCache.GetOptions <DateTime>().Formats
= new string[] { "yyyy-MM-dd" };
csv.WriteRecords <UnscheduledCsvRow>(new[] {
new UnscheduledCsvRow()
{
Id = "12345",
DueDate = DateTime.Today.AddDays(10),
Priority = 100,
Part = "part1",
Quantity = 50,
},
new UnscheduledCsvRow()
{
Id = "98765",
DueDate = DateTime.Today.AddDays(12),
Priority = 100,
Part = "part2",
Quantity = 77,
}
});
}
}
private void ToolStripMenuItem_save_Click(object sender, EventArgs e)
{
SaveFileDialog sa = new SaveFileDialog();
sa.Title = "ファイルを保存する";
sa.InitialDirectory = ConfigurationManager.AppSettings["lastSaveDir"];
sa.FileName = CurrentFileName;
sa.Filter = "CSV(*.csv)|*.csv|すべてのファイル(*.*)|*.*";
sa.FilterIndex = 1;
DialogResult result = sa.ShowDialog();
if (result == DialogResult.OK)
{
// フルパスが取得される
string fileName = sa.FileName;
using (var csvr = new CsvHelper.CsvWriter(new StreamWriter(fileName, false, Encoding.UTF8)))
{
csvr.Configuration.RegisterClassMap <TalkTable>();
csvr.WriteRecords(talkings.ToArray());
ConfigurationManager.AppSettings["lastSaveDir"] = Path.GetDirectoryName(fileName);
CurrentFileName = Path.GetFileName(fileName);
this.Text = formTitle;
}
isSaved = true;
}
else if (result == DialogResult.Cancel)
{
}
}
static void Main(string[] args)
{
using (var sr = new StreamWriter($"{Environment.CurrentDirectory}/my.csv"))
using (var csv = new CsvHelper.CsvWriter(sr, CultureInfo.InvariantCulture))
{
int start = 4200;
int stop = 6400;
int parallelThreads = 50;
int failCounter = 0;
foreach (var request in JiraHttpRequest.getWorkItemObjects(start, stop, parallelThreads))
{
try
{
csv.WriteRecords(FlattenItems(request));
Console.WriteLine($"Finished writing POB-{request.id}");
}
catch (Exception e)
{
Console.WriteLine($"Failed to write POB-{request.id} " + e.ToString());
failCounter++;
}
}
Console.WriteLine($"Failed to write {failCounter} records");
}
}
public void WriteData()
{
if (isIOInProgress)
{
return;
}
try
{
isIOInProgress = true;
// convert ActivityTimer View Model to Model...
List <Data.ActivityTimerRow> rows = new List <Data.ActivityTimerRow>();
foreach (ActivityTimerVM timerVM in TimerCollection)
{
rows.Add(timerVM.GetModel());
}
// write the model out...
using (var sWriter = new System.IO.StreamWriter(strFilePath))
using (var csvWriter = new CsvHelper.CsvWriter(sWriter))
{
csvWriter.WriteRecords(rows);
}
}
finally
{
isIOInProgress = false;
}
}
public async Task <IActionResult> OnPostExportEventsFromFilesStoreToCsv()
{
if ((_eventPersistence is FilesEventPersistence) == false)
{
throw new ApplicationException($"{nameof(FilesEventPersistence)} not configured");
}
var events = await _eventPersistence.LoadAllCommittedEvents(GlobalPosition.Start, 1000, CancellationToken.None);
var result = events.CommittedDomainEvents
.Cast <FilesEventPersistence.FileEventData>()
.Select(x => new { Source = x, Deserialized = _eventJsonSerializer.Deserialize(x) })
.Select(x => new EventFlow.SQLite.EventStores.SQLiteEventPersistence.EventDataModel()
{
GlobalSequenceNumber = x.Source.GlobalSequenceNumber,
BatchId = Guid.Parse(x.Deserialized.Metadata["batch_id"]),
AggregateId = x.Source.AggregateId,
AggregateName = x.Deserialized.Metadata["aggregate_name"],
Data = x.Source.Data,
Metadata = x.Source.Metadata,
AggregateSequenceNumber = x.Source.AggregateSequenceNumber
});
using (var stream = new System.IO.MemoryStream())
using (var writer = new System.IO.StreamWriter(stream))
using (var csv = new CsvHelper.CsvWriter(writer, new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentUICulture)))
{
csv.WriteRecords(result);
csv.Flush();
writer.Flush();
return(File(stream.ToArray(), "text/csv", "events.csv"));
}
}
void LogActivity(ActivityEvent act)
{
var f = Path.Combine(myPath, "activities.csv");
_log.Info("activity change detected");
bool isNew = File.Exists(f);
lock (this)
{
using (var writer = new StreamWriter(f, true))
using (var csv = new CsvHelper.CsvWriter(writer, new CsvHelper.Configuration.Configuration()
{
Encoding = Encoding.UTF8, HasHeaderRecord = !isNew, CultureInfo = System.Globalization.CultureInfo.CurrentCulture
}))
{
csv.Configuration.TypeConverterOptionsCache.GetOptions <DateTime>().Formats = new[] { "yyyy-MM-dd HH:mm:ss.fff" };
csv.WriteRecords(new List <ActivityEvent>()
{
act
});
csv.Flush();
}
}
//activity change
lastActivitiy = act;
}
private async void csvExport_Click(object sender, RoutedEventArgs e)
{
/*
* Task gVotes = Task.Run(() => getVotes(false, false));
* gVotes.Wait();
*
* Task gCandidates= Task.Run(() => getCandidates(false, false,false));
* gCandidates.Wait();
*/
getVotes(false, false);
candidatesList.Clear();
var firebase = new FirebaseClient("https://votingcalculator.firebaseio.com");
var candidates = await firebase.Child("candidates").OnceAsync <Candidate>();
foreach (var candidate in candidates)
{
Candidate newcandidate = new Candidate
{
name = candidate.Object.name,
party = candidate.Object.party,
votes = candidate.Object.votes
};
candidatesList.Add(newcandidate);
}
partyList = candidatesList.GroupBy(c => c.party).Select(cl => new Candidate
{
party = cl.First().party,
votes = cl.Sum(c => c.votes),
}).ToList();
//candidates database
using (var streamWriter = File.CreateText(desktopPath + "//vcCsvCandidates.csv"))
{
var csv = new CsvHelper.CsvWriter(streamWriter, true);
csv.WriteRecords(candidatesList);
csv.Flush();
}
//votes database
using (var streamWriter = File.CreateText(desktopPath + "//vcCsvVotes.csv"))
{
List <Votes> votesList = new List <Votes>();
votesList.Add(GetVotesObject);
var csv = new CsvHelper.CsvWriter(streamWriter, true);
csv.WriteRecords(votesList);
csv.Flush();
}
//parties database
using (var streamWriter = File.CreateText(desktopPath + "//vcCsvParties.csv"))
{
var csv = new CsvHelper.CsvWriter(streamWriter, true);
csv.WriteRecords(partyList);
csv.Flush();
}
System.Windows.MessageBox.Show("You can find .csv files on your desktop as 'vcCsvCandidates.csv', 'vcCsvParties.csv' and 'vcCsvVotes.csv'.");
}
public static void Export <T>(IEnumerable <T> objs, string path, Encoding encoding)
{
using (StreamWriter stream = new StreamWriter(File.Open(path, FileMode.Create), encoding))
{
CsvHelper.CsvWriter writer = new CsvHelper.CsvWriter(stream, CultureInfo.InvariantCulture);
writer.WriteRecords(objs);
}
}
public string CsvHelperSerialize()
{
using MemoryStream memoryStream = new MemoryStream();
using StreamWriter streamWriter = new StreamWriter(memoryStream);
using CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter);
csvWriter.WriteRecords(_data);
return(Encoding.UTF8.GetString(memoryStream.ToArray()));
}
public static void WriteCSVFile <T>(string csvFilePath, IEnumerable <T> samples)
{
using (var f = File.CreateText(csvFilePath))
{
var writer = new CsvHelper.CsvWriter(f);
writer.WriteRecords(samples);
}
}
public static void Write <T>(IEnumerable <T> dto, string file)
{
using (var stream = File.Open(file, FileMode.Create, FileAccess.Write, FileShare.Read))
using (var writer = new StreamWriter(stream))
{
var csv = new CsvHelper.CsvWriter(writer);
csv.WriteRecords(dto);
}
}
public override void Write(TextWriter writer)
{
using (var csv = new CsvHelper.CsvWriter(writer))
{
csv.Configuration.HasHeaderRecord = true;
csv.Configuration.RegisterClassMap <Mapping>();
csv.WriteRecords(DenormalizedSchema_);
}
}
public static void WriteToCSVFile <T>(this IEnumerable <T> records, string path)
{
using (var sw = new StreamWriter(path))
{
var csvWriter = new CsvHelper.CsvWriter(sw);
csvWriter.WriteRecords(records);
}
}
private string processCsv(List <ExportInvoiceHolder> invoices)
{
using StringWriter writer = new StringWriter();
using var csvWriter = new CsvHelper.CsvWriter(writer, new CsvConfiguration(CultureInfo.InvariantCulture), true);
csvWriter.WriteHeader <ExportInvoiceHolder>();
csvWriter.NextRecord();
csvWriter.WriteRecords(invoices);
csvWriter.Flush();
return(writer.ToString());
}
public string Serialize <tEntity>(List <tEntity> listEntity) where tEntity : BaseEntity
{
using (TextWriter writer = new StringWriter())
{
using (CsvHelper.CsvWriter writerCsv = new CsvHelper.CsvWriter(writer))
{
writerCsv.WriteRecords(listEntity);
}
return(writer.ToString());
}
}
static Action <IEnumerable <NarrowRow <T> >, TextWriter> MakeWriteWithCsvHelper(CsvHelper.Configuration.CsvConfiguration config)
{
return
((IEnumerable <NarrowRow <T> > rows, TextWriter into) =>
{
using (var writer = new CsvHelper.CsvWriter(into, config))
{
writer.WriteRecords(rows);
}
});
}
private static string ProcessCsv(IEnumerable <ExportTransaction> invoices)
{
using StringWriter writer = new();
using var csvWriter = new CsvHelper.CsvWriter(writer, new CsvConfiguration(CultureInfo.InvariantCulture), true);
csvWriter.Configuration.RegisterClassMap <ExportTransactionMap>();
csvWriter.WriteHeader <ExportTransaction>();
csvWriter.NextRecord();
csvWriter.WriteRecords(invoices);
csvWriter.Flush();
return(writer.ToString());
}
public override void Write <T>(List <T> items, string path)
{
CsvConfiguration configuration = new CsvConfiguration(CultureInfo.InvariantCulture);
configuration.HasHeaderRecord = false;
using (var writer = new StreamWriter(path))
using (var csv = new CsvHelper.CsvWriter(writer, configuration))
{
csv.WriteRecords(items);
}
}
/// <summary>
/// Creates CSV from a completedOrder
/// </summary>
/// <param name="completedOrders"></param>
private void CreateCSV(List <CompletedOrder> completedOrders)
{
foreach (var completedOrder in completedOrders)
{
var lines = completedOrder.GenerateCsvLines();
using (var writer = new StreamWriter($"{OutputDirectory}/{completedOrder.Order.Marketplace}-{completedOrder.Order.OrderReference}.csv"))
{
var csv = new CsvHelper.CsvWriter(writer);
csv.WriteRecords(lines);
}
}
}
public static void Harvest(List <string> tickers, string filename)
{
var targetFile = $@"c:\temp\{filename}.csv";
var baseUrl = "http://www.cefconnect.com/api/v3";
IJsonServiceClient client = new JsonServiceClient(baseUrl);
var results = new List <DataRow>();
foreach (var ticker in tickers)
{
var year = DateTime.Now.Year - 5;
var resultsFound = true;
while (resultsFound)
{
var request = new GetCefConnect {
ticker = ticker, yyyy = year.ToString()
};
var url = request.ToGetUrl();
var response = client.Get(request);
resultsFound = (response.Data.IsNullOrEmpty() == false);
if (resultsFound)
{
var dataRows = response.Data.ConvertAll(x => x.ConvertTo <DataRow>());
dataRows.ForEach(dr => dr.Ticker = ticker);
results.AddRange(dataRows);
year = year - 5;
}
}
Console.WriteLine($"Parsed {ticker}");
}
using (var sw = new StreamWriter(targetFile))
{
//var reader = new CsvReader(sr);
var writer = new CsvHelper.CsvWriter(sw);
//CSVReader will now read the whole file into an enumerable
//IEnumerable records = reader.GetRecords<DataRecord>().ToList();
//Write the entire contents of the CSV file into another
writer.WriteRecords(results);
Console.WriteLine($"Wrote out {targetFile}");
}
}
