ThothRpc

Thothrpc

ThothRPC est un cadre holistique, holistique, entièrement compatible, léger, duplex complet et Bidirectional pour .NET. C'est mort simple mais puissant. Il est entièrement agnostique et modulaire de plate-forme, ne faisant aucune hypothèse sur le type de projet que vous construisez. Les couches de transport et de sérialisation des objets (pour les paramètres et les rendements de la méthode) sont distinctes de la bibliothèque de base et de la mise en œuvre personnalisée de ces couches sont faciles à vous donner la liberté pour vous de construire facilement votre système RPC.

Bien sûr, ce ne serait pas simple si ces couches n'étaient pas incluses pour vous. Cette bibliothèque est livrée avec une couche de transport UDP fiable et commandée construite à partir de Linedetlib et une couche de sérialisation construite à partir d'un pack de messages rapide avec une solution de transport Web HTTP / 2 sécurisée sur la feuille de route.

Construire

Nuget

Exemples d'utilisation

Pour utiliser l'exemple de code suivant, vous avez besoin de ces 3 packages NuGet.

 dotnet add package ThothRpc
dotnet add package ThothRpc.LiteNetLib
dotnet add package ThothRpc.MessagePack

--ou--

 Install-Package ThothRpc
Install-Package ThothRpc.LiteNetLib
Install-Package ThothRpc.MessagePack

RPC tapé

Code partagé

 public interface IClientService
{
    [ ThothMethod ] // indicates that this method is callable from server
    void PrintServerTime ( DateTime time ) ;

    Task GetHelloWorld ( ) ;
}

public interface IServerService
{
    [ ThothMethod ] // indicates that this method is callable from client
    string GetHelloWorld ( ) ;
} 

Serveur

 // hubs are thread-safe and can be single instanced for your entire app,
// or you can have multiple instances - its up to you
var hub = ServerHubBuilder . BuildServer ( )
    . UseTransport < LiteNetRpcServer > ( )
    . UseMessagePack ( ) // any object that is serializable by MessagePack can be used in parameters or return values
    . Build ( ) ;

var serverService = new ServerService ( hub ) ;

// register methods can be called multiple times to register multiple services to the same hub
hub . RegisterAs < IServerService > ( serverService ) ;
hub . Listen ( 9050 , "SomeConnectionKey" ) ;

// Thread.Sleep(60000);
// hub.Dispose(); // closes the connection

public class ServerService : IServerService
{
    readonly ServerHub _hub ;

    public ServerService ( ServerHub hub )
    {
        _hub = hub ;

        Task . Run ( async ( ) =>
        {
            // print the current time to all clients every second
            while ( true )
            {
                var now = DateTime . Now ;
                
                // Fire and forget
                _hub . InvokeForgetAllClients < IClientService > ( DeliveryMode . Sequenced ,
                    c => c . PrintServerTime ( now ) ) ;

                await Task . Delay ( 1000 ) ;
            }
        } ) ;
    }

    public string GetHelloWorld ( ) // called from client
    {
        return "Hello World From Server!" ;
    }
} 

Client

 var hub = ClientHubBuilder . BuildClient ( )
    . UseTransport < LiteNetRpcClient > ( )
    . UseMessagePack ( )
    . Build ( ) ;

var clientService = new ClientService ( hub ) ;
hub . RegisterAs < IClientService > ( clientService ) ;

await hub . ConnectAsync ( "localhost" , 9050 , "SomeConnectionKey" ) ;
await clientService . GetHelloWorld ( ) ;

public class ClientService : IClientService
{
    readonly ClientHub _hub ;

    public ClientService ( ClientHub hub )
    {
        _hub = hub ;
    }

    public async Task GetHelloWorld ( )
    {
        // Method invocations not using fire-and-forget with a udp transport are always delivered reliable and ordered.
        var helloWorld = await _hub . InvokeServerAsync < IServerService , string >
            ( s => s . GetHelloWorld ( ) ) ;

        Console . WriteLine ( helloWorld ) ;
    }

    public void PrintServerTime ( DateTime time ) // called from server
    {
        Console . WriteLine ( $ "Server time: { time } " ) ;
    }
}

RPC sans dactylographie

Le code ci-dessous est le même que ci-dessus, mais cette fois sans typage solide.

Serveur

 var hub = ServerHubBuilder . BuildServer ( )
    . UseTransport < LiteNetRpcServer > ( )
    . UseMessagePack ( )
    . Build ( ) ;

var serverService = new ServerService ( hub ) ;
hub . Register ( serverService , "ServerService" ) ;
hub . Listen ( 9050 , "SomeConnectionKey" ) ;

public class ServerService
{
    readonly ServerHub _hub ;

    public ServerService ( ServerHub hub )
    {
        _hub = hub ;

        Task . Run ( async ( ) =>
        {
            while ( true )
            {
                _hub . InvokeForgetAllClients ( DeliveryMode . Sequenced , 
                    "ClientService" , "PrintServerTime" , DateTime . Now ) ;

                await Task . Delay ( 1000 ) ;
            }
        } ) ;
    }

    [ ThothMethod ]
    public string GetHelloWorld ( )
    {
        return "Hello World From Server!" ;
    }
} 

Client

 var hub = ClientHubBuilder . BuildClient ( )
    . UseTransport < LiteNetRpcClient > ( )
    . UseMessagePack ( )
    . Build ( ) ;

var clientService = new ClientService ( hub ) ;
hub . Register ( clientService , "ClientService" ) ;

await hub . ConnectAsync ( "localhost" , 9050 , "SomeConnectionKey" ) ;
await clientService . GetHelloWorld ( ) ;

public class ClientService
{
    readonly ClientHub _hub ;

    public ClientService ( ClientHub hub )
    {
        _hub = hub ;
    }

    public async Task GetHelloWorld ( )
    {
        var helloWorld = await _hub . InvokeServerAsync < string >
            ( "ServerService" , "GetHelloWorld" ) ;

        Console . WriteLine ( helloWorld ) ;
    }

    [ ThothMethod ]
    public void PrintServerTime ( DateTime time )
    {
        Console . WriteLine ( $ "Server time: { time } " ) ;
    }
} 

Cas d'utilisation

Thoth (dans son état actuel) est idéal pour…

• Réseautage multijoueur de jeu
• Communication microservice bidirectionnelle fiable ultra-rapide au sein d'un VPC sécurisé
• Applications et outils basés sur LAN / VPN

Remarque: Le trafic sécurisé actuellement crypté n'est pas encore une fonctionnalité mais sera présent dans le prochain transport HTTP / 2. Cependant, la mise en œuvre de votre propre système de chiffrement est facile avec les rappels entrants et sorties.

Caractéristiques

• Basé sur l'exécution
  • Aucun dossier de contrat (.proto, ect)
  • Enregistrement / non-inscription dynamique
• Performant
  • Conception de pression GC faible
  • Faible utilisation du processeur
  • Petite taille de paquet (jusqu'à 3 octets au total pour un incendie optimisé et oublier l'appel)
• Diverses conventions d'appel
  • Invocation dactylographiée ou sans dactylographie
  • Appels de méthode directe dans le processus lorsque le client et le serveur sont sur la même machine
  • Serveur d'appels ou client rapide à feu incendie avec mode de livraison personnalisable
  • RPC fiable RPC Bidirectional Request-Response Cappel
• Demandez séparément la personnalisation de la gestion du serveur et du client
  • Manuel Gestion permettant à toutes les demandes entrantes d'être interrogées sur un fil (c'est-à-dire en boucle de jeu)
  • Manipulation de pool de threads multi-thread de toutes les demandes entrantes (comme ASP.NET Core)
• Holistique et modulaire
  • Transport et sérialisation configurables
  • Entrée et sortie de données configurables
  • Loggotage sans dépendance (fonctionne avec tout ce que vous avez, utilisez simplement les rappels)
  • Pas de liens de middleware, de configuration d'injection de dépendance requise ou de code de passe-partout compliqué