[C#] Wat is hier verkeerd aan?

[Reef]

Ik probeer dus eigenlijk iets heel simpel te verwezenlijken in C#, namelijk de inhoud van een textbox te wijzigen vanuit een aparte class. Maar het lukt totaal niet.

Hier is de code van de main form:

code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace test
{
    public partial class mainForm : Form
    {
        public string myString;
        
        public mainForm()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            testClass test = new testClass();
            test.changeContents();
        }
        public void fillTextBox(string str)
        {
            textBox1.Text = str;
            button1.Text = str;
            Console.WriteLine(str);
        }
    }
}

en dan van de aparte class:

code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace test
{
    public class testClass : mainForm
    {
        public void changeContents()
        {
            mainForm frm = new mainForm();
            frm.myString = "TEST";
            frm.fillTextBox(frm.myString);
        }
    }
}

De class vult de variabele myString juist in, want de Console.WriteLine in de main form laat TEST zien in de output, maar diezelfde variabele wordt dus NIET in de textbox of op de button weergegeven. Ik snap er dus niks meer van...

Kan iemand mij verder helpen? Alvast bedankt!

[KompjoeFriek]

Ik ben totaal niet bekend met C#, maar is het niet makkelijker om in de functie button1_Click het te veranderen object (textBox1) mee te geven aan de functie waar je het wilt veranderen (changeContents)?

zoiets:

C#:

        private void button1_Click(object sender, EventArgs e)
        {
            testClass test = new testClass();
            test.changeContents(textBox1);
        }

// en

        public void changeContents(object myTextBox)
        {
            myTextBox.Text = "TEST";
        }

[ Voor 0% gewijzigd door KompjoeFriek op 05-10-2009 00:44 . Reden: iets vergeten ]

[boe2]

Ik denk dat je het hele objectgeorienteerd gedoe nog niet door hebt. Doe op het einde van die aparte klas eens frm.Show();. Dan zie je waarschijnlijk wel je redeneringsfout

[_js_]

Reef schreef op maandag 05 oktober 2009 @ 00:28:
en dan van de aparte class:
mainForm frm = new mainForm();

Daar gaat het mis (kijk nog eens wat je daar precies aan het doen bent).

[Reef]

Boeboe schreef op maandag 05 oktober 2009 @ 00:47:
Ik denk dat je het hele objectgeorienteerd gedoe nog niet door hebt. Doe op het einde van die aparte klas eens frm.Show();. Dan zie je waarschijnlijk wel je redeneringsfout

Die frm.Show() werkt wel, maar dan krijg ik telkens een nieuwe form als ik op de button klik.

@_js_: Kan je dat even verder uitleggen aan deze C# newbie?

[NMe]

Reef schreef op maandag 05 oktober 2009 @ 00:55:
[...]

Die frm.Show() werkt wel, maar dan krijg ik telkens een nieuwe form als ik op de button klik.

@_js_: Kan je dat even verder uitleggen aan deze C# newbie?

Je maakt op elke klik op die button een nieuw (en onzichtbaar) formulier aan en vult alleen op dat nieuwe formulier de waarde in. Je wil dus (uiteraard) geen new mainForm maken maar je bestaande formulier wijzigen.

[Reef]

Uiteindelijk was het mijn bedoeling om gewoonweg code te verdelen over verschillende bestanden. Dit om te vermijden dat ik op den duur met een enorm lange lijst aan code zou zitten in éénzelfde bestand.
Ik heb net ontdekt dat het eigenlijk veel gemakkelijker gaat door een partial class te gebruiken, zo blijft het steeds in dezelfde class, maar dan verspreid over meerdere bestanden, wat de leesbaarheid van de code ten goede komt.

Dit is wat ik nu heb:

Main form:

code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace test
{
    public partial class mainForm : Form
    {
        public string myString;
        
        public mainForm()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            changeContents();
        }
        private void fillTextBox(string str)
        {
            textBox1.Text = str;
            button1.Text = str;
            Console.WriteLine(str);
        }
    }
}

2e bestand:

code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace test
{
    public partial class mainForm
    {
        private void changeContents()
        {
            myString = "TEST";
            fillTextBox(myString);
        }
    }
}

Dit werkt perfect en is ook nog eens minder code dan voorheen.

In ieder geval bedankt iedereen om mij op de juiste weg te helpen!

[Glashelder]

Een class is een bouwtekening. Door een nieuwe instantie van een class te maken
(wat je in deze regel doet: )

C#:

testClass test = new testClass();

bouw je dat huis. Het probleem wat jij in je huidige code hebt is dat je constant nieuwe huizen aan het bouwen bent door iedere keer weer een nieuwe instantie aan te maken Daarom krijg je met een form.Show() ook constant nieuwe forms voor je kiezen.

Je moet je code zo ombouwen dat je 'changeContents' functie bewerkingen uitvoert op de huidige instantie van 'mainForm', of beter nog, op het textbox object wat zich op mainForm bevind.

Dat doe je door in de argumentenlijst van 'changeContents' een referentie te vragen naar een textbox object.

Je class bestand gaat er dan ongeveer zo uitzien:

C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace test
{
    public class testClass : mainForm
    {
        public void changeContents(ref TextBox TxtBoxRefVanMainForm)
        {
            TxtBoxRefVanMainForm.Text = "Een tekst..verzin iets leuks";
        }
    }
}

In je main bestand geef je dan gewoon het hele object mee:

C#:

        private void button1_Click(object sender, EventArgs e)
        {
            testClass test = new testClass();
            test.changeContents(ref this.textBox1);
        }

De functie changeContents krijgt nu een referentie / verwijzing naar een bestaand object in het geheugen en gaat daar dan wijzigingen op aanbrengen. Wellicht dat je ook niet helemaal begrijpt wat 'this' nou precies doet. Nou, 'this' is altijd een verwijzing naar de huidige instantie van een object waar je op dat moment in werkt. Kortweg gezegd; hijzelf dus.

Het duurde even voordat ik dit helemaal uitgetypt had (wilde ook even testen of de code geen compile errors gaf ), dus ik zie dat je er intussen op een andere manier al uitgekomen was, maar misschien dat je hier toch nog wat aan hebt

[CodeCaster]

Kijk eens naar abstractie om verantwoordelijkheden af te schermen, en naar ontwerppatronen zoals het MVC-patroon. Wat jij eigenlijk zou moeten doen is niet langs de kamer van koophandel, maar iets gebruiken als dit:

C#:

static class TextboxContentGenerator {
  String MaakEenString(String met, String wat, String argumenten) {

    return met + " en " + wat + " en " + argumenten;

  }
}

En in je view, je formulier, gebruik je dan:

C#:

private void button1_Click(object sender, EventArgs e) {
  textBox1.Text = TextboxContentGenerator.MaakEenString("a", "b", "c");
}

[Reef]

Bedankt Glashelder voor deze glasheldere uitleg Dit wordt zeker gewaardeerd!

[Crazy D]

Reef schreef op maandag 05 oktober 2009 @ 01:40:
Uiteindelijk was het mijn bedoeling om gewoonweg code te verdelen over verschillende bestanden. Dit om te vermijden dat ik op den duur met een enorm lange lijst aan code zou zitten in éénzelfde bestand.
Ik heb net ontdekt dat het eigenlijk veel gemakkelijker gaat door een partial class te gebruiken, zo blijft het steeds in dezelfde class, maar dan verspreid over meerdere bestanden, wat de leesbaarheid van de code ten goede komt.

Als 'leesbaarheid' de reden is zijn partial classes een optie, en gebruik regions. Ik heb nog nooit het gevoel gehad een file te hebben met teveel code, met regions kun je hele stukken code eenvoudig in- en uitklappen. Naar mijn mening handiger en overzichtelijker dan code in verschillende files opdelen voor de leesbaarheid. (als er 'OO redenen' zijn om dat te doen is het natuurlijk een ander verhaal).

[Phyxion]

Crazy D schreef op maandag 05 oktober 2009 @ 08:04:
[...]

Als 'leesbaarheid' de reden is zijn partial classes een optie, en gebruik regions. Ik heb nog nooit het gevoel gehad een file te hebben met teveel code, met regions kun je hele stukken code eenvoudig in- en uitklappen. Naar mijn mening handiger en overzichtelijker dan code in verschillende files opdelen voor de leesbaarheid. (als er 'OO redenen' zijn om dat te doen is het natuurlijk een ander verhaal).

Ben ik inderdaad mee eens, het is beter om regions te gebruiken dan partial classes.
Sowieso het voorbeeld van TS om alleen even text te veranderen is wel erg overbodig om dat in een aparte class te doen, tenzij het programma alleen maar uit text veranderen bestaat.

[H!GHGuY]

wat een bloated oplossingen allemaal
@CodeCaster De TS heeft helemaal geen TextGenerator class nodig. Als hij al iets geavanceerd zou willen dan is dat een simpele string.Format() en een culture-specific string met "{0}..." in. Zo'n speciale klasse daarvoor is gewoon bloat voor wat de TS wil.

@GlasHelder: die "ref" is helemaal niet nodig. Ik neem aan dat je zelf ook beter even opzoekt wat het ref keyword in C# doet. De TS wil helemaal niet de TextBox assignen.

@Reef: partial classes gebruiken om te grote files te vermijden is niet echt de bedoeling. Je verschuift het probleem dan alleen maar: "in welke sub-file stond nou dat stukje code".
De beste toepassing wordt al gebruikt door Visual Studio en dat is om gegenereerde code van eigen code te onderscheiden. Gebruik, zoals reeds aangehaald

C#:

#region TextBox
#endregion

om je code te kunnen inklappen en je file overzichtelijk te houden. Zeker in kleine applicaties is dit voldoende.

Een 2de approach, die waarschijnlijk voor jouw toepassing overkill is, is om custom controls te maken. Hierin stop je een groep samenhorende controls (bvb rond 1 business klasse) om 1 stuk functionaliteit te maken. Deze control kun je nadien zelfs nog hergebruiken.
Bij een facturatie-applicatie zou je bvb een control kunnen hebben om persoonsgegevens van 1 persoon te manipuleren, een control om facturen op te zoeken, een control om de gegevens van 1 factuur of 1 offerte te manipuleren etc.

[whoami]

Reef schreef op maandag 05 oktober 2009 @ 01:40:
Uiteindelijk was het mijn bedoeling om gewoonweg code te verdelen over verschillende bestanden. Dit om te vermijden dat ik op den duur met een enorm lange lijst aan code zou zitten in éénzelfde bestand.

Ik denk dat je hier een fout maakt.
Code ga je opsplitsen adhv 'verantwoordelijkheden', niet omdat je anders 'veel code in een bestand' gaat hebben.
Denk na over de 'verantwoordelijkheden', en ga na wat er in welke class thuishoort. Zet iedere class in een ander bestand; op die manier ga je je doel natuurlijk ook bereiken.

Ik heb net ontdekt dat het eigenlijk veel gemakkelijker gaat door een partial class te gebruiken, zo blijft het steeds in dezelfde class, maar dan verspreid over meerdere bestanden, wat de leesbaarheid van de code ten goede komt.

Tja, dat vind ik niet altijd.
Partial classes werden in het leven geroepen om oa. de designer generated code in een ander bestand te kunnen plaatsen. Partial classes hebben zo hun toepassingen natuurlijk, maar je mag ze ook niet misbruiken.

[CodeCaster]

H!GHGuY schreef op maandag 05 oktober 2009 @ 08:45:
wat een bloated oplossingen allemaal
@CodeCaster De TS heeft helemaal geen TextGenerator class nodig. Als hij al iets geavanceerd zou willen dan is dat een simpele string.Format() en een culture-specific string met "{0}..." in. Zo'n speciale klasse daarvoor is gewoon bloat voor wat de TS wil.

Liever met een goede basis beginnen die iets te uitgebreid is om eenvoudig te zijn dan op een verkeerde manier, toch? Nee, hij heeft geen TextGenerator nodig, maar txtbox.text = "hoi" is waarschijnlijk ook van zijn kant een simplificatie. En straks heeft hij (de berekening van) de inhoud van die string ergens anders in z'n programma nog eens nodig, dan is het toch wel handig als hij niet Form1.Class1.Texbox1_click() aan hoeft te roepen.

[whoami]

CodeCaster schreef op maandag 05 oktober 2009 @ 10:14:
[...]

Liever met een goede basis beginnen die iets te uitgebreid is om eenvoudig te zijn dan op een verkeerde manier, toch? Nee, hij heeft geen TextGenerator nodig, maar txtbox.text = "hoi" is waarschijnlijk ook van zijn kant een simplificatie. En straks heeft hij (de berekening van) de inhoud van die string ergens anders in z'n programma nog eens nodig, dan is het toch wel handig als hij niet Form1.Class1.Texbox1_click() aan hoeft te roepen.

YAGNI's all over the way hoor ....
Ik hou ook van uitbreidbare oplossingen enzo, maar als er iets is wat ik ondertussen geleerd heb, is het, dat het beter is om voor de meest simpele oplossing te kiezen waarmee je het probleem kan oplossen. Op die manier verlies je minder tijd (waardoor je wellicht op tijd kunt opleveren). Mocht het dan nodig zijn dat één van de veronderstellingen (want dat zijn het) echt requirements worden, dan kan je de boel nog altijd ombouwen / refactoren naar een generiekere (complexere) oplossing.
Een eenvoudige oplossing is altijd makkelijker aan te passen, dan een complexe oplossing.