C# .Net 프레임워크 기반의 고급 사이클링 또는 클라이언트-서버 애플리케이션

기입

동료가 작은 웹 서비스를 만들자고 제안하면서 모든 것이 시작되었습니다. 부싯깃과 같은 것이지만 IT 행 아웃을위한 것입니다. 기능은 완전히 간단합니다. 등록하고 프로필을 작성하고 대담자를 찾고 연결을 확장하고 새로운 지인을 만드는 주요 지점으로 이동합니다.

여기에서 나는 나 자신에 대해 조금 이야기하고 이야기해야하므로 앞으로 내가 왜 그러한 개발 단계를 밟았는지 더 명확해질 것입니다.

현재 저는 게임 스튜디오에서 테크니컬 아티스트의 직책을 맡고 있으며 C# 프로그래밍 경험은 Unity용 스크립트 및 유틸리티 작성과 더불어 안드로이드 장치로 저수준 작업을 위한 플러그인 생성에만 기반을 두고 있습니다. 이 세상 밖에서는 아직 그런 기회를 선택해서 찾아본 적이 없습니다.

파트 1. 프레임 프로토타이핑

이 서비스가 무엇인지 결정한 후 구현 옵션을 찾기 시작했습니다. 가장 쉬운 방법은 일종의 기성 솔루션을 찾는 것입니다. 지구본의 올빼미처럼 우리의 역학을 끌어내어 대중의 비난을 위해 모든 것을 배치할 수 있습니다.
그러나 이것은 흥미롭지 않고 이것에서 어떤 도전과 의미도 보지 못했기 때문에 웹 기술과 상호 작용 방법을 연구하기 시작했습니다.

연구는 C# .Net에서 기사와 문서를 보는 것으로 시작되었습니다. 여기에서 작업을 수행하는 다양한 방법을 찾았습니다. ASP.Net 또는 Azure 서비스와 같은 본격적인 솔루션에서 TcpHttp 연결과의 직접적인 상호 작용에 이르기까지 네트워크와 상호 작용하기 위한 많은 메커니즘이 있습니다.

ASP로 첫 시도를 한 후 즉시 취소했는데 저희 서비스에 너무 어려운 결정이었다고 생각합니다. 이 플랫폼 기능의 XNUMX/XNUMX도 사용하지 않을 것이므로 검색을 계속했습니다. TCP와 Http 클라이언트-서버 사이에서 선택이 이루어졌습니다. 여기 Habré에서 다음과 같은 기사를 접했습니다. 다중 스레드 서버, 수집하고 테스트 한 후 TCP 연결과의 상호 작용에 집중하기로 결정했습니다. 어떤 이유로 http가 크로스 플랫폼 솔루션을 만들 수 없다고 생각했습니다.

서버의 첫 번째 버전에는 연결 처리, 정적 웹 페이지 콘텐츠 제공 및 사용자 데이터베이스가 포함되었습니다. 그리고 우선 사이트 작업을 위한 기능을 구축하기로 결정했습니다. 나중에 여기에서 Android 및 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 형식의 배열로 구동하는 헤더를 읽고 유사한 배열로 구동하는 수반되는 콘텐츠(예: 쿼리 문자열)가 있는 경우 찾기도 합니다. 또한 파서는 현재 클라이언트가 권한이 있는지 확인하고 데이터를 저장합니다. 승인된 클라이언트의 모든 요청에는 쿠키에 저장되는 승인 해시가 포함되어 있습니다. 덕분에 두 가지 유형의 클라이언트에 대한 추가 작업 로직을 분리하고 올바른 답변을 제공할 수 있습니다.
음, "site.com/@UserName"과 같은 요청을 동적으로 생성된 사용자 페이지로 변환하는 별도의 모듈로 이동해야 하는 작고 멋진 기능입니다. 요청을 처리한 후 다음 모듈이 작동합니다.
Chapter 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에 구현하고 json 형식의 승인 양식 데이터가 포함된 HttpRequestMessage 서버에 던졌습니다. 특별한 것을 기대하지 않고 서버 로그를 열었고 모든 데이터가 있는 장치의 요청을 보았습니다. 가벼운 무감각, 나른한 저녁의 지난 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 페이지를 생성할 필요가 없다는 유일한 차이점을 제외하고는 공통 개념을 가집니다.
출력
"나루도 모르고 물에 머리를 찌르지 말라" 작업을 시작하기 전에 목표와 목표를 더 명확하게 정의하고 다양한 클라이언트에서 구현하는 데 필요한 기술과 방법을 연구해야 한다고 생각합니다. 이 프로젝트는 이미 완성에 가까워지고 있지만, 내가 어떤 일을 또 어떻게 망쳤는지에 대해 이야기하기 위해 다시 돌아올 것입니다. 개발 과정에서 많은 것을 배웠지만 앞으로 배울 것이 더 많습니다. 여기까지 읽으셨다면 읽어주셔서 감사합니다.
출처 : habr.com