MHLab.AspNetCore.Enet

MHLab.AspNetCore.Enet

Une extension qui vous permet de faire tourner un serveur Enet dans votre application ASP.NET Core. Il est basé sur le travail génial de Stanislav Denisov : ENet-CSharp.

C'est facile à définir :

 public void ConfigureServices ( IServiceCollection services )
{
    // Your other code...

    services . AddEnet ( ( configuration ) =>
    {
        configuration
            /* Set the port your Enet Server will listen to. */
            . SetPort ( 7001 )
            /* Set the polling time, in milliseconds. */
            . SetPollingTimeout ( 15 ) ;

        /* Add your connection handlers to compose the pipeline. The order matters. */
        configuration
            . AddConnectionHandler < MyConnectionHandler1 > ( )
            . AddConnectionHandler < MyConnectionHandlerN > ( ) ;

        /* Add your disconnection handlers to compose the pipeline. The order matters. */
        configuration
            . AddDisconnectionHandler < MyDisconnectionHandler1 > ( )
            . AddDisconnectionHandler < MyDisconnectionHandlerN > ( ) ;

        /* Add your timeout handlers to compose the pipeline. The order matters. */
        configuration
            . AddTimeoutHandler < MyTimeoutHandler1 > ( )
            . AddTimeoutHandler < MyTimeoutHandlerN > ( ) ;

        /* Add your packet received handlers to compose the pipeline. The order matters. */
        configuration
            . AddPacketHandler < MyPacketHandler1 > ( )
            . AddPacketHandler < MyPacketHandlerN > ( ) ;
    } ) ;

    // Your other code...
} 

Échantillon

Vous pouvez trouver l’exemple d’utilisation dans le dossier MHLab.AspNetCore.Enet.Sample . Il s'agit du modèle d'API Web ASP.NET Core classique avec l'ajout du serveur Enet.

Gestionnaires de connexion

Un gestionnaire de connexion est déclenché lorsqu'une nouvelle connexion client est établie. Vous pouvez créer vos gestionnaires de connexion comme ceci :

 using ENet ;
using MHLab . AspNetCore . Enet . Handlers ;
using Microsoft . Extensions . Logging ;

public class ConnectionHandler : IConnectionHandler
{
    private readonly ILogger < ConnectionHandler > _logger ;

    public ConnectionHandler ( ILogger < ConnectionHandler > logger )
    {
        /* Here in the constructor you can take the full advantage of the 
        Microsoft Dependency Injection framework. */
        _logger = logger ;
    }

    public void OnConnectedPeer ( Peer peer )
    {
        _logger . LogDebug ( $ "Client connected - ID: { peer . ID } , IP: { peer . IP } " ) ;
    }
} 

Gestionnaires de déconnexion

Un gestionnaire de déconnexion est déclenché lorsqu'un client déjà connecté se déconnecte correctement. Vous pouvez créer vos gestionnaires de déconnexion comme ceci :

 using ENet ;
using MHLab . AspNetCore . Enet . Handlers ;
using Microsoft . Extensions . Logging ;

public class DisconnectionHandler : IDisconnectionHandler
{
    private readonly ILogger < DisconnectionHandler > _logger ;

    public DisconnectionHandler ( ILogger < DisconnectionHandler > logger )
    {
        /* Here in the constructor you can take the full advantage of the 
        Microsoft Dependency Injection framework. */
        _logger = logger ;
    }

    public void OnDisconnectedPeer ( Peer peer )
    {
        _logger . Log ( LogLevel . Debug , $ "Client disconnected - ID: { peer . ID } , IP: { peer . IP } " ) ;
    }
} 

Gestionnaires de délais d'attente

Un gestionnaire de délai d'attente est déclenché lorsqu'un client déjà connecté se déconnecte de manière inappropriée. Vous pouvez créer vos gestionnaires de délai d'attente comme ceci :

 using ENet ;
using MHLab . AspNetCore . Enet . Handlers ;
using Microsoft . Extensions . Logging ;

public class TimeoutHandler : ITimeoutHandler
{
    private readonly ILogger < TimeoutHandler > _logger ;

    public TimeoutHandler ( ILogger < TimeoutHandler > logger )
    {
        /* Here in the constructor you can take the full advantage of the 
        Microsoft Dependency Injection framework. */
        _logger = logger ;
    }

    public void OnTimeoutPeer ( Peer peer )
    {
        _logger . Log ( LogLevel . Debug , $ "Client timeout - ID: { peer . ID } , IP: { peer . IP } " ) ;
    }
} 

Gestionnaires de paquets

Un gestionnaire de paquets est déclenché lorsqu'un message est reçu d'un client connecté. Vous pouvez créer vos gestionnaires de paquets comme ceci :

 using ENet ;
using MHLab . AspNetCore . Enet . Handlers ;
using Microsoft . Extensions . Logging ;

public class PacketHandler : IPacketHandler
{
    private readonly ILogger < PacketHandler > _logger ;

    public PacketHandler ( ILogger < PacketHandler > logger )
    {
        /* Here in the constructor you can take the full advantage of the 
        Microsoft Dependency Injection framework. */
        _logger = logger ;
    }

    public void OnPacketReceived ( Peer peer , byte channelId , Packet packet )
    {
        _logger . Log ( LogLevel . Debug , $ "Packet received from - ID: { peer . ID } , IP: { peer . IP } , Channel ID: { channelId } , Data length: { packet . Length } " ) ;
    }
}