public static async void Run(int delay, bool dispalyP2P)
{
var paths = new[]
{
@".\Homework\Class 3\Test Data\1-240-12.csv",
@".\Homework\Class 3\Test Data\233-12.csv",
@".\Homework\Class 3\Test Data\239-12.csv"
};
foreach (var path in paths)
{
try
{
Console.Clear();
Console.WriteLine($"# File: {Path.GetFileName(path)}");
var csv = CommaSeparatedValues <PressureNode> .Load(
csvFilePath : path,
converter : x => new PressureNode(TimeSpan.FromSeconds(double.Parse(x[0])), double.Parse(x[1])));
var analyzer = new PressureAnalyzer(new QuickSort <PressureNode>(x => (decimal)x.TimeStamp.TotalMilliseconds));
var result = analyzer.Analyze(csv);
Console.WriteLine(result.PrettyPrint(dispalyP2P));
await Task.Delay(delay);
}
catch (Exception e)
{
Debug.WriteLine(e);
}
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in CommaSeparatedValues.GetEntries(payload.Data))
{
string csvString = CommaSeparatedValues.GetValue(entry);
if (string.IsNullOrEmpty(csvString))
{
yield break;
}
var values = csvString.Split(',');
NumberOfElementsTarget.SetValue(values.Length, entry);
foreach (var value in values)
{
SingleEntryTarget.SetValue(value, entry);
var iterator = PerEntryState.Transmit(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
}
}
/// <summary>
/// Query
/// </summary>
public static IEnumerable <string[]> Query(string dataset, string apiKey, int version)
{
if (null == dataset)
{
throw new ArgumentNullException(nameof(dataset));
}
else if (version <= 0)
{
version = 3;
}
string address = $"https://www.quandl.com/api/v{version}/datasets/{dataset}.csv";
if (string.IsNullOrEmpty(apiKey))
{
apiKey = ApiKey;
}
if (!string.IsNullOrEmpty(apiKey))
{
address += $"?api_key={apiKey}";
}
HttpClient httpClient = Dependencies.GetServiceRequired <HttpClient>();
using var response = httpClient.GetAsync(address).Result;
using Stream stream = response.Content.ReadAsStreamAsync().Result;
foreach (var record in CommaSeparatedValues.ParseCsv(stream, ',', '"', Encoding.UTF8))
{
yield return(record);
}
}
/// <summary>
/// Query
/// </summary>
public static async Task <string[][]> QueryAsync(string dataset, string apiKey, int version)
{
if (null == dataset)
{
throw new ArgumentNullException(nameof(dataset));
}
else if (version <= 0)
{
version = 3;
}
string address = $"https://www.quandl.com/api/v{version}/datasets/{dataset}.csv";
if (string.IsNullOrEmpty(apiKey))
{
apiKey = ApiKey;
}
if (!string.IsNullOrEmpty(apiKey))
{
address += $"?api_key={apiKey}";
}
HttpClient httpClient = Dependencies.GetServiceRequired <HttpClient>();
using var response = await httpClient.GetAsync(address).ConfigureAwait(false);
using Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(await Task <string[][]> .Run(() => CommaSeparatedValues
.ParseCsv(stream, ',', '"', Encoding.UTF8)
.ToArray()).ConfigureAwait(false));
//return CommaSeparatedValues.ParseCsv(stream, ',', '"', Encoding.UTF8).ToArray();
}
/// <summary>
/// Read Csv
/// </summary>
public static async IAsyncEnumerable <string[]> ReadCsvAsync(string address,
Encoding encoding = null,
char delimiter = ',',
char quotation = '"',
[EnumeratorCancellation] CancellationToken token = default)
{
if (address is null)
{
throw new ArgumentNullException(nameof(address));
}
encoding ??= Encoding.Default;
using Stream stream = await Client.GetStreamAsync(address, token).ConfigureAwait(false);
using StreamReader reader = new(stream, encoding, true, -1, true);
IEnumerable <string> Lines()
{
for (string line = reader.ReadLine(); line is not null; line = reader.ReadLine())
{
token.ThrowIfCancellationRequested();
yield return(line);
}
}
foreach (string[] record in CommaSeparatedValues.ParseCsv(Lines(), delimiter, quotation))
{
token.ThrowIfCancellationRequested();
yield return(record);
}
}
static void Main(string[] args)
{
List <Process> list = Process.GetProcesses().ToList();
DataTable dt = CollectionHelper.ConvertToDataTable(list);
string result = CommaSeparatedValues.ConvertDataTableToCsv(dt, ';', true);
DataSet ds = Database.ExecuteQuery("System.Data.OleDb",
@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Users\ima\Desktop\Ressourcenplanung\Ressourcenplanung.mdb",
"SELECT * FROM tPlan WHERE Ausfuhrender = 'IMA' ORDER BY Status");
}
static void Main(string[] args)
{
//validate input parameters
if (!ValidateParamsLength(args))
{
return;
}
//read input parameters
string path = args[0];
int filterColumnIndex = 0;
string filterColumnValue = null;
if (args.Length == 3)
{
if (!Int32.TryParse(args[1], out filterColumnIndex) || filterColumnIndex < 1)
{
ReportError($"Param {filterColumnIndexParamName} must be an integer, starting from 1.");
return;
}
filterColumnValue = args[2];
}
try
{
//read file
CSVFileParser parser = new CSVFileParser(path);
CommaSeparatedValues csvData = parser.Read();
//output to console depending on input parameters
if (filterColumnValue == null)
{
Console.Write(csvData.ToString());
}
else
{
//validate filterColumnIndex
if (filterColumnIndex < 1 || filterColumnIndex > csvData.ColumnsCount)
{
throw new IndexOutOfRangeException(string.Format("{0} is out of range.", nameof(filterColumnIndex)));
}
int filterColumnIndex0Based = filterColumnIndex - 1;
Console.Write(csvData.ToString(filterColumnIndex0Based, filterColumnValue));
}
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(string.Format("Error during processing. Exception message: {0} ", ex.Message));
}
}
static void Main(string[] args)
{
string commaSeparatedSample = "a,b,c,d,efg";
CommaSeparatedValues commaSeparatedValues = new CommaSeparatedValues(commaSeparatedSample);
Console.WriteLine(commaSeparatedValues);
List <string> list = new List <string>();
list.Add("Fred");
}
public void ConvertDataTableToCsvTest()
{
// Arrange
List <Process> list = Process.GetProcesses().ToList();
DataTable dt = CollectionHelper.ConvertToDataTable(list);
// Act
string result = CommaSeparatedValues.ConvertDataTableToCsv(dt, ';', true);
// Assert
}
public void TestRead(string inputFilePath, string[][] expectedCSVFields, Encoding encoding)
{
CSVFileParser parser = new CSVFileParser(Path.Combine(Helper.GetAssemblyPath(), inputFilePath), encoding);
CommaSeparatedValues csv = parser.Read();
Assert.AreEqual(expectedCSVFields.Length > 0 ? expectedCSVFields[0].Length : 0, csv.ColumnsCount);
Assert.AreEqual(expectedCSVFields.Length, csv.RowsCount);
for (int i = 0; i < expectedCSVFields.Length; i++)
{
for (int j = 0; j < expectedCSVFields[i].Length; j++)
{
Assert.AreEqual(expectedCSVFields[i][j], csv.GetField(i, j));
}
}
}
protected override void OnProcessOutputSchema(MutableObject newSchema)
{
var csv = CommaSeparatedValues.GetFirstValue(newSchema);
int csvFirst = 0;
if (!int.TryParse(csv, out csvFirst))
{
csvFirst = csv.Contains(',')
? int.Parse(csv.Split(',').First())
: int.Parse(csv.Split('.').First());
}
SingleEntryTarget.SetValue(csvFirst, newSchema);
NumberOfElementsTarget.SetValue(1, newSchema);
Router.TransmitAllSchema(newSchema);
}
public void TestGetRow(string[][] inputValues, int columnIndex, string fieldValue, string[] expectedResult)
{
//init CSV
CommaSeparatedValues csv = new CommaSeparatedValues();
for (int i = 0; i < inputValues.Length; i++)
{
csv.AddRow(inputValues[i].ToList <string>());
}
List <string> actualResult = csv.GetRow(columnIndex, fieldValue);
Assert.AreEqual(expectedResult.Length, actualResult.Count);
for (int i = 0; i < expectedResult.Length; i++)
{
Assert.AreEqual(expectedResult[i], actualResult[i]);
}
}
public CommaSeparatedValuesDebuggerProxy(CommaSeparatedValues commaSeparatedValues)
{
m_commaSeparatedValues = commaSeparatedValues;
}
public CommaSeparatedValuesBinderAdapter(CommaSeparatedValues <string> model)
{
this.model = model;
}
