So, Alarm zurück...
im Constructor stand noch versteckt ein

dataGridView1.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.ColumnHeader

Die Einstellung aus dem Designer wurde also immer überschrieben, jetzt klappt es. 👍

Vielen Dank für den Tipp!

Habe mit der Einstellung herumgespielt und jeden Wert einmal durchgetestet, aber leider kann ich weiterhin nur die Höhe Anpassen und die Breite dieser ersten "Auswahlspalte" ganz links.

Hier ein Ausschnitt aus dem Code wie die Daten an das Datagridview gebunden sind:

private DataSet dataset = new DataSet();
private DataTable original_data = new DataTable("Original Data");
private BindingSource bsource = new BindingSource();


original_data.Columns.Add("Test", typeof(string));
dataset.Tables.Add(original_data);

[...]

bsource.DataSource = dataset.Tables["Original Data"];
dataGridView1.DataSource = bsource;
[...]

Vielen Dank erst einmal für deine Antwort.
Vielleicht habe ich das mit dem Cursor Symbol auch nur falsch im Kopf, aber genau diese Funktion von der du sprichst mit der man zwischen zwei Spalten die Breite anpasst funktioniert nicht.

Einzig bei der aller ersten Spalte (in deinem Screenshot mit dem schwarzen Pfeil) geht das. Diese Funktion hätte ich nun auch gerne bei den anderen Spalten.

Ich habe ein Datagridview welches mit einer Bindingsource und einem DataSet gebunden ist.

Die Spalten werden über die Datentabelle im Dataset definiert.
Leider erscheint im Datagridview kein Pfeil um die Spaltenbreite von Hand anzupassen.

Gibt es da einen Trick diese Funktion auch bei einem datengebundenen Datagridview zu aktivieren?

AllowUserToResizeColumns ist an.
Auch ansonsten habe ich schon alles mögliche probiert ohne Erfolg.

Gibt es zur Anzeige eines Videos auf einer anderen Form also keine andere Möglichkeit als einen Stream mit bytes oder ähnlichem auszutauschen?

Ich habe mal wieder ein Problem zu dem ich einfach keine Lösung finde... 🙁

Ich habe zwei Forms (jeweils Plugins von einem Hauptprogramm, dass ich nicht selber geschrieben habe)

Dort gibt es die Möglichkeit zwischen Plugins Daten in Form von strings auszutauschen.

Das Ziel ist es ein Video das in Form2 bekannt ist und erzeugt wird in Form 1 anzuzeigen.
Dazu wollte ich das Handle eines Panel das in Form1 erstellt wurde von Form 2 abrufen lassen.

Leider bekommt man aber so keinen Zugriff. Hat jemand eine Idee?

string handlestr = DX_echangePluginData("Form1", "getPanelHandle", "Panel");

IntPtr handle = new IntPtr(Convert.ToInt32(handlestr, 16));

MessageBox.Show(handle.ToString());
Control cPanel = Control.FromHandle(handle);
if (cPanel != null)
{
     Panel vPanel = (Panel)cPanel;
     if (vPanel != null)
     {
         vPanel.Controls.Add(pb);
     }
     else
         MessageBox.Show("vpanel is null");
}
else
    MessageBox.Show("cpanel is null");

Das Ergebnis ist das die erste MessageBox das Handle ausgibt:
z.B.: 2508952

cPanel kann dann bereits nicht mehr aus dem Handle erstellt werden.
Sodass ich dort "cpanel is null" ausgegeben bekomme.

Hat jemand eine Idee wie ich das lösen kann?

Das "Problem ist" eigentlich das der User mit einer xml Datei das Layout der Ausgabe bestimmt.

Das heißt: Er kann dort Positionen eingeben wo dann die einzelnen Werte (die er selber aussuchen kann) erscheinen sollen.

So sieht das dann aus

<Content type="Text" position="1;58" datasource="MEDIA" style="Text2">{Artist}</Content>

Was ich dabei nicht bedacht habe, ist, dass fast ausschließlich immer genau ein Tag dort steht, sodass in meinen Augen die Regex Variante wenig sinn macht.
Dazu kommt, dass ich alle möglichen Strings auch im Vorhinein kenne, sodass auch dort der Vorteil der Regex Variante flach fällt.

Wovon ich mir jetzt aber einen größeren Performanceschub erhoffe ist folgendes: Ich abonniere die nächstes / vorheriges Lied Events und rufe dann einmal aus der SDK die Werte Titel, Interpret usw. ab.
Erst beim Songwechsel beginnt das Spiel von neuem.

Dann brauch ich schonmal nur die Sachen wir Spieldauer, Uhrzeit usw. jedes Mal abrufen.

Ja das stimmt, die sind ja auch alle um 5 verschoben.

Ich werde jetzt mal deinen Vorschlag umsetzten. Davon erhoffe ich mir am meisten.
Muss mich nur mal jetzt mit dem Regex auseinandersetzen, damit ich das hinbekomme das er alle Wörter mit geschweiften Klammern herausfiltert.

//Edit: Der Vollständigkeit halber hier das Regex Pattern "{.*}"

//Edit2: So habe jetzt eine eigene Klasse geschrieben die die Zeit genauer misst, wie Th69 vorgeschlagen hat.

Durchgänge habe ich 100.000 gewählt.

Variante1: Regex + Dictionary + Stringbuilder.Replace
=> Deutlich am langsamsten: 12,6994 Sekunden

Variante2: String.Contains + Stringbuilder.Replace
=> 2,2458 Sekunden

Variante3: String.Contains + String.Replace
=> 1,74401 Sekunden

Das einzige was ich hierbei noch nicht testen konnte waren die Abfragen mit dem SDK. Ich habe jetzt nur Dummy Werte zum ersetzen genommen.

//Edit3: Ich habe nun noch eine weitere Möglichkeit getestet, nämlich
String.Contains + String.Replace + Dictionary.

Das gruppiert sich wie erwartet, zwischen Variante 2 und 3 und ist damit zwar nicht die allerschnellste Variante, dafür aber die vom Code her sauberste.

Oh das hab ich ganz übersehen.

Das heißt das ist: 0,0000585568051407115 richtig?

Dann ist die Methode also auf jeden fall schon deutlich schneller... 👍

Ok, das wäre dann die Messung hier:
Das habe ich dann eine weile im normalen Ablauf laufen lassen und mir dann die Log Datei angeschaut.

HiPerfTimer pt = new HiPerfTimer();

pt.Start();
StringBuilder a = new StringBuilder(text);

a.Replace("{Artist}", SDK_getValue("CurrentMedia.Artist"));
a.Replace("{Title}", SDK_getValue("CurrentMedia.Title"));
a.Replace("{Album}", SDK_getValue("CurrentMedia.Album"));
a.Replace("{Position}", SDK_getValue("CurrentMedia.Position"));
a.Replace("{Duration}", SDK_getValue("CurrentMedia.Duration"));
a.Replace("{Mode}", SDK_getValue("CurrentMedia.Mode"));

string wurst = a.ToString();
pt.Stop();
WriteLog("Stringbuilder: " + pt.Duration.ToString());

pt.Start();
StringBuilder c = new StringBuilder(text);
if (text.Contains("{Artist}"))
 c.Replace("{Artist}", SDK_getValue("CurrentMedia.Artist"));
                                                                
if (text.Contains("{Title}"))
c.Replace("{Title}", SDK_getValue("CurrentMedia.Title"));
                                                                
if (text.Contains("{Album}"))
c.Replace("{Album}", SDK_getValue("CurrentMedia.Album"));
                                                                
if (text.Contains("{Position}"))
c.Replace("{Position}", SDK_getValue("CurrentMedia.Position"));
                                                                
if (text.Contains("{Duration}"))
c.Replace("{Duration}", SDK_getValue("CurrentMedia.Duration"));
                                                                
if (text.Contains("{Mode}"))
c.Replace("{Mode}", SDK_getValue("CurrentMedia.Mode"));

string wurst2 = c.ToString();
pt.Stop();
WriteLog("Stringbuilder-Contains: " + pt.Duration.ToString());

pt.Start();
if (text.Contains("{Artist}"))
text = text.Replace("{Artist}", SDK_getValue("CurrentMedia.Artist"));

if (text.Contains("{Title}"))
text = text.Replace("{Title}", SDK_getValue("CurrentMedia.Title"));

if (text.Contains("{Album}"))
 text = text.Replace("{Album}", SDK_getValue("CurrentMedia.Album"));

                                                             
if (text.Contains("{Position}"))
 text = text.Replace("{Position}", SDK_getValue("CurrentMedia.Position"));

if (text.Contains("{Duration}"))
text = text.Replace("{Duration}", SDK_getValue("CurrentMedia.Duration"));

if (text.Contains("{Mode}"))
 text = text.Replace("{Mode}", SDK_getValue("CurrentMedia.Mode"));

pt.Stop();
 WriteLog("Contains und Replace: " + pt.Duration.ToString());

Also beim Dictionary hab ich doch auch wieder das Problem, dass ich jeden Wert erst von dem SDK abrufen muss um sie einzuspeichern?

Mappingtabelle hab ich ehrlich gesagt noch nie benutzt, das müsste ich mir dann mal ansehen.

Das ist wohl eher unperformant, was?

foreach (string placeholder in placeholders)
{
    if (placeholder = "{Artist}")
       ...
    else if (placeholder = "{Title}")
     ...
}

Mit dieser Klasse hier, die nehme ich meistens für sowas:

internal class HiPerfTimer
    {
        [DllImport("Kernel32.dll")]
        private static extern bool QueryPerformanceCounter(
            out long lpPerformanceCount);

        [DllImport("Kernel32.dll")]
        private static extern bool QueryPerformanceFrequency(
            out long lpFrequency);

        private long startTime, stopTime;
        private long freq;

        // Constructor

        public HiPerfTimer()
        {
            startTime = 0;
            stopTime = 0;

            if (QueryPerformanceFrequency(out freq) == false)
            {
                // high-performance counter not supported

                throw new Win32Exception();
            }
        }

        // Start the timer

        public void Start()
        {
            // lets do the waiting threads there work

            Thread.Sleep(0);

            QueryPerformanceCounter(out startTime);
        }

        // Stop the timer

        public void Stop()
        {
            QueryPerformanceCounter(out stopTime);
        }

        // Returns the duration of the timer (in seconds)

        public double Duration
        {
            get
            {
                return (double)(stopTime - startTime) / (double)freq;
            }
        }
    }

Also ihr schlagt vor: Erst Regex um die Platzhalter zu finden und dann mit switch oder wie würdet ihr das machen?

Also ich habe grade mal einen Test der drei Varianten gemacht:

Mit einem relativ komischen Ergebnis

Variante 1: Stringbuilder
Hier werden alle Abfragen an die SDK weitergeleitet, ob der Text nun vorkommt oder nicht.

Ergebnis: Hier dauert es am längsten. Bei einer Standardabfrage. Allerdings: Umso länger das Programm läuft und die Werte gleich bleiben umso kürzer die Abfrage. (Annäherend 0)

>> Zu Beginn: 5,85568051407115E-05 , Später: 0,000104154317340446

Variante 2: Stringbuilder und String.Contains
Immer gleiche Dauer der Ausführung. Manchmal unwesentlich schneller als String.Contains & String.Replace aber fast durchgehend auf gleichem Level

>> 3,16782716334997E-05 || 4,4157590761848E-05

Variante 3: String.Replace und String.Contains
Die Ausgangsvariante. Diese ist durchschnittlich immernoch die schnellste, allerdings gibt es hier nicht diesen eigenartigen Performance Effekt, bei dem plötzlich die Dauer auf annähernd 0 herabsinkt wenn das Programm länger läuft und die Werte gleich bleiben.

>> 3,26382192587572E-05 || 2,83184549450982E-05

Ok, ich danke dir.

Das heißt: Da Stringbuilder kein Contains besitzt muss ich auf jeden Fall schon mit einer Kombination arbeiten...

Wäre ja auch zu schön gewesen.

//Edit: Eine Idee kam mir noch in den Sinn: Was meint ihr, wäre es vielleicht performanter wenn ich mit einem geeigneten Regex Befehl alle Platzhalter aufliste und dann nur diese abarbeite? Ich bin mir nicht sicher ob das schneller wäre als einzelne Contains für jeden Platzhalter.

Nach Recherche im Internet habe ich herausgefunden, dass Stringbuilder Replace performanter ist als String Replace wenn man wie ich viele Platzhalter ersetzen möchte, da beim Stringbuilder am eigentlichen String gearbeitet wird und nicht jeweils ein neuer erstellt wird der dann zugewiesen wird.

Meine Frage ist allerdings:
Wenn ich sehr viele solcher Befehle habe:

StringBuilder b = new StringBuilder(text);

b.Replace("%Artist%", SDK_getValue("CurrentMedia.Artist"));
b.Replace("%Title%", SDK_getValue("CurrentMedia.Title"));
...

Wird

SDK_getValue("CurrentMedia.Artist")

auch abgerufen wenn %Artist% nicht gefunden wurde?

Ich möchte erreichen, dass die neuen Werte auch wirklich nur dann abgerufen werden wenn der Text vorkommt. (Damit nicht unnötig viele Abfragen gemacht werden)
Reicht es also so, oder muss ich zusätzlich vorher noch ein Contains aufrufen?

Hm also bisher hab ich es noch nicht hinbekommen.
Es tut sich noch nichts. Bin nicht ganz sicher was ich als IntPtr für den neuen Cursor übergeben soll. Ist Zero da okay?

Ist das erstellen des Handles so in Orndung?

Hier mal mein Code:

HandleRef refhwnd = new HandleRef(null, wind);
com.SetClassLong(refhwnd, GCL_HCURSOR, IntPtr.Zero);

        public IntPtr SetClassLong(HandleRef hWnd, int nIndex, IntPtr dwNewLong)
        {
            if (IntPtr.Size > 4)
                return SetClassLongPtr64(hWnd, nIndex, dwNewLong);
            else
                return new IntPtr(SetClassLongPtr32(hWnd, nIndex, unchecked((uint)dwNewLong.ToInt32())));
        }

        [DllImport("user32.dll", EntryPoint = "SetClassLongPtr")]
        public static extern IntPtr SetClassLongPtr64(HandleRef hWnd, int nIndex, IntPtr dwNewLong);

        [DllImport("user32.dll", EntryPoint = "SetClassLong")]
        public static extern uint SetClassLongPtr32(HandleRef hWnd, int nIndex, uint dwNewLong);

Dann mal hier einen Auszug aus dem Code:

IntPtr wind = com.getWindow("Notepad";);
while (wind.ToInt32() == 0)
{
       Thread.Sleep(100);
       wind = com.getWindow("Notepad";);
}
IntPtr par = this.Handle;

com.SetPar(wind, par);
int style = com.GetWindow(wind, GWL_STYLE);
com.SetWindow(wind, GWL_STYLE, WS_NOBORDER);
com.SetCurs(IntPtr.Zero);

com.SetWindowPosition(wind, 0, 0);
com.SetCurs(IntPtr.Zero); //auch nochmal nach der letzten Fenster Aktivität.

Leider passiert da soweit gar nichts. com ist eine eigene Klasse die die Methoden bereitstellt.

Hier dann noch der Ausschnitt aus der Com Klasse:

public IntPtr SetPar(IntPtr hWndChil, IntPtr hWndPar)
{
       return SetParent(hWndChil, hWndPar);
}

[DllImport("USER32.DLL";)]
public static extern IntPtr SetParent(IntPtr hWndChild, IntPtr hWndNewParent);

const UInt32 SWP_NOZORDER = 0x0004;
const UInt32 SWP_SHOWWINDOW = 0x0040;

public bool SetWindowPosition(IntPtr hWnd, int x, int y)
{
       return SetWindowPos(hWnd, 0, x, y, 800, 422, SWP_NOZORDER | SWP_SHOWWINDOW);
}

[DllImport("user32.dll";)]
static extern bool SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int X,
int Y, int cx, int cy, uint uFlags);

public bool SetCurs(IntPtr cur)
{
       return SetCursor(cur);
}

[DllImport("user32.dll";)]
static extern bool SetCursor(IntPtr hcur);

Hallo,

danke schon mal für den Tip. Aber leider passiert dabei gar nichts. Ich kann die Funktion so oft aufrufen wie ich will. Der Mauszeiger wird weder ausserhalb noch über der Form versteckt.
Es muss doch eine Möglichkeit geben die Cursor Eigenschaft für ein anderes Fenster von aussen zu bestimmen?

Vielleicht weiß jemand wie man das globale Cursor Icon per Code ändern kann?

Ich habe zur Zeit folgendes Problem:
Ich schreibe ein kleines Programm für meinen CarPC. Dieses holt sich das Handle eines externen Programms (Navigationssoftware).
Danach wird der Rahmen entfernt und das Fenster per SetParent in mein Programm integriert. Nun würde ich aber aus Touchscreen gründen gerne den Mauszeiger auf dem Navigationsprogramm entfernen.

Das gestaltet sich allerdings schwieriger als erhofft. Man kommt leider nur an den Cursor des eigenen Prozesses ran. Invoke geht auch nicht weil man aus einem Handle nur ein Form Element holen kann wenn man selbst Ersteller dieses ist.

Also was tun? Die Sendmessage API bietet leider nur die Funktion den Cursor zu verschieben.

Hat jemand noch eine Idee? Ein transparentes Bild wäre natürlich auch eine Möglichkeit, allerdings genauso schwierig wenn man keinen Zugriff auf den Cursor hat.

//edit: Bisher konnte ich es auch noch nicht hinbekommen.

So wie es aussieht kann man mit der SDK nur windows media player dienste benutzen aber nicht auf den player und seine Daten zugreifen.

Hab mich jetzt nochmal umgeschaut.
Eine Möglichkeit ist ein Plugin für Windows Media Player zu schreiben, dass dann die Daten an das eigene Programm übergibt.

Es gibt einen c# Wrapper:
Wrapper

Allerdings ist diese dll nirgends mehr zu finden.

Ja soweit verstehe ich das ja, dass soll ja hier passieren:

output = Regex.Replace(zeile1text.InnerText, name_, replace_);

allerdings wird ja im ersten Durchgang z.b. aus

Hallo, es ist <uhrzeit> am <datum>

Hallo, es ist 14:56 am <datum>

und im zweiten Durchgang soll dann daraus

Hallo, es ist 14:56 am 15.12.2021 werden

und daher muss der Wert "zeile1text.InnerText" aktualisiert werden, damit beim nächsten durchlauf das 14:56 nicht vergessen wurde.

herbivore hatte gesagt das strings in C# immutable sind also nicht umgespeichert werden können, also muss zeile1text.innertext durch output ersetzt werden.

Und das habe ich mit diesem "output = output.Replace(zeile1text.InnerText, output);" zu machen...

aber ein simples

zeile1text.InnerText = output;

hätte es auch getan oO 😁

Jetzt gehts... danke an alle für die Hilfe.
Hier kann jetzt geschlossen werden.

Also zur Dokumentation der String.Replace Methode habe ich folgendes unter dieser Adresse (http://msdn.microsoft.com/library/deu/default.asp?url=/library/DEU/cpref/html/frlrfsystemstringclassreplacetopic.asp) gefunden:

public string Replace(
   string oldValue,
   string newValue

müsste dann mein Code nicht eigentlich richtig sein?
zeile1text.InnerText wird mit output überschrieben um beim nächsten durchgang weiter bearbeitet zu werden?

Der Grund wieso ich meinen Eingangspost mehr oder weniger grundlegend geändert habe ist, weil ich nach deinem Post gemerkt habe das doch einiges sehr unsinnig war.

Also habe ich die Fehler die du genannt hast verbessert und dann den ganzen Code überarbeitet.
Die Fragestellung ist allerdings die gleiche geblieben.

Hallo herbivore,

das ist echt zum verzweifeln, in dem Beispiel ist auch nirgends "ch" definiert. Ich versteh einfach nicht was damit gemeint ist.
Ich habe folgendes probiert:

Das müsste doch richtig sein oder?

                        output = output.Replace(zeile1text.InnerText, output);
                        output2 = output2.Replace(zeile2text.InnerText, output2);
                        output3 = output3.Replace(zeile3text.InnerText, output3);

aber dann wird wieder nur eine Variable mit ihrem Wert ersetzt?
Jeweils die, dessen Plugin zuletzt geladen wird.

Aber wenn ich in meinen Code

output = ouput.replace(ch)

schreibe sagt er mir immer "Der Name "ch" ist im aktuellen Kontext nicht vorhanden.
Was ist mit ch gemeint? oder was muss ich dahinschreiben?

Hallo Herbivore,

danke für den Tip, aber wie könnte ich dann den String so speichern, das beim nächsten Durchlauf der zuvor bearbeitete weiter bearbeitet wird?

Ich habe den Anfangs Beitrag jetzt auf die Lösung von der Seite (http://forums.asp.net/p/1185961/2036998.aspx#2036998) angepasst.

Hier ein Zitat der Seite:

public string strSqlBlocker(string StrValue)
        {   
            string[] BadCharacters = { "Hello", "World", "And", "How" };
            string[] GoodCharacters = { "Goodbye", "Moon", "Without", "When" };
            string strReplaced = "";
    
            int i;
            for(i=0; i9            {
               strReplaced = StrValue.Replace(BadCharacters[i], GoodCharacters[i]);
           }
   
           return strReplaced;
           
       }

Ebenfalls von der Seite kommt dieser Tip, den ich allerdings nicht verstehe, danach soll es bei demjenigen der dort ein Problem hatte funktionieren, also könnte das auch mein Problem sein.

Inside the loop do

mystring = mystring.Replace(ch);

So you always have the new string replacing the old. Makes sense?

was ist da mit ch gemeint?

Vielen Dank schon mal für die Hilfe!

Hallo,

hab mich gerade extra angemeldet weil ich mit meinem Problem einfach nicht fertig werde.
Habe schon alles abgesucht aber einfach keine Lösung gefunden.

Ich habe ein Programm geschrieben das mit Plugins gefüttert werden kann.
Diese Plugins haben eine Methode in der ein Variablenname definiert wird. (Variablename)
Das Host Programm ruft diesen Variablennamen ab und soll ihn mit dem ersetzen, was im Plugin unter (Variable) ausgegeben wird.

In einer XML Datei stehen die zu überprüfenden Strings.
Diese sollen dann nach Variablenamen aller Plugins durchsucht werden.

In der XML könnte also z.B. stehen: Hallo, es ist <uhrzeit> am <datum>

Das Ergebnis soll so aussehen: Hallo, es ist 14:23 am 15.02.2008

Es geht aber immer nur eine anzeige, entweder uhrzeit oder datum, jenachdem welches Plugin als letztes geladen wird (hängt vom Dateinamen ab)

Also so:

Hallo, es ist 14:23 am <datum>

oder so:

Hallo, es ist <uhrzeit> am 14.02.2008

mp ist ein LCD display das das ganze anzeigen soll.

Wenn nur ein Plugin vorhanden ist wird natürlich nur eins ersetzt, aber alle Plugins funktionieren einzeln.

Ich würde mich wirklich freuen wenn mir jemand helfen kann.
Sollten noch Fragen offen sein, bitte einfach fragen.

            //Die ArrayListen werden erstellt, denen die Variablenamen der einzelnen               
            //Plugins hinzugefügt werden sollen
            ArrayList variablename = new ArrayList();
            ArrayList variable = new ArrayList();
            //Der Ordner in dem nach Plugins gesucht werden soll wird definiert
            Global.Plugins.FindPlugins(Application.StartupPath + @"\Plugins");

            //In der folgenden Schleife soll für jedes Plugin einmal der Variablenname 
            //(z.B. <datum>) und der Wert (z.B: 03.02.2008) zu den Arrays hinzugefügt 
            //werden
            foreach (Types.AvailablePlugin pluginOn in Global.Plugins.AvailablePlugins)
            {
                variablename.Add(pluginOn.Instance.Variablename);
                variable.Add(pluginOn.Instance.Variable);
            }

            //Hier werden die Object Arrays zu String Arrays umgeschrieben, um sie 
            //später beim Replace Befehl benutzen zu können
            string[] name = (string[])variablename.ToArray(typeof(string));
            string[] replace = (string[])variable.ToArray(typeof(string));

            //Die Strings die nachher ausgegeben werden sollen, werden definiert.
            string output = null;
            string output2 = null;
            string output3 = null;

            //Die XML Datei mit den Ausgangs strings wird geladen
            //z.B. Es ist <uhrzeit> am <datum>
            XmlDocument xmlDoc = new XmlDocument();
            XmlNodeList nodeList = null;
            xmlDoc.Load("settings2.xml");
            nodeList = xmlDoc.DocumentElement.SelectNodes("//Einstellungen/Screens/*");
            
            //Solange der Wert vary == 1 ist wird die Schleife ausgeführt
            //Wird er in 0 verändert, durch den Button Stop, hört die Schleife beim 
            //nächsten Durchgang auf
            while (vary == 1)
            {
                foreach (XmlNode n in nodeList)
                {
                    //Die XML Knoten mit den Strings werden geladen
                    XmlNode zeile1text = xmlDoc.SelectSingleNode("//Einstellungen/Screens/" + n.Name + "/Zeile1");
                    XmlNode zeile2text = xmlDoc.SelectSingleNode("//Einstellungen/Screens/" + n.Name + "/Zeile2");
                    XmlNode zeile3text = xmlDoc.SelectSingleNode("//Einstellungen/Screens/" + n.Name + "/Zeile3");
            
                    int i;
                    //Die Ersetzen Methode soll solange arbeiten, bis alle Variablen durch 
                    //ihre Werte ersetzt wurden
                    for (i = 0; i < variablename.Count; i++)
                    {
                        //Den Werten Output wird der neue Wert zugewiesen
                        output = Regex.Replace(zeile1text.InnerText, name[i], replace[i]);
                        output2 = Regex.Replace(zeile2text.InnerText, name[i], replace[i]);
                        output3 = Regex.Replace(zeile3text.InnerText, name[i], replace[i]);
                        
                        //Hier wird der Wert zeile1text.innertext mit dem neuen wert output    
                        //ersetzt, hoffe ich?
                        output = output.Replace(zeile1text.InnerText, output);
                        output2 = output2.Replace(zeile2text.InnerText, output2);
                        output3 = output3.Replace(zeile3text.InnerText, output3);
                    }
                    //Dem LCD Display werden die fertigen Strings übergeben
                    mp.SetLine(0, output);
                    mp.SetLine(1, output2);
                    mp.SetLine(2, output3);
                    if (vary == 0)
                    {
                        mp.CleanUp();
                    }
                    //Der Thread läuft als BackgroundTask ab, damit er um die Dauer der 
                    //Anzeige angehalten werden kann
                    XmlNode dauer = xmlDoc.SelectSingleNode("//Einstellungen/Screens/" + n.Name + "/Dauer");
                    Thread.Sleep(Convert.ToInt32(dauer.InnerText));

                }
                }