Iscrizione
Tutto è iniziato quando un collega mi ha suggerito di realizzare un piccolo servizio web. Doveva essere qualcosa come un'esca, ma per un ritrovo informatico. La funzionalità è assolutamente semplice, ti registri, compili un profilo e passi al punto principale, ovvero trovare un interlocutore ed espandere le tue connessioni e fare nuove conoscenze.
Qui devo divagare e raccontare un po' di me, in modo che in futuro sia più chiaro il motivo per cui ho compiuto tali passi nello sviluppo.
Al momento ricopro la posizione di Technical Artist in uno studio di gioco, la mia esperienza di programmazione C# si basava solo sulla scrittura di script e utilità per Unity e, oltre a questo, sulla creazione di plugin per il lavoro di basso livello con dispositivi Android. Al di fuori di questo mondo, non ho ancora scelto e poi presentato un'opportunità del genere.
Parte 1. Prototipazione del telaio
Dopo aver deciso come sarà questo servizio, ho iniziato a cercare opzioni per l'implementazione. Il modo più semplice sarebbe trovare una sorta di soluzione già pronta, sulla quale, come un gufo su un globo, puoi estrarre i nostri meccanici e disporre il tutto per la pubblica censura.
Ma questo non è interessante, non vedevo alcuna sfida e senso in questo, e quindi ho iniziato a studiare le tecnologie web e le modalità di interazione con esse.
Lo studio è iniziato visualizzando articoli e documentazione su C # .Net. Qui ho trovato vari modi per portare a termine il compito. Esistono molti meccanismi per interagire con la rete, da soluzioni complete come ASP.Net o i servizi di Azure, all'interazione diretta con le connessioni TcpHttp.
Dopo aver fatto il primo tentativo con ASP, l'ho subito cancellato, secondo me era una decisione troppo difficile per il nostro servizio. Non utilizzeremo nemmeno un terzo delle capacità di questa piattaforma, quindi ho continuato la mia ricerca. La scelta è nata tra TCP e Http client-server. Qui, su Habré, mi sono imbattuto in un articolo su , dopo aver raccolto e testato quali, ho deciso di concentrarmi sull'interazione con le connessioni TCP, per qualche motivo ho pensato che http non mi avrebbe permesso di creare una soluzione multipiattaforma.
La prima versione del server includeva la gestione delle connessioni, la fornitura di contenuti di pagine Web statiche e l'inclusione di un database utente. E per cominciare, ho deciso di creare un funzionale per lavorare con il sito, in modo che in seguito potessi legare qui l'elaborazione dell'applicazione su Android e iOS.
Ecco un po' di codice
Il thread principale che accetta i client in un ciclo infinito:
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);
}
}
}Il gestore del client stesso:
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();
}
}
}
E il primo database basato su SQL locale: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}");
}
}
}
}
}
Come puoi vedere, questa versione differisce poco da quella nell'articolo. Qui, infatti, sono stati aggiunti solo il caricamento delle pagine da una cartella sul computer e il database (che, tra l'altro, non funzionava in questa versione, a causa dell'architettura di connessione errata).capitolo 2
Dopo aver testato il server, sono giunto alla conclusione che questa sarebbe stata un'ottima soluzione (spoiler: no), per il nostro servizio, quindi il progetto ha iniziato ad acquisire logica.
Passo dopo passo, iniziarono ad apparire nuovi moduli e la funzionalità del server crebbe. Il server ha un dominio di prova e la crittografia della connessione ssl.Un po' più di codice che descrive la logica del server e l'elaborazione dei client
Una versione aggiornata del server, incluso l'uso di un certificato.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(); } } }Oltre a un nuovo gestore client con autorizzazione tramite 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);
}
}
}
Ma poiché il server lavora esclusivamente su una connessione TCP, è necessario creare un modulo che possa riconoscere il contesto della richiesta. Ho deciso che qui è adatto un parser che suddividerà la richiesta del cliente in parti separate con le quali posso interagire per dare al cliente le risposte necessarie.analizzatore
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;
}
}
}
La sua essenza sta nel fatto che con l'aiuto di espressioni regolari per suddividere la richiesta in parti. Riceviamo un messaggio dal client, selezioniamo la prima riga, che contiene il metodo e l'url della richiesta. Quindi leggiamo le intestazioni, che inseriamo in un array della forma HeaderName = Content, e troviamo anche, se presente, il contenuto di accompagnamento (ad esempio, querystring) che inseriamo anch'esso in un array simile. Inoltre, il parser scopre se il client corrente è autorizzato e salva i suoi dati. Tutte le richieste dei client autorizzati contengono un hash di autorizzazione, che viene memorizzato nei cookie, grazie al quale è possibile separare ulteriori logiche di lavoro per due tipi di client e fornire loro le risposte corrette.Bene, una piccola, bella funzionalità che dovrebbe essere spostata in un modulo separato, convertendo richieste come "site.com/@UserName" in pagine utente generate dinamicamente. Dopo aver elaborato la richiesta, entrano in gioco i seguenti moduli.
Capitolo 3. Installazione del manubrio, lubrificazione della catena
Non appena il parser ha completato, il gestore entra in gioco, dando ulteriori istruzioni al server e dividendo il controllo in due parti.
gestore semplice
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); }; } } }Infatti, c'è un solo controllo per l'autorizzazione dell'utente, dopo il quale inizia l'elaborazione della richiesta.
Controllori del cliente
Se l'utente non è autorizzato, per lui la funzionalità si basa solo sulla visualizzazione dei profili utente e sulla finestra di registrazione dell'autorizzazione. Il codice per un utente autorizzato sembra più o meno lo stesso, quindi non vedo alcun motivo per duplicarlo.Utente non autorizzato
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;}
}
}
}
E, naturalmente, l'utente deve ricevere alcuni contenuti delle pagine, quindi per le risposte c'è il seguente modulo, che è responsabile di rispondere a una richiesta di risorse.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":
returnquot;{Header} text/html";
case ".css":
returnquot;{Header} text/css";
case ".js":
returnquot;{Header} text/javascript";
case ".jpg":
case ".jpeg":
case ".png":
case ".gif":
returnquot;{Header} image/{extension}";
default:
if (extension.Length > 1)
{
returnquot;{Header} application/" + extension.Substring(1);
}
else
{
returnquot;{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();
}
}
}
Ma per mostrare all'utente il suo profilo e i profili di altri utenti, ho deciso di utilizzare RazorEngine, o meglio parte di esso. Include anche la gestione delle richieste errate e l'emissione del codice di errore appropriato.Razor Controller
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(); } } } }E, naturalmente, affinché la verifica degli utenti autorizzati funzioni, è necessaria l'autorizzazione. Il modulo di autorizzazione interagisce con il database. I dati ricevuti dai moduli presenti sul sito vengono analizzati dal contesto, l'utente viene salvato e riceve in cambio i cookie e l'accesso al servizio.
Modulo di autorizzazione
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);
}
}
}
}
Ed ecco come appare il database:База данных
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;
}
}
}
}
E tutto funziona come un orologio, il lavoro di autorizzazione e registrazione, la funzionalità minima di accesso al servizio è già disponibile ed è ora di scrivere un'applicazione e legare il tutto alle funzioni principali per le quali tutto è fatto.capitolo 4
Per ridurre i costi di manodopera per la scrittura di due applicazioni per due piattaforme, ho deciso di creare una piattaforma multipiattaforma su Xamarin.Forms. Ancora una volta, grazie al fatto che è in C#. Avendo realizzato un'applicazione di prova che invia semplicemente dati al server, mi sono imbattuto in un momento interessante. Per una richiesta del dispositivo, per gioco, l'ho implementato su HttpClient e l'ho lanciato sul server HttpRequestMessage che contiene i dati del modulo di autorizzazione in formato json. Senza aspettarmi nulla di particolare, ho aperto il log del server e ho visto una richiesta dal dispositivo con tutti i dati presenti. Leggero stupore, consapevolezza di tutto ciò che è stato fatto nelle ultime 3 settimane di languida serata. Per verificare la correttezza dei dati inviati, ho assemblato un server di prova su HttpListner. Avendo già ricevuto la richiesta successiva, l'ho smontata in un paio di righe di codice, ho ottenuto i dati KeyValuePair dal modulo. Analisi della query ridotta a due righe.
Ho iniziato a testare ulteriormente, non è stato menzionato prima, ma sul server precedente ho ancora implementato una chat costruita su websocket. Funzionava abbastanza bene, ma il principio stesso dell'interazione tramite Tcp era deprimente, dovevano essere prodotti troppi extra per costruire correttamente l'interazione di due utenti con la registrazione della corrispondenza. Ciò include l'analisi di una richiesta di cambio di connessione e la raccolta di una risposta utilizzando il protocollo RFC 6455. Pertanto, nel server di test, ho deciso di creare una semplice connessione websocket. Solo per interesse.
Connessione chat
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(); } } } } }E ha funzionato. Il server stesso ha impostato la connessione, ha generato una chiave di risposta. Non ho nemmeno dovuto configurare separatamente la registrazione del server tramite ssl, è sufficiente che il sistema abbia già un certificato installato sulla porta richiesta.
Sul lato dispositivo e sul lato sito, due client si sono scambiati messaggi, tutto questo è stato registrato. Nessun enorme parser che rallenta il server, niente di tutto ciò era richiesto. Il tempo di risposta è stato ridotto da 200 ms a 40-30 ms. E sono arrivato all'unica decisione giusta.
Elimina l'attuale implementazione del server su Tcp e riscrivi tutto sotto Http. Ora il progetto è in fase di riprogettazione, ma secondo principi di interazione completamente diversi. Il funzionamento dei dispositivi e del sito è sincronizzato e debuggato e ha un concetto comune, con l'unica differenza che i dispositivi non hanno bisogno di generare pagine html.
conclusione
"Non conoscendo il guado, non ficcare la testa nell'acqua" Penso che, prima di iniziare il lavoro, avrei dovuto definire più chiaramente gli obiettivi e gli obiettivi, nonché approfondire lo studio delle tecnologie e dei metodi necessari per la loro implementazione su vari clienti. Il progetto è già in fase di completamento, ma forse tornerò a parlare di come ho sbagliato di nuovo certe cose. Ho imparato molto durante il processo di sviluppo, ma c'è ancora molto da imparare in futuro. Se hai letto fin qui, grazie per aver letto.
Fonte: habr.com
