Entry
Det hele startet med at en kollega foreslo at jeg skulle lage en liten nettjeneste. Det skulle være noe sånt som en tinder, men for en IT-hangout. Funksjonaliteten er helt enkel, du registrerer deg, fyller ut en profil og går videre til hovedpoenget, nemlig å finne en samtalepartner og utvide kontaktene dine og få nye bekjentskaper.
Her må jeg stikke av og fortelle litt om meg selv, slik at det i fremtiden skulle bli tydeligere hvorfor jeg tok slike steg i utviklingen.
For øyeblikket har jeg stillingen som teknisk artist i et spillstudio, C#-programmeringsopplevelsen min var kun basert på å skrive skript og verktøy for Unity, og i tillegg til dette, lage plugins for arbeid på lavt nivå med Android-enheter. Utenfor denne verden har jeg ennå ikke valgt og deretter dukket opp en slik mulighet.
Del 1. Frame Prototyping
Etter å ha bestemt meg for hvordan denne tjenesten skal se ut, begynte jeg å se etter alternativer for implementering. Den enkleste måten ville være å finne en form for ferdig løsning, der du, som en ugle på en jordklode, kan trekke mekanikken vår og legge ut det hele for offentlig kritikk.
Men dette er ikke interessant, jeg så ingen utfordring og mening i dette, og derfor begynte jeg å studere nettteknologier og metoder for å samhandle med dem.
Studien startet med å se artikler og dokumentasjon på C # .Net. Her fant jeg ulike måter å utføre oppgaven på. Det er mange mekanismer for å samhandle med nettverket, fra fullverdige løsninger som ASP.Net eller Azure-tjenester, til direkte interaksjon med TcpHttp-tilkoblinger.
Etter å ha gjort det første forsøket med ASP, avbrøt jeg det umiddelbart, etter min mening var det en for vanskelig avgjørelse for tjenesten vår. Vi vil ikke bruke en tredjedel av mulighetene til denne plattformen, så jeg fortsatte søket. Valget oppsto mellom TCP og Http klient-server. Her på Habré kom jeg over en artikkel om , etter å ha samlet og testet noe, bestemte jeg meg for å fokusere på å samhandle med TCP-tilkoblinger, av en eller annen grunn trodde jeg at http ikke ville tillate meg å lage en løsning på tvers av plattformer.
Den første versjonen av serveren inkluderte håndtering av tilkoblinger, servering av statisk nettsideinnhold og inkludert en brukerdatabase. Og for det første bestemte jeg meg for å bygge en funksjon for å jobbe med nettstedet, slik at jeg senere kunne knytte søknadsbehandlingen på android og ios her.
Her er litt kode
Hovedtråden som aksepterer klienter i en endeløs loop:
using System;
using System.Net.Sockets;
using System.Net;
using System.Threading;
namespace ClearServer
{
class Server
{
TcpListener Listener;
public Server(int Port)
{
Listener = new TcpListener(IPAddress.Any, Port);
Listener.Start();
while (true)
{
TcpClient Client = Listener.AcceptTcpClient();
Thread Thread = new Thread(new ParameterizedThreadStart(ClientThread));
Thread.Start(Client);
}
}
static void ClientThread(Object StateInfo)
{
new Client((TcpClient)StateInfo);
}
~Server()
{
if (Listener != null)
{
Listener.Stop();
}
}
static void Main(string[] args)
{
DatabaseWorker sqlBase = DatabaseWorker.GetInstance;
new Server(80);
}
}
}Selve klientbehandleren:
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();
}
}
}
Og den første databasen bygget på lokal 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}");
}
}
}
}
}
Som du kan se, skiller denne versjonen seg lite fra den i artikkelen. Faktisk ble det bare lagt inn lasting av sider fra en mappe på datamaskinen og databasen her (som forresten ikke fungerte i denne versjonen på grunn av feil tilkoblingsarkitektur).Kapittel 2
Etter å ha testet serveren kom jeg til den konklusjon at dette ville være en flott løsning (spoiler: nei), for vår tjeneste, så prosjektet begynte å skaffe seg logikk.
Steg for steg begynte nye moduler å dukke opp og funksjonaliteten til serveren vokste. Serveren har fått et testdomene og ssl-tilkoblingskryptering.Litt mer kode som beskriver logikken til serveren og behandlingen av klienter
En oppdatert versjon av serveren, inkludert bruk av et sertifikat.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(); } } }Samt en ny klientbehandler med autorisasjon via 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);
}
}
}
Men siden serveren utelukkende fungerer på en TCP-tilkobling, er det nødvendig å lage en modul som kan gjenkjenne forespørselskonteksten. Jeg bestemte meg for at en parser er egnet her som vil dele opp forespørselen fra klienten i separate deler som jeg kan samhandle med for å gi klienten de nødvendige svarene.parser
using ClearServer.Core.UserController; using ReServer.Core.Classes; using System; using System.Collections.Generic; using System.Linq; using System.Net.Security; using System.Net.Sockets; using System.Text; using System.Text.RegularExpressions; namespace ClearServer.Core.Requester { public class RequestContext { public string Message = ""; private readonly byte[] buffer = new byte[1024]; public string RequestMethod; public string RequestUrl; public User RequestProfile; public User CurrentUser = null; public List<RequestValues> HeadersValues; public List<RequestValues> FormValues; private TcpClient TcpClient; private event Action<SslStream, RequestContext> OnRead = RequestHandler.OnHandle; DatabaseWorker databaseWorker = new DatabaseWorker(); public RequestContext(SslStream ClientStream, TcpClient Client) { this.TcpClient = Client; try { ClientStream.BeginRead(buffer, 0, buffer.Length, ClientRead, ClientStream); } catch { return; } } private void ClientRead(IAsyncResult ar) { SslStream ClientStream = (SslStream)ar.AsyncState; if (ar.IsCompleted) { Message = Encoding.UTF8.GetString(buffer); Message = Uri.UnescapeDataString(Message); Console.WriteLine(quot;n{DateTime.Now:g} Client IP:{TcpClient.Client.RemoteEndPoint}n{Message}");
RequestParse();
HeadersValues = HeaderValues();
FormValues = ContentValues();
UserParse();
ProfileParse();
OnRead?.Invoke(ClientStream, this);
}
}private void RequestParse()
{
Match methodParse = Regex.Match(Message, @"(^w+)s+([^s?]+)[^s]*s+HTTP/.*|");
RequestMethod = methodParse.Groups[1].Value.Trim();
RequestUrl = methodParse.Groups[2].Value.Trim();
}
private void UserParse()
{
string cookie;
try
{
if (HeadersValues.Any(x => x.Name.Contains("Cookie")))
{
cookie = HeadersValues.FirstOrDefault(x => x.Name.Contains("Cookie")).Value;
try
{
CurrentUser = databaseWorker.CookieValidate(cookie);
}
catch { }
}
}
catch { }}
private List<RequestValues> HeaderValues()
{
var values = new List<RequestValues>();
var parse = Regex.Matches(Message, @"(.*?): (.*?)n");
foreach (Match match in parse)
{
values.Add(new RequestValues()
{
Name = match.Groups[1].Value.Trim(),
Value = match.Groups[2].Value.Trim()
});
}
return values;
}
private void ProfileParse()
{
if (RequestUrl.Contains("@"))
{
RequestProfile = databaseWorker.FindUser(RequestUrl.Substring(2));
RequestUrl = "/profile";
}
}
private List<RequestValues> ContentValues()
{
var values = new List<RequestValues>();
var output = Message.Trim('n').Split().Last();
var parse = Regex.Matches(output, @"([^&].*?)=([^&]*b)");
foreach (Match match in parse)
{
values.Add(new RequestValues()
{
Name = match.Groups[1].Value.Trim(),
Value = match.Groups[2].Value.Trim().Replace('+', ' ')
});
}
return values;
}
}
}
Dens essens ligger i det faktum at ved hjelp av vanlige uttrykk for å bryte forespørselen i deler. Vi mottar en melding fra klienten, velg den første linjen, som inneholder metoden og forespørsels-url. Deretter leser vi overskriftene, som vi kjører inn i en array av formen HeaderName = Content, og finner også eventuelt tilhørende innhold (for eksempel querystring) som vi også kjører inn i en lignende array. I tillegg finner parseren ut om den nåværende klienten er autorisert og lagrer dataene hans. Alle forespørsler fra autoriserte klienter inneholder en autorisasjonshash, som lagres i informasjonskapsler, takket være den er det mulig å skille videre arbeidslogikk for to typer klienter og gi dem de riktige svarene.Vel, en liten, fin funksjon som bør flyttes inn i en egen modul, som konverterer forespørsler som "site.com/@UserName" til dynamisk genererte brukersider. Etter å ha behandlet forespørselen, kommer følgende moduler inn i bildet.
Kapittel 3. Montering av styret, smøring av kjedet
Så snart parseren er fullført, kommer behandleren i spill, og gir ytterligere instruksjoner til serveren og deler kontrollen i to deler.
enkel behandler
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); }; } } }Faktisk er det bare én sjekk for brukerautorisasjon, hvoretter forespørselsbehandlingen begynner.
Klientkontrollører
Hvis brukeren ikke er autorisert, er funksjonaliteten for ham bare basert på visning av brukerprofiler og autorisasjonsregistreringsvinduet. Koden for en autorisert bruker ser omtrent lik ut, så jeg ser ingen grunn til å duplisere den.Uautorisert bruker
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;}
}
}
}
Og selvfølgelig må brukeren motta noe innhold på sidene, så for svar er det følgende modul, som er ansvarlig for å svare på en forespørsel om ressurser.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();
}
}
}
Men for å vise brukeren hans profil og profiler til andre brukere, bestemte jeg meg for å bruke RazorEngine, eller rettere sagt en del av den. Det inkluderer også håndtering av dårlige forespørsler og utstedelse av riktig feilkode.RazorController
using ClearServer.Core.Requester; using RazorEngine; using RazorEngine.Templating; using System; using System.IO; using System.Net; using System.Net.Security; namespace ClearServer.Core.UserController { internal class RazorController { private RequestContext Context; private SslStream ClientStream; dynamic PageContent; public RazorController(RequestContext context, SslStream clientStream) { this.Context = context; this.ClientStream = clientStream; } public void ProfileLoader(string ViewPath) { string Filepath = ViewPath + "/profile.cshtml"; if (Context.RequestProfile != null) { if (Context.CurrentUser != null && Context.RequestProfile.login == Context.CurrentUser.login) { try { PageContent = new { isAuth = true, Name = Context.CurrentUser.name, Login = Context.CurrentUser.login, Skills = Context.CurrentUser.skills }; ClientSend(Filepath, Context.CurrentUser.login); } catch (Exception e) { Console.WriteLine(e); } } else { try { PageContent = new { isAuth = false, Name = Context.RequestProfile.name, Login = Context.RequestProfile.login, Skills = Context.RequestProfile.skills }; ClientSend(Filepath, "PublicProfile:"+ Context.RequestProfile.login); } catch (Exception e) { Console.WriteLine(e); } } } else { ErrorLoader(404); } } public void ErrorLoader(int Code) { try { PageContent = new { ErrorCode = Code, Message = ((HttpStatusCode)Code).ToString() }; string ErrorPage = "C:/Users/drdre/source/repos/ClearServer/View/Errors/ErrorPage.cshtml"; ClientSend(ErrorPage, Code.ToString()); } catch { } } private void ClientSend(string FilePath, string Key) { var template = File.ReadAllText(FilePath); var result = Engine.Razor.RunCompile(template, Key, null, (object)PageContent); byte[] buffer = System.Text.Encoding.UTF8.GetBytes(result); ClientStream.BeginWrite(buffer, 0, buffer.Length, OnClientSend, ClientStream); } private void OnClientSend(IAsyncResult ar) { if (ar.IsCompleted) { ClientStream.Close(); } } } }Og selvfølgelig, for at verifiseringen av autoriserte brukere skal fungere, trengs autorisasjon. Autorisasjonsmodulen samhandler med databasen. Dataene som mottas fra skjemaene på nettstedet, analyseres fra konteksten, brukeren lagres og mottar informasjonskapsler og tilgang til tjenesten i retur.
Autorisasjonsmodul
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);
}
}
}
}
Og slik ser databasen ut: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;
}
}
}
}
Og alt fungerer som urverk, autorisasjons- og registreringsarbeid, minimumsfunksjonaliteten for tilgang til tjenesten er allerede tilgjengelig, og det er på tide å skrive en søknad og knytte det hele til hovedfunksjonene som alt er gjort for.Kapittel 4
For å redusere arbeidskostnadene ved å skrive to søknader for to plattformer, bestemte jeg meg for å lage en kryssplattform på Xamarin.Forms. Igjen, takket være det faktum at det er i C#. Etter å ha laget en testapplikasjon som ganske enkelt sender data til serveren, møtte jeg et interessant øyeblikk. For en forespørsel fra enheten, for moro skyld, implementerte jeg den på HttpClient og kastet den på serveren HttpRequestMessage som inneholder data fra autorisasjonsskjemaet i json-format. Uten å forvente noe spesielt, åpnet jeg serverloggen og så en forespørsel fra enheten med alle dataene der. Lett stupor, bevissthet om alt som har blitt gjort de siste 3 ukene med sløv kveld. For å sjekke riktigheten av de sendte dataene, satt jeg sammen en testserver på HttpListner. Etter å ha mottatt neste forespørsel allerede på den, tok jeg den fra hverandre i et par linjer med kode, fikk KeyValuePair-dataene fra skjemaet. Spørringsparsing redusert til to linjer.
Jeg begynte å teste videre, det var ikke nevnt før, men på forrige server implementerte jeg fortsatt en chat bygget på websockets. Det fungerte ganske bra, men selve prinsippet for interaksjon via Tcp var deprimerende, for mye ekstra måtte produseres for å kunne bygge samspillet til to brukere riktig med logging av korrespondanse. Dette inkluderer å analysere en forespørsel om tilkoblingsbytte og samle inn et svar ved å bruke RFC 6455-protokollen. Derfor bestemte jeg meg for å opprette en enkel websocket-tilkobling i testserveren. Rent for interessens skyld.
Chat-tilkobling
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(); } } } } }Og det fungerte. Serveren selv satte opp tilkoblingen, genererte en svarnøkkel. Jeg trengte ikke engang å konfigurere serverregistrering separat via ssl, det er nok at systemet allerede har et sertifikat installert på den nødvendige porten.
På enhetssiden og sidesiden utvekslet to klienter meldinger, alt dette ble logget. Ingen store parsere som bremser serveren, ingenting av dette var nødvendig. Responstiden er redusert fra 200ms til 40-30ms. Og jeg kom til den eneste riktige avgjørelsen.
Kast ut den nåværende serverimplementeringen på Tcp og omskriv alt under Http. Nå er prosjektet på redesignstadiet, men etter helt andre samhandlingsprinsipper. Driften av enheter og nettstedet er synkronisert og feilsøkt og har et felles konsept, med den eneste forskjellen at enheter ikke trenger å generere html-sider.
Utgang
"Uten å kjenne vadestedet, ikke stikk hodet i vannet" Jeg tror, før jeg starter arbeidet, burde jeg ha tydeligere definert målene og målene, samt fordype meg i studiet av nødvendige teknologier og metoder for implementering av dem på forskjellige klienter. Prosjektet nærmer seg allerede ferdigstillelse, men kanskje jeg kommer tilbake for å snakke om hvordan jeg har skrudd sammen enkelte ting igjen. Jeg lærte mye under utviklingsprosessen, men det er mer å lære i fremtiden. Hvis du har lest så langt, takk for at du leste.
Kilde: www.habr.com
