static void Main(string[] args)
{
System.Net.WebSockets.WebSocket webSocket = new System.Net.WebSockets.ClientWebSocket();
//new MyWebServer().StartListenAsync().Wait();
//new MyWebServer().Listener();
// this is test
new PostProcessor(8876).Listen();
using (HttpClient client = new HttpClient())
{
client.GetStringAsync("http://127.0.0.1:5700/send_private_msg?user_id=962549599&message=hello%20HTTP/1.1").Wait();
string json = JsonConvert.SerializeObject(new
{
user_id = 962549599,
message = "hello"
});
var content = new StringContent(json, Encoding.UTF8, "application/json");
var t = client.PostAsync("http://127.0.0.1:5700/send_private_msg/", content);
t.Wait();
var r = t.Result;
Console.WriteLine(r.Content.ReadAsStringAsync().Result);
json = JsonConvert.SerializeObject(new
{
group_id = 614892339,
user_id = 2930081217
});
content = new StringContent(json, Encoding.UTF8, "application/json");
t = client.PostAsync("http://127.0.0.1:5700/get_group_member_info", content);
t.Wait();
r = t.Result;
Console.WriteLine(r.Content.ReadAsStringAsync().Result);
}
Console.Read();
}
static async Task Main(string[] args)
{
Console.WriteLine("Write pixels to ESP32");
using (var cts = new CancellationTokenSource())
{
// when cancel is pressed
Console.CancelKeyPress += (s, e) =>
{
cts.Cancel();
e.Cancel = true; // don't terminate the app, just let it finish gracefully
};
using (var cs = new System.Net.WebSockets.ClientWebSocket())
{
// don't forget to change the IP
await cs.ConnectAsync(new Uri("ws://192.168.8.222:1337"), cts.Token);
var buffer = new byte[HeaderSize + StripCount * LedCount * BytesPerPixel]; // 2 strips, 60 leds, 4 bytes per pixel (RGBW)
// while the app is running, write the pixels to the ESP32
while (!cts.IsCancellationRequested)
{
UpdateBuffer(buffer);
await cs.SendAsync(new ArraySegment <byte>(buffer), System.Net.WebSockets.WebSocketMessageType.Binary, true, cts.Token);
}
}
}
}
private async Task ReadMessagesAsync()
{
try
{
var sb = new StringBuilder();
while (true)
{
var buffer = new ArraySegment <byte>(new byte[4096]);
var r = await this.client.ReceiveAsync(buffer, CancellationToken.None);
if (r.MessageType != System.Net.WebSockets.WebSocketMessageType.Text)
{
break;
}
sb.Append(System.Text.Encoding.UTF8.GetString(buffer.Array, 0, r.Count));
if (r.EndOfMessage)
{
var text = sb.ToString();
onMessageReceived?.Invoke(text);
sb.Clear();
}
}
} catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
// disconnect...
client.Dispose();
client = null;
}
}
protected override async Task <Stream> InnerConnectAsync()
{
client = new System.Net.WebSockets.ClientWebSocket();
await client.ConnectAsync(new Uri(options.Url), CancellationToken.None);
return(new WebSocketClientStream(client));
}
public V8InspectorProtocolProxy(Uri uri)
{
this.uri = uri;
client = new System.Net.WebSockets.ClientWebSocket();
cancellationTokenSource = new CancellationTokenSource();
}
public Twitch(string oauth, string canal)
{
this.canal = canal;
this.oauth = oauth;
cliente = new System.Net.WebSockets.ClientWebSocket();
clienteTopic = new System.Net.WebSockets.ClientWebSocket();
}
public async Task <bool> GetWsStatusAsync(int nodeId)
{
var nodeUrl = this.db.Nodes
.Where(x => x.Id == nodeId)
.Select(x => $"ws://{x.Url}:10334")
.FirstOrDefault();
var websocket = new System.Net.WebSockets.ClientWebSocket();
var success = false;
try
{
await websocket.ConnectAsync(new System.Uri(nodeUrl), CancellationToken.None);
success = websocket.State == System.Net.WebSockets.WebSocketState.Open;
await websocket.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus.NormalClosure, null, CancellationToken.None);
}
catch (Exception e)
{
Log.Error("WS connection CloseAsync() ", e);
}
finally
{
websocket.Dispose();
}
return(success);
}
private async Task <System.Net.WebSockets.ClientWebSocket> Connect(string url)
{
System.Net.WebSockets.ClientWebSocket webSocket = new System.Net.WebSockets.ClientWebSocket();
await webSocket.ConnectAsync(new Uri(url), CancellationToken.None);
return(webSocket);
}
static async Task Main(string[] args)
{
var socket = new System.Net.WebSockets.ClientWebSocket();
var chargerId = "xxxx"; // id of the charger
var password = "******"; // any non-empty string
var endpoint = "xxxxxx"; //url to websocket server e.g ws://abc.com
var auth = Convert.ToBase64String(Encoding.UTF8.GetBytes(chargerId + ":" + password));
socket.Options.SetRequestHeader("Authorization", "Basic " + auth);
socket.Options.AddSubProtocol("ocpp1.6");
var cancellationToken = CancellationToken.None;
try
{
await socket.ConnectAsync(new Uri(endpoint + "/" + chargerId), cancellationToken);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
Console.WriteLine(socket.State); // status is opened now
var sampleAuthReq = new AuthorizeRequest();
sampleAuthReq.IdTag = "111"; // a correct IdTag predefined on server side
var newMessageToSend = new TransportLayerMessage
{
MessageType = MessageTypes.CALL,
UniqueId = GenerateUniqueId(),
Action = sampleAuthReq.Action,
Payload = sampleAuthReq.ToJson()
};
if (socket.State == System.Net.WebSockets.WebSocketState.Open)
{
try
{
var keystring = Console.ReadKey();
while (keystring.Key == ConsoleKey.S)
{
await Send(newMessageToSend.ToJson(), socket, cancellationToken);
keystring = Console.ReadKey();
}
Console.WriteLine("finished");
Console.ReadKey();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
/// <summary>
/// Initiates a client connection.
/// </summary>
/// <param name="remoteIp">Remote server IP address to connect to.</param>
/// <param name="remotePort">Remote server IP port to connect to.</param>
/// <param name="enableNatTraversal">Set to true to try and enable NAT traversal via configuring your router for port forwarding.</param>
/// <returns>Returns an instance of the created client ISocket if the connection was established, null otherwise.</returns>
public ISocket Connect(string remoteIp, int remotePort, bool enableNatTraversal = false)
{
if (enableNatTraversal)
{
StartNatPortMapping();
}
System.Net.WebSockets.ClientWebSocket webSocket = Connect(GetClientAddress(remoteIp, remotePort)).Result;
return(SetupClientToken(webSocket).Result);
}
/// <summary>
/// Initiates a client connection.
/// </summary>
/// <param name="remoteIp">Remote server IP address to connect to.</param>
/// <param name="remotePort">Remote server IP port to connect to.</param>
/// <param name="enableNatTraversal">Set to true to try and enable NAT traversal via configuring your router for port forwarding.</param>
/// <returns>Returns an instance of the created client ISocket if the connection was established, null otherwise.</returns>
public async Task <ISocket> ConnectAsync(string remoteIp, int remotePort, bool enableNatTraversal = false)
{
if (enableNatTraversal)
{
StartNatPortMapping();
}
System.Net.WebSockets.ClientWebSocket webSocket = await Connect(GetClientAddress(remoteIp, remotePort));
return(await SetupClientToken(webSocket));
}
public async Task TestWithDifferentCloseResponse()
{
var webSocketUrl = new Uri($"{WebServerUrl.Replace("http", "ws")}close");
using var clientSocket = new System.Net.WebSockets.ClientWebSocket();
await clientSocket.ConnectAsync(webSocketUrl, default).ConfigureAwait(false);
var buffer = new ArraySegment <byte>(new byte[8192]);
var result = await clientSocket.ReceiveAsync(buffer, default).ConfigureAwait(false);
Assert.IsTrue(result.CloseStatus.HasValue);
Assert.IsTrue(result.CloseStatus == System.Net.WebSockets.WebSocketCloseStatus.InvalidPayloadData);
}
/// <summary>
/// Initiates a client connection.
/// </summary>
/// <param name="callback">Callback invoked once the connection is established. T will be null if the connection did not succeed.</param>
/// <param name="remoteIp">Remote server IP address to connect to.</param>
/// <param name="remotePort">Remote server IP port to connect to.</param>
/// <param name="enableNatTraversal">Set to true to try and enable NAT traversal via configuring your router for port forwarding.</param>
/// <returns>Returns an instance of the created client ISocket</returns>
public void ConnectAsync(Action <ISocket> callback, string remoteIp, int remotePort, bool enableNatTraversal = false)
{
Task.Run(async() =>
{
if (enableNatTraversal)
{
StartNatPortMapping();
}
System.Net.WebSockets.ClientWebSocket webSocket = await Connect(GetClientAddress(remoteIp, remotePort));
var result = await SetupClientToken(webSocket);
callback?.Invoke(result);
});
}
public async Task TestSendBigDataWebSocket()
{
var webSocketUrl = new Uri($"{WebServerUrl.Replace("http", "ws")}bigdata");
using var clientSocket = new System.Net.WebSockets.ClientWebSocket();
await clientSocket.ConnectAsync(webSocketUrl, default).ConfigureAwait(false);
var buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes("HOLA"));
await clientSocket.SendAsync(buffer, System.Net.WebSockets.WebSocketMessageType.Text, true, default).ConfigureAwait(false);
var json = await ReadString(clientSocket).ConfigureAwait(false);
Assert.AreEqual(Json.Serialize(BigDataWebSocket.BigDataObject), json);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var socket = new System.Net.WebSockets.ClientWebSocket();
var token = new CancellationToken(false);
socket.ConnectAsync(new Uri("ws://localhost:50000/testsample/test3/test2"), token).Wait();
socket.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes("heelo")), System.Net.WebSockets.WebSocketMessageType.Binary, false, token).Wait();
var buffer = new ArraySegment <byte>(new byte[1024]);
var result = socket.ReceiveAsync(buffer, token);
result.Wait();
Console.WriteLine(Encoding.UTF8.GetString(buffer.Array, 0, result.Result.Count));
Console.ReadLine();
}
protected static async Task <string> ReadString(System.Net.WebSockets.ClientWebSocket ws)
{
var buffer = new ArraySegment <byte>(new byte[8192]);
using var ms = new MemoryStream();
System.Net.WebSockets.WebSocketReceiveResult result;
do
{
result = await ws.ReceiveAsync(buffer, default);
ms.Write(buffer.Array, buffer.Offset, result.Count);
}while (!result.EndOfMessage);
return(Encoding.UTF8.GetString(ms.ToArray()));
}
static async Task TestWS(string url)
{
System.Net.WebSockets.ClientWebSocket cws = new System.Net.WebSockets.ClientWebSocket();
await cws.ConnectAsync(new Uri(url), CancellationToken.None);
Console.WriteLine(cws.State);
for (var i = 0; i < 100; i++)
{
var bytes = System.Text.Encoding.UTF8.GetBytes("hello there.");
ArraySegment <byte> sendbuf = bytes;
await cws.SendAsync(sendbuf, System.Net.WebSockets.WebSocketMessageType.Binary, true, CancellationToken.None);
}
while (true)
{
}
}
public async Task TestConnectWebSocket()
{
var websocketUrl = new Uri(WebServerUrl.Replace("http", "ws") + "test");
using var clientSocket = new System.Net.WebSockets.ClientWebSocket();
await clientSocket.ConnectAsync(websocketUrl, default);
Assert.AreEqual(
System.Net.WebSockets.WebSocketState.Open,
clientSocket.State,
$"Connection should be open, but the status is {clientSocket.State} - {websocketUrl}");
var buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes("HOLA"));
await clientSocket.SendAsync(buffer, System.Net.WebSockets.WebSocketMessageType.Text, true, default);
Assert.AreEqual(await ReadString(clientSocket), "HELLO");
}
public async static void TestWebSocketError()
{
var done = Assert.Async();
try
{
var sc = new System.Net.WebSockets.ClientWebSocket();
await sc.ConnectAsync(new Uri("wss://NotExistServer/NotExist"), System.Threading.CancellationToken.None);
Assert.Fail("ConnectAsync() to an invalid address didn't throw an exception.");
done();
}
catch (Exception ex)
{
Assert.NotNull(ex, "ConnectAsync() thrown an exception when trying to connect to an invalid address.");
done();
}
}
protected static async Task <string> ReadString(System.Net.WebSockets.ClientWebSocket ws)
{
var buffer = new ArraySegment <byte>(new byte[8192]);
#pragma warning disable IDE0067 // Object not disposed - Apparently VS2019 (16.4.2) doesn't understand "await using" yet.
await using var ms = new MemoryStream();
#pragma warning restore IDE0067
System.Net.WebSockets.WebSocketReceiveResult result;
do
{
result = await ws.ReceiveAsync(buffer, default);
ms.Write(buffer.Array !, buffer.Offset, result.Count);
}while (!result.EndOfMessage);
return(Encoding.UTF8.GetString(ms.ToArray()));
}
private static async Task <WebSocket> SetupClientToken(System.Net.WebSockets.ClientWebSocket socket)
{
if (socket.State == System.Net.WebSockets.WebSocketState.Connecting || socket.State == System.Net.WebSockets.WebSocketState.Open)
{
byte[] _buffer = new byte[BUFFER_SIZE];
ArraySegment <byte> buffer = new ArraySegment <byte>(_buffer);
var received = await socket.ReceiveAsync(buffer, CancellationToken.None);
if (received.Count > 0)
{
byte[] tokenBytes = new byte[received.Count];
Array.ConstrainedCopy(buffer.Array, 0, tokenBytes, 0, received.Count);
return(new WebSocket(socket, new RandomId(tokenBytes)));
}
}
return(null);
}
static async Task Send(string ocppMessage, System.Net.WebSockets.ClientWebSocket client, CancellationToken token)
{
try
{
var buf = Encoding.UTF8.GetBytes(ocppMessage);
int offset = 0;
bool lastPackage = false;
do
{
lastPackage = buf.Length - offset <= BufferSize;
await client.SendAsync(new ArraySegment <byte>(buf, offset, lastPackage ? buf.Length - offset : BufferSize), System.Net.WebSockets.WebSocketMessageType.Text, lastPackage, token);
offset += BufferSize;
} while (!lastPackage);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task Connect(Uri uri)
{
this.websocket = new System.Net.WebSockets.ClientWebSocket();
try
{
await websocket.ConnectAsync(uri, System.Threading.CancellationToken.None);
//peer.OnConnect(websocket);
}
catch (Exception err)
{
Console.CursorLeft = 0;
Console.WriteLine("error on connect." + err.Message);
}
//此时调用一个不等待的msgprocessr
MessageProcesser();
MessageSender();
return;
}
public void StartReadingData()
{
cws = new System.Net.WebSockets.ClientWebSocket();
token.Register(OnCancel);
cws.ConnectAsync(new Uri("wss://ws.bitstamp.net"), token).Wait();
string msgSubscribe = String.Format("{{\"event\": \"bts:subscribe\",\"data\": {{\"channel\": \"order_book_{0}\"}}}}\r\n", currencyPair);
string msgUnubscribe = String.Format("{{\"event\": \"bts:unsubscribe\",\"data\": {{\"channel\": \"order_book_{0}\"}}}}\r\n", currencyPair);
cws.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(msgSubscribe)), System.Net.WebSockets.WebSocketMessageType.Binary, true, token);
ReadMsgSync(token);
string msg = ReadMsgSync(token);
cws.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(msgUnubscribe)), System.Net.WebSockets.WebSocketMessageType.Text, true, token);
JsonData data = System.Text.Json.JsonSerializer.Deserialize <JsonData>(msg);
Bids.Clear();
Asks.Clear();
MoveJsonDataToTransactions(data);
thread = new System.Threading.Thread(ReadAndUpdateData);
thread.Start();
}
private void cleanupConnection()
{
Messages.RequestData.resetCounter();
if (sendTh != null)
{
// if (sendTh.ThreadState == ThreadState.Running || sendTh.ThreadState== ThreadState.Background)
// sendTh.Abort();
sendTh = null;
}
if (receiveTh != null)
{
// if (receiveTh.ThreadState == ThreadState.Running || receiveTh.ThreadState == ThreadState.Background)
// receiveTh.Abort();
receiveTh = null;
}
if (client != null)
{
client.Abort();
client = null;
}
}
private void Reconnect(System.Object State)
{
if (this.WebSocket.State == System.Net.WebSockets.WebSocketState.Open)
{
System.String Message = $"{{\"ping\":{System.DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}}}";
/*
#if DEBUG
* System.Console.WriteLine(Message); // Debug Ping Messages
#endif
*/
this.WebSocket.SendAsync(new System.ArraySegment <System.Byte>(System.Text.Encoding.UTF8.GetBytes(Message)), System.Net.WebSockets.WebSocketMessageType.Text, true, System.Threading.CancellationToken.None).ConfigureAwait(false);
return;
}
if (this.WebSocket.State == System.Net.WebSockets.WebSocketState.Connecting)
{
return;
}
if (this._LastState != this._State)
{
this.State = SoftmakeAll.SDK.Communication.ClientWebSocket.ConnectionStates.Disconnected;
this.Closed?.Invoke(this.WebSocket.CloseStatus == System.Net.WebSockets.WebSocketCloseStatus.NormalClosure || this.WebSocket.CloseStatusDescription == null ? null : new System.Exception(this.WebSocket.CloseStatusDescription));
}
if ((!(this.AutomaticReconnection)) || (this.WebSocket.CloseStatus == System.Net.WebSockets.WebSocketCloseStatus.NormalClosure))
{
return;
}
this.WebSocket.Abort();
this.WebSocket.Dispose();
this.WebSocket = null;
try { this.StartAsync().ConfigureAwait(false); } catch { }
}
// 即時関数にはならない
public static void Main()
{
Console.WriteLine("即時関数test");
TimeSpan s1 = new TimeSpan(1), s2 = new TimeSpan(1);
var s3 = s1 + s2;
var s4 = s1 - s2;
if (s3 <= s4)
{
Console.WriteLine("");
}
if (s3 == s4)
{
Console.WriteLine("");
}
var ws = new System.Net.WebSockets.ClientWebSocket();
ws.ConnectAsync(new Uri(""), System.Threading.CancellationToken.None);
var ss = ws.ToString();
}
private static async System.Threading.Tasks.Task Prototype201802084_1()
{
// todo We need exception handling here.
{
double dateTimeFrequencyToPhaseFrequencyRatio =
(double)System.TimeSpan.TicksPerSecond / (double)System.Diagnostics.Stopwatch.Frequency;
long basePhase = System.Diagnostics.Stopwatch.GetTimestamp();
long baseUtcDateTimeInTicks = System.DateTime.UtcNow.Ticks;
basePhase = System.Diagnostics.Stopwatch.GetTimestamp();
baseUtcDateTimeInTicks = System.DateTime.UtcNow.Ticks;
var clientWebSocket = new System.Net.WebSockets.ClientWebSocket();
//System.Threading.Tasks.Task task =
await
clientWebSocket.ConnectAsync
(new System.Uri
//(@"wss://ws-feed-public.sandbox.gdax.com"),
(@"wss://ws-feed.gdax.com"),
System.Threading.CancellationToken.None
);
// todo ??? The caller really should do this if needed.
// todo ??? But any method really should do this
// todo ??? if after {await} it's not supposed to return to the synchronization context.
//// todo Comment in other places where we don't call this.
//.ConfigureAwait(false);
//int timeSpanInMilliSeconds = System.Environment.TickCount;
// todo Remember to call this even if the task already completed -- to rethrow any exceptions.
// todo {task.Result} also waits, right?
//task.Wait();
//task.RunSynchronously();
//timeSpanInMilliSeconds = System.Environment.TickCount - timeSpanInMilliSeconds;
//>>>clientWebSocket.ReceiveAsync
if (clientWebSocket.State == System.Net.WebSockets.WebSocketState.Open)
{
// todo Prototype subscribe/unsubscribe for 1 instrument at a time.
const string channelName =
//@"heartbeat";
//@"ticker";
@"level2";
//@"user";
//@"matches";
//@"full";
const string requestString =
//Newtonsoft.Json.JsonConvert.SerializeObject
// ( new
// {
// type = "subscribe",
// product_ids = new string[] { @"ETH-USD", @"ETH-EUR", },
// }
// );
"{" +
"\"type\":\"subscribe\"," +
"\"channels\":[{\"name\":\"" + channelName + "\",\"product_ids\":[\"BTC-USD\",\"BTC-EUR\"]}]" +
"}";
byte[] requestBytes = System.Text.Encoding.ASCII.GetBytes(requestString);
await clientWebSocket.SendAsync
(new System.ArraySegment <byte>(requestBytes),
// todo ??? Binary didn't work, right?
System.Net.WebSockets.WebSocketMessageType.Text,
//System.Net.WebSockets.WebSocketMessageType.Binary,
true,
System.Threading.CancellationToken.None
);
// todo This really doesn't need to be more than 16K, right?
var receiveBuffer = new System.ArraySegment <byte>(new byte[33 * 1024]);
for (bool isMessageBegin = true; ;)
{
if (clientWebSocket.State != System.Net.WebSockets.WebSocketState.Open)
{
System.Console.WriteLine(@"201802085");
break;
}
else
{
}
System.Net.WebSockets.WebSocketReceiveResult webSocketReceiveResult =
await clientWebSocket.ReceiveAsync(receiveBuffer, System.Threading.CancellationToken.None);
// todo ???
if (webSocketReceiveResult.Count <= 0)
{
System.Console.WriteLine(@"201802086");
break;
}
else
{
}
if (isMessageBegin)
{
isMessageBegin = false;
System.Console.WriteLine(',');
//System.Console.WriteLine();
long currentUtcDateTimeInTicks =
(long)((double)(ulong)(System.Diagnostics.Stopwatch.GetTimestamp() - basePhase) * dateTimeFrequencyToPhaseFrequencyRatio + 0.5) +
baseUtcDateTimeInTicks;
System.Console.Write
((new System.DateTime(currentUtcDateTimeInTicks)).ToString(@"o", System.Globalization.DateTimeFormatInfo.InvariantInfo));
}
else
{
}
string string1 =
System.Text.Encoding.ASCII.GetString(receiveBuffer.Array, 0, webSocketReceiveResult.Count);
System.Console.Write(string1);
if (webSocketReceiveResult.MessageType == System.Net.WebSockets.WebSocketMessageType.Close)
{
System.Console.WriteLine(@"201802087");
break;
}
else
{
}
if (webSocketReceiveResult.EndOfMessage)
{
isMessageBegin = true;
//break;
}
else
{
}
}
}
else
{
System.Console.WriteLine(@"201802088");
}
// todo ??? WebSocketState >= CloseSent
clientWebSocket.Dispose();
}
StaticBool1_ = true;
}
public async System.Threading.Tasks.Task StartAsync(System.Threading.CancellationToken CancellationToken = default)
{
if (this.WebSocket == null)
{
this.WebSocket = new System.Net.WebSockets.ClientWebSocket();
foreach (System.Collections.Generic.KeyValuePair <System.String, System.String> Header in this.Headers)
{
WebSocket.Options.SetRequestHeader(Header.Key, Header.Value);
}
if (this.PingInterval != System.TimeSpan.Zero)
{
WebSocket.Options.SetRequestHeader("pingInterval", this.PingInterval.TotalMilliseconds.ToString());
}
}
switch (this.WebSocket.State)
{
case System.Net.WebSockets.WebSocketState.Connecting:
case System.Net.WebSockets.WebSocketState.Open:
return;
default:
break;
}
if (!(this._IsReconnection))
{
this.State = SoftmakeAll.SDK.Communication.ClientWebSocket.ConnectionStates.Connecting;
}
else
{
this.Reconnecting?.Invoke(null);
this.State = SoftmakeAll.SDK.Communication.ClientWebSocket.ConnectionStates.Reconnecting;
}
try
{
await this.WebSocket.ConnectAsync(new System.Uri(this.URL), CancellationToken);
}
catch
{
this.State = SoftmakeAll.SDK.Communication.ClientWebSocket.ConnectionStates.Disconnected;
throw;
}
if (this.WebSocket.State != System.Net.WebSockets.WebSocketState.Open)
{
this.State = SoftmakeAll.SDK.Communication.ClientWebSocket.ConnectionStates.Disconnected;
return;
}
this.State = SoftmakeAll.SDK.Communication.ClientWebSocket.ConnectionStates.Connected;
if (this._IsReconnection)
{
this.Reconnected?.Invoke(null);
}
_ = System.Threading.Tasks.Task.Run(async() =>
{
const System.Int16 BufferSize = 512;
System.Net.WebSockets.WebSocketReceiveResult Result;
do
{
System.Collections.Generic.IEnumerable <System.Byte> Data = new System.Byte[] { };
do
{
System.Byte[] Buffer = new System.Byte[BufferSize];
Result = await this.WebSocket.ReceiveAsync(new System.ArraySegment <System.Byte>(Buffer), System.Threading.CancellationToken.None);
if (Result.MessageType == System.Net.WebSockets.WebSocketMessageType.Text)
{
Data = Data.Concat(Buffer);
}
}while (!(Result.EndOfMessage));
if ((Result.MessageType == System.Net.WebSockets.WebSocketMessageType.Text) && (this.ReceiveMessageAction != null))
{
System.String Message = System.Text.Encoding.UTF8.GetString(Data.SkipLast(BufferSize - Result.Count).ToArray());
if (!(Message.StartsWith("{\"pong\":")))
{
this.ReceiveMessageAction?.Invoke(Message);
}
else
{
System.Int64 ServerUnixTime = Message.ToJsonElement().GetInt64("pong");
this._Latency = ServerUnixTime > 0 ? System.DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() - ServerUnixTime : 0;
/*
#if DEBUG
* System.Console.WriteLine(Message); // Debug Pong Messages
#endif
*/
}
}
else if (Result.MessageType == System.Net.WebSockets.WebSocketMessageType.Close)
{
this.State = SoftmakeAll.SDK.Communication.ClientWebSocket.ConnectionStates.Disconnected;
this.Closed?.Invoke(Result.CloseStatus == System.Net.WebSockets.WebSocketCloseStatus.NormalClosure || Result.CloseStatusDescription == null ? null : new System.Exception(Result.CloseStatusDescription));
}
}while (this.WebSocket.State == System.Net.WebSockets.WebSocketState.Open);
});
if ((!(this._IsReconnection)) && (this.PingInterval != System.TimeSpan.Zero))
{
this._ReconnectionTimer = new System.Threading.Timer(this.Reconnect, null, System.TimeSpan.Zero, this.PingInterval);
}
this._IsReconnection = true;
}
private static async System.Threading.Tasks.Task Prototype201803072_1()
{
// todo We need exception handling here.
{
double dateTimeFrequencyToPhaseFrequencyRatio =
(double)System.TimeSpan.TicksPerSecond / (double)System.Diagnostics.Stopwatch.Frequency;
long basePhase = System.Diagnostics.Stopwatch.GetTimestamp();
long baseUtcDateTimeInTicks = System.DateTime.UtcNow.Ticks;
basePhase = System.Diagnostics.Stopwatch.GetTimestamp();
baseUtcDateTimeInTicks = System.DateTime.UtcNow.Ticks;
var clientWebSocket = new System.Net.WebSockets.ClientWebSocket();
await
clientWebSocket.ConnectAsync
(new System.Uri
(@"wss://testnet.bitmex.com/realtime"),
//(@"wss://bitmex.com/realtime"),
System.Threading.CancellationToken.None
);
// todo ??? The caller really should do this if needed.
// todo ??? But any method really should do this
// todo ??? if after {await} it's not supposed to return to the synchronization context.
//// todo Comment in other places where we don't call this.
//.ConfigureAwait(false);
if (clientWebSocket.State == System.Net.WebSockets.WebSocketState.Open)
{
{
const string message = @"GET/realtime";
string nonceAsString = (++Nonce_).ToString();
// todo Use ASCII encoding everywhere.
byte[] signatureBytes =
hmacsha256
(System.Text.Encoding.UTF8.GetBytes(ApiKeySecret_),
System.Text.Encoding.UTF8.GetBytes(message + nonceAsString)
);
string signatureString = ByteArrayToString(signatureBytes);
/*const*/ string requestString =
"{" +
"\"op\":\"authKey\"," +
"\"args\":[\"" + ApiKeyId_ + "\"," + nonceAsString + ",\"" + signatureString + "\"]" +
"}";
byte[] requestBytes = System.Text.Encoding.ASCII.GetBytes(requestString);
await clientWebSocket.SendAsync
(new System.ArraySegment <byte>(requestBytes),
System.Net.WebSockets.WebSocketMessageType.Text,
true,
System.Threading.CancellationToken.None
);
}
if (clientWebSocket.State == System.Net.WebSockets.WebSocketState.Open)
{
{
const string subscriptionTopicName =
//@"quote:XBTUSD";
//@"trade:XBTUSD";
//@"orderBookL2:XBTUSD";
//@"instrument:XBTUSD";
//@"instrument";
//@"liquidation";
//@"quoteBin1m:XBTUSD";
@"order";
const string requestString =
"{" +
"\"op\":\"subscribe\"," +
"\"args\":[\"" + subscriptionTopicName + "\"]" +
"}";
byte[] requestBytes = System.Text.Encoding.ASCII.GetBytes(requestString);
await clientWebSocket.SendAsync
(new System.ArraySegment <byte>(requestBytes),
// todo ??? For GDAX binary didn't work, right?
System.Net.WebSockets.WebSocketMessageType.Text,
//System.Net.WebSockets.WebSocketMessageType.Binary,
true,
System.Threading.CancellationToken.None
);
}
// todo For GDAX this really doesn't need to be more than 16K, right?
var receiveBuffer = new System.ArraySegment <byte>(new byte[33 * 1024]);
for (bool isMessageBegin = true; ;)
{
if (clientWebSocket.State != System.Net.WebSockets.WebSocketState.Open)
{
System.Console.WriteLine(@"201802085");
break;
}
else
{
}
System.Net.WebSockets.WebSocketReceiveResult webSocketReceiveResult =
await clientWebSocket.ReceiveAsync(receiveBuffer, System.Threading.CancellationToken.None);
// todo Is this correct?
// todo Are these conditions equivalent?
if (webSocketReceiveResult.CloseStatus.HasValue || webSocketReceiveResult.Count <= 0)
{
System.Console.WriteLine(@"201802086");
break;
}
else
{
}
if (isMessageBegin)
{
isMessageBegin = false;
System.Console.WriteLine(',');
//System.Console.WriteLine();
long currentUtcDateTimeInTicks =
(long)((double)(ulong)(System.Diagnostics.Stopwatch.GetTimestamp() - basePhase) * dateTimeFrequencyToPhaseFrequencyRatio + 0.5) +
baseUtcDateTimeInTicks;
System.Console.Write
((new System.DateTime(currentUtcDateTimeInTicks)).ToString(@"o", System.Globalization.DateTimeFormatInfo.InvariantInfo));
}
else
{
}
// todo Preserve decoding state between decoding chunks.
string string1 =
System.Text.Encoding.ASCII.GetString(receiveBuffer.Array, 0, webSocketReceiveResult.Count);
System.Console.Write(string1);
if (webSocketReceiveResult.MessageType == System.Net.WebSockets.WebSocketMessageType.Close)
{
System.Console.WriteLine(@"201802087");
break;
}
else
{
}
if (webSocketReceiveResult.EndOfMessage)
{
isMessageBegin = true;
//break;
}
else
{
}
}
}
else
{
System.Console.WriteLine(@"201802088");
}
}
else
{
System.Console.WriteLine(@"201804021");
}
// todo ??? WebSocketState >= CloseSent
clientWebSocket.Dispose();
}
StaticBool1_ = true;
}
