Utilisation de WebSockets avec l'API Web ASP.NET

Quelle est la méthode préférée pour l'aide de matières websockets dans un ASP.NET application d'API Web?

Nous aimerions utiliser binaire WebSockets sur un couple de nos interfaces de nos ASP.NET l'API Web de l'application. Je vais avoir un moment difficile de déterminer comment cela doit être fait comme il semble y avoir plusieurs contradictoires et/ou périmés implémentations en ligne pour .NET.

Il y a des exemples qui semblent être ASP.NET comme ce unmais je pense il doit y avoir un moyen d'utiliser les websockets dans le cadre de l'API Web. Comme je sais que vous pouvez utiliser Signalr dans WebAPI.

Je pensée à l'aide de Microsoft.AspNet.SignalR.Les WebSockets.WebSocketHandler pourrait fonctionner, mais je ne suis pas sûr de la façon de lier le WebSocketHandler au Contrôleur...

class MyServiceController : ApiController
{
    [HttpGet]
    public HttpResponseMessage SwitchProtocols (string param)
    {
        HttpContext currentContext = HttpContext.Current;
        if (currentContext.IsWebSocketRequest || 
            currentContext.IsWebSocketRequestUpgrading)
        {
            //several out-dated(?) examples would 
            //use 'new MySocketHandler' for ???
            var unknown = new ????
            currentContext.AcceptWebSocketRequest(unknown); 
            return Request.CreateResponse(HttpStatusCode.SwitchingProtocols);
        }   
    }
}

class MySocketHandler : WebSocketHandler
{
    public MySocketHandler(): base(2048){}

    ...
}

Malheureusement, AcceptWebSocketRequest n'accepte plus que les WebSocketHandler, au lieu de sa nouvelle signature est...

public void AcceptWebSocketRequest(Func<AspNetWebSocketContext, Task> userFunc)

Quelqu'un aurait un lien ou un échantillon rapide de mise en œuvre brute websockets dans ASP.NET l'API Web de l'application est à jour?

source d'informationauteur Tony

asp.net-mvc-4 asp.net-web-api c#signalr websocket

Mise à JOUR: Après une recherche un peu plus par moi-même et un collègue de travail, nous en sommes venus à la conclusion que la WebSocketHandler classe ne semble pas être destinés à être utilisés à l'extérieur des processus internes de SignalR. Comme il n'est pas évident de trouver un moyen de mettre à profit WebSocketHandler isolé à partir de SignalR. C'est malheureux, car je trouve ses interfaces légèrement plus haute que le niveau du Système.Web/Système.Net interfaces. En outre, la méthode décrite ci-dessous permet l'utilisation de HttpContext qui je croire doit être évitée.

En tant que tel, nous avons l'intention de prendre une approche similaire à celle présentée par Mrchief, mais avec un peu plus de l'API Web de saveur. C'est comme ça...(NOTE: notre socket est en écriture seule, mais j'ai découvert que vous DOIT effectuer les opérations de lecture si vous voulez WebSocket.L'etat pour obtenir mis à jour correctement.

class MyServiceController : ApiController
{
    public HttpResponseMessage Get (string param)
    {
        HttpContext currentContext = HttpContext.Current;
        if (currentContext.IsWebSocketRequest || 
            currentContext.IsWebSocketRequestUpgrading)
        {
            currentContext.AcceptWebSocketRequest(ProcessWebsocketSession); 
            return Request.CreateResponse(HttpStatusCode.SwitchingProtocols);
        }   
    }

    private async Task ProcessWebsocketSession(AspNetWebSocketContext context)
    {
        var ws = context.WebSocket;

        new Task(() =>
        {
            var inputSegment = new ArraySegment<byte>(new byte[1024]);

            while (true)
            {
                //MUST read if we want the state to get updated...
                var result = await ws.ReceiveAsync(inputSegment, CancellationToken.None);

                if (ws.State != WebSocketState.Open)
                {
                    break;
                }
            }
        }).Start();

        while (true)
        {
            if (ws.State != WebSocketState.Open)
            {
                break;
            }
            else
            {
                byte[] binaryData = { 0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe };
                var segment = new ArraySegment<byte>(binaryData);
                await ws.SendAsync(segment, WebSocketMessageType.Binary, 
                    true, CancellationToken.None);
            }
        }
    }
}

REMARQUE: Évidemment, la vérification des erreurs et l'utilisation correcte d'un CancellationToken est laissé comme exercice pour le lecteur.

C'est une vieille question, mais je voudrais ajouter une autre réponse à cette question.

Il s'avère, vous POUVEZ l'utiliser, et je n'ai aucune idée de pourquoi ils l'ont fait de manière "cachée". Ce serait bien si quelqu'un pourrait m'expliquer quel est le problème avec cette classe, ou si ce que je fais ici est en quelque sorte "interdit" ou "mauvais design".

Si nous regardons dans la Microsoft.Web.WebSockets.WebSocketHandlernous trouvons cette méthode publique:

[EditorBrowsable(EditorBrowsableState.Never)]
public Task ProcessWebSocketRequestAsync(AspNetWebSocketContext webSocketContext);

Cette méthode est caché intellisense, mais il est là, et peut être appelée sans erreurs de compilation.

Nous pouvons utiliser cette méthode pour obtenir la tâche que nous devons revenir dans la AcceptWebSocketRequest méthode. Check this out:

public class MyWebSocketHandler : WebSocketHandler
{
    private static WebSocketCollection clients = new WebSocketCollection();

    public override void OnOpen()
    {
        clients.Add(this);
    }

    public override void OnMessage(string message)
    {
        Send("Echo: " + message);
    }
}

Et puis dans mon API contrôleur:

public class MessagingController : ApiController
{
    public HttpResponseMessage Get()
    {
        var currentContext = HttpContext.Current;
        if (currentContext.IsWebSocketRequest ||
            currentContext.IsWebSocketRequestUpgrading)
        {
            currentContext.AcceptWebSocketRequest(ProcessWebsocketSession);
        }

        return Request.CreateResponse(HttpStatusCode.SwitchingProtocols);
    }

    private Task ProcessWebsocketSession(AspNetWebSocketContext context)
    {
        var handler = new MyWebSocketHandler();
        var processTask = handler.ProcessWebSocketRequestAsync(context);
        return processTask;
    }
}

Cela fonctionne tout à fait acceptable. OnMessage se déclenche, et revient en écho à mon JavaScript instancié WebSocket...

J'ai trouvé ce exemple:

Exemple de code (reproduit à partir de la poste):

public class WSHandler : IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        if (context.IsWebSocketRequest)
        {
            context.AcceptWebSocketRequest(ProcessWSChat);
        }
    }

    public bool IsReusable { get { return false; } }

    private async Task ProcessWSChat(AspNetWebSocketContext context)
    {
        WebSocket socket = context.WebSocket;
        while (true)
        {
            ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
            WebSocketReceiveResult result = await socket.ReceiveAsync(
                buffer, CancellationToken.None);
            if (socket.State == WebSocketState.Open)
            {
                string userMessage = Encoding.UTF8.GetString(
                    buffer.Array, 0, result.Count);
                userMessage = "You sent: " + userMessage + " at " + 
                    DateTime.Now.ToLongTimeString();
                buffer = new ArraySegment<byte>(
                    Encoding.UTF8.GetBytes(userMessage));
                await socket.SendAsync(
                    buffer, WebSocketMessageType.Text, true, CancellationToken.None);
            }
            else
            {
                break;
            }
        }
    }
}

Partage mon code sur la base de Tony réponse avec un nettoyant pour tâche de manutention. Ce code envoie de l'heure UTC actuelle environ chaque seconde:

public class WsTimeController : ApiController
{
[HttpGet]
public HttpResponseMessage GetMessage()
{
var status = HttpStatusCode.BadRequest;
var context = HttpContext.Current;
if (context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest(ProcessRequest);
status = HttpStatusCode.SwitchingProtocols;
}
return new HttpResponseMessage(status);
}
private async Task ProcessRequest(AspNetWebSocketContext context)
{
var ws = context.WebSocket;
await Task.WhenAll(WriteTask(ws), ReadTask(ws));
}
//MUST read if we want the socket state to be updated
private async Task ReadTask(WebSocket ws)
{
var buffer = new ArraySegment<byte>(new byte[1024]);
while (true)
{
await ws.ReceiveAsync(buffer, CancellationToken.None).ConfigureAwait(false);
if (ws.State != WebSocketState.Open) break;
}
}
private async Task WriteTask(WebSocket ws)
{
while (true)
{
var timeStr = DateTime.UtcNow.ToString("MMM dd yyyy HH:mm:ss.fff UTC", CultureInfo.InvariantCulture);
var buffer = Encoding.UTF8.GetBytes(timeStr);
if (ws.State != WebSocketState.Open) break;
var sendTask = ws.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);
await sendTask.ConfigureAwait(false);
if (ws.State != WebSocketState.Open) break;
await Task.Delay(1000).ConfigureAwait(false); //this is NOT ideal
}
}
}

0

Que sur l'utilisation de SignalR 2?
- Peut être installé via NuGet
- Pour .NET 4.5+
- N'est pas permanent, boucle
- De radiodiffusion possible
  -Tutoriel ici

Vous devez vous connecter pour publier un commentaire.