Entrada
Todo empezó cuando un colega me sugirió que hiciera un pequeño servicio web. Se suponía que era algo así como Tinder, pero para un lugar de reunión de TI. La funcionalidad es absolutamente sencilla: te registras, rellenas un perfil y pasas al punto principal: encontrar un interlocutor, ampliar tus conexiones y hacer nuevas amistades.
Aquí tengo que hacer una digresión y contar un poco sobre mí, para que en el futuro quede más claro por qué tomé tales pasos en el desarrollo.
Actualmente ocupo el puesto de Artista Técnico en un estudio de juegos, mi experiencia en programación en C# se basó únicamente en escribir scripts y utilidades para Unity y, además, crear complementos para trabajo de bajo nivel con dispositivos Android. Fuera de este pequeño mundo, todavía no he elegido y luego se me ha ocurrido esa oportunidad.
Parte 1. Creación de prototipos de marcos
Habiendo decidido cómo será este servicio, comencé a buscar opciones de implementación. La forma más sencilla sería encontrar algún tipo de solución ya preparada en la que, como un búho en un globo terráqueo, podamos utilizar nuestra mecánica y exponer todo para la censura pública.
Pero esto no es interesante, no vi ningún desafío ni sentido en esto, y por eso comencé a estudiar tecnologías web y métodos para interactuar con ellas.
El estudio comenzó viendo artículos y documentación en C#.Net. Aquí encontré varias formas de realizar la tarea. Existen muchos mecanismos para interactuar con la red, desde soluciones completas como ASP.Net o servicios Azure, hasta interacción directa con conexiones TcpHttp.
Habiendo hecho el primer intento con ASP, lo cancelé inmediatamente, en mi opinión fue una decisión demasiado difícil para nuestro servicio. No utilizaremos ni un tercio de las capacidades de esta plataforma, así que continué mi búsqueda. Surgió la elección entre TCP y Http cliente-servidor. Aquí, en Habré, encontré un artículo sobre , después de haber recopilado y probado cuál, decidí concentrarme en interactuar con conexiones TCP, por alguna razón pensé que http no me permitiría crear una solución multiplataforma.
La primera versión del servidor incluía el manejo de conexiones, la entrega de contenido de páginas web estáticas y la inclusión de una base de datos de usuarios. Y para empezar, decidí crear una función para trabajar con el sitio, para luego poder vincular aquí el procesamiento de la aplicación en Android e iOS.
Aquí hay un código
El hilo principal que acepta clientes en un bucle sin fin:
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);
}
}
}El propio controlador de cliente:
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();
}
}
}
Y la primera base de datos construida en SQL local: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}");
}
}
}
}
}
Como puedes ver, esta versión difiere poco de la del artículo. De hecho, aquí solo se agregó la carga de páginas desde una carpeta en la computadora y la base de datos (que, por cierto, no funcionó en esta versión debido a la arquitectura de conexión incorrecta).Capitulo 2
Después de probar el servidor, llegué a la conclusión de que sería una gran solución (spoiler: no), para nuestro servicio, por lo que el proyecto empezó a adquirir lógica.
Paso a paso, comenzaron a aparecer nuevos módulos y se amplió la funcionalidad del servidor. El servidor ha adquirido un dominio de prueba y cifrado de conexión SSL.Un poco más de código que describe la lógica del servidor y el procesamiento de clientes.
Una versión actualizada del servidor, incluido el uso de un certificado.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(); } } }Y también un nuevo controlador de cliente con autorización 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);
}
}
}
Pero como el servidor funciona exclusivamente en una conexión TCP, es necesario crear un módulo que pueda reconocer el contexto de la solicitud. Decidí que aquí es adecuado un analizador que dividirá la solicitud del cliente en partes separadas con las que puedo interactuar para darle al cliente las respuestas necesarias.analizador
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;
}
}
}
Su esencia radica en el hecho de que con la ayuda de expresiones regulares se puede dividir la solicitud en partes. Recibimos un mensaje del cliente, seleccionamos la primera línea, que contiene el método y la URL de solicitud. Luego leemos los encabezados, que incorporamos a una matriz del formato NombreEncabezado = Contenido, y también buscamos, si lo hay, el contenido que los acompaña (por ejemplo, cadena de consulta) que también incorporamos a una matriz similar. Además, el analizador descubre si el cliente actual está autorizado y guarda sus datos. Todas las solicitudes de clientes autorizados contienen un hash de autorización, que se almacena en cookies, gracias al cual es posible separar la lógica de trabajo adicional para dos tipos de clientes y darles las respuestas correctas.Bueno, una característica pequeña y agradable que debería trasladarse a un módulo separado, convirtiendo solicitudes como "site.com/@UserName" en páginas de usuario generadas dinámicamente. Después de procesar la solicitud, entran en juego los siguientes módulos.
Capítulo 3. Instalación del manillar, lubricación de la cadena.
Tan pronto como el analizador se completa, el controlador entra en juego, dando más instrucciones al servidor y dividiendo el control en dos partes.
manejador simple
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); }; } } }De hecho, solo hay una verificación de autorización del usuario, después de la cual comienza el procesamiento de la solicitud.
Controladores de cliente
Si el usuario no está autorizado, para él la funcionalidad se basa únicamente en la visualización de los perfiles de usuario y la ventana de registro de autorización. El código para un usuario autorizado parece más o menos el mismo, por lo que no veo ninguna razón para duplicarlo.Usuario no autorizado
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;}
}
}
}
Y por supuesto, el usuario debe recibir algún contenido de las páginas, por lo que para respuestas existe el siguiente módulo, que se encarga de responder a una solicitud de recursos.EscritorControlador
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();
}
}
}
Pero para mostrarle al usuario su perfil y los perfiles de otros usuarios, decidí usar RazorEngine, o más bien parte de él. También incluye manejar solicitudes incorrectas y emitir el código de error apropiado.Controlador de maquinilla de afeitar
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(); } } } }Y por supuesto, para que funcione la verificación de usuarios autorizados, se necesita autorización. El módulo de autorización interactúa con la base de datos. Los datos recibidos de los formularios del sitio se analizan a partir del contexto, el usuario se guarda y recibe a cambio cookies y acceso al servicio.
Módulo de autorización
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);
}
}
}
}
Y así es como se ve la base de datos:База данных
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;
}
}
}
}
Y todo funciona como un reloj, trabajo de autorización y registro, la funcionalidad mínima de acceso al servicio ya está disponible y es hora de escribir una solicitud y vincular todo con las funciones principales para las cuales está hecho todo.Capítulo 4. Tirar la bicicleta
Para reducir los costos laborales de escribir dos aplicaciones para dos plataformas, decidí crear una plataforma multiplataforma en Xamarin.Forms. Nuevamente gracias a que está en C#. Después de haber creado una aplicación de prueba que simplemente envía datos al servidor, me encontré con un momento interesante. Para una solicitud del dispositivo, por diversión, lo implementé en HttpClient y lo lancé al servidor HttpRequestMessage, que contiene datos del formulario de autorización en formato json. Sin esperar nada en particular, abrí el registro del servidor y vi una solicitud del dispositivo con todos los datos allí. Ligero estupor, conciencia de todo lo que se ha hecho durante las últimas 3 semanas de velada lánguida. Para comprobar la exactitud de los datos enviados, monté un servidor de prueba en HttpListner. Habiendo recibido la siguiente solicitud, la desarmé en un par de líneas de código y obtuve los datos KeyValuePair del formulario. El análisis de consultas se redujo a dos líneas.
Comencé a realizar más pruebas, no se mencionó antes, pero en el servidor anterior también implementé un chat integrado en websockets. Funcionó bastante bien, pero el principio mismo de interacción a través de Tcp era deprimente: se tuvo que hacer demasiado trabajo innecesario para construir de manera competente la interacción de dos usuarios con un registro de correspondencia. Esto incluye analizar una solicitud para cambiar la conexión y recopilar una respuesta utilizando el protocolo RFC 6455. Por lo tanto, en el servidor de prueba, decidí crear una conexión websocket simple. Solo por diversión.
conexión de 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(); } } } } }Y funcionó. El propio servidor configuró la conexión y generó una clave de respuesta. Ni siquiera tuve que configurar por separado el registro del servidor a través de SSL, basta con que el sistema ya tenga un certificado instalado en el puerto requerido.
En el lado del dispositivo y en el lado del sitio, dos clientes intercambiaron mensajes, todo esto quedó registrado. No había grandes analizadores que ralentizaran el servidor, nada de esto era necesario. El tiempo de respuesta se ha reducido de 200 ms a 40-30 ms. Y tomé la única decisión correcta.
Deseche la implementación actual del servidor en Tcp y reescriba todo en Http. Ahora el proyecto se encuentra en la etapa de rediseño, pero de acuerdo con principios de interacción completamente diferentes. El funcionamiento de los dispositivos y del sitio está sincronizado y depurado y tiene un concepto común, con la única diferencia de que los dispositivos no necesitan generar páginas html.
conclusión
“Si no conoces el vado, no te metas al agua” Creo que antes de empezar a trabajar debería haber definido más claramente las metas y objetivos, así como profundizar en el estudio de las tecnologías y métodos necesarios para su implementación en diversos clientes. El proyecto ya está a punto de finalizar, pero tal vez vuelva a hablar de cómo volví a arruinar ciertas cosas. Aprendí mucho durante el proceso de desarrollo, pero hay más que aprender en el futuro. Si has leído hasta aquí, gracias por leer.
Fuente: habr.com
