C# & XAML problem!

Du kan inte uppdatera UI från annan tråd än UItråden. Du löser detta genom att göra updateringen i dispatchern. Ännu bättre är att använda sig av ett MVVM ramverk som löser dessa saker åt dig bakom huven. Kolla på Caliburn Micro grymt bra MVVM ramvekr

Om CurrentThread != this...Dispatcher.Thread så this.Dispatcher.BeginInvoke ...

Ja kolla på det, riktigt trevligt sätt att skriva UI på

BeginInvoke tar ett delegat som kommer köras på UI tråden

this.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>

{

//do something

}));

Caliburn Micro hello world
http://buksbaum.us/2010/08/01/caliburn-micro-hello-world/

Det du vill göra är något som kallas Invoke. Jag föredrar BeginInvoke då denna variant inte kan åstadkomma deadlock. BeginInvoke hakar på GUI tråden vilken är den enda tråden som tillåter kommunikation med GUI. I BeginInvoke anropar man normalt en funktion med ett delegate som motsvarar det man vill göra. Det finns många varianter på hur man vill lösa detta. Kolla MSDN på WPF BeginInvoke så får du bästa möjliga info så du lär dig behärska detta. Det är i grunden ganska enkelt men också svårt om man behöver synkronisera flera trådar. Skriver på mobilen nu så jag kan inte skriva ett exempel på rak arm, dock imorgon bitti om du så önskar.

Förutom Hello world länken jag länka till ovan kan du kolla in koden till ett av mina Open Source projekt, den använder sig av Caliburn Micro

https://github.com/AndersMalmgren/FreePIE

Nedan finner du 3 olika kodexempel. Det är lite olika när man använder vilket exempel men i detta fall göra samtliga exakt samma sak på i princip samma sätt. Om man har ett fall där man vill att flera GUI komponenter ska uppdateras och man vill säkerställa att det gör det i sekvens så är exempel 2 och 3 bra.

/************************ KODEXEMPEL 1 ************************/
// Detta exempel är mer allmänt vad gäller hur man jackar på GUI tråden för att visa händelser.
// Kod du placerar utanför metoden men i klassen eller utanförklassen för publik åtkomst (private blir då public)
#region Delegates
// Eftersom xamldoc.textbox.Text är en string behöver vi ett string delegate för att uföra BeginInvoke
// Du kan döpa delegate till vad du vill men jag brukar döpa dem så det blir enkelt att hitta rätt delegate med intellisense
private delegate void StringParamDelegate(string pString); // I C++ kallas detta funktionspekare
#endregion

// Kod du placerar i din metod
// Kontroll om körande tråd är samma som vår GUI-tråd
if (this.Dispatcher.Thread == System.Threading.Thread.CurrentThread)
{
xamldoc.textbox.Text = "meddelande du vill visa";
}
else
{
// Körande tråd skiljer sig från GUI-tråd
this.Dispatcher.BeginInvoke(new StringParamDelegate(delegate(string dText) { xamldoc.textbox.Text = dText; }),
new object[] { "meddelande du vill visa" });
}

/************************ KODEXEMPEL 2 ************************/
#region Delegates
private delegate void StringParamDelegate(string pString);
#endregion

// Kod du placerar i din metod
// Detta exempel visar hur du anropar en metod via BeginInvoke.
if (this.Dispatcher.Thread == System.Threading.Thread.CurrentThread)
{
UpdateTextBox("meddelande du vill visa");
}
else
{
// Körande tråd skiljer sig från GUI-tråd
this.Dispatcher.BeginInvoke(new StringParamDelegate(UpdateTextBox), "meddelande du vill visa");
}

private void UpdateTextBox(string pText)
{
try
{
xamldoc.textbox.Text = pText;
}
catch (Exception ex)
{
// Logga fel
}
}

/************************ KODEXEMPEL 3 ************************/
#region Delegates
private delegate void StringBoolParamDelegate(string pString, bool pBool);
#endregion

// Kod du placerar i din metod
UpdateTextBox("meddelande du vill visa");

// Anropa aldrig denna metod direkt med pInvoked = true utan låt den default vara false
private void UpdateTextBox(string pText, bool pInvoked = false)
{
try
{
if ((!pInvoked) && (this.Dispatcher.Thread != System.Threading.Thread.CurrentThread))
{
this.Dispatcher.BeginInvoke(new StringBoolParamDelegate(UpdateTextBox), pText, true);
}
else
{
xamldoc.textbox.Text = pText;
}
}
catch (Exception ex)
{
// Logga fel
}
}

NOTERA att det som i WPF genomförs med if (this.Dispatcher.Thread == System.Threading.Thread.CurrentThread) i WinForms heter if (this.InvokeRequired)

En förutsättning för att använda en dispatcher är att det finns ett Window. Om ditt fönster är dynamiskt skapat som i tex den kod du skrivit ovan så bör du istället för this.Dispatcher skriva xamldoc.Dispatcher

Du bör kanske lägga till att du inte vill att den ska skriva till din TextBox om din temp = "", typ if (!string.IsNullOrEmpty(temp.Trim()))

Vad använder du för delimiter vid sändningen av meddelanden? Om du använder null så bör du filtrera bort null från inkommande meddelande för att inte paja det för GUI.

Det är lite svårt att med så lite info säga vad som felar. Men, kan det vara så att en annan tråd i sig äger xamldoc? Om du kunde ge mer av din kod kan jag säga vad som felar, denna typ av programmering gör jag dagligen. Eftersom jag inte vet var din huvudkod körs ifrån blir det svårt att säga vilken tråd som bråkar. Om det är MainWindow som initierar client så borde det bästa vara om du i client skapar ett Event som MainWindow jackar på. När ett meddelande kommer så kickar du eventet vilket släppas upp av MainWindow och det är här du sedan gör BeginInvoke och då ska det vara this.Dispatcher.BeginInvoke eftersom this refererar till MainWindow.

Då var det som jag ungefär antog och då ska den lösning som jag föreslog fungera.

En råd på vägen är att aldrig försöka kommunicera tillbaka till ett fönster som något kom ifrån genom att skapa en ny instans av det fönster. Om du ska kommunicera tillbaka den fula vägen så bör det går genom att du när du initierar Client även skickar med en referens av fönstret enligt Client(string ip, int port, ref Window parentWindow), sedan sparar man in Konstruktorn till Client parentWindow till en static variabel. Genom att göra på detta sätt så låser man ju sin klient till att endast kunna kommunicera med WPF Window och det är inte bra men det funkar givetvis.
------------------------------------------------------------------------------------------------------------
En bättre lösning är att göra följande.
------------------------------------------------------------------------------------------------------------
* Flytta metoden UpdateTextBox till MainWindow och byt ut xamldoc till this.
* I Client.cs lägger du till följande Event som binder sig till delegatet StringParamDelegate.

public event StringParamDelegate OnNewMessage;

I Client när du mottagit ett meddelande som ska sändas vidare så gör du följande:
// Är det någon som lyssnar på mitt event
if (OnNewMessage != null)
{
// Sända meddelandet till den som lyssnar. Observera att om ditt är ett public static event så kan flera olika lyssnare få meddelandet samtidigt eftersom static betyder 1 instans totalt.
OnNewMessage("ditt meddelande");
}
else
{
// Vad göra
}

Nu kan du när du initierar din klient i MainWindow och skriver client.OnNewMessage och sedan tabbar du dig igenom så Visual Studio skapar funktionen åt dig ...vilket bör bli:
client.OnNewMessage += Client.StringParamDelegate(client_OnNewMessage);
// Med metoden
private void client_OnNewMessage(string pString)
{
if (xamldoc.Dispatcher.Thread == System.Threading.Thread.CurrentThread)
{
UpdateTextBox(pString);
}
else
{
this.Dispatcher.BeginInvoke(new StringParamDelegate(UpdateTextBox), pString);

}
}

En sak som du ska veta som är lite klurig när det gäller MessageBox är att meddelande boxen poppar för det fönster som för tillfälligt är aktivt dvs om du har en applikation med 3 fönster och poppar MessageBox i koden för fönster 1 medan fönster 3 är aktivt så kommer fönster 3 att äga MessageBoxen.

Det beror lite på hur man vill känna till om en uppkoppling är aktiv eller inte. I ditt fall kopplar den upp när du skapar en instans av Client och om det räcker med att veta status efter att instansen gjorts så är det enklast om du i Client lägger till en publik property, se nedan.

#region Properties
public bool Connected { get { return (((tcpClient != null) && (tcpClient.Connected)) ? true : false); } }
#endregion

sedan kan du i MainWindow titta på client.Connected efter raden client = new Client("192.168.1.5", 1337);