Tokenparsing Hilfe

**Sky.NET** · 23.11.2011, 23:47

Hier, könnter haben, is unvollständig, unoptimiert und an manchen stellen bisschen behindert gecoded, aber wer coden kann, weiß was man damit anfängt...

nicht erschrecken, das sind ca. 2050 Zeilen, so ziemlich der größte teil einer library die ich mal geschrieben, aber nie veröffentlich habe (war mir noch nicht 'fertig' genug).
sämtlicher code kann überall verwendet werden, copyright is nicht nötig, eine erwähnung wäre aber nett...

die meisten zeilen sind bis ins kleinste detail durchkommentiert, also auch der noobigste anfänger sollte damit klarkommen...

achso, und wers gebrauchen kann : ein danke wäre nett!

Spoiler:

Klasse 'DataPaser'

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Drawing;

using System.Net;

using System.IO;



namespace KLib2

{

    public class DataParser

    {

        private char s;



        public Client client

        {

            get { return _client; }

        }

        private Client _client;



        /// <summary>

        /// Methode um Daten vom Server auszuwerten

        /// </summary>

        /// <param name="client">Der Client</param>

        /// <param name="splitter">Das Zeichen welches die Strings trennt</param>

        public DataParser(Client client, char splitter)

        {

            s = splitter;

            _client = client;

        }



        /// <summary>

        /// Wertet die Channelliste aus

        /// </summary>

        /// <param name="data">Die Daten vom Server</param>

        /// <returns>Channelliste</returns>

        public List<ChannelInChannelList> parseChannelList(string data)

        {

            List<ChannelInChannelList> chList = new List<ChannelInChannelList>();

            //Wir splitten den Channelstring in einzelne Channels auf

            //Die Channels werden durch ein "-" separiert

            string[] rawChannels = (data.Replace("b" + s, String.Empty)).Split(new string[] { s + "-" + s }, StringSplitOptions.RemoveEmptyEntries);

            //z.B. Aachen\n40\0p\0B\0pics/icon_fullChannel.gif



            //Da ja immer eine Nummer an die Unterchannels gehangen wird,

            //müssen wir einen int dafür bereitstellen

            int lastChannelNumber = 1;

            string lastChannel = String.Empty;

            foreach (string rawChannel in rawChannels)

            {

                //Ob der Channel mehrere Unterchannels hat

                bool isParent = true;

                //Der Hauptchannel über einem Subchannel

                string parentChannel = "-";

                //(komischerweise wird hier mit einem Unix-Zeilenumbruch getrennt, naja was solls)

                string channelName = rawChannel.Split('\n')[0];

                //Wenn der Channelname ein " ist, dann ist es ein Unterchannel eines vorrangegangen Channels.

                if (channelName == """ && channelName.Length == 1)

                {

                    isParent = false;

                    lastChannelNumber++;

                    parentChannel = lastChannel;

                    channelName = lastChannel + " " + lastChannelNumber.ToString();

                }

                //Manchmal gibt es z.B. den Channel Flirt 20 und dann erst Flirt 22.

                //In diesem Fall steht die nummer hinter dem ", die wir natürlich dann auch setzen

                else if (channelName.Contains("""))

                {

                    lastChannelNumber = int.Parse(channelName.Replace(""", String.Empty));

                    channelName = lastChannel + " " + lastChannelNumber.ToString();

                }

                else

                {

                    //Wenn nicht, ist es ein neuer Channel, und wir müssen die Nummer wieder auf 0 setzen.

                    lastChannel = channelName;

                    lastChannelNumber = 1;

                }

                //40

                int usersOnlineInChannel = int.Parse(rawChannel.Split('\n')[1].Split('\0')[0]);

                //p = normaler Channel ohne Zugangsvorrausetzungen

                //i = Channel mit Zugangsvorrausetzungen

                bool isRestrictedChannel = false;

                if (rawChannel.Split('\n')[1].Split(s)[1] == "i")

                    isRestrictedChannel = true;

                //B

                //Keine Ahnung, steht aber bei allen Channels dabei.



                //pics/icon_fullChannel.gif = Ein Icon was hinter dem Channel dargestellt wird,

                //können mehrere sein, daher eine Liste

                List<Image> channelImages = new List<Image>();

                //An der existenz des Bildes "icon_fullchannel.gif sehen wir on der Channel voll ist oder nicht.

                bool isFull = false;

                foreach (string str in rawChannel.Split('\n')[1].Split(s))

                {

                    if (str.Contains(".gif"))

                    {



                        string folderName = ClientHelper.imageDirectory + "/" + ClientHelper.standartPicsDirectory;

                        //Wenn wir das Bild noch nicht gespeichert haben, laden wir es herunter

                        channelImages.Add(ClientHelper.imageLoader(str, folderName, _client.chatSystem));

                        if (str.Contains("icon_fullChannel.gif"))

                            isFull = true;

                    }

                }

                // Wir fügen unseren Channel der Liste hinzu

                chList.Add(new ChannelInChannelList(channelName, usersOnlineInChannel, isRestrictedChannel, isFull, isParent, channelImages, parentChannel));

            }

            return chList;

        }



        /// <summary>

        /// Wertet die Parameter eines Channels aus

        /// </summary>

        /// <param name="data">Die Daten vom Server</param>

        /// <returns>Channel</returns>

        public Channel parseChannel(string data, bool change)

        {

            string[] parameter = data.Split(s);

            string channelName = parameter[1];

            //Bei einem wechsel wird kein nick übergeben

            string nickJoined = string.Empty;

            if (!change)

                nickJoined = parameter[2];

            //Bei dem Channel 8-ball bekommen wir ein array was 1 wert

            //mehr enthällt, bei 10 wird noch ein "-" eingeschoben

            //daher müssen wir alles was danach kommt um eins hochzählen

            //Ausserdem  wird bei einem wechsel weniger übergeben

            int x = 0;

            if (change)

                x = -9;

            //wenn andere Channels auch solche probleme machen, haben wir damit eine

            //sehr dynamische Lösung für diese, einfach noch eine if-abfrage einfügen

            //kein Ärger bei Änderungen und Updates =)

            if (channelName.StartsWith("8")) { x += 1; }



            //Vordergrundfarbe des Channels

            Color foreColor = Color.FromArgb(int.Parse(parameter[x + 11].Split(',')[0]), int.Parse(parameter[x + 11].Split(',')[1]), int.Parse(parameter[x + 11].Split(',')[2]));

            //Hintergrundfarbe des Channels

            Color backColor = Color.FromArgb(int.Parse(parameter[x + 12].Split(',')[0]), int.Parse(parameter[x + 12].Split(',')[1]), int.Parse(parameter[x + 12].Split(',')[2]));

            parameter[x + 13] = parameter[x + 13].Replace("[", String.Empty);

            parameter[x + 13] = parameter[x + 13].Replace("]", String.Empty);

            parameter[x + 14] = parameter[x + 14].Replace("[", String.Empty);

            parameter[x + 14] = parameter[x + 14].Replace("]", String.Empty);

            //Wert durch den Rot ersetzt wird (°RR°)

            Color red = Color.Red;

            if (!(parameter[x + 13] == "R"))

                red = Color.FromArgb(int.Parse(parameter[x + 13].Split(',')[0]), int.Parse(parameter[x + 13].Split(',')[1]), int.Parse(parameter[x + 13].Split(',')[2]));



            //Wert durch den Blau ersetzt wird (°BB°)

            Color blue = Color.Blue;

            if (!(parameter[x + 14] == "B"))

                blue = Color.FromArgb(int.Parse(parameter[x + 14].Split(',')[0]), int.Parse(parameter[x + 14].Split(',')[1]), int.Parse(parameter[x + 14].Split(',')[2]));



            //Eine bisher unbekannte Farbe

            Color someOtherColor = Color.FromArgb(int.Parse(parameter[x + 18].Split(',')[0]), int.Parse(parameter[x + 18].Split(',')[1]), int.Parse(parameter[x + 18].Split(',')[2]));

            //Die Standartschriftgröße des Channels

            int fontSize = int.Parse(parameter[x + 15]);

            //Der horizontale Zeilenabstand des Cahnnels



            int linePitch = int.Parse(parameter[x + 16]);

            //Bei fotoflirt ist das linepitch immer 0

            if (channelName.Contains("Foto"))

                linePitch = 0;

            //Wahrscheinlich die Zeit in der das interne Anti-Spam-Script anläuft

            //Wenn man nicht diese Zeit abstand zwischen zwei Posts lässt

            int maybeSpamTimeout = 3000;

            if (!change)

                maybeSpamTimeout = int.Parse(parameter[x + 22]);

            //Wir erstellen einen neuen Channel anhand der Infos die uns der Server gesendet hat

            Channel chl = new Channel(channelName, nickJoined, foreColor, backColor, red, blue, fontSize, linePitch, someOtherColor, maybeSpamTimeout);

            //Wenn ein Hintergrundbild eingestellt ist (kein "-" an Stelle 8 des Arrays)

            if (parameter[8].Split('/')[parameter[8].Split('/').Length - 1] != "-" && !change)

            {

                //laden wir noch unser Bild in unser Dateisystem herunter

                chl.backgroundImage = ClientHelper.imageLoader(parameter[8], ClientHelper.imageDirectory + "/" + ClientHelper.backgroundImagesDirectory, _client.chatSystem);

                //und natürlich später zum HTMLén den Pfad zur Datei

                chl.backgroundImagePath = parameter[8];

            }

            //Ob das Hintergrundbild gestreckt, zentriert oder wiederholt wird

            string repeatStrechCenter = parameter[9];



            //Wir geben den Channel zurück

            return chl;

        }



        /// <summary>

        /// Erstellt eine UserListe aus den empfangenen Daten

        /// </summary>

        /// <param name="data">Die Daten vom Server</param>

        /// <returns>UserListe</returns>

        public UserList parseUserList(string data)

        {

            //Wir splitten den empfangenen string

            string[] userListParameters = data.Split(s);

            //Der Channelname ist die zweite Stelle im array

            string channelName = userListParameters[1];

            //Dana wird immer ein user mit "-\0" gesplittet

            string[] users = data.Split(new string[] { "-" + s }, StringSplitOptions.RemoveEmptyEntries);

            //Die Userliste erstllen

            UserList channelUsers = new UserList(channelName, data);

            //Alle Userstrings durchlaufen

            foreach (string userString in users)

                //User selbst parsen (in separater Methode, wir arbeiten Objektorientiert!)

                channelUsers.Add(parseUser(userString, channelName));

            //Userliste zurückgeben

            return channelUsers;

        }



        /// <summary>

        /// Erstellt einen User aus dem Userstring

        /// </summary>

        /// <param name="userString">Der String mit den Userparametern</param>

        /// <param name="channelName">Der Channel des Users</param>

        /// <returns>User</returns>

        public User parseUser(string userString, string channelName)

        {

            //Wenn es der erste teil des Userstrings ist, muss dieser entfernt werden

            if (userString.StartsWith("u" + s + channelName))

                userString = userString.Replace("u" + s + channelName, string.Empty);

            //Nun kann man die einzelnen user-eigenschaften herausfiltern

            string[] userParameters = userString.Split(new string[] { s.ToString() }, StringSplitOptions.RemoveEmptyEntries);

            //Den Usernamen

            string userName = string.Empty;

            int age = 0;

            if (userParameters[0].Contains("\n"))

            {

                userName = userParameters[0].Split('\n')[0];

                //Das Alter

                age = int.Parse(userParameters[0].Split('\n')[1]);

            }

            else

                userName = userParameters[0];

            //Die Formatierung des Usernamens

            char userNameAppearanceFormatter = char.Parse(userParameters[1]);

            //Und die vordergrundfarbe des Users (Schriftfarbe)

            Color userForeColor = Color.Black;

            if (userParameters[2] != "B")

                userForeColor = Color.FromArgb(int.Parse(userParameters[2].Split(',')[0]), int.Parse(userParameters[2].Split(',')[1]), int.Parse(userParameters[2].Split(',')[2]));

            else if (userParameters[2] == "B")

                userForeColor = Color.Black;

            //Als nächstes müssen wir noch sehen ob an dem User bilder dranhängen

            Dictionary<string, Image> userImages = new Dictionary<string, Image>();

            //Alles nach der 3. Stelle in userParameters sind Pics



            //Die natürlich auch anzeigen ob Männlich oder Weiblich

            bool? gender = null;

            //oder andere Status

            bool away = false;

            bool cm = false;

            bool ill = false;

            bool pillowFighter = false;

            bool hasDevilsBomb = false;

            bool isNewBee = false;

            bool moderatorRights = false;

            bool vipRights = false;

            bool schützling = false;



            for (int x = 3; x <= userParameters.Length - 1; x++)

            {

                //To-Do--->

                //Auslesen aller statuspics zwecks festlegen von usereigenschaften

                //cm zb oder nose oder zzz

                //--->



                //Feststellen des Alters, wenn angegeben und im Channel angezeigt



                //Wichtig!!! Da in female "male" drinsteckt, müssen wir zuerst die weibchen

                //parsen, sonst sind auf einmal alle männlich

                if (userParameters[x].Contains("female"))

                    gender = false;

                else if (userParameters[x].Contains("male"))

                    gender = true;



                //ob der User gerade away ist

                else if (userParameters[x].Contains("away"))

                    away = true;

                //ob er cm ist

                else if (userParameters[x].Contains("cm"))

                    cm = true;

                //ob er die knuddeslgrippe hat

                else if (userParameters[x].Contains("nose"))

                    ill = true;

                //ob er gerade an einer Kissenschlacht teilnimmt

                else if (userParameters[x].Contains("pillow"))

                    pillowFighter = true;

                //ob er die Bombe des Devilsmileys hat

                else if (userParameters[x].Contains("devilbomb"))

                    hasDevilsBomb = true;

                //ob er ein newbie ist

                else if (userParameters[x].Contains("newUser"))

                    isNewBee = true;

                //ob er der Schützling des eingeloggten Nicks ist

                else if (userParameters[x].Contains("schaf"))

                    schützling = true;

                //ob er Mod-Status hat

                else if (userParameters[x].Contains("moderator"))

                    moderatorRights = true;

                //ob er VIP-Status hat

                else if (userParameters[x].Contains("vip"))

                    vipRights = true;

                //Hier laden wir das Bild in unser Filesystem und fügen es zur Imagelist des users hinzu

                userImages.Add(userParameters[x], ClientHelper.imageLoader(userParameters[x], ClientHelper.imageDirectory + "/" + ClientHelper.standartPicsDirectory, _client.chatSystem));

            }

            //Den User erstellen mit den Standartwerten

            User usr = new User(userName, gender, userNameAppearanceFormatter, userForeColor, userImages);

            //Die verschiedenen Bilderabhängigen Status setzen

            usr.cm = cm; usr.ill = ill; usr.pillowFighter = pillowFighter;

            usr.hasDevilsBomb = hasDevilsBomb; usr.isNewBee = isNewBee;

            usr.schützling = schützling; usr.moderatorRights = moderatorRights;

            usr.vipRights = vipRights;



            if (age != 0)

                usr.age = age;



            return usr;

        }



        public User parseUserJoinsChannel(string data)

        {

            string[] userParameters = data.Split(s);



            string userName = string.Empty;

            int age = 0;

            if (userParameters[2].Contains("\n"))

            {

                age = int.Parse(userParameters[2].Split('\n')[1]);

                userName = userParameters[2].Split('\n')[0];

            }

            else

                userName = userParameters[2];



            char userNameAppearanceFormatter = char.Parse(userParameters[3]);

            Color userForeColor = Color.FromArgb(int.Parse(userParameters[4].Split(',')[0]), int.Parse(userParameters[4].Split(',')[1]), int.Parse(userParameters[4].Split(',')[2]));



            Dictionary<string, Image> userImages = new Dictionary<string, Image>();

            bool? gender = null;

            int y = 0;

            for (int x = 5; x <= userParameters.Length - 1; x++)

            {

                if (userParameters[x] == "-")

                {

                    y = x + 1;

                    break;

                }

                if (userParameters[x].Contains("female"))

                    gender = false;

                else if (userParameters[x].Contains("male"))

                    gender = true;

                userImages.Add(userParameters[x], ClientHelper.imageLoader(userParameters[x], ClientHelper.imageDirectory + "/" + ClientHelper.standartPicsDirectory, _client.chatSystem));

            }



            string channelLeaved = null;

            //Der Channel der verlassen wurde

            if (userParameters[y] != "")

                channelLeaved = userParameters[y];



            string channelJoined = null;

            //Der Channel der betreten wurde

            if (userParameters[1] != "-")

                channelJoined = userParameters[1];



            User usr = new User(userName, gender, userNameAppearanceFormatter, userForeColor, userImages, channelJoined, channelLeaved);



            if (age != 0)

                usr.age = age;



            //zwei bisher nicht bekannte Informationen

            string unknownArgument1 = userParameters[userParameters.Length - 2];

            string unknownArgument2 = userParameters[userParameters.Length - 1];





            return usr;

        }



        /// <summary>

        /// Parsed eine öffentliche Nachricht zurecht

        /// </summary>

        /// <param name="data">Die Daten vom Server</param>        

        /// <returns>PublicMessage</returns>

        public PublicMessage parsePublicMessage(string data, bool function)

        {

            string[] messageParameters = data.Split(s);

            string sender = messageParameters[1];



            string channel = messageParameters[2];

            string message = messageParameters[3];

            string imageName = null;



            if (sender == ">")

            {

                sender = KCode.ToHTML("°BB°_>; ", _client.actualChannel);

            }



            Image img = null;

            String imagePath = null;



            string sizer = null;

            if (messageParameters.Length > 4)

            {

                imageName = messageParameters[4];

                imageName = imageName.Substring(imageName.LastIndexOf("/") + 1);

                imageName = imageName.Replace("?", "´");

                imageName = imageName.Replace("%", "~");

                if (imageName.StartsWith("knuddels.de"))

                {

                    string directory = ClientHelper.imageDirectory + "/" + ClientHelper.userPicsDirectory + "/" + ClientHelper.userPicsThumbs;

                    img = ClientHelper.imageLoader(messageParameters[4], directory, this._client.chatSystem);

                    imagePath = new FileInfo(ClientHelper.imageDirectory + @"" + ClientHelper.userPicsDirectory + @"" + ClientHelper.userPicsThumbs + @"" + imageName).FullName;

                }

                else

                {

                    string directory = ClientHelper.imageDirectory + "/" + ClientHelper.standartPicsDirectory;

                    img = ClientHelper.imageLoader(messageParameters[4], directory, this._client.chatSystem);

                    imagePath = new FileInfo(ClientHelper.imageDirectory + @"" + ClientHelper.standartPicsDirectory + @"" + imageName).FullName;

                }

            }



            string fotoFlirtHTML = "";

            if (channel.Contains("FotoFlirt"))

            {

                fotoFlirtHTML = "<tr><td><div style ="width="40""></td><td><hr style="border:none;border-top: 1px solid #333333;background-color:#000000;height:1px;"></div></td></tr>";

            }

            if (_client.useHTMLEngine)

            {

                if (img == null)

                    sender =

                        fotoFlirtHTML +

                        "<a href="/serverpp " + messageParameters[1] + "|/w " + messageParameters[1] + "" style ="text-decoration:none; color:" + ColorTranslator.ToHtml(_client.userChannels[channel].foreColor) + ";" <b>" + messageParameters[1] + "</b></a>";

                else

                {

                    sender =

                        "<table width="100%" height="1%" border="0" cellpadding="0" cellspacing="0">" +

                        fotoFlirtHTML +

                        "<tr><td width="40" height="40" style="vertical-align:top;"><img src="" + "file:///" + imagePath + "" width="40" height="40" style="border:1px solid #FFFFFF;" ></td>" +

                        "<td valign="middle" >" +

                        "<a class="std" href="/serverpp " + messageParameters[1] + "|/w " + messageParameters[1] + "">" + messageParameters[1] + "</a>";

                    message = message + "</tr></td></table>";

                }



                if (messageParameters[1] == ">")

                {

                    sender =

                        "<table width="100%" height="1%" border="0" cellpadding="0" cellspacing="0">" +

                        fotoFlirtHTML +

                        "<td width="1%" style="vertical-align:top;"><img src="" + "file:///" + imagePath + "" width="40" height="40"></td>" +

                        "<td valign="middle">" +

                        messageParameters[1] + "</a>";

                }

            }



            return new PublicMessage(sender, channel, message, function);

        }



        /// <summary>

        /// Parsed eine private Nachricht zurecht

        /// </summary>

        /// <param name="data">Die Daten vom Server</param>

        /// <returns>Private Message</returns>

        public PrivateMessage parsePrivateMessage(string data)

        {

            string[] messageParameters = data.Split(s);



            string sender = messageParameters[1];

            List<string> receivers = new List<string>();



            if (messageParameters[2].Contains(", "))

                receivers.AddRange(messageParameters[2].Split(new string[] { ", " }, StringSplitOptions.RemoveEmptyEntries));

            else

                receivers.Add(messageParameters[2]);



            string fromChannel = messageParameters[3];

            //Wenn die Nachricht aus einem Channel kommt in dem wir uns gerade befinden

            //wir dies durch ein "-" an Stelle des Channelnamens angezeigt

            if (fromChannel == "-")

                fromChannel = _client.actualChannel.channelName;



            string message = messageParameters[4];



            return new PrivateMessage(sender, receivers, fromChannel, message);

        }









        //Da es zuviele verschiedene Fenster gibt,

        //Gibt es extra eine Methode um Fenster zu parsen        

        public void WindowParser(string[] WindowTokens)

        {



        }

    }

}[/highlight]



Commands.cs

[highlight=csharp]using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using KLib2.Kodierungen;

using System.Windows.Forms;



namespace KLib2

{

    public class Commands

    {

        private char s;



        public Client client { get { return c; } }

        private Client c;



        private event EventHandler<ChannelLeftEventargs> _OnChannelLeft;



        public Commands(Client client, char splitter, EventHandler<ChannelLeftEventargs> OnChannelLeft)

        { c = client; s = splitter; _OnChannelLeft = OnChannelLeft; }



        /// <summary>

        /// Der Befehl zum Ausloggen

        /// </summary>

        public void Exit()

        { c.SendRaw("d"); }



        /// <summary>

        /// Einen Channel betreten

        /// </summary>

        /// <param name="channelName">Name des Channels</param>

        public void JoinToChannel(string channelName, string nickName, string password, string passKey)

        {

            PasswordHash pwh = new PasswordHash(passKey);

            c.SendRaw("n" + s + channelName + s + nickName + s + pwh.GetHashedPassword(password).ToString());

        }



        /// <summary>

        /// Sendet den Befehl um die UserList eines Channels zu holen

        /// </summary>

        /// <param name="channel">Name des Channels</param>

        public void getUserInChannel(string channel)

        {

            c.SendRaw("r" + channel);

        }



        /// <summary>

        /// Verlässt einen Channel wieder

        /// </summary>

        /// <param name="channelName">Name des Channels</param>

        public void LeaveChannel(string channelName, EventHandler<LoggedInStateChangedEventArgs> OnLoggedInStateChanged)

        {

            c.SendRaw("w" + s + channelName);

            if (_OnChannelLeft != null)

                _OnChannelLeft(c, new ChannelLeftEventargs(channelName));

            c.userChannels.Remove(channelName);



            if (c.userChannels.Count == 0)

            {

                c.loggedIn = false;

                if (OnLoggedInStateChanged != null)

                    OnLoggedInStateChanged(this, new LoggedInStateChangedEventArgs(c.loggedIn));

            }

        }



        /// <summary>

        /// Sendet eine Öffentliche Nachricht an einen Channel

        /// </summary>

        /// <param name="pubM">Die öffentliche Nachricht</param>        

        public void SendPublicMessage(PublicMessage pubM)

        {

            c.SendRaw("e" + s + pubM.channel + s + pubM.message);

        }



        /// <summary>

        /// Sendet eine Private Nachricht an den Chat

        /// </summary>

        /// <param name="pm">Die Private Nachricht die gesendet werden soll</param>

        public void SendPrivateMessage(PrivateMessage pm)

        {

            string receivers = "";



            if (pm.receiver.Count > 1)

                for (int i = 0; i <= pm.receiver.Count; i++)

                    if (i == 0)

                        receivers += pm.receiver[i];

                    else

                        receivers += "," + pm.receiver[i];

            else

                receivers = pm.receiver[0];



            c.SendRaw("e" + s + pm.fromChannel + s + "/p " + receivers + ":" + pm.message);

        }



        /// <summary>

        /// Sendet eine ChatMail an einen Chatter (/m)

        /// </summary>

        /// <param name="chatMail">Die zu sendende ChatMail</param>

        public void SendChatMail(ChatMail chatMail)

        {

            if (chatMail.Betreff != string.Empty && chatMail.Betreff != "" && chatMail.Betreff != null)

                c.SendRaw("e" + s + chatMail.channel + s + "/m " + chatMail.Empfänger + ":" + chatMail.Betreff + "§" + chatMail.Nachricht);

            else

                c.SendRaw("e" + s + chatMail.channel + s + "/m " + chatMail.Empfänger + ":" + chatMail.Nachricht);

        }



    }

}

**Sky.NET** · 23.11.2011, 23:48

ClientHelper.cs

[csharp]using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.IO;
using System.Net;
using System.Windows.Forms;
using System.Threading;

namespace KLib2
{
public class ClientHelper
{
//Das Verzeichnis indem Wir Bilder speichern
public const string imageDirectory = "Images";
//Die Standartbilder vom Chat
public const string standartPicsDirectory = "StandartImages";
//Die Standart-Channelhintergrundbilder
public const string backgroundImagesDirectory = "BackgroundImages";
//Die Smileys
public const string smileyPicsDirectory = "SmileyImages";
//Die Benutzerbilder
public const string userPicsDirectory = "UserImages";
//Die Thumbs der BEnutzerbilder
public const string userPicsThumbs = "Thumbs";

public static string root = "file:///" + Environment.CurrentDirectory;

/// <summary>
/// Lädt Bilder des Chats herunter und gibt sie als Image zurück
/// </summary>
/// <param name="relativeUri">Der Realtive Pfad (vom Server) zum Bild</param>
/// <param name="folderName">Der gewünschte Speicherort auf der Festplatte</param>
/// <param name="chatSystem">Die Url des Chatsystems</param>
/// <returns>Ein Bild, frisch vom Server geladen</returns>
public static Image imageLoader(string relativeUri, string folderName, string chatSystem)
{
//Das meist noch pics/ vor dem Bild steht, und uns das nicht interessiert
//Splitten wir das und nehmen nur den richtigen Bildnamen
string imageName = string.Empty;
if (relativeUri.Contains('/'))
imageName = relativeUri.Split('/')[relativeUri.Split('/').Length - 1];
else
imageName = relativeUri;
string url = string.Empty;

imageName = imageName.Replace("?", "´");
imageName = imageName.Replace("%", "~");

//Wir prüfen ob das Bild schon existiert und laden das Pic runter wenn nicht
if (!File.Exists(folderName + "/" + imageName))
{
//Die url
if (!relativeUri.Contains("pics"))
url = chatSystem + "/pics/" + relativeUri;
else
url = chatSystem + "/" + relativeUri;

if(!url.StartsWith("chat."))
url = "http://chat." + url;
else
url = "http://" + url;

//Mit dem Webclient können wir vernünftig Bilder herunterladen
try
{
byte[] picture = new WebClient().DownloadData(url);
File.WriteAllBytes(folderName + "/" + imageName, picture);
Thread.Sleep(150);
}
catch
{
MessageBox.Show(url);
}
}
//Egal ob das Bild nun schon da war oder nicht, wir haben es und geben es zurück
try
{
return Image.FromFile(folderName + "/" + imageName);
}
catch (Exception ex)
{
MessageBox.Show(relativeUri + "\r\n" + url + "\r\n" + folderName + "/" + imageName);
MessageBox.Show(ex.ToString());
return null;
}
}
}
}[csharp]

UserList.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace KLib2
{
public class UserList : List<User>
{
private string _ownerChannel;
public string ownerChannel { get { return _ownerChannel; } }

private string _ReceivedData;
public string RevceivedData { get { return _ReceivedData; } }

public UserList(string ownerChannel, string ReceivedData)
{ _ownerChannel = ownerChannel; _ReceivedData = ReceivedData; }
}
}





Channel.cs

 [highlight=csharp]using System;

 using System.Collections.Generic;

 using System.Linq;

 using System.Text;

 using System.Drawing;

 

 namespace KLib2

 {

     public class Channel

     {

         private string _channelName;

         public string channelName { get { return _channelName; } set { _channelName = value; } }

 

         private string _nickJoined;

         public string nickJoined { get { return _nickJoined; } }

 

         private Image _backgroundImage;

         public Image backgroundImage

         {

             get { return _backgroundImage; }

             set { _backgroundImage = value; }

         }

 

         private string _backgroundImagePath;

         public string backgroundImagePath

         {

             get { return _backgroundImagePath; }

             set { _backgroundImagePath = value; }

         }

 

         private Color _foreColor;

         public Color foreColor { get { return _foreColor; } }

 

         private Color _backColor;

         public Color backColor { get { return _backColor; } }

 

         private Color _red;

         public Color red { get { return _red; } }

 

         private Color _blue;

         public Color blue { get { return _blue; } }

 

         private Color _someOtherColor;

         public Color someOtherColor { get { return _someOtherColor; } }

 

         private int _fontSize;

         public int fontSize { get { return _fontSize; } }

 

         private int _linePitch;

         public int linePitch { get { return _linePitch; } }

 

         private int _maybeSpamTimeout;

         public int maybeSpamTimeout { get { return _maybeSpamTimeout; } }

 

         private List<User> _userList;

         public List<User> UserList

         {

             get { return _userList; }

             set { _userList = value; }

         }

         private string _repeatStretchCenter;

         public string RepeatStretchCenter

         {

             get { return _repeatStretchCenter; }

             set { _repeatStretchCenter = value; }

         }

 

         private string _UserListString;

         public string UserListString

         {

             set { _UserListString = value; }

             get { return _UserListString; }

         }

 

         public Channel(string channelName, string nickJoined,

             Color foreColor, Color backColor, Color red, Color blue,

             int fontSize, int linePitch, Color someOtherColor, int maybeSpamTimeout)

         {

             _channelName = channelName;

             _nickJoined = nickJoined;

 

             _foreColor = foreColor;

             _backColor = backColor;

             _red = red;

             _blue = blue;

             _someOtherColor = someOtherColor;

 

             _fontSize = fontSize;

             _linePitch = linePitch;

             _maybeSpamTimeout = maybeSpamTimeout;

         }

     }

 }

__________________
Klasse ChannelInChannelList

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Drawing;



namespace KLib2

{

    public class ChannelInChannelList

    {

        private string _channelName;

        public string channelName { get { return _channelName; } }



        private int _usersOnline;

        public int usersOnline { get { return _usersOnline; } }



        private bool _isRestrictedChannel;

        public bool isRestrictedChannel { get { return _isRestrictedChannel; } }



        private bool _full;

        public bool full { get { return _full; } }



        private List<Image> _imageList;

        public List<Image> imageList { get { return _imageList; } }



        private bool _isParent;

        public bool isParent { get { return _isParent; } }



        private string _parentChannel;

        public string parentChannel { get { return _parentChannel; } }



        /// <summary>

        /// Erzeugt einen neuen Channel in der globalen Channelliste

        /// </summary>

        /// <param name="channelName">Der Channelname</param>

        /// <param name="usersOnline">Wieviele User dort Online sind</param>

        /// <param name="isRestrictedChannel">Ob der Channel Zutrittsberechtigungen hat</param>

        /// <param name="full">Ob der Channel voll ist</param>

        /// <param name="imageList">Bilder des Channels</param>       

        public ChannelInChannelList(string channelName, int usersOnline, bool isRestrictedChannel, bool full, bool isParent, List<Image> imageList,string parentChannel)

        {

            _channelName = channelName;

            _usersOnline = usersOnline;

            _isRestrictedChannel = isRestrictedChannel;

            _full = full;

            _imageList = imageList;

            _isParent = isParent;

            _parentChannel = parentChannel;

        }

    }

}

Klasse ChatMail



using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace KLib2

{

    public class ChatMail

    {

        private string _absender;

        private string _empfänger;

        private string _nachricht;

        private string _betreff;

        private string _datum;

        private string _signatur;

        /// <summary>

        /// Liefert den Absender der /m zurück

        /// </summary>

        public string Sender

        {

            get { return _absender; }

        }

        /// <summary>

        /// Liefert den Empfänger der /m zurück

        /// </summary>

        public string Empfänger

        {

            get { return _empfänger; }

        }

        /// <summary>

        /// Liefert den Inhalt der /m zurück

        /// </summary>

        public string Nachricht

        {

            get { return _nachricht; }

        }

        /// <summary>

        /// Liefert den Betreff der /m zurück

        /// </summary>

        public string Betreff

        {

            get { return _betreff; }

        }

        /// <summary>

        /// Liefert das Sendedatum der /m zurück

        /// </summary>

        public string Datum

        {

            get { return _datum; }

        }

        /// <summary>

        /// Liefert die Signatur der /m zurück

        /// </summary>

        public string Signatur

        {

            get { return _signatur; }

        }



        /// <summary>

        /// Eine empfangene Mail (/m)

        /// </summary>

        /// <param name="absender">Absender</param>

        /// <param name="empfänger">Empfänger</param>

        /// <param name="nachricht">Nachricht</param>

        /// <param name="betreff">Betreff</param>

        /// <param name="datum">Datum</param>

        /// <param name="signatur">Signatur</param>        

        public ChatMail(string sender, string receiver, string body, string subject, string dateTime, string signature)

        {

            _absender = sender;

            _betreff = subject;

            _datum = dateTime;

            _empfänger = receiver;

            _nachricht = body;

            _signatur = signature;

        }



        private string _channel;

        public string channel { get {return _channel; } }



        /// <summary>

        /// Eine zu sendende Mail (/m)

        /// </summary>

        /// <param name="receiver">Empfänger der Mail</param>

        /// <param name="body">Nachricht der Mail</param>

        /// <param name="subject">Betreff der Mail</param>

        /// <param name="channel">Der Channel aus dem die Nachricht gesendet werden soll</param>

        public ChatMail(string receiver, string body, string subject, string channel)

        {

            _betreff = subject;

            _empfänger = receiver;

            _nachricht = body;

            _channel = channel;

        }



    }



}

__________________
Klasse PrivateMessage.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace KLib2

{

    public class PrivateMessage

    {

        private string _message;

        public string message { get { return _message; } set { _message = value; } }



        private string _sender;

        public string sender { get { return _sender; } set { _sender = value; } }



        private string _fromChannel;

        public string fromChannel { get { return _fromChannel; } }



        private List<string> _receiver;

        public List<string> receiver { get { return _receiver; } }



        /// <summary>

        /// Eine empfangene private Nachricht (/p)

        /// </summary>

        /// <param name="sender">Absender der Nachricht</param>

        /// <param name="receiver">Empfänger der Nachricht</param>

        /// <param name="fromChannel">Absenderchannel</param>

        /// <param name="message">Nachricht</param>

        public PrivateMessage(string sender, List<string> receiver, string fromChannel, string message)

        {

            _receiver = receiver;

            _sender = sender;

            _message = message;

            _fromChannel = fromChannel;

        }

        /// <summary>

        /// Eine zu sendende parivate Nachricht (/p)

        /// </summary>        

        /// <param name="receiver">Empfänger der Nachricht</param>

        /// <param name="fromChannel">Absenderchannel</param>

        /// <param name="message">Nachricht</param>

        public PrivateMessage(List<string> receiver, string fromChannel, string message)

        {

            _receiver = receiver;            

            _message = message;

            _fromChannel = fromChannel;

        }



    }

}[/highlight]



Klasse PublicMessage.cs

[highlight=csharp]using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Drawing;



namespace KLib2

{

    public class PublicMessage

    {

        private string _message;

        public string message { get { return _message; } set { _message = value; } }



        private string _sender;

        public string sender { get { return _sender; } set { _sender = value; } }



        private string _channel;

        public string channel { get { return _channel; } }



        private bool _function;

        public bool function { get { return _function; } }



        private Image _leadingImage;



        public Image LeadingImage

        {

            get { return _leadingImage; }            

        }



        private string _leadingImagePath;



        public string LeadingImagePath

        {

            get { return _leadingImagePath; }            

        }



        /// <summary>

        /// Eine eingehende Nachricht die geparsed werden soll

        /// </summary>

        /// <param name="sender">Der Absender</param>

        /// <param name="channel">Der Channel in dem es geschrieben wurde</param>

        /// <param name="message">Die Nachricht</param>

        public PublicMessage(string sender, string channel, string message, bool function, Image leadingImage, string leadingImagePath)

        {

            _sender = sender;

            _message = message;

            _channel = channel;

            _function = function;

            _leadingImage = leadingImage;

            _leadingImagePath = leadingImagePath;

        }



        /// <summary>

        /// Eine eingehende Nachricht die geparsed werden soll

        /// </summary>

        /// <param name="sender">Der Absender</param>

        /// <param name="channel">Der Channel in dem es geschrieben wurde</param>

        /// <param name="message">Die Nachricht</param>

        public PublicMessage(string sender, string channel, string message, bool function)

        {

            _sender = sender;

            _message = message;

            _channel = channel;

            _function = function;

        }



        /// <summary>

        /// Eine Ausgehende Nachricht die gesendet werden soll

        /// </summary>

        /// <param name="channel">Der Channel an den die Nachricht gehen soll</param>

        /// <param name="message">Die Nachricht</param>

        public PublicMessage(string channel, string message)

        {

            _message = message;

            _channel = channel;

        }



    }

}

Klasse User.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Drawing;



namespace KLib2

{

    public class User

    {

        private string _nickName;

        public string nickName { get { return _nickName; } }



        private char _userNameAppearanceFormatter;

        public char userNameAppearanceFormatter { get { return _userNameAppearanceFormatter; } }



        private Color _userForeColor;

        public Color userForeColor { get { return _userForeColor; } }



        private Dictionary<string,Image> _userListPics;

        public Dictionary<string, Image> userListPics { get { return _userListPics; } }



        private UserProfile _userProfile;

        public UserProfile userProfile

        {

            get { return _userProfile; }

            set { _userProfile = value; }

        }



        private int _age;

        public int age

        {

            get { return _age; }

            set { _age = value; }

        }

        private bool _away;

        public bool away

        {

            get { return _away; }

            set { _away = value; }

        }

        private bool _cm;

        public bool cm

        {

            get { return _cm; }

            set { _cm = value; }

        }

        private bool _ill;

        public bool ill

        {

            get { return _ill; }

            set { _ill = value; }

        }

        private bool _pillowFighter;

        public bool pillowFighter

        {

            get { return _pillowFighter; }

            set { _pillowFighter = value; }

        }

        private bool _hasDevilsBomb;

        public bool hasDevilsBomb

        {

            get { return _hasDevilsBomb; }

            set { _hasDevilsBomb = value; }

        }

        private bool _isNewBee;

        public bool isNewBee

        {

            get { return _isNewBee; }

            set { _isNewBee = value; }

        }

        private bool _schützling;

        public bool schützling

        {

            get { return _schützling; }

            set { _schützling = value; }

        }

        private bool _moderatorRights;

        public bool moderatorRights

        {

            get { return _moderatorRights; }

            set { _moderatorRights = value; }

        }

        private bool _vipRights;

        public bool vipRights

        {

            get { return _vipRights; }

            set { _vipRights = value; }

        }



        /// <summary>

        /// W=false, M=True, N/A=null.

        /// </summary>

        private bool? _gender;

        public bool? gender

        {

            get { return _gender; }

        }



        /// <summary>

        /// Ein normaler User

        /// </summary>

        /// <param name="nickName">Nickname</param>

        /// <param name="gender">Geschlecht</param>

        /// <param name="userNameAppearanceFormatter">Schriftformatierung</param>

        /// <param name="userForeColor">Vordergrundfarbe</param>

        /// <param name="userListPics">Bilder</param>

        public User(string nickName, bool? gender, char userNameAppearanceFormatter, Color userForeColor, Dictionary<string, Image> userListPics)

        {

            _gender = gender;

            _nickName = nickName;

            _userNameAppearanceFormatter = userNameAppearanceFormatter;

            _userForeColor = userForeColor;

            _userListPics = userListPics;

        }



        private string _channelJoined;

        public string channelJoined { get { return _channelJoined; } set { _channelJoined = value; } }



        private string _channelLeaved;

        public string channelLeaved { get { return _channelLeaved; } set { _channelLeaved = value; } }



        /// <summary>

        /// Ein User der einen Channel betreten/verlassen hat

        /// </summary>

        /// <param name="nickName">Nickname</param>

        /// <param name="gender">Geschlecht</param>

        /// <param name="userNameAppearanceFormatter">Schriftformatierung</param>

        /// <param name="userForeColor">Vordergrundfarbe</param>

        /// <param name="userListPics">Bilder</param>

        /// <param name="channelJoinedTo">Der Channel der betreten wurde</param>

        /// <param name="channelLeavedTo">Der Channel der verlassen wurde</param>

        public User(string nickName, bool? gender, char userNameAppearanceFormatter, Color userForeColor, Dictionary<string, Image> userListPics, string channelJoined, string channelLeaved)

        {

            _gender = gender;

            _nickName = nickName;

            _userNameAppearanceFormatter = userNameAppearanceFormatter;

            _userForeColor = userForeColor;

            _userListPics = userListPics;

            _channelJoined = channelJoined;

            _channelLeaved = channelLeaved;

        }

    }

}

**Sky.NET** · 23.11.2011, 23:54

Spoiler:

**Sky.NET** · 30.11.2011, 13:22

Push (Overview)

**uncopyable** · 30.11.2011, 13:54

Hallo

erstmal Danke fürs Public stellen

zweitens hab ich eine frage worauf sich der Verweis "KLib2.Kodierungen" bezieht?

**Lyra** · 30.11.2011, 15:40

Sehr nice & vorbildich von dir, diesen code (der bestimmt viel Zeit gekostet hat) public zu stellen!

**Sky.NET** · 07.02.2012, 17:57

Zitat von uncopyable

Hallo

erstmal Danke fürs Public stellen

zweitens hab ich eine frage worauf sich der Verweis "KLib2.Kodierungen" bezieht?

Unwichtig, das war damals zur direkten Decodierung des Passwortes whatever, aber das geht ja nicht mehr...

U-Labs

Account-Boerse

U-IMG

Thema: Tokenparsing Hilfe