Maak een C# script om gegevensomzettingstaken te automatiseren
description
Door deze prompt te gebruiken, kun je je gegevensverwerkingsworkflows stroomlijnen, consistentie in gegevensomzettingen waarborgen en de kans op fouten verminderen door geautomatiseerde processen.
prompt
try_prompt
Help me een C# script te maken dat gegevensomzettingstaken automatiseert voor mijn toepassing. Het script moet in staat zijn gegevens te lezen van een gespecificeerde bron, omzettingsregels toe te passen, en de getransformeerde gegevens ... more
generate_helper
...
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een voorbeeld van een C# script dat gegevens leest van een bron (bijvoorbeeld een CSV-bestand), omzettingsregels toepast (zoals datumconversie naar ISO-formaat, en gegevensconversie naar CSV en XML), en de getransformeerde gegevens naar een doelbestand schrijft. Het bevat ook foutafhandelingsmechanismen voor ongeldige gegevens.
```csharp
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml;
namespace GegevensOmzetting
{
class Program
{
static void Main(string[] args)
{
string bronPad = "gegevens.csv"; // Pas dit aan naar je bronbestand
string doelCsvPad = "getransformeerd.csv";
string doelXmlPad = "getransformeerd.xml";
try
{
// Lees gegevens van bron
var records = LeesCsv(bronPad);
// Verwerk gegevens
var getransformeerdeRecords = new List<Dictionary<string, string>>();
foreach (var record in records)
{
try
{
var getransformeerd = TransformeerRecord(record);
getransformeerdeRecords.Add(getransformeerd);
}
catch (Exception ex)
{
Console.WriteLine($"Fout bij verwerken record: {ex.Message}");
// Hier kun je kiezen om het record over te slaan of te stoppen
}
}
// Output naar CSV
SchrijfCsv(getransformeerdeRecords, doelCsvPad);
// Output naar XML
SchrijfXml(getransformeerdeRecords, doelXmlPad);
Console.WriteLine("Gegevensomzetting voltooid.");
}
catch (Exception ex)
{
Console.WriteLine($"Er is een fout opgetreden: {ex.Message}");
}
}
// Lees CSV-bestand in
static List<Dictionary<string, string>> LeesCsv(string pad)
{
var lijst = new List<Dictionary<string, string>>();
using (var reader = new StreamReader(pad))
{
string headerLine = reader.ReadLine();
if (headerLine == null)
throw new Exception("CSV-bestand is leeg.");
var headers = headerLine.Split(',');
string line;
while ((line = reader.ReadLine()) != null)
{
var velden = line.Split(',');
if (velden.Length != headers.Length)
throw new Exception("Ongeldige CSV-rij: aantal kolommen komt niet overeen.");
var record = new Dictionary<string, string>();
for (int i = 0; i < headers.Length; i++)
{
record[headers[i]] = velden[i];
}
lijst.Add(record);
}
}
return lijst;
}
// Transformeer een record volgens de regels
static Dictionary<string, string> TransformeerRecord(Dictionary<string, string> record)
{
var resultaat = new Dictionary<string, string>();
// Voorbeeld: Datumconversie naar ISO-formaat
if (record.ContainsKey("Datum"))
{
resultaat["Datum"] = ConverteerDatumNaarISO(record["Datum"]);
}
else
{
throw new Exception("Datum veld ontbreekt.");
}
// Voorbeeld: Naam kopiëren
if (record.ContainsKey("Naam"))
{
resultaat["Naam"] = record["Naam"];
}
else
{
resultaat["Naam"] = "";
}
// Voeg meer omzettingsregels toe zoals nodig
return resultaat;
}
// Datumconversie met foutafhandeling
static string ConverteerDatumNaarISO(string datumInvoer)
{
DateTime dt;
string[] formaten = { "dd/MM/yyyy", "MM/dd/yyyy", "yyyy-MM-dd" }; // Voeg meer formaten toe indien nodig
if (DateTime.TryParseExact(datumInvoer, formaten, CultureInfo.InvariantCulture, DateTimeStyles.None, out dt))
{
return dt.ToString("yyyy-MM-dd");
}
else
{
throw new Exception($"Ongeldige datum: {datumInvoer}");
}
}
// Schrijf gegevens naar CSV
static void SchrijfCsv(List<Dictionary<string, string>> records, string pad)
{
if (records.Count == 0)
return;
using (var writer = new StreamWriter(pad))
{
// Schrijf koppen
var headers = new List<string>(records[0].Keys);
writer.WriteLine(string.Join(",", headers));
// Schrijf records
foreach (var record in records)
{
var velden = new List<string>();
foreach (var header in headers)
{
velden.Add(record.ContainsKey(header) ? record[header] : "");
}
writer.WriteLine(string.Join(",", velden));
}
}
}
// Schrijf gegevens naar XML
static void SchrijfXml(List<Dictionary<string, string>> records, string pad)
{
using (XmlWriter writer = XmlWriter.Create(pad, new XmlWriterSettings { Indent = true }))
{
writer.WriteStartDocument();
writer.WriteStartElement("Records");
foreach (var record in records)
{
writer.WriteStartElement("Record");
foreach (var kvp in record)
{
writer.WriteElementString(kvp.Key, kvp.Value);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
}
}
```
**Samenvatting van functies:**
- `LeesCsv`: Leest gegevens uit een CSV-bestand en converteert naar een lijst van dictionaries.
- `TransformeerRecord`: Past omzettingsregels toe, zoals datumconversie.
- `ConverteerDatumNaarISO`: Converteert datums naar ISO 8601-formaat, met foutafhandeling.
- `SchrijfCsv` en `SchrijfXml`: Output functies voor respectievelijk CSV en XML.
**Aanpassingen:**
- Pas de padnamen en veldnamen aan naar jouw gegevens.
- Voeg extra omzettingsregels toe in `TransformeerRecord`.
- Breid de datumformaten uit indien nodig.
Heeft u verdere wensen of specifieke omzettingsregels, dan hoor ik dat graag!
provider: deepseek
model: deepseek-chat
Hier is een C# script voor gegevensomzetting met de gevraagde functionaliteiten:
```csharp
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Linq;
namespace DataTransformatie
{
public class DataTransformer
{
public enum OutputFormat
{
ISO,
CSV,
XML
}
public class TransformatieRegels
{
// Datum conversie naar ISO 8601 formaat
public static string ConverteerDatumNaarISO(string inputDatum)
{
if (DateTime.TryParse(inputDatum, CultureInfo.CurrentCulture, DateTimeStyles.None, out DateTime datum))
{
return datum.ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
}
throw new FormatException($"Ongeldige datum: {inputDatum}");
}
// Valuta conversie naar standaard formaat
public static string ConverteerValuta(string bedrag)
{
if (decimal.TryParse(bedrag, NumberStyles.Currency, CultureInfo.CurrentCulture, out decimal waarde))
{
return waarde.ToString("F2", CultureInfo.InvariantCulture);
}
throw new FormatException($"Ongeldig bedrag: {bedrag}");
}
// Telefoonnummer standaardisatie
public static string ConverteerTelefoonnummer(string telefoon)
{
if (string.IsNullOrWhiteSpace(telefoon))
throw new ArgumentException("Telefoonnummer mag niet leeg zijn");
string alleenCijfers = new string(telefoon.Where(char.IsDigit).ToArray());
if (alleenCijfers.Length < 10)
throw new FormatException($"Ongeldig telefoonnummer: {telefoon}");
return $"+31{alleenCijfers.Substring(alleenCijfers.Length - 9)}";
}
// Email validatie en standaardisatie
public static string ConverteerEmail(string email)
{
if (string.IsNullOrWhiteSpace(email))
throw new ArgumentException("Email mag niet leeg zijn");
email = email.Trim().ToLower();
if (!email.Contains("@") || !email.Contains("."))
throw new FormatException($"Ongeldig email adres: {email}");
return email;
}
}
public class DataRecord
{
public string Naam { get; set; }
public string Email { get; set; }
public string Telefoon { get; set; }
public string Bedrag { get; set; }
public string Datum { get; set; }
}
public class TransformatieResultaat
{
public bool IsSuccesvol { get; set; }
public string FoutMelding { get; set; }
public string GetransformeerdeData { get; set; }
}
public TransformatieResultaat TransformeerData(
List<DataRecord> bronData,
OutputFormat doelFormaat)
{
try
{
var resultaat = new TransformatieResultaat();
var getransformeerdeRecords = new List<DataRecord>();
foreach (var record in bronData)
{
try
{
var getransformeerdRecord = new DataRecord
{
Naam = record.Naam?.Trim() ?? throw new ArgumentException("Naam is verplicht"),
Email = TransformatieRegels.ConverteerEmail(record.Email),
Telefoon = TransformatieRegels.ConverteerTelefoonnummer(record.Telefoon),
Bedrag = TransformatieRegels.ConverteerValuta(record.Bedrag),
Datum = TransformatieRegels.ConverteerDatumNaarISO(record.Datum)
};
getransformeerdeRecords.Add(getransformeerdRecord);
}
catch (Exception ex)
{
// Log de fout maar ga door met andere records
Console.WriteLine($"Fout bij transformeren record: {ex.Message}");
}
}
if (!getransformeerdeRecords.Any())
{
throw new InvalidOperationException("Geen geldige records gevonden om te transformeren");
}
resultaat.GetransformeerdeData = GenereerOutput(getransformeerdeRecords, doelFormaat);
resultaat.IsSuccesvol = true;
return resultaat;
}
catch (Exception ex)
{
return new TransformatieResultaat
{
IsSuccesvol = false,
FoutMelding = $"Transformatie mislukt: {ex.Message}"
};
}
}
private string GenereerOutput(List<DataRecord> records, OutputFormat formaat)
{
return formaat switch
{
OutputFormat.ISO => GenereerISOOutput(records),
OutputFormat.CSV => GenereerCSVOutput(records),
OutputFormat.XML => GenereerXMLOutput(records),
_ => throw new ArgumentException("Ongeldig output formaat")
};
}
private string GenereerISOOutput(List<DataRecord> records)
{
var sb = new StringBuilder();
foreach (var record in records)
{
sb.AppendLine($"NAAM: {record.Naam}");
sb.AppendLine($"EMAIL: {record.Email}");
sb.AppendLine($"TELEFOON: {record.Telefoon}");
sb.AppendLine($"BEDRAG: {record.Bedrag}");
sb.AppendLine($"DATUM: {record.Datum}");
sb.AppendLine("---");
}
return sb.ToString();
}
private string GenereerCSVOutput(List<DataRecord> records)
{
var sb = new StringBuilder();
// Header
sb.AppendLine("Naam,Email,Telefoon,Bedrag,Datum");
// Data
foreach (var record in records)
{
sb.AppendLine($"\"{record.Naam}\",\"{record.Email}\",\"{record.Telefoon}\",{record.Bedrag},{record.Datum}");
}
return sb.ToString();
}
private string GenereerXMLOutput(List<DataRecord> records)
{
var root = new XElement("DataRecords");
foreach (var record in records)
{
var recordElement = new XElement("Record",
new XElement("Naam", record.Naam),
new XElement("Email", record.Email),
new XElement("Telefoon", record.Telefoon),
new XElement("Bedrag", record.Bedrag),
new XElement("Datum", record.Datum)
);
root.Add(recordElement);
}
return root.ToString();
}
}
// Gebruiksvoorbeeld
class Program
{
static void Main()
{
var transformer = new DataTransformer();
// Voorbeeld data
var bronData = new List<DataTransformer.DataRecord>
{
new() { Naam = "Jan Jansen", Email = "JAN@EXAMPLE.COM", Telefoon = "06-12345678", Bedrag = "100,50", Datum = "1-1-2023" },
new() { Naam = "Piet Pieters", Email = "piet@example.com", Telefoon = "+31687654321", Bedrag = "250.00", Datum = "15-03-2023 14:30" }
};
try
{
// Transformeer naar CSV
var resultaat = transformer.TransformeerData(bronData, DataTransformer.OutputFormat.CSV);
if (resultaat.IsSuccesvol)
{
Console.WriteLine("Transformatie succesvol!");
Console.WriteLine(resultaat.GetransformeerdeData);
// Opslaan naar bestand
File.WriteAllText("output.csv", resultaat.GetransformeerdeData);
}
else
{
Console.WriteLine($"Fout: {resultaat.FoutMelding}");
}
}
catch (Exception ex)
{
Console.WriteLine($"Onverwachte fout: {ex.Message}");
}
}
}
}
```
**Specifieke omzettingsregels geïmplementeerd:**
1. **Datum conversie**: Naar ISO 8601 formaat (yyyy-MM-ddTHH:mm:ss.fffZ)
2. **Valuta conversie**: Naar standaard decimalen formaat met 2 decimalen
3. **Telefoonnummer standaardisatie**: Naar internationaal formaat (+31...)
4. **Email standaardisatie**: Naar lowercase en validatie
**Foutafhandelingsmechanismen:**
- Validatie van verplichte velden
- Try-catch blokken voor individuele records
- Specifieke excepties voor verschillende type fouten
- Graceful degradation bij gedeeltelijke fouten
- Duidelijke foutmeldingen
Het script kan eenvoudig worden uitgebreid met aanvullende transformatieregels en ondersteunt meerdere output formaten.