GameSparks Client Proxy

//in main "Awake" method:

//Set proxy address
ProxyAddress.addressServerEndPoint = ...

GameSparks.RT.Connection.ProxyTool.TcpProxy = TcpProxy;
GameSparks.RT.Connection.ProxyTool.UdpProxy = UdpProxy;

private IPEndPoint TcpProxy(IPEndPoint endPoint)
{
    return ProxyAddress.GetTcp(endPoint);
}

private IPEndPoint UdpProxy(IPEndPoint endPoint)
{
    // Like userID + matchID to avoid collisions
    var id = ...

    return ProxyAddress.GetUdp(id, endPoint);
}

public static class ProxyAddress
{
    public static IPEndPoint addressServerEndPoint;

    public static byte tryCount = 20;

    public static ushort retryDelayMs = 100;

    private class Context
    {
        internal readonly UdpClient socket;

        internal readonly string request;

        internal volatile string result;

        internal Context(UdpClient socket, string request)
        {
            this.socket = socket;
            this.request = request;
        }
    }

    public static IPEndPoint GetTcp(IPEndPoint address)
    {
        return Get("tcp", null, address);
    }

    public static IPEndPoint GetUdp(string id, IPEndPoint address)
    {
        return Get("udp", id, address);
    }

    private static IPEndPoint Get(string protocol, string id, IPEndPoint address)
    {
        var request = protocol + address;
        if (!string.IsNullOrEmpty(id)) request += ':' + id;

        var context = new Context(new UdpClient(addressServerEndPoint.Address.ToString(), addressServerEndPoint.Port), request);

        context.socket.BeginReceive(OnDataReceive, context);

        var bytes = Encoding.ASCII.GetBytes(context.request);
        for (var i = 0; i < tryCount; i++)
        {
            context.socket.Send(bytes, bytes.Length);

            Thread.Sleep(retryDelayMs);

            if (context.result != null)
            {
                context.socket.Close();

                var args = context.result.Split(':');

                return new IPEndPoint(IPAddress.Parse(args[0]), ushort.Parse(args[1]));
            }
        }

        return new IPEndPoint(0, 0);
    }

    private static void OnDataReceive(IAsyncResult result)
    {
        var context = (Context) result.AsyncState;

        if (context.result == null)
        {
            try
            {
                var remoteEndPoint = new IPEndPoint(0, 0);
                var data = context.socket.EndReceive(result, ref remoteEndPoint);

                if (data != null && data.Length > 4)
                {
                    var responseString = Encoding.ASCII.GetString(data);

                    var response = responseString.Split(new[] {"/"}, StringSplitOptions.RemoveEmptyEntries);

                    if (response.Length == 2 && response[0] == context.request)
                    {
                        if (ushort.TryParse(response[1], out var port))
                        {
                            context.result = remoteEndPoint.Address + ":" + port;

                            return;
                        }
                    }
                }
            }
            catch
            {
                return;
            }
        }

        try
        {
            context.socket.BeginReceive(OnDataReceive, context);
        }
        catch
        {
            //Ignore all
        }
    }
}