Ich bedanke mich für die Hilfe. Es hat funktioniert =)
Danke für die Antwort.
Aber wenn ich gar nicht auf die DB zugreife, wieso funktioniert dann die Zeile
DataTable t = dataSet.Tables["Kunde"];
und wenn ich Kunde in etwas andere ändere dann nicht mehr. Eine Verbindung zu DB muss doch irgendwie vorhanden sein.
Deinen Link lese ich mir morgen früh in Ruhe durch =)
VG
Hallo,
ich habe mit der Dienstbasierten Datenbank von C# eine eine Datenbank erstellt und auch Werte eingefügt. Dann habe ich mit dem DataSet eine Verbindung hergestellt, die zweifelsohne funktioniert, da ich die Zeilen ansprechen kann. Beispielsweise funktioniert t.Columns["Name"]. t.Columns["Name2"] aber nicht. Die Verbindung steht also. In der Datenbank selber snd zwei Datensätze, die ich manuell eingeführt habe. Wenn ich mit dem folgenden Quellcode aber weitere Datensätze einfüge dann werden mir nur die beiden Datensätze ausgegeben, die ich im Quellcode eingefügt habe. In der DB sind sie auch nicht vorhanden.
DataTable t = dataSet.Tables["Kunde"];
t.Rows.Add(1, 1, 1);
t.Rows.Add(3, 6, 4);
foreach (DataRow row in t.Rows)
{
Console.WriteLine(":: ROW ::");
foreach (var item in row.ItemArray)
{
Console.WriteLine("Zeile");
Console.WriteLine(item.ToString());
}
}
Ich komme nicht auf den Fehler und wäre über Hilfe sehr dankbar.
VG
Vielen vielen Dank für deine Hilfe! Ich denke, damit komme ich gut weiter 😃 Und Auszug aus der DJP:
"Fortgeschrittene Programmieraufgaben - Netzwerkprogrammierung - TcpListener - TcpClient"
Viele Grüße
Wenn eine untergeordnete Schicht Benachrichtigungen oder Daten an obere Schichten schicken soll, so sollten dafür dann Ereignisse benutzt werden, s.a.
> .
Ich beziehe mich jetzt auf diese Aussage. Mir ist in diesem Fall nicht ganz klar wo die TCPListener als Kommunikationsschnittstelle ihren Platz finden.
Naja grundlegende Dinge sind eigentlich:
- Weil Du direkt mit TCP arbeitest, solltest Du Dir eigentlich ein Protokoll ausdenken, mit dem Du dann arbeitest. Dass Du derzeit nur einzelne Stichworte über den Kanal schickst; das mag aktuell noch funktionieren. Aber im Endeffekt betreibst Du hier ein absolutes No Go: unstrukturierte Informationen über einen Kanal schicken.
Was ist denn der Unterschied zu dem was ich getan habe, zu einem Protokoll? Es wird new dann wird der user übergeben dann die einzelnen tasks?
dann >
Daher auch meine häufigen Hinweise: vermeide TCP, wenn möglich. Dafür gibt es Abstraktionen, die einem sehr viel abnehmen (ich hab aber ehrlich gesagt immer noch nicht verstanden, wieso Du Dir das antust).
Weil es in der didaktischen Jahresplanung steht. Ich habe damit vorher auch noch nie etwas gemacht
Ich habe nun 3 Klassen gebaut. 1. die GUI:
public partial class Client : Form
{
private List<Label> labels = new List<Label>();
private List<Button> buttons = new List<Button>();
private Logic logicController;
private String name;
public delegate void addTaskDelegate(String name, List<Task> tasks, int count);
private delegate void deleteAllLabelsDelegate();
public Client()
{
logicController = new Logic(this);
InitializeComponent();
}
private void bConnect_Click(object sender, EventArgs e)
{
logicController.connect(tServer.Text, Int32.Parse(tPort.Text));
}
public void deleteAllLabels()
{
if (InvokeRequired)
Invoke(new deleteAllLabelsDelegate(deleteAllLabels), new object[] { });
else
{
foreach (Label label in labels)
{
this.Controls.Remove(label);
}
foreach (Button button in buttons)
{
this.Controls.Remove(button);
}
}
}
public void addTasks(string name, List<Task> tasks, int count)
{
if (InvokeRequired)
Invoke(new addTaskDelegate(addTasks), new object[] { name, tasks, count });
else
{
//Namen hinzufügen
Label lName = new Label();
lName.Text = name;
int yPostion = count * 25 + 53;
int xPostion = 20;
lName.Size = new Size(80, 20);
lName.Location = new Point(xPostion, yPostion);
labels.Add(lName);
this.Controls.Add(lName);
User user = new User();
user.UserName1 = name;
//Hinzuügen der einzelnen Aufgaben
for(int i = 0; i < tasks.Count; i ++) {
Button button = new Button();
button.Text = tasks.ElementAt(i).Taskname;
xPostion = (i * 120 + 110);
button.Location = new Point(xPostion, yPostion);
button.Size = new Size(100, 20);
if (tasks.ElementAt(i).State)
{
button.BackColor = Color.Green;
}
else
{
button.BackColor = Color.Red;
}
this.Controls.Add(button);
//Hinzufügen eines Events beim Drücken
button.Tag = name;
button.Click += new EventHandler(this.clickButton);
buttons.Add(button);
// user.Tasks.Add(new Task(button, tasks.ElementAt(i), false));
//lTasks.Add(new Task(button, tasks.ElementAt(i), false, user));
}
//lUser.Add(user);
}
}
public void clickButton(Object sender,
EventArgs e)
{
Button button = (Button)sender;
if (button.Tag.Equals(name))
{
logicController.sendText("*changeState");
logicController.sendText(button.Text);
}
}
private void bSend_Click(object sender, EventArgs e)
{
logicController.sendText(tText.Text);
name = tText.Text;
lNachricht.Text = "Sie sind als " + tText.Text + " angemeldet";
logicController.startThreadHandleCommunication();
}
private void bTerminateConnection_Click(object sender, EventArgs e)
{
logicController.sendText("Disconnect");
}
private void Client_Load(object sender, EventArgs e)
{
}
}
}
Die Logik Schicht:
class Logic
{
Boolean isConnected;
Data data = new Data();
Client client;
public Logic(Client client)
{
this.client = client;
isConnected = true;
}
public void connect(String address, int port)
{
data.connect(address, port);
}
private void HandleCommunication()
{
//Array, welches auf dem Panel eingefügt wird. An der ersten Stelle steht der User
List<Task> tasksTmpList;
String sDataIncomming;
String name;
Task taskTmp;
int count = 0;
while (isConnected)
{
sDataIncomming = data.readLine();
if (sDataIncomming.Equals("*New"))
{
client.deleteAllLabels();
sDataIncomming = data.readLine();
while (!sDataIncomming.Equals("/User"))
{
tasksTmpList = new List<Task>();
sDataIncomming = data.readLine();
name = sDataIncomming;
sDataIncomming = data.readLine();
if (sDataIncomming.Equals("*Tasks"))
{
sDataIncomming = data.readLine();
while (!sDataIncomming.Equals("/Tasks"))
{
taskTmp = new Task();
taskTmp.Taskname = sDataIncomming;
if (data.readLine().Equals("true"))
{
taskTmp.State = true;
}
else
{
taskTmp.State = false;
}
tasksTmpList.Add(taskTmp);
sDataIncomming = data.readLine();
}
client.addTasks(name, tasksTmpList, count++);
sDataIncomming = data.readLine();
}
}
count = 0;
}
}
}
public void sendText(String text)
{
data.send(text);
}
public void startThreadHandleCommunication()
{
Thread thread = new Thread(HandleCommunication);
thread.Start();
}
}
}
und die Data Schicht:
class Data
{
private TcpClient client;
private StreamReader sReader;
private StreamWriter sWriter;
private String lastString;
public string LastString
{
get
{
return lastString;
}
set
{
lastString = value;
}
}
public void connect(String address, int port)
{
client = new TcpClient();
client.Connect(address, port);
sReader = new StreamReader(client.GetStream(), Encoding.ASCII);
sWriter = new StreamWriter(client.GetStream(), Encoding.ASCII);
}
public void send(String text)
{
sWriter.WriteLine(text);
sWriter.Flush();
}
public void read()
{
lastString = sReader.ReadLine();
}
public String readLine()
{
return sReader.ReadLine();
}
}
Erst einmal danke für eure Antworten! Ich darf in der Schichten Architektur ja nur von oben nach unten gehen. Wenn ich nun die Methode handleCommunictation nutze, dann muss die untere Schicht doch auf die Daten warten. Erhält diese Daten müssten die in der Schicht da drüber verarbeitet werden. Und ein Thread müsste ja durchgehend abfragen ob neue Daten erhalten wurden. Dies würde doch dann den umgekehrten Weg gehen, oder?
Beste Grüße
Den Fehler habe ich gefunden. Anmerkungen zum Code würden mich trotzdem freuen 😃
Eine Art Lernhelfer. Der Client bekommt die Aufgaben und kann gucken wer fertig ist. Und dabei auch seine eigenen Aufgaben abhaken.
Der Server stellt Aufgaben zur Verfügung. Wenn das System gestartet wird erhält der Client alle Nutzer mit allen Aufgaben. Und dann soll man live sehen können, wer welche Aufgabe als erledigt makiert hat. Bzw kann man die eigenen Aufgaben dann auch als erledigt makieren.
Was ist an dem Code denn so wahnsinnig schlimm?
Beste Grüße
Hallo,
ich habe mal eine Frage: Ich habe einen Client programmiert und ich nutze die Methode HandleCommunication() um Nachrichten abzuarbeiten. Diese sieht folgendermaßen aus:
private void HandleCommunication()
{
//Array, welches auf dem Panel eingefügt wird. An der ersten Stelle steht der User
List<String> tasksTmp;
String sDataIncomming;
String name;
int count = 0;
while (isConnected)
{
sDataIncomming = sReader.ReadLine();
if (sDataIncomming.Equals("*User"))
{
tasksTmp = new List<string>();
sDataIncomming = sReader.ReadLine();
name = sDataIncomming;
sDataIncomming = sReader.ReadLine();
if (sDataIncomming.Equals("*Tasks"))
{
sDataIncomming = sReader.ReadLine();
while (!sDataIncomming.Equals("/Tasks")){
tasksTmp.Add(sDataIncomming);
sDataIncomming = sReader.ReadLine();
}
addTasks(name, tasksTmp, count++);
}
}
}
}
Wenn die äußere WhileSchleife einmal durchgelaufen ist und sich im zweiten Durchlauf befindet bricht der Thread bzw das Debugging in der Zeile ab:
while (!sDataIncomming.Equals("/Tasks")){
tasksTmp.Add(sDataIncomming);
sDataIncomming = sReader.ReadLine();// in dieser Zeile wenn der Client /Tasks erhält
Und danach ist Feierbaend und er führt das zweite addTasks nicht mehr aus. Hat irgendjmand eine Idee woran das liegen kann? Anbei noch einmal das komplette Programm.
Beste Grüße und vielen Dank!
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Station_9_Client
{
public partial class Client : Form
{
private TcpClient client;
private StreamReader sReader;
private StreamWriter sWriter;
// private List<Task> lTasks = new List<Task>();
private List<User> lUser = new List<User>();
private List<Task> lTasks = new List<Task>();
private delegate void addTaskDelegate(String name, List<String> users, int count);
private Boolean isConnected = false;
public Client()
{
InitializeComponent();
}
private void bConnect_Click(object sender, EventArgs e)
{
client = new TcpClient();
client.Connect(tServer.Text, Int32.Parse(tPort.Text));
sReader = new StreamReader(client.GetStream(), Encoding.ASCII);
sWriter = new StreamWriter(client.GetStream(), Encoding.ASCII);
isConnected = true;
}
private void HandleCommunication()
{
//Array, welches auf dem Panel eingefügt wird. An der ersten Stelle steht der User
List<String> tasksTmp;
String sDataIncomming;
String name;
int count = 0;
while (isConnected)
{
sDataIncomming = sReader.ReadLine();
if (sDataIncomming.Equals("*User"))
{
tasksTmp = new List<string>();
sDataIncomming = sReader.ReadLine();
name = sDataIncomming;
sDataIncomming = sReader.ReadLine();
if (sDataIncomming.Equals("*Tasks"))
{
sDataIncomming = sReader.ReadLine();
while (!sDataIncomming.Equals("/Tasks")){
tasksTmp.Add(sDataIncomming);
sDataIncomming = sReader.ReadLine();
}
addTasks(name, tasksTmp, count++);
}
}
}
}
private void addTasks(String name, List<String> tasks, int count)
{
if (InvokeRequired)
Invoke(new addTaskDelegate(addTasks), new object[] { name, tasks, count });
else
{
Label lName = new Label();
lName.Text = name;
int yPostion ;
User user = new User();
for(int i = 0; i < tasks.Count; i ++) {
yPostion = count * 25 + 53;
Button button = new Button();
button.Text = tasks.ElementAt(i);
int xPostion = (i * 120 + 80);
button.Location = new Point(xPostion, yPostion);
button.Size = new Size(100, 20);
button.BackColor = Color.Red;
this.Controls.Add(button);
//Hinzufügen eines Events beim Drücken
button.Click += new EventHandler(this.clickButton);
user.Tasks.Add(new Task(button, tasks.ElementAt(i), false));
//lTasks.Add(new Task(button, task, false));
}
lUser.Add(user);
}
}
public void clickButton(Object sender,
EventArgs e)
{
Button button = (Button)sender;
Task taskTmp = null;
//Suchen der konkreten Aufgabe die geändert werden soll
foreach (Task task in lTasks)
{
if (task.Taskname1.Equals(button.Text))
{
taskTmp = task;
}
}
if (taskTmp.State1 == true)
{
taskTmp.State1 = false;
taskTmp.Button1.BackColor = Color.Red;
}
else
{
taskTmp.State1 = true;
taskTmp.Button1.BackColor = Color.Green;
}
sWriter.WriteLine("*changeState");
sWriter.Flush();
sWriter.WriteLine(taskTmp.Taskname1);
sWriter.Flush();
}
private void bSend_Click(object sender, EventArgs e)
{
sWriter.WriteLine(tText.Text);
sWriter.Flush();
lNachricht.Text = "Sie sind als " + tText.Text + " angemeldet";
Thread t = new Thread(HandleCommunication);
t.Start();
}
private void bTerminateConnection_Click(object sender, EventArgs e)
{
sWriter.WriteLine("Disconnect");
sWriter.Flush();
isConnected = false;
client.Close();
}
private void Client_Load(object sender, EventArgs e)
{
}
}
}
Vielen Dank euch beiden. Das hilft mir weiter und ein frohes Fest =)
Danke erstmal für deine Antwort. Du magst damit recht haben, aber ich habe eine didaktische Jahresplanung an die ich mich halten muss. Und da steht drin: "TCPListener" und "TCPClient". Die Daten hin und her senden klappt damit wirklich gut.
Mir ist das den String Operatoren auch klar. Ich habe das für meine Beispielanwendung ebenfalls so gebaut. Ich suche jetzt allerdings nach einem Stichwort in Form für eine Literatur, die ich meinen Schülern an die Hand geben kann, dass die sich das selbständig erschliessen bzw. darauf kommen.
BG
Hey, habt ihr da vielleicht eine Idee wonach ich suchen kann um gute Literatur zu finden`? Ich möchte per TCP in C# Daten hin und hersenden und da brauche ich jetzt einen Interpreter der die Nachricht "/ChangeNameTo Stefan" interpretiert und dann den Namen ändert. Also, dass ich sozusagen mit dem Interpreter ein eigenes Protokoll entwickel? Habt ihr da vielleicht ne Idee was Stichwörter etc angeht?
Ja, ich hab die while Schleife an eine andere Stelle gesetzt:
private void bStart_Click(object sender, EventArgs e)
{
lVerbidnung.Text= "Verbunden unter dem Port: "+ tPort.Text;
Thread t = new Thread(HandleConnection);
t.Start();
}
public void HandleConnection()
{
server = new TcpListener(Int32.Parse(tPort.Text));
server.Start();
while (!isRunning)
{
TcpClient newClient = server.AcceptTcpClient();
Thread t = new Thread(new ParameterizedThreadStart(HandleClient));
t.Start(newClient);
}
}
Das ist der COde und er funktioniert. 😃
Hi Abt, danke für die Antwort. Ich hatte jetzt nicht das Gefühl, dass ich den Code nicht verstanden habe. Ich hab das if einfach übersehen und ein while draus gemacht. Ich glaube, dass es gestern einfach zu spät war 😉
Es läuft auf jeden Fall.
LG
Hi, ich nutze VisualStudio 2015 und möchte gerne einen kleinen Chat programmieren. Dafür habe ich mir ein Beispielsprogram aus dem Netz geholt. Ich schaffe es auch, dass sich Clients verbinden können. Auf der grafischen Oberfläche wird allerdings immer nur ein Client angezeigt und die Daten verarbeitet. Auch im Debugger sehe ich nicht, dass ein weiter Thread geöffnet wird. Hat vlt jemand eine Idee?
LG
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace ServerChatGrafisch
{
public partial class Index : Form
{
BackgroundWorker worker;
private TcpListener server;
private Boolean isRunning = false;
delegate void addString(String name);
private StreamReader sReader;
private StreamWriter sWriter;
public Index()
{
InitializeComponent();
}
private void bStart_Click(object sender, EventArgs e)
{
if (!isRunning)
{
lVerbidnung.Text= "Verbunden unter dem Port: "+ tPort.Text;
server = new TcpListener(Int32.Parse(tPort.Text));
server.Start();
TcpClient newClient = server.AcceptTcpClient();
Thread t = new Thread(new ParameterizedThreadStart(HandleClient));
t.Start(newClient);
}
}
private void addUser(String user)
{
if (this.listUser.InvokeRequired)
{
MethodInvoker del = delegate { addUser(user); };
this.listUser.Invoke(del);
}
else
{
this.listUser.Items.Add(user);
}
}
private void addText(String user, String text)
{
if (this.listUser.InvokeRequired)
{
MethodInvoker del = delegate { addText( user, text); };
this.lbChat.Invoke(del);
}
else
{
this.lbChat.Items.Add(user + ": " + text);
}
}
public void HandleClient(object obj)
{
String name;
TcpClient client = (TcpClient)obj;
// sets two streams
StreamWriter sWriter = new StreamWriter(client.GetStream(), Encoding.ASCII);
StreamReader sReader = new StreamReader(client.GetStream(), Encoding.ASCII);
Boolean bClientConnected = true;
String sData = null;
name = sReader.ReadLine();
addUser(name);
while (bClientConnected)
{
Thread.Sleep(5000);
// reads from stream
sData = sReader.ReadLine();
// shows content on the console.
addText(name, sData);
Console.WriteLine("Client " + name + " " + sData);
// to write something back.
sWriter.WriteLine(name + " " + sData);
sWriter.Flush();
}
}
private void lbChat_SelectedIndexChanged(object sender, EventArgs e)
{
}
}
}