neuecc/MagicOnion

Features

• Remote Procedure Call Frameworks - Provides a high-performance binary RPC framework for invoking methods on remote services as if they were local.
• Remote Procedure Calls - Implements a remote procedure call framework for executing functions on remote servers as if they were local.
• Complex Data Serialization - Converts complex objects into a compact binary format for efficient network transmission.
• AOT-Compatible Networking Clients - Provides networking clients specifically designed to operate without dynamic reflection in AOT environments.
• Unity Networking Integrations - Provides a specialized communication layer for Unity with support for AOT compilation and engine-specific data types.
• Binary Communication Protocols - Implements a high-performance binary transport protocol for efficient distributed system communication.
• Server-Side Session State - Maintains dedicated server-side service instances for each connection to preserve state across method calls.
• Server-to-Client Event Emissions - Allows servers to push asynchronous messages to connected clients via a persistent connection to enable live updates.
• Binary Serialization - Uses compact binary representations for efficient network transmission of complex objects.
• Realtime Communication Protocols - Establishes persistent, bidirectional data exchange for broadcasting and state synchronization between server and clients.
• Remote Method Invocation - Establishes communication channels to trigger functions on a remote device as if they were local asynchronous calls.
• RPC Clients - Provides a client-side proxy for executing remote methods on a server across various .NET platforms.
• RPC Frameworks - Functions as a high-performance RPC framework for executing remote procedures across .NET network nodes.
• RPC Servers - Hosts a remote procedure call service to process incoming requests from connected clients.
• RPC Service Implementations - Implements business logic by inheriting from base classes and fulfilling shared interfaces to handle remote requests.
• Schema-Driven RPC Implementations - Implements remote procedure call services using shared interfaces as the formal protocol schema.
• Bidirectional RPC Streaming - Establishes continuous bidirectional connections to send and receive messages asynchronously.
• Ahead-Of-Time Compilation - Ensures the communication layer is compatible with ahead-of-time compilation for mobile and desktop platforms.
• Fullstack Type Sharing - Shares type definitions between client and server to ensure end-to-end type safety.
• Interface Contracts - Uses shared interface contracts to ensure consistent type-safe communication across application boundaries.
• Request-Response Exchanges - Implements synchronous remote procedure calls that treat each request as a single transaction over a network connection.
• Shared API Contract Libraries - Utilizes a shared library of interfaces and data types to maintain consistent communication contracts.
• AOT Proxy Generators - Produces client-side proxy code during compilation to remove runtime reflection and support AOT platforms.
• Unary RPC Execution - Implements standard request-response remote procedure call patterns for simple interactions.
• Type-Safe Client Generators - Generates type-safe client proxy code during compilation to ensure consistency between server interfaces and client calls.
• Interface-Based Definitions - Uses shared interfaces to define service contracts and generate transparent client proxies for type-safe communication.
• AOT-Compatible Unity Serializers - Provides a communication layer with AOT-compatible serialization for Unity native data types.
• Real-Time Communication - Implements persistent, bidirectional data streaming between clients and servers for live updates and interactive messaging.
• Real-Time Data Streaming - Provides utilities for pushing live server-side data updates to connected clients via bidirectional streams.
• Bidirectional Streams - Implements full-duplex message exchange patterns for simultaneous client-to-server and server-to-client streaming.
• Request and Response Interception - Executes custom logic pipelines before and after service method calls to handle global processing and exceptions.
• Complex Data Type Exchange - Exchanges high-level objects and native data types, such as Unity vectors, across different execution environments.
• Broadcast Messaging - Enables sending single messages to groups of connected clients simultaneously to synchronize data.
• Real-time Notification Broadcasters - Pushes real-time alerts and asynchronous updates to users via persistent websocket connections.
• Cross-Platform Networking - Provides a unified, portable communication layer for various .NET platforms.
• Session State Persistence - Preserves a service instance and its associated state across multiple method calls during a persistent connection.
• Real-Time State Broadcasting - Streams internal application state changes to multiple external clients via persistent network connections.
• Service Meshes - Provides an infrastructure layer to manage service-to-service communication, security, and policy enforcement.
• Bearer Token Attachments - Adds security tokens and custom metadata to client request headers to authenticate identity.
• Role-Based Access Control - Restricts access to specific classes or methods based on assigned user roles.
• JWT Authentication - Validates signed JSON Web Tokens in request headers to identify users via the web context.
• Request Filter Integrations - Inspects request headers using custom filters to implement security checks and API key validation.
• Secure Network Communication - Secures network services using TLS encryption, JWT authentication, and role-based access control.
• TLS Traffic Encryption - Encrypts communication channels between clients and servers using SSL/TLS encryption.
• Request Interceptors - Provides a request interceptor pipeline to handle cross-cutting concerns like authentication and global exceptions.
• Stateful Service Instances - Maintains dedicated server-side service instances for each connection to preserve user state across multiple calls.
• Sequential Request Processing - Processes method calls from a single client in the exact order they were sent to prevent race conditions.
• Server Metrics - Exposes real-time server health metrics including connection counts, method durations, and exception rates.
• Message Ordering - Guarantees the sequential processing of remote method calls arriving from a single connection.
• Application Frameworks - gRPC-based streaming RPC framework.
• Dotnet Frameworks - Streaming framework for .NET and Unity.
• Networking Libraries - gRPC-based RPC framework.

Star history