Introduction
It all started when a colleague suggested that I create a small web service. It was supposed to be something like a tinder, but for the IT crowd. The functionality is extremely simple, you register, fill out a profile and go to the main point, namely, finding an interlocutor and expanding your connections and getting new acquaintances.
Here I must digress and tell a little about myself, so that in the future it would be clearer why I took such steps in development.
At the moment, I hold the position of a Technical Artist in one game studio, my experience in C # programming was based only on writing scripts and utilities for Unity and, in addition to this, creating plugins for low-level work with android devices. I haven’t gotten out of this little world yet, and then such an opportunity turned up.
Part 1. Prototyping the frame
Having decided what this service would be like, I began to look for options for implementation. The easiest way would be to find some kind of ready-made solution, which, like an owl on a globe, can be pulled by our mechanics and put the whole thing on public censure.
But this is not interesting, I did not see any challenge and sense in this, and therefore I began to study web technologies and methods of interaction with them.
I started by looking at C # .Net articles and documentation. Here I found various ways to accomplish the task. There are many mechanisms for interacting with the network, from full-fledged solutions like ASP.Net or Azure services, to direct interaction with Tcp \ Http connections.
Having made the first attempt with ASP, I immediately dismissed it, in my opinion it was too difficult a decision for our service. We will not use even a third of the capabilities of this platform, so I continued to search. The choice came between TCP and Http client-server. Here, on Habré, I came across an article about a multithreaded server , having collected and tested which, I decided to focus on the interaction with TCP connections, for some reason I thought that http would not allow me to create a cross-platform solution.
The first version of the server included handling connections, serving static content on web pages, and including a user database. And for starters, I decided to build a functional for working with the site, so that later on the processing of the application on android and ios would be attached here.
Here's some code
, :
:
local SQL:
, , . ( , - ).
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("\r\n\r\n") >= 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 = $"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 = $"image/{Extension.Substring(1)}";
break;
default:
if (Extension.Length > 1)
{
ContentType = $"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 = $"HTTP/1.1 200 OK\nContent-Type: {ContentType}\nContent-Length: {FS.Length}\n\n";
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();
}
}
}local 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($"{item.login} {item.password}");
}
}
}
}
}, , . ( , - ).
Chapter 2. Tightening the wheels
After testing the server operation, I came to the conclusion that this would be an excellent solution ( spoiler: no ) for our service, so the project began to acquire logic.
Step by step new modules began to appear and the server's functionality expanded. The server has got a test domain and ssl encryption of the connection.
A little more code describing the logic of the server and client handling
, .
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:\ssl\itinder.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" +
$"|{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);
}
}
}
But since the server works exclusively on a TCP connection, it is necessary to create a module that could recognize the request context. I decided that a parser would be suitable here, which will split the request from the client into separate parts, with which I can interact in order to give the client the necessary answers.
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($"\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;
}
}
}Its essence lies in the fact that using regular expressions to split the request into parts. We receive a message from the client, select the first line, which contains the method and url of the request. Then we read the headers, which we drive into an array of the form HeaderName = Content, and also find, if any, accompanying content (for example, querystring) which we also drive into a similar array. In addition, the parser finds out if the current client is authorized and saves its data. All requests from authorized clients contain an authorization hash, which is stored in cookies, so you can separate further work logic for two types of clients and give them the correct answers.
Well, and a small, nice feature that should be taken out in a separate module, converting requests like "site.com/@UserName" into dynamically generated user pages. After processing the request, the following modules come into play.
Chapter 3. Handlebar Installation, Chain Lubrication
As soon as the parser has finished working, the handler comes into play, giving further instructions to the server and dividing control into two parts.
Simple handler
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);
};
}
}
}In fact, there is only one check for user authorization, after which the request processing begins.
Client controllers
, \. , .
, , , .
RazorEngine, . .
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 = $"HTTP/1.1 200 OK\nContent-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;
}
}
}
}
, , , .
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 = $"{Header}\nContent-Length: {fileStream.Length}\n\n";
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 OK\nContent-Type:";
switch (extension)
{
case ".html":
case ".htm":
return $"{Header} text/html";
case ".css":
return $"{Header} text/css";
case ".js":
return $"{Header} text/javascript";
case ".jpg":
case ".jpeg":
case ".png":
case ".gif":
return $"{Header} image/{extension}";
default:
if (extension.Length > 1)
{
return $"{Header} application/" + extension.Substring(1);
}
else
{
return $"{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, . .
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();
}
}
}
}
And of course, in order for the verification of authorized users to work, you need authorization. The authorization module interacts with the database. The data received from the forms on the site is parsed from the context, the user is saved and in return receives cookies and access to the service.
Authorization module
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($"HTTP/1.1 301 Moved Permanently\nLocation: /@{user.login}\nSet-Cookie: {cookies.AuthCookie}; Expires={DateTime.Now.AddDays(2):R}; Secure; HttpOnly\n\n");
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($"{user.password} {user.password.Trim().Length}");
DatabaseWorker.UserRegister(user);
var response = Encoding.UTF8.GetBytes($"HTTP/1.1 301 Moved Permanently\nLocation: /@{user.login}\nSet-Cookie: {user.cookie}; Expires={DateTime.Now.AddDays(2):R}; Secure; HttpOnly\n\n");
ClientStream.BeginWrite(response, 0, response.Length, WriteController.OnClientSend, null);
}
else
{
RazorController.ErrorLoader(401);
}
}
}
}
And this is how database processing looks like:
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($"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($"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;
}
}
}
}
And everything works like clockwork, authorization and registration is working, the minimum functionality of access to the service is already available, and it's time to write an application and tie the whole thing with the main functions for which everything is done.
Chapter 4. Throwing away the bike
In order to reduce labor costs for writing two applications for two platforms, I decided to make a cross-platform on Xamarin.Forms. Again, due to the fact that it is in C #. Having made a test application that simply sends data to the server, I ran into one interesting point. For a request from the device, for interest, I implemented it on HttpClient and threw it onto the server HttpRequestMessage, which contains data from the authorization form in json format. Without expecting anything, I opened the server log and saw a request from the device with all the data. A slight stupor, the realization of everything that has been done in the last 3 weeks of a languid evening. To check the correctness of the sent data, I collected a test server on HttpListner. Having received the next request already on it, in a couple of lines of code I parsed it into parts, received the KeyValuePair of data from the form.The parsing of the query was reduced to two lines.
I started testing further, it was not mentioned earlier, but on the previous server I was still implementing a chat built on websockets. It worked pretty well, but the very principle of interaction through Tcp was depressing, too much superfluous had to be produced in order to competently build the interaction of two users with the maintenance of a correspondence log. This is parsing a request for a connection switch and collecting a response using the RFC 6455 protocol. Therefore, in the test server, I decided to create a simple websocket connection. Purely for fun.
Connect to 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();
}
}
}
}
}
And it worked. The server set up the connection itself, generated a response key. I didn't even have to separately configure the server registration via ssl, it was enough that the certificate was already installed in the system on the required port.
On the device side and on the site side, two clients exchanged messages, all this was logged. No huge parsers slowing down the server, none of this was required. The response time has decreased from 200ms to 40-30ms. And I came to the only correct decision.
Throw the current server implementation to Tcp and rewrite everything under Http. Now the project is at the stage of redesigning, but already according to completely different principles of interaction. The operation of devices and the site is synchronized and debugged and has a common concept, with the only difference that you do not need to generate html pages for devices.
Output
“Not knowing the ford, do not poke your head into the water” I think, before starting work, I should have more clearly defined the goals and objectives, as well as delve into the study of the necessary technologies and methods of their implementation on various clients. The project is already nearing completion, but maybe I'll come back to talk about how I got some stuff again. I learned a lot during the development process, but there is still more to be learned in the future. If you've read this far, thank you for that.