public void LoadCsv()
{
using (var csv = new CachedCsvReader(new StreamReader("data.csv"), false))
{
csv.Columns.Add(new Column {
Name = "PriceDate", Type = typeof(DateTime)
});
csv.Columns.Add(new Column {
Name = "OpenPrice", Type = typeof(decimal)
});
csv.Columns.Add(new Column {
Name = "HighPrice", Type = typeof(decimal)
});
csv.Columns.Add(new Column {
Name = "LowPrice", Type = typeof(decimal)
});
csv.Columns.Add(new Column {
Name = "ClosePrice", Type = typeof(decimal)
});
csv.Columns.Add(new Column {
Name = "Volume", Type = typeof(int)
});
// Field headers will now be picked from the Columns collection
//csv.Dump();
//csv[]
}
}
public static IEnumerable <Code> ParseUnlocodecsv(StreamReader reader)
{
using (var csv = new CachedCsvReader(reader, hasHeaders: true))
{
var e = new DbEnumerator(csv);
while (e.MoveNext())
{
if (e.Current == null)
{
continue;
}
var record = (IDataRecord)e.Current;
if (record.FieldCount == 0)
{
continue;
}
var code = new Code()
{
Country = (string)record.GetValue(1),
Location = (string)record.GetValue(2),
Name = (string)record.GetValue(3),
NameWoDiacritics = (string)record.GetValue(4),
};
yield return(code);
}
}
}
public override DataTable ReadExcel(string filepath)
{
using (CsvReader csv = new CachedCsvReader(new StreamReader(filepath)))
{
return(csv.ToTable());
}
}
public string Execute(string inputFilePath)
{
var statusMessage = string.Empty;
var conn = (SqlConnection)objSpace.Connection;
int rowCount = 0;
using (var csv = new CachedCsvReader(new StreamReader(inputFilePath), true))
using (var cmd = conn.CreateCommand())
using (var bc = new SqlBulkCopy(conn))
{
//cmd.Transaction = trn;
cmd.CommandTimeout = CashDiscipline.Common.Constants.SqlCommandTimeout;
cmd.CommandText = createSql;
cmd.ExecuteNonQuery();
bc.DestinationTableName = "#TmpApInvoiceBal";
bc.WriteToServer(csv);
cmd.CommandText = "SELECT COUNT(*) FROM #TmpApInvoiceBal";
rowCount = Convert.ToInt32(cmd.ExecuteScalar());
cmd.CommandText = persistSql;
cmd.ExecuteNonQuery();
}
statusMessage = string.Format("{0} rows processed.", rowCount);
return(statusMessage);
}
/// <summary>
/// This method takes a csv string (comma separated) and turns into a DataTable.
/// </summary>
/// <param name="csvString">The CSV string (comma separated).</param>
/// <param name="tableName">Name of the table.</param>
/// <returns></returns>
public static DataTable CsvToTable(string csvString, string tableName)
{
var dtResult = new DataTable();
dtResult.TableName = tableName;
using (var csv = new CachedCsvReader(new StringReader(csvString), true))
{
string[] headers = csv.GetFieldHeaders();
foreach (string header in headers)
{
dtResult.Columns.Add(header, typeof(string));
}
while (csv.ReadNextRecord())
{
var newRow = dtResult.NewRow();
for (int columnNumber = 0; columnNumber < headers.GetLongLength(0); columnNumber++)
{
newRow[columnNumber] = csv[columnNumber];
}
dtResult.Rows.Add(newRow);
}
}
return(dtResult);
}
/// <summary>
/// Retrieve station basic information for given year.
/// </summary>
/// <param name="year"></param>
/// <returns>If information has been successfully retrieved.</returns>
/// <remarks>The time range of climate stations are different. If there is no data in one year, the station information
/// can't be retrieved.</remarks>
private bool retrieveStationBasicInformation(int year)
{
string header = retrieveHeader(year);
if (header.Length == 0)
{
return(false);
}
using (CachedCsvReader csv = new CachedCsvReader(new StringReader(header), false))
{
if (csv.FieldCount < 2)
{
return(false);
}
csv.ReadNextRecord(); //station name
_name = csv[1];
csv.ReadNextRecord(); //province
_province = csv[1];
csv.ReadNextRecord(); //Latitude
_latitude = csv[1];
csv.ReadNextRecord(); //Lontitude
_longitude = csv[1];
csv.ReadNextRecord(); //Elevation
_elevation = csv[1];
return(true);
}
}
public static DataTable loadFromCSV(string pathName, bool isHeader, DataTable table)
{
using (CachedCsvReader csv = new CachedCsvReader(new StreamReader(pathName), false)) {
table.Load(csv);
}
return(table);
}
public static CachedCsvReader Run1(string path, int field)
{
CachedCsvReader csv = new CachedCsvReader(new StreamReader(path), false);
string s;
if (field == -1)
{
while (csv.ReadNextRecord())
{
for (int i = 0; i < csv.FieldCount; i++)
{
s = csv[i];
}
}
}
else
{
while (csv.ReadNextRecord())
{
s = csv[field];
}
}
return(csv);
}
private static DataTable ConvertCsvReaderToDataTable(CachedCsvReader csv)
{
DataTable csvDataTable = new DataTable();
String[] csvHeaders = csv.GetFieldHeaders();
if (csvHeaders.Length > 0)
{
foreach (String csvHeader in csvHeaders)
{
csvDataTable.Columns.Add(csvHeader, typeof(String));
}
}
else
{
for (int i = 0; i < csv.FieldCount; i++)
{
csvDataTable.Columns.Add(String.Format(LanguageUtil.GetCurrentLanguageString("StandardColumnLabel", className), i + 1), typeof(String));
}
}
do
{
object[] csvRow = new object[csvDataTable.Columns.Count];
for (int i = 0; i < csv.FieldCount; i++)
{
csvRow[i] = csv[i];
}
csvDataTable.Rows.Add(csvRow);
} while (csv.ReadNextRecord());
return(csvDataTable);
}
private IEnumerable <Pair> DoParse(CachedCsvReader csv, DateTime dt)
{
var pairs = new List <Pair>();
var headers = csv.GetFieldHeaders();
var symbolColumnIndex = headers
.Select((header, idx) => new { idx, header })
.Where(x => x.header.Equals("Code"))
.Select(x => x.idx)
.Single();
var rateColumnIndex = headers
.Select((header, idx) => new { idx, header })
.Where(x => x.header.Equals("Rate"))
.Select(x => x.idx)
.Single();
var rates = csv.Select(
line => new Pair()
{
Dt = dt,
BaseSymbol = "CZK",
CounterSymbol = line[symbolColumnIndex],
Rate = ParseDoubleInverted(line[rateColumnIndex])
}
).Where(
x => !double.IsNaN(x.Rate)
);
return(rates.ToArray());
}
public IEnumerable <Pair> Parse(string csv)
{
if (csv == null)
{
throw new ArgumentNullException("csv");
}
try
{
using (var reader = new StringReader(csv))
{
var dt = ParseDailyDateLine(reader.ReadLine());
using (var csvProvider = new CachedCsvReader(reader, true, '|'))
{
if (!csvProvider.HasHeaders)
{
throw new ArgumentException("csv");
}
return(DoParse(csvProvider, dt));
}
}
}
catch (Exception e)
{
log.Error(e, "CreateFromWebCsvDaily");
return(Array.Empty <Pair>());
}
}
public static void Run2(CachedCsvReader csv, int field)
{
using (csv)
{
string s;
if (field == -1)
{
while (csv.ReadNextRecord())
{
for (int i = 0; i < csv.FieldCount; i++)
{
s = csv[i];
}
}
}
else
{
while (csv.ReadNextRecord())
{
s = csv[field];
}
}
}
}
/// <summary>
/// CSV文字列読み込み
/// ※要素は全トリムされます。
/// </summary>
/// <param name="val">CSV文字列</param>
/// <param name="tableName">戻り値にセットするテーブル名</param>
/// <param name="delimiter">区切り文字</param>
/// <returns>CSVデータをDataTableとして返す。</returns>
public DataTable ReadStringCsv(string val, string tableName, char delimiter)
{
StringReader sr = new StringReader(val);
using (CachedCsvReader csvr = new CachedCsvReader(sr, true, delimiter)) {
return(CsvToDataTable(csvr, tableName, false));
}
}
private void button1_Click(object sender, EventArgs e)
{
using (CachedCsvReader csv = new CachedCsvReader(new StringReader(CsvReaderSampleData.SampleData1), true))
{
dataGrid1.DataSource = csv;
}
button2.Enabled = true;
}
private IEnumerable <Pair> DoParse(CachedCsvReader csv)
{
var rates = new List <Pair>();
var headers = csv.GetFieldHeaders();
var dateColumnIndex = headers
.Select((header, idx) => new { idx, header })
.Where(x => x.header.Equals("Date"))
.Select(x => x.idx)
.Single();
var volumes = headers
.Select(
(header, idx) => KeyValuePair.Create(idx, ParseSymbolVolume(header))
)
.Where(
x => x.Value != null &&
double.IsFinite(x.Value.Volume) &&
Math.Abs(x.Value.Volume) > double.Epsilon
)
.ToDictionary(x => x.Key, x => x.Value);
foreach (var line in csv)
{
var dt = DateTime.Parse(line[dateColumnIndex]);
for (int i = 0; i < headers.Length; ++i)
{
if (i == dateColumnIndex)
{
continue;
}
if (double.TryParse(
line[i],
NumberStyles.Any,
CultureInfo.InvariantCulture,
out double rate
)
)
{
var volume = volumes[i];
rates.Add(
new Pair()
{
BaseSymbol = volume.Symbol,
CounterSymbol = "CZK",
Rate = volume.Volume / rate,
Dt = dt
}
);
}
}
}
return(rates);
}
/// <summary>
/// CSVファイル読み込み
/// ・要素は全トリムされます。
/// ・ファイルオープン時でも読み込みます。
/// </summary>
/// <param name="csvPath">CSVファイルへのパス</param>
/// <param name="tableName">戻り値にセットするテーブル名</param>
/// <param name="delimiter">区切り文字</param>
/// <param name="enc">文字エンコード</param>
/// <param name="existsHeader">ヘッダ行が存在するか</param>
/// <returns>CSVデータをDataTableとして返す。</returns>
public DataTable ReadCsv(string csvPath, string tableName, char delimiter, Encoding enc, bool existsHeader)
{
using (FileStream fs = new FileStream(csvPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) {
using (TextReader sr = new StreamReader(fs, enc)) {
using (CachedCsvReader csvr = new CachedCsvReader(sr, existsHeader, delimiter)) {
return(CsvToDataTable(csvr, tableName, existsHeader));
}
}
}
}
public void CachedNoHeader()
{
var csv = new CachedCsvReader(new StringReader("12345678;Hello\r\n78945612;World"), false, ';');
var dgv = new System.Windows.Forms.DataGridView();
dgv.DataSource = csv;
dgv.Refresh();
}
private static List <string> GetConfigCodes(string filePath)
{
using (var csv = new CachedCsvReader(new StreamReader(filePath), true))
{
//column 15 is the config code
return(csv.Select(x => x[15])
.Where(x => !string.IsNullOrWhiteSpace(x))
.ToList());
}
}
protected override void readCSVFile(CachedCsvReader csv)
{
#if (UseHeaders)
#else
int persIDIndex = _PersIDIndex;
int codeIndex = _CodeIndex;
int codeNameIndex = _CodeNameIndex;
int beginTimeIndex = _BeginTimeIndex;
int endTimeIndex = _EndTimeIndex;
#endif
Dictionary <string, ImportFileLongTimeAbsenceData> data = new Dictionary <string, ImportFileLongTimeAbsenceData>();
while (csv.ReadNextRecord())
{
csvDataNextRow();
short code = short.Parse(csv[codeIndex]);
string persID = csv[persIDIndex];
DateTime beginTime = DateTime.ParseExact(csv[beginTimeIndex], "yyyyMMdd", null);
string endTimeStr = csv[endTimeIndex];
if (string.IsNullOrEmpty(endTimeStr))
{
endTimeStr = DateTimeSql.SmallDatetimeMaxStr;
}
DateTime endTime = DateTime.ParseExact(endTimeStr, "yyyyMMdd", null);
string key = persID + code.ToString() + beginTime.ToString() + endTime.ToString();
if (!data.ContainsKey(key))
{
ImportLongTimeAbsenceData lta = new ImportLongTimeAbsenceData();
lta.PersID = persID;
lta.BeginTime = beginTime;
lta.EndTime = endTime;
lta.Code = code;
lta.CodeName = csv[codeNameIndex];
data.Add(key, new ImportFileLongTimeAbsenceData(_CurrentRow, lta));
}
else
{
message(string.Format(GetLocalized("LongTimeAbsenceExists"), _CurrentRow, persID, code, beginTime, endTime));
}
}
csvDataEndRead();
List <ImportLongTimeAbsenceData> list = new List <ImportLongTimeAbsenceData>(data.Count);
foreach (ImportFileLongTimeAbsenceData value in data.Values)
{
list.Add(value.Data);
}
SaveDataResult saveDataResult = _EmployeeService.LongTimeAbsenceService.ImportLongTimeAbsence(list);
list = (List <ImportLongTimeAbsenceData>)saveDataResult.Data;
foreach (ImportLongTimeAbsenceData value in list)
{
string key = value.PersID.ToString() + value.Code.ToString() + value.BeginTime.ToString() + value.EndTime.ToString();
message(string.Format(GetLocalized("LongTimeAbsenceNotAssignToEmployee"), data[key].RecordNumber, value.PersID));
}
}
/// <summary>
/// 將 CSV 檔案 Import 到指定的 DataTable 中
/// </summary>
public static void CSV2DataTable(bool clear, DataTable _DataTable, string _FileName, Encoding _Encoding)
{
if (clear)
{
_DataTable.Clear();
}
using (CachedCsvReader csv = new CachedCsvReader(new StreamReader(_FileName, _Encoding), true))
{
_DataTable.Load(csv);
}
}
private void ReadMaterialsCsv()
{
// open the file which is a CSV file with headers
string CSVFile = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), Settings.Default.tablesDir, "materials.csv");
using (CachedCsvReader csv = new CachedCsvReader(new StreamReader(CSVFile), true))
{
// Field headers will automatically be used as column names
dataGridViewMaterials.DataSource = csv;
}
}
public DataTable Import(String path)
{
var dataTable = new DataTable();
using (CachedCsvReader csv = new CachedCsvReader(new StreamReader(path), true)){
int fieldCount = csv.FieldCount;
string[] headers = csv.GetFieldHeaders();
for (int i = 0; i < fieldCount; i++)
{
dataTable.Columns.Add(headers[i]);
switch (headers[i])
{
case "Lat":
dataTable.Columns[i].DataType = System.Type.GetType("System.Double");
break;
case "Lng":
dataTable.Columns[i].DataType = System.Type.GetType("System.Double");
break;
case "Date":
dataTable.Columns[i].DataType = System.Type.GetType("System.DateTime");
break;
default:
dataTable.Columns[i].DataType = System.Type.GetType("System.String");
break;
}
}
while (csv.ReadNextRecord())
{
DataRow dr = dataTable.NewRow();
for (int i = 0; i < fieldCount; i++)
{
dr[headers[i]] = csv[i].ToString().Replace("\"", "");
}
bool missing = false;
for (int i = 0; i < fieldCount; i++)
{
missing = dr[i].ToString() == "" ? true : false;
}
if (!missing)
{
dataTable.Rows.Add(dr);
}
}
}
return(dataTable);
}
public static DataTable ReadFile(string Filename = "input.txt")
{
char delimiter = '\t';
DataTable Projects = new DataTable();
// open the input file
using (var csv = new CachedCsvReader(new StreamReader(Filename), true, delimiter))
{
Projects.Load(csv);
}
return(Projects);
}
public static void GenerateRTUTagInfo(string path = @".\")
{
var overrideFile = path + "_equipmentoverrides.csv";
DataTable dt = new DataTable();
dt.Columns.Add("RTUName");
dt.Columns.Add("TagName");
dt.Columns.Add("Type");
dt.Columns.Add("Index");
dt.Columns.Add("RelayName");
dt.Columns.Add("RelayAddress");
dt.Columns.Add("ScaleFactor");
dt.Columns.Add("DeviceIndex");
var files = Directory.GetFiles(path + @"rtu\", "*.cfg");
foreach (var file in files)
{
SCD5200TagReader rtu = new SCD5200TagReader(file);
rtu.ReadIeds();
rtu.ProcessTags(dt);
}
//override the equipment from the equipment map
Dictionary <string, string> overrides = new Dictionary <string, string>();
using (CachedCsvReader csv = new CachedCsvReader(new StreamReader(new FileStream(overrideFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)), true))
{
while (csv.ReadNextRecord())
{
overrides.Add(csv["OldEquipment"], csv["NewEquipment"]);
}
}
for (int i = 0; i < dt.Rows.Count; i++)
{
string tagName = dt.Rows[i]["TagName"] as string;
string equipment = dt.Rows[i]["DeviceIndex"] as string;
if (overrides.ContainsKey(equipment))
{
dt.Rows[i]["RelayName"] = overrides[equipment];
}
else
{
//TODO: won't need this after sorting out deviceindexdebarcle
dt.Rows[i]["RelayName"] = equipment;
}
}
Util.ExportDatatable(dt, path + "_rtutaginfo.csv");
}
internal static void ReadCsv(CsvEditor form, bool withHeader, char delimiter, char quote)
{
Form1 form1 = (Form1)form.Owner;
XtraTabControl pagesTabControl = form1.pagesTabControl;
DataGridView csvGridView = form.csvGridView;
//ContextMenuStrip contentContextMenuStrip = form.contentContextMenuStrip;
Encoding textEncoding = EncodingUtil.GetDefaultEncoding();
String text = String.Empty;
if (pagesTabControl != null)
{
textEncoding = TabUtil.GetTabTextEncoding(pagesTabControl.SelectedTabPage);
text = ProgramUtil.GetPageTextBox(pagesTabControl.SelectedTabPage).Text;
}
byte[] byteArray = textEncoding.GetBytes(text);
using (MemoryStream stream = new MemoryStream(byteArray))
{
try
{
using (CachedCsvReader csv = new CachedCsvReader(new StreamReader(stream), withHeader, delimiter, quote, '\\', '#', ValueTrimmingOptions.UnquotedOnly))
{
csv.DefaultParseErrorAction = ParseErrorAction.AdvanceToNextLine;
csv.SkipEmptyLines = true;
if (String.IsNullOrEmpty(csv[0, 0]))
{
WindowManager.ShowAlertBox(form, LanguageUtil.GetCurrentLanguageString("NoResults", className));
}
//PutCsvReaderIntoDataGrid(csv, csvGridView);
csvGridView.Columns.Clear();
csvGridView.DataSource = ConvertCsvReaderToDataTable(csv);
}
//for (int i = 0; i < csvGridView.Rows.Count; i++)
//{
// for (int j = 0; j < csvGridView.Rows[i].Cells.Count; j++)
// {
// csvGridView.Rows[i].Cells[j].ContextMenuStrip = contentContextMenuStrip;
// }
//}
}
catch (Exception exception)
{
WindowManager.ShowErrorBox(form, LanguageUtil.GetCurrentLanguageString("ContentError", className), exception);
}
}
csvGridView.Refresh();
}
private bool write2FreeFormat(string resultsForOneYear, int[] fields, StreamWriter writer, bool needWriteHeader, FormatType format)
{
StringBuilder sb = new StringBuilder();
using (CachedCsvReader csv = new CachedCsvReader(new StringReader(resultsForOneYear), true))
{
if (csv.FieldCount < 27)
{
return(false);
}
string date = "";
if (needWriteHeader)
{
string[] fieldNames = csv.GetFieldHeaders();
sb.Append(formatFreeFormatData(fieldNames[0], format, true));
foreach (int field in fields)
{
if (format == FormatType.SIMPLE_CSV)
{
sb.Append(",");
}
sb.Append(formatFreeFormatData(fieldNames[field], format, false));
}
sb.AppendLine();
}
while (csv.ReadNextRecord())
{
date = csv[0];
sb.Append(formatFreeFormatData(date, format, true));
foreach (int field in fields)
{
if (format == FormatType.SIMPLE_CSV)
{
sb.Append(",");
}
sb.Append(formatFreeFormatData(csv[field], format, false));
}
sb.AppendLine();
}
checkLastDayofYear(date);
}
if (sb.Length > 0)
{
writer.Write(sb.ToString());
}
return(sb.Length > 0);
}
public ObservableCollection <ObservableCollection <CellContent> > ParseCsvStreamToData(Stream stream)
{
using (var reader = new StreamReader(stream))
{
using (var csv = new CachedCsvReader(reader, true))
{
var list = new ObservableCollection <ObservableCollection <CellContent> >();
var colCount = csv.Columns.Count;
var columnCollection = new ObservableCollection <CellContent>();
if (!csv.ReadNextRecord())
{
return(list);
}
for (var index = 0; index < csv.Columns.Count; index++)
{
Column column = csv.Columns[index];
columnCollection.Add(new CellContent(column.Name)
{
Column = index
});
}
list.Add(columnCollection);
// Field headers will automatically be used as column names
while (true)
{
columnCollection = new ObservableCollection <CellContent>();
for (int index = 0; index < csv.Columns.Count; index++)
{
var colValue = csv[index];
columnCollection.Add(new CellContent(colValue)
{
Column = index
});
}
list.Add(columnCollection);
if (!csv.ReadNextRecord())
{
break;
}
}
return(list);
}
}
}
protected override void readCSVFile(CachedCsvReader csv)
{
#if (UseHeaders)
int systemID1Index = csv.GetFieldIndex(_VLID);
int systemID2Index = csv.GetFieldIndex(_CountryID);
int countryNameIndex = csv.GetFieldIndex(_CountryName);
#else
int systemID1Index = _VLIDIndex;
int systemID2Index = _CountryIDIndex;
int countryNameIndex = _CountryNameIndex;
#endif
Dictionary <string, Country> dbCountryHash = getDBCountryListSysKey();
List <Country> importCountryList = new List <Country>();
Country country;
while (csv.ReadNextRecord())
{
csvDataNextRow();
string key = csv[systemID1Index];
if (dbCountryHash.ContainsKey(key))
{
country = dbCountryHash[key];
}
else
{
country = new Country();
country.SystemID2 = csv[systemID2Index];
}
country.Name = csv[countryNameIndex];
country.Import = true;
country.CountryLanguage = SharedConsts.NeutralLangId;
country.LanguageID = SharedConsts.NeutralLangId;
country.SystemID1 = byte.Parse(csv[systemID1Index]);
if (country.IsNew && !dbCountryHash.ContainsKey(key))
{
dbCountryHash.Add(key, country);
}
if (!importCountryList.Contains(country))
{
importCountryList.Add(country);
}
else
{
message(string.Format(GetLocalized("CountryExists"), _CurrentRow, _VLID, key));
}
}
csvDataEndRead();
SaveOrUpdateList <Country>(_IContryServise, importCountryList);
}
protected override void readCSVFile(CachedCsvReader csv)
{
_Data = new Dictionary <string, ImportFileTimeData>();
while (csv.ReadNextRecord())
{
csvDataNextRow();
string persID = csv[_PersIDIndex];
string charID = csv[_AbsenceCharIDIndex];
DateTime date = DateTime.ParseExact(csv[_DateIndex], "yyyyMMdd", null);
short begin = getTimeInMinutes(csv[_BeginIndex]);
short end = getTimeInMinutes(csv[_EndIndex]);
string key = persID.ToString() + charID + csv[_DateIndex] + begin.ToString() + end.ToString();
if (!_Data.ContainsKey(key))
{
ImportTimeData awp = new ImportTimeData();
awp.PersID = persID;
awp.CharID = charID;
awp.Date = date;
awp.Begin = begin;
awp.End = end;
_Data.Add(key, new ImportFileTimeData(_CurrentRow, awp));
}
else
{
message(
string.Format(GetLocalized("TimePlanningExists"), _CurrentRow, persID, date, charID, begin, end));
}
}
csvDataEndRead();
List <ImportTimeData> list = new List <ImportTimeData>(_Data.Count);
foreach (ImportFileTimeData value in _Data.Values)
{
list.Add(value.Data);
}
_EmployeeTimeService.OperationComplete += new OperationCompleteDelegate(employeeTimeService_OnOperationComplete);
try
{
_EmployeeTimeService.ImportTime(list, _ImportTimeType);
while (_ImportRunning)
{
Thread.Sleep(1000);
}
}
finally
{
_EmployeeTimeService.OperationComplete -= new OperationCompleteDelegate(employeeTimeService_OnOperationComplete);
}
}
private void LoadCSVFile(String filename)
{
this.csvDisplayGrid.DataSource = null;
this.csvDisplayGrid.Columns.Clear();
this.csvDisplayGrid.Rows.Clear();
lock (this.flag)
{
this.queue = new List <UserState>();
this.retryQueue = new List <UserState>();
}
Stream f = File.Open(filename, FileMode.Open);
using (CachedCsvReader csv = new CachedCsvReader(new StreamReader(f, Encoding.UTF8), true))
{
this.csvDisplayGrid.DataSource = csv;
while (this.csvDisplayGrid.Columns.Count > COLUMN_MAX)
{
this.csvDisplayGrid.Columns.RemoveAt(6);
}
if (this.csvDisplayGrid.Columns.Count != COLUMN_MAX)
{
MessageBox.Show("The file " + filename + " is not in the correct format");
this.csvDisplayGrid.DataSource = null;
}
}
// now add a status column
DataGridViewColumn status = new DataGridViewColumn();
status.Name = "Upload Status";
status.CellTemplate = new DataGridViewTextBoxCell();
this.csvDisplayGrid.Columns.Add(status);
DataGridViewColumn vid = new DataGridViewColumn();
vid.Name = "Video ID";
vid.CellTemplate = new DataGridViewTextBoxCell();
this.csvDisplayGrid.Columns.Add(vid);
this.Upload.Enabled = true;
SetTitle();
Trace.TraceInformation("Loaded csv file: " + filename + "successfully");
}
