public void write_csv_writes_all_public_properties_by_default() { using (var stringWriter = new StringWriter()) using (var writer = new CsvWriter(stringWriter)) { writer.NewLine = "<EOL>"; var items = new TestType1[] { new TestType1 { Property1 = "1", Property2 = "2", Property3 = "3" }, new TestType1 { Property1 = "4", Property2 = "5", Property3 = "6" } }; items.WriteCsv(writer); var result = stringWriter.ToString(); // can't assert exact contents because order of properties is undefined (and changes) Assert.Contains("Property1", result); Assert.Contains("Property2", result); Assert.Contains("1", result); Assert.Contains("2", result); Assert.Contains("4", result); Assert.Contains("5", result); } }
/// <summary> /// Экспортирует массив данных в CSV формат с учетом выбранной локали /// </summary> /// <param name="path">Путь к файлу, в который нужно сохранить данные</param> /// <param name="localisation">Локализация</param> /// <returns>Успешное завершение операции</returns> public override bool Export(String path, Localisation localisation) { try { if (!path.EndsWith(".csv")) path += ".csv"; Thread.CurrentThread.CurrentCulture = new CultureInfo((int)localisation); log.Info(String.Format("Export to .csv file to: {0}", path)); var timer = new Stopwatch(); timer.Start(); using (var streamWriter = new StreamWriter(path)) using (var writer = new CsvWriter(streamWriter)) { writer.ValueSeparator = Thread.CurrentThread.CurrentCulture.TextInfo.ListSeparator[0]; dataTable.WriteCsv(writer); } timer.Stop(); log.Info(String.Format("CSV export complete! Elapsed time: {0} ms", timer.Elapsed.Milliseconds)); return true; } catch (Exception ex) { log.Error("Can't export to .csv file!", ex); return false; } }
/// <summary> /// Converts a DataTable to a csv string /// </summary> /// <param name="dataTable">The dataTable</param> /// <param name="headers">(Optional) Headers</param> /// <param name="ignore">(Optional) Keys to ignore</param> public static string ToCSV(this IEnumerable<Dictionary<string, Object>> dataTable, string[] headers = null, string[] ignore = null) { if (ignore == null) ignore = new string[] { }; var stringWriter = new StringWriter(); var csvWriter = new CsvWriter(stringWriter); if (headers == null) { headers = (from kvp in dataTable.First() where !ignore.Contains(kvp.Key) select kvp.Key).ToArray(); } csvWriter.WriteHeaderRecord(headers); foreach (var record in dataTable) { var values = (from kvp in record where !ignore.Contains(kvp.Key) select kvp.Value == null? "": kvp.Value.ToString()).ToArray(); csvWriter.WriteDataRecord(values); } csvWriter.Close(); var csv = stringWriter.ToString(); return csv; }
public static void WriteTable(TableFileBase tableFile) { string path = "./Assets/Resources/Tables/" + tableFile.GetType().Name + ".csv"; string[] lines = File.ReadAllLines(path, Encoding.Default); lines[0] = lines[0].Replace("\r\n", "\n"); StringReader rdr = new StringReader(string.Join("\n", lines)); List<string> titles = new List<string>(); using (var reader = new CsvReader(rdr)) { HeaderRecord header = reader.ReadHeaderRecord(); for (int i = 0; i < header.Count; ++i) { titles.Add(header[i]); } } File.Delete(path); using (StreamWriter SourceStream = new StreamWriter(path, false, System.Text.Encoding.Default)) { CsvWriter writer = new CsvWriter(SourceStream); writer.WriteRecord(titles.ToArray()); foreach (var record in tableFile.Records) { writer.WriteRecord(record.Value.GetRecordStr()); } } }
public void write_csv_writes_header_record_by_default() { using (var stringWriter = new StringWriter()) using (var writer = new CsvWriter(stringWriter)) { writer.NewLine = "<EOL>"; new TestType1[0].WriteCsv(writer); var result = stringWriter.ToString(); // can't assert exact contents because order of properties is undefined (and changes) Assert.Contains("Property1", result); Assert.Contains("Property2", result); } }
public static void ExportCSV(string path, Guid pollId) { var poll = DataService.PerThread.ContentSet.OfType<Poll>().SingleOrDefault(x => x.Id == pollId); if (poll == null) { throw new BusinessLogicException("Указан неверный идентификатор голосования"); } else { var bulletins = poll.Bulletins.OrderByDescending(x => x.Weight).ThenByDescending(x => x.Result).ThenBy(x => x.Id).ToList(); using (var writer = new CsvWriter(path)) { writer.ValueSeparator = ';'; writer.WriteHeaderRecord("Номер бюллетеня", "Голос", "Вес"); foreach (var pollBulletin in bulletins) { if (pollBulletin.Weight.Equals(0)) { writer.WriteDataRecord(pollBulletin.Id, "Голос делегирован", "-"); } else { switch ((VoteOption)pollBulletin.Result) { case VoteOption.Yes: writer.WriteDataRecord(pollBulletin.Id, "За", pollBulletin.Weight); break; case VoteOption.No: writer.WriteDataRecord(pollBulletin.Id, "Против", pollBulletin.Weight); break; case VoteOption.NotVoted: writer.WriteDataRecord(pollBulletin.Id, "Не голосовал", pollBulletin.Weight); break; case VoteOption.Refrained: writer.WriteDataRecord(pollBulletin.Id, "Воздержался", pollBulletin.Weight); break; default: writer.WriteDataRecord(pollBulletin.Id, "Неизвестно", pollBulletin.Weight); break; } } } writer.Close(); } } }
protected override void ProcessRecord() { FileName = Path.GetFullPath(FileName); var basePath = Path.GetDirectoryName(FileName); var csvName = string.Format("{0}.csv", Path.GetFileNameWithoutExtension(FileName)); if (File.Exists(FileName)) { throw new ArgumentException(string.Format("File {0} exists!", FileName));} if (!Directory.Exists(basePath)) { throw new DirectoryNotFoundException(string.Format("Directory {0} does not exist.", basePath));} using (var zipStream = new ZipFile(basePath)) using (var csvRaw = new MemoryStream()) using (var csvWriter = new CsvWriter(csvRaw)) { csvWriter.WriteAll(Data); csvRaw.Seek(0, SeekOrigin.Begin); zipStream.AddEntry(csvName, csvRaw); } }
public override void Execute(object parameter) { var stream = GetOutputStream(); if (stream == null) return; using (stream) using (var writer = new CsvWriter(stream)) { writer.WriteHeaderRecord(new[] {"Key"}.Concat(model.ValueCalculations.Select(v => v.Header))); foreach (var reportRow in model.Results) { writer.WriteDataRecord(new object[] { reportRow.Key}.Concat(model.ValueCalculations.Select(v => (object)reportRow.Values[v.Header]))); } } }
private static void Main() { if (Settings.Default.UseAccessPair) { _tokens.AccessToken = Settings.Default.AccessToken; _tokens.AccessTokenSecret = Settings.Default.AccessSecret; } else { if (string.IsNullOrEmpty(Settings.Default.UserAccessToken) || string.IsNullOrEmpty(Settings.Default.UserAccessSecret)) { var tokenResponse = GetUserToken(); Settings.Default.UserAccessToken = tokenResponse.Token; Settings.Default.UserAccessSecret = tokenResponse.TokenSecret; Settings.Default.UserId = (int)tokenResponse.UserId; Settings.Default.Save(); } _tokens.AccessToken = Settings.Default.UserAccessToken; _tokens.AccessTokenSecret = Settings.Default.UserAccessSecret; } /* { var userInfo = GetUserInfo().ToBsonDocument(); var csvWriter = new CsvWriter(Console.Out); csvWriter.WriteHeaderRecord(userInfo.Names.ToArray()); csvWriter.WriteDataRecord(userInfo.Values); Console.WriteLine(); } */ { var users = GetMutualFriends(_tokens); var csvWriter = new CsvWriter(Console.Out); csvWriter.WriteHeaderRecord(users.First().ToBsonDocument().Names.ToArray()); foreach (var user in users) { csvWriter.WriteDataRecord(user.ToBsonDocument().Values.ToArray()); } Console.WriteLine(); } }
public static void WriteFile(ContentFile file) { if (!string.IsNullOrEmpty(file.ConstructFile.OldName)) { string oldPath = TableGlobalConfig.Instance.ResTablePath + "/" + file.ConstructFile.OldName + ".csv"; if (!string.IsNullOrEmpty(oldPath)) { File.Delete(oldPath); } file.WriteFlag = true; WriteConstruct.WriteFileOldName(file.ConstructFile, ""); } if(!file.IsNeedWrite()) return; string path = TableGlobalConfig.Instance.ResTablePath + "/" + file.ConstructFile.Name + ".csv"; if (string.IsNullOrEmpty(path)) return; File.Delete(path); using (StreamWriter SourceStream = new StreamWriter(path, false, System.Text.Encoding.UTF8)) { CsvWriter writer = new CsvWriter(SourceStream); writer.WriteRecord(file.ConstructFile.GetColumnTitles()); foreach (ContentRow row in file.ContentRow) { writer.WriteRecord(row.GetItemsStr()); } } file.AlreadyWrite(); }
public void write_csv_throws_if_any_property_cannot_be_resolved() { var writer = new CsvWriter(new StringWriter()); var ex = Assert.Throws<InvalidOperationException>(() => new List<DateTime>().WriteCsv(writer, true, new string[] { "Date", "Foo" })); Assert.Equal("Property 'Foo' was not found on type 'System.DateTime'.", ex.Message); }
public async Task write_csv_async_throws_if_enumerable_is_null() { var writer = new CsvWriter(new StringWriter()); await Assert.ThrowsAsync<ArgumentNullException>(() => ((IEnumerable<DateTime>)null).WriteCsvAsync(writer)); }
public async Task write_csv_async_throws_if_property_names_is_null() { var writer = new CsvWriter(new StringWriter()); await Assert.ThrowsAsync<ArgumentNullException>(() => new List<DateTime>().WriteCsvAsync(writer, true, null)); }
public async Task write_csv_async_non_reflection_overload_allows_arbitrary_conversion_of_objects_to_csv() { using (var stringWriter = new StringWriter()) using (var writer = new CsvWriter(stringWriter)) { writer.NewLine = "<EOL>"; var items = new DateTime[] { new DateTime(2004, 12, 31), new DateTime(1978, 12, 4), new DateTime(1979, 10, 26) }; var header = new string[] { "The Year", "Even Year?" }; await items.WriteCsvAsync(writer, header, dt => new string[] { dt.Year.ToString(CultureInfo.InvariantCulture), (dt.Year % 2 == 0).ToString(CultureInfo.InvariantCulture) }); Assert.Equal("The Year,Even Year?<EOL>2004,True<EOL>1978,True<EOL>1979,False<EOL>", stringWriter.ToString()); } }
public void write_csv_throws_if_csv_writer_is_disposed() { var writer = new CsvWriter(new StringWriter()); writer.Dispose(); Assert.Throws<ObjectDisposedException>(() => new DateTime[0].WriteCsv(writer)); }
public async Task write_csv_async_non_reflection_throws_if_object_to_record_converter_is_null() { using (var writer = new CsvWriter(new StringWriter())) { var header = new string[] { "The Year", "Even Year?" }; await Assert.ThrowsAsync<ArgumentNullException>(() => new DateTime[0].WriteCsvAsync(writer, header, null)); } }
public void write_csv_throws_if_any_property_name_is_null() { var writer = new CsvWriter(new StringWriter()); var ex = Assert.Throws<ArgumentException>(() => new List<DateTime>().WriteCsv(writer, true, new string[] { "Date", null })); Assert.Equal("A property name is null.", ex.Message); }
/// <summary> /// Сохраняет DataGridView в CSV в файл с указанным именем. /// </summary> /// <param name="dgvInf">Таблица DataGridView</param> /// <param name="filename">Имя файла</param> public static void DGVtoCSV(DataGridView dgvInf, string filename) { using (CsvWriter writer = new CsvWriter(filename)) { writer.ValueSeparator = Char.Parse(";"); string[] dataString = new string[dgvInf.ColumnCount]; for (int i = 0; i < dgvInf.RowCount; i++) { for (int b = 0; b < dgvInf.ColumnCount; b++) { dataString[b] = dgvInf.Rows[i].Cells[b].Value.ToString(); } writer.WriteDataRecord(dataString); } writer.Close(); } }
private void WriteColumnsForDocuments(CsvWriter writer, IEnumerable<JsonDocument> documents, DocumentColumnsExtractor extractor) { foreach (var document in documents) { var values = extractor.GetValues(document); writer.WriteDataRecord(values); } }
public async Task write_csv_async_writes_only_requested_properties_if_specified() { using (var stringWriter = new StringWriter()) using (var writer = new CsvWriter(stringWriter)) { writer.NewLine = "<EOL>"; var items = new TestType1[] { new TestType1 { Property1 = "1", Property2 = "2", Property3 = "3" }, new TestType1 { Property1 = "4", Property2 = "5", Property3 = "6" } }; await items.WriteCsvAsync(writer, true, new string[] { "Property2" }); Assert.Equal("Property2<EOL>2<EOL>5<EOL>", stringWriter.ToString()); } }
public async Task write_csv_async_throws_if_csv_writer_is_disposed() { var writer = new CsvWriter(new StringWriter()); writer.Dispose(); await Assert.ThrowsAsync<ObjectDisposedException>(() => new DateTime[0].WriteCsvAsync(writer)); }
public async Task write_csv_async_throws_if_object_to_string_converter_is_null() { var writer = new CsvWriter(new StringWriter()); await Assert.ThrowsAsync<ArgumentNullException>(() => new List<DateTime>().WriteCsvAsync(writer, true, new string[] { "Date" }, null)); }
public async Task ExportAsync(CancellationToken cancellationToken, Action<int> reportProgress) { reportProgress = reportProgress ?? delegate { }; var context = SynchronizationContext.Current; using (stream) using (var writer = new CsvWriter(stream)) { var extractor = new DocumentColumnsExtractor(columns); writer.WriteHeaderRecord(columns.Select(c => c.Header)); // we do the streaming of documents on a background thread mainly to escape the // SynchronizationContext: when there's no synchronization context involved the // async methods can resume on any thread instead of having to hop back to the UI thread. // This avoids massive overheads await TaskEx.Run(async () => { var totalResults = new Reference<long>(); using (var documentsStream = await collectionSource.StreamAsync(totalResults)) { IList<JsonDocument> documentBatch; var fetchedDocuments = 0; do { documentBatch = await GetNextBatch(documentsStream, cancellationToken); fetchedDocuments += documentBatch.Count; // extracting properties from the documents has to be done on the UI thread // because it might involve using FrameworkElements and Silverlight databinding context.Send(delegate { WriteColumnsForDocuments(writer, documentBatch, extractor); reportProgress((int) (((double) fetchedDocuments/totalResults.Value)*100)); }, null); } while (documentBatch.Count > 0); } }); } }
public async Task write_csv_async_writes_converts_null_property_values_to_empty_strings() { using (var stringWriter = new StringWriter()) using (var writer = new CsvWriter(stringWriter)) { writer.NewLine = "<EOL>"; var items = new TestType2[] { new TestType2 { Property1 = null, Property2 = 2d, Property3 = 3, Property4 = 4m }, new TestType2 { Property1 = null, Property2 = 6d, Property3 = 7, Property4 = null } }; await items.WriteCsvAsync(writer); Assert.Equal("Property1,Property2,Property3,Property4<EOL>,2,3,4<EOL>,6,7,<EOL>", stringWriter.ToString()); } }
/// <summary> /// Gets the RecurringServices CSV for a role. /// </summary> /// <param name="roleId">The role id.</param> public byte[] GetRecurringServicesCSVForRole(Guid roleId) { var memoryStream = new MemoryStream(); var csvWriter = new CsvWriter(memoryStream); csvWriter.WriteHeaderRecord("Service Type", "Client", "Location", "Address Line 1", "Frequency", "Start Date", "End Date", "Repeat Every", "Repeat On"); var recurringServices = RecurringServicesForServiceProviderOptimized(roleId).Include(rs => rs.Client).Include(rs => rs.Repeat).Include(rs => rs.ServiceTemplate); //Force Load LocationField's Location //TODO: Optimize by IQueryable recurringServices.SelectMany(rs => rs.ServiceTemplate.Fields).OfType<LocationField>().Select(lf => lf.Value).ToArray(); //join RecurringServices with client names var records = from rs in recurringServices orderby rs.Client.Name select new { RecurringService = rs, ServiceType = rs.ServiceTemplate.Name, ClientName = rs.Client.Name }; foreach (var record in records.ToArray()) { //Get destination information from LocationField var destination = record.RecurringService.ServiceTemplate.GetDestination(); var locationName = ""; var address = ""; if (destination != null) { locationName = destination.Name; address = destination.AddressLineOne; } var repeat = record.RecurringService.Repeat; //Select proper end date info var endDate = ""; if (repeat.EndDate.HasValue) endDate = repeat.EndDate.Value.ToShortDateString(); else if (repeat.EndAfterTimes.HasValue) endDate = repeat.EndAfterTimes.Value.ToString(); #region setup RepeatOn string var frequency = repeat.Frequency; var repeatOn = ""; if (frequency == Frequency.Weekly) { var weeklyFrequencyDetail = repeat.FrequencyDetailAsWeeklyFrequencyDetail; //Build a weekly frequency string if (weeklyFrequencyDetail.Any(fd => fd == DayOfWeek.Sunday)) repeatOn += "Sun"; if (weeklyFrequencyDetail.Any(fd => fd == DayOfWeek.Monday)) { if (repeatOn.ToCharArray().Any()) repeatOn += ","; repeatOn += "Mon"; } if (weeklyFrequencyDetail.Any(fd => fd == DayOfWeek.Tuesday)) { if (repeatOn.ToCharArray().Any()) repeatOn += ","; repeatOn += "Tues"; } if (weeklyFrequencyDetail.Any(fd => fd == DayOfWeek.Wednesday)) { if (repeatOn.ToCharArray().Any()) repeatOn += ","; repeatOn += "Wed"; } if (weeklyFrequencyDetail.Any(fd => fd == DayOfWeek.Thursday)) { if (repeatOn.ToCharArray().Any()) repeatOn += ","; repeatOn += "Thur"; } if (weeklyFrequencyDetail.Any(fd => fd == DayOfWeek.Friday)) { if (repeatOn.ToCharArray().Any()) repeatOn += ","; repeatOn += "Fri"; } if (weeklyFrequencyDetail.Any(fd => fd == DayOfWeek.Saturday)) { if (repeatOn.ToCharArray().Any()) repeatOn += ","; repeatOn += "Sat"; } } else if (frequency == Frequency.Monthly) { var monthlyFrequencyDetail = repeat.FrequencyDetailAsMonthlyFrequencyDetail; if (monthlyFrequencyDetail.HasValue) repeatOn = monthlyFrequencyDetail.Value == MonthlyFrequencyDetail.OnDayInMonth ? "Date" : "Day"; else repeatOn = "Date"; } #endregion //Convert frequency detail to: day or date //"Service Type", "Client", "Location", "Address", "Frequency" csvWriter.WriteDataRecord(record.ServiceType, record.ClientName, locationName, address, frequency.ToString(), //"Start Date", "End Date", "Repeat Every", "Repeat On" repeat.StartDate.ToShortDateString(), endDate, repeat.RepeatEveryTimes.ToString(), repeatOn); } csvWriter.Close(); var csv = memoryStream.ToArray(); memoryStream.Dispose(); return csv; }
public void write_csv_throws_if_object_to_string_converter_is_null() { var writer = new CsvWriter(new StringWriter()); Assert.Throws<ArgumentNullException>(() => new List<DateTime>().WriteCsv(writer, true, new string[] { "Date" }, null)); }
/// <summary> /// Converts the DataTable to a CSV. /// </summary> /// <param name="alternateHeaders">The alternate headers.</param> /// <param name="columnsIndexesToIgnore">The columns indexes to ignore.</param> /// <returns>A byte[] CSV.</returns> public byte[] ToCSV(IEnumerable<string> alternateHeaders = null, IEnumerable<int> columnsIndexesToIgnore = null) { var memoryStream = new MemoryStream(); var csvWriter = new CsvWriter(memoryStream); var columnsToTake = this.Columns.Select(c => c.ColumnName).ToList(); //Remove any column indexes to ignores if (columnsIndexesToIgnore != null) foreach (var columnIndexToIgnore in columnsIndexesToIgnore.OrderByDescending(ci => ci)) columnsToTake.RemoveAt(columnIndexToIgnore); //If alternateHeaders is not null use them for the header record //Otherwise use the datatable's column names for the header record csvWriter.WriteHeaderRecord(alternateHeaders.ToArray() ?? columnsToTake.ToArray()); foreach (var row in this.Rows) { var rowValues = columnsToTake.Select(column => row[column]).ToArray(); csvWriter.WriteDataRecord(rowValues); } csvWriter.Close(); var csv = memoryStream.ToArray(); memoryStream.Dispose(); return csv; }
public async Task write_csv_async_uses_object_to_string_converter_if_specified() { using (var stringWriter = new StringWriter()) using (var writer = new CsvWriter(stringWriter)) { writer.NewLine = "<EOL>"; var items = new TestType2[] { new TestType2 { Property1 = "1", Property2 = 2d, Property3 = 3, Property4 = 4m }, new TestType2 { Property1 = "5", Property2 = 6d, Property3 = 7, Property4 = 8m } }; await items.WriteCsvAsync(writer, true, new string[] { "Property1", "Property2" }, o => o.ToString() + "_SUFFIX"); Assert.Equal("Property1,Property2<EOL>1_SUFFIX,2_SUFFIX<EOL>5_SUFFIX,6_SUFFIX<EOL>", stringWriter.ToString()); } }
/// <summary> /// Gets the locations CSV for a role. /// </summary> /// <param name="roleId">The role id.</param> /// <param name="clientId">The optional client id filter.</param> /// <param name="regionId">The optional region id filter.</param> /// <returns></returns> public byte[] GetLocationsCSVForRole(Guid roleId, Guid clientId, Guid regionId) { var businessAccount = ObjectContext.Owner(roleId).First(); var memoryStream = new MemoryStream(); var csvWriter = new CsvWriter(memoryStream); csvWriter.WriteHeaderRecord("Client", "Location", "Address 1", "Address 2", "City", "State", "Country Code", "Zip Code", "Region", "Latitude", "Longitude"); var locations = ObjectContext.Locations.Where(loc => loc.BusinessAccountId == businessAccount.Id && !loc.BusinessAccountIdIfDepot.HasValue); //Add client context if it exists if (clientId != Guid.Empty) locations = locations.Where(loc => loc.ClientId == clientId); //Add region context if it exists if (regionId != Guid.Empty) locations = locations.Where(loc => loc.RegionId == regionId); var records = from loc in locations //Get the Clients names join c in ObjectContext.Clients on loc.Client.Id equals c.Id orderby loc.AddressLineOne select new { ClientName = c.Name, loc.Name, loc.AddressLineOne, loc.AddressLineTwo, loc.AdminDistrictTwo, loc.AdminDistrictOne, loc.PostalCode, loc.CountryCode, RegionName = loc.Region.Name, loc.Latitude, loc.Longitude }; foreach (var record in records.ToArray()) csvWriter.WriteDataRecord(record.ClientName, record.Name, record.AddressLineOne, record.AddressLineTwo, record.AdminDistrictTwo, record.AdminDistrictOne, record.PostalCode, record.CountryCode, record.RegionName, record.Latitude, record.Longitude); csvWriter.Close(); var csv = memoryStream.ToArray(); memoryStream.Dispose(); return csv; }
public async Task write_csv_async_returns_number_of_items_written() { using (var writer = new CsvWriter(new StringWriter())) { writer.WriteRecord("some", "record"); var items = new TestType1[] { new TestType1 { Property1 = "1", Property2 = "2", Property3 = "3" }, new TestType1 { Property1 = "4", Property2 = "5", Property3 = "6" } }; Assert.Equal(2, await items.WriteCsvAsync(writer)); Assert.Equal(2, await items.WriteCsvAsync(writer, false)); } }