ການຂີ່ລົດຖີບແບບພິເສດ ຫຼືແອັບພລິເຄຊັນເຊີບເວີຕາມ C# .Net framework

ເຂົ້າ

ມັນທັງຫມົດໄດ້ເລີ່ມຕົ້ນເມື່ອເພື່ອນຮ່ວມງານແນະນໍາວ່າຂ້ອຍສ້າງບໍລິການເວັບໄຊຕ໌ຂະຫນາດນ້ອຍ. ມັນຄວນຈະເປັນບາງສິ່ງບາງຢ່າງເຊັ່ນ Tinder, ແຕ່ສໍາລັບຝູງຊົນ IT. ຫນ້າທີ່ເຮັດວຽກແມ່ນງ່າຍດາຍທີ່ສຸດ, ທ່ານລົງທະບຽນ, ຕື່ມຂໍ້ມູນໃສ່ profile ແລະຍ້າຍໄປສູ່ຈຸດຕົ້ນຕໍ, ຄືການຊອກຫາຄົນທີ່ຈະສົນທະນາແລະຂະຫຍາຍການເຊື່ອມຕໍ່ຂອງທ່ານແລະສ້າງຄົນຮູ້ຈັກໃຫມ່.

ໃນທີ່ນີ້ຂ້າພະເຈົ້າຕ້ອງ retreat ແລະບອກເລັກນ້ອຍກ່ຽວກັບຕົນເອງ, ດັ່ງນັ້ນໃນອະນາຄົດມັນຈະຊັດເຈນກວ່າວ່າເປັນຫຍັງຂ້າພະເຈົ້າໄດ້ເອົາບາດກ້າວດັ່ງກ່າວໃນການພັດທະນາ.

ໃນປັດຈຸບັນຂ້າພະເຈົ້າຖືຕໍາແຫນ່ງນັກວິຊາການໃນສະຕູດິໂອເກມຫນຶ່ງ, ປະສົບການການຂຽນໂປລແກລມຂອງຂ້ອຍໃນ C# ຖືກສ້າງຂຶ້ນພຽງແຕ່ໃນການຂຽນສະຄິບແລະຜົນປະໂຫຍດສໍາລັບ Unity ແລະນອກຈາກນີ້, ການສ້າງ plugins ສໍາລັບການເຮັດວຽກໃນລະດັບຕ່ໍາກັບອຸປະກອນ Android. ຂ້າ​ພະ​ເຈົ້າ​ຍັງ​ບໍ່​ທັນ​ໄດ້​ປະ​ຖິ້ມ​ຄວາມ​ເສຍ​ຫາຍ​ໄປ​ນອກ​ໂລກ​ນີ້, ແລະ​ຈາກ​ນັ້ນ​ກໍ​ມີ​ໂອ​ກາດ​ດັ່ງ​ກ່າວ.

ສ່ວນທີ 1. ການສ້າງຕົວແບບກອບ

ໂດຍໄດ້ຕັດສິນໃຈວ່າການບໍລິການນີ້ຈະເປັນແນວໃດ, ຂ້ອຍເລີ່ມຊອກຫາທາງເລືອກໃນການຈັດຕັ້ງປະຕິບັດ. ສິ່ງທີ່ງ່າຍທີ່ສຸດແມ່ນການຊອກຫາວິທີແກ້ໄຂທີ່ກຽມພ້ອມບາງຊະນິດ, ເຊິ່ງ, ຄືກັບນົກອິນຊີ, ກົນຈັກຂອງພວກເຮົາສາມາດດຶງແລະສິ່ງທັງຫມົດສາມາດຖືກກ່າວຫາສາທາລະນະ.
ແຕ່ນີ້ບໍ່ຫນ້າສົນໃຈ, ຂ້ອຍບໍ່ເຫັນສິ່ງທ້າທາຍຫຼືຄວາມຮູ້ສຶກໃດໆໃນມັນ, ແລະດັ່ງນັ້ນຂ້ອຍຈຶ່ງເລີ່ມສຶກສາເທກໂນໂລຍີເວັບແລະວິທີການພົວພັນກັບພວກເຂົາ.

ຂ້າພະເຈົ້າໄດ້ເລີ່ມຕົ້ນການສຶກສາໂດຍການເບິ່ງບົດຄວາມແລະເອກະສານກ່ຽວກັບ C# .Net. ທີ່ນີ້ຂ້ອຍພົບວິທີຕ່າງໆເພື່ອເຮັດສໍາເລັດຫນ້າວຽກ. ມີຫຼາຍກົນໄກສໍາລັບການພົວພັນກັບເຄືອຂ່າຍ, ຈາກການແກ້ໄຂເຕັມຮູບແບບເຊັ່ນ: ບໍລິການ ASP.Net ຫຼື Azure, ໄປຫາການໂຕ້ຕອບໂດຍກົງກັບການເຊື່ອມຕໍ່ TcpHttp.

ໂດຍໄດ້ພະຍາຍາມຄັ້ງທໍາອິດກັບ ASP, ຂ້ອຍປະຕິເສດທັນທີ; ໃນຄວາມຄິດເຫັນຂອງຂ້ອຍ, ນີ້ແມ່ນການຕັດສິນໃຈທີ່ຍາກເກີນໄປສໍາລັບການບໍລິການຂອງພວກເຮົາ ພວກເຮົາຈະບໍ່ໃຊ້ຄວາມສາມາດຂອງເວທີນີ້, ສະນັ້ນຂ້າພະເຈົ້າສືບຕໍ່ຊອກຫາ. ທາງເລືອກແມ່ນລະຫວ່າງ TCP ແລະ Http client-server. ທີ່ນີ້, ກ່ຽວກັບHabre, ຂ້າພະເຈົ້າໄດ້ມາໃນທົ່ວບົດຄວາມກ່ຽວກັບ ເຊີບເວີ multithreaded, ໂດຍໄດ້ລວບລວມແລະທົດສອບມັນ, ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈສຸມໃສ່ການພົວພັນກັບການເຊື່ອມຕໍ່ TCP ໂດຍສະເພາະ, ສໍາລັບເຫດຜົນບາງຢ່າງທີ່ຂ້ອຍຄິດວ່າ http ຈະບໍ່ອະນຸຍາດໃຫ້ຂ້ອຍສ້າງການແກ້ໄຂຂ້າມເວທີ.

ເວີຊັ່ນທຳອິດຂອງເຊີບເວີລວມມີການປະມວນຜົນການເຊື່ອມຕໍ່, ຮັບໃຊ້ເນື້ອຫາໜ້າເວັບແບບຄົງທີ່, ແລະລວມເອົາຖານຂໍ້ມູນຜູ້ໃຊ້. ແລະເພື່ອເລີ່ມຕົ້ນດ້ວຍ, ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈສ້າງຫນ້າທີ່ເຮັດວຽກກັບເວັບໄຊທ໌, ດັ່ງນັ້ນຂ້າພະເຈົ້າສາມາດເພີ່ມການປຸງແຕ່ງຄໍາຮ້ອງສະຫມັກໃນ Android ແລະ iOS.

ນີ້ແມ່ນລະຫັດບາງຢ່າງ
ກະທູ້ຕົ້ນຕໍ, ການຮັບລູກຄ້າໃນ loop ບໍ່ມີທີ່ສິ້ນສຸດ:

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. Screwing ລໍ້
ຫຼັງ​ຈາກ​ການ​ທົດ​ສອບ​ເຄື່ອງ​ແມ່​ຂ່າຍ​, ຂ້າ​ພະ​ເຈົ້າ​ໄດ້​ສະ​ຫຼຸບ​ວ່າ​ນີ້​ຈະ​ເປັນ​ການ​ແກ້​ໄຂ​ທີ່​ດີ​ເລີດ (spoiler: ບໍ່), ສໍາລັບການບໍລິການຂອງພວກເຮົາ, ດັ່ງນັ້ນໂຄງການໄດ້ເລີ່ມຕົ້ນທີ່ຈະໄດ້ຮັບເຫດຜົນ.
 ເທື່ອລະຂັ້ນຕອນ, ໂມດູນໃໝ່ເລີ່ມປາກົດຂຶ້ນ ແລະ ໜ້າທີ່ຂອງເຊີບເວີໄດ້ຂະຫຍາຍອອກໄປ. ເຊີບເວີໄດ້ຮັບໂດເມນທົດສອບ ແລະ 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, ມັນຈໍາເປັນຕ້ອງສ້າງໂມດູນທີ່ສາມາດຮັບຮູ້ສະພາບການຂອງການຮ້ອງຂໍ. ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈວ່າຕົວວິເຄາະຈະເຫມາະສົມຢູ່ທີ່ນີ້ທີ່ຈະທໍາລາຍຄໍາຮ້ອງຂໍຈາກລູກຄ້າອອກເປັນສ່ວນແຍກຕ່າງຫາກທີ່ຂ້ອຍສາມາດໂຕ້ຕອບກັບລູກຄ້າເພື່ອໃຫ້ຄໍາຕອບທີ່ຈໍາເປັນ.
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<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 ຮ້ອງຂໍ. ຫຼັງຈາກນັ້ນ, ພວກເຮົາອ່ານຫົວຂໍ້, ທີ່ພວກເຮົາໃສ່ເຂົ້າໄປໃນ array ຂອງແບບຟອມ HeaderName=Content, ແລະພວກເຮົາຍັງຊອກຫາ, ຖ້າມີ, ມາພ້ອມກັບເນື້ອຫາ (ຕົວຢ່າງ, querystring) ທີ່ພວກເຮົາໃສ່ເຂົ້າໄປໃນ array ທີ່ຄ້າຍຄືກັນ. ນອກຈາກນັ້ນ, parser ຄົ້ນພົບວ່າລູກຄ້າໃນປະຈຸບັນໄດ້ຮັບອະນຸຍາດແລະເກັບຮັກສາຂໍ້ມູນຂອງລາວຫຼືບໍ່. ການຮ້ອງຂໍທັງຫມົດຈາກລູກຄ້າທີ່ໄດ້ຮັບອະນຸຍາດມີ hash ການອະນຸຍາດ, ເຊິ່ງຖືກເກັບໄວ້ໃນ cookies, ຍ້ອນການນີ້ມັນເປັນໄປໄດ້ທີ່ຈະແຍກເຫດຜົນການດໍາເນີນງານຕື່ມອີກສໍາລັບລູກຄ້າສອງປະເພດແລະໃຫ້ຄໍາຕອບທີ່ຖືກຕ້ອງ.
ດີ, ຄຸນນະສົມບັດຂະຫນາດນ້ອຍ, ງາມທີ່ຈະຄຸ້ມຄ່າໃສ່ໃນໂມດູນແຍກຕ່າງຫາກ, ການປ່ຽນຄໍາຖາມເຊັ່ນ "site.com/@UserName" ເຂົ້າໄປໃນຫນ້າຜູ້ໃຊ້ທີ່ສ້າງແບບເຄື່ອນໄຫວ. ຫຼັງ​ຈາກ​ການ​ປະ​ຕິ​ບັດ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​, ໂມ​ດູນ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​ເຂົ້າ​ມາ​ໃນ​ການ​ຫຼິ້ນ​.
ບົດທີ 3. ການຕິດຕັ້ງພວງມາໄລ, lubrication ຂອງຕ່ອງໂສ້
ທັນທີທີ່ parser ໄດ້ສໍາເລັດການເຮັດວຽກຂອງຕົນ, handler ເຂົ້າມາຫຼິ້ນ, ໃຫ້ຄໍາແນະນໍາເພີ່ມເຕີມຕໍ່ກັບເຄື່ອງແມ່ຂ່າຍແລະແບ່ງການຄວບຄຸມເປັນສອງສ່ວນ.
ຕົວຈັດການງ່າຍດາຍ
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();
            }
        }
    }
}
ແລະແນ່ນອນ, ເພື່ອໃຫ້ການກວດສອບຜູ້ໃຊ້ທີ່ໄດ້ຮັບອະນຸຍາດເຮັດວຽກ, ການອະນຸຍາດແມ່ນຈໍາເປັນ. ໂມດູນການອະນຸຍາດພົວພັນກັບຖານຂໍ້ມູນ. ຂໍ້​ມູນ​ທີ່​ໄດ້​ຮັບ​ຈາກ​ຮູບ​ແບບ​ຢູ່​ໃນ​ເວັບ​ໄຊ​ໄດ້​ຖືກ​ແຍກ​ຈາກ​ສະ​ພາບ​ການ​, ຜູ້​ໃຊ້​ໄດ້​ຖືກ​ບັນ​ທຶກ​ໄວ້​ແລະ​ໃນ​ການ​ກັບ​ຄືນ​ໄດ້​ຮັບ cookies ແລະ​ການ​ເຂົ້າ​ເຖິງ​ການ​ບໍ​ລິ​ການ​.
ໂມດູນການອະນຸຍາດ
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;
 }
 }
 }
 }

 ແລະທຸກສິ່ງທຸກຢ່າງເຮັດວຽກເຊັ່ນ: clockwork, ການອະນຸຍາດແລະການລົງທະບຽນ, ຫນ້າທີ່ຕໍາ່ສຸດທີ່ສໍາລັບການເຂົ້າເຖິງການບໍລິການແມ່ນມີຢູ່ແລ້ວແລະເວລາໄດ້ມາຂຽນຄໍາຮ້ອງສະຫມັກແລະຜູກມັດສິ່ງທັງຫມົດຮ່ວມກັນກັບຫນ້າທີ່ຕົ້ນຕໍທີ່ທຸກສິ່ງທຸກຢ່າງກໍາລັງເຮັດ.
ບົດທີ 4. ການຖິ້ມລົດຖີບ
ເພື່ອຫຼຸດຜ່ອນຄ່າໃຊ້ຈ່າຍແຮງງານໃນການຂຽນຄໍາຮ້ອງສະຫມັກສອງສໍາລັບສອງແພລະຕະຟອມ, ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈສ້າງເວທີຂ້າມຜ່ານ Xamarin.Forms. ອີກເທື່ອຫນຶ່ງ, ຂໍຂອບໃຈກັບຄວາມຈິງທີ່ວ່າມັນຢູ່ໃນ C #. ໄດ້ເຮັດຄໍາຮ້ອງສະຫມັກການທົດສອບທີ່ພຽງແຕ່ສົ່ງຂໍ້ມູນກັບເຄື່ອງແມ່ຂ່າຍ, ຂ້າພະເຈົ້າໄດ້ພົບເຫັນຈຸດທີ່ຫນ້າສົນໃຈ. ສໍາລັບການຮ້ອງຂໍຈາກອຸປະກອນ, ເພື່ອຄວາມມ່ວນ, ຂ້າພະເຈົ້າໄດ້ປະຕິບັດມັນຢູ່ໃນ HttpClient ແລະສົ່ງມັນໄປຫາເຄື່ອງແມ່ຂ່າຍຂອງ HttpRequestMessage, ເຊິ່ງປະກອບດ້ວຍຂໍ້ມູນຈາກແບບຟອມການອະນຸຍາດໃນຮູບແບບ json. ໂດຍບໍ່ມີການຄາດຫວັງຫຍັງໂດຍສະເພາະ, ຂ້າພະເຈົ້າໄດ້ເປີດບັນທຶກຂອງເຄື່ອງແມ່ຂ່າຍແລະເຫັນວ່າມີການຮ້ອງຂໍຈາກອຸປະກອນທີ່ມີຂໍ້ມູນທັງຫມົດ. ອາການງຶດງົງເລັກນ້ອຍ, ການຮັບຮູ້ທຸກຢ່າງທີ່ໄດ້ເຮັດໃນ 3 ອາທິດຜ່ານມາໃນຕອນແລງທີ່ອິດເມື່ອຍ. ເພື່ອກວດສອບຄວາມຖືກຕ້ອງຂອງຂໍ້ມູນທີ່ສົ່ງ, ຂ້ອຍໄດ້ລວບລວມເຄື່ອງແມ່ຂ່າຍການທົດສອບຢູ່ໃນ HttpListner. ໄດ້ຮັບການຮ້ອງຂໍອື່ນແລ້ວກ່ຽວກັບມັນ, ຂ້າພະເຈົ້າໄດ້ເອົາມັນອອກຈາກກັນໃນສອງສາມເສັ້ນຂອງລະຫັດແລະໄດ້ຮັບຂໍ້ມູນ KeyValuePair ຈາກແບບຟອມ. ການວິເຄາະແບບສອບຖາມໄດ້ຖືກຫຼຸດລົງເປັນສອງແຖວ.
ຂ້ອຍເລີ່ມທົດສອບຕື່ມອີກ, ມັນບໍ່ໄດ້ຖືກກ່າວເຖິງກ່ອນຫນ້ານີ້, ແຕ່ໃນເຄື່ອງແມ່ຂ່າຍທີ່ຜ່ານມາຂ້ອຍຍັງໄດ້ປະຕິບັດການສົນທະນາທີ່ສ້າງຂຶ້ນໃນ websockets. ມັນເຮັດວຽກໄດ້ດີ, ແຕ່ຫຼັກການຫຼາຍຂອງການໂຕ້ຕອບຜ່ານ Tcp ແມ່ນມີຄວາມຫົດຫູ່ຫຼາຍ; ນີ້ປະກອບມີການແຍກຄໍາຮ້ອງຂໍເພື່ອສະຫຼັບການເຊື່ອມຕໍ່ແລະການລວບລວມການຕອບສະຫນອງໂດຍໃຊ້ໂປໂຕຄອນ RFC 6455 ດັ່ງນັ້ນ, ໃນເຄື່ອງແມ່ຂ່າຍການທົດສອບ, ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈສ້າງການເຊື່ອມຕໍ່ websocket ແບບງ່າຍດາຍ. ພຽງແຕ່ສໍາລັບການມ່ວນຊື່ນ.
ເຊື່ອມຕໍ່ກັບການສົນທະນາ
 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;
ໃນດ້ານອຸປະກອນແລະດ້ານເວັບໄຊທ໌, ລູກຄ້າສອງຄົນໄດ້ແລກປ່ຽນຂໍ້ຄວາມ, ທັງຫມົດນີ້ຖືກບັນທຶກ. ບໍ່ມີຕົວວິເຄາະຂະໜາດໃຫຍ່ທີ່ເຮັດໃຫ້ເຊີບເວີຊ້າລົງ, ບໍ່ຈຳເປັນຕ້ອງມີອັນໃດອັນນີ້. ເວລາຕອບສະຫນອງໄດ້ຫຼຸດລົງຈາກ 200ms ຫາ 40-30ms. ແລະຂ້າພະເຈົ້າໄດ້ມາເຖິງການຕັດສິນໃຈທີ່ຖືກຕ້ອງເທົ່ານັ້ນ.
ຖິ້ມການປະຕິບັດເຊີຟເວີໃນປະຈຸບັນໃນ Tcp ແລະຂຽນຄືນທຸກສິ່ງທຸກຢ່າງພາຍໃຕ້ Http. ໃນປັດຈຸບັນໂຄງການແມ່ນຢູ່ໃນຂັ້ນຕອນການອອກແບບໃຫມ່, ແຕ່ອີງຕາມຫຼັກການທີ່ແຕກຕ່າງກັນຫມົດຂອງການໂຕ້ຕອບ. ການດໍາເນີນງານຂອງອຸປະກອນແລະເວັບໄຊທ໌ແມ່ນ synchronized ແລະ debugged ແລະມີແນວຄວາມຄິດທົ່ວໄປ, ມີຄວາມແຕກຕ່າງພຽງແຕ່ວ່າບໍ່ຈໍາເປັນຕ້ອງສ້າງຫນ້າ HTML ສໍາລັບອຸປະກອນ.
ສະຫລຸບ
"ຖ້າທ່ານບໍ່ຮູ້ຟອດ, ຢ່າເຂົ້າໄປໃນນ້ໍາ" ຂ້າພະເຈົ້າຄິດວ່າກ່ອນທີ່ຈະເລີ່ມຕົ້ນການເຮັດວຽກ, ຂ້າພະເຈົ້າຄວນຈະມີເປົ້າຫມາຍແລະຈຸດປະສົງທີ່ຊັດເຈນກວ່າ, ເຊັ່ນດຽວກັນກັບການສຶກສາກ່ຽວກັບເຕັກໂນໂລຢີແລະວິທີການທີ່ຈໍາເປັນສໍາລັບການປະຕິບັດຂອງພວກເຂົາຕໍ່ລູກຄ້າຕ່າງໆ. ໂຄງການໃກ້ຈະສຳເລັດແລ້ວ, ແຕ່ບາງທີຂ້ອຍອາດຈະກັບມາເວົ້າກ່ຽວກັບວິທີການບັນທຶກບາງຢ່າງອີກຄັ້ງ. ຂ້າພະເຈົ້າໄດ້ຮຽນຮູ້ຫຼາຍຢ່າງໃນລະຫວ່າງຂະບວນການພັດທະນາ, ແຕ່ຍັງມີຫຼາຍທີ່ຈະຮຽນຮູ້ໃນອະນາຄົດ. ຖ້າທ່ານໄດ້ອ່ານມາຮອດນີ້, ຂອບໃຈສໍາລັບການເຮັດ.
ແຫຼ່ງຂໍ້ມູນ: www.habr.com