C#, ik weet wat ik wil, maar niet hoe.

[107mb]

ik wil in C# een console app schrijven die het volgende doet:
JSONof CSV file met gegevens inlezen
elke 20 seconden een regel van het inleesbestand inserten in een SQL server database.
...

ik gebruik een SQL server database, en Visual Studio community 2017
...

Het probleem dat ik heb is dat ik geen idee heb hoe dit in C# op te zetten. Ik kan mij goed redden met SQL, VBA en vele andere technieken, maar in C# (OO in het algemeen) heb ik geen idee hoe dit aan te vliegen.

Tutorials hebben het snel over een Hello World, of heelspecifiek JSON inlezen. Waar ik moeite mee heb is om het gehele plaatje te zien. Waar stop ik wat in? Is het één grote brij met code, of ga ik alles splitsen in groepen. Stop ik de inleesdata in een array, of een groot object, of een array van objecten? ik ben het spoor kwijt. Wie helpt mij aan goede info over het opzetten van zo'n programma?

[Broken]

Ik zou eerst beginnen met de basis leren, dus van hello world tot het maken van simpele programma's met verschillende classes. Als je dit een beetje onder de knie hebt zul je zien dat je vanzelf beter het plaatje begint te overzien.

De kleine simpele oefening (die overal op het internet zijn te vinden) O), specifiek gericht op C#, kunnen je een goede basis geven om dit te leren.

Het heeft naar mijn mening niet heel veel zin om uit te leggen hoe je dit oplost voor dit specifieke probleem, want dan maak je de 'klik' met OO waarschijnlijk niet.

[The_Vice]

Niks mis met een beetje knippen en plakken om jezelf dingen aan te leren. Met aan de ander kant een goed boek ernaast of een goede tutorial. Neem niet aan dat je een ambitie nu hebt om een professionele developer te worden.

Maar om op je vraag in te gaan, ja, de hele code zoveel mogelijk splitsen in kleine deelstappen, dus functions. Dat vergemakkelijkt ook het zoeken op voorbeelden op functie niveau, een voorbeeld dat alles doet zal je minder makkelijk vinden.

Zoals ik het zou aanvliegen (in welke omgeving dan ook):

• localiseer bestand
• lees bestand naar stream
• zet stream om in een 1 dimensionale array (splits op regel/line niveau)
• maak een teller aan van de lengte van de array

• loop (for .. to) door het aantal van de teller heen
• -- lees het item nummer van de array (één regel uit CSV) uit
• -- splits de regel in een nieuwe 1-dimensionale array
• -- verbind met database en tabel
• -- voeg elke item uit de nieuwe 1-dimensionale array toe in het bestemde veld in de tabel in de database
• -- sluit de database verbinding
• -- wacht 20 seconden
• ga naar begin van loop

[DonJunior]

Weet niet waar je CSV of JSON vandaan komt maar hou wel rekening met SQL injection please.
https://www.w3schools.com/sql/sql_injection.asp

Voor je het weet heb je alles om zeep geholpen.


@The_Vice Ik zou dan ook nog de Stream even netjes sluiten en de hele zooi async doen zodat niet je hele app hangt op een timer van 20 seconden.

[Gropah]

TS vraagt oa om verduidelijking van het OOP principe, maar ik zie tot nu toe voornamelijk C# antwoorden.

OOP is het idee dat je classes schrijft, die iets representeren wat zijn eigen data, operaties/methods daarop en verantwoordelijkheid neemt. Een instantie van zo'n classe is een object en je kunt meerdere instanties van een classe maken. Let wel, functie's en methodes zijn verschillend, een functie roep je globaal aan terwijl je een methode op ene object aanroept.

Zo kun in de klassieke foxes & rabbits classes maken voor foxes, rabbits en het veld waarop ze worden gezet. Het veld zorgt voor locatiebepaling, terwijl de foxes en rabbits hun gedrag bepalen (en evt het opeten van gras/konijnen). Zo'n simulatie zou beginnen met 1 veld, x foxes en y rabbits.

Het is voor een vos niet normaal om te weten hoe een konijn denkt, en andersom. Daarom kunnen ze niet zomaar bij gegevens van elkaar. Het idee hier achter is dat je een redelijke parallel kunt trekken vanuit de echte wereld naar het ontwerp van een programma.

Het is natuurlijk allemaal wat complexer dan dit, maar dit kan mensen vaak genoeg op weg helpen met het nadenken over OOP. Verder zou ik je ook zeker aanraden om verder te kijken naar dingen zoals encapsulation, abstraction, inheritance, and polymorphism welke redelijk goed worden uitgelegd in dit artikel

Vanuit hier kom je waarschijnlijk wel weer met extra vragen of bedenkingen wat je prima verder kan helpen met het duiken in OOP.

[Jaaap]

Probeer je iets gedaan te krijgen (inserts in een DB) of probeer je C# te leren?

[jip_86]

Wat helpt is opbreken in stukjes of eerst iets versimpelen.
Begin eens met het inlezen van een regel en niet elke twintig seconden.

Maak daarna eens los van de json een nieuw record aan in je database. Desnoods volg je hetzelfde formaat als die uit de eerste regel is gekomen.

Daarna kun je gaan kijken hoe je dat aan elkaar kunt knopen. Maar dan helpt het dus wel als je de deelstappen begrijpt.

[EfBe]

Key voor OO is: tell, don't ask. Dus je vertelt iets (een object) iets te doen, en hoe dat gebeurt, dat zoekt dat object maar uit.

Je ontwerp baseer je dan op dat gegeven: je schuift in feite de verantwoordelijkheid wie het nu eigenlijk gaat doen voor je uit door het te delegaten naar objects. Dit helpt bij het redeneren over hoe iets werkt: ipv dat je over een lijstje loopt met een forloop, vertel je het lijstje dat je X gedaan wilt krijgen. Het lijstje zal dan dus code moeten hebben om dat te doen.

Je probleem heeft een aantal onderdelen:
- inlezen van de brondata
- omzetten van de brondata in data dat geinsert kan worden in een DB
- het inserten van die data in de DB.
- een timer die iedere 20s een regel uit de brondata haalt, omzet naar DB data en deze insert.

Als je begint met een class te maken die de brondata regelt. Dan kun je die vertellen dat deze de data van een regel moet opleveren. Hoe deze dat doet (alles in 1 keer inlezen, dan een regel teruggeven of per regel de file openen, scannen naar de huidige regel en dan die regel lezen) is voor de buitenwereld onbekend en irrelevant.

Verder combineer dit met de antwoorden hierboven en je bent al een heel eind.

[Sandor_Clegane]

Of je gebruikt iets als F# en je laat het hele OO voor wat het is.

Als je dan toch nog moet beginnen.

Gewoon omdat het kan:

code:

open System
open FShap.Data

//CSV path
let path = "filename gaat hier"


//csv 
let csv = CsvFile.Load("""path""")

let dbString = """db string gaat hier"""

//wegschrijven in db
let insertIntoDb row =
    use conn = new SqlConnection(dbString)
    conn.Open()
    let cmdText = """INSERT INTO tabel ("veld1, veld2") VALUES (@v1, @v2)"""
    use cmd = new SqlCommand(cmdText, conn)
    cmd.Parameters.AddWithValue("@v1", row.Veld1) |> ignore
    cmd.Parameters.AddWithValue("@v2", row.Veld2) |> ignore
    cmd.ExecuteNonQuery() |> ignore


//itereer over csv en wacht 20 seconden voor elke insert.
let insertCsv data =
    async {
        for row in data do
            do! Async.Sleep 20000
            insertIntoDb row |> ignore
    }

    
//start het hele zwikkie.
Async.RunSynchronously(insertCsv csv)

Er zullen vast fouten in zitten, het is meer het idee dat het niet echt complex hoeft te zijn. En voor alle "teach a man to fish" enzo, als je niet weet welke manieren er om te vissen zijn kan je overal met dynamiet gaan vissen terwijl er ook vishengels zijn.

[Voor 86% gewijzigd door Sandor_Clegane op 01-11-2018 09:30]

[whoami]

^^ Sluit je nooit je connectie dan ?

[Sandor_Clegane]

whoami schreef op donderdag 1 november 2018 @ 09:54:
^^ Sluit je nooit je connectie dan ?

Daar is de use voor.

[Voor 79% gewijzigd door Sandor_Clegane op 01-11-2018 10:09]

[Not Pingu]

107mb schreef op dinsdag 30 oktober 2018 @ 19:28:
Waar stop ik wat in? Is het één grote brij met code, of ga ik alles splitsen in groepen. Stop ik de inleesdata in een array, of een groot object, of een array van objecten? ik ben het spoor kwijt. Wie helpt mij aan goede info over het opzetten van zo'n programma?

Puur voor het bereiken van je doel zijn al je antwoorden in principe goed. Je data kan je vanuit een array halen (hoewel: als het JSON is, is het wellicht meer hiërarchisch en dan kun je het alleen in objecten goed vatten).

Laten we even aannemen dat de data in JSON is ipv CSV, en dat de JSON een reeks objecten van type Boterham bevat.
Mijn voorstel zou zijn om in elk geval een class Boterham en aanverwante zaken (Beleg, Boter) te maken die de JSON goed weergeven. Met de bekende NewtonSoft JSON.Net kun je makkelijk de hele JSON file serializen naar een array/List/IEnumerable van je class: https://www.newtonsoft.co...sonSerializerFromFile.htm
Dit voorbeeld haalt maar 1 instance van een object op, maar je kunt zo een lijst met Boterhammen ophalen:

C#:

IEnumerable<Boterham> boterhammen = JsonConvert.DeserializeObject<IEnumerable<Boterham>>(File.ReadAllText(@"C:\pad\naar\mijn.json"));

Vervolgens loop je door de lijst boterhammen heen en roep je je SQL command aan. Dit kan gewoon in 1 block code maar voor de overzichtelijkheid is het imho beter om dit naar een aparte functie te verplaatsen:

C#:

public void LoadJsonAndInsert()
{
    IEnumerable<Boterham> boterhammen = JsonConvert.DeserializeObject<IEnumerable<Boterham>>(File.ReadAllText(@"C:\pad\naar\mijn.json"));

    foreach(var boterham in boterhammen)
    {
        InsertIntoDatabase(boterham);
        System.Threading.Thread.Sleep(20000); //=20 seconden
    }
}

//aparter functie
public void InsertIntoDatabase(Boterham boterham)
{
    //SQL connection
    //SQL command met parameters
}

Mocht je JSON bestand nou heel groot zijn, dan hier nog een ideetje om de file te streamen ipv in 1x in te lezen: https://stackoverflow.com...ile-as-stream-in-json-net