Hallo liebe Foren-Mitglieder!
Ums es vorweg zu nehmen:
JA, ich bin ein Anfänger im Programmieren mit C# (bzw. OOP) und
JA, ich hab bereits mit bestem Wissen & Gewissen die Suchfunktion von
Google verwendet, habe aber dennoch keine spezifische Problemlösung
gefunden, welche bisher funktionierte :-(
Die Problemstellung ist an und für sich relativ einfach:
Ich möchte eine Variable "x", des Typs "String" mit dem Inhalt "Hallo"
in FORM1, auch für FORM2 zugänglich machen,
sodass ich deren Inhalt beispielsweise in einer Textbox ausgeben oder
sonst weiterverarbeiten kann.
Ist dies in einer OOP denn überhaupt möglich?
Meine Idee war anfangs, eine eigene Klasse zu generieren,
die eine "globale" Variable (public string x = null;) enthält,
von der aus ich beliebige Objekte abspalten kann, um dann auf die
Variable "x" zugreifen zu können.
Dummerweise kann ich dann aber immer nur denn Wert "null" auslesen :-S
Was gibt es da denn für Möglichkeiten um dies zu realisieren?!
Vielen dank bereits im Voraus!!
du musst erstmal überlegen zu was dein String gehört. Wenn er zu Form1
gehört muss er dort rein, Wenn er zu form2 gehört muss er zu form2. Wenn
er aber zu deiner Anwendung gehört dann muss er in die Klasse der
anwendung. Die Formulare können dann auf die Anwendung die ja global ist
zugreifen oder du musst sie beim konstruktor der Form mit übergeben.
eine variable die waehrend der komplette laufzeit zu verfuegung stehen
soll, braucht das schluesselwort "static"
so koenntest du eine globale instanz folgender art erstellen:
public static class Globals
{
public static string BitteGebeDeinenVariablenGescheiteNamenUndNichtX =
"affe'
}
Hallo PeterII!
Ich habe einen String, der in FORM1 Daten zur Verfügung stellt
und nun in einer Textbox, in FORM2 ausgegeben werden soll.
Dazu habe ich bisher versucht, das ganze mit einer Property global
zugänglich zu machen, wobei ich nur die default-Einstellungen der
Variable auslesen konnte
ben91 schrieb:> ... auf der Textbox wird "null" ausgegeben :-(
Und was hast du statt dessen erwartet.
public partial class Form2 : Form
{
Wenn die Form2 erzeugt wird, dann läuft diese Funktion
Form1 x_objekt = new Form1();
diese Funktion erzeugt sich sofort erst mal eine neue Form1
Das heist, ein neues Form1 Objekt wird erzeugt und diese Form1 erzeugt
sich
public partial class Form1 : Form
{
private string x = null;
einen neuen String x, der erst mal auf null gesetzt wird.
Weiter geht es in der Form2, in der Konstruktorfunktion
textBoxTest.Text = x_objekt.global_x;
von diesem neuen Form1 Objekt fragst du das global_x Member ab. Das ist
aber klarerweise immer noch null, denn in der Zwischenzeit hat da ja
keiner was reingeschrieben.
Also: Warum erwartest du, dass du da etwas anderes zurück bekommst?
Tut mir leid, hab ne (entscheidende) Code-Zeile vergessen:
nach "private String x = null;"
... käme noch "x = textboxBoxClass1.Text;" (allerdings in einem
Unterprogramm verschachtelt)
Wobei stattdessen lediglich "null" ausgegeben wird :-/
Ben91 schrieb:> Tut mir leid, hab ne (entscheidende) Code-Zeile vergessen:>> nach "private String x = null;">> ... käme noch "x = textboxBoxClass1.Text;" (allerdings in einem> Unterprogramm verschachtelt)
Wo kommt das?
Und wie soll dieses 'Unterprogram' bei der Erzeugung des Form1 Objektes
aufgerufen werden?
Ich glaub, du meinst, wenn du einmal eine Zuweisung machst, dass dann
die Variable für immer an die Textbox gebunden ist. Das stimmt so
nicht... wenn du den Wert der Variablen aktualisierst, dann ändert sich
der Inhalt der Textbox noch lange nicht.
Das nennt sich "Data Binding", aber das ist noch etwas komplizierter. Du
musst nach dem Unterprogrammaufruf noch mal eine Zuweisung
"textBoxTest.Text = x_objekt.global_x;" machen.
Erstmal guten Morgen!
Danke für die vielen Hilfestellungen (auf die ich jetzt leider nicht
alle individuell eingehen kann :-/ )
@"nocheinGast": ja du hast recht, ich hab das "data binding" noch nicht
so ganz im Griff :-(
Ich hab jetzt mal ein kleines Testprogramm geschrieben,
damit ich mich zuerst auf das wesentliche konzentrieren kann (ohne
GUI,...)
Ziel war es, den Inhalt der Variable "i" aus dem "Unterprogramm"
(bezeichnet man sowas in der OOP denn eigentlich auch als
Unterprogramm?) in der Klasse "Program" auf der Console auszugeben.
Gibt es da denn auch ne Möglichkeit, das ganze ohne "return" im UP zu
realisieren?
[c]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
/*--------*/using System.Text.RegularExpressions;
namespace Uebungen
{
class Program
{
static void Main(string[] args)
{
meineKlasse meinObjekt = new meineKlasse();
Console.WriteLine(meinObjekt.Name);
Console.ReadKey();
}
}
public class meineKlasse
{
private int i = 0;
public int Name
{
get { return this.Unterprogramm(); }
// set { this.Unterprogramm = value; }
}
private int Unterprogramm()
{
i = 5;
return i;
}
}
}
[c/]
Vielen dank für eure Hilfe!
> Gibt es da denn auch ne Möglichkeit, das ganze ohne "return" im UP zu> realisieren?
Kommt drauf an, welche C#-Version du benutzt... vielleicht kennt sie
schon "automatic properties". Dann schreibst du das einfach so:
1
publicintValue{get;set;}
Der Backing Store wird dabei implizit miterzeugt, du hast allerdings
keinen direkten Zugriff darauf. Deswegen bei Properties, die nach außen
read-only sein sollen, den Setter private machen und nicht weglassen:
>Ich möchte eine Variable "x", des Typs "String" mit dem Inhalt "Hallo">in FORM1, auch für FORM2 zugänglich machen.
Dann erzeugst du FORM1 in einer Methode von FORM2. Dann kannst du dieser
beim Erzeugen auch einen Wert mitgeben, oder setzen.
z.B.
public void createForm2(string x)
{
Form2 Windos...Form = new Windos...Form();
Form2.x.Text = x;
}
Gruß Jonas
