C# .Net ਫਰੇਮਵਰਕ 'ਤੇ ਆਧਾਰਿਤ ਐਡਵਾਂਸਡ ਸਾਈਕਲਿੰਗ ਜਾਂ ਕਲਾਇੰਟ-ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨ

ਇੰਦਰਾਜ਼

ਇਹ ਸਭ ਉਦੋਂ ਸ਼ੁਰੂ ਹੋਇਆ ਜਦੋਂ ਇੱਕ ਸਹਿਕਰਮੀ ਨੇ ਸੁਝਾਅ ਦਿੱਤਾ ਕਿ ਮੈਂ ਇੱਕ ਛੋਟੀ ਵੈਬ ਸੇਵਾ ਬਣਾਵਾਂ. ਇਹ ਟਿੰਡਰ ਵਰਗਾ ਕੁਝ ਹੋਣਾ ਚਾਹੀਦਾ ਸੀ, ਪਰ ਆਈਟੀ ਭੀੜ ਲਈ. ਕਾਰਜਕੁਸ਼ਲਤਾ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਹੈ, ਤੁਸੀਂ ਰਜਿਸਟਰ ਕਰੋ, ਇੱਕ ਪ੍ਰੋਫਾਈਲ ਭਰੋ ਅਤੇ ਮੁੱਖ ਬਿੰਦੂ 'ਤੇ ਅੱਗੇ ਵਧੋ, ਅਰਥਾਤ ਗੱਲ ਕਰਨ ਲਈ ਇੱਕ ਵਿਅਕਤੀ ਨੂੰ ਲੱਭਣਾ ਅਤੇ ਆਪਣੇ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਵਧਾਉਣਾ ਅਤੇ ਨਵੇਂ ਜਾਣੂ ਬਣਾਉਣਾ।

ਇੱਥੇ ਮੈਨੂੰ ਇੱਕ ਪਿੱਛੇ ਹਟਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਬਾਰੇ ਥੋੜਾ ਜਿਹਾ ਦੱਸਣਾ ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਜੋ ਭਵਿੱਖ ਵਿੱਚ ਇਹ ਸਪੱਸ਼ਟ ਹੋ ਸਕੇ ਕਿ ਮੈਂ ਵਿਕਾਸ ਵਿੱਚ ਅਜਿਹੇ ਕਦਮ ਕਿਉਂ ਚੁੱਕੇ ਹਨ।

ਇਸ ਸਮੇਂ ਮੇਰੇ ਕੋਲ ਇੱਕ ਗੇਮ ਸਟੂਡੀਓ ਵਿੱਚ ਤਕਨੀਕੀ ਕਲਾਕਾਰ ਦੀ ਸਥਿਤੀ ਹੈ, C# ਵਿੱਚ ਮੇਰਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਤਜਰਬਾ ਸਿਰਫ ਏਕਤਾ ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਅਤੇ ਉਪਯੋਗਤਾਵਾਂ ਨੂੰ ਲਿਖਣ 'ਤੇ ਬਣਾਇਆ ਗਿਆ ਸੀ ਅਤੇ ਇਸ ਤੋਂ ਇਲਾਵਾ, ਐਂਡਰੌਇਡ ਡਿਵਾਈਸਾਂ ਨਾਲ ਹੇਠਲੇ-ਪੱਧਰ ਦੇ ਕੰਮ ਲਈ ਪਲੱਗਇਨ ਬਣਾਉਣਾ. ਮੈਂ ਅਜੇ ਇਸ ਨਿੱਕੀ ਜਿਹੀ ਦੁਨੀਆਂ ਤੋਂ ਅੱਗੇ ਨਿਕਲਿਆ ਨਹੀਂ ਸੀ ਕਿ ਅਜਿਹਾ ਮੌਕਾ ਆ ਗਿਆ।

ਭਾਗ 1. ਫਰੇਮ ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ

ਇਹ ਫੈਸਲਾ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕਿ ਇਹ ਸੇਵਾ ਕਿਸ ਤਰ੍ਹਾਂ ਦੀ ਹੋਵੇਗੀ, ਮੈਂ ਲਾਗੂ ਕਰਨ ਲਈ ਵਿਕਲਪਾਂ ਦੀ ਖੋਜ ਕਰਨੀ ਸ਼ੁਰੂ ਕਰ ਦਿੱਤੀ। ਸਭ ਤੋਂ ਆਸਾਨ ਗੱਲ ਇਹ ਹੋਵੇਗੀ ਕਿ ਕੋਈ ਅਜਿਹਾ ਤਿਆਰ-ਬਰ-ਤਿਆਰ ਹੱਲ ਲੱਭ ਲਿਆ ਜਾਵੇ, ਜਿਸ ਦੇ ਆਧਾਰ 'ਤੇ ਗਲੋਬ 'ਤੇ ਉੱਲੂ ਵਾਂਗ ਸਾਡੇ ਮਕੈਨਿਕਾਂ ਨੂੰ ਖਿੱਚਿਆ ਜਾ ਸਕੇ ਅਤੇ ਸਾਰੀ ਗੱਲ ਨੂੰ ਜਨਤਕ ਨਿੰਦਿਆ ਦਾ ਸਾਹਮਣਾ ਕੀਤਾ ਜਾ ਸਕੇ।
ਪਰ ਇਹ ਦਿਲਚਸਪ ਨਹੀਂ ਹੈ, ਮੈਨੂੰ ਇਸ ਵਿੱਚ ਕੋਈ ਚੁਣੌਤੀ ਜਾਂ ਭਾਵਨਾ ਨਹੀਂ ਦਿਖਾਈ ਦਿੱਤੀ, ਅਤੇ ਇਸਲਈ ਮੈਂ ਵੈਬ ਤਕਨਾਲੋਜੀਆਂ ਅਤੇ ਉਹਨਾਂ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਦੇ ਤਰੀਕਿਆਂ ਦਾ ਅਧਿਐਨ ਕਰਨਾ ਸ਼ੁਰੂ ਕੀਤਾ।

ਮੈਂ C# .Net 'ਤੇ ਲੇਖਾਂ ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਦੇਖ ਕੇ ਅਧਿਐਨ ਕਰਨਾ ਸ਼ੁਰੂ ਕੀਤਾ। ਇੱਥੇ ਮੈਨੂੰ ਕੰਮ ਨੂੰ ਪੂਰਾ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਮਿਲੇ। ASP.Net ਜਾਂ Azure ਸੇਵਾਵਾਂ ਵਰਗੇ ਸੰਪੂਰਨ ਹੱਲਾਂ ਤੋਂ ਲੈ ਕੇ, TcpHttp ਕਨੈਕਸ਼ਨਾਂ ਨਾਲ ਸਿੱਧੀ ਗੱਲਬਾਤ ਕਰਨ ਲਈ, ਨੈੱਟਵਰਕ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਵਿਧੀਆਂ ਹਨ।

ASP ਨਾਲ ਮੇਰੀ ਪਹਿਲੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਇਸਨੂੰ ਤੁਰੰਤ ਰੱਦ ਕਰ ਦਿੱਤਾ; ਮੇਰੀ ਰਾਏ ਵਿੱਚ, ਇਹ ਸਾਡੀ ਸੇਵਾ ਲਈ ਬਹੁਤ ਮੁਸ਼ਕਲ ਫੈਸਲਾ ਸੀ। ਅਸੀਂ ਇਸ ਪਲੇਟਫਾਰਮ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਦਾ ਤੀਜਾ ਹਿੱਸਾ ਵੀ ਨਹੀਂ ਵਰਤਾਂਗੇ, ਇਸ ਲਈ ਮੈਂ ਆਪਣੀ ਖੋਜ ਜਾਰੀ ਰੱਖੀ। ਚੋਣ TCP ਅਤੇ Http ਕਲਾਇੰਟ-ਸਰਵਰ ਵਿਚਕਾਰ ਸੀ। ਇੱਥੇ, Habré 'ਤੇ, ਮੈਨੂੰ ਬਾਰੇ ਇੱਕ ਲੇਖ ਭਰ ਵਿੱਚ ਆਇਆ ਸੀ ਮਲਟੀਥ੍ਰੈਡਡ ਸਰਵਰ, ਇਸ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਅਤੇ ਟੈਸਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਖਾਸ ਤੌਰ 'ਤੇ TCP ਕਨੈਕਸ਼ਨਾਂ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਕਿਸੇ ਕਾਰਨ ਕਰਕੇ ਮੈਂ ਸੋਚਿਆ ਕਿ http ਮੈਨੂੰ ਇੱਕ ਕਰਾਸ-ਪਲੇਟਫਾਰਮ ਹੱਲ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦੇਵੇਗਾ.

ਸਰਵਰ ਦੇ ਪਹਿਲੇ ਸੰਸਕਰਣ ਵਿੱਚ ਕਨੈਕਸ਼ਨ ਪ੍ਰੋਸੈਸਿੰਗ, ਸਥਿਰ ਵੈਬ ਪੇਜ ਦੀ ਸਮਗਰੀ ਦੀ ਸੇਵਾ, ਅਤੇ ਇੱਕ ਉਪਭੋਗਤਾ ਡੇਟਾਬੇਸ ਸ਼ਾਮਲ ਸੀ। ਅਤੇ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਮੈਂ ਸਾਈਟ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਤਾਂ ਜੋ ਮੈਂ ਬਾਅਦ ਵਿੱਚ ਐਂਡਰੌਇਡ ਅਤੇ ਆਈਓਐਸ 'ਤੇ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਜੋੜ ਸਕਾਂ।

ਇੱਥੇ ਕੁਝ ਕੋਡ ਹੈ
ਇੱਕ ਬੇਅੰਤ ਲੂਪ ਵਿੱਚ ਗਾਹਕਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲਾ ਮੁੱਖ ਥ੍ਰੈਡ:

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 ਫਾਰਮ ਦੀ ਇੱਕ ਐਰੇ ਵਿੱਚ ਪਾਉਂਦੇ ਹਾਂ, ਅਤੇ ਅਸੀਂ ਇਹ ਵੀ ਲੱਭਦੇ ਹਾਂ, ਜੇਕਰ ਕੋਈ ਹੋਵੇ, ਸਮੱਗਰੀ (ਉਦਾਹਰਨ ਲਈ, ਪੁੱਛਗਿੱਛ) ਜੋ ਅਸੀਂ ਇੱਕ ਸਮਾਨ ਐਰੇ ਵਿੱਚ ਪਾਉਂਦੇ ਹਾਂ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪਾਰਸਰ ਇਹ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਕਲਾਇੰਟ ਅਧਿਕਾਰਤ ਹੈ ਅਤੇ ਉਸਦਾ ਡੇਟਾ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਅਧਿਕਾਰਤ ਗਾਹਕਾਂ ਦੀਆਂ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਵਿੱਚ ਇੱਕ ਪ੍ਰਮਾਣੀਕਰਨ ਹੈਸ਼ ਹੁੰਦਾ ਹੈ, ਜੋ ਕਿ ਕੂਕੀਜ਼ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਸਦਾ ਧੰਨਵਾਦ ਦੋ ਕਿਸਮਾਂ ਦੇ ਗਾਹਕਾਂ ਲਈ ਹੋਰ ਓਪਰੇਟਿੰਗ ਤਰਕ ਨੂੰ ਵੱਖ ਕਰਨਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਹੀ ਜਵਾਬ ਦੇਣਾ ਸੰਭਵ ਹੈ।
ਖੈਰ, ਇੱਕ ਛੋਟੀ, ਵਧੀਆ ਵਿਸ਼ੇਸ਼ਤਾ ਜੋ ਇੱਕ ਵੱਖਰੇ ਮੋਡੀਊਲ ਵਿੱਚ ਪਾਉਣ ਦੇ ਯੋਗ ਹੋਵੇਗੀ, "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;
            }
        }
    }

}



ਅਤੇ ਬੇਸ਼ੱਕ, ਉਪਭੋਗਤਾ ਨੂੰ ਕਿਸੇ ਕਿਸਮ ਦੀ ਪੰਨਾ ਸਮੱਗਰੀ ਪ੍ਰਾਪਤ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਇਸ ਲਈ ਜਵਾਬਾਂ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਮੋਡੀਊਲ ਹੈ, ਜੋ ਸਰੋਤ ਬੇਨਤੀਆਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ।
ਰਾਈਟਰ ਕੰਟਰੋਲਰ
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, ਜਾਂ ਇਸਦੇ ਇੱਕ ਹਿੱਸੇ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ. ਇਸ ਵਿੱਚ ਅਵੈਧ ਬੇਨਤੀਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਅਤੇ ਇੱਕ ਢੁਕਵਾਂ ਗਲਤੀ ਕੋਡ ਜਾਰੀ ਕਰਨਾ ਵੀ ਸ਼ਾਮਲ ਹੈ।
ਰੇਜ਼ਰ ਕੰਟਰੋਲਰ
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 ਦੁਆਰਾ ਸਰਵਰ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਕੌਂਫਿਗਰ ਕਰਨ ਦੀ ਵੀ ਲੋੜ ਨਹੀਂ ਸੀ; ਇਹ ਕਾਫ਼ੀ ਸੀ ਕਿ ਸਿਸਟਮ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਲੋੜੀਂਦੇ ਪੋਰਟ 'ਤੇ ਇੱਕ ਸਰਟੀਫਿਕੇਟ ਸਥਾਪਤ ਸੀ।
ਡਿਵਾਈਸ ਸਾਈਡ ਅਤੇ ਸਾਈਟ ਸਾਈਡ 'ਤੇ, ਦੋ ਕਲਾਇੰਟਸ ਨੇ ਸੰਦੇਸ਼ਾਂ ਦਾ ਆਦਾਨ-ਪ੍ਰਦਾਨ ਕੀਤਾ, ਇਹ ਸਭ ਲੌਗ ਕੀਤਾ ਗਿਆ ਸੀ। ਸਰਵਰ ਨੂੰ ਹੌਲੀ ਕਰਨ ਵਾਲੇ ਕੋਈ ਵੱਡੇ ਪਾਰਸਰ ਨਹੀਂ, ਇਸ ਵਿੱਚੋਂ ਕਿਸੇ ਦੀ ਵੀ ਲੋੜ ਨਹੀਂ ਸੀ। ਜਵਾਬ ਸਮਾਂ 200ms ਤੋਂ ਘਟ ਕੇ 40-30ms ਹੋ ਗਿਆ ਹੈ। ਅਤੇ ਮੈਂ ਸਿਰਫ ਸਹੀ ਫੈਸਲੇ 'ਤੇ ਆਇਆ ਹਾਂ.

Tcp 'ਤੇ ਮੌਜੂਦਾ ਸਰਵਰ ਲਾਗੂਕਰਨ ਨੂੰ ਬਾਹਰ ਸੁੱਟੋ ਅਤੇ Http ਦੇ ਅਧੀਨ ਹਰ ਚੀਜ਼ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੋ। ਹੁਣ ਪ੍ਰੋਜੈਕਟ ਰੀਡਿਜ਼ਾਈਨ ਪੜਾਅ ਵਿੱਚ ਹੈ, ਪਰ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਦੇ ਬਿਲਕੁਲ ਵੱਖਰੇ ਸਿਧਾਂਤਾਂ ਦੇ ਅਨੁਸਾਰ. ਡਿਵਾਈਸਾਂ ਅਤੇ ਸਾਈਟ ਦਾ ਸੰਚਾਲਨ ਸਮਕਾਲੀ ਅਤੇ ਡੀਬੱਗ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਇਸਦਾ ਇੱਕ ਆਮ ਸੰਕਲਪ ਹੈ, ਸਿਰਫ ਫਰਕ ਇਹ ਹੈ ਕਿ ਡਿਵਾਈਸਾਂ ਲਈ HTML ਪੰਨੇ ਬਣਾਉਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।
ਸਿੱਟਾ
"ਜੇ ਤੁਸੀਂ ਫੋਰਡ ਨੂੰ ਨਹੀਂ ਜਾਣਦੇ, ਤਾਂ ਪਾਣੀ ਵਿੱਚ ਨਾ ਜਾਓ" ਮੈਂ ਸੋਚਦਾ ਹਾਂ ਕਿ ਕੰਮ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਮੇਰੇ ਕੋਲ ਵਧੇਰੇ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਟੀਚਿਆਂ ਅਤੇ ਉਦੇਸ਼ਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਵੱਖ-ਵੱਖ ਗਾਹਕਾਂ 'ਤੇ ਉਹਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀਆਂ ਤਕਨਾਲੋਜੀਆਂ ਅਤੇ ਤਰੀਕਿਆਂ ਦਾ ਅਧਿਐਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਪ੍ਰੋਜੈਕਟ ਪਹਿਲਾਂ ਹੀ ਪੂਰਾ ਹੋਣ ਦੇ ਨੇੜੇ ਹੈ, ਪਰ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਮੈਂ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਨ ਲਈ ਵਾਪਸ ਆਵਾਂਗਾ ਕਿ ਮੈਂ ਕੁਝ ਚੀਜ਼ਾਂ ਨੂੰ ਦੁਬਾਰਾ ਕਿਵੇਂ ਸੁਰੱਖਿਅਤ ਕੀਤਾ। ਮੈਂ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਬਹੁਤ ਕੁਝ ਸਿੱਖਿਆ ਹੈ, ਪਰ ਭਵਿੱਖ ਵਿੱਚ ਸਿੱਖਣ ਲਈ ਹੋਰ ਵੀ ਬਹੁਤ ਕੁਝ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹੁਣ ਤੱਕ ਪੜ੍ਹ ਲਿਆ ਹੈ, ਤਾਂ ਅਜਿਹਾ ਕਰਨ ਲਈ ਤੁਹਾਡਾ ਧੰਨਵਾਦ।
ਸਰੋਤ: www.habr.com