C# Text Speichern und Abfragen

[Strong.]

Hallöchen,

Ich bin dabei das Programmieren von C# zu
Lernen durch Videos & dem Lesen verschiedener pdf
Tutorials ( 200 Seiten ).
Ich bastel momentan an einem Project was ich echt
gerne zu ende bringen würde, meine eigene Datenbank
wo ich Daten reinschreiben kann ( Abspeichern ) und
später wieder Aufrufen kann per Button. Kommen
wir mal zu den Fragen..

Ich habe 2 Textboxen in die Obere soll der jenige
seine ID reinschreiben und in die 2te sein Passwort,
anschließend auf Speichern drücken, wie muss ungefähr
der Code aussehen damit die Daten in einem
Textdokument abgespeichert werden sobald man auf
Speichern drückt?

Gibt es die Funktion, dass wenn ich auf einen bestimmten
Button drücke der Text in beiden TextBoxes gelöscht wird?

Wie muss der Code ungefähr aussehen wenn ich per Button
eine TextBox öffnen möchte wo alle bisherigen Daten
Gespeichert wurden sind?

Hoffe auf Hilfe...

Auf Skype Adden wäre eine SUPER Möglichkeit!

[warfley]

Ich habe 2 Textboxen in die Obere soll der jenige
seine ID reinschreiben und in die 2te sein Passwort,
anschließend auf Speichern drücken, wie muss ungefähr
der Code aussehen damit die Daten in einem
Textdokument abgespeichert werden sobald man auf
Speichern drückt?

String[] UserData = new String[2]
UserData[0]=Benutzername.Text;
UserData[1]=Passwort.Text;
System.IO.File.WriteAllLines("Pfad zur Datei", UserData);

Gibt es die Funktion, dass wenn ich auf einen bestimmten
Button drücke der Text in beiden TextBoxes gelöscht wird?

Username.Text="";
Passwort.Text="";

Wie muss der Code ungefähr aussehen wenn ich per Button
eine TextBox öffnen möchte wo alle bisherigen Daten
Gespeichert wurden sind?

String[] Data=System.IO.File.ReadAllLines("Pfad");
Zeile1 = Data[0] //Erste zeile
Zeile2 = Data[1] //Zweite zeile
Zeile3 = Data[2] //Dritte zeile
//And so on

[Lee Ki-Hwan]

Was ich noch gerne dazu sagen würde, ist nämlich das wenn du sowas machst ist es am besten immer eine eigene Klasse für sowas zu machen denn dann haste eine bessere übersicht und es ist leichter die Werte zu bekommen oder zu setzen dafür werden jeweils get oder set Methoden benutzt. (Also das ist in deinem Fall vielleicht nicht nötig, ist aber gut zu wissen.)

Das funtkioniert auch recht simple:

private int myValue;
private int myValue2;

//Default Constructor initialize with 0/-1
public MyClass()
{
     this.myValue = 0; //oder -1 wie man es halt mag.
     this.myValue2 = 0;
}

//Das ist der erweiterte Konstruktor, hier kannst die Werte direkt setzen und dann abrufen
public MyClass(int myValue, int myValue2)
{
     this.myValue = myValue;
     this.myValue2 = myValue2;
}

/* ---- Get & Set Methoden ---- */
public int getmyValue()
{
       return this.myValue; 
}

public int getmyValue2()
{
      return this.myValue2;
}

public void setmyValue(int value)
{
     this.myValue = value;
}

public void setmyValue2(int value2)
{
    this.myValue2 = value2;
}

Die benutzung wäre ja dann auch sehr simple:

MyClass klasse = new MyClass(); // Hier benutzen wir den Konstruktor wo wir noch keine Werte haben.

//Hier setzt du die Werte für myValue und myValue2
klasse.setmyValue(1);
klasse.setmyValue2(2);

//Und hier holst du sie dir wieder aus der Klasse
int myValue = klasse.getmyValue();
int myValue2 = klasse.getmyValue2();

//Oder du benutzt den anderen Konstruktor und setzt die Werte direkt und benutzt dann ur noch die Get-Methods
MyClass klasse2 = new MyClass(1,2);

int myValue = klasse2.getmyValue();
int myValue2 = klasse2.getmyValue2();

soviel dazu

[Mostey]

Originally Posted by The Notorious B.I.G

Was ich noch gerne dazu sagen würde, ist nämlich das wenn du sowas machst ist es am besten immer eine eigene Klasse für sowas zu machen denn dann haste eine bessere übersicht und es ist leichter die Werte zu bekommen oder zu setzen dafür werden jeweils get oder set Methoden benutzt. (Also das ist in deinem Fall vielleicht nicht nötig, ist aber gut zu wissen.)

Das funtkioniert auch recht simple:

private int myValue;
private int myValue2;

//Default Constructor initialize with 0/-1
public MyClass()
{
     this.myValue = 0; //oder -1 wie man es halt mag.
     this.myValue2 = 0;
}

//Das ist der erweiterte Konstruktor, hier kannst die Werte direkt setzen und dann abrufen
public MyClass(int myValue, int myValue2)
{
     this.myValue = myValue;
     this.myValue2 = myValue2;
}

/* ---- Get & Set Methoden ---- */
public int getmyValue()
{
       return this.myValue; 
}

public int getmyValue2()
{
      return this.myValue2;
}

public void setmyValue(int value)
{
     this.myValue = value;
}

public void setmyValue2(int value2)
{
    this.myValue2 = value2;
}

Die benutzung wäre ja dann auch sehr simple:

MyClass klasse = new MyClass(); // Hier benutzen wir den Konstruktor wo wir noch keine Werte haben.

//Hier setzt du die Werte für myValue und myValue2
klasse.setmyValue(1);
klasse.setmyValue2(2);

//Und hier holst du sie dir wieder aus der Klasse
int myValue = klasse.getmyValue();
int myValue2 = klasse.getmyValue2();

//Oder du benutzt den anderen Konstruktor und setzt die Werte direkt und benutzt dann ur noch die Get-Methods
MyClass klasse2 = new MyClass(1,2);

int myValue = klasse2.getmyValue();
int myValue2 = klasse2.getmyValue2();

soviel dazu

Ohne zu wissen worum es geht hilft es auch nicht wirklich ihm eine Klasse dafür vorzuschlagen, er wird ohne Erklärung nicht verstehen wieso es wichtig ist. Da OOP in C# schon sehr stark präsent ist, würde er sich sowieso in's Bein schießen wenn er das nicht nutzt. Ich rate da eher zu einem guten Buch/Tutorial/PDF dass die Grundlagen abdeckt.

Getter und Setter kannst du übrigens in C# extrem kürzen:

public class MyClass
{
    public int SomeValue { get; set; }
}

// Anwendung
var someClass = new MyClass();
someClass.SomeValue = 4;
Console.WriteLine(someClass.SomeValue);

this kannst du übrigens auch weglassen, das ist redundant.

[Lee Ki-Hwan]

Ja ich wollte nur darauf hinweisen
Das mit get; set; hatte ich schon fast vergessen, bin nur noch mit Java beschäftigt wegen meiner Firma.

[snow]

#moved

[Black Tiger ツ]

Du musst dir erstmal Gedanken über das was/wo/wie machen. In der Tat ist es in C# sehr einfach, denn C# ist eine schöne Sprache die sehr viele Möglichkeiten bietet.

Ziel: Daten persistent abspeicherbar(serialisieren) und wieder aufrufbar(deserialisieren) zu machen.

1. Was soll serialisieren werden?
-> Ein(e) Wörterbuch/Liste (dymanische Datenstruktur) welche alle Objekte (mit den Eigenschaften ID/PW) enthält, nur einzelne Objekte oder nur Eigenschaften von Objekten?

2. Wo soll es wieder deserialisieren werden?
-> Wo willstn deine Datenbank wieder aufrufen? Nur mit dem Programm oder soll der User auch die Daten mit dem Editor ändern können, oder ...?

3. Wie soll es serialisieren werden?
-> Binary, XML-Format oder einfach nur Plain Text? Gibt sicherlich noch mehr, z.B. RTF, CSV, usw.