Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von Franknstein
Thema: Einsteigerfrage: Client/Server mit Remoting oder Streams ?
Am im Forum: Netzwerktechnologien

Zu dem Remoting kann ich nichts sagen, das habe ich noch nie gemacht.

Bisher habe ich immer nur mit Streams gearbeitet. Und ich weiß nicht, was dbf-Dateien sind. Aber im Prizip würde ich das so lösen:
Der Client baut beim Start eine Verbindung per TCP zum Server auf. Wenn dann eine Datei geändert/erzeugt wurde, wird diese Änderung zum Server übertragen. Ich würde dazu einfach ein Xml-Dokument erzeugen, welches verschiedene Daten des Clients und die Datei enthält. Das komprimiert man dann noch, falls es was bringt und schickt es zum Server.

Der Server wartet auf neue Verbindungen. Wenn ein Client verbindet, wird ein neuer Thread angelegt und zusammen mit einer ClientId in einer List abgelegt. Die ClientId wird dem Client geschickt. Der Client muss diese Id immer mitschicken, wenn er was zum Server überträgt. Der neu angelegte Thread macht eingentlich nur eins: Er wartet auf neue Daten vom Client. Wenn neue Daten empfangen wurden, wird das Packet mit dem Xml-Dokument zerlegt und die Datei daraus extrahiert. Dann kann man das Empfangene Packet auswerten in die Datenbank packen(, die anderen Clientes über Änderungen benachrichtigen) und dem Clienten sagen, dass alles gut verlaufen ist.

Thema: Problem mit TcpListener
Am im Forum: Netzwerktechnologien

Es wird nur so lange bis zum nächsten Zeilenumbruch gelesen, bis ein Byte den Wert 0x00 hat.

Wobei das nicht unbedingt so klappen kann. Besser währe:


StringBuilder bd = new StringBuilder();
char[] buffer = new char[1024];
while(sr.Peek() != -1)
{
    sr.Read(buffer, 0, buffer.Lenght);
    bd.Append(buffer);
}

Console.WriteLine(bd.ToString());

Das tuts nämlich auch ohne ein Zeilenumbruch!
(Falls es überhaupt funktioniert, ich habe es nicht getestet)

Thema: TcpClient kann nicht verbinden?
Am im Forum: Netzwerktechnologien

Würde ich nicht asyncron machen. Es macht zwar mehr Aufwand, wenn du die Dateien zerlegst, versendest und dann wieder zusammenbaust, aber dafür kannst du einige Vorteile nutzen. So musst du zum Beispiel dich nicht dem dem asyncronen Zeuch rumplagen. Außerdem kannst du, je nach dem wie komplex das Protokoll ist, auch noch andere, wichtigere (Steuer)Daten übertragen. Und wenn mal die Verbindung zusammenbricht, macht das auch nichts, da du ja problemlos gucken kannst, welche Packete der Datei fehlen.

Thema: TcpClient kann nicht verbinden?
Am im Forum: Netzwerktechnologien

Ist der TCPListener ordnunsgemäß gestartet? Kannst du mal bitte noch den Code mit dem Teil zeigen, bei dem eine Verbindung vom Server angenommen wird?

Noch eine Frage:
Warum gibst du die Verbindungsdaten beim Erzeugen des Objekts und beim Herstellen der Verbindung an? Ich habe die IP und den Port immer nur der Connect-Methode mitgegeben. Und in der MSDN wird die Connect garnicht aufgerufen. Dort wird direkt der Stream nach dem Erzeugen des Objekts genommen um Daten zu übertragen. Evtl. liegt da der Fehler. (Was aber irgentwie unwarscheinlich ist)

Thema: Windows dienst als socketserver
Am im Forum: Netzwerktechnologien

Hallo, du kannst auch einen Socket auf eine neue Verbindung warten lassen. Das geht laut MSDN so:


// create the socket
    Socket listenSocket = new Socket(AddressFamily.InterNetwork, 
                                     SocketType.Stream,
                                     ProtocolType.Tcp);

    // bind the listening socket to the port
IPAddress hostIP = (Dns.Resolve(IPAddress.Any.ToString())).AddressList[0];
    IPEndPoint ep = new IPEndPoint(hostIP, port);
    listenSocket.Bind(ep); 

    // start listening
    listenSocket.Listen(backlog);



Probier das halt mal. Vielleicht klappts ja, aber ich wüsste nicht, warum ein Dienst im Zusammenhang mit einem TCPListener Probleme bereitet. Villeicht liegt das Problem auch andernweilig. Vielleicht kann der Dienst nicht mehr reagierern, wenn er auf eine neue Verbindung wartet? Ich weiß es nicht.

Wenn das oben nicht klappt, kannst du ja asyncron auf eine neue Verbindung warten.
Lies dir am besten mal das hier durch:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemnetsocketssocketclassbeginaccepttopic.asp

Thema: Problem mit TcpClient
Am im Forum: Netzwerktechnologien

Den Fehler konnte ich bei mir noch nie feststellen, obwohl ich Teilweise schon TCP-Verbindungen über das Internet aufgebaut habe. Kannst du die Rahmenbedingungen des Test näher beschreiben?

Thema: Mulit-Client TcpListener
Am im Forum: Netzwerktechnologien

Ich hätte gerne noch den Code der cd.StructThread.Abort()-Methoden gesehen.

Was mir an dem Code missfällt ist, dass dort zum Beispiel immer wenn was empfangen werden soll, du dir den Stream neu greifst. Hierbei wird, denke ich, aber nicht das Problem liegen.

Ich habe immer eine Client-Klasse geschrieben, welche die Verbindung zum Clienten/Server kapselt. Dieser kann man im Konstruktor den Socket mit der Verbindung zum Clienten übergeben. Diese Instanz wird dann von der Serverklasse, die auch auf neue Verbindungen wartet, in einer Liste gespeichert. Weiterhin stellt die Klasse Client zwei Methoden zum Senden und Empfangen bereit. Das Empfangen ist aber keine öffentliche Methode, da ich immer wenn Daten empfangen werden, einen Event auslöse, der von der übergeordneten Severklasse ausgewertet wird. Wenn die Verbindung zusammenbricht, oder eine SocketException in der Client-Klasse fliegt, versuche ich den Socket zu schließen, und löse dann einen Exit-Event aus. Dieser wird auch von der Server-Klasse abgefangen und daraufhin wird der Client aus der Liste der Verbindungen geworfen. Weiterhin existieren Mechanismen um auch Timeouts von Clientseiten zu erkennen. Also wenn der Client zum Beispiel mal zwei Minuten nichts geschickt hat, wird ihm auch die Verbindung getrennt.

Thema: Mulit-Client TcpListener
Am im Forum: Netzwerktechnologien

Du musst einen Tcp-Listener Starten. Der wartet dann auf neuen Verbindungen. Wenn dann eine neue Verbindung hergestellt wird, erzeugst du einen neuen Thread der das Socket-Objekt(Oder TCP-Client-Objekt) verwaltet.

Aber warscheinlich weißt du das auch schon. Daher würde ich dich bitten, die Frage zu konkretisieren.

Thema: Höchster Wert einer Tabelle übergeben
Am im Forum: Datentechnologien

Guck mal bitte, ob der nachfolgende Code richtig funktioniert:


int height = 0;
int screen_id = -1;
foreach (DataRow row in dataSet21.TB_Screen.Rows)
{
    if((int) row["Screen_Height"] > height)
    {
        height = (int) row["Screen_Height"];
        screen_id = (int) row["Screen_Id"];
    }
}
Console.WriteLine("Maximalhöhe: {0}", height);
Console.WriteLine("Datensatznummer: {0}", screen_id);

Nachträglich angefügt:
Der Fehler mit Variable nicht zugewiesen kommt, weil die Variable in einer Schleife steht, du sie aber ,,globaler`` deklariert(?) hast. Du kannst mal testen, was passiert, wenn du w2 = "" anstatt nur string w2 schreibst.

Thema: MySQL Datenbank verwenden
Am im Forum: Datentechnologien

Der hier http://dev.mysql.com/downloads/connector/net/1.0.html ist eigentlich recht gut....

Thema: Ist C# als Server-Programmiersprache geeignet?
Am im Forum: Netzwerktechnologien

Das mit den TCP und UDP-Packeten ins Internet senden sollte fast mit am leichtesten sein. Guck mal ob da was passendes dabei ist:
http://www.microsoft.com/germany/msdn/library/net/csharp/CsharpTippsTeil1NetzwerkUndInternet.mspx
An sonsten hilft dir bestimmt das Schlüsselwort Sockt weiter.

Das aufbauen der Telefonverbindung mit der Fritzcard sollte auch gut möglich sein. Ein Bekannter von mir hat sich mal eine Freisprecheinrichtung gebaut. Das GSM-Modem hat er dabei über AT-Kommandos angesteuert. Vielleicht hilft dir der Link hier weiter:
http://www.computerjockey.de/netzwerke/at/

Zu dem VoIP kann ich so nichts sagen. Damit habe ich mich noch nie befasst.

Thema: Sql
Am im Forum: Datentechnologien

Also, die Unterstützung für den MSSql-Server 2000 ist meines Wissens immer schon standartmäßig beim Dotnet-Framework dabei. Bei dem 2005er wird der Zugriffsprovider auf alle Fälle mitgeliefert. Ich habe da nämlich vor kurzem eine Applikation für entwickelt und keine zusätzlichen Komponenten zum Verbinden zum Sql-Server gebraucht.

Thema: Sql
Am im Forum: Datentechnologien

In groben Zügen?
Das sollte doch gehen:
-Du importierst den System.Data.SqlClient-Namespace
-Du erzeugst eine Verbindung zur Datenbank mit der SqlConnection-Klasse
-Du verwendest die Verbindung nach dem öffenen um einen SqlCommand auszuführen. -Dannach kannst du mit einem SqlDataReader die evtl ausgewählten Daten hohlen.

Thema: Asynchrone Abfragen in Mysql
Am im Forum: Datentechnologien

Ich habe mir mal einen solchen selbst geschrieben. Allerdings musst du einige Dinge beachten:
a) Alle Connections die du hohlst, musst du auch wieder immer zurückgeben. Sonst blockiert der Verbindungspool alle Threads die neue Verbindungen haben wollen. Timeouts, das die Verbindungen nach der Zeit x freigegeben werden, gibt es nicht.
b) Evtl muss du die Stelle auskommentieren, an der die Datenbankverbindung genullt wird, wenn sie dem Pool wieder übergeben wird. Dann musst du dich aber darum kümmern, dass sie automatisch neu erzeugt wird, wenn die Verbindung mal kaputt gehen sollte. (Die Klasse erzeugt nämlich immer eine neue Verbindung, wenn ein Verbindungsobjekt benötigt wird, was du ja nicht willst)
c) Du solltest es vermeiden, mehrere Verbindungen im selben Thread zu verwenden, wenn das maximale Verbindungslimit zu gering ist. Sonst kannst du das ganze Programm blockieren.

Warscheinlich mag es sinnvoll sein, diese Klasse lediglich als Anregung für einen eingenen Verbindungspool heranzuziehen und selbst einen Verbindungspool für deine Bedürfnisse zu entwickeln.

So und jetzt der Quelltext:


using System;
using System.Collections.Generic;
using System.Text;
using MySQLDriverCS;
using System.Threading;

namespace Chat.Server.Database
{
    class MySqlConnectionPool
    {
        MySQLConnection[] m_Connections = null;
        private bool m_HasFreeConnection = false;
        private Queue<int> m_FreeConnections = null;
        private AutoResetEvent m_Semaphore = null;
        private int m_MaxConnections = 5;
        private string m_ConnectionString = "Der Connectionstring";

        private MySqlConnectionPool()
        {
            this.m_Connections = new MySQLConnection[this.m_MaxConnections];

            this.m_Semaphore = new AutoResetEvent(false);
            this.m_FreeConnections = new Queue<int>();
            this.m_HasFreeConnection = true;

            this.m_HasFreeConnection = true;
            for (int i = 0; i < this.m_Connections.Length; i++)
            {
                this.m_FreeConnections.Enqueue(i);
            }
        }

        private static MySqlConnectionPool m_Instance = null;
        public static MySqlConnectionPool Instance
        {
            get
            {
                if (m_Instance == null)
                    m_Instance = new MySqlConnectionPool();

                return m_Instance;
            }
        }

        public MySQLConnection Get()
        {
            if (!this.m_HasFreeConnection)
                this.m_Semaphore.WaitOne();

            int Index = this.m_FreeConnections.Dequeue();
            this.m_Connections[Index] = new MySQLConnection(
                                     this.m_ConnectionString);
            this.m_Connections[Index].Open();
            this.m_Connections[Index].Database = "chatserver";

            if (this.m_FreeConnections.Count == 0)
                this.m_HasFreeConnection = false;

            return this.m_Connections[Index];
        }

        
        public void Return(MySQLConnection connection)
        {
            try
            {
                int index = this.IndexOf(connection);
                if (this.m_Connections[index].State != System.Data.ConnectionState.Closed)
                {
                    this.m_Connections[index].Close();
                    this.m_Connections[index].Dispose();
                }
                this.m_Connections[index] = null;
                this.m_FreeConnections.Enqueue(index);
                this.m_HasFreeConnection = true;
                this.m_Semaphore.Set();
            }
            catch (Exception)
            {
                if (connection.State != System.Data.ConnectionState.Closed)
                {
                    connection.Close();
                    connection.Dispose();
                    connection = null;
                }
                throw new Exception("Fehler: Die Datenbankverbindung existiert nicht in der Datenbankverbindungsliste");
            }
        }

        private int IndexOf(MySQLConnection con)
        {
            for (int i = 0; i < this.m_Connections.Length; i++)
            {
                if (this.m_Connections[i] == con)
                {
                    return i;
                }
            }
            throw new Exception("Das angegebene Element wurde nicht gefunden");
        }
    }
}

Bearbeitet:

Hier ist noch ein kleines Beispiel, wie die Klasse zu verwenden ist:


MySQLConnection con = null;
try
{
    con = MySqlConnectionPool.Instance.Get();
    MySQLCommand com = con.CreateCommand();
    com.CommandText = "DeinSQL";
    //Hier kannst du dann deinen DataReader/etc ausführen....   
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message, ex.StackTrace);
}
finally
{
    if(con != null)
    MySqlConnectionPool.Instance.Return(con);
}

Thema: Daten senden
Am im Forum: Netzwerktechnologien

writer.Write(reader.ReadToEnd());
ersetzt du durch:


byte[] buf = new byte[1024];

while(reader.Peek() != -1)
{
    reader.Read(buf, 0, 1024);    
    stream.Write(buf, 0, 1024);
}

Also, ich habe das jetzt mal so frei Schnautze aufgeschrieben, wie es evtl funktioniert. Es kann natürlich sein, dass irgent welche Parameter zu viel sind(bei dem stream.Write), aber es sollte passen. Guck halt mal ob es funktioniert. Wenn der Code vom Syntax richtig ist, aber der Server nur die ersten 1024 Bytes empfängt, musst du halt dort auch noch eine Schleife bauen, mit der du auch nachfolgende Daten hohlst.

Evtl musst du Binärdaten aber mit Convert.ToBase64String noch in das Base64-Format umwandeln.

Thema: Asynchrone Abfragen in Mysql
Am im Forum: Datentechnologien

Also, der Mysql-Treiber lockt immer die Verbindung, wenn ein DataReader gerade Daten von einem vorausgegangenen Command abhohlt. Dann wird die Verbindung erst wieder freigegeben, wenn der Reader auch geschlossen ist. Dieses Verhalten ist bei allen mir bekannten Datenbanktreibern mehr oder weniger feststellbar. (Mit weniger meine ich, dass es z.B. beim SQL-Base-Treiber meistens mit mehreren Kommandos pro Connections in unterschiedlichen Threads gekappt hat, aber eben nicht immer)

Du solltest einen Connection-Pool verwenden, der dir Datenbankverbindungen zur Verfügung stellt. Weiterhin läufst du dann auch nicht Gefahr, dass dir ein anderer deiner Threads die Datenbankverbindung schließt während du im einen Thread noch eine Abfrage ausführst.

Thema: Daten senden
Am im Forum: Netzwerktechnologien

Wenn du den Status der Übertragung meinst, kannst du nur die Bytes mitzählen, die du schon geschrieben hast. Dazu musst du aber deinen Code etwas verändern. Dazu darfst du nämlich die Datei nicht an einem Stück in den Netzwerkstream schicken, sondern musst sie in byte-Arrays aufteilen.(Geht bestimmt auch anders - ich würde das allerdings so tuen)

Thema: FTP Server Grundlagen
Am im Forum: Netzwerktechnologien

Ich würde erstmal ein FTP-Clienten schreiben....
Dann wirst du schonmal mit der Netzwerkprogrammierung und dem FTP-Protokoll vertraut, musst dich aber noch nicht um die Serverfunktionen kümmern.
Wenn du das getan hast, kannst du ja einen Server schreiben.

Thema: Geschwindigkeit TCP<->UDP
Am im Forum: Netzwerktechnologien

Ich würde ehr den Mehraufwand aufwenden beim Protkolldesign um den Datendurchsatz zu senken. Umso weniger Daten gesendet werden, umso weniger Packete gehen verlohren und müssen nachgeschickt werden.... Und umso weniger Daten müssen verarbeitet werden. Das kostet nämlich vermutlich mehr Zeit wie das verschicken(wenn du das ungünstig machst)....

Thema: Geschwindigkeit TCP<->UDP
Am im Forum: Netzwerktechnologien

Kann man ja auch garnicht! Das eine ist dazu da, um große Mengen Daten rauszufeuern, bei denen es Egal ist ob ein Teil dieser Daten abhanden kommt. Mit dem anderen muss man etwas übertragen und sich sicher sein, dass es auf der Gegenseite ankommt.

Thema: Geschwindigkeit TCP<->UDP
Am im Forum: Netzwerktechnologien

Warum ist dir klar, dass Udp schneller sein muss?
Udp hat nur keine Fehlerkorrektur die kaputte Packete nachfordert. Wenn bei Udp ein Packet gehimmelt ist, wird es halt verworfen. Von der Geschwindigkeit ist TCP und UDP annähernd gleichschnell. Allerdings kann es passieren, dass die Daten mittels TCP langsamer übertragen werden, wenn Packete fehlen. Bei UDP verschwinden diese Packete wie gesagt aber. Weiterhin merkst du niemals bei UDP ob die Gegenseite die Packete entgegenommen hat, oder ob sie weg sind.

--
mfg
Franknstein

Thema: Problem mit TcpListener
Am im Forum: Netzwerktechnologien

Er blockt meines Wissens nur, wenn er auf neue Connections wartet. Und wenn das Programm halt beendet wird muss eben eine Threadabortexception geworfen werden um dann eine Socketexception im Thread auszulösen.

Ich hoffe das ist das, was du gemeint hast. Wenn nicht, dann erläutere bitte genauer was du damit sagen willst....

--
mfg
Frankenstein

Thema: Problem mit TcpListener
Am im Forum: Netzwerktechnologien

Es ist zwar bei diesem Beispiel nicht der Fall, da es sich um eine Konsolenapplikation handelt, aber bei mir bekommt jeder Socket einen eigenen Thread. Der TCPListener ist nichts anderes als ein Socket, und wird daher auch in einem eigenen Thread ausgeführt.

Thema: Problem mit TcpListener
Am im Forum: Netzwerktechnologien

Ok, sowas ist natürlich sehr schön. Danke für den Tipp!

Allerdings fällt mir noch ein Punkt d ein:
Du könntest in die Connection- und Client-Klasse noch Events für
-Verbindung hergstellt
-Verbindung geschlossen
-Daten gesendet
-Daten empfangen
-...
einbauen. Damit kannst du einfach andere Aktionen ausführen, wenn etwas passiert ist...

Thema: Problem mit TcpListener
Am im Forum: Netzwerktechnologien

Hast du das mit den Beispiel gemacht, das hinter den Links Client oder Server in deinem ersten Beitrag angeführt ist?

Wenn ja, dann wundert mich das nämlich nicht, da das Warten auf neue Verbindungen und das Warten auf Packete die zu empfangen sind, den derzeitigen Thread so lange blockieren, bis neue Daten zum empfangen oder neuen Verbindungen da sind:
Ich würde das so machen:

Client:


using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace NetworkTest
{
    class Client
    {
        private Socket m_Socket = null;
        private NetworkStream m_Stream = null;
        private Thread m_Thread = null;
        public Client()
        {
            this.m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            this.m_Thread = new Thread(new ThreadStart(this.Recceive));
        }

        public void Open()
        {
            this.m_Socket.Connect(Dns.GetHostEntry("localhost").AddressList, 13000);
            this.m_Stream = new NetworkStream(this.m_Socket);
            this.m_Thread.Start();
        }

        public void Close()
        {
            this.m_Thread.Abort();
            this.m_Stream.Close();
            this.m_Socket.Close();
        }

        public void Send(string msg)
        {
            try
            {
                byte[] buf = Encoding.Default.GetBytes(msg);
                this.m_Stream.Write(buf, 0, buf.Length);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.WriteLine(e.StackTrace);
            }
        }

        private void Recceive()
        {
            try
            {
                while (true)
                {
                    byte[] buffer = new byte[10240];
                    this.m_Stream.Read(buffer, 0, buffer.Length);
                    string msg = Encoding.Default.GetString(buffer).TrimEnd((char) 0x00);
                    Console.WriteLine(msg);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message); 
                Console.WriteLine(e.StackTrace);
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Client cli = new Client();
            cli.Open();
            cli.Send("Meldung vom Clienten");
        }
    }
}

Server:

namespace Server
{
    class Connection
    {
        private Thread m_Thread = null;
        private Socket m_Socket = null;
        private NetworkStream m_Stream = null;

        public Connection(Socket s)
        {
            this.m_Socket = s;
            this.m_Stream = new NetworkStream(s);
            this.m_Thread = new Thread(new ThreadStart(this.Recceive));
            this.m_Thread.Start();
        }

        private void Recceive()
        {
            try
            {
                while (true)
                {
                    byte[] buffer = new byte[10240];
                    this.m_Stream.Read(buffer, 0, buffer.Length);
                    Console.WriteLine(System.Text.Encoding.Default.GetString(buffer).TrimEnd((char) 0x00));
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.WriteLine(e.StackTrace);
            }
        }

        public void Send(string msg)
        {
            try
            {
                byte[] buffer = System.Text.Encoding.Default.GetBytes(msg);
                lock (this.m_Stream)
                {
                    this.m_Stream.Write(buffer, 0, buffer.Length);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);
            }
        }

        public void Close()
        {
            try
            {
                this.m_Thread.Abort();
                this.m_Stream.Close();
                this.m_Socket.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);
            }
        }
    }

    class TCPServer
    {
        TcpListener m_Listener = null;
        Thread m_Thread = null;
        List<Connection> m_Connections = null;

        public TCPServer()
        {
            this.m_Listener = new TcpListener(IPAddress.Any, 13000);
            this.m_Thread = new Thread(new ThreadStart(this.Run));
            this.m_Connections = new List<Connection>();
        }

        public void Start()
        {
            this.m_Listener.Start();
            this.m_Thread.Start();
        }

        public void Stop()
        {
            this.m_Thread.Abort();
            this.m_Listener.Stop();
        }

        private void Run()
        {
            try
            {
                while (true)
                {
                    Socket s = this.m_Listener.AcceptSocket();
                    Connection conn = new Connection(s);
                    this.m_Connections.Add(conn);
                    conn.Send("Hallo vom Server");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            TCPServer svr = new TCPServer();
            svr.Start();
        }
    }
}
Es gibt nur einige Punkte zu beachten:
a) Ich würde anstatt der List<Connection> eine eigene Listen-Klasse verwenden, die Möglichkeiten bietet, per IP-Addresse auf die Verbindung zuzugreifen.
b) Das ganze ist mit der Beta von VS2005 gemacht. Evtl musst du etwas verändern um es mit dem 2003er zu verwenden.
c) Du musst immer die SocketExceptions abfangen und dann die Verbindung trennen.
Nämlich immer wenn ein Socket geschlossen wird, wird auf der Gegenseite eine Socketexception fliegen... (Hauptsächlich in der Methode die auf neue Daten wartet, kann aber auch bei der Senden-Funktion passieren)

Hoffe es hilft dir weiter!

Thema: Methode von anderem Thread ausführen lassen?
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo,

Wenn ich ein Windows-Forms-Programm habe, in dem mehrere Threads existieren, dann muss ich, wenn ich von einem fremden Thread auf die WinForm-Methoden zugreifen will, dies über Winform.BeginInvoke tuen.

Allerdings ist mein Problem, dass ich keine Winform sondern eigene Klassen "synkronisieren" müsste. Daher würde es mich interessieren, wie man so etwas in seine eigenen Klassen implementiert. (Also das die Klasse eine BeginInvoke-Methode bereit stellt, mit der ich eine Funktion der Klasseninstanz in dem Thread ausführen kann, in dem auch die Klasse instanziiert wurde, obwohl ich die Funktion aus einem anderen Thread heraus aufrufe....)

Ich hoffe ich habe mich verständlich genug ausgedrückt.....


mfg
Franknstein

Thema: Dateitransfer mit AsyncCallback-Socket
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Ich würde zwar schon asyncrone Methoden benutzen, aber es sein lassen, den Threadpool zu verwenden. Nimmst du eigentlich Sockets oder so TCPClients?
Übrigens gilt es nicht, dass es dich nervt.

Thema: Dateitransfer mit AsyncCallback-Socket
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Das ist zwar nicht die Lösung, aber ich würde keinen Threadpool verwenden.
Ein Threadpool kann nur 25 Threads verwalten und wird auch von Framework verwendet. Wenn du ihn also ewig blockierst, verhinderst du, dass andere Klassen die den Pool auch nutzen , diesen sofort verwenden können. Verwalte doch mal deine Threads selbst!

Außerdem würde ich die Datei nicht in einem Rutsch übertragen, sondern in vielen kleinen Stücken. Wenn dann nämlich mal ein Bruchstück nicht übertragen werden konnte, kannst du ja dafür sorgen, es erneut zu senden.

Deinen Source habe ich mir aber aus Zeitmagel nicht angesehen.

PS:
Wenn man die Asynronen Funktionen verwendet, wird dann automatisch dies ein einem neuen Thread ausgeführt? (Also die zu tätigende Aktion wie das übertragen?)

Thema: Eigenes "Protokoll" schreiben
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Du kannst dazu eine neue Klasse erzeugen, die von der Socket oder Streamklasse erbt. Dann musst du nur noch die Methoden zum Lesen und Schreiben überschreiben und die übertragenen Bytes mitzählen. Dann weißt du genau, wie viel du übertragen hast. Oder du summierst auf eine Int64-Variable auf, wie viele Bytes du gesendet hast. Weiterhin kann du ja noch in einer Zweiten Variablen speichern, wie viele Bytes empfangen wurden.

Übrigens rate ich von dem Tutorial ab, da alle Beispiele synkron sind. Mache lieber das ganze mit AsyncCallbacks (hier).

Wenn das ganze mit Threads auf Packete wartet hat man zwar den Vorteil, dass der Quelltext leichter Verständlich ist, und man nicht so viel Programmieraufwand hat, aber wenn man das ganze mit AsyncCallbacks macht, muss man sich nicht um die Timeouts von Clients kümmern. Wenn dann nämlich jemand bei Threads die Gegenseite per Taskmanager von Windows beendet, bekommt der Socket das nicht mit und es kann passieren, dass der Thread ewig auf Daten wartet wenn man sich nicht um sein Ableben kümmert(Ich kenne das nur zu Gut! Es ging einmal sogar so weit, dass das Programm sich selbst per Process.Kill() beenden musste, weil in irgent einer Lib, auf die ich keinen Zugriff hatte, ein Thread nicht beenden wollte, wenn das Programm beendet wurde und vorher die Gegenseite sich nicht abgemeldet hat. Den Fehler zu suchen war nicht lustig. Ich habe ihn dann nach einer ewigen Zeitspanne durch Zufall entdeckt!). Wenn man aber statt dessen die AsyncCallbacks verwendet, dann kann man sich Sicher sein, dass nach der Zeit x eine SocketException fliegt. Daher würde ich auf alle Fälle die asyncr. Verbindungen bevorzugen.

Thema: Von einer Klasse ohne parameterlosem Constructor erben?
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Mein Problem ist folgendes:


using System;
using System.Net.Sockets;

namespace Test
{
	public class CNetworkstream : NetworkStream
	{

	}
}
Und es kommt folgender Fehler beim Compilieren:
No Overload for Networkstream takes 0 arguments