private async Task <int> ExportDepositAddressesAsync(
string settingsUrl)
{
#region RegisterDependencies
var appSettings = _helper.GetCurrentSettingsFromUrl(settingsUrl);
var(resolver, consoleLogger) = _helper.GetResolver(appSettings);
#endregion
string hotWalletAddress = appSettings.CurrentValue.Ethereum.HotwalletAddress;
var transferContractRepository =
(IErc223DepositContractRepository)resolver.ResolveKeyed(Constants.DefaultKey,
typeof(IErc223DepositContractRepository));
string continuationToken = null;
await consoleLogger.WriteInfoAsync(nameof(ExportDepositAddressesAsync),
"", $"Begin export");
using (var writer = new StreamWriter("exportedDeposits.csv"))
using (var csvWriter = new CsvHelper.CsvWriter(writer))
{
csvWriter.WriteHeader <DepositRecord>();
csvWriter.NextRecord();
var record = new DepositRecord {
Address = hotWalletAddress
};
csvWriter.WriteRecord(record);
csvWriter.NextRecord();
do
{
var(collection, token) = await transferContractRepository.GetByTokenAsync(100, continuationToken);
continuationToken = token;
foreach (var depositContract in collection)
{
var newRecord = new DepositRecord {
Address = depositContract.ContractAddress
};
csvWriter.WriteRecord(newRecord);
csvWriter.NextRecord();
}
} while (!string.IsNullOrEmpty(continuationToken));
}
await consoleLogger.WriteInfoAsync(nameof(ExportDepositAddressesAsync),
"", $"Export is completed");
return(0);
}
protected override void OutBlock(ResModel resModel, IXAQuery query, CsvHelper.CsvWriter writer)
{
var szTrCode = resModel.Name;
var block = resModel.Blocks[szTrCode + "OutBlock"];
writer.WriteHeader <_t9942OutBlock>();
for (var i = 0; i < query.GetBlockCount(block.Name); i++)
{
var result = new _t9942OutBlock()
{
hname = query.GetFieldData(block.Name, "hname", i),
shcode = query.GetFieldData(block.Name, "shcode", i),
expcode = query.GetFieldData(block.Name, "expcode", i),
};
writer.NextRecord();
writer.WriteRecord(result);
Constants.CodeElws.Add(result.shcode, new CodeElw()
{
UnderlyingAssetsCategory = "",
UnderlyingAssetsCode = "",
Name = result.hname,
Code = result.shcode,
ExpandedCode = result.expcode,
});
}
}
private static void po2csv(string poPath, string csvPath)
{
try
{
var items = PoReader.GetItems(poPath);
using (StreamWriter streamWriter = new StreamWriter(csvPath))
{
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter))
{
foreach (var item in items)
{
csvWriter.WriteRecord(item);
}
}
}
Console.WriteLine("Convert to CSV file successfully.");
}
catch (PoConvert.Exception.InvalidFormatException e)
{
Console.WriteLine("[ERROR] {0}", e.Message);
}
catch (FileNotFoundException e)
{
Console.WriteLine(e.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
}
}
protected override void OutBlock(ResModel resModel, IXAQuery query, CsvHelper.CsvWriter writer)
{
var szTrCode = resModel.Name;
var block1 = resModel.Blocks[szTrCode + "OutBlock1"];
writer.WriteHeader <_t9905OutBlock1>();
for (var i = 0; i < query.GetBlockCount(szTrCode + "OutBlock1"); i++)
{
var result = new _t9905OutBlock1()
{
shcode = query.GetFieldData(block1.Name, "shcode", i),
expcode = query.GetFieldData(block1.Name, "expcode", i),
hname = query.GetFieldData(block1.Name, "hname", i),
};
writer.NextRecord();
writer.WriteRecord(result);
Constants.CodeElwBases.Add(result.shcode, new CodeElwBase()
{
Name = result.hname,
Code = result.shcode,
ExpandedCode = result.expcode,
});
}
}
private void button1_Click(object sender, EventArgs e)
{
List <Musteri> musterilerim = new List <Musteri>();
for (int i = 0; i < 50; i++)
{
Musteri temp = new Musteri();
temp.ID = i;
temp.Adi = FakeData.NameData.GetFirstName();
temp.Soyadi = FakeData.NameData.GetSurname();
temp.Email = $"{temp.Adi}.{temp.Soyadi}@{FakeData.NetworkData.GetDomain()}";
temp.Tel = FakeData.PhoneNumberData.GetPhoneNumber();
musterilerim.Add(temp);
}
if (!Directory.Exists("D:\\CSV\\Dosyam"))
{
Directory.CreateDirectory("D:\\CSV\\Dosyam");
}
StreamWriter sw = new StreamWriter("D:\\CSV\\Dosyam\\yeni", true);
CsvHelper.CsvWriter writer = new CsvHelper.CsvWriter(sw);
writer.WriteHeader(typeof(Musteri));
foreach (Musteri item in musterilerim)
{
writer.WriteRecord(item);
}
sw.Close();
MessageBox.Show("Tamamlandı");
}
public void TranslateDirectory(string path)
{
foreach (var kvp in GetTranslationsFromDirectory(path))
{
var fileName = kvp.Key;
var translations = kvp.Value;
var output = Path.Combine(path, $"{fileName}.csv");
using (var file = File.OpenWrite(output))
{
using (var writer = new StreamWriter(file, _encoding))
{
using (var csvWriter = new CsvHelper.CsvWriter(writer, new Configuration {
HasHeaderRecord = false, QuoteAllFields = true
}))
{
foreach (var translation in translations)
{
csvWriter.WriteRecord(translation);
csvWriter.NextRecord();
}
}
}
}
}
}
protected override void OutBlock(ResModel resModel, IXAQuery query, CsvHelper.CsvWriter writer)
{
var szTrCode = resModel.Name;
var block = resModel.Blocks[szTrCode + "OutBlock"];
writer.WriteHeader <_t8401OutBlock>();
for (var i = 0; i < query.GetBlockCount(block.Name); i++)
{
var result = new _t8401OutBlock()
{
hname = query.GetFieldData(block.Name, "hname", i),
shcode = query.GetFieldData(block.Name, "shcode", i),
expcode = query.GetFieldData(block.Name, "expcode", i),
basecode = query.GetFieldData(block.Name, "basecode", i),
};
writer.NextRecord();
writer.WriteRecord(result);
Constants.CodeFutures.Add(result.shcode, new CodeFutures()
{
UnderlyingAssetsCategory = "STOCK",
UnderlyingAssetsCode = result.basecode,
Name = result.hname,
Code = result.shcode,
ExpandedCode = result.expcode,
//TODO Listing, Expirationdate
ListingDate = "",
ExpirationDate = "",
});
}
}
private void btnWrite_Click(object sender, EventArgs e)
{
using (SaveFileDialog sfd = new SaveFileDialog()
{
Filter = "CSV|*.csv", ValidateNames = true
})
{
if (sfd.ShowDialog() == DialogResult.OK)
{
using (var sw = new StreamWriter(sfd.FileName))
{
var csvWriter = new CsvHelper.CsvWriter(sw);
csvWriter.WriteHeader(typeof(Student));
csvWriter.NextRecord();
// Method 1
//foreach (Student s in studentBindingSource.DataSource as List<Student>)
//{
// csvWriter.WriteRecord(s);
// csvWriter.NextRecord();
//}
// Method 2
foreach (Student s in studentBindingSource.List)
{
csvWriter.WriteRecord(s);
csvWriter.NextRecord();
}
}
MessageBox.Show("Your data has been successfully saved", "Message", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
private static string WriteToFile(List <Tweet> tweets, string startDate, string endDate, string dataType)
{
var csvFilePath = $"/Users/{Environment.UserName}/Desktop/{dataType}_{startDate.ReplaceAll("/","-")}-{endDate.ReplaceAll("/", "-")}.csv".MapAbsolutePath();
using (var writer = new StreamWriter(csvFilePath))
using (var csv = new CsvHelper.CsvWriter(writer, CultureInfo.InvariantCulture))
{
csv.WriteHeader <Tweet>();
csv.NextRecord();
foreach (var tweet in tweets)
{
Tweet extendedTweet = tweet;
extendedTweet.MediaData.ForEach(media =>
{
extendedTweet.MediaDataUrl = media.url;
extendedTweet.MediaTitle = media.title;
extendedTweet.MediaDescription = media.description;
});
extendedTweet.ReferencedTweets.ForEach(reference =>
{
extendedTweet.ReferencedTweetId = reference.Id;
extendedTweet.ReferencedTweetType = reference.Type;
});
csv.WriteRecord(extendedTweet);
csv.NextRecord();
}
}
return(csvFilePath);
}
public static void WriteCSV <T>(IEnumerable <T> simulationResults, string fileName)
{
var csvFilePath = Path.Combine(Directory.GetCurrentDirectory(), fileName);
Console.WriteLine(csvFilePath);
using (var fileStream = new FileStream(csvFilePath, FileMode.Create))
{
using (var writer = new StreamWriter(fileStream, Encoding.UTF8))
{
using (var csvWriter = new CsvHelper.CsvWriter(writer))
{
csvWriter.WriteHeader <T>();
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
foreach (var result in simulationResults)
{
csvWriter.WriteRecord(result);
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
}
}
}
}
}
private static void po2csv(string poPath, string csvPath)
{
try
{
var items = PoReader.GetItems(poPath);
using (StreamWriter streamWriter = new StreamWriter(csvPath))
{
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter))
{
foreach (var item in items)
{
csvWriter.WriteRecord(item);
}
}
}
Console.WriteLine("Convert to CSV file successfully.");
}
catch (PoConvert.Exception.InvalidFormatException e)
{
Console.WriteLine("[ERROR] {0}", e.Message);
}
catch (FileNotFoundException e)
{
Console.WriteLine(e.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
}
}
private void WriteScheduledBookings(string scheduleId, DateTime scheduledTimeUTC, IEnumerable <string> bookingIds)
{
var unschBookings = LoadUnscheduledBookings();
foreach (var bookingId in bookingIds)
{
using (var f = File.Open(Path.Combine(CSVBasePath, Path.Combine(ScheduledBookingsPath, bookingId + ".csv")), FileMode.Create))
using (var stream = new StreamWriter(f))
using (var csv = new CsvHelper.CsvWriter(stream, CultureInfo.InvariantCulture))
{
csv.Configuration.TypeConverterOptionsCache.GetOptions <DateTime>().Formats
= new string[] { "yyyy-MM-ddTHH:mm:ssZ" };
csv.WriteHeader <ScheduledBookingCsvRow>();
csv.NextRecord();
if (unschBookings.ContainsKey(bookingId))
{
foreach (var p in unschBookings[bookingId].Parts)
{
csv.WriteRecord(new ScheduledBookingCsvRow
{
ScheduledTimeUTC = scheduledTimeUTC,
Part = p.Part,
Quantity = p.Quantity,
ScheduleId = scheduleId
});
csv.NextRecord();
}
}
else
{
csv.WriteRecord(new ScheduledBookingCsvRow
{
ScheduledTimeUTC = scheduledTimeUTC,
Part = "",
Quantity = 0,
ScheduleId = scheduleId
});
csv.NextRecord();
}
stream.Flush();
//f.Flush(true);
f.Flush();
}
}
}
public static void WriteToCsv(List <double> data, string path)
{
using (TextWriter textWriter = File.CreateText(path))
{
var csv = new CsvHelper.CsvWriter(textWriter);
foreach (var item in data)
{
csv.WriteRecord(item);
}
}
}
public string Serialize <tEntity>(tEntity entity) where tEntity : BaseEntity
{
using (TextWriter writer = new StringWriter())
{
using (CsvHelper.CsvWriter writerCsv = new CsvHelper.CsvWriter(writer))
{
writerCsv.WriteRecord(entity);
}
return(writer.ToString());
}
}
public void WriteAll(StreamWriter stream, IEnumerable <CityEvent> events)
{
using (var ww = new CsvHelper.CsvWriter(stream, _conf))
{
ww.WriteHeader <CityEvent>();
foreach (var el in events)
{
ww.WriteRecord(el);
}
}
}
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>();
foreach (var invoice in invoices)
{
csvWriter.WriteRecord(invoice);
}
csvWriter.Flush();
return(writer.ToString());
}
public static void WriteToCSV <T>(string path, bool append, List <T> modelList)
{
using (StreamWriter stream = new StreamWriter(path, append))
{
using (CsvHelper.CsvWriter cw = new CsvHelper.CsvWriter(stream))
{
for (int i = 0; i < modelList.Count; i++)
{
cw.WriteRecord(modelList[i]);
cw.NextRecord();
}
}
}
}
protected override void OutBlock(ResModel resModel, IXAQuery query, CsvHelper.CsvWriter writer)
{
var szTrCode = resModel.Name;
var block = resModel.Blocks[szTrCode + "OutBlock"];
writer.WriteHeader <_t8424OutBlock>();
for (var i = 0; i < query.GetBlockCount(block.Name); i++)
{
//LOG.Debug($"trCountLimit : {query.GetTRCountLimit(szTrCode)}, trCountRequest : {query.GetTRCountRequest(szTrCode)}, trCountBaseSec : {query.GetTRCountBaseSec(szTrCode)}, trCountPerSec : {query.GetTRCountPerSec(szTrCode)}");
var result = new _t8424OutBlock()
{
hname = query.GetFieldData(block.Name, "hname", i),
upcode = query.GetFieldData(block.Name, "upcode", i),
};
writer.NextRecord();
writer.WriteRecord(result);
string category;
switch (_inBlock.gubun1)
{
case "1":
category = "KOSPI";
break;
case "2":
category = "KOSDAQ";
break;
case "3":
category = "KRX";
break;
case "4":
category = "ETC";
break;
default:
category = "ALL";
//TODO error
break;
}
Constants.CodeSectors.Add(result.upcode, new CodeSector()
{
Category = category,
Name = result.hname,
Code = result.upcode,
});
}
}
public static HttpResponseMessage Export <T>(List <T> list, Type classMapType, string fileName, bool hasHeader = true)
{
CsvHelper.Configuration.CsvConfiguration csvCommonConfiguration = new CsvHelper.Configuration.CsvConfiguration
{
Delimiter = ",",
HasHeaderRecord = hasHeader
};
MemoryStream ms = new MemoryStream();
StreamWriter swriter = new StreamWriter(ms, Encoding.GetEncoding("windows-1252"));
var csv = new CsvHelper.CsvWriter(swriter, csvCommonConfiguration);
csv.Configuration.RegisterClassMap(classMapType);
if (hasHeader)
{
csv.WriteHeader <T>();
}
for (int i = 0; i < list.Count; i++)
{
try
{
csv.WriteRecord(list[i]);
}
catch (Exception ex)
{
#region Logging
if (logger.IsErrorEnabled)
{
logger.Error(string.Format("L'export de la ligne {0} a échoué", i), ex);
}
#endregion Logging
}
}
//Flush du writer et remise à zéro du pointeur de lecture du stream
swriter.Flush();
ms.Position = 0;
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StreamContent(ms);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
response.Content.Headers.ContentDisposition.FileName = fileName;
return(response);
}
public void WriteCSVFile(string fileName, List <IInstruction> fileContents, StringCollection fileStrings)
{
fileName = Path.Combine(Path.GetDirectoryName(fileName), Path.GetFileNameWithoutExtension(fileName) + ".csv");
DirectoryGuard.CheckDirectory(fileName);
FileStream fs = new FileStream(fileName, FileMode.Create);
StreamWriter sw = new StreamWriter(fs);
var csv = new CsvHelper.CsvWriter(sw);
csv.Configuration.RegisterClassMap <CSVRecordMap>();
csv.WriteHeader <CSVRecord>();
csv.NextRecord();
string lastSpeaker = "";
foreach (var instruction in fileContents)
{
if (instruction is IHasStrings)
{
var temp = instruction as IHasStrings;
List <CSVRecord> csvRecords = temp.GetCSVRecords();
foreach (var record in csvRecords)
{
record.originalText = fileStrings.GetString(record.stringID);
if (record.speaker != lastSpeaker)
{
lastSpeaker = record.speaker;
}
else
{
record.speaker = ""; // blank out the name of the speaker if it is being repeated to make it easier to note when speaker changes and avoid massive walls of speakers text
}
csv.WriteRecord(record);
csv.NextRecord();
}
}
}
csv.Flush();
sw.Close();
fs.Close();
}
static void Main(string[] args)
{
List <Musteri> musterilerim = new List <Musteri>();
for (int i = 0; i < 50; i++)
{
Musteri m1 = new Musteri();
m1.ID = Guid.NewGuid();
m1.Isim = FakeData.NameData.GetFirstName();
m1.Soyisim = FakeData.NameData.GetSurname();
m1.Telefonnumarasi = FakeData.PhoneNumberData.GetPhoneNumber();
m1.Emailadres = $"{m1.Isim}.{m1.Soyisim}@{FakeData.NetworkData.GetDomain()}";
musterilerim.Add(m1);
}
if (Directory.Exists("C:\\CSV\\"))
{
}
else
{
Directory.CreateDirectory("C:\\CSV\\");
}
StreamReader SR = new StreamReader("C:\\CSV\\Musteriler.csv");
CsvHelper.CsvReader reader = new CsvHelper.CsvReader(SR);
List <Musteri> okunandata = reader.GetRecords <Musteri>().ToList();
StreamWriter SW = new StreamWriter("C:\\CSV\\Musteriler.csv");
CsvHelper.CsvWriter write = new CsvHelper.CsvWriter(SW);
write.WriteHeader(typeof(Musteri));
foreach (Musteri item in musterilerim)
{
write.WriteRecord(item);
}
SW.Close();
Console.WriteLine("CSV olarak kayit islemi tamamlanmistir.");
Console.WriteLine($"Toplam Adet: {musterilerim.Count}");
Console.ReadKey();
}
} // end sub
/// <summary>
/// <para xml:lang="en">Dump properties of a object to a TSV file. Output multiple objects on each rows of the TSV file.</para>
/// <para xml:lang="ja">オブジェクトのプロパティをTSVファイルにダンプします。複数のオブジェクトをTSVファイルの各行に出力します。</para>
/// </summary>
/// <typeparam name="T">
/// <para xml:lang="en">The type of object to dump.</para>
/// <para xml:lang="ja">ダンプするオブジェクトの型</para>
/// </typeparam>
/// <param name="target">
/// <para xml:lang="en">The collection of objects to dump.</para>
/// <para xml:lang="ja">ダンプするオブジェクトのコレクション</para>
/// </param>
/// <param name="name">
/// <para xml:lang="en">The name which is used for a file.</para>
/// <para xml:lang="ja">ファイルに使用される名前。</para>
/// </param>
/// <param name="format">
/// <para xml:lang="en">
/// The lambda expression which is used for choosing properties to dump.
/// Set like <code>a=>new {a.A, a.B}</code> to dump A property and B property of the object.
/// Set like <code>a=>a</code> to dump all properties of the object.
/// </para>
/// <para xml:lang="ja">
/// ダンプするプロパティを選択するラムダ式。
/// オブジェクトのAプロパティとBプロパティをダンプする場合には、<code>a=>new {a.A, a.B}</code> のように指定します。
/// 全てのプロパティをダンプする場合には<code>a=>a</code>を指定します。
/// </para>
/// </param>
/// <param name="writeHeader">
/// <para xml:lang="en">
/// Set true to output a header of a TSV file. The names of properties of the object are output.
/// Set false and so a header is not outputted. Use the DumpTsvHeader method or the WriteTsvHeader method to output the header, separately.
/// </para>
/// <para xml:lang="ja">
/// TSVファイルの1行目にヘッダを出力する場合はtrueを指定します。オブジェクトのプロパティ名が出力されます。
/// falseを指定するとヘッダが出力されません。別途、DumpTsvHeaderメソッドやWriteTsvHeaderメソッドを使用してヘッダを出力してください。
/// </para>
/// </param>
public static void DumpTsv <T>(IEnumerable <T> target, string name, Func <T, object> format, bool writeHeader = true)
{
Dumper.WriteTextFile(name, ".tsv", writer =>
{
var configuration = new CsvHelper.Configuration.Configuration {
Delimiter = "\t"
};
using (var tsv = new CsvHelper.CsvWriter(writer, configuration))
{
var isFirst = true;
foreach (var item in target)
{
var v = format(item);
if (isFirst)
{
isFirst = false;
if (writeHeader)
{
if (typeof(T) == typeof(string))
{
tsv.WriteField("string");
}
else
{
tsv.WriteHeader(v.GetType());
} // end if
tsv.NextRecord();
}
} // end if
if (typeof(T) == typeof(string))
{
tsv.WriteField(v);
}
else
{
tsv.WriteRecord(v);
} // end if
tsv.NextRecord();
} // next item
} // end using (tsv)
});
} // end sub
public async Task ConvertCsv()
{
var csvPath = @"C:\Users\sweet\Downloads\Beat Buddy Midi Drum Map - Map (1).csv";
using (var reader = new StreamReader(csvPath))
using (var writer = new StreamWriter("map.csv"))
using (var csvReader = new CsvHelper.CsvReader(reader, CultureInfo.InvariantCulture))
using (var csvWriter = new CsvHelper.CsvWriter(writer, new CsvConfiguration(CultureInfo.InvariantCulture)))
{
await csvReader.ReadAsync();
csvReader.ReadHeader();
csvWriter.WriteHeader <Record>();
await csvWriter.NextRecordAsync();
while (await csvReader.ReadAsync())
{
var inRecord = csvReader.GetRecord <dynamic>() as IDictionary <string, object>;
var keys = inRecord.Keys;
var outRecord = new Record()
{
Number = Convert.ToInt32(inRecord["Number"]),
MidiNote = Convert.ToString(inRecord["Note"]),
OctaveMiddleC3 = Convert.ToInt32(inRecord["Octave (Middle C3)"]),
OctaveMiddleC4 = Convert.ToInt32(inRecord["Octave (Middle C4)"])
};
for (var k = 4; k < keys.Count; k++)
{
var key = keys.ElementAt(k);
var value = Convert.ToString(inRecord[key]);
// if (string.IsNullOrWhiteSpace(value))
// continue;
var instrimentNote = GetInstrumentNote(value);
outRecord.Kit = key;
outRecord.Instrument = instrimentNote.Instrument;
outRecord.KitNote = instrimentNote.KitNote;
csvWriter.WriteRecord(outRecord);
await csvWriter.NextRecordAsync();
}
}
}
}
private static void CSVOluşturma()
{
List <Kullanici> Kullanicilar = new List <Kullanici>();
Kullanici k1 = new Kullanici();
k1.ID = Guid.NewGuid();
k1.Isim = "Salih";
k1.Soyisim = "SEKER";
k1.Numara = 1;
k1.Github = "github.com/salihseker";
Kullanicilar.Add(k1);
Kullanici k2 = new Kullanici();
k2.ID = Guid.NewGuid();
k2.Isim = "Kerami";
k2.Soyisim = "Ozsoy";
k2.Numara = 2;
k2.Github = "github.com/keramiozsoy";
Kullanicilar.Add(k2);
for (int i = 0; i < 10; i++)
{
Kullanicilar.Add(k1);
Kullanicilar.Add(k2);
}
// Yazma işlemi.
StreamWriter SW = new StreamWriter(@"D:\Kullanicilar.csv");
CsvHelper.CsvWriter Write = new CsvHelper.CsvWriter(SW);
Write.WriteHeader(typeof(Kullanici));
foreach (Kullanici item in Kullanicilar)
{
Write.WriteRecord(item);
}
SW.Close();
}
private static void ReMakeRecords(int playerCount)
{
var csvFilePath = Path.Combine(Directory.GetCurrentDirectory(), $"all-in-versusFold-{playerCount}players.csv");
Console.WriteLine(csvFilePath);
using (var fileStream = new FileStream(csvFilePath, FileMode.Create))
{
using (var writer = new StreamWriter(fileStream, Encoding.UTF8))
{
using (var csvWriter = new CsvHelper.CsvWriter(writer))
{
csvWriter.WriteHeader <AllInSimulation.SimulationResult>();
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
var simulation = new AllInVersusFoldBadCardsSimulation();
var simulationResults = simulation.Run(new AllInSimulation.SimulationOptions
{
ConfidenceLevel = ConfidenceLevel.L95,
WinLoseRatesDesiredRelativeError = 0.02,
BalanceDesiredAbsoluteError = 0.01,
PlayerCount = playerCount
});
var watch = Stopwatch.StartNew();
foreach (var result in simulationResults)
{
csvWriter.WriteRecord(result);
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
Console.WriteLine($"Processed {result.Card1}, {result.Card2}. Elapsed totally {watch.Elapsed}, Time: {DateTime.Now}");
}
}
}
}
}
protected override void OutBlock(ResModel resModel, IXAQuery query, CsvHelper.CsvWriter writer)
{
var szTrCode = resModel.Name;
var block = resModel.Blocks[szTrCode + "OutBlock"];
writer.WriteHeader <_t8425OutBlock>();
for (var i = 0; i < query.GetBlockCount(block.Name); i++)
{
var result = new _t8425OutBlock()
{
tmcode = query.GetFieldData(block.Name, "tmcode", i),
tmname = query.GetFieldData(block.Name, "tmname", i),
};
writer.NextRecord();
writer.WriteRecord(result);
Constants.CodeThemes.Add(result.tmcode, new CodeTheme()
{
Code = result.tmcode,
Name = result.tmname,
});
}
}
protected override void OutBlock(ResModel resModel, IXAQuery query, CsvHelper.CsvWriter writer)
{
var szTrCode = resModel.Name;
var block = resModel.Blocks[szTrCode + "OutBlock"];
writer.WriteHeader <_t8436OutBlock>();
for (var i = 0; i < query.GetBlockCount(block.Name); i++)
{
var result = new _t8436OutBlock()
{
hname = query.GetFieldData(block.Name, "hname", i),
shcode = query.GetFieldData(block.Name, "shcode", i),
expcode = query.GetFieldData(block.Name, "expcode", i),
etfgubun = query.GetFieldData(block.Name, "etfgubun", i),
uplmtprice = long.Parse(query.GetFieldData(block.Name, "uplmtprice", i)),
dnlmtprice = long.Parse(query.GetFieldData(block.Name, "dnlmtprice", i)),
jnilclose = long.Parse(query.GetFieldData(block.Name, "jnilclose", i)),
memedan = query.GetFieldData(block.Name, "memedan", i),
recprice = long.Parse(query.GetFieldData(block.Name, "recprice", i)),
gubun = query.GetFieldData(block.Name, "gubun", i),
bu12gubun = query.GetFieldData(block.Name, "bu12gubun", i),
spac_gubun = query.GetFieldData(block.Name, "spac_gubun", i),
filler = query.GetFieldData(block.Name, "filler", i),
};
writer.NextRecord();
writer.WriteRecord(result);
Constants.CodeStocks.Add(result.shcode, new CodeStock()
{
Name = result.hname,
Code = result.shcode,
ExpandedCode = result.expcode,
EtfGubun = result.etfgubun,
SpacGubun = result.spac_gubun,
MarketGubun = result.gubun,
Bu12Gubun = result.bu12gubun,
});
}
}
public int CSVDataVer()
{
int Sonuc = 0;
try
{
List <RehberKayit> Kayitlar = DLL.RehberKayitlariGetir();
StreamWriter SW = new StreamWriter(@"c:\TelefonRehberiDB\DataVerCSV.csv");
CsvHelper.CsvWriter Write = new CsvHelper.CsvWriter(SW);
Write.WriteHeader(typeof(RehberKayit));
foreach (var item in Kayitlar)
{
Write.WriteRecord(item);
}
SW.Close();
Sonuc = 1;
}
catch (Exception ex)
{
Sonuc = 0;
}
return(Sonuc);
}
private static void Main(string[] args)
{
ExceptionlessClient.Default.Startup("7iL4b0Me7W8PbFflftqWgfQCIdf55flrT2O11zIP");
SetupNLog();
var logger = LogManager.GetCurrentClassLogger();
_fluentCommandLineParser = new FluentCommandLineParser <ApplicationArguments>();
_fluentCommandLineParser.Setup(arg => arg.CsvDirectory)
.As("csv")
.WithDescription("Directory to save CSV formatted results to. Required")
.Required();
_fluentCommandLineParser.Setup(arg => arg.CsvName)
.As("csvf")
.WithDescription("File name to save CSV formatted results to. When present, overrides default name\r\n");
_fluentCommandLineParser.Setup(arg => arg.HiveFile)
.As('f')
.WithDescription(
"Full path to SYSTEM hive to process. If this option is not specified, the live Registry will be used")
.SetDefault(string.Empty);
_fluentCommandLineParser.Setup(arg => arg.SortTimestamps)
.As('t')
.WithDescription("Sorts last modified timestamps in descending order\r\n")
.SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.ControlSet)
.As('c')
.WithDescription("The ControlSet to parse. Default is to extract all control sets.")
.SetDefault(-1);
_fluentCommandLineParser.Setup(arg => arg.Debug)
.As("debug")
.WithDescription("Debug mode")
.SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.DateTimeFormat)
.As("dt")
.WithDescription(
"The custom date/time format to use when displaying timestamps. See https://goo.gl/CNVq0k for options. Default is: yyyy-MM-dd HH:mm:ss")
.SetDefault("yyyy-MM-dd HH:mm:ss");
_fluentCommandLineParser.Setup(arg => arg.NoTransLogs)
.As("nl")
.WithDescription(
"When true, ignore transaction log files for dirty hives. Default is FALSE").SetDefault(false);
var header =
$"AppCompatCache Parser version {Assembly.GetExecutingAssembly().GetName().Version}" +
$"\r\n\r\nAuthor: Eric Zimmerman ([email protected])" +
$"\r\nhttps://github.com/EricZimmerman/AppCompatCacheParser";
var footer = @"Examples: AppCompatCacheParser.exe --csv c:\temp -t -c 2" + "\r\n\t " +
@" AppCompatCacheParser.exe --csv c:\temp --csvf results.csv" + "\r\n\t " +
"\r\n\t" +
" Short options (single letter) are prefixed with a single dash. Long commands are prefixed with two dashes\r\n";
_fluentCommandLineParser.SetupHelp("?", "help").WithHeader(header).Callback(text => logger.Info(text + "\r\n" + footer));
var result = _fluentCommandLineParser.Parse(args);
if (result.HelpCalled)
{
return;
}
if (result.HasErrors)
{
_fluentCommandLineParser.HelpOption.ShowHelp(_fluentCommandLineParser.Options);
return;
}
var hiveToProcess = "Live Registry";
if (_fluentCommandLineParser.Object.HiveFile?.Length > 0)
{
hiveToProcess = _fluentCommandLineParser.Object.HiveFile;
}
logger.Info(header);
logger.Info("");
logger.Info($"Command line: {string.Join(" ", Environment.GetCommandLineArgs().Skip(1))}\r\n");
if (IsAdministrator() == false)
{
logger.Fatal($"Warning: Administrator privileges not found!\r\n");
}
logger.Info($"Processing hive '{hiveToProcess}'");
logger.Info("");
if (_fluentCommandLineParser.Object.Debug)
{
LogManager.Configuration.LoggingRules.First().EnableLoggingForLevel(LogLevel.Debug);
}
try
{
var appCompat = new AppCompatCache.AppCompatCache(_fluentCommandLineParser.Object.HiveFile,
_fluentCommandLineParser.Object.ControlSet, _fluentCommandLineParser.Object.NoTransLogs);
var outFileBase = string.Empty;
var ts1 = DateTime.Now.ToString("yyyyMMddHHmmss");
if (_fluentCommandLineParser.Object.HiveFile?.Length > 0)
{
if (_fluentCommandLineParser.Object.ControlSet >= 0)
{
outFileBase =
$"{ts1}_{appCompat.OperatingSystem}_{Path.GetFileNameWithoutExtension(_fluentCommandLineParser.Object.HiveFile)}_ControlSet00{_fluentCommandLineParser.Object.ControlSet}_AppCompatCache.csv";
}
else
{
outFileBase =
$"{ts1}_{appCompat.OperatingSystem}_{Path.GetFileNameWithoutExtension(_fluentCommandLineParser.Object.HiveFile)}_AppCompatCache.csv";
}
}
else
{
outFileBase = $"{ts1}_{appCompat.OperatingSystem}_{Environment.MachineName}_AppCompatCache.csv";
}
if (_fluentCommandLineParser.Object.CsvName.IsNullOrEmpty() == false)
{
outFileBase = Path.GetFileName(_fluentCommandLineParser.Object.CsvName);
}
if (Directory.Exists(_fluentCommandLineParser.Object.CsvDirectory) == false)
{
Directory.CreateDirectory(_fluentCommandLineParser.Object.CsvDirectory);
}
var outFilename = Path.Combine(_fluentCommandLineParser.Object.CsvDirectory, outFileBase);
var sw = new StreamWriter(outFilename);
var csv = new CsvWriter(sw, CultureInfo.InvariantCulture);
var foo = csv.Context.AutoMap <CacheEntry>();
var o = new TypeConverterOptions
{
DateTimeStyle = DateTimeStyles.AssumeUniversal & DateTimeStyles.AdjustToUniversal
};
csv.Context.TypeConverterOptionsCache.AddOptions <CacheEntry>(o);
foo.Map(t => t.LastModifiedTimeUTC).Convert(t => t.Value.LastModifiedTimeUTC.HasValue ? t.Value.LastModifiedTimeUTC.Value.ToString(_fluentCommandLineParser.Object.DateTimeFormat): "");
foo.Map(t => t.CacheEntrySize).Ignore();
foo.Map(t => t.Data).Ignore();
foo.Map(t => t.InsertFlags).Ignore();
foo.Map(t => t.DataSize).Ignore();
foo.Map(t => t.LastModifiedFILETIMEUTC).Ignore();
foo.Map(t => t.PathSize).Ignore();
foo.Map(t => t.Signature).Ignore();
foo.Map(t => t.ControlSet).Index(0);
foo.Map(t => t.CacheEntryPosition).Index(1);
foo.Map(t => t.Path).Index(2);
foo.Map(t => t.LastModifiedTimeUTC).Index(3);
foo.Map(t => t.Executed).Index(4);
foo.Map(t => t.Duplicate).Index(5);
foo.Map(t => t.SourceFile).Index(6);
csv.WriteHeader <CacheEntry>();
csv.NextRecord();
logger.Debug($"**** Found {appCompat.Caches.Count} caches");
var cacheKeys = new HashSet <string>();
if (appCompat.Caches.Any())
{
foreach (var appCompatCach in appCompat.Caches)
{
if (_fluentCommandLineParser.Object.Debug)
{
appCompatCach.PrintDump();
}
try
{
logger.Info(
$"Found {appCompatCach.Entries.Count:N0} cache entries for {appCompat.OperatingSystem} in ControlSet00{appCompatCach.ControlSet}");
if (_fluentCommandLineParser.Object.SortTimestamps)
{
// csv.WriteRecords(appCompatCach.Entries.OrderByDescending(t => t.LastModifiedTimeUTC));
foreach (var cacheEntry in appCompatCach.Entries)
{
cacheEntry.SourceFile = hiveToProcess;
cacheEntry.Duplicate = cacheKeys.Contains(cacheEntry.GetKey());
cacheKeys.Add(cacheEntry.GetKey());
csv.WriteRecord(cacheEntry);
csv.NextRecord();
}
}
else
{
foreach (var cacheEntry in appCompatCach.Entries)
{
cacheEntry.SourceFile = hiveToProcess;
cacheEntry.Duplicate = cacheKeys.Contains(cacheEntry.GetKey());
cacheKeys.Add(cacheEntry.GetKey());
csv.WriteRecord(cacheEntry);
csv.NextRecord();
}
//csv.WriteRecords(appCompatCach.Entries);
}
}
catch (Exception ex)
{
logger.Error($"There was an error: Error message: {ex.Message} Stack: {ex.StackTrace}");
try
{
appCompatCach.PrintDump();
}
catch (Exception ex1)
{
logger.Error($"Couldn't PrintDump {ex1.Message} Stack: {ex1.StackTrace}");
}
}
}
sw.Flush();
sw.Close();
logger.Warn($"\r\nResults saved to '{outFilename}'\r\n");
}
else
{
logger.Warn($"\r\nNo caches were found!\r\n");
}
}
catch (Exception ex)
{
if (ex.Message.Contains("Sequence numbers do not match and transaction logs were not found in the same direct") == false)
{
if (ex.Message.Contains("Administrator privileges not found"))
{
logger.Fatal($"Could not access '{_fluentCommandLineParser.Object.HiveFile}'. Does it exist?");
logger.Error("");
logger.Fatal("Rerun the program with Administrator privileges to try again\r\n");
}
else if (ex.Message.Contains("Invalid diskName:"))
{
logger.Fatal($"Could not access '{_fluentCommandLineParser.Object.HiveFile}'. Invalid disk!");
logger.Error("");
}
else
{
logger.Error($"There was an error: {ex.Message}");
logger.Error($"Stacktrace: {ex.StackTrace}");
logger.Info("");
}
}
}
}
/// <summary>
/// Uploads book cover images to ipfs
/// Writes a mapping csv file to relate ean, image size, ipfs hash etc
/// Assumes the book cover images are held locally so....
/// Ensure the cover images have been downloaded first! (DownloadCoversAsync)
/// </summary>
/// <param name="books"></param>
/// <returns></returns>
public static async Task UploadCoversToIpfsAsync(
IEnumerable <Book> books, string coverFolder, string indexOutputFilePath, string ipfsUrl)
{
ipfsFilesLoaded = 0;
//indexOutputFilePath
try
{
// we'll parallel load images - but don't want to write to the csv in parallel
var semaphore = new SemaphoreSlim(1);
using (var textWriter = File.CreateText(indexOutputFilePath))
{
var csvWriter = new CsvHelper.CsvWriter(textWriter, CultureInfo.InvariantCulture);
csvWriter.WriteHeader <IpfsBookCoverMapping>();
csvWriter.NextRecord();
try
{
var ipfsService = new IpfsService(ipfsUrl);
foreach (var book in books.AsParallel())
{
if (!string.IsNullOrWhiteSpace(book.COVER_SMALL))
{
var smallCover = await UploadCoverToIpfs(coverFolder, book.EAN, "s", book.COVER_SMALL, ipfsService);
await Save(smallCover);
}
if (!string.IsNullOrWhiteSpace(book.COVER_MED))
{
var mediumCover = await UploadCoverToIpfs(coverFolder, book.EAN, "m", book.COVER_MED, ipfsService);
await Save(mediumCover);
}
if (!string.IsNullOrWhiteSpace(book.COVER_LARGE))
{
var largeCover = await UploadCoverToIpfs(coverFolder, book.EAN, "l", book.COVER_LARGE, ipfsService);
await Save(largeCover);
}
async Task Save(IpfsBookCoverMapping mapping)
{
await semaphore.WaitAsync();
try
{
csvWriter.WriteRecord(mapping);
csvWriter.NextRecord();
}
finally
{
semaphore.Release();
}
}
}
}
finally
{
await csvWriter.FlushAsync();
await textWriter.FlushAsync();
}
}
}
finally
{
// consider changing file name on completion to avoid it being overwritten accidentally
}
}
private static void ProcessFile(string file)
{
if (File.Exists(file) == false)
{
_logger.Warn($"'{file}' does not exist! Skipping");
return;
}
_logger.Warn($"\r\nProcessing '{file}'...");
Stream fileS;
try
{
fileS = new FileStream(file, FileMode.Open, FileAccess.Read);
}
catch (Exception)
{
//file is in use
if (Helper.IsAdministrator() == false)
{
_logger.Fatal("\r\nAdministrator privileges not found! Exiting!!\r\n");
Environment.Exit(0);
}
_logger.Warn($"\r\n'{file}' is in use. Rerouting...");
var files = new List <string>();
files.Add(file);
var rawFiles = Helper.GetFiles(files);
fileS = rawFiles.First().FileStream;
}
try
{
var evt = new EventLog(fileS);
var seenRecords = 0;
foreach (var eventRecord in evt.GetEventRecords())
{
if (_includeIds.Count > 0)
{
if (_includeIds.Contains(eventRecord.EventId) == false)
{
//it is NOT in the list, so skip
continue;
}
}
else if (_excludeIds.Count > 0)
{
if (_excludeIds.Contains(eventRecord.EventId))
{
//it IS in the list, so skip
continue;
}
}
eventRecord.SourceFile = file;
try
{
_csvWriter?.WriteRecord(eventRecord);
_csvWriter?.NextRecord();
var xml = string.Empty;
if (_swXml != null)
{
xml = eventRecord.ConvertPayloadToXml();
_swXml.WriteLine(xml);
}
if (_swJson != null)
{
JsConfig.IncludeNullValues = true;
JsConfig.DateHandler = DateHandler.ISO8601;
var jsOut = eventRecord.ToJson();
if (_fluentCommandLineParser.Object.FullJson)
{
if (xml.IsNullOrEmpty())
{
xml = eventRecord.ConvertPayloadToXml();
}
var xd = new XmlDocument();
xd.LoadXml(xml);
jsOut = JsonConvert.SerializeXmlNode(xd);
}
_swJson.WriteLine(jsOut);
}
seenRecords += 1;
}
catch (Exception e)
{
_logger.Error($"Error processing record #{eventRecord.RecordNumber}: {e.Message}");
}
}
if (evt.ErrorRecords.Count > 0)
{
_errorFiles.Add(file, evt.ErrorRecords.Count);
}
_fileCount += 1;
_logger.Info("");
_logger.Fatal("Event log details");
_logger.Info(evt);
_logger.Info($"Records processed: {seenRecords:N0} Errors: {evt.ErrorRecords.Count:N0}");
if (evt.ErrorRecords.Count > 0)
{
_logger.Warn("\r\nErrors");
foreach (var evtErrorRecord in evt.ErrorRecords)
{
_logger.Info($"Record #{evtErrorRecord.Key}: Error: {evtErrorRecord.Value}");
}
}
if (_fluentCommandLineParser.Object.Metrics && evt.EventIdMetrics.Count > 0)
{
_logger.Fatal("\r\nMetrics");
_logger.Warn("Event Id\tCount");
foreach (var esEventIdMetric in evt.EventIdMetrics.OrderBy(t => t.Key))
{
if (_includeIds.Count > 0)
{
if (_includeIds.Contains((int)esEventIdMetric.Key) == false)
{
//it is NOT in the list, so skip
continue;
}
}
else if (_excludeIds.Count > 0)
{
if (_excludeIds.Contains((int)esEventIdMetric.Key))
{
//it IS in the list, so skip
continue;
}
}
_logger.Info($"{esEventIdMetric.Key}\t\t{esEventIdMetric.Value:N0}");
}
}
}
catch (Exception e)
{
if (e.Message.Contains("Invalid signature! Expected 'ElfFile"))
{
_logger.Info($"'{file}' is not an evtx file! Message: {e.Message} Skipping...");
}
else
{
_logger.Error($"Error processing '{file}'! Message: {e.Message}");
}
}
fileS?.Close();
}
