C# Vraagje

[Huub Buis]

Dit bleef de afgelopen dagen een beetje in mijn achterhoofd hangen.. een "Bibliotheek" maken..
hoe doe ik dat?.. gooi ik die code dan in een apart Class die ik aan mijn nieuwe project kan toevoegen?
is dat vergelijkbaar met Modules in VB.NET?..

Ja, dat is vergelijkbaar.

Eigenlijk wil ik de diverse zaken ook divers afhandelen.. in VB zou ik een module schrijven voor het laden en opslaan van de Code, een Module voor de Tekst Formatting en een module met de dialogen.

Dat is een goed uitgangspunt.

Code moet je zoveel mogelijk schrijven voor meerdere toepassingen. In C# zet je daarvoor de code in een class. Zo heb ik een class voor het lezen van tekst bestanden. Daarvan afgeleid, heb ik een class voor het lezen van xml bestanden. Die verschilt maar een paar regels code, o.a. voor de default extensie. Toch is het een aparte class zodat ik nooit meer hoef na te denken over welke bestandstype welke extensies heeft. Deze ( en nog enkele) classes zitten in dezelfde bibliotheek, hebben dezelfde namespace, en worden in één bestand opgeslagen.

[Arie Kabaalstra]

't is eigenlijk bij EdingCNC ook al zo.. je hebt 2 Macro's..
zodra ik een Upgrade ga doen op de Freesbank, dan kieper ik de standaard macro's leeg, en schrijf gewoon de Machinefuncties (nulpunten vastleggen, Gereedschapskalibratie, en gereedschapswissels) in de "MachineMacro, en de Code voor de Cycli, die mieter ik in de "UserMacro".

als ik vanuit een Class iets moet aanroepen uit een andere Class.. laten we zeggen we hebben een class die het laden en saven afhandelt(we noemen em even FileIO, en ik heb een Textbox op Form 1..

Krijg ik dan zoiets als :
String Savestring= Textbox1.text
FileIO.filesave();

als ik in de Class FileIO een Void Filesave() heb, die het opslaan van een file regelt?

[Huub Buis]

Krijg ik dan zoiets als :
String Savestring= Textbox1.text
FileIO.filesave();

String Savestring= Textbox1.text
FileIO.filesave(Savestring)

Inderdaad, zoiets....

[Arie Kabaalstra]

Ok.. dan begin ik blijkbaar te begrijpen hoe het werkt.. Top!...

Dan Ga ik van de "oefenprojectjes" de boel eens opsplitsen in verschillende Classes, en die aan de uiteindelijke versie hangen..

[Arie Kabaalstra]

Even nog een vraagje.. als ik een Class toevoeg aan mijn programma, 'k heb em FileIO genoemd.. dan krijg ik 't volgende:

Code: Selecteer alles

namespace EMCO_TM02
{
    class FileIO
    {
    }
}

en dat ziet er natuurlijk prima uit. maar als ik deze Class ook in een ander project wil gebruiken, moet ik dan de Namespace aanpassen aan de naam van die Applicatie?..

[Huub Buis]

en dat ziet er natuurlijk prima uit. maar als ik deze Class ook in een ander project wil gebruiken, moet ik dan de Namespace aanpassen aan de naam van die Applicatie?..

Nee, dat hoeft niet en dat moet je ook niet doen anders moet je alle programma's die deze namespace gebruiken ook aanpassen.

Ik heb in de project map een map lib
In de map lib heb ik een bibliotheek in het bestand "lib\algemeen.cs"
die bibliotheek heeft een namespace "Algemeen"
daar in zitten o.a. de classes:
- public class Position
- public class TimePassed : Stopwatch
- public class Plane
- etc

In het formulier 'ApShell.xaml.cs wordt het gebruik van de bibliotheek (namespace) aangegeven middels de regel:
using Algemeen;

vervolgens kunnen de classes in de namespace "Algemeen" gebruikt worden zoals in de volgende regel:
public TimePassed TimePassedProgramStart();

zonder de using Algemeen; kan het ook:
public Algemeen.TimePassed TimePassedProgramStart();
of
Algemeen.Position xx = new Algemeen.Position(1, 1);

Ik plaats vrijwel altijd een using regel in het begin van het programma, anders is het teveel extra type werk.

[Arie Kabaalstra]

'k had bedacht.. Laden en Opslaan van bestanden in een aparte Class te gooien.

Nou had ik in de Namespace FileIO al even een Void gemaakt die ik kan aanroepen vanuit Form1.cs
maar... een void Returnt niets..

Wat ik wil bereiken is: Op Form 1 knoop ik een knop. druk ik die in, dan roep ik FileIO.Open aan, en die moet dan de string "Loadfile" terugkoppen, zodat ik die in het textvenster kan smijten.

[Huub Buis]

Als je met classes wil gaan werken, dat zet je beter de string (inhoud van het bestand) in de class en alle andere informatie die nodig is. Dat is makkelijker, zeker als je meerdere bestanden gaat gebruiken. Op die manier heb je minder variabelen in je programma.

Code: Selecteer alles

class FileIO
{
	String Inhoud="";
	String Filename="Gcode.txt";
	String LastErrorMessage="";
	
	FileIO() //Dit is een constructor die verder niets doet
	{
	;
	} 
	
	FileIO(String filename); //Dit is de constructor waarbij je de filename ook geeft
	{
		this.FileName=fileName;
	}
	
	bool ReadFile()
	{
		Inhoud=lees het bestand
		return Inhoud;
	}
	
	bool ReadFile(String FileName)
	{ 
		this.FileName=fileName;
		return ReadFile();
	}
	
	String GetInhoud()
	{
		return Inhoud;
	}
}

[rverhag]

'k had bedacht.. Laden en Opslaan van bestanden in een aparte Class te gooien.

Als je dit wil doen om het zelf maken van classes onder de knie te krijgen is dit natuurlijk een prima "vingeroefening", maar in de namespace System.IO zit al een class File die dit voor je kan doen:

Code: Selecteer alles

 string inhoud = File.ReadAllText("test.txt");

en

Code: Selecteer alles

File.WriteAllText("test.txt", inhoud);

de class File is overigens een wat bijzonder type. Hij is volledig static net zo als al z'n methods. Dus als leervoorbeeld om classes en objecten te begrijpen misschien niet zo'n best voorbeeld.

Het werken met classes vergt een beetje "metaforisch denken". Als je een object instantieert (constructor van een class aanroepen) dan heb je iets wat iets kan (methods) en wat iets weet (properties). Dus bij het ontwerpen van classes is het belangrijk om je steeds af te vragen wat wil ik dat het ding gaat doen en welke informatie laat ik hem vasthouden.

In het geval van iets dat alleen kan laden en opslaan van een file (methods Load() en Save()) zal de inhoud van de file niet per se in het object zelf vastgehouden hoeven worden (deze staat nl. in het bestand zelf): je vraagt het object dus alleen om iets te doen. In een dergelijk geval hoeft een class dus eigenlijk niet geinstantieerd te worden, en kan je volstaan met static methods op de class zelf.

Code: Selecteer alles

public class FileIO
    {
        public static string Load(string filename)  //Static!
        {
            //lees de inhoud zoals jij het wil
            return inhoud;
        }
    }

inhoud van de file haal je dan op via aanroep op de static method

Code: Selecteer alles

 string fileInhoud=FileIO.Load("test.txt");

Wanneer je dit niet via een static method zou doen,

Code: Selecteer alles

 public class FileIO
    {
        public string Load(string filename)  //Niet static!!
        {
            //lees de inhoud zoals jij het wil
            return inhoud;
        }
    }

ben je genoodzaakt de class te instantieren:

Code: Selecteer alles

FileIO fileIO=new FileIO();
string inhoud=fileIO.Load("test.txt");

en zit je dus met een object in memory waar de garbagecollector weer werk aan heeft en waar je zelf verder niets mee doet...

[Arie Kabaalstra]

Jongens.. geweldig al die hulp!..

'k heb zojuist mijn eerste aanroep van mijn eerste zelfgeschreven klasse FileIO gemaakt...

in mijn Form1:

Code: Selecteer alles

private void button1_Click(object sender, EventArgs e)
        {
            string G_Code = Files.Open();
            textBox1.Text = (G_Code);
        }

en in mijn Class

Code: Selecteer alles

 public static string Open()
        {
            
                OpenFileDialog LoadDlg = new OpenFileDialog();
                LoadDlg.Filter = "NC files (*.NC)|*.NC|All files (*.*)|*.*";
                LoadDlg.RestoreDirectory = true;
                if (LoadDlg.ShowDialog() == DialogResult.OK)
                {
                    string Loadfile = System.IO.File.ReadAllText(LoadDlg.FileName);
                    return Loadfile;
                }
            else
            {
                return "";
            }
        }
        

en Dat't werkt!.. klik op Button 1.. en hij kiepert de hele inhoud van het in File.Open gekozen bestand in de Tekstbox

Jee.. wat is dat gaaf!..

Nu even puzzelen.. Ik wil mijn dialogen ook met een Class gaan doen..
zeg voor't gemak dat ik elke dialoog een nummer geef, dan kan ik met een Switch Case verwijzen naar de juiste routine, en dan de waarden voor het aantal velden (rijen van de DataGridview) alsmede de teksten returnen..

[rverhag]

En wat denk je van

Code: Selecteer alles

private void button1_Click(object sender, EventArgs e)
        {
            textBox1.Text = Files.Open();
        }

en in je class

Code: Selecteer alles

public static string Open()
        {
            
                OpenFileDialog LoadDlg = new OpenFileDialog();
                LoadDlg.Filter = "NC files (*.NC)|*.NC|All files (*.*)|*.*";
                LoadDlg.RestoreDirectory = true;
                if (LoadDlg.ShowDialog() == DialogResult.OK)
                {
                    return System.IO.File.ReadAllText(LoadDlg.FileName);
                }
            else
            {
                return "";
            }
        }

je hebt die variabelen G_Code en Loadfile dus niet nodig....

[Arie Kabaalstra]

Verrek!.. Ja.. dat werkt!..

weet wel..'t is pas sinds een maandje ofzo dat ik in C# programmeer.. en als je dan ziet hoeveel ik in die tijd, mede door jullie hulp geleerd heb!..

'k heb inmiddels ook een testje.. Ik kan het aantal rijen in de DataGridview laten bepalen door de andere Class, door een aanroep.. meer dan dat de class gewoon een getal terugkopt is het momenteel nog niet.. maar ik maak nog een Class Dialog, gewoon omdat ik dat hele gebeuren in een aparte Class wil doen om de code overzichtelijk te houden.
Dan kan ik in de toekomst ook makkelijker dingen wijzigen

[Huub Buis]

omdat ik dat hele gebeuren in een aparte Class wil doen om de code overzichtelijk te houden.
Dan kan ik in de toekomst ook makkelijker dingen wijzigen

Zo hoort het, leesbaarheid gaat voor snelheid!!!

[Arie Kabaalstra]

't is net als bij Eding CNC.. de machine functies (homen, kalibreren, gereedschapswissel en dat soort zaken doe je in de Machine Macro, en de rest, je eigen functies.. die zet je in de User Macro.

't is voor mij momenteel een ontdekkingsreis.. eerst zien wat er mogelijk is, dan hoe het werkt, en dan hoe je het toe kan passen, en hoe je het schrijft..de {} Accolades heb ik nu wel onder de knie, de ; Puntkomma's.. ik vergeet er nog wel eens eentje.. maar dan waarschuwt Visual Studio me wel.. en haakjes ().. wanneer wel, en wanneer niet?..

Maar goed.. nu ik dus in staat ben om het aantal rijen van een DataGridview uit een Class te toveren, kan ik verder met hoe flikker ik de strings erin..
en dan nog uitvogelen of we de verwerking van de waarden ook in die Class Dialog kunnen gaan regelen..
't moet kunnen.. ik weet alleen nog niet hoe..