public ChatHandler(RichTextBox messageList, RichTextBox roomMessageList)
{
this.messageList = messageList;
this.roomMessageList = roomMessageList;
websocket = new WebSocket("ws://" + ClientBase.serverAdress + PORT_ROUTE);
websocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(receiveChat);
websocket.Open();
}
public MainWindow()
{
InitializeComponent();
if (serverURL == "")
{
textBox1.Text = "[エラー]";
textBox2.Text = "[エラー]\n";
textBox2.Text += " サーバのURLを講義担当者から聞いてserverURL変数にセットしてください\n";
}
else
{
websocket = new WebSocket(serverURL);
websocket.Closed += new EventHandler(websocket_Closed);
websocket.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(websocket_Error);
websocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(websocket_MessageReceived);
websocket.Opened += new EventHandler(websocket_Opened);
textBox2.Text += "[使い方]\n";
textBox2.Text += " 上のテキストボックスに入力しenterか送信ボタンでサーバへ送信されます。\n";
textBox2.Text += " サーバは得たデータの先頭に'Server said'と付けて、そのまま返します。\n";
textBox2.Text += " サーバから帰って来た文字列がこのテキストボックスに表示されます。\n";
textBox2.Text += " 発言の先頭に「all:」を付けて送信すると、サーバに接続している全員に送られます。\n";
textBox2.Text += "[init]\n";
textBox1.Focus();
websocket.Open();
}
}
public void FetchConnections()
{
if (!_isConnected)
throw new Exception("Not connected");
_socket = new WebSocket("wss://www.irccloud.com/", "", _cookies, null, "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)", "https://www.irccloud.com");
_socket.MessageReceived += socket_MessageReceived;
_socket.Open();
}
public void Start()
{
if (_ws != null) return;
string wsUrl;
if (!string.IsNullOrEmpty(_symbol))
{
wsUrl = string.Format("wss://www.stockfighter.io/ob/api/ws/{0}/venues/{1}/tickertape/stocks/{2}", _account, _venue, _symbol);
}
else
{
wsUrl = string.Format("wss://www.stockfighter.io/ob/api/ws/{0}/venues/{1}/tickertape", _account, _venue);
}
_ws = new WebSocket(wsUrl);
_ws.MessageReceived += MessageReceived;
_ws.Opened += (s, e) => { if (Started != null) Started(this, EventArgs.Empty); };
_ws.Error += (s, e) => { if (ErrorOccured != null) ErrorOccured(this, e.Exception.Message); };
_ws.Closed += (s, e) =>
{
if (Stopped != null) Stopped(this, EventArgs.Empty);
if (_reconnect) _ws.Open();
};
_ws.Open();
}
private void Init()
{
Task.Run(async() =>
{
string msg = string.Empty;
while (true)
{
if (websocket.State == WebSocketState.Open && _waitForSendMsg.TryDequeue(out msg))
{
try
{
websocket.Send(msg);
}
catch (Exception e)
{
Info("send log err " + e.Message);
}
}
else if (websocket.State != WebSocketState.Connecting && websocket.State != WebSocketState.Open)
{
try
{
websocket.Open();
}
catch (Exception e)
{
Info("open log err " + e.Message);
}
}
await Task.Delay(10);
}
});
}
public static WebSocketDisposable ReserveConnection(string uri)
{
Tuple<WebSocket, RefCountDisposable> connection;
lock(openConnectionsLock)
{
if(!openConnections.TryGetValue(uri, out connection))
{
Debug.WriteLine("Creating new websocket");
WebSocket ws = new WebSocket(uri);
// Set callbacks?
ws.Open();
var dispose = Disposable.Create(() =>
{
Debug.WriteLine("Disposing of websocket");
ws.Close();
openConnections.Remove(uri);
});
RefCountDisposable refCount = new RefCountDisposable(dispose);
connection = Tuple.Create(ws, refCount);
openConnections.Add(uri, connection);
return new WebSocketDisposable(connection.Item1, connection.Item2.GetDisposable());
}
}
Debug.WriteLine("Returning old websocket");
return new WebSocketDisposable(connection.Item1, connection.Item2.GetDisposable());
}
protected override void DoOpen()
{
var log = LogManager.GetLogger(Global.CallerName());
log.Info("DoOpen uri =" + this.Uri());
ws = new WebSocket4Net.WebSocket(this.Uri(), "", Cookies, MyExtraHeaders);
ws.EnableAutoSendPing = false;
if (ServerCertificate.Ignore)
{
var security = ws.Security;
if (security != null)
{
security.AllowUnstrustedCertificate = true;
security.AllowNameMismatchCertificate = true;
}
}
ws.Opened += ws_Opened;
ws.Closed += ws_Closed;
ws.MessageReceived += ws_MessageReceived;
ws.DataReceived += ws_DataReceived;
ws.Error += ws_Error;
ws.Open();
}
public async void Start(int port, string uri)
{
var localIP = ProductConfiguration.LocalIP;
var server = new WebSocketServer($"wss://{localIP}:{port}");
client = new WebSocket4Net.WebSocket(uri, version: WebSocketVersion.Rfc6455);
server.Certificate = new X509Certificate2(Resources.RedoCert, "CyberAgent");
server.Start(socket =>
{
this.server = socket;
socket.OnOpen = () =>
{
server.ListenerSocket.Close();
client.AllowUnstrustedCertificate = true;
client.DataReceived += (sender, e) =>
RecvHandle?.Invoke(new ByteArray(e.Data));
client.Closed += (sender, e) => socket.Close();
client.Open();
};
socket.OnBinary = data =>
SendHandle?.Invoke(new ByteArray(data));
socket.OnClose = client.Close;
});
await Task.Delay(60 * 1000);
server.ListenerSocket.Close();
}
public void send(pushermodel mdl)
{
//var uri = string.Format("ws://{0}:{1}/", ip, port);
//List<pushermodel> mm = new List<pushermodel>();
List <pushermodel> mds = new List <pushermodel>();
mds.Add(mdl);
_client.NoDelay = true;
if (_client.State != WebSocketState.Open)
{
if (_client.State != WebSocketState.Connecting)
{
_client.Open();
}
}
_client.Opened += (sender2, e2) => websocket_Opened(sender2, e2, mds);
//_client.EnableAutoSendPing = true;
//_client.AutoSendPingInterval = 3;
//_client.Send("mantap");
}
private void Init()
{
Task.Run(async() =>
{
while (true)
{
if (websocket.State == WebSocketState.Open && MsgQueue.TryDequeue(out string msg))
{
try
{
websocket.Send(msg);
}
catch (Exception e)
{
LogFactory.Create().Info("send log err " + e.Message);
}
}
else if (websocket.State != WebSocketState.Connecting && websocket.State != WebSocketState.Open)
{
try
{
websocket.Open();
}
catch (Exception e)
{
LogFactory.Create().Info("open log err " + e.Message);
}
}
await Task.Delay(10);
}
});
}
public void Connect()
{
String url;
if (String.IsNullOrEmpty(Port) ||
String.IsNullOrEmpty(Domain))
return;
url = String.Format("ws://{0}:{1}{2}", Domain, Port, Path);
try
{
socket = new WebSocket(
url,
"",
Cookies,
null,
null,
"http://" + Domain,
WebSocketVersion.DraftHybi10
);
socket.Opened += new EventHandler(socket_Opened);
socket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(socket_MessageReceived);
socket.Closed += new EventHandler(socket_Closed);
socket.Open();
}
catch (Exception e)
{
Debug.Print(String.Format("Websocket connection failed. {0} {1}", url, e.Message));
}
}
public void PingPong()
{
using (NetMQContext context = NetMQContext.Create())
{
using (WebSocket4Net.WebSocket webSocket = new WebSocket("ws://localhost:82", "WSNetMQ"))
{
webSocket.EnableAutoSendPing = true;
webSocket.AutoSendPingInterval = 1; // one second
using (WSRouter router = context.CreateWSRouter())
{
router.Bind("ws://localhost:82");
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
webSocket.Opened += (sender, args) => manualResetEvent.Set();
webSocket.Open();
webSocket.Error += (sender, args) => Console.WriteLine("Error");
manualResetEvent.WaitOne();
Thread.Sleep(5000);
Assert.AreEqual(webSocket.State, WebSocketState.Open);
}
}
}
}
public MainWindow()
{
InitializeComponent();
if (serverURL == "")
{
textBox1.Text = "URL不明！";
}
else
{
textBox1.Text = channel;
websocket = new WebSocket(serverURL);
websocket.Closed += new EventHandler(websocket_Closed);
websocket.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(websocket_Error);
websocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(websocket_MessageReceived);
websocket.Opened += new EventHandler(websocket_Opened);
websocket.Open();
InitializeComponent(); // aaa
//Kinectの初期化
kinect = KinectSensor.KinectSensors[0];
//イベントハンドラの登録
kinect.SkeletonFrameReady += new EventHandler<SkeletonFrameReadyEventArgs>(handler_SkeletonFrameReady);
//骨格トラッキングの有効化
kinect.SkeletonStream.Enable();
kinect.Start(); // aaa
}
}
//Object syncLock = new Object();
public OnlineUserHandler(ListView onlineUserList)
{
this.onlineUserList = onlineUserList;
websocket = new WebSocket("ws://" + ClientBase.serverAdress + PORT_ROUTE);
websocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(handleOnlineUsers);
websocket.Open();
}
private void button1_Click(object sender, EventArgs e)
{
if (webSocket.State == WebSocketState.Open)
{
MessageBox.Show("连接成功");
return;
}
if (webSocket.State != WebSocketState.Open)
{
webSocket.Open();
if (OpenedEvent.WaitOne(2000))
{
if (webSocket.State == WebSocketState.Open)
{
MessageBox.Show("连接成功");
return;
}
else
{
MessageBox.Show("连接失败");
return;
}
}
}
MessageBox.Show("连接成功");
}
public Task ConnectAsync(string url)
{
var taskCompletionSource = new TaskCompletionSource <bool>();
try
{
_socket = new WebSocket4Net.WebSocket(url);
_socket.MessageReceived += WebsocketMessageReceived;
_socket.Opened += (sender, args) =>
{
Connected?.Invoke(this, EventArgs.Empty);
taskCompletionSource.TrySetResult(true);
};
_socket.Closed += SocketClosed;
_socket.Open();
}
catch (Exception ex)
{
_socket = null;
taskCompletionSource.TrySetException(ex);
}
return(taskCompletionSource.Task);
}
private async Task ConnectInternalAsync(string host)
{
await DisconnectInternalAsync().ConfigureAwait(false);
_disconnectCancelTokenSource?.Dispose();
_cancelTokenSource?.Dispose();
_client?.Dispose();
_disconnectCancelTokenSource = new CancellationTokenSource();
_cancelTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_parentToken, _disconnectCancelTokenSource.Token);
_cancelToken = _cancelTokenSource.Token;
_client = new WS4NetSocket(host, "", customHeaderItems: _headers.ToList())
{
EnableAutoSendPing = false,
NoDelay = true,
Proxy = null
};
_client.MessageReceived += OnTextMessage;
_client.DataReceived += OnBinaryMessage;
_client.Opened += OnConnected;
_client.Closed += OnClosed;
_client.Open();
_waitUntilConnect.Wait(_cancelToken);
}
public void Connect(string url)
{
Uri uri = null;
string connectionId = Strings.RandomString(8);
int serverId = Strings.RandomNumber(1, 1000);
try
{
uri = new Uri(url);
}
catch (Exception)
{
throw new OrtcEmptyFieldException(String.Format("Invalid URL: {0}", url));
}
string prefix = uri != null && "https".Equals(uri.Scheme) ? "wss" : "ws";
Uri connectionUrl = new Uri(String.Format("{0}://{1}:{2}/broadcast/{3}/{4}/websocket", prefix, uri.DnsSafeHost, uri.Port, serverId, connectionId));
//
// NOTE: For wss connections, must have a valid installed certificate
// See: http://www.runcode.us/q/c-iphone-push-server
//
_websocket = new WebSocket(connectionUrl.AbsoluteUri);
_websocket.Opened += new EventHandler(websocket_Opened);
_websocket.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(websocket_Error);
_websocket.Closed += new EventHandler(websocket_Closed);
_websocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(websocket_MessageReceived);
_websocket.Open();
}
public void ReConnect(string symbol, dynamic form, string timeFrame)
{
IsSocketOpened = false;
list = new List <MapSymbolChart>();
webSocket = new WebSocket4Net.WebSocket(host);
webSocket.Open();
webSocket.Opened += WebSocket_Opened;
webSocket.Closed += WebSocket_Closed;
webSocket.Error += WebSocket_Error;
webSocket.MessageReceived += WebSocket_MessageReceived;
while (!IsSocketOpened)
{
}
foreach (var item in listForms)
{
form.candleData = new BindingList <CandleData>();
if (item.form == form)
{
SendSymbol(symbol, timeFrame);
item.timeFrame = timeFrame;
item.symbol = symbol;
}
else
{
SendSymbol(item.symbol, item.timeFrame);
}
}
}
public void Start(List <ProductType> productTypes, List <ChannelType> channelTypes = null)
{
if (WebSocketFeed != null && WebSocketFeed.State != WebSocketState.Closed)
{
throw new GDAXSharpHttpException(
$"Websocket needs to be in the closed state, current state is {WebSocketFeed.State}");
}
if (productTypes.Count == 0)
{
throw new ArgumentException("You must specify at least one product type");
}
StopWebSocket = false;
ProductTypes = productTypes;
ChannelTypes = channelTypes;
var socketUrl = SandBox
? SandBoxApiUri
: ApiUri;
WebSocketFeed = new WebSocket4Net.WebSocket(socketUrl);
WebSocketFeed.Closed += WebSocket_Closed;
WebSocketFeed.Error += WebSocket_Error;
WebSocketFeed.MessageReceived += WebSocket_MessageReceived;
WebSocketFeed.Opened += WebSocket_Opened;
WebSocketFeed.Open();
}
public Task Connect(string host, CancellationToken cancelToken)
{
try
{
_webSocket = new WebSocketClient(host);
_webSocket.EnableAutoSendPing = false;
_webSocket.NoDelay = true;
_webSocket.Proxy = null;
_webSocket.DataReceived += OnWebSocketBinary;
_webSocket.MessageReceived += OnWebSocketText;
_webSocket.Error += OnWebSocketError;
_webSocket.Closed += OnWebSocketClosed;
_webSocket.Opened += OnWebSocketOpened;
_waitUntilConnect.Reset();
_waitUntilDisconnect.Reset();
_webSocket.Open();
_waitUntilConnect.Wait(cancelToken);
_taskManager.ThrowException(); //In case our connection failed
}
catch
{
_waitUntilDisconnect.Set();
throw;
}
return(TaskHelper.CompletedTask);
}
public Task Connect(string host, CancellationToken cancelToken)
{
try
{
_webSocket = new WebSocketClient(host);
_webSocket.EnableAutoSendPing = false;
_webSocket.NoDelay = true;
_webSocket.Proxy = null;
_webSocket.DataReceived += OnWebSocketBinary;
_webSocket.MessageReceived += OnWebSocketText;
_webSocket.Error += OnWebSocketError;
_webSocket.Closed += OnWebSocketClosed;
_webSocket.Opened += OnWebSocketOpened;
_waitUntilConnect.Reset();
_waitUntilDisconnect.Reset();
_webSocket.Open();
_waitUntilConnect.Wait(cancelToken);
_taskManager.ThrowException(); //In case our connection failed
}
catch
{
_waitUntilDisconnect.Set();
throw;
}
return TaskHelper.CompletedTask;
}
public void connection()
{
_socket = new WebSocket4Net.WebSocket("ws://10.0.3.2:9898");
_socket.Opened += OnConnectionOpen;
_socket.MessageReceived += OnMessage;
_socket.Open();
}
public void Connect(string url)
{
session_.Settings.ConnectionURI = url;
if (!url.Contains("ws://"))
url = "ws://" + url;
if (socket_ != null) {
if (session_ != null)
session_.IsConnected = false;
socket_.Close();
socket_ = null;
}
if (socket_ == null) {
session_.Log.Add(new LogMessage {
MsgType = MessageType.Info,
Message = "Attempting to connect"
});
string res = new Uri(url).AbsoluteUri;
socket_ = new WebSocket(res);
socket_.EnableAutoSendPing = true;
socket_.AutoSendPingInterval = 50;
socket_.Opened += _Opened;
socket_.Closed += _Closed;
socket_.MessageReceived += _ReceiveMsg;
socket_.DataReceived += _ReceiveData;
socket_.Error += _Error;
socket_.Open();
}
}
public Task ConnectAsync(CancellationToken cancellationToken)
{
var channelOptions = (MqttClientWebSocketOptions)_clientOptions.ChannelOptions;
var uri = "ws://" + channelOptions.Uri;
var sslProtocols = SslProtocols.None;
if (channelOptions.TlsOptions.UseTls)
{
uri = "wss://" + channelOptions.Uri;
#if NETCOREAPP3_0 || NET5_0
sslProtocols = SslProtocols.Tls13;
#else
sslProtocols = SslProtocols.Tls12;
#endif
}
var subProtocol = channelOptions.SubProtocols.FirstOrDefault() ?? string.Empty;
_webSocket = new WebSocket4Net.WebSocket(uri, subProtocol, sslProtocols: sslProtocols);
_webSocket.DataReceived += OnDataReceived;
_webSocket.Open();
SpinWait.SpinUntil(() => _webSocket.State == WebSocketState.Open, _clientOptions.CommunicationTimeout);
return(Task.FromResult(0));
}
void Connect(int times=3)
{
if (times > 0)
{
try
{
_socketInstance = new WebSocket(_serverAddress);
_socketInstance.Opened += _socketInstance_Opened;
_socketInstance.Closed += _socketInstance_Closed;
_socketInstance.DataReceived += _socketInstance_DataReceived;
_socketInstance.Error += _socketInstance_Error;
_socketInstance.Open();
}
catch (System.Exception e)
{
_dispatcher.LogException(e);
_dispatcher.LogWarning("Connect Failed! Try again 3 seconds later!");
Connect(times - 1);
}
}
else
{
_dispatcher.Quit();
}
}
//
// Excel calls this. It's an entry point. It passes us a callback
// structure which we save for later.
//
int IRtdServer.ServerStart(IRtdUpdateEvent callback)
{
_callback = callback;
//
// We will throttle out updates so that Excel can keep up.
// It is also important to invoke the Excel callback notify
// function from the COM thread. System.Windows.Threading'
// DispatcherTimer will use COM thread's message pump.
//
_timer = new DispatcherTimer();
_timer.Interval = TimeSpan.FromSeconds(0.5);
_timer.Tick += TimerElapsed;
_timer.Start();
_socket.Open();
_socket.Opened += (s, e) =>
{
dynamic j = new JObject();
j.type = "subscribe";
j.channels = new JArray("heartbeat");
j.product_ids = new JArray("BTC-USD");
_socket.Send(j.ToString());
};
_socket.MessageReceived += OnWebSocketMessageReceived;
return(1);
}
static void Main(string[] args)
{
m_WebSockets = new WebSocket[1000];
var autoEventReset = new AutoResetEvent(false);
for(var i = 0; i < m_WebSockets.Length; i++)
{
var websocket = new WebSocket("ws://localhost:2011/");
websocket.Opened += (s, e) =>
{
autoEventReset.Set();
};
websocket.Error += (s, e) =>
{
Console.WriteLine(e.Exception.Message);
autoEventReset.Set();
};
websocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(websocket_MessageReceived);
websocket.Open();
autoEventReset.WaitOne();
m_WebSockets[i] = websocket;
Console.WriteLine(i);
}
Console.WriteLine("All connected");
Console.ReadLine();
}
public MainWindow()
{
InitializeComponent();
if (serverURL == "")
{
textBox1.Text = "URL不明！";
}
else
{
textBox1.Text = channel;
websocket = new WebSocket(serverURL);
websocket.Closed += new EventHandler(websocket_Closed);
websocket.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(websocket_Error);
websocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(websocket_MessageReceived);
websocket.Opened += new EventHandler(websocket_Opened);
websocket.Open();
drumset = new Drumset();
drumset.SetElements(
new CircleTarget("RideCymbal", new Position3D(0.4, 0.3, 2.0), 0.3),
new CircleTarget("HiHat", new Position3D(-0.7, 0.1, 2.4), 0.3),
new CircleTarget("Drum1", new Position3D(-0.2, 0.0, 2.2), 0.3),
new CircleTarget("Drum2", new Position3D(0.5, 0.1, 2.6), 0.3)
);
System.Console.WriteLine("Loaded");
foreach (var potentialSensor in KinectSensor.KinectSensors)
{
if (potentialSensor.Status == KinectStatus.Connected)
{
this.sensor = potentialSensor;
break;
}
}
if (null != this.sensor)
{
// Turn on the skeleton stream to receive skeleton frames
this.sensor.SkeletonStream.Enable();
// Add an event handler to be called whenever there is new color frame data
this.sensor.SkeletonFrameReady += this.SensorSkeletonFrameReady;
// Start the sensor!
try
{
this.sensor.Start();
}
catch (IOException)
{
this.sensor = null;
}
}
this.sensor.SkeletonStream.TrackingMode = SkeletonTrackingMode.Seated;
}
}
/// <summary>
/// Connects.
/// </summary>
/// <param name="url">The URL.</param>
public void Connect(string url)
{
_socket = new WebSocket4Net.WebSocket(url);
_socket.MessageReceived += websocket_MessageReceived;
_socket.Open();
}
public void CreateWebSocket(String url)
{
ws = new WebSocket(url);
ws.Opened += (sender, args) => Console.WriteLine("Opened..." + sender.ToString() + "," + args.ToString());
ws.Closed += (sender, args) => Console.WriteLine("Closed..." + sender.ToString() + "," + args.ToString());
ws.MessageReceived += WsOnMessageReceived;
ws.Open();
}
/// <summary>
/// Connects the async.
/// </summary>
/// <param name="url">The URL.</param>
public void Connect(string url)
{
_socket = new WebSocket4Net.WebSocket(url);
_socket.MessageReceived += websocket_MessageReceived;
_socket.Open();
}
protected override void OnStart(string[] args)
{
websocket.Open();
HelperLog.Info("Start");
OpenPort();
HelperLog.Info("OPen");
//this.timer_inv.Enabled = true;
}
private DataServerClient()
{
websocket = new WebSocket4Net.WebSocket(ConfigurationManager.AppSettings["WebSocketUri"].ToString());
websocket.Opened += new EventHandler(websocket_Opened);
websocket.Error += new EventHandler <ErrorEventArgs>(websocket_Error);
websocket.Closed += new EventHandler(websocket_Closed);
websocket.MessageReceived += Websocket_MessageReceived;
websocket.Open();
}
private void connect_Click(object sender, EventArgs e)
{
websocket = new WebSocket("ws://114.80.136.56:20718/dataproxy");
websocket.Opened += new EventHandler(websocket_Opened);
websocket.Error += new EventHandler<ErrorEventArgs>(websocket_Error);
websocket.Closed += new EventHandler(websocket_Closed);
websocket.DataReceived += new EventHandler<DataReceivedEventArgs>(websocket_MessageReceived);
websocket.Open();
}
public void Open()
{
webSocketFeed.Open();
webSocketFeed.MessageReceived += MessageReceived;
webSocketFeed.Closed += Closed;
webSocketFeed.Error += Error;
webSocketFeed.Opened += Opened;
}
private void Form1_Load(object sender, EventArgs e)
{
websocket = new WebSocket("ws://127.0.0.1:8081");
websocket.Opened += new EventHandler(websocket_Opened);
websocket.Error += new EventHandler <SuperSocket.ClientEngine.ErrorEventArgs>(websocket_Error);
websocket.Closed += new EventHandler(websocket_Closed);
websocket.MessageReceived += new EventHandler <MessageReceivedEventArgs>(websocket_MessageReceived);
websocket.Open();
}
public static void onDLL()
{
websocket = new WebSocket("ws://localhost:9998/");//ubuntu ifconfig
websocket.Opened += new EventHandler(websocket_Opened);
/* websocket.Error += new EventHandler<ErrorEventArgs>(websocket_Error);
websocket.Closed += new EventHandler(websocket_Closed);
websocket.MessageReceived += new EventHandler(websocket_MessageReceived);*/
websocket.Open();
}
// private constructor.
private BitfinexSocket()
{
webSocket = new WebSocket4Net.WebSocket(host);
webSocket.Open();
webSocket.Opened += WebSocket_Opened;
webSocket.Closed += WebSocket_Closed;
webSocket.Error += WebSocket_Error;
webSocket.MessageReceived += WebSocket_MessageReceived;
}
public Connector(string uri)
{
_Host = uri;
// Socket = new JsonWebSocket(Host);
// Socket.On<JsonObject>("Answer", (e) => { handle(e,this); });
Socket = new WebSocket(Host);
Socket.Open();
}
/// <summary>
/// Method to connect to Twitch's PubSub service. You MUST listen toOnConnected event and listen to a Topic within 15 seconds of connecting (or be disconnected)
/// </summary>
public void Connect()
{
socket = new WebSocket("wss://pubsub-edge.twitch.tv");
socket.Opened += OnOpen;
socket.Error += OnError;
socket.MessageReceived +=OnMessage;
socket.Closed +=OnClose;
socket.Open();
}
protected override void DoOpen()
{
var log = LogManager.GetLogger(Global.CallerName());
log.Info("DoOpen uri =" + this.Uri());
ws = new WebSocket4Net.WebSocket(this.Uri(), String.Empty, Cookies, MyExtraHeaders)
{
EnableAutoSendPing = false
};
if (ServerCertificate.Ignore)
{
var security = ws.Security;
if (security != null)
{
security.AllowUnstrustedCertificate = true;
security.AllowNameMismatchCertificate = true;
}
}
ws.Opened += ws_Opened;
ws.Closed += ws_Closed;
ws.MessageReceived += ws_MessageReceived;
ws.DataReceived += ws_DataReceived;
ws.Error += ws_Error;
var destUrl = new UriBuilder(this.Uri());
if (this.Secure)
{
destUrl.Scheme = "https";
}
else
{
destUrl.Scheme = "http";
}
// We don't want to overwrite a user defined proxy.
var hasNoUserDefinedProxy = Proxy == null;
if (hasNoUserDefinedProxy)
{
Proxy = WebRequest.DefaultWebProxy;
}
// The "Proxy" property could be null, in this case we'll let "IsBypassed" be true, so no proxy is used.
var useProxy = !(Proxy?.IsBypassed(destUrl.Uri) ?? true);
if (useProxy)
{
var proxyUrl = Proxy.GetProxy(destUrl.Uri);
var proxy = new HttpConnectProxy(new DnsEndPoint(proxyUrl.Host, proxyUrl.Port), destUrl.Host);
ws.Proxy = proxy;
}
ws.Open();
}
public void Init()
{
websocket = new WebSocket("ws://localhost:2012/");
websocket.Opened += new EventHandler(websocket_Opened);
websocket.Error += new EventHandler <ErrorEventArgs>(websocket_Error);
websocket.Closed += new EventHandler(websocket_Closed);
websocket.MessageReceived += new EventHandler <MessageReceivedEventArgs>(websocket_MessageReceived);
websocket.Open();
}
public AuthenticationHandler(User user)
{
this.user = user;
webSocket = new WebSocket("ws://" + ClientBase.serverAdress + PORT_ROUTE);
webSocket.Opened += new EventHandler(authenticate);
//webSocket.Closed += new EventHandler(websocket_Closed);
webSocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(receiveThisUserObject);
webSocket.Open();
}
public void Execute()
{
_socket = new WebSocket4Net.WebSocket(Url);
_socket.Opened += OnConnected;
_socket.Error += OnError;
_socket.Closed += OnClosed;
_socket.MessageReceived += OnMessage;
_socket.Open();
}
/// <summary>
/// Return a connected <see cref="WebSocket"/>.
/// </summary>
/// <param name="uri">
/// The uri to connect the result to.
/// </param>
/// <returns>
/// A connected <see cref="WebSocket"/>.
/// </returns>
private static async Task <WebSocket4Net.WebSocket> ConnectSocket(Uri uri)
{
var socket = new WebSocket4Net.WebSocket(uri.ToString());
var opened = Observable.FromEventPattern(_ => socket.Opened += _, _ => socket.Opened -= _);
socket.Open();
await opened.ToTask();
return(socket);
}
public void Connect(string url)
{
_url = "ws://" + url + "/websocket";
_socket = new WebSocket(_url);
_socket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(socket_MessageReceived);
_socket.Opened += new EventHandler(_socket_Opened);
_socket.Open();
_isWait = 1;
this.Wait();
}
static void websocket_Error(object sender, SuperSocket.ClientEngine.ErrorEventArgs e)
{
websocket = null;
websocket = new WebSocket("ws://www.palmmud.com:8080");
websocket.Opened += new EventHandler(websocket_Opened);
websocket.Error += new EventHandler <SuperSocket.ClientEngine.ErrorEventArgs>(websocket_Error);
websocket.Closed += new EventHandler(websocket_Closed);
websocket.MessageReceived += new EventHandler <MessageReceivedEventArgs>(websocket_MessageReceived);
websocket.Open();
}
/// <summary>
/// 连接 url，向服务器端发消息
/// </summary>
/// <param name="wsOrWssUrl">ws或wss地址</param>
/// <param name="data">要发送的字符串</param>
public void SendMsg2(string wsOrWssUrl, string data)
{
this.data = data;
websocket = new WebSocket4Net.WebSocket(wsOrWssUrl);
websocket.Opened += websocket_Opened;
websocket.Closed += websocket_Closed;
websocket.Error += Websocket_Error;
websocket.MessageReceived += websocket_MessageReceived;
websocket.Open();
}
public void Connect(string address)
{
_websocket = new WebSocket(address);
_websocket.Opened += websocket_Opened;
_websocket.Error += websocket_Error;
_websocket.Closed += websocket_Closed;
_websocket.MessageReceived += websocket_MessageReceived;
_websocket.Open();
}
private void Open()
{
Lock(
() =>
{
if (socket.State != WebSocket4Net.WebSocketState.Connecting)
{
socket.Open();
}
});
}
/// <summary>
/// Connects the async.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public Task ConnectAsync(string url, CancellationToken cancellationToken)
{
return Task.Run(() =>
{
_socket = new WebSocket4Net.WebSocket(url);
_socket.MessageReceived += websocket_MessageReceived;
_socket.Open();
});
}
private string SendCommand(string sessionWSEndpoint, string cmd)
{
WebSocket4Net.WebSocket j = new WebSocket4Net.WebSocket(sessionWSEndpoint);
ManualResetEvent waitEvent = new ManualResetEvent(false);
ManualResetEvent closedEvent = new ManualResetEvent(false);
string message = "";
byte[] data;
Exception exc = null;
j.Opened += delegate(System.Object o, EventArgs e)
{
j.Send(cmd);
};
j.MessageReceived += delegate(System.Object o, MessageReceivedEventArgs e)
{
message = e.Message;
waitEvent.Set();
};
j.Error += delegate(System.Object o, SuperSocket.ClientEngine.ErrorEventArgs e)
{
exc = e.Exception;
waitEvent.Set();
};
j.Closed += delegate(System.Object o, EventArgs e)
{
closedEvent.Set();
};
j.DataReceived += delegate(System.Object o, DataReceivedEventArgs e)
{
data = e.Data;
waitEvent.Set();
};
j.Open();
waitEvent.WaitOne();
if (j.State == WebSocket4Net.WebSocketState.Open)
{
j.Close();
closedEvent.WaitOne();
}
if (exc != null)
{
throw exc;
}
return(message);
}
public static void Connect()
{
if (Socket != null && Socket.State == WebSocketState.Open) Socket.Close();
Connected = false;
Socket = new WebSocket(Endpoints.PushAddress);
Socket.Opened += OnOpen;
Socket.MessageReceived += MessageReceived;
Socket.Closed += (sender, args) => { if (LostConnection != null) LostConnection(); };
Socket.Open();
Connected = true;
}
public ChessWebWebSocketComm(string uri)
{
this.uri = uri;
webSocket = new WebSocket(uri);
webSocket.Opened += WebSocket_Opened;
webSocket.MessageReceived += WebSocket_MessageReceived;
webSocket.Closed += WebSocket_Closed;
webSocket.Open();
}
static void Test1()
{
ws = new WebSocket("ws://192.168.2.23/api/Default");
ws.Error += ws_Error;
ws.Closed += ws_Closed;
ws.DataReceived += ws_DataReceived;
ws.MessageReceived += ws_MessageReceived;
ws.Opened += ws_Opened;
ws.Open();
}
public void Connect(string url, bool keepAlive = true)
{
_keepAlive = keepAlive;
_url = "ws://" + url + "/websocket";
_socket = new WebSocket(_url);
_socket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(_socket_MessageReceived);
_socket.Opened += new EventHandler(_socket_Opened);
_socket.Open();
_isWait = 1;
this._wait();
}
/// <summary>
/// Connects the async.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public Task ConnectAsync(string url, CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
_socket = new WebSocket4Net.WebSocket(url);
_socket.MessageReceived += websocket_MessageReceived;
_socket.Open();
}));
}
public NetLog()
{
_localIp = Utility.Common.GetLocalIpex();
websocket = new WebSocket($"ws://{Config.SERVER_ADDR}:{Config.LOG_PORT}/");
websocket.Opened += websocket_Opened;
websocket.Error += Websocket_Error;
websocket.Closed += Websocket_Closed;
websocket.MessageReceived += Websocket_MessageReceived;
websocket.Open();
Init();
}
public void connect(string ip, int port)
{
if (connection != null)
disconnect();
string wsUri = "ws://" + ip + ":" + port.ToString();
connection = new WebSocket(wsUri);
//connection.Opened += Connection_Opened;
//connection.Closed += Connection_Closed;
// connection.Error += Connection_Error;
connection.MessageReceived += Connection_MessageReceived;
connection.Open();
}
