Avancerad cykelbyggnad eller klient-serverapplikation baserad på C# .Net framework

Inledning

Allt började med att en kollega föreslog att jag skulle skapa en liten webbservice. Det skulle bli något liknande Tinder, men för IT-gemenskapen. Funktionaliteten är otroligt enkel: du registrerar dig, fyller i din profil och går vidare till kärnan av tjänsten, nämligen att hitta samtalspartner och utöka ditt nätverk samt få nya bekantskaper.

Här måste jag ta ett steg tillbaka och berätta lite om mig själv, så att det senare blir tydligare varför jag har tagit just dessa steg i utvecklingen.

För närvarande arbetar jag som Teknisk Artist på en speldstudio. Min erfarenhet av programmering i C# har enbart byggt på att skriva skript och verktyg för Unity, samt skapa plugins för låg-nivå arbete med Android-enheter. Jag har ännu inte vågat mig utanför denna värld, och nu dök den här möjligheten upp.

Del 1. Prototyping av ramen

När jag bestämt mig för hur tjänsten skulle se ut, började jag leta efter alternativ för genomförande. Det skulle vara enklast att hitta en färdig lösning som vi kunde anpassa våra mekaniker till och publicera för allmän kritik.
Men det här var inte intressant, jag såg ingen utmaning eller mening i det, så jag började studera webbteknologier och metoder för interaktion med dem.

Jag började med att läsa artiklar och dokumentation om C# .Net. Här hittade jag olika sätt att lösa uppgiften. Det finns många mekanismer för nätverksinteraktion, från fullständiga lösningar som ASP.Net eller Azure-tjänster, till direkt interaktion med TcpHttp-anslutningar.

Efter mitt första försök med ASP avfärdade jag det snabbt; jag tyckte att det var en alltför tung lösning för vår tjänst. Vi skulle inte ens använda en tredjedel av plattformens möjligheter, så jag fortsatte letandet. Valet stod mellan TCP och Http-klient/server. flermarkserver, efter att ha samlat och testat vilken, beslutade jag att stanna vid interaktionen med TCP-anslutningar, av någon anledning trodde jag att http inte skulle tillåta mig att skapa en plattformsoberoende lösning.

Den första versionen av servern inkluderade hantering av anslutningar, levererade statiskt innehåll på webb sidor och hade en databas för användare. För att börja bestämde jag mig för att bygga funktionalitet för webbplatsen, så att jag senare skulle kunna integrera hantering av applikationen på Android och iOS.

Här är lite kod
Huvudtråden, som i en oändlig loop tar emot klienter:

using System;
using System.Net.Sockets;
using System.Net;
using System.Threading;

namespace ClearServer
{

    class Server
    {
        TcpListener Listener;
        public Server(int Port)
        {
            Listener = new TcpListener(IPAddress.Any, Port);
            Listener.Start();

            while (true)
            {
                TcpClient Client = Listener.AcceptTcpClient();
                Thread Thread = new Thread(new ParameterizedThreadStart(ClientThread));
                Thread.Start(Client);
            }
        }

        static void ClientThread(Object StateInfo)
        {
            new Client((TcpClient)StateInfo);
        }

        ~Server()
        {
            if (Listener != null)
            {
                Listener.Stop();
            }
        }

        static void Main(string[] args)
        {
            DatabaseWorker sqlBase = DatabaseWorker.GetInstance;

            new Server(80);
        }
    }
}

Själva klienthanteraren:

använda System;
använda System.IO;
använda System.Net.Sockets;
använda System.Text;
använda System.Text.RegularExpressions;

namespace ClearServer
{
    class Client
    {


        public Client(TcpClient Client)
        {

            string Meddelande = "";
            byte[] Buffer = new byte[1024];
            int Antal;
            while ((Antal = Client.GetStream().Read(Buffer, 0, Buffer.Length)) > 0)
            {
                Meddelande += Encoding.UTF8.GetString(Buffer, 0, Antal);

                if (Meddelande.IndexOf("rnrn") >= 0 || Meddelande.Length > 4096)
                {
                    Console.WriteLine(Meddelande);
                    break;
                }
            }

            Match ReqMatch = Regex.Match(Meddelande, @"^w+s+([^s?]+)[^s]*s+HTTP\/.*|");
            if (ReqMatch == Match.Empty)
            {
                ErrorWorker.SendError(Client, 400);
                return;
            }
            string RequestUri = ReqMatch.Groups[1].Value;
            RequestUri = Uri.UnescapeDataString(RequestUri);
            if (RequestUri.IndexOf("..") >= 0)
            {
                ErrorWorker.SendError(Client, 400);
                return;
            }
            if (RequestUri.EndsWith("/"))
            {
                RequestUri += "index.html";
            }

            string Filväg =
"D:/Web/TestSite{RequestUri}";
 if (!File.Exists(Filväg)
 {
 ErrorWorker.SendError(Client, 404);
 return;
 }
 string Tillägg = RequestUri.Substring(RequestUri.LastIndexOf('.'));
 string Innehållstyp = "";
 switch (Tillägg)
 {
 case ".htm":
 case ".html":
 Innehållstyp = "text/html";
 break;
 case ".css":
 Innehållstyp = "text/css";
 break;
 case ".js":
 Innehållstyp = "text/javascript";
 break;
 case ".jpg":
 Innehållstyp = "image/jpeg";
 break;
 case ".jpeg":
 case ".png":
 case ".gif":
 Innehållstyp =
"image/{Tillägg.Substring(1)}";
 break;
 default:
 if (Tillägg.Length > 1)
 {
 Innehållstyp =
"application/{Tillägg.Substring(1)}";
 }
 else
 {
 Innehållstyp = "application/unknown";
 }
 break;
 }
 FileStream FS;
 försök
 {
 FS = new FileStream(Filväg, FileMode.Open, FileAccess.Read, FileShare.Read);
 }
 catch (Exception)
 {
 ErrorWorker.SendError(Client, 500);
 return;
 }
 string Headers =
"HTTP/1.1 200 OKnContent-Type: {Innehållstyp}nContent-Length: {FS.Length}nn";
 byte[] HeadersBuffer = Encoding.ASCII.GetBytes(Headers);
 Client.GetStream().Write(HeadersBuffer, 0, HeadersBuffer.Length);
 while (FS.Position < FS.Length)
 {
 Antal = FS.Read(Buffer, 0, Buffer.Length);
 Client.GetStream().Write(Buffer, 0, Antal);
 }
 FS.Close();
 Client.Close();
 }
 }
 }
 Och den första databasen byggd på local SQL:
using System;
uusing System.Data.Linq;
namespace ClearServer
{
    class DatabaseWorker
    {

        private static DatabaseWorker instance;

        public static DatabaseWorker GetInstance
        {
            get
            {
                if (instance == null)
                    instance = new DatabaseWorker();
                return instance;
            }
        }


        private DatabaseWorker()
        {
            string connectionStr = databasePath;
            using (DataContext db = new DataContext(connectionStr))
            {
                Table users = db.GetTable();
                foreach (var item in users)
                {
                    Console.WriteLine("{item.login} {item.password}");
                }
            }
        }
    }
}
"{item.login} {item.password}"
 }
 }
 }
 }
 }
 Som man kan se, skiljer sig den här versionen lite från den som beskrevs i artikeln. I grund och botten har det bara lagts till laddning av sidor från mappen på datorn och databasen (som förresten inte fungerade i denna version på grund av felaktig anslutningsarkitektur).
Kapitel 2. Integrera hjul
Efter att ha testat serverns funktion beslutade jag mig för att detta skulle vara en utmärkt lösning (spoiler: nej), för vår tjänst, så projektet började växa i logik.
 Steg för steg började nya moduler dyka upp och serverns funktionalitet växte. Servern fick en testdomän och ssl kryptering av anslutningen.
Lite mer kod som beskriver serverns logik och hantering av klienter
 Uppdaterad version av servern som inkluderar användning av certifikat.
using System;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Security;
using System.Security.Cryptography.X509Certificates;
using System.Security.Permissions;
using System.Security.Policy;
using System.Threading;


namespace ClearServer
{

    sealed class Server
    {
        readonly bool ServerRunning = true;
        readonly TcpListener sslListner;
        public static X509Certificate serverCertificate = null;
        Server()
        {
            serverCertificate = X509Certificate.CreateFromSignedFile(@"C:sslitinder.online.crt");
            sslListner = new TcpListener(IPAddress.Any, 443);
            sslListner.Start();
            Console.WriteLine("Starting server.." + serverCertificate.Subject + "n" + Assembly.GetExecutingAssembly().Location);
            while (ServerRunning)
            {
                TcpClient SslClient = sslListner.AcceptTcpClient();
                Thread SslThread = new Thread(new ParameterizedThreadStart(ClientThread));
                SslThread.Start(SslClient);
            }
            
        }
        static void ClientThread(Object StateInfo)
        {
            new Client((TcpClient)StateInfo);
        }

        ~Server()
        {
            if (sslListner != null)
            {
                sslListner.Stop();
            }
        }

        public static void Main(string[] args)
        {
            if (AppDomain.CurrentDomain.IsDefaultAppDomain())
            {
                Console.WriteLine("Switching another domain");
                new AppDomainSetup
                {
                    ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase
                };
                var current = AppDomain.CurrentDomain;
                var strongNames = new StrongName[0];
                var domain = AppDomain.CreateDomain(
                    "ClearServer", null,
                    current.SetupInformation, new PermissionSet(PermissionState.Unrestricted),
                    strongNames);
                domain.ExecuteAssembly(Assembly.GetExecutingAssembly().Location);
            }
            new Server();
        }
    }
}
Och en ny klienthandläggare med SSL-autentisering:
using ClearServer.Core.Requester;
using System;
using System.Net.Security;
using System.Net.Sockets;

namespace ClearServer
{
    public class Client
    {
        public Client(TcpClient Client)
        {
            SslStream SSlClientStream = new SslStream(Client.GetStream(), false);
            try
            {
                SSlClientStream.AuthenticateAsServer(Server.serverCertificate, clientCertificateRequired: false, checkCertificateRevocation: true);
            }
            catch (Exception e)
            {
                Console.WriteLine(
                    "---------------------------------------------------------------------n" +

"|{DateTime.Now:g}n|------------n|{Client.Client.RemoteEndPoint}n|------------n|Exception: {e.Message}n|------------n|Autentisering misslyckades - stänger anslutningen.n" +
 "---------------------------------------------------------------------n");
 SSlClientStream.Close();
 Client.Close();
 }
 new RequestContext(SSlClientStream, Client);
 }
 }
 }

 Eftersom servern fungerar uteslutande med TCP-anslutningar, behövs en modul som kan känna igen begärans sammanhang. Jag kom fram till att en parser skulle passa här, som kan dela upp begäran från klienten i separata delar, med vilka jag kan interagera för att ge klienten de svar som behövs.
Parser
using ClearServer.Core.UserController;
using ReServer.Core.Classes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Security;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;

namespace ClearServer.Core.Requester
{
    public class RequestContext
    {
        public string Message = "";
        private readonly byte[] buffer = new byte[1024];
        public string RequestMethod;
        public string RequestUrl;
        public User RequestProfile;
        public User CurrentUser = null;
        public List HeadersValues;
        public List FormValues;
        private TcpClient TcpClient;

        private event Action OnRead = RequestHandler.OnHandle;

        DatabaseWorker databaseWorker = new DatabaseWorker();

        public RequestContext(SslStream ClientStream, TcpClient Client)
        {

            this.TcpClient = Client;
            try
            {
                ClientStream.BeginRead(buffer, 0, buffer.Length, ClientRead, ClientStream);
            }
            catch { return; }
        }
        private void ClientRead(IAsyncResult ar)
        {
            SslStream ClientStream = (SslStream)ar.AsyncState;

            if (ar.IsCompleted)
            {
                Message = Encoding.UTF8.GetString(buffer);
                Message = Uri.UnescapeDataString(Message);
                Console.WriteLine(",{DateTime.Now:g} Client IP:{TcpClient.Client.RemoteEndPoint}n{Message}");
n{DateTime.Now:g} Klient IP:{TcpClient.Client.RemoteEndPoint}n{Message}");
 RequestParse();
 HeadersValues = HeaderValues();
 FormValues = ContentValues();
 UserParse();
 ProfileParse();
 OnRead?.Invoke(ClientStream, this);
 }
 }
 private void RequestParse()
 {
 Match methodParse = Regex.Match(Message, @"(^w+)s+([^s?]+)[^s]*s+HTTP/.*|");
 RequestMethod = methodParse.Groups[1].Value.Trim();
 RequestUrl = methodParse.Groups[2].Value.Trim();
 }
 private void UserParse()
 {
 string cookie;
 försök
 {
 if (HeadersValues.Any(x => x.Name.Contains("Cookie")))
 {
 cookie = HeadersValues.FirstOrDefault(x => x.Name.Contains("Cookie")).Value;
 försök
 {
 CurrentUser = databaseWorker.CookieValidate(cookie);
 }
 catch { }
 }
 }
 catch { }
 }
 private List HeaderValues()
 {
 var values = new List();
 var parse = Regex.Matches(Message, @"(.*?): (.*?)n");
 foreach (Match match in parse)
 {
 values.Add(new RequestValues()
 {
 Name = match.Groups[1].Value.Trim(),
 Value = match.Groups[2].Value.Trim()
 });
 }
 return values;
 }
 private void ProfileParse()
 {
 if (RequestUrl.Contains("@"))
 {
 RequestProfile = databaseWorker.FindUser(RequestUrl.Substring(2));
 RequestUrl = "/profile";
 }
 }
 private List ContentValues()
 {
 var values = new List();
 var output = Message.Trim('n').Split().Last();
 var parse = Regex.Matches(output, @"([^&].*?)=([^&]*b)");
 foreach (Match match in parse)
 {
 values.Add(new RequestValues()
 {
 Name = match.Groups[1].Value.Trim(),
 Value = match.Groups[2].Value.Trim().Replace('+', ' ')
 });
 }
 return values;
 }
 }
 }
 Kärnan handlar om att använda reguljära uttryck för att dela upp en begäran i delar. Vi får ett meddelande från klienten, identifierar den första raden som innehåller metoden och URL:en för begäran. Sedan läser vi rubrikerna och samlar dem i en array i formatet Rubriknamn=Innehåll, och vi letar också efter eventuell medföljande information (t.ex. querystring) som vi också lägger i en liknande array. Dessutom bestämmer parsern om den aktuella klienten är autentiserad och sparar dess data. Alla begärningar från autentiserade klienter innehåller en autentisering hash som lagras i cookies, vilket gör att vi kan separera den framtida logiken för två typer av klienter och ge dem rätt svar.
Och en liten, trevlig funktion som skulle vara värt att lyfta ut till en separat modul är omvandlingen av begärningar som "site.com/@UserName" till dynamiskt genererade sidor för användare. Efter att begäran har behandlats, träder följande moduler in i bilden.
Kapitel 3. Installation av ratten, smörjning av kedjan
Så snart parsern har arbetat klart, träder en hanterare in som ger ytterligare instruktioner till servern och delar upp kontrollen i två delar.
En enkel hanterare
using ClearServer.Core.UserController;
using System.Net.Security;
namespace ClearServer.Core.Requester
{
    public class RequestHandler
    {
        public static void OnHandle(SslStream ClientStream, RequestContext context)
        {

            if (context.CurrentUser != null)
            {
                new AuthUserController(ClientStream, context);
            }
            else 
            {
                new NonAuthUserController(ClientStream, context);
            };
        }
    }
}
I grunden finns det bara en kontroll av användarens autentisering, varefter begäran börjar bearbetas.
Klientkontroller
 Om användaren inte är autentiserad är funktionaliteten begränsad till att visa användarprofiler och registrerings- och inloggningsfönster. Koden för autentiserade användare ser ungefär likadan ut, så jag ser ingen anledning att duplicera den.
Inte autentiserad användare
using ClearServer.Core.Requester;
using System.IO;
using System.Net.Security;

namespace ClearServer.Core.UserController
{
    internal class NonAuthUserController
    {
        private readonly SslStream ClientStream;
        private readonly RequestContext Context;
        private readonly WriteController WriteController;
        private readonly AuthorizationController AuthorizationController;

        private readonly string ViewPath = "C:\/Users\/drdre\/source\/repos\/ClearServer\/View";

        public NonAuthUserController(SslStream clientStream, RequestContext context)
        {
            this.ClientStream = clientStream;
            this.Context = context;
            this.WriteController = new WriteController(clientStream);
            this.AuthorizationController = new AuthorizationController(clientStream, context);
            ResourceLoad();
        }

        void ResourceLoad()
        {
            string[] blockextension = new string[] {"cshtml", "html", "htm"};
            bool block = false;
            foreach (var item in blockextension)
            {
                if (Context.RequestUrl.Contains(item))
                {
                    block = true;
                    break;
                }
            }
            string FilePath = "";
            string Header = "";
            var RazorController = new RazorController(Context, ClientStream);
            
            switch (Context.RequestMethod)
            {
                case "GET":
                    switch (Context.RequestUrl)
                    {
                        case "\/":
                            FilePath = ViewPath + "\/loginForm.html";
                            Header =
quot;HTTP\/1.1 200 OKnContent-Type: text\/html";
 WriteController.DefaultWriter(Header, FilePath);
 break;
 case "\/profile":
 RazorController.ProfileLoader(ViewPath);
 break;
 default:
 //в данном блоке кода происходит отсечение запросов к серверу по прямому адресу страницы вида site.com/page.html
 if (!File.Exists(ViewPath + Context.RequestUrl) | block)
 {
 RazorController.ErrorLoader(404);
 }
 else if (Path.HasExtension(Context.RequestUrl) && File.Exists(ViewPath + Context.RequestUrl))
 {
 Header = WriteController.ContentType(Context.RequestUrl);
 FilePath = ViewPath + Context.RequestUrl;
 WriteController.DefaultWriter(Header, FilePath);
 }
 break;
 }
 break;
 case "POST":
 AuthorizationController.MethodRecognizer();
 break;
 }
 }
 }
 }

 Och självklart ska användaren få något innehåll på sidorna, så för svaren finns följande modul som ansvarar för att svara på resursförfrågningar.
WriterController
using System;
using System.IO;
using System.Net.Security;
using System.Text;

namespace ClearServer.Core.UserController
{
    public class WriteController
    {
        SslStream ClientStream;
        public WriteController(SslStream ClientStream)
        {
            this.ClientStream = ClientStream;
        }

        public void DefaultWriter(string Header, string FilePath)
        {
            FileStream fileStream;
            try
            {
                fileStream = new FileStream(FilePath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
                Header =
quot;{Header}nContent-Length: {fileStream.Length}nn";
 ClientStream.Write(Encoding.UTF8.GetBytes(Header));
 byte[] response = new byte[fileStream.Length];
 fileStream.BeginRead(response, 0, response.Length, OnFileRead, response);
 }
 catch { }
 }
 public string ContentType(string Uri)
 {
 string extension = Path.GetExtension(Uri);
 string Header = "HTTP\/1.1 200 OKnContent-Type:";
 switch (extension)
 {
 case ".html":
 case ".htm":
 återvända
quot;{Header} text\/html";
 case ".css":
 återvända
quot;{Header} text\/css";
 case ".js":
 återvända
quot;{Header} text\/javascript";
 case ".jpg":
 case ".jpeg":
 case ".png":
 case ".gif":
 återvända
quot;{Header} image\/{extension}";
 default:
 if (extension.Length > 1)
 {
 återvända
quot;{Header} application\" + extension.Substring(1);
 }
 else
 {
 återvända
quot;{Header} application\/unknown";
 }
 }
 }
 public void OnFileRead(IAsyncResult ar)
 {
 if (ar.IsCompleted)
 {
 var file = (byte[])ar.AsyncState;
 ClientStream.BeginWrite(file, 0, file.Length, OnClientSend, null);
 }
 }
 public void OnClientSend(IAsyncResult ar)
 {
 if (ar.IsCompleted)
 {
 ClientStream.Close();
 }
 }
 }
 Men för att visa användaren sin profil och profilerna för andra användare bestämde jag mig för att använda RazorEngine, eller snarare en del av den. Den inkluderar också hantering av felaktiga förfrågningar och ger motsvarande felkod.
RazorController
using ClearServer.Core.Requester;
using RazorEngine;
using RazorEngine.Templating;
using System;
using System.IO;
using System.Net;
using System.Net.Security;

namespace ClearServer.Core.UserController
{
    internal class RazorController
    {
        private RequestContext Context;
        private SslStream ClientStream;
        dynamic PageContent;


        public RazorController(RequestContext context, SslStream clientStream)
        {
            this.Context = context;
            this.ClientStream = clientStream;

        }

        public void ProfileLoader(string ViewPath)
        {
            string Filepath = ViewPath + "\/profile.cshtml";
            if (Context.RequestProfile != null)
            {
                if (Context.CurrentUser != null && Context.RequestProfile.login == Context.CurrentUser.login)
                {
                    try
                    {
                        PageContent = new { isAuth = true, Name = Context.CurrentUser.name, Login = Context.CurrentUser.login, Skills = Context.CurrentUser.skills };
                        ClientSend(Filepath, Context.CurrentUser.login);
                    }
                    catch (Exception e) { Console.WriteLine(e); }

                }
                else
                {
                    try
                    {
                        PageContent = new { isAuth = false, Name = Context.RequestProfile.name, Login = Context.RequestProfile.login, Skills = Context.RequestProfile.skills };
                        ClientSend(Filepath, "PublicProfile:" + Context.RequestProfile.login);
                    }
                    catch (Exception e) { Console.WriteLine(e); }
                }
            }
            else
            {
                ErrorLoader(404);
            }


        }

        public void ErrorLoader(int Code)
        {
            try
            {
                PageContent = new { ErrorCode = Code, Message = ((HttpStatusCode)Code).ToString() };
                string ErrorPage = "C:\Users\drdre\source\repos\ClearServer\View\Errors\ErrorPage.cshtml";
                ClientSend(ErrorPage, Code.ToString());
            }
            catch { }

        }

        private void ClientSend(string FilePath, string Key)
        {
            var template = File.ReadAllText(FilePath);
            var result = Engine.Razor.RunCompile(template, Key, null, (object)PageContent);
            byte[] buffer = System.Text.Encoding.UTF8.GetBytes(result);
            ClientStream.BeginWrite(buffer, 0, buffer.Length, OnClientSend, ClientStream);
        }

        private void OnClientSend(IAsyncResult ar)
        {
            if (ar.IsCompleted)
            {
                ClientStream.Close();
            }
        }
    }
}
Naturligtvis, för att autentisering av inloggade användare ska fungera, behövs autentisering. Autentiseringsmodulen interagerar med databasen. De uppgifter som fås från formulären på webbplatsen parsas från kontexten, användaren sparas och får i utbyte cookies och åtkomst till tjänsten.
Autentiseringsmodul
using ClearServer.Core.Cookies;
using ClearServer.Core.Requester;
using ClearServer.Core.Security;
using System;
using System.Linq;
using System.Net.Security;
using System.Text;

namespace ClearServer.Core.UserController
{
    internal class AuthorizationController
    {
        private SslStream ClientStream;
        private RequestContext Context;
        private UserCookies cookies;
        private WriteController WriteController;
        DatabaseWorker DatabaseWorker;
        RazorController RazorController;
        PasswordHasher PasswordHasher;
        public AuthorizationController(SslStream clientStream, RequestContext context)
        {
            ClientStream = clientStream;
            Context = context;
            DatabaseWorker = new DatabaseWorker();
            WriteController = new WriteController(ClientStream);
            RazorController = new RazorController(context, clientStream);
            PasswordHasher = new PasswordHasher();
        }

        internal void MethodRecognizer()
        {
            if (Context.FormValues.Count == 2 && Context.FormValues.Any(x => x.Name == "password")) Authorize();
            else if (Context.FormValues.Count == 3 && Context.FormValues.Any(x => x.Name == "regPass")) Registration();
            else
            {
                RazorController.ErrorLoader(401);
            }
        }

        private void Authorize()
        {
            var values = Context.FormValues;
            var user = new User()
            {
                login = values[0].Value,
                password = PasswordHasher.PasswordHash(values[1].Value)
            };
            user = DatabaseWorker.UserAuth(user);
            if (user != null)
            {
                cookies = new UserCookies(user.login, user.password);
                user.cookie = cookies.AuthCookie;
                DatabaseWorker.UserUpdate(user);
                var response = Encoding.UTF8.GetBytes(
"HTTP/1.1 301 Moved Permanently Location: /@{user.login} Set-Cookie: {cookies.AuthCookie}; Expires={DateTime.Now.AddDays(2):R}; Secure; HttpOnly");
 ClientStream.BeginWrite(response, 0, response.Length, WriteController.OnClientSend, null);
 }
 else
 {
 RazorController.ErrorLoader(401);
 }
 }
 private void Registration()
 {
 var values = Context.FormValues;
 var user = new User()
 {
 name = values[0].Value,
 login = values[1].Value,
 password = PasswordHasher.PasswordHash(values[2].Value),
 };
 cookies = new UserCookies(user.login, user.password);
 user.cookie = cookies.AuthCookie;
 if (DatabaseWorker.LoginValidate(user.login))
 {
 Console.WriteLine("User ready");
 Console.WriteLine(
"{user.password} {user.password.Trim().Length}");
 DatabaseWorker.UserRegister(user);
 var response = Encoding.UTF8.GetBytes(
"HTTP/1.1 301 Moved Permanently Location: /@{user.login} Set-Cookie: {user.cookie}; Expires={DateTime.Now.AddDays(2):R}; Secure; HttpOnly");
 ClientStream.BeginWrite(response, 0, response.Length, WriteController.OnClientSend, null);
 }
 else
 {
 RazorController.ErrorLoader(401);
 }
 }
 }
 }

 Så här ser databashanteringen ut:
Databas
using ClearServer.Core.UserController;
using System;
using System.Data.Linq;
using System.Linq;

namespace ClearServer
{
    class DatabaseWorker
    {

        private readonly Table users = null;
        private readonly DataContext DataBase = null;
        private const string connectionStr = @"vägen till databasen";

        public DatabaseWorker()
        {
            DataBase = new DataContext(connectionStr);
            users = DataBase.GetTable();
        }

        public User UserAuth(User User)
        {
            try
            {
                var user = users.SingleOrDefault(t => t.login.ToLower() == User.login.ToLower() && t.password == User.password);
                if (user != null)
                    return user;
                else
                    return null;
            }
            catch (Exception)
            {
                return null;
            }

        }

        public void UserRegister(User user)
        {
            try
            {
                users.InsertOnSubmit(user);
                DataBase.SubmitChanges();
                Console.WriteLine("User {user.name} med id {user.uid} tillagd");
            }
"User {user.name} med id {user.uid} tillagd";
 foreach (var item in users)
 {
 Console.WriteLine(item.login + "n");
 }
 }
 catch (Exception e)
 {
 Console.WriteLine(e);
 }
 }
 public bool LoginValidate(string login)
 {
 if (users.Any(x => x.login.ToLower() == login.ToLower()))
 {
 Console.WriteLine("Användarnamnet finns redan");
 return false;
 }
 return true;
 }
 public void UserUpdate(User user)
 {
 var UserToUpdate = users.FirstOrDefault(x => x.uid == user.uid);
 UserToUpdate = user;
 DataBase.SubmitChanges();
 Console.WriteLine(
"Användare {UserToUpdate.name} med id {UserToUpdate.uid} uppdaterad";
 foreach (var item in users)
 {
 Console.WriteLine(item.login + "n");
 }
 }
 public User CookieValidate(string CookieInput)
 {
 User user = null;
 försök
 {
 user = users.SingleOrDefault(x => x.cookie == CookieInput);
 }
 catch
 {
 return null;
 }
 if (user != null) return user;
 else return null;
 }
 public User FindUser(string login)
 {
 User user = null;
 försök
 {
 user = users.Single(x => x.login.ToLower() == login.ToLower());
 if (user != null)
 {
 return user;
 }
 else
 {
 return null;
 }
 }
 catch (Exception)
 {
 return null;
 }
 }
 }
 }

 Och allt fungerar som en klocka, autentisering och registrering fungerar, minimiåtkomst till tjänsten finns redan och nu är det dags att skriva applikationen och koppla ihop allt detta med de grundläggande funktioner som hela denna process syftar till.
Kapitel 4. Att skapa något nytt
För att minska arbetsinsatsen för att skriva två applikationer för två plattformar beslutade jag att skapa en korsplattform på Xamarin.Forms. Återigen, tack vare att den är skriven i C#. Efter att ha gjort en testapplikation som helt enkelt skickar data till servern, stötte jag på en intressant punkt. För att göra en begäran från enheten implementerade jag av nyfikenhet detta med HttpClient och skickade till servern en HttpRequestMessage som innehöll data från inloggningsformuläret i json-format. Utan att förvänta mig mycket, öppnade jag serverloggen och såg där en begäran från enheten med all data. En lätt förvirring, insikten av allt som hade gjorts under de senaste tre veckorna av långa kvällar. För att kontrollera riktigheten av de skickade uppgifterna satte jag upp en testserver med HttpListener. När jag fick en ny begäran där, delade jag upp den i delar med bara några rader kod och fick en KeyValuePair med data från formuläret. Återanalysen av begäran minskade till två rader.
Jag började testa vidare, tidigare nämndes inte, men på den gamla servern hade jag också implementerat en chatt baserad på webbsockets. Den fungerade ganska bra, men själva principen för interaktion via Tcp var nedslående, det krävdes för mycket extra arbete för att på ett korrekt sätt bygga interaktionen mellan två användare med loggföring av konversationen. Det handlade om att parsa begäran för att växla anslutningen och samla svar enligt protokollet RFC 6455. Därför beslutade jag att skapa en enkel websocket-anslutning på testservern. Bara av nyfikenhet.
Anslutning till chatten
 privat statisk async void HanteraWebsocket(HttpListenerContext context)
        {
            var socketContext = await context.AcceptWebSocketAsync(null);
            var socket = socketContext.WebSocket;
            Locker.EnterWriteLock();
            try
            {
                Clients.Add(socket);
            }
            finally
            {
                Locker.ExitWriteLock();
            }

            while (true)
            {
                var buffer = new ArraySegment(new byte[1024]);
                var result = await socket.ReceiveAsync(buffer, CancellationToken.None);
                var str = Encoding.Default.GetString(buffer);
                Console.WriteLine(str);

                for (int i = 0; i < Clients.Count; i++)
                {
                    WebSocket client = Clients[i];

                    try
                    {
                        if (client.State == WebSocketState.Open)
                        {
                            
                            await client.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
                        }
                    }
                    catch (ObjectDisposedException)
                    {
                        Locker.EnterWriteLock();
                        try
                        {
                            Clients.Remove(client);
                            i--;
                        }
                        finally
                        {
                            Locker.ExitWriteLock();
                        }
                    }
                }
            }
        }
Och det fungerade. Servern konfigurerade själv anslutningen och genererade svarnyckeln. Jag behövde till och med inte ställa in serverregistreringen för ssl separat, det var tillräckligt med att certifikatet redan var installerat i systemet på rätt port.
På enheten och på webbplatsen utbytte två klienter meddelanden, allt registrerades. Inga stora parserar som saktade ner serverns arbete behövdes. Svarstiden minskade från 200 ms till 40-30 ms. Och jag kom fram till den enda rätta lösningen.
Att avbryta den nuvarande implementeringen av servern på Tcp och skriva om allt för Http. Nu befinner sig projektet i en omdesignfas, men enligt helt andra principer för samverkan. Enheternas och webbplatsens arbete är synkroniserat och justerat och har en gemensam koncept, med den enda skillnaden att det inte behövs genereras html-sidor för enheterna.
Utdata
«Utan att veta vad som döljer sig, inte gå in i vattnet» Jag tror att jag innan jag började arbeta borde ha definierat syften och mål tydligare, samt fördjupat mig i studiet av nödvändiga teknologier och metoder för deras implementering på olika kunder. Projektet är redan nära att avslutas, men jag kanske kommer tillbaka för att berätta om hur jag återigen har gjort misstag med vissa saker. Jag har lärt mig mycket under utvecklingsprocessen, men det finns ännu mer att lära i framtiden. Om du har läst fram till detta, tack för det.
Källa: habr.com