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 19Alex99
Thema: C# und Unity - Womit wie beginnen?
Am im Forum: Grundlagen von C#

Hallo Lalgeriano,

um Unity zu entdecken und damit Spiele zu entwickeln, kann ich dir den YouTube-Kanal von Hummelwalker sehr empfehlen ( https://www.youtube.com/user/hummelwalker).

Bin selbst großer "Fan" von diesem Kanal und finde, das dort alles gut erklärt wird und man schnell Fortschritte macht.

Thema: Eigene If-Anweisung für eigene Programmiersprache realisieren
Am im Forum: Rund um die Programmierung

Hallo,

das hier ist eine für euch wahrscheinlich sehr ungewöhnliche Frage :

Ich möchte wissen, ob und wenn ja wie, es möglich wäre, eine eigene If-Anweisung zu schreiben. Mein Ziel ist es, eine Programmiersprache zu schreiben, die auf C# basiert. Das heißt, es gibt ganz normal Klassen etc.. Die zu programmieren ist kein Problem, aber ich möchte später in meiner eigenen Programmiersprache dann auch eigene If-Abfragen verwenden können.
Ich hatte auch schon überlegt es ungefähr so zu lösen:

IF(15 + 5 = 20, ErgebnisRichtig());

Aber 100% zufriedenstellend ist diese Lösung für mich nicht. Deshalb meine Frage.

Schon mal Danke im Vorraus!

Lg Alex

Thema: Hilfe bei Chat Programm
Am im Forum: Netzwerktechnologien

Hi,

ich bin neu hier und hoffe deshalb, dass mein Thema im richtigen Forum ist.

Mein Problem ist, dass ich aus dem Internet einen Code habe, um ein Chat Server und Client zu erstellen. Also das Programm ist nicht von mir!

Ich hatte vor, dieses Programm mir anzuschauen und dann damit ein paar Sachen auszuprobieren.
Leider trat ein Fehler auf.
Fehlermeldung:

Fehler
Fehler 6 Der Typ- oder Namespacename "NewStateEventArgs" konnte nicht gefunden werden. (Fehlt eine Using-Direktive oder ein Assemblyverweis?) C:\Users\*\Chat\Program.cs 303 32 Chat
Hier das ganze Programm:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Data;

namespace Chat
{
    class Program
    {
        static void Main(string[] args)
        {
        }
        public event EventHandler<NewStateEventArgs> NewState;

        private readonly Dictionary<string, TcpClient> clientNames = new Dictionary<string, TcpClient>();
        private readonly Dictionary<TcpClient, string> clientObjects = new Dictionary<TcpClient, string>();

        private TcpListener tcpListener;
        private TcpClient client;
        private IPAddress ipAddress;
        private Thread acceptThread;
        private Thread listenThread;
        private bool isConnected;
        private bool closingClients;
        private string ip;

        /// <summary>
        /// Starts the server
        /// </summary>
        public void Start()
        {
            closingClients = false;
            ip = GetIp();

            ipAddress = IPAddress.Parse(ip);

            tcpListener = new TcpListener(ipAddress, Settings.Default.Port);
            tcpListener.Start();

            isConnected = true;

            acceptThread = new Thread(AcceptClient);
            acceptThread.Start();

            DisplayNewState(String.Format("SERVER´S IP ADDRESS: {0}", ip));
            DisplayNewState(String.Format("LISTENING TO PORT {0}", Settings.Default.Port));
        }

        /// <summary>
        /// Gets the local ip address
        /// </summary>
        /// <returns>The local ip address</returns>
        public string GetIp()
        {
            string hostName = Dns.GetHostName();
            IPHostEntry hostInfo = Dns.GetHostByName(hostName);
            return hostInfo.AddressList[0].ToString();
        }

        /// <summary>
        /// Waits for clients to be accepted
        /// </summary>
        private void AcceptClient()
        {
            while (isConnected)
            {
                try
                {
                    client = tcpListener.AcceptTcpClient();
                    listenThread = new Thread(ListenToClient);
                    listenThread.Start(client);
                }

                catch (SocketException)
                {
                    isConnected = false;
                }
            }
        }

        /// <summary>
        /// Gets all online users
        /// </summary>
        public StringBuilder GetOnlineClients()
        {
            StringBuilder clientList = new StringBuilder();
            foreach (KeyValuePair<string, TcpClient> kvp in clientNames)
            {
                clientList.Append(',' + kvp.Key);
            }

            return clientList;
        }

        /// <summary>
        /// Sends all online users to the clients
        /// </summary>
        private void SendOnlineClients()
        {
            foreach (KeyValuePair<string, TcpClient> kvp in clientNames)
            {
                SendTelegram(kvp.Key, String.Format("LIST_CLIENT|{0}|{1}", GetOnlineClients(), clientNames.Count));
            }
        }

        /// <summary>
        /// Listens to a referenced client
        /// </summary>
        /// <param name="aClient">Client to listen to</param>
        private void ListenToClient(object aClient)
        {
            TcpClient tcpClient = (TcpClient)aClient;
            bool isListening = true;

            while (isListening)
            {
                try
                {
                    NetworkStream stream = tcpClient.GetStream();
                    StreamReader reader = new StreamReader(stream);
                    string telegram = reader.ReadLine();
                    if (!String.IsNullOrEmpty(telegram))
                    {
                        ParseReceivedTelegram(tcpClient, telegram);
                    }

                    else
                    {
                        string offlineClient = String.Empty;
                        foreach (KeyValuePair<TcpClient, string> kvp in clientObjects)
                        {
                            if (kvp.Key.Equals(tcpClient))
                            {
                                offlineClient = kvp.Value;
                            }
                        }
                        clientObjects.Remove(tcpClient);
                        clientNames.Remove(offlineClient);

                        if (!closingClients)
                        {
                            if (!String.IsNullOrEmpty(offlineClient))
                            {
                                DisplayNewState(String.Format("[{0}] IS OFFLINE", offlineClient));
                                DisplayNewState(String.Format("{0} CLIENTS ONLINE", clientNames.Count));
                                SendOnlineClients();
                                SendServerMessage(String.Format("[{0}] is offline", offlineClient));
                            }
                        }
                        isListening = false;
                    }
                }

                catch (IOException)
                {
                    isListening = false;
                }
            }
        }

        /// <summary>
        /// Sends a raw message to a specified client
        /// </summary>
        /// <param name="receiverName">Username of the client</param>
        /// <param name="message">Message to be sent</param>
        public void SendTelegram(string receiverName, string message)
        {
            TcpClient c = clientNames[receiverName];
            NetworkStream stream = c.GetStream();
            StreamWriter writer = new StreamWriter(stream);
            stream.Flush();
            writer.WriteLine(message);
            writer.Flush();
        }

        /// <summary>
        /// Sends a raw message to a specified client
        /// </summary>
        /// <param name="receiver">Client object</param>
        /// <param name="message">Message to be sent</param>
        public void SendTelegram(TcpClient receiver, string message)
        {
            TcpClient clnt = receiver;
            NetworkStream stream = clnt.GetStream();
            StreamWriter writer = new StreamWriter(stream);
            writer.WriteLine(message);
            writer.Flush();
        }

        /// <summary>
        /// Parses a received telegram from a client
        /// </summary>
        /// <param name="senderClient">Sender client</param>
        /// <param name="telegram">Sent telegram</param>
        private void ParseReceivedTelegram(TcpClient senderClient, string telegram)
        {
            if (telegram != null)
            {
                string[] message = telegram.Split('|');
                string command = message[0];

                switch (command)
                {
                    case "CLIENT_ID":
                        {
                            if (!clientNames.ContainsKey(message[1]))
                            {
                                clientNames.Add(message[1], senderClient);
                                clientObjects.Add(senderClient, message[1]);
                                DisplayNewState(String.Format("NEW CLIENT REGISTERED: [{0}]", message[1]));
                                DisplayNewState(String.Format("{0} CLIENTS ONLINE", clientNames.Count));
                                foreach (KeyValuePair<string, TcpClient> kvp in clientNames)
                                {
                                    if (kvp.Key != message[1])
                                    {
                                        SendPrivateMessage("Server", kvp.Key,
                                                           String.Format("[{0}] is online", message[1]));
                                    }
                                }
                            }

                            else
                            {
                                SendTelegram(senderClient, "END_CLIENT|Username already exists.");
                            }
                            break;
                        }

                    case "MSG_PUBLIC":
                        {
                            SendPublicMessage(message[1], message[2]);
                            DisplayNewState(String.Format(@"PUBLIC MESSAGE FROM [{0}]: ""{1}""", message[1], message[2]));
                            break;
                        }

                    case "MSG_PRIVATE":
                        {
                            SendPrivateMessage(message[1], message[2], message[3]);
                            DisplayNewState(String.Format(@"PRIVATE MESSAGE FROM [{0}] TO [{1}]: ""{2}""", message[1], message[2], message[3]));
                            break;
                        }

                    case "LIST_CLIENT":
                        {
                            SendOnlineClients();
                            break;
                        }
                }
            }
        }

        /// <summary>
        /// Sends a private message to a specified client
        /// </summary>
        /// <param name="sender">Username of the sender</param>
        /// <param name="receiver">Username of the receiver</param>
        /// <param name="message">Message to be sent</param>
        private void SendPrivateMessage(string sender, string receiver, string message)
        {
            SendTelegram(receiver, String.Format("MSG_PRIVATE|{0}|{1}", sender, message));
        }

        /// <summary>
        /// Sends a public message
        /// </summary>
        /// <param name="sender">Username of the sender</param>
        /// <param name="message">Message to be sent</param>
        private void SendPublicMessage(string sender, string message)
        {
            foreach (KeyValuePair<string, TcpClient> kvp in clientNames)
            {
                if (kvp.Key != sender)
                {
                    SendTelegram(kvp.Key, String.Format("MSG_PUBLIC|{0}|{1}", sender, message));
                }
            }

        }

        /// <summary>
        /// Sends a message from the server
        /// </summary>
        /// <param name="message">Message to be sent</param>
        public void SendServerMessage(string message)
        {
            foreach (KeyValuePair<string, TcpClient> kvp in clientNames)
            {
                SendPrivateMessage("Server", kvp.Key, message);
            }
        }

        /// <summary>
        /// Displays a new server state
        /// </summary>
        /// <param name="state">State to be added</param>
        private void DisplayNewState(string state)
        {
            Newstate(this, new NewStateEventArgs(String.Format("[{0}]> {1}", DateTime.Now.ToShortTimeString(), state)));
        }

        /// <summary>
        /// Kicks the referenced client from the server
        /// </summary>
        public void KickClient(string user, string text)
        {
            SendTelegram(user, String.Format("END_CLIENT|{0}", text));
        }

        /// <summary>
        /// Stops the server
        /// </summary>
        public void Stop()
        {
            closingClients = true;
            List<string> clientsToKick = new List<string>();
            foreach (KeyValuePair<string, TcpClient> kvp in clientNames)
            {
                clientsToKick.Add(kvp.Key);
            }

            foreach (string s in clientsToKick)
            {
                KickClient(s, "The server is no longer available.");
            }

            clientNames.Clear();
            clientObjects.Clear();
            tcpListener.Stop();
            if (client != null)
            {
                client.Close();
            }
        }
    }
}

Ich hoffe, dass ihr mir helfen könnt, diesen Fehler zu beheben.
Danke schon mal fürs durchlesen!