🥇C# .Net Framework-ზე დაფუძნებული ველოსიპედის აწყობის ან კლიენტ-სერვერის აპლიკაციის გაფართოებული ვერსია

Entry

ყველაფერი მაშინ დაიწყო, როცა კოლეგამ შემომთავაზა პატარა ვებ სერვისის გაკეთება. ეს რაღაც ტინდერის მსგავსი უნდა ყოფილიყო, მაგრამ IT hangout-ისთვის. ფუნქციონალობა უკიდურესად მარტივია, დარეგისტრირდებით, ავსებთ პროფილს და გადადიხართ მთავარ საკითხზე, კერძოდ, თანამოსაუბრის პოვნაზე და კავშირების გაფართოებაზე და ახალ ნაცნობებზე.

აქ უნდა გადავიდე და ცოტა ჩემს შესახებაც ვისაუბრო, რათა მომავალში უფრო ნათელი გახდეს, რატომ გადავდგი ასეთი ნაბიჯები განვითარებაში.
ამჟამად სათამაშო სტუდიაში ტექნიკური შემსრულებლის პოზიციას ვიკავებ, ჩემი C# პროგრამირების გამოცდილება ეფუძნებოდა მხოლოდ სკრიპტების და უტილიტების დაწერას Unity-სთვის და, გარდა ამისა, ანდროიდის მოწყობილობებთან დაბალი დონის მუშაობისთვის დანამატების შექმნაზე. ამ სამყაროს გარეთ, მე ჯერ არ ამირჩევია და შემდეგ გამომიყენებია ასეთი შესაძლებლობა.

ნაწილი 1: ჩარჩოს პროტოტიპირება

მას შემდეგ რაც გადავწყვიტე როგორი იქნება ეს სერვისი, დავიწყე განხორციელების ვარიანტების ძებნა. უმარტივესი გზა იქნება რაიმე სახის მზა გადაწყვეტის პოვნა, რომელზედაც, როგორც ბუს გლობუსზე, შეძლებთ ჩვენი მექანიკის მოზიდვას და მთელი საქმის განხილვას საზოგადოების ცენზურისთვის.
მაგრამ ეს არ არის საინტერესო, მე ამაში ვერავითარი გამოწვევა და აზრი ვერ დავინახე და ამიტომ დავიწყე ვებ ტექნოლოგიებისა და მათთან ურთიერთობის მეთოდების შესწავლა.

კვლევა C#.Net-ზე სტატიებისა და დოკუმენტაციის ნახვით დაიწყო. აქ ვიპოვე დავალების შესრულების სხვადასხვა გზა. ქსელთან ურთიერთქმედების მრავალი მექანიზმი არსებობს, სრულფასოვანი გადაწყვეტილებებიდან, როგორიცაა ASP.Net ან Azure სერვისები, TcpHttp კავშირებთან პირდაპირი ურთიერთქმედებამდე.

ASP-თან პირველი მცდელობის შემდეგ, მე მაშინვე გავაუქმე, ჩემი აზრით, ძალიან რთული გადაწყვეტილება იყო ჩვენი სერვისისთვის. ჩვენ არ გამოვიყენებთ ამ პლატფორმის შესაძლებლობების მესამედსაც, ამიტომ გავაგრძელე ძებნა. არჩევანი გაჩნდა TCP და Http კლიენტ-სერვერს შორის. აქ, ჰაბრეზე, წავაწყდი სტატიას მრავალძაფიანი სერვერი, აწყობილი და გამოცდის შემდეგ, გადავწყვიტე ფოკუსირება გამეკეთებინა TCP კავშირებთან ურთიერთქმედებაზე, რატომღაც ვფიქრობდი, რომ http არ მომცემდა კროს-პლატფორმული გადაწყვეტის შექმნის საშუალებას.

სერვერის პირველი ვერსია მოიცავდა კავშირების მართვას, ვებ გვერდის სტატიკური შინაარსის მომსახურებას და მომხმარებლის მონაცემთა ბაზის ჩათვლით. და დამწყებთათვის გადავწყვიტე ავაშენო ფუნქციონალი საიტთან მუშაობისთვის, რათა მოგვიანებით შემეძლოს აქ დავაკავშირო აპლიკაციის დამუშავება ანდროიდზე და ios-ზე.

აქ არის რამდენიმე კოდი
ძირითადი თემა, რომელიც იღებს კლიენტებს გაუთავებელ ციკლში:

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);
        }
    }
}

თავად კლიენტის დამმუშავებელი:

using System;
using System.IO;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;

namespace ClearServer
{
    class Client
    {


        public Client(TcpClient Client)
        {

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

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

            Match ReqMatch = Regex.Match(Message, @"^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 FilePath =
quot;D:/Web/TestSite{RequestUri}";
 if (!File.Exists(FilePath))
 {
 ErrorWorker.SendError(Client, 404);
 return;
 }
 string Extension = RequestUri.Substring(RequestUri.LastIndexOf('.'));
 string ContentType = "";
 switch (Extension)
 {
 case ".htm":
 case ".html":
 ContentType = "text/html";
 break;
 case ".css":
 ContentType = "text/css";
 break;
 case ".js":
 ContentType = "text/javascript";
 break;
 case ".jpg":
 ContentType = "image/jpeg";
 break;
 case ".jpeg":
 case ".png":
 case ".gif":
 ContentType =
quot;image/{Extension.Substring(1)}";
 break;
 default:
 if (Extension.Length > 1)
 {
 ContentType =
quot;application/{Extension.Substring(1)}";
 }
 else
 {
 ContentType = "application/unknown";
 }
 break;
 }
 FileStream FS;
 try
 {
 FS = new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
 }
 catch (Exception)
 {
 ErrorWorker.SendError(Client, 500);
 return;
 }
 string Headers =
quot;HTTP/1.1 200 OKnContent-Type: {ContentType}nContent-Length: {FS.Length}nn";
 byte[] HeadersBuffer = Encoding.ASCII.GetBytes(Headers);
 Client.GetStream().Write(HeadersBuffer, 0, HeadersBuffer.Length);
 while (FS.Position < FS.Length)
 {
 Count = FS.Read(Buffer, 0, Buffer.Length);
 Client.GetStream().Write(Buffer, 0, Count);
 }
 FS.Close();
 Client.Close();
 }
 }
 }
 და პირველი მონაცემთა ბაზა, რომელიც აგებულია ადგილობრივ SQL-ზე:using System;
using 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<User> users = db.GetTable<User>();
                foreach (var item in users)
                {
                    Console.WriteLine(
quot;{item.login} {item.password}");
 }
 }
 }
 }
 }
 როგორც ხედავთ, ეს ვერსია ცოტათი განსხვავდება სტატიისგან. ფაქტობრივად, აქ დაემატა მხოლოდ გვერდების ჩატვირთვა კომპიუტერის საქაღალდედან და მონაცემთა ბაზაში (რაც, სხვათა შორის, ამ ვერსიაში არ მუშაობდა, არასწორი კავშირის არქიტექტურის გამო).თავი 2
სერვერის ტესტირების შემდეგ მივედი დასკვნამდე, რომ ეს შესანიშნავი გამოსავალი იქნებოდა (სპოილერი: არა), ჩვენი სერვისისთვის, ასე რომ, პროექტმა დაიწყო ლოგიკის შეძენა.
 ეტაპობრივად, ახალი მოდულები გამოჩნდა და სერვერის ფუნქციონალი გაფართოვდა. სერვერმა შეიძინა სატესტო დომენი და ssl კავშირის დაშიფვრა.
ცოტა მეტი კოდი, რომელიც აღწერს სერვერის ლოგიკას და კლიენტების დამუშავებას
 სერვერის განახლებული ვერსია, სერტიფიკატის გამოყენების ჩათვლით.
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();
        }
    }
}
ასევე ახალი კლიენტის დამმუშავებელი ავტორიზაცია ssl-ის საშუალებით:
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" +

quot;|{DateTime.Now:g}n|------------n|{Client.Client.RemoteEndPoint}n|------------n|Exception: {e.Message}n|------------n|Authentication failed - closing the connection.n" +
 "---------------------------------------------------------------------n");
 SSlClientStream.Close();
 Client.Close();
 }
 new RequestContext(SSlClientStream, Client);
 }
 }
 }

 მაგრამ რადგან სერვერი მუშაობს ექსკლუზიურად TCP კავშირზე, აუცილებელია მოდულის შექმნა, რომელიც ამოიცნობს მოთხოვნის კონტექსტს. მე გადავწყვიტე, რომ აქ შესაფერისია პარსერი, რომელიც დაყოფს კლიენტის მოთხოვნას ცალკეულ ნაწილებად, რომლებთანაც შემიძლია ურთიერთქმედება, რათა კლიენტს მივცე საჭირო პასუხები.პარსერი
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<RequestValues> HeadersValues;
        public List<RequestValues> FormValues;
        private TcpClient TcpClient;

        private event Action<SslStream, RequestContext> 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(
quot;n{DateTime.Now:g} Client 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;
 try
 {
 if (HeadersValues.Any(x => x.Name.Contains("Cookie")))
 {
 cookie = HeadersValues.FirstOrDefault(x => x.Name.Contains("Cookie")).Value;
 try
 {
 CurrentUser = databaseWorker.CookieValidate(cookie);
 }
 catch { }
 }
 }
 catch { }
 }
 private List<RequestValues> HeaderValues()
 {
 var values = new List<RequestValues>();
 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<RequestValues> ContentValues()
 {
 var values = new List<RequestValues>();
 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;
 }
 }
 }
 მისი არსი მდგომარეობს იმაში, რომ რეგულარული გამონათქვამების დახმარებით მოთხოვნის ნაწილებად დაყოფა. კლიენტისგან ვიღებთ შეტყობინებას, ვირჩევთ პირველ სტრიქონს, რომელიც შეიცავს მეთოდს და მოთხოვნის url-ს. შემდეგ ჩვენ ვკითხულობთ სათაურებს, რომლებსაც ვატარებთ მასივის ფორმაში HeaderName = Content და ასევე ვპოულობთ, ასეთის არსებობის შემთხვევაში, თანმხლებ შინაარსს (მაგალითად, querystring), რომელსაც ასევე ვატარებთ მსგავს მასივში. გარდა ამისა, პარსერი აღმოაჩენს, არის თუ არა ამჟამინდელი კლიენტი ავტორიზებული და ინახავს მის მონაცემებს. ავტორიზებული კლიენტების ყველა მოთხოვნა შეიცავს ავტორიზაციის ჰეშს, რომელიც ინახება ქუქი-ფაილებებში, რის წყალობითაც შესაძლებელია შემდგომი სამუშაო ლოგიკის გამოყოფა ორი ტიპის კლიენტისთვის და სწორი პასუხის გაცემა.ისე, პატარა, ლამაზი ფუნქცია, რომელიც უნდა გადავიდეს ცალკეულ მოდულში და გადააკეთოს მოთხოვნები, როგორიცაა "site.com/@UserName" დინამიურად გენერირებულ მომხმარებლის გვერდებად. მოთხოვნის დამუშავების შემდეგ ამოქმედდება შემდეგი მოდულები.
თავი 3. სახელურის დაყენება, ჯაჭვის შეზეთვა
როგორც კი პარსერი დაასრულებს, თამაშში შედის დამმუშავებელი, რომელიც დამატებით მითითებებს აძლევს სერვერს და ყოფს კონტროლს ორ ნაწილად.
მარტივი დამმუშავებელი
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);
            };
        }
    }
}
სინამდვილეში, მომხმარებლის ავტორიზაციის მხოლოდ ერთი შემოწმებაა, რის შემდეგაც იწყება მოთხოვნის დამუშავება.
კლიენტის კონტროლერები
 თუ მომხმარებელი არ არის ავტორიზებული, მაშინ მისთვის ფუნქციონირება ეფუძნება მხოლოდ მომხმარებლის პროფილების ჩვენებას და ავტორიზაციის რეგისტრაციის ფანჯარას. ავტორიზებული მომხმარებლის კოდი დაახლოებით ერთნაირად გამოიყურება, ამიტომ მისი დუბლირების მიზეზს ვერ ვხედავ.
არაავტორიზებული მომხმარებელი
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;
 }
 }
 }
 }

 და რა თქმა უნდა, მომხმარებელმა უნდა მიიღოს გვერდების გარკვეული შინაარსი, ამიტომ პასუხებისთვის არის შემდეგი მოდული, რომელიც პასუხისმგებელია რესურსების მოთხოვნაზე პასუხის გაცემაზე.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":
 return
quot;{Header} text/html";
 case ".css":
 return
quot;{Header} text/css";
 case ".js":
 return
quot;{Header} text/javascript";
 case ".jpg":
 case ".jpeg":
 case ".png":
 case ".gif":
 return
quot;{Header} image/{extension}";
 default:
 if (extension.Length > 1)
 {
 return
quot;{Header} application/" + extension.Substring(1);
 }
 else
 {
 return
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();
 }
 }
 }
 მაგრამ იმისათვის, რომ მომხმარებელს ეჩვენებინა მისი პროფილი და სხვა მომხმარებლების პროფილები, გადავწყვიტე გამომეყენებინა RazorEngine, უფრო სწორად მისი ნაწილი. ის ასევე მოიცავს ცუდი მოთხოვნების დამუშავებას და შესაბამისი შეცდომის კოდის გაცემას.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();
            }
        }
    }
}
და რა თქმა უნდა, იმისათვის, რომ ავტორიზებული მომხმარებლების გადამოწმებამ იმუშაოს, საჭიროა ავტორიზაცია. ავტორიზაციის მოდული ურთიერთქმედებს მონაცემთა ბაზასთან. საიტზე არსებული ფორმებიდან მიღებული მონაცემები ანალიზდება კონტექსტიდან, მომხმარებელი ინახება და სანაცვლოდ იღებს ქუქი-ფაილებს და სერვისზე წვდომას.
ავტორიზაციის მოდული
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(
quot;HTTP/1.1 301 Moved PermanentlynLocation: /@{user.login}nSet-Cookie: {cookies.AuthCookie}; Expires={DateTime.Now.AddDays(2):R}; Secure; HttpOnlynn");
 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(
quot;{user.password} {user.password.Trim().Length}");
 DatabaseWorker.UserRegister(user);
 var response = Encoding.UTF8.GetBytes(
quot;HTTP/1.1 301 Moved PermanentlynLocation: /@{user.login}nSet-Cookie: {user.cookie}; Expires={DateTime.Now.AddDays(2):R}; Secure; HttpOnlynn");
 ClientStream.BeginWrite(response, 0, response.Length, WriteController.OnClientSend, null);
 }
 else
 {
 RazorController.ErrorLoader(401);
 }
 }
 }
 }

 და მონაცემთა ბაზა ასე გამოიყურება:Მონაცემთა ბაზა
using ClearServer.Core.UserController;
using System;
using System.Data.Linq;
using System.Linq;

namespace ClearServer
{
    class DatabaseWorker
    {

        private readonly Table<User> users = null;
        private readonly DataContext DataBase = null;
        private const string connectionStr = @"путькбазе";

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

        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(
quot;User{user.name} with id {user.uid} added");
 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("Login already exists");
 return false;
 }
 return true;
 }
 public void UserUpdate(User user)
 {
 var UserToUpdate = users.FirstOrDefault(x => x.uid == user.uid);
 UserToUpdate = user;
 DataBase.SubmitChanges();
 Console.WriteLine(
quot;User {UserToUpdate.name} with id {UserToUpdate.uid} updated");
 foreach (var item in users)
 {
 Console.WriteLine(item.login + "n");
 }
 }
 public User CookieValidate(string CookieInput)
 {
 User user = null;
 try
 {
 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;
 try
 {
 user = users.Single(x => x.login.ToLower() == login.ToLower());
 if (user != null)
 {
 return user;
 }
 else
 {
 return null;
 }
 }
 catch (Exception)
 {
 return null;
 }
 }
 }
 }

 და ყველაფერი მუშაობს, როგორც საათის მექანიზმი, ავტორიზაცია და სარეგისტრაციო სამუშაოები, სერვისზე წვდომის მინიმალური ფუნქციონირება უკვე ხელმისაწვდომია და დროა დაწეროთ აპლიკაცია და შევაერთოთ ყველაფერი ძირითადი ფუნქციებით, რისთვისაც ყველაფერი კეთდება.თავი 4
ორ პლატფორმაზე ორი აპლიკაციის დაწერის შრომის ხარჯების შესამცირებლად გადავწყვიტე შემექმნა კროს-პლატფორმა Xamarin.Forms-ზე. კიდევ ერთხელ, იმის წყალობით, რომ ის არის C#-ში. შევქმენი სატესტო აპლიკაცია, რომელიც უბრალოდ აგზავნის მონაცემებს სერვერზე, ერთ საინტერესო მომენტში წავედი. მოწყობილობის მოთხოვნისთვის, გასართობად, დავაყენე ის HttpClient-ზე და გადავყარე სერვერზე HttpRequestMessage, რომელიც შეიცავს მონაცემებს ავტორიზაციის ფორმიდან json ფორმატში. კონკრეტულს არაფრის მოლოდინის გარეშე გავხსენი სერვერის ჟურნალი და ვნახე თხოვნა მოწყობილობიდან ყველა მონაცემით. მსუბუქი სისულელე, ცნობიერება ყველაფრის შესახებ, რაც გაკეთდა ბოლო 3 კვირის განმავლობაში დაღლილი საღამოს განმავლობაში. გაგზავნილი მონაცემების სისწორის შესამოწმებლად მე შევკრიბე სატესტო სერვერი HttpListner-ზე. მას შემდეგ რაც მივიღე შემდეგი მოთხოვნა მასზე, მე დავშალე ის კოდის რამდენიმე სტრიქონში, მივიღე KeyValuePair მონაცემები ფორმიდან. შეკითხვის ანალიზი შემცირდა ორ ხაზამდე.
დავიწყე შემდგომი ტესტირება, ეს ადრე არ იყო ნახსენები, მაგრამ წინა სერვერზე მაინც დავაყენე ვებსოკეტებზე აგებული ჩატი. ის საკმაოდ კარგად მუშაობდა, მაგრამ Tcp-ის საშუალებით ურთიერთქმედების პრინციპი დამთრგუნველი იყო, ზედმეტი ზედმეტი იყო საჭირო იმისათვის, რომ სწორად აგებულიყო ორი მომხმარებლის ურთიერთქმედება კორესპონდენციის აღრიცხვასთან ერთად. ეს მოიცავს კავშირის გადართვის მოთხოვნის ანალიზს და პასუხის შეგროვებას RFC 6455 პროტოკოლის გამოყენებით. ამიტომ, სატესტო სერვერზე გადავწყვიტე შემექმნა მარტივი ვებსოკეტის კავშირი. მხოლოდ ინტერესის გამო.
ჩეთის კავშირი
 private static async void HandleWebsocket(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<byte>(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();
                        }
                    }
                }
            }
        }
და იმუშავა. სერვერმა თავად დააყენა კავშირი, შექმნა პასუხის გასაღები. მე კი არ მომიწია ცალკე სერვერის რეგისტრაციის კონფიგურაცია ssl-ის საშუალებით, საკმარისია სისტემას უკვე დაყენებული ჰქონდეს სერთიფიკატი საჭირო პორტზე.
მოწყობილობის მხარეს და საიტის მხარეს, ორმა კლიენტმა გაცვალა შეტყობინებები, ეს ყველაფერი იყო ჩაწერილი. არ არის უზარმაზარი პარსერი, რომელიც ანელებს სერვერს, არცერთი ეს არ იყო საჭირო. რეაგირების დრო 200 ms-დან 40-30ms-მდე შემცირდა. და მე მივედი ერთადერთ სწორ გადაწყვეტილებამდე.
გადაყარეთ სერვერის მიმდინარე განხორციელება Tcp-ზე და გადაწერეთ ყველაფერი Http-ის ქვეშ. ახლა პროექტი რედიზაინის ეტაპზეა, მაგრამ ურთიერთქმედების სრულიად განსხვავებული პრინციპების მიხედვით. მოწყობილობებისა და საიტის მუშაობა სინქრონიზებულია და გამართულია და აქვს საერთო კონცეფცია, ერთადერთი განსხვავებით, რომ მოწყობილობებს არ სჭირდებათ html გვერდების გენერირება.
გამოყვანის
"ფორდს რომ არ იცნობ, თავი წყალში არ ჩაიდე" ვფიქრობ, მუშაობის დაწყებამდე უფრო მკაფიოდ უნდა განვსაზღვრო მიზნები და ამოცანები, ასევე ჩავუღრმავდე სხვადასხვა კლიენტებზე მათი დანერგვის საჭირო ტექნოლოგიებისა და მეთოდების შესწავლას. პროექტი უკვე დასასრულს უახლოვდება, მაგრამ იქნებ დავბრუნდე და ვისაუბრო იმაზე, თუ როგორ გავაფუჭე გარკვეული რამ ისევ. ბევრი რამ ვისწავლე განვითარების პროცესში, მაგრამ მომავალში კიდევ ბევრია სასწავლი. თუ აქამდე წაიკითხეთ, მადლობა რომ კითხულობთ.
წყარო: www.habr.com