[C#] Beginnervraag

[Voxyn]

Hallo mensen ik ben op dit moment mezelf aan het leren programmeren en moet toegeven tot nu toe is het zeer interessant. Maar nu wil ik een zeer groot .ini bestand lezen en dat dat in een textbox zetten.
Dat wil ik doen door gebruik te maken van de readline functie(ik kan niet gewoon de .Readtoend functie gebruiken want ik wil wat handelingen uitvoeren op de tekst) alleen nu loopt hij na 1000 regels vast iemand enig idee wat ik fout doe of hoe ik het beter kan doen.

Ik heb het idee dat ik zeer vaag ben ik voeg wel wat code toe wat het probleem wat duidelijker maakt.

code:

            TextReader tr = new StreamReader("uit te lezen bestand.ini");
            string line;
            while ((line = tr.ReadLine()) !=null)
            {
                
                TxtGames.Text = TxtGames.Text + "\r\n" + line;
                TxtGames.Refresh();
                gelezen = gelezen + 1;
                label1.Text = gelezen.ToString();
                label1.Refresh();
            }

Alvast bedankt .

[beany]

Hoe bedoel je 'loopt vast' ? De applicatie reageert niet meer? Er treedt een fout op?

En als je nou eens eerst alle regels toevoegd aan TxtGames en daarna(dus na de while) een Refresh doet?

[remco_k]

Debuggen: op welke regel loopt hij vast?

Verder wat tips die de boel wat kunnen versnellen is het _niet_ refreshen maar ook minder vaak 'invullen' van controls zoals TxtGames en label1.

Je kan misschien beter de file in 1 keer in het geheugen inlezen, dan je processing uitvoeren en dan naar de output (=TxtGames) doorzetten.

[Gimmeabrake]

Wat gebeurt er? Loopt hij vast? Krijg je een exception? Zo ja, wat voor exception en op welke regel?

ik heb fout gegokt

Een gokje van mij is namelijk dat je een exception krijgt bij volgende regel: [code]while ((line = tr.ReadLine()) !=null)[/code]ik gebruik altijd volgende code(nja, in VB.Net dan, heb het uit het hoofd voor je vertaald):[code]while (tr.peek > -1) {
line = tr.ReadLine();
//rest van je code
}[/code]
Tenminste, als ik het me goed herinner... heb nu even geen .Net omgeving bij de hand om het te testen.

[ Voor 15% gewijzigd door Gimmeabrake op 06-04-2010 12:45 . Reden: typos ]

[Voxyn]

beany schreef op dinsdag 06 april 2010 @ 12:32:
Hoe bedoel je 'loopt vast' ? De applicatie reageert niet meer? Er treedt een fout op?

En als je nou eens eerst alle regels toevoegd aan TxtGames en daarna(dus na de while) een Refresh doet?

Hij reageert niet meer, en ik had dat eerder al geprobeerd dat hij ze eerst toevoegt en dan pas refreshed alleen dat werkte ook niet.

[DRaakje]

label1.Refresh(); <= dat gebeurt veels te vaak op dit moment, laat dit 1 keer per 100.000 lines doen oid. Of maak gebruik van een progressbar. En laat het doen door een backgroundworker...

[ Voor 14% gewijzigd door DRaakje op 06-04-2010 12:38 ]

[Voxyn]

remco_k schreef op dinsdag 06 april 2010 @ 12:33:
Debuggen: op welke regel loopt hij vast?

Verder wat tips die de boel wat kunnen versnellen is het _niet_ refreshen maar ook minder vaak 'invullen' van controls zoals TxtGames en label1.

Je kan misschien beter de file in 1 keer in het geheugen inlezen, dan je processing uitvoeren en dan naar de output (=TxtGames) doorzetten.

Sorry ik heb geen idee wat je bedoeld met eerst in het geheugen inlezen en dan pas de processing uitvoeren ben echt pas net begonnen met programmeren .

En hoe zou ik deze moeten debuggen want als ik eerst 1000 maal de loop moet doorlopen voordat ik bij het stukje ben waar het fout gaat ben ik nog wel even bezig ik neem aan dat hier een optie voor is ik gebruik als ide vs2008 professional.

[ Voor 16% gewijzigd door Voxyn op 06-04-2010 12:40 ]

[beany]

Voxyn schreef op dinsdag 06 april 2010 @ 12:38:
[...]

Sorry ik heb geen idee wat je bedoeld met eerst in het geheugen inlezen en dan pas de processing uitvoeren ben echt pas net begonnen met programmeren .

Lees eerst alle regels in in een array, dan pas in een textbox zetten.

code:

List<string> regels = new List<string>();
while ((line = tr.ReadLine()) !=null)
{
   regels.add(line);
}

[Hydra]

gerrymeistah schreef op dinsdag 06 april 2010 @ 12:33:
Wat gebeurt er? Loopt hij vast? Krijg je een exception? Zo ja, wat voor exception en op welke regel? Een gokje van mij is namelijk dat je een exception krijgt bij volgende regel:

code:

while ((line = tr.ReadLine()) !=null)

ik gebruik altijd volgende code(nja, in VB.Net dan, heb het uit het hoofd voor je vertaald):

code:

while (tr.peek > -1) {
   line = tr.ReadLine();
   //rest van je code
}

Tenminste, als ik het me goed herinner... heb nu even geen .Net omgeving bij de hand om het te testen.

Zijn manier is gewoon goed en eigenlijk de standaard manier. Peek heeft geen toegevoegde waarde.

@TS: de dotnet controls zijn gebaseerd op windows controls, en die hebben een maximale lengte kennelijk:

http://www.pcreview.co.uk/forums/thread-1298254.php

[ Voor 10% gewijzigd door Hydra op 06-04-2010 12:42 ]

[Gimmeabrake]

Hydra schreef op dinsdag 06 april 2010 @ 12:40:
[...]


Zijn manier is gewoon goed en eigenlijk de standaard manier. Peek heeft geen toegevoegde waarde.

Danku, weer wat geleerd tja, ik kom van VB.Net af, en daar had ik verschillende samples gezien die het op mijn manier deden. Pas later op C# overgestapt, en heel kort daarna op java ivm mijn opleiding...

[remco_k]

Voxyn schreef op dinsdag 06 april 2010 @ 12:38:
[...]
En hoe zou ik deze moeten debuggen want als ik eerst 1000 maal de loop moet doorlopen voordat ik bij het stukje ben waar het fout gaat ben ik nog wel even bezig ik neem aan dat hier een optie voor is ik gebruik als ide vs2008 professional.

De breakpoint pas zetten ergens in die while lus als je applicatie "hangt" geeft je in ieder geval inzicht of er nog wel of niet door die lus wordt gelopen. De kans bestaat namelijk dat hij daar nog gewoon bezig is.

Verder kan je vaak een 'passcount' opgeven bij een breakpoint. Zet die op 1000 en op de 1001ste keer is de breakpoint aktief. Ik ben alleen geen C# programmeur, dus geen idee of dergelijke opties daadwerkelijk bestaan in C#. Ik zou het uiterst merkwaardig vinden als dat niet kon.

[ Voor 3% gewijzigd door remco_k op 06-04-2010 12:46 ]

[pedorus]

Tsja, je hebt nu een hele ingewikkelde implementatie van File.ReadAllText()... Verder iets met debuggen denk ik zo, maar waarschijnlijk zit je gewoon op een maximum ofzo op een gegeven moment zoals hier boven staat. Conditional breakpoints bestaan gewoon in VS.

[Voxyn]

beany schreef op dinsdag 06 april 2010 @ 12:40:
[...]

Lees eerst alle regels in in een array, dan pas in een textbox zetten.

code:

List<string> regels = new List<string>();
while ((line = tr.ReadLine()) !=null)
{
   regels.add(line);
}

Bedankt ga ik zometeen proberen .

Hydra schreef op dinsdag 06 april 2010 @ 12:40:
[...]


Zijn manier is gewoon goed en eigenlijk de standaard manier. Peek heeft geen toegevoegde waarde.

@TS: de dotnet controls zijn gebaseerd op windows controls, en die hebben een maximale lengte kennelijk:

http://www.pcreview.co.uk/forums/thread-1298254.php

Toen ik het via .readtoend deed toen kwam we alles er gewoon netjes te staan dus het lijkt me dat dat niet uitmaakt of zie ik dat nu verkeerd?

[NickThissen]

Hij bedoelt waarschijnlijk eerst alle regels in een array of iets dergelijks op te slaan. Dan kun je je processing op die array uitvoeren, en uiteindelijk de tekst in een textbox/label zetten.

Als de file zeer groot is dan zal dit waarschijnlijk lang duren, en tijdens het uitlezen kan je programma dan niets anders doen, omdat het 'vast' zit in die ene while loop. Je programma lijkt dan te hangen. Als je toch probeert ergens op te klikken oid, dan zal het vaak zelfs crashen.

Om dit te voorkomen kun je het beste het uitlezen in een background thread doen. Daar heb je verschillende methoden voor, maar misschien zijn die allemaal nog wat te complex voor je als beginner.
Als 'dirty' oplossing kun je ook een Application.DoEvents() callen elke paar loops (zeg, elke 1000 iteraties ofzo).

Als je dit niet doet (geen background thread of DoEvents callen), dan zal je tekst nooit updaten, omdat je loop nog bezig is (de GUI heeft dan geen tijd om zichzelf te refreshen). De enige manier waarop je dit wel kan forceren is de Refresh calls die je maakt. Dat is geen goede oplossing; je merkt zelf al waarom.

Ik raad je dus aan om die Refresh calls weg te halen, en de loop in een aparte thread te doen. Je zult dan waarschijnlijk problemen krijgen met crossthread calls (je kan niet zomaar de label text zetten in een andere thread). Om dat op te lossen verwijs ik je naar een ander forum, waar het mooi uitgelegd wordt:
http://www.vbforums.com/showthread.php?t=544824

[Gimmeabrake]

beany schreef op dinsdag 06 april 2010 @ 12:40:
[...]

Lees eerst alle regels in in een array, dan pas in een textbox zetten.

code:

List<string> regels = new List<string>();
while ((line = tr.ReadLine()) !=null)
{
   regels.add(line);
}

Misschien dat ik een beetje een mierenneuker ben nu, en het zal in dit geval niet heel veel uitmaken, maar ik vind wel dat er een (behoorlijk) verschil is tussen een list en een array, en ik vind dat TS als beginnende developer wel moet weten dat er een verschil is. Hoewel beiden een verzameling van objecten van hetzelfde type opslaan, is het achterliggende concept verschillend en varieert de performance van beide datatypes ook enorm in verschillende situaties.

[Grijze Vos]

Voxyn schreef op dinsdag 06 april 2010 @ 12:38:
[...]

En hoe zou ik deze moeten debuggen want als ik eerst 1000 maal de loop moet doorlopen voordat ik bij het stukje ben waar het fout gaat ben ik nog wel even bezig ik neem aan dat hier een optie voor is ik gebruik als ide vs2008 professional.

Je kunt het breakpoint instellen dat ie na 1000 hits pas breakt.

[Hydra]

gerrymeistah schreef op dinsdag 06 april 2010 @ 12:55:
Misschien dat ik een beetje een mierenneuker ben nu, en het zal in dit geval niet heel veel uitmaken, maar ik vind wel dat er een (behoorlijk) verschil is tussen een list en een array, en ik vind dat TS als beginnende developer wel moet weten dat er een verschil is. Hoewel beiden een verzameling van objecten van hetzelfde type opslaan, is het achterliggende concept verschillend en varieert de performance van beide datatypes ook enorm in verschillende situaties.

List is een arraylist. Natuurlijk moet 'ie het verschil tussen verschillende collections en arrays snappen, maar dat is hier ff bijzaak.

Voxyn schreef op dinsdag 06 april 2010 @ 12:49:
Toen ik het via .readtoend deed toen kwam we alles er gewoon netjes te staan dus het lijkt me dat dat niet uitmaakt of zie ik dat nu verkeerd?

Met readtoend kwam wel alles in die textbox te staan? Dat had je niet verteld nl?

In jouw geval zou ik trouwens in plaats van met een list gewoon met een System.Text.StringBuilder werken. Dan hoef je later die lijst niet om te vormen naar een string om in je TextBox te proppen.

[ Voor 27% gewijzigd door Hydra op 06-04-2010 13:07 ]

[NickThissen]

Ik zou graag willen vragen aan de TS wat precies de bedoeling is, bijvoorbeeld van de 'gelezen' counter. Wil je in real-time zien hoe de text in je textbox veranderd, en hoeveel regels je al gelezen hebt (in label1)?
Als dat zo is dan zul je echt een aparte thread willen gaan gebruiken, in plaats van 'hacks' zoals de Refresh calls die je maakt.

Als je niet in real-time de text wil zien veranderen, dan hoeft dat niet persé, maar haal dan gewoon de Refresh calls weg. Je zult de tekst dan pas zien nadat de loop klaar is. In dat geval kun je dan ook beter de tekst pas helemaal op het eind 1 keer zetten, in plaats van elke iteratie een nieuwe regel er aan toevoegen. Dat zal vast en zeker sneller zijn.
Houd er wel rekening mee dat de loop lang kan duren en je in die tijd niets anders kunt doen (zelfs niet je window verplaatsen).

[ Voor 12% gewijzigd door NickThissen op 06-04-2010 13:08 ]

[NickThissen]

Hydra schreef op dinsdag 06 april 2010 @ 13:05:
[...]

List is een arraylist.

Een ArrayList en een List<T> zijn twee totaal verschillende klassen.

[Hydra]

NickThissen schreef op dinsdag 06 april 2010 @ 13:09:
Een ArrayList en een List<T> zijn twee totaal verschillende klassen.

http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx

"The List(Of T) class is the generic equivalent of the ArrayList class. It implements the IList(Of T) generic interface using an array whose size is dynamically increased as required."

[FireDrunk]

Beste advies wat ik je kan geven is:
Probeer het eerst in een zo simpel mogelijke applicatie te maken...
Dus een Console Applicatie met de functies waarin je gewoon droog op het scherm wegschrijft wat je normaal in die textbox wil plempen.

C#:

string[] contents = File.ReadAllLines("filename.ini");
foreach (string line in contents)
{
 ChangeLine(line);
 Console.WriteLine(line);
}

public void ChangeLine(string line)
{
//doe iets met de regel
}

Later kan je de console.writeline gewoon verwijderen (of uitcommenten) en de code hergebruiken in je windows project

[AttiDude1]

Beetje aan het testen geweest voor je. Ik krijg hem niet vast gelopen met een ini bestand van 10000 regels. Maar merk wel dat het gewoonweg zeer traag gaat. De eerste 200regels gaan wel maar daarna schiet het echt niet op. Ik denk ook gewoon dat dit waarschijnlijk ook de reden is waarom hij niet reageerd.

Ik raad je het volgende aan. Voeg een backgroundworker(staat gewoon in de toolbox) toe aan je programma. En gebruik deze code. 10000 regels in 10seconde en programma blijft responsive.

code:

 private void button1_Click(object sender, EventArgs e)
        {
            openFileDialog1.ShowDialog(); // in mijn geval komt hier de bestandsnaam uit. Uiteraard kan je dat veranderen.
            backgroundWorker1.RunWorkerAsync();
            
        }
        delegate void SetTextCallback(string text);
        private void SetLabel(string text)
        {
            if (this.label1.InvokeRequired)
            {
                SetTextCallback d = new SetTextCallback(SetLabel);
                this.Invoke(d, new object[] { text });
            }
            else
            {
                this.label1.Text = text;
            }
        }

        private void SetTextbox(string text)
        {
            if (this.TxtGames.InvokeRequired)
            {
                SetTextCallback d = new SetTextCallback(SetTextbox);
                this.Invoke(d, new object[] { text });
            }
            else
            {
                this.TxtGames.Text = text;
            }
        }

        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            TextReader tr = new StreamReader(openFileDialog1.FileName); // verander openFileDialog1.FileName naar jou file
            string line;
            int gelezen = 0;
            while ((line = tr.ReadLine()) != null)
            {

                SetTextbox(TxtGames.Text + "\r\n" + line);
                gelezen = gelezen + 1;
                SetLabel(gelezen.ToString());
            }
        }

Succes!

[ Voor 0% gewijzigd door AttiDude1 op 06-04-2010 13:23 . Reden: Typo ]

[NickThissen]

Hydra schreef op dinsdag 06 april 2010 @ 13:12:
[...]


http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx

"The List(Of T) class is the generic equivalent of the ArrayList class. It implements the IList(Of T) generic interface using an array whose size is dynamically increased as required."

Equivalent != equal.
Een List<T> is een generic, type-safe list, en een ArrayList niet. De enige overeenkomst is dat ze beiden een lijstje zijn waar je dingen aan kan toevoegen. Daar zou ik niet van zeggen dat ze hetzelfde zijn...

AttiDude1 schreef op dinsdag 06 april 2010 @ 13:13:
Beetje aan het testen geweest voor je. Ik krijg hem niet vast gelopen met een ini bestand van 10000 regels. Maar merk wel dat het gewoonweg zeer traag gaat. De eerste 200regels gaan wel maar daarna schiet het echt niet op. Ik denk ook gewoon dat dit waarschijnlijk ook de reden is waarom hij niet reageerd.

Ik raad je het volgende aan. Voeg een backgroundworker(staat gewoon in de toolbox) toe aan je programma. En gebruik deze code. 10000 regels in 10seconde en programma blijft responsive.

code:

code...

Succes!

@ topic starter:
Dit zou ik inderdaad doen. Ik zou de code wel goed bekijken, want het is niet triviaal hoe dit werkt. Je kunt het natuurlijk blind copy/pasten maar daar leer je niets van, vrij nutteloos dus als je dit doet om te leren.
Het belangrijkste deel van de code is het zetten van de text op de textbox en label (met de SetTextBox en SetLabel methods). Hoe dat werkt wordt uitgelegd in de link die ik eerder al stuurde, dus daar kun je lezen wat er precies gebeurt.

@AttiDude1:
Beetje nit-picking, maar je hoeft geen object array door te sturen met de argumenten in de Invoke method. Je kunt gewoon de argumenten los sturen (sinds .NET 2.0 geloof ik):

code:

this.Invoke(d, text);

[ Voor 53% gewijzigd door NickThissen op 06-04-2010 13:27 ]

[Hydra]

NickThissen schreef op dinsdag 06 april 2010 @ 13:22:
Equivalent != equal.
Een List<T> is een generic, type-safe list, en een ArrayList niet. De enige overeenkomst is dat ze beiden een lijstje zijn waar je dingen aan kan toevoegen. Daar zou ik niet van zeggen dat ze hetzelfde zijn...

Ik zei List is een arraylist, niet List is een System.Collections.ArrayList. System.Collections.ArrayList is een arraylist. System.Collections.Generic.List is een arraylist. java.util.ArrayList is een arraylist. En ga nu maar weer buitenspelen.

[pedorus]

AttiDude1 schreef op dinsdag 06 april 2010 @ 13:13:
Ik raad je het volgende aan. Voeg een backgroundworker(staat gewoon in de toolbox) toe aan je programma. En gebruik deze code. 10000 regels in 10seconde en programma blijft responsive.

Is dit een serieus voorstel? Ik zie eigenlijk gewoon heel veel code voor iets dat in <1 seconden kan:

C#:

            TxtGames.Text = File.ReadAllText(@"filename.ini");

En daarnaast neem ik aan dat die textbox toch pas moet werken als de backgroundworker klaar is. (En openFileDialog1.FileName lijkt me niet iets om uit te lezen in een andere thread.)

[Hydra]

pedorus schreef op dinsdag 06 april 2010 @ 13:29:
[...]

Is dit een serieus voorstel? Ik zie eigenlijk gewoon heel veel code voor iets dat in <1 seconden kan:

C#:

            TxtGames.Text = File.ReadAllText(@"filename.ini");

En daarnaast neem ik aan dat die textbox toch pas moet werken als de backgroundworker klaar is. (En openFileDialog1.FileName lijkt me niet iets om uit te lezen in een andere thread.)

TS gaf al aan dat de regels nog bewerkt moesten worden, dus die readall is geen optie.

[AttiDude1]

Invoke is om cross threads te voorkomen.

[Snake]

NickThissen schreef op dinsdag 06 april 2010 @ 13:22:
[...]

Equivalent != equal.
Een List<T> is een generic, type-safe list, en een ArrayList niet. De enige overeenkomst is dat ze beiden een lijstje zijn waar je dingen aan kan toevoegen. Daar zou ik niet van zeggen dat ze hetzelfde zijn...


[...]

@ topic starter:
Dit zou ik inderdaad doen. Ik zou de code wel goed bekijken, want het is niet triviaal hoe dit werkt. Je kunt het natuurlijk blind copy/pasten maar daar leer je niets van, vrij nutteloos dus als je dit doet om te leren.
Het belangrijkste deel van de code is het zetten van de text op de textbox en label (met de SetTextBox en SetLabel methods). Hoe dat werkt wordt uitgelegd in de link die ik eerder al stuurde, dus daar kun je lezen wat er precies gebeurt.

@AttiDude1:
Beetje nit-picking, maar je hoeft geen object array door te sturen met de argumenten in de Invoke method. Je kunt gewoon de argumenten los sturen (sinds .NET 2.0 geloof ik):

code:

this.Invoke(d, text);

Te zijn wel degelijk 99% hetzelfde. Enige verschil is dat een ArrayList een object geturned en een List iets van het type T.

Maar ze gebruiken allebij een array, implementeren dezelfde interfaces (waarvan ArrayList de non generic versie, en List<T> de generic versie). Kijk maar naar de code.

[pedorus]

Hydra schreef op dinsdag 06 april 2010 @ 13:37:
TS gaf al aan dat de regels nog bewerkt moesten worden, dus die readall is geen optie.

Dan nog zal het bestand in 1x uitlezen waarschijnlijk sneller gaan, dus zoals FireDrunk laat zien. Zo'n reader is alleen maar nuttig als de bestanden groter worden dan goed is voor het geheugengebruik, en dat lijkt me bij een ini-bestand niet echt van toepassing. Voor je het weet krijg je meer api-calls naar de disk/netwerk toe dan strikt noodzakelijk, en dat kost alleen maar tijd (even nog afgezien vans steeds die textbox en label zetten per regel).

En eventueel zadel je een beginner ook nog op met multi-thread synchronisatieproblemen (zeg dat de veranderingen niet statisch zijn bijvoorbeeld)

[NickThissen]

Snake schreef op dinsdag 06 april 2010 @ 13:48:
[...]

Te zijn wel degelijk 99% hetzelfde. Enige verschil is dat een ArrayList een object geturned en een List iets van het type T.

Maar ze gebruiken allebij een array, implementeren dezelfde interfaces (waarvan ArrayList de non generic versie, en List<T> de generic versie). Kijk maar naar de code.

Mijn punt was dat de System.Collections.Generics.List<T> klasse niet dezelfde klasse was als de System.Collections.ArrayList klasse. Ik nam aan dat Hydra de .NET ArrayList klasse bedoelde, aangezien deze thread over .NET gaat. Blijkbaar werd 'arraylist' als algemene term bedoeld. Beetje onduidelijk, maar goed.

[ Voor 40% gewijzigd door NickThissen op 06-04-2010 13:53 ]

[Snake]

NickThissen schreef op dinsdag 06 april 2010 @ 13:52:
[...]

Mijn punt was dat de System.Collections.Generics.List<T> klasse niet dezelfde klasse was als de System.Collections.ArrayList klasse. Ik nam aan de Hydra de .NET ArrayList klasse bedoelde, aangezien deze thread over .NET gaat. Blijkbaar werd 'arraylist' als algemene term bedoeld. Beetje onduidelijk, maar goed.

Klopt, hij gebruikt ook de verkeerde term.

Een list is een wrapper rond een dynamisch uitbreidbaar array.

[Hydra]

NickThissen schreef op dinsdag 06 april 2010 @ 13:52:
Mijn punt was dat de System.Collections.Generics.List<T> klasse niet dezelfde klasse was als de System.Collections.ArrayList klasse. Ik nam aan dat Hydra de .NET ArrayList klasse bedoelde, aangezien deze thread over .NET gaat. Blijkbaar werd 'arraylist' als algemene term bedoeld. Beetje onduidelijk, maar goed.

Als het je onduidelijk is kun je ook vragen wat ik bedoel in plaats van hoog van de toren te blazen. Een arraylist is gewoon een algemene term. En hoe je in hemelsnaam op het idee kunt komen dat ik denk dat System.Collections.Generic.List dezelfde class is als System.Collections.ArrayList is me een raadsel

Snake schreef op dinsdag 06 april 2010 @ 13:55:
Klopt, hij gebruikt ook de verkeerde term.

Godkolere

[ Voor 14% gewijzigd door Hydra op 06-04-2010 13:58 ]

[Snake]

Hydra schreef op dinsdag 06 april 2010 @ 13:05:
[...]
List is een arraylist. Natuurlijk moet 'ie het verschil tussen verschillende collections en arrays snappen, maar dat is hier ff bijzaak.
[...]

QTF

[NickThissen]

Hydra schreef op dinsdag 06 april 2010 @ 13:57:
[...]
Als het je onduidelijk is kun je ook vragen wat ik bedoel in plaats van hoog van de toren te blazen. Een arraylist is gewoon een algemene term. En hoe je in hemelsnaam op het idee kunt komen dat ik denk dat System.Collections.Generic.List dezelfde class is als System.Collections.ArrayList is me een raadsel

Hoog van de toren te blazen? Ik corrigeerde alleen even iets waarvan ik dacht dat het fout was.
En hoe moet ik weten dat jij het verschil tussen een List<T> en ArrayList weet? Ik ken je niet eens. Omdat ik de term 'arraylist' interpreteerde als System.Collections.ArrayList, klopte er dus gewoon niet wat er stond, dus, voor zover ik wist, snapte je het verschil inderdaad niet. Blijkbaar zat ik fout. Who cares?

[Hydra]

pedorus schreef op dinsdag 06 april 2010 @ 13:51:
Dan nog zal het bestand in 1x uitlezen waarschijnlijk sneller gaan, dus zoals FireDrunk laat zien. Zo'n reader is alleen maar nuttig als de bestanden groter worden dan goed is voor het geheugengebruik, en dat lijkt me bij een ini-bestand niet echt van toepassing.

Als de bestanden niet groter worden dan goed is voor het geheugengebruik zijn ze ook niet zo groot dat het erg boeit of je ze als stream benaderd of in een keer in een array leest (ik heb zo'n donkerbruin vermoeden dat er onderhuids ook een soort arraylist gebruikt wordt die telkens vergroot wordt). Laten we niet vergeten dat de TS een beginner is, en het de bedoeling is dat we hem primair helpen met z'n probleem en niet met premature optimizations om te oren gaan smijten.

NickThissen schreef op dinsdag 06 april 2010 @ 14:03:
Hoog van de toren te blazen? Ik corrigeerde alleen even iets waarvan ik dacht dat het fout was.
En hoe moet ik weten dat jij het verschil tussen een List<T> en ArrayList weet?

Genoeg hierover. Jij begreep mij niet, ik vind het irritant als iemand ervanuit gaat dat ik het verschil niet weet.

[pedorus]

Nou ja, het probleem van die StreamReader valt inderdaad wel mee (hoewel het bestand in cache staat, waardoor het lastig testen is). Getest met:

C#:

        using (var tr = new StreamReader(@"filename.ini"))
        {
            var sb = new StringBuilder(3000000); // +/- 3 mb
            string line;
            int gelezen = 0;
            while ((line = tr.ReadLine()) != null)
            {
                if (gelezen > 0)
                    sb.Append(Environment.NewLine);
                sb.Append(line);
                gelezen++;
            }
            TxtGames.Text = sb.ToString();
        }

[Korben]

Hoe moeilijk kan het zijn.

C#:

string[] lines = File.ReadAllLines("bestandsnaam.groot");

Daarna kun je alle nabewerking doen die je kunt verzinnen, en vervolgens de hele mik in een TextBox plakken:

C#:

output.Text = string.Join("\r\n", lines);

[roy-t]

Korben schreef op woensdag 07 april 2010 @ 05:59:
Hoe moeilijk kan het zijn.

C#:

string[] lines = File.ReadAllLines("bestandsnaam.groot");

Daarna kun je alle nabewerking doen die je kunt verzinnen, en vervolgens de hele mik in een TextBox plakken:

C#:

output.Text = string.Join("\r\n", lines);

je kunt in je textbox via de Lines property er gewoon een array in gooien dacht ik, hoe je niet eens te joinen.

[BM]

En om het dan af te maken: als je dan toch joined, doe dat dan op Environment.NewLine ipv "\r\n". Effectief precies hetzelfde, maar ik krijg jeuk van hardcoded strings in m'n code

[Gimmeabrake]

Wat roy-t zegt, het kan dus inderdaad in 2 regels. Merk ik toch dat ik het .Net framework niet zo goed onder de knie heb als ik soms denk...

offtopic:
Wat een discussie heeft mijn reactie over die array/list losgebracht

Goed, even mijn 2 cents dan:

Een List is volgens de boeken een abstract data type(ADT), iets wat je in de praktijk met een interface in code omzet. Een list moet dus bepaalde functionaliteit hebben: je moet er items aan toe kunnen voegen, op kunnen vragen, kunnen verwijderen, en nog wat andere meuk. Hoe dat gebeurt, doet er bij een ADT niet toe.

In java is List<E> die interface, en zijn ArrayList<E> en LinkedList<E> bijvoorbeeld implementaties daarvan, die beiden hun voor- en nadelen hebben. (Bij de een kun je sneller inserten, bij de ander kun je weer sneller een item op een bepaalde index ophalen, enz.)

In .Net daarentegen is IList<T> de interface, en is List<T> al een implementatie daarvan: een arraylist. Dit zorgt waarschijnlijk voor verwarring bij mensen die regelmatig tussen Java en C# wisselen.

Dat een (array)list iets heel anders is als een array lijkt me duidelijk... een array heeft geen dynamic size, en wordt bovendien niet circulair gebruikt, terwijl dat bij de Java en C# implementaties van de arraylist (hopelijk ) wel gebeurt.

Als je de functionaliteit van een list bij een array wilt programmeren, ben je stiekem een arraylist aan het implementeren en jezelf dus voor de gek aan het houden: daarvoor kun je ook gewoon een ArrayList gebruiken.

[Hydra]

Korben schreef op woensdag 07 april 2010 @ 05:59:
Hoe moeilijk kan het zijn.

C#:

string[] lines = File.ReadAllLines("bestandsnaam.groot");

Daarna kun je alle nabewerking doen die je kunt verzinnen, en vervolgens de hele mik in een TextBox plakken:

C#:

output.Text = string.Join("\r\n", lines);

Hij leest de file gewoon in met een streamreader. M.i. is dat in ieder geval de manier hoe een beginner files zou moeten gaan lezen (in de meeste gevallen is het niet wenselijk data in een keer helemaal in je geheugen in te lezen). Een "hoe moeilijk kan het wezen" opmerking vind ik nogal misplaatst als het om een beginner gaat. Hij is in ieder geval goed op weg.

[NickThissen]

Als je de ReadAllLines functie gebruikt, dan kun je dus niet een 'running counter' bij houden en niet in real-time zien hoe de regels gelezen worden. De code van de TS doet dit wel, en het lijkt er dus op dat hij dit wel wil doen. Of dat echt zo is of niet heb ik al gevraagd maar nog geen reactie zie ik.
Ik weet het, het is niet erg logisch om zoiets in real-time te willen zien, maar waarom zou hij anders elke keer de Refresh aanroepen van de textbox en van de 'gelezen' label? Ik nam aan dat hij dat deed zodat de GUI refreshte. Als het niet in real-time nodig is, dan is dat allemaal nutteloos. In dat geval zal zijn originele code net zo goed werken, als de Refresh calls weg gehaald worden (alleen mogelijk iets langzamer doordat hij steeds opnieuw iets aan de text van de textbox toevoegd).

En mijn laatste woorden over de list discussie... In .NET is de ArrayList klasse (dus niet als algemene term bedoeld) geen generic klasse (in java blijkbaar wel?). De List<T> klasse werkt in principe (van de buitenkant in ieder geval) hetzelfde als de ArrayList, alleen de List<T> is type-safe en de ArrayList niet. Dit feitje alleen is in mijn mening meer dan genoeg om duidelijk te maken dat een ArrayList en een List<T> niet hetzelfde zijn en ook niet hetzelfde werken.

[Hydra]

NickThissen schreef op woensdag 07 april 2010 @ 10:27:
In .NET is de ArrayList klasse (dus niet als algemene term bedoeld) geen generic klasse (in java blijkbaar wel?).

De 'oude' niet generic versie van ArrayList in Java is java.util.Vector. Over slechte namen gesproken

NickThissen schreef op woensdag 07 april 2010 @ 10:27:
Dit feitje alleen is in mijn mening meer dan genoeg om duidelijk te maken dat een ArrayList en een List<T> niet hetzelfde zijn en ook niet hetzelfde werken.

Hoe kom je erbij dat List en ArrayList niet hetzelfde werken? De eerste is een generic collection maar afgezien daarvan is de implementatie gelijk.

[ Voor 38% gewijzigd door Hydra op 07-04-2010 10:33 ]

[NickThissen]

Ik bedoel van de buitenkant gezien, niet de implementatie. Als je een ArrayList gebruikt zul je meestal moeten casten om er iets zinnigs uit te halen. Bij een List<T> hoeft dat uiteraard niet.

[Hydra]

NickThissen schreef op woensdag 07 april 2010 @ 10:45:
Ik bedoel van de buitenkant gezien, niet de implementatie. Als je een ArrayList gebruikt zul je meestal moeten casten om er iets zinnigs uit te halen. Bij een List<T> hoeft dat uiteraard niet.

Jij zegt "niet hetzelfde zijn en ook niet hetzelfde werken". Ik vind 'werken' over het algemeen slaan op de implementatie van iets Dat de een een generic is en de ander niet is wat mij betreft puur buitenkant.

[NickThissen]

Ik snap wat je bedoelt. Ik had misschien beter kunnen zeggen dat ze niet hetzelfde gebruikt worden.

[Korben]

Hydra schreef op woensdag 07 april 2010 @ 10:25:
[...]


Hij leest de file gewoon in met een streamreader. M.i. is dat in ieder geval de manier hoe een beginner files zou moeten gaan lezen (in de meeste gevallen is het niet wenselijk data in een keer helemaal in je geheugen in te lezen). Een "hoe moeilijk kan het wezen" opmerking vind ik nogal misplaatst als het om een beginner gaat. Hij is in ieder geval goed op weg.

Ben ik het niet mee eens. Werken met een StreamReader is leuk, maar voor een beginner niet makkelijk om goed te doen (waar is de using of Dispose() bijvoorbeeld?). En voor je het weet zit het fout werken met streams er in geroest. En gezien het feit dat het dus blijkbaar niet zo makkelijk is, lijkt het me niet verkeerd om een functie te gebruiken die doet wat hij wil, namelijk een bestand inlezen (ik betwijfel of die running counter de bedoeling is, lijkt me meer een debugging-iets).

[Hydra]

Korben schreef op woensdag 07 april 2010 @ 11:05:
Ben ik het niet mee eens. Werken met een StreamReader is leuk, maar voor een beginner niet makkelijk om goed te doen

IO in zowel .net als Java is zo ongeveer compleet op streams gebaseerd. Maakt niet uit of je nu files leest of schrijft of bezig bent met TCP/IP connecties. Het is een van de meest basale onderdelen van je leerproces binnen .Net en Java en hij zal het toch moeten leren.

En wat foute dingen aanleren betreft; een hele file op jouw manier in een keer in het geheugen laden is beter volgens jou?

[Korben]

Hydra schreef op woensdag 07 april 2010 @ 11:52:
[...]
En wat foute dingen aanleren betreft; een hele file op jouw manier in een keer in het geheugen laden is beter volgens jou?

Ja. Ik quote de TS:

Maar nu wil ik een zeer groot .ini bestand lezen en dat dat in een textbox zetten.

Hij zegt het zelf. Hij wil een tekstbestand lezen en in een TextBox zetten. Dus ja, dat bestand in één keer in het geheugen laden, bewerken en daarna in de TextBox zetten lijkt mij het handigst.

[Hydra]

Korben schreef op woensdag 07 april 2010 @ 13:25:
Ja. Ik quote de TS:

Ik heb het niet over dit specifieke geval maar gewoon standaard File-IO. In de meeste gevallen zul je niet het hele bestand onbewerkt in geheugen nodig hebben.

[ Voor 17% gewijzigd door Hydra op 07-04-2010 13:47 ]

[remco_k]

Hydra schreef op woensdag 07 april 2010 @ 13:46:
[...]


Ik heb het niet over dit specifieke geval maar gewoon standaard File-IO. In de meeste gevallen zul je niet het hele bestand onbewerkt in geheugen nodig hebben.

Maar dat is dan ook geen klusje voor een beginner die probeerd om de inhoud van een bestand weer te geven. Uiteindelijk wel, maar dan moet hij wel eerst de voorgaande stappen snappen. En dan lijkt het mij logisch dat (zoals ik al in het 2e antwoord in dit topic aangaf) dat het bestand eerst ergens in het geheugen wordt geladen, dan de nodige bewerking plaatsvind en dan pas weergeven.

Optimalisatie komt later - zeker in de leerfase.

[Hydra]

remco_k schreef op woensdag 07 april 2010 @ 14:25:
Maar dat is dan ook geen klusje voor een beginner die probeerd om de inhoud van een bestand weer te geven. Uiteindelijk wel, maar dan moet hij wel eerst de voorgaande stappen snappen. En dan lijkt het mij logisch dat (zoals ik al in het 2e antwoord in dit topic aangaf) dat het bestand eerst ergens in het geheugen wordt geladen, dan de nodige bewerking plaatsvind en dan pas weergeven.

Optimalisatie komt later - zeker in de leerfase.

Tja. Lets agree to disagree. Het heeft bij mij niks te maken met 'optimalisatie' trouwens, onnodig gebruik van geheugen is gewoon basic programmeerwerk. Ik heb het niet over overal proberen nog een byte af te schaven, m.i. is een heel bestand in het geheugen laden terwijl het niet nodig is gewoon een hele simpele basale denkfout. Komt bij dat zoals ik al zei IO in Java en .Net (en afaik ook in C++) gewoon gebaseerd is op streams en hij dat toch moet leren.

[yade]

C#:

TxtGames.Text = TxtGames.Text + "\r\n" + line;

Deze regel doet veel pijn. Iedere keer dat deze regel wordt uitgevoerd wordt er een string vermoord, en meerdere (dure) allocaties uitgevoerd. Nog erger is het als de strings langer en langer worden, waardoor de Garbage Collector steeds vaker werk gaat doen om al die onschuldige vermoorde strings op te ruimen.

Gebruik StringBuilder om na het lezen het geheel aan Text toe te kennen of, mooier, de Lines property om na het lezen van het geheel in een List<string> type.

Als dit gedaan is kun je het mooi maken door dit gedeelte uit te voeren in een thread, bijvoorbeeld door een BackgroundWorker.

Daarna kijk je hoe je de progress kan weergeven.