 |
ProtonNet Server 1.0
An Open Solution for all your socket or web api needs.
|
|
ProtonNet Server 1.0
An Open Solution for all your socket or web api needs.
|
| ▼NXmobiTea | |
| ►NBean | |
| ►NAttributes | |
| CAutoBindAttribute | Attribute used to automatically bind a field or property to a specific type |
| CSingletonAttribute | Attribute used to mark a class as a singleton |
| ►NFactory | |
| CISingletonFactory | Defines the interface for a singleton factory |
| CSingletonFactory | A factory class for creating and managing singleton instances |
| ►NSupport | |
| CIAfterAutoBind | Defines a method that is called after auto-binding is complete |
| CIBeforeAutoBind | Defines a method that is called before the auto-binding process begins |
| CIConstructorInvoke | Defines a method that is called immediately after the constructor is invoked |
| CIFinalAutoBind | Defines a method that is called after the final auto-binding all process is completed |
| CBeanContext | Implements the IBeanContext interface to manage singleton instances, handle auto-binding of dependencies, and scan classes in assemblies |
| CIAutoBindingContext | Defines methods for automatically binding dependencies in singleton instances |
| CIBeanContext | Combines singleton management, auto-binding, and class scanning functionalities |
| CIClassScannerContext | Defines methods for scanning and retrieving types within a given namespace or assembly |
| CISingletonContext | Defines methods for managing singleton instances in the context |
| ►NBinary | |
| ►NHelper | |
| ►NParsers | |
| CBoolDataConverter | Provides methods for converting objects to Boolean values |
| CByteDataConverter | Provides methods for converting objects to unsigned byte values |
| CCharDataConverter | Provides methods for converting objects to character values |
| CDataParser | Provides an implementation of the IDataParser interface for parsing data types |
| CDoubleDataConverter | Provides methods for converting objects to double-precision floating-point values |
| CFloatDataConverter | Provides methods for converting objects to single-precision floating-point values |
| CIDataConverter | Provides a method to convert an object to a specific data type |
| CIDataParser | Defines methods for parsing various types of data |
| CIntDataConverter | Provides methods for converting objects to signed integer values |
| CLongDataConverter | Provides methods for converting objects to signed long integer values |
| CSByteDataConverter | Provides methods for converting objects to signed byte values |
| CShortDataConverter | Provides methods for converting objects to signed short integer values |
| CStringDataConverter | Provides methods for converting objects to string values |
| CUIntDataConverter | Provides methods for converting objects to unsigned integer values |
| CULongDataConverter | Provides methods for converting objects to unsigned long integer values |
| CUShortDataConverter | Provides methods for converting objects to unsigned short integer values |
| ►NMessagePack | |
| ►NDeserialize | |
| ►NReader | |
| ►NCore | |
| CBinaryReader | Provides a base class for reading binary data of a specific type from a stream and interpreting it according to a type code |
| CIBinaryReader | Defines methods for reading binary data from a stream and interpreting it according to a type code |
| CAbstractCollectionBinaryReader | Provides a base class for reading binary data for collection types from a stream and interpreting it according to a type code |
| CArrayBinaryReader | Implements a binary reader for deserializing array types from a binary stream |
| CBinaryBinaryReader | Implements a binary reader for deserializing binary data (byte arrays) from a binary stream |
| CBooleanBinaryReader | Implements a binary reader for deserializing boolean values from a binary stream |
| CExtensionBinaryReader | Implements a binary reader for deserializing extension data from a binary stream |
| CFloatBinaryReader | Implements a binary reader for deserializing floating-point numbers from a binary stream |
| CIntegerBinaryReader | Implements a binary reader for deserializing integer values from a binary stream |
| CMapBinaryReader | Implements a binary reader for deserializing map (dictionary) data from a binary stream |
| CNilBinaryReader | Implements a binary reader for deserializing 'nil' values (representing null) from a binary stream |
| CStringBinaryReader | Implements a binary reader for deserializing string data from a binary stream |
| CBinaryDeserializer | Implements the IBinaryDeserializer interface, providing deserialization functionality for binary data |
| CIBinaryDeserializer | Defines the contract for a binary deserializer capable of deserializing data from binary streams and byte arrays |
| ►NSerialize | |
| ►NWriter | |
| ►NCore | |
| CBinaryWriter | Provides an abstract base class for implementing binary writers for specific data types |
| CIBinaryWriter | Defines the contract for a binary writer capable of serializing objects into a binary format |
| CAbstractCollectionBinaryWriter | Provides an abstract base class for implementing binary writers for collection types |
| CArrayBinaryWriter | Provides functionality to serialize arrays into MessagePack binary format |
| CBinaryBinaryWriter | Provides functionality to serialize binary data (byte arrays) into MessagePack binary format |
| CBooleanBinaryWriter | Provides functionality to serialize boolean values into MessagePack binary format |
| CExtensionBinaryWriter | Provides functionality to serialize extension types (tuples of sbyte and byte arrays) into MessagePack binary format |
| CFloatBinaryWriter | Provides functionality to serialize floating-point numbers (both single and double precision) into MessagePack binary format |
| CIntegerBinaryWriter | Provides functionality to serialize integer values (both signed and unsigned) into MessagePack binary format |
| CMapBinaryWriter | Provides functionality to serialize dictionary objects into MessagePack binary format |
| CNilBinaryWriter | Provides functionality to serialize a null or nil object into MessagePack binary format |
| CStringBinaryWriter | Provides functionality to serialize a string into MessagePack binary format |
| CBinarySerializer | Implements the IBinarySerializer interface to provide serialization capabilities for various data types |
| CIBinarySerializer | Provides methods for serializing objects into MessagePack binary format |
| CBinaryConverter | Provides methods for serializing and deserializing objects using MessagePack |
| ►NSimplePack | |
| ►NDeserialize | |
| ►NReader | |
| ►NCore | |
| CBinaryReader | |
| CIBinaryReader | |
| CAbstractCollectionBinaryReader | |
| CBooleanBinaryReader | |
| CByteBinaryReader | |
| CCharBinaryReader | |
| CCollectionOfIdentifyBinaryReader | |
| CCollectionOfObjectBinaryReader | |
| CDateTimeBinaryReader | |
| CDecimalBinaryReader | |
| CDictionaryKeyIdentifyValueIdentifyBinaryReader | |
| CDictionaryKeyIdentifyValueObjectBinaryReader | |
| CDictionaryKeyObjectValueIdentifyBinaryReader | |
| CDictionaryKeyObjectValueObjectBinaryReader | |
| CDoubleBinaryReader | |
| CFloatBinaryReader | |
| CIntBinaryReader | |
| CLongBinaryReader | |
| CNullBinaryReader | |
| CSByteBinaryReader | |
| CShortBinaryReader | |
| CStringBinaryReader | |
| CUIntBinaryReader | |
| CULongBinaryReader | |
| CUShortBinaryReader | |
| CBinaryDeserializer | |
| CIBinaryDeserializer | |
| ►NSerialize | |
| ►NWriter | |
| ►NCore | |
| CBinaryWriter | |
| CIBinaryWriter | |
| CAbstractCollectionBinaryWriter | |
| CBooleanBinaryWriter | |
| CByteBinaryWriter | |
| CCharBinaryWriter | |
| CCollectionOfIdentifyBinaryWriter | |
| CCollectionOfObjectBinaryWriter | |
| CDateTimeBinaryWriter | |
| CDecimalBinaryWriter | |
| CDictionaryKeyIdentifyValueIdentifyBinaryWriter | |
| CDictionaryKeyIdentifyValueObjectBinaryWriter | |
| CDictionaryKeyObjectValueIdentifyBinaryWriter | |
| CDictionaryKeyObjectValueObjectBinaryWriter | |
| CDoubleBinaryWriter | |
| CFloatBinaryWriter | |
| CIntBinaryWriter | |
| CLongBinaryWriter | |
| CNullBinaryWriter | |
| CSByteBinaryWriter | |
| CShortBinaryWriter | |
| CStringBinaryWriter | |
| CUIntBinaryWriter | |
| CULongBinaryWriter | |
| CUShortBinaryWriter | |
| CBinarySerializer | |
| CIBinarySerializer | |
| CBinaryConverter | |
| CIBinaryConverter | Defines methods for serializing and deserializing objects to and from binary data |
| ►NCollections | |
| ►NGeneric | |
| CThreadSafeArray | Provides a thread-safe array implementation that supports safe access to elements in a multi-threaded environment |
| CThreadSafeDictionary | Provides a thread-safe dictionary implementation that supports concurrent access to elements in a multi-threaded environment |
| CThreadSafeList | Provides a thread-safe list implementation that supports safe access to elements in a multi-threaded environment |
| ►NCrypto | |
| ►NAes | |
| ►NDecrypt | |
| CCryptoDecrypter | Implementation of the ICryptoDecrypter interface for AES decryption |
| CICryptoDecrypter | Defines the interface for a cryptographic decrypter |
| ►NEncrypt | |
| CCryptoEncrypter | Implementation of the ICryptoEncrypter interface for AES encryption |
| CICryptoEncrypter | Defines the interface for a cryptographic encrypter |
| CCryptoProvider | Provides AES-based cryptographic operations including encryption and decryption |
| CICryptoProvider | Defines the interface for a cryptographic provider that supports encryption and decryption of data |
| ►NData | |
| ►NConverter | |
| ►NHelper | |
| CDetectSupport | Provides utility methods for type detection |
| ►NModels | |
| CDataMemberFieldInfoTypeMapper | Implements the IDataMemberFieldInfoTypeMapper interface to map data member fields to metadata information |
| CDeserializeConverter | Implementation of IDeserializeConverter for converting GNHashtable and GNArray objects to their respective types |
| CGNEnhancedObjectFieldMetadata | Implementation of IGNEnhancedObjectFieldMetadata that provides metadata for fields in a GNEnhanced object |
| CIDataMemberFieldInfoTypeMapper | Interface for mapping data member fields to metadata information |
| CIDeserializeConverter | Interface for converting GNHashtable and GNArray objects to their respective types |
| CIGNEnhancedObjectFieldMetadata | Interface defining metadata for fields in a GNEnhanced object |
| CISerializeConverter | Interface for converting objects and lists to GNHashtable and GNArray respectively |
| CSerializeConverter | Implementation of ISerializeConverter for converting objects and lists to GNHashtable and GNArray |
| ►NRpc | |
| CBooleanDataMemberAttribute | Attribute for marking fields that represent boolean data members. Extends DataMemberAttribute with additional boolean-specific metadata |
| CDataMemberAttribute | Base attribute for marking fields that represent data members in an object. Provides common properties for specifying metadata such as field type, code, and default value |
| CGNArrayDataMemberAttribute | Attribute for marking fields that represent GNArray data members. Extends DataMemberAttribute with additional GNArray-specific metadata |
| CGNHashtableDataMemberAttribute | Attribute for marking fields that represent GNHashtable data members. Extends DataMemberAttribute with additional GNHashtable-specific metadata |
| CNumberDataMemberAttribute | Attribute for marking fields that represent numeric data members. Extends DataMemberAttribute with additional number-specific metadata |
| CStringDataMemberAttribute | Attribute for marking fields that represent string data members. Extends DataMemberAttribute with additional string-specific metadata |
| CDataConverter | Provides methods for serializing and deserializing objects and arrays using custom converters |
| CIDataConverter | Defines methods for serializing and deserializing objects and arrays |
| ►NHelper | |
| ►NParsers | |
| CBoolDataConverter | Converter class for converting various types to a boolean |
| CByteDataConverter | Converter class for converting various types to a byte |
| CCharDataConverter | Converter class for converting various types to a char |
| CDataParser | Implementation of the IDataParser interface for converting objects to various data types |
| CDoubleDataConverter | Converter class for converting various types to a double |
| CFloatDataConverter | Converter class for converting various types to a float |
| CIDataConverter | Interface for data conversion |
| CIDataParser | Interface defining methods for parsing objects into various data types |
| CIntDataConverter | Converter class for converting various types to an integer |
| CLongDataConverter | Converter class for converting various types to a long |
| CSByteDataConverter | Converter class for converting various types to a signed byte |
| CShortDataConverter | Converter class for converting various types to a short |
| CStringDataConverter | Converter class for converting various types to a string |
| CUIntDataConverter | Converter class for converting various types to an unsigned integer |
| CULongDataConverter | Converter class for converting various types to an unsigned long |
| CUShortDataConverter | Converter class for converting various types to an unsigned short |
| ►CGNArray | Represents a generic array data structure with various utility methods |
| CBuilder | A builder class for constructing instances of GNArray |
| CGNData | Abstract class representing generic data operations |
| ►CGNHashtable | Represents a generic hashtable data structure with various utility methods |
| CBuilder | A builder class for constructing instances of GNHashtable |
| CIGNData | Defines a contract for classes that can convert their data into a specific format |
| ►NLogging | |
| ►NConsole | |
| CConsoleLogger | A logger implementation that outputs logs to the console with various log levels |
| CConsoleLoggerFactory | Factory class to create instances of ConsoleLogger. This class is a singleton, with the single instance accessible via the Instance property |
| ►NEmpty | |
| CEmptyLogger | Represents a logger that performs no logging actions. This class is a placeholder or no-op (no operation) logger, useful for cases where logging needs to be disabled |
| CEmptyLoggerFactory | Factory class for creating instances of EmptyLogger. This factory returns a logger that performs no logging operations |
| ►NLog4Net | |
| CLog4NetLogger | Implements the ILogger interface using the log4net logging framework |
| CLog4NetLoggerFactory | Provides a factory for creating instances of ILogger that use the log4net logging framework |
| CILogger | Provides a logging interface with various levels of logging |
| CILoggerFactory | Interface representing a factory for creating loggers |
| ►NProtonNet | |
| ►NClient | |
| ►NModels | |
| CClientPeerInitRequest | Implements the IClientPeerInitRequest interface |
| CIClientPeerInitRequest | Represents an initialization request for a client peer |
| COperationEventPending | Represents a pending operation event that is queued for sending to the server. Stores the event data and the parameters used for sending it |
| COperationRequestPending | Represents a pending operation request that is queued for sending to the server. Stores the request data, parameters, and the callback for handling the server's response |
| ►NServices | |
| CIInitRequestProviderService | Interface for a service that provides initialization requests for creating new client peers |
| ►CInitRequestProviderService | Service that provides initialization requests for creating new client peers. It generates session IDs, encryption keys, and client IDs for the requests |
| CClientIdProvider | Nested class responsible for generating unique client IDs |
| CEncryptKeyProvider | Nested class responsible for generating random encryption keys |
| CSessionIdProvider | Nested class responsible for generating random session IDs |
| CIRpcProtocolService | Interface for handling the serialization and deserialization of operation models in an RPC (Remote Procedure Call) communication protocol. Provides methods for writing data to a stream, optionally with encryption, and for reading and deserializing data from a stream |
| CRpcProtocolService | Implements the IRpcProtocolService interface, providing methods for handling RPC protocol operations, including serialization, deserialization, and encryption of operation models |
| ►NSocket | |
| ►NClients | |
| CISetEncryptKey | Interface for setting the encryption key used by the socket client |
| CISocketClient | Interface representing a socket client, responsible for managing socket connections and data transmission |
| CSocketSslClient | Represents a secure socket client that uses SSL/TLS for communication, implementing the ISocketClient and ISetEncryptKey interfaces |
| CSocketTcpClient | Represents a TCP socket client, implementing the ISocketClient and ISetEncryptKey interfaces |
| CSocketUdpClient | Represents a UDP socket client, implementing the ISocketClient and ISetEncryptKey interfaces |
| CSocketWsClient | Represents a WebSocket client, implementing the ISocketClient and ISetEncryptKey interfaces |
| CSocketWssClient | Represents a WebSocket Secure (WSS) client, implementing the ISocketClient and ISetEncryptKey interfaces |
| ►NHandlers | |
| CAbstractOperationModelHandler | Abstract base class for handling specific types of socket operation models |
| CEventHandler | Abstract base class for handling events during socket communication |
| CIEventHandler | Interface for handling events that occur during socket communication |
| CISocketOperationModelHandler | Interface for handling socket operation models of any type |
| COperationDisconnectHandler | Handles OperationDisconnect instances, typically issued by servers to notify clients of disconnection events |
| COperationEventHandler | Handles OperationEvent instances, typically issued by servers to notify clients of events |
| COperationHandshakeAckHandler | Handles OperationHandshakeAck instances, typically issued by servers to acknowledge a client's handshake request |
| COperationHandshakeHandler | Handles OperationHandshake instances, typically issued by clients to initiate a connection with the server |
| COperationPingHandler | Handles OperationPing instances, typically issued by servers to check the client's connection status |
| COperationPongHandler | Handles OperationPong instances, typically issued by clients in response to a ping operation from the server |
| COperationRequestHandler | Handles OperationRequest instances, typically issued by clients |
| COperationResponseHandler | Handles OperationResponse instances, typically issued by servers |
| ►NServices | |
| CEventService | Implementation of IEventService that manages event handlers and processes incoming operation events |
| CIEventService | Interface for an event service that manages event handlers and processes incoming operation events |
| CISocketOperationModelService | Interface for a service that handles socket operation models based on their operation type |
| CISocketSessionEmitService | Interface for a service that handles emitting various types of socket operations, such as events, requests, responses, and protocol-specific operations like ping, pong, and handshakes |
| CSocketOperationModelService | Implementation of ISocketOperationModelService that manages operation model handlers and processes incoming operations |
| CSocketSessionEmitService | Implements the ISocketSessionEmitService interface to handle the emission of various socket operations, including events, requests, pings, pongs, and handshakes |
| CISocketClientPeer | Interface representing a socket client peer, which is responsible for managing socket connections, sending events, and handling callbacks for various socket events |
| CISocketPingPong | Interface that defines the service method for managing ping-pong operations over a socket connection |
| CSocketClientPeer | Represents a client peer that manages socket connections, sends and receives operations, and handles various socket events such as connection, disconnection, and errors. Inherits from ClientPeer and implements ISocketClientPeer and IAfterAutoBind |
| CSocketPingPong | Implements the ISocketPingPong interface to manage the ping-pong operations between the client and server over a socket connection |
| ►NSupports | |
| CDefaultDebugOperationService | Default implementation of the IDebugSupport interface, providing methods for generating debug information related to the lifecycle of operation requests and events |
| CIDebugSupport | Interface that provides methods for generating debug information related to the lifecycle of operation requests and events |
| ►NWebApi | |
| CAbstractWebApiClientPeer | Abstract base class for a Web API client peer, implementing common functionality and providing a base for more specific Web API client peer implementations |
| CHttpClientClientPeer | Represents a Web API client peer that communicates with the server using HTTP. Inherits from AbstractWebApiClientPeer and implements the IWebApiClientPeer interface |
| CIWebApiClientPeer | Interface for a Web API client peer, extending the basic client peer functionality with additional methods specific to Web API operations |
| CClientPeer | Abstract class representing a client peer in the network communication system. Handles sending and receiving of operation requests, managing response timings, and providing debug support |
| ►CClientPeerFactory | Factory class to create and manage different types of client peers, including Web API and Socket client peers |
| CBuilder | Builder class for configuring and constructing instances of the ClientPeerFactory |
| CIClientPeer | Represents a client peer in the network communication system. Provides methods to send requests, manage connections, and access network statistics |
| CIClientPeerFactory | Interface for a factory that creates and manages various types of client peers |
| ►NControl | |
| ►NAgent | |
| ►NAgents | |
| CIStartupAgent | Interface defining the methods for a startup agent |
| ►CPlainStartupAgent | Implementation of IStartupAgent for managing the startup of different types of servers |
| CBuilder | Builder class for creating instances of PlainStartupAgent |
| ►CServiceStartupAgent | Service base implementation for starting and stopping a service with a specific startup agent |
| CBuilder | Builder class for creating instances of ServiceStartupAgent |
| ►CApplicationStartup | Handles the startup of the application, including configuration and agent creation |
| CBuilder | Builder class for ApplicationStartup with fluent API |
| CProgram | Entry point for the application |
| CStartupAgentArgsBuilder | Builds arguments for starting an agent |
| ►CStartupAgentInfo | Represents the startup agent information |
| CBuilder | Builder class for creating instances of StartupAgentInfo |
| ►NHandlers | |
| CAbstractExecuteHandler | Abstract base class for command execution handlers |
| CIExecuteHandler | Interface for command execution handlers |
| CLinuxExecuteHandler | Handler for executing commands on Linux platform |
| COSXExecuteHandler | Handler for executing commands on OSX platform |
| CWindowsExecuteHandler | Handler for executing commands on Windows platform |
| ►NHelper | |
| ►NModels | |
| CAuthTokenSettings | Settings auth token service |
| CHttpServerSettings | Settings for HTTP server configuration |
| CSessionConfigSettings | Configuration settings for session management |
| CSocketStartupSettings | Startup settings for the socket server |
| CSslConfigSettings | Configuration settings for SSL/TLS |
| CTcpServerSettings | Settings for TCP server configuration |
| CThreadPoolSizeSettings | Settings for thread pool size configuration |
| CUdpServerSettings | Settings for UDP server configuration |
| CUdpSessionConfigSettings | Configuration settings for UDP session |
| CWebApiStartupSettings | Startup settings for Web API |
| CWebSocketServerSettings | Settings for WebSocket server configuration |
| CIStartupSettingsReader | Defines methods for reading startup settings related to Web API and Socket configurations. This interface provides methods to load startup settings from JSON files for both Web API and Socket applications |
| CProtonNetServerSettingsUtils | Utility class for handling Proton server settings |
| CStartupSettingsReader | Provides implementations for reading Web API and Socket startup settings from JSON files. This class implements the IStartupSettingsReader interface to deserialize JSON files into their corresponding startup settings objects |
| ►NModels | |
| CProtonNetInstance | Represents a configuration instance for a ProtonNet server |
| CProtonNetServerSettings | Represents the settings for a Proton server instance |
| ►NServices | |
| CExecuteService | Implementation of IExecuteService that manages and executes commands using platform-specific handlers |
| CIExecuteService | Interface for executing commands based on the platform |
| ►CApplicationStartup | The ApplicationStartup class is responsible for initializing and running the ProtonNet Control application |
| CBuilder | The Builder class is used to configure and create an instance of ApplicationStartup |
| CProgram | The Program class is the entry point for the ProtonNet Control application |
| CStartupAgentArgsBuilder | The StartupAgentArgsBuilder class is used to build startup arguments for the Proton Agent |
| ►NNetworking | |
| CIOperationModel | Defines the interface for operation models in the networking layer |
| COperationDisconnect | Represents a disconnect operation in the networking layer |
| COperationEvent | Represents an event operation in the networking layer |
| COperationHandshake | Represents a handshake operation in the networking layer |
| COperationHandshakeAck | Represents a handshake acknowledgment operation in the networking layer |
| COperationPing | Represents a Ping operation in the networking layer, typically used to check connectivity or latency |
| COperationPong | Represents a Pong operation in the networking layer, typically used as a response to a Ping |
| COperationRequest | Represents a request for an operation in the networking layer |
| COperationResponse | Represents the response to an operation in the networking layer |
| CSendParameters | Struct representing parameters used during a send operation |
| ►NRpcProtocol | |
| ►NModels | |
| COperationHeader | Represents the header for an operation in the RPC protocol |
| CIOperationDeserializeSupport | Interface defining the contract for deserialization support of operation models in the XmobiTea.ProtonNet library |
| CIOperationSerializeSupport | Interface defining the contract for serialization support of operation models in the XmobiTea.ProtonNet library |
| CIRpcProtocol | Interface defining the contract for RPC communication protocols in the XmobiTea.ProtonNet library |
| COperationDeserializeSupport | Implementation of IOperationDeserializeSupport that provides deserialization support for various operation types |
| COperationSerializeSupport | Implementation of IOperationSerializeSupport that provides serialization support for various operation types |
| CRpcProtocol | RpcProtocol class implements the IRpcProtocol interface to handle RPC communication protocols |
| ►NServer | |
| ►NContext | |
| CIServerContext | Defines the interface for server context services |
| CServerContext | Implements the server context services |
| ►NHandlers | |
| ►NAttributes | |
| CAllowAnonymousAttribute | Indicates that the attributed class allows anonymous access |
| CDisableHandlerAttribute | Indicates that the attributed class should have its handler functionality disabled |
| COnlyServerAttribute | Specifies that the attributed class EventHandler or RequestHandler, sender must is Server can handle |
| CEventHandler | Provides a base implementation for event handlers |
| CIEventHandler | Defines the interface for event handlers |
| CIRequestHandler | Defines the interface for request handlers |
| CRequestHandler | Provides a base implementation for request handlers |
| ►NModels | |
| CChannel | Implements the channel interface and provides methods for managing users and channel properties |
| CIChannel | Defines methods for channel operations, including user management and properties |
| CIChannelMediator | Defines methods for managing channel membership and operations |
| CIEncryptKeySetter | Defines a method for setting the encryption key |
| CIProperty | Defines methods for managing property data with a string key |
| CISession | Defines methods for accessing session information |
| CISessionFiber | Defines a method for retrieving the fiber associated with the session |
| CISessionIdSetter | Defines a method for setting the session ID |
| CISessionInitRequest | Defines the properties required for a session initialization request |
| CISetterUserPeer | Defines methods for setting user peer properties |
| CIUserPeer | Defines methods for accessing user peer properties |
| CProperty | Implements the IProperty interface for managing properties with a thread-safe dictionary |
| CServerNetworkStatistics | Implements IServerNetworkStatistics to aggregate network statistics from multiple sources |
| CSessionInitRequest | Implements the ISessionInitRequest interface for session initialization requests |
| CUserPeer | Implements the IUserPeer and ISetterUserPeer interfaces for managing user peer data |
| CUserPeerTokenPayload | Represents the payload of a user peer token, implementing ITokenPayload |
| ►NServices | |
| CByteArrayManagerService | Service that manages byte array pooling by renting and returning byte arrays. Implements the IByteArrayManagerService interface |
| CChannelService | Implements IChannelService to manage channels and user memberships |
| CEventService | Implements IEventService to manage and handle events |
| CIByteArrayManagerService | Interface that defines methods for renting and returning byte arrays based on a given buffer, position, and count |
| CIChannelService | Provides methods for managing channels and user memberships in channels |
| CIEventService | Defines methods for managing and handling events |
| CIInitRequestProviderService | Defines a service for creating new session initialization requests |
| ►CInitRequestProviderService | Implements IInitRequestProviderService to provide new session initialization requests |
| CConnectionIdProvider | Provides functionality to generate connection IDs |
| CFiberProvider | Provides functionality to create new fibers |
| CSessionIdProvider | Provides functionality to generate session IDs |
| CIRequestService | Defines a service for handling requests |
| CIRpcProtocolService | Defines the service for handling RPC protocol operations |
| CISessionService | Defines the service for managing sessions |
| CIUserPeerAuthTokenService | Defines the service for generating and verifying authentication tokens for user peers |
| CIUserPeerService | Defines the service for managing user peers in the system |
| CIUserPeerSessionService | Defines the service for managing user peers associated with session IDs |
| CRequestService | Implements IRequestService to handle requests |
| CRpcProtocolService | Implements IRpcProtocolService to handle RPC protocol operations |
| CSessionService | Implements ISessionService to manage sessions |
| CUserPeerAuthTokenService | Implements IUserPeerAuthTokenService to handle authentication token generation and verification |
| CUserPeerService | Implements IUserPeerService to manage user peers |
| CUserPeerSessionService | Implements IUserPeerSessionService to manage user peers associated with session IDs |
| ►NSocket | |
| ►NContext | |
| CISocketServerContext | Provides an interface for the socket server context, extending IServerContext |
| ►CSocketServerContext | Represents the socket server context, implementing ISocketServerContext. This class is sealed to prevent inheritance |
| CBuilder | Provides a builder pattern for constructing instances of SocketServerContext |
| ►NControllers | |
| CProtonSocketController | Represents a specialized socket controller for handling operations in the Proton socket server |
| CSocketController | Represents an abstract base class for socket controllers that handle various events such as connection, data reception, errors, and disconnections |
| ►NExceptions | |
| CMissingSocketControllerException | Represents an exception that is thrown when a required socket controller is missing |
| ►NHandlers | |
| CAbstractOperationModelHandler | Provides an abstract base class for handling operations on socket sessions with a specific operation model type |
| CIOperationModelHandler | Defines a generic interface for handling operations on socket sessions with a specific operation model type |
| CISocketOperationModelHandler | Defines the interface for handling operations on socket sessions |
| COperationDisconnectHandler | Handles the OperationDisconnect by logging a warning since only the client should handle it |
| COperationEventHandler | Handles the OperationEvent by processing it and passing it to the event service |
| COperationHandshakeAckHandler | Handles the OperationHandshakeAck by logging a warning since only the client should handle it |
| COperationHandshakeHandler | Handles the OperationHandshake by verifying and establishing a session, and mapping the session to a user peer |
| COperationPingHandler | Handles the OperationPing by responding with an OperationPong |
| COperationPongHandler | Handles the OperationPong, but since it's only for clients, it does nothing on the server side |
| COperationRequestHandler | Handles the OperationRequest by processing it and sending a response back to the client |
| COperationResponseHandler | Handles the OperationResponse by logging a warning since only the client should handle it |
| ►NModels | |
| CISocketSessionTime | Defines the interface for tracking and managing time-related information for a socket session, such as connection time, handshake time, and the last received data time |
| CSocketSessionTime | Implements the ISocketSessionTime interface to track and manage time-related information for a socket session, such as connection time, handshake time, and the last received data time |
| ►NServer | |
| CIServer | Defines the interface for a server, providing methods to manage server operations such as starting, stopping, and restarting the server, as well as retrieving network statistics |
| CSocketSslServer | Represents a secure TCP server (SSL/TLS) that integrates with the ProtonNet framework, allowing for secure TCP communication within the socket server context |
| CSocketTcpServer | Represents a TCP server that integrates with the ProtonNet framework, allowing for TCP communication within the socket server context |
| CSocketUdpServer | Represents a UDP server that integrates with the ProtonNet framework, allowing for UDP communication within the socket server context |
| CSocketWsServer | Represents a WebSocket (WS) server that integrates with the ProtonNet framework, allowing for WebSocket communication within the socket server context |
| CSocketWssServer | Represents a WebSocket Secure (WSS) server that integrates with the ProtonNet framework, allowing for secure WebSocket communication within the socket server context |
| ►NServices | |
| CISocketControllerService | Defines the interface for a service that manages socket controller operations, including handling connections, data reception, disconnections, and errors for socket sessions |
| CISocketOperationModelService | Defines the interface for handling operations on socket sessions, allowing for the management and processing of different operation models based on their type |
| CISocketSessionEmitService | Defines the interface for a service responsible for emitting various operations (events, responses, requests, etc.) to socket sessions |
| CISocketSessionTimeService | Provides an interface for managing the session time service in a socket server |
| ►CSendOperationEventOptions | Represents options for sending an operation event, including the targeted receivers and protocols |
| CReceiverOptions | Defines the options for specifying the receivers of the operation event |
| CReceiverProtocolOptions | Defines the options for specifying the protocols through which the operation event should be sent |
| CSocketControllerService | Implements the ISocketControllerService interface to manage socket session events such as connection, data reception, disconnection, and errors. This service coordinates the handling of these events through registered socket controllers |
| CSocketOperationModelService | Implements the ISocketOperationModelService interface to manage and dispatch operations to the appropriate handlers based on the operation type |
| CSocketSessionEmitService | Implements the ISocketSessionEmitService interface to handle the emission of various operations (events, responses, etc.) to socket sessions, including encryption and protocol handling |
| CSocketSessionTimeService | Implements the ISocketSessionTimeService to manage session timeouts such as handshake and idle timeouts for socket sessions |
| ►NSessions | |
| CISocketSession | Defines the interface for a socket session, providing methods for sending data, managing session state, and handling encryption and session time |
| CSocketSslSession | Represents an SSL session for handling client connections, sending and receiving data, and managing session-specific state in a secure manner |
| CSocketTcpSession | Represents a TCP session for handling client connections, sending and receiving data, and managing session-specific state |
| CSocketUdpSession | Represents a UDP session for handling client connections, sending and receiving data, and managing session-specific state |
| CSocketWsSession | Represents a WebSocket (WS) session for handling client connections, sending and receiving data, and managing session-specific state |
| CSocketWssSession | Represents a WebSocket Secure (WSS) session for handling client connections, sending and receiving data, and managing session-specific state |
| ►CAuthTokenSettings | Settings auth token service |
| CBuilder | Builder for ThreadPoolSizeSettings |
| ►CDebugSocketServerEntry | Represents a debug implementation of ISocketServerEntry for creating and configuring a socket server specifically for debugging purposes |
| CBuilder | Builder class for constructing instances of DebugSocketServerEntry |
| CISocketServer | Defines the interface for a socket server, including methods to start and stop the server, and to retrieve the server context and network statistics |
| CISocketServerEntry | Represents an entry point for obtaining an instance of ISocketServer |
| ►CSessionConfigSettings | Represents the session configuration settings, including various TCP and buffer settings for optimizing network communication |
| CBuilder | Builder class for constructing instances of SessionConfigSettings |
| CSocketServer | Represents the implementation of the SocketServer class, providing methods to initialize, start, and stop the server, along with various utility and configuration methods |
| ►CSocketServerEntry | Provides an implementation of ISocketServerEntry for creating and configuring socket servers |
| CBuilder | Builder class for constructing instances of SocketServerEntry |
| ►CSslConfigSettings | Represents the SSL configuration settings, including enabling SSL, port number, certificate file path, and certificate password |
| CBuilder | Builder class for constructing instances of SslConfigSettings |
| ►CStartupSettings | Represents the startup configuration settings, including session limits, timeout settings, and server configurations for TCP, UDP, and WebSocket |
| CBuilder | Builder class for constructing instances of StartupSettings |
| ►CTcpServerSettings | Represents the TCP server configuration settings, including enabling the server, address, port, session configuration, and SSL configuration |
| CBuilder | Builder class for constructing instances of TcpServerSettings |
| ►CThreadPoolSizeSettings | Represents the settings for thread pool size, specifically for different types of fibers |
| CBuilder | Builder class for constructing instances of ThreadPoolSizeSettings |
| ►CUdpServerSettings | Represents the UDP server configuration settings, including enabling the server, address, port, and session configuration |
| CBuilder | Builder class for constructing instances of UdpServerSettings |
| ►CUdpSessionConfigSettings | Represents the UDP session configuration settings, including dual-mode, address reuse, exclusive address use, and buffer limits and capacities |
| CBuilder | Builder class for constructing instances of UdpSessionConfigSettings |
| ►CWebSocketServerSettings | Represents the WebSocket server configuration settings, including enabling the server, address, port, maximum frame size, session configuration, and SSL configuration |
| CBuilder | Builder class for constructing instances of WebSocketServerSettings |
| ►NWebApi | |
| ►NContext | |
| CIWebApiServerContext | Represents the context for a Web API server |
| ►CWebApiServerContext | Provides an implementation of the WebApiServerContext |
| CBuilder | Builder class for constructing instances of WebApiServerContext |
| ►NControllers | |
| ►NAttribute | |
| CFromAutoBindAttribute | Attribute used to automatically bind a method parameter to a specific type or use default auto-binding |
| CFromBodyBytesAttribute | Specifies that a parameter should be bound from the body of the HTTP request as raw bytes |
| CFromHeaderAttribute | Specifies that a parameter should be bound from the HTTP request headers |
| CFromHttpParamAttribute | Abstract base attribute for specifying how a parameter should be bound from an HTTP request |
| CFromMiddlewareContextAttribute | Attribute for specifying that a parameter should be bound from the middleware context |
| CFromParamAttribute | Attribute for specifying that a parameter should be bound from a specific HTTP parameter |
| CFromQueryAttribute | Attribute for specifying that a parameter should be bound from the query string in an HTTP request |
| CHttpGetAttribute | Attribute for marking methods as handling HTTP GET requests |
| CHttpMethodAttribute | Base class for HTTP method attributes |
| CHttpMiddlewareAttribute | Represents an HTTP middleware attribute for web requests |
| CHttpPostAttribute | Specifies an HTTP POST route for a web request |
| CHttpWebAttribute | Specifies an HTTP GET route for a web request |
| CRouteAttribute | Specifies a route for a class in a web application |
| ►NRender | |
| ►NFactory | |
| CAbstractContentFactory | Provides a base implementation for a content factory that manages content |
| CIContentFactory | Defines the contract for a content factory that can set up content and retrieve it by name |
| CILayoutContentFactory | Defines the contract for a layout content factory that manages layout content |
| CIPartialContentFactory | Defines the contract for a partial content factory that manages and processes partial content |
| CIRawHtmlContentFactory | Defines the contract for a factory that handles raw HTML templates, including generating and retrieving them based on views and layouts |
| CIViewContentFactory | Defines the contract for a factory that manages and retrieves view content |
| CLayoutContentFactory | Provides the implementation for handling layout content, including loading and retrieving layouts |
| CPartialContentFactory | Provides the implementation for handling partial content, including loading, processing, and replacing partial tags within content |
| CRawHtmlContentFactory | Provides an implementation for handling raw HTML content templates, including generating new templates based on views and layouts, and managing session and view data |
| CViewContentFactory | Provides an implementation for handling view content, including loading and processing views, managing layout overrides, and handling session content |
| ►NModels | |
| CGetViewDataElement | Represents an implementation of IGetViewDataElement, used to retrieve a specific view data element by its name |
| CIGetViewDataElement | Defines the contract for an element that retrieves view data by name |
| CILayoutContent | Defines the contract for layout content, including the name, original content, and processed content with partial renders |
| CIPartialContent | Defines the contract for partial content, including the name, original content, and processed content with partial renders |
| CIPinitElement | Defines the contract for an initialization element that contains a collection of set view data elements |
| CIRawHtmlTemplate | Defines the contract for a raw HTML template, including the name, content, renderable view data elements, and initialization elements |
| CIRenderViewDataElement | Defines the contract for an element that is responsible for rendering view data in a template, including its name and original content |
| CISessionContent | Defines the contract for session content, including the name, original content, and processed content with partial renders |
| CISetViewDataElement | Defines the contract for an element that sets view data, including its name and value |
| CIView | Defines the contract for a view that holds the HTML content to be rendered |
| CIViewContent | Defines the contract for view content, which includes the original content, processed content, session-related data, and layout override information |
| CLayoutContent | Represents the implementation of ILayoutContent, holding both the original and processed content of a layout, including partial renders |
| CPartialContent | Represents the implementation of IPartialContent, holding both the original and processed content of a partial, including partial renders |
| CPinitElement | Represents the implementation of IPinitElement, holding an array of elements used to set view data during initialization |
| CRawHtmlTemplate | Represents the implementation of IRawHtmlTemplate, holding the name, content, renderable view data elements, and initialization elements for the template |
| CRenderViewDataElement | Represents the implementation of IRenderViewDataElement, holding the name and original content of the view data element to be rendered |
| CSessionContent | Represents the implementation of ISessionContent, holding the name, original content, and processed content of a session, including partial renders |
| CSetViewDataElement | Represents the implementation of ISetViewDataElement, holding the name and value of the view data element |
| CView | Represents a concrete implementation of the IView interface, which holds the HTML content to be rendered |
| CViewContent | Represents the implementation of IViewContent, which includes the name, original content, processed content, layout override, and session contents |
| CConstance | |
| CIViewEngine | Defines the contract for a view engine that processes templates and renders views with data |
| CViewEngine | Implements the IViewEngine interface to process templates and render views |
| ►NSupport | |
| CIBeforeWebApiControllerResponse | Defines a handler that processes the final response before sending it back to the client in the Web API pipeline |
| CAbstractWatch | Provides a base class for file system watching with support for resource disposal |
| CBufferCache | Implementation of a buffer cache that stores byte arrays using a thread-safe dictionary |
| CFileCacheWatch | Monitors changes to a specific file and updates the cache accordingly |
| CFolderCacheWatch | Monitors changes to files and folders within a specified directory and updates the cache accordingly |
| CIBufferCache | Interface for a buffer cache that stores byte arrays |
| CICache | Interface for a cache that handles key-value pairs |
| CIStaticCache | Defines the contract for a static cache that stores files and folders and provides methods to manage and access them |
| CIWatchCache | Interface for a watch cache that stores instances of AbstractWatch objects |
| CProtonWebApiController | Controller for handling Proton Web API requests |
| CStaticCache | Implements a static cache for managing files and folders with optional watching and auto-updating capabilities |
| CWatchCache | Implementation of a watch cache that stores instances of AbstractWatch using a thread-safe dictionary |
| CWebApiController | Abstract base class for Web API controllers |
| ►NExceptions | |
| CMethodControllerInvalidException | Exception thrown when a method controller is invalid |
| CMethodParameterControllerInvalidException | Exception thrown when a method parameter is invalid in the context of a controller |
| ►NModels | |
| CGenerateParameterData | Represents the data used for generating parameters for method invocation |
| CHttpRequest | Represents an HTTP request, inheriting from ProtonNetCommon.HttpRequest |
| CIViewData | Represents a collection of key-value pairs used to store data for rendering views |
| CMethodController | Represents a controller for handling methods, including method information and controllers for different prefixes |
| CMethodInformation | Represents information about a method, including its parameters and how to generate those parameters |
| CMethodInvokeInformation | Represents information about a method invocation, including its prefix |
| CMiddlewareContext | Represents the context for middleware operations, allowing storage and retrieval of data |
| CQueryItem | Represents a query parameter item containing a key and its associated value |
| CViewData | Represents a collection of key-value pairs used to store data for rendering views |
| CViewResult | Represents a response from the server that is intended to be rendered as a view |
| ►NServer | |
| CISubServer | Defines the contract for a sub-server, including methods for starting, stopping, and restarting the server, as well as retrieving network statistics |
| CWebApiHttpServer | Represents an HTTP server for handling Web API requests, inheriting from HttpServer and implementing ISubServer |
| CWebApiHttpsServer | Represents an HTTPS server for handling Web API requests, inheriting from HttpsServer and implementing ISubServer |
| ►NServices | |
| CIWebApiControllerService | Defines methods for managing Web API controllers, handling static content, middleware, and request routing |
| CWebApiControllerService | |
| CWebApiInitRequestProviderService | Provides initialization requests for Web API sessions |
| ►NSessions | |
| CIWebApiSession | Defines the methods and properties for a Web API session |
| CWebApiHttpSession | Represents an HTTP session in the Web API server |
| CWebApiHttpsSession | Represents an HTTPS session in the Web API server |
| ►CAuthTokenSettings | Settings auth token service |
| CBuilder | Builder for ThreadPoolSizeSettings |
| ►CDebugWebApiServerEntry | Represents an entry point for a debug web API server. Implements IWebApiServerEntry to provide server creation |
| CBuilder | Builder class for creating instances of DebugWebApiServerEntry |
| ►CHttpServerSettings | Settings HttpServer |
| CBuilder | Builder for HttpServerSettings |
| CIWebApiServer | Interface for web API server operations |
| CIWebApiServerEntry | Interface for web API server entry |
| ►CSessionConfigSettings | Settings SessionConfig |
| CBuilder | Builder for SessionConfigSettings |
| ►CSslConfigSettings | Settings ssl config |
| CBuilder | Builder for SslConfigSettings |
| ►CStartupSettings | Startup Settings |
| CBuilder | Builder for StartupSettings |
| ►CThreadPoolSizeSettings | Settings thread pool size |
| CBuilder | Builder for ThreadPoolSizeSettings |
| CWebApiServer | Represents the partial implementation of the WebApiServer class, which provides functionalities for managing the Web API server operations, including startup, shutdown, and managing various server services |
| ►CWebApiServerEntry | Implementation of the IWebApiServerEntry interface |
| CBuilder | Builder for WebApiServerEntry |
| ►NToken | |
| ►NAlgorithm | |
| CHMACTokenAlgorithmEncode | Implements the ITokenAlgorithmEncode interface using HMAC for encryption |
| CITokenAlgorithmEncode | Defines a method for encrypting data |
| CKeyedHashAlgorithmTokenAlgorithmEncode | Implements the ITokenAlgorithmEncode interface using KeyedHashAlgorithm for encryption |
| CMD5TokenAlgorithmEncode | Implements the ITokenAlgorithmEncode interface using MD5 for encryption |
| CSHA1TokenAlgorithmEncode | Implements the ITokenAlgorithmEncode interface using SHA1 for encryption |
| CSHA256TokenAlgorithmEncode | Implements the ITokenAlgorithmEncode interface using SHA256 for encryption |
| CSHA384TokenAlgorithmEncode | Implements the ITokenAlgorithmEncode interface using SHA384 for encryption |
| CSHA512TokenAlgorithmEncode | Implements the ITokenAlgorithmEncode interface using SHA512 for encryption |
| ►NAttributes | |
| CTokenMemberAttribute | Specifies that a property is a member of a token and associates it with a code |
| ►NBinary | |
| CITokenBinaryDecode | Defines methods for deserializing binary data |
| CITokenBinaryEncode | Defines methods for serializing data into binary format |
| CProtocolTokenBinaryDecode | Implements the ITokenBinaryDecode interface for deserializing binary data |
| CProtocolTokenBinaryEncode | Implements the ITokenBinaryEncode interface for serializing data into binary format |
| ►NDeserialize | |
| CITokenDeserializer | Provides methods for deserializing token headers and payloads |
| CTokenDeserializer | Implementation of ITokenDeserializer that handles the deserialization of token headers and payloads |
| ►NExceptions | |
| CTokenException | Represents the base class for exceptions that occur during token processing |
| CTokenExpiredException | Represents an exception that is thrown when a token has expired |
| CTokenSignatureInvalidException | Represents an exception that is thrown when a token's signature is invalid |
| CTokenStringInvalidException | Represents an exception that is thrown when a token string is invalid |
| ►NFactory | |
| CITokenAlgorithmFactory | Provides a method to retrieve an encoder based on the TokenAlgorithmType |
| CITokenBinaryFactory | Provides methods for obtaining binary encoding and decoding implementations based on the specified TokenBinaryType |
| CTokenAlgorithmFactory | Factory class that provides instances of algorithm encoding based on TokenAlgorithmType |
| CTokenBinaryFactory | Factory class that provides instances of binary encoding and decoding based on TokenBinaryType |
| ►NModels | |
| CITokenHeader | Represents the interface for token header information |
| CITokenPayload | Represents the interface for token payload data |
| CTokenHeader | Implementation of the token header interface |
| CTokenPayload | Implementation of a basic token payload |
| ►NSerialize | |
| CITokenSerializer | Interface for token serialization operations |
| CTokenSerializer | Implementation of the token serializer interface |
| ►NServices | |
| CITokenMemberPropertyService | This interface defines a service that retrieves properties for a given type |
| CTokenMemberPropertyService | A concrete implementation of the ITokenMemberPropertyService. This class caches the properties of types that have the TokenMemberAttribute applied |
| CAuthToken | Implements the IAuthToken interface for encoding, decoding, and verifying authentication tokens |
| CIAuthToken | Defines the methods for encoding, decoding, and verifying authentication tokens |
| CTokenOptions | Represents the options for configuring token generation and validation |
| ►NProtonNetClient | |
| ►NOptions | |
| CTcpClientOptions | Represents the configuration options for a TCP client. Provides properties to configure various TCP settings such as dual mode, keep-alive, buffer sizes, and more |
| CUdpClientOptions | Represents the configuration options for a UDP client. Provides properties to configure various UDP settings such as dual mode, address reuse, multicast, buffer sizes, and more |
| CHttpClient | Represents an HTTP client that handles sending requests and receiving responses over a TCP connection |
| CHttpsClient | Represents an HTTPS client that handles sending requests and receiving responses over an SSL/TLS-encrypted TCP connection |
| CIClient | Defines the interface for a client that can connect, disconnect, and send data over a network. Supports both synchronous and asynchronous operations |
| CIHttpClient | Defines the interface for an HTTP client that can send requests and handle responses over a network. Inherits from IClient |
| CITcpClient | Represents the interface for a TCP client that can connect, disconnect, and send data over a network |
| CIUdpClient | Defines the interface for a UDP client that can connect, disconnect, send, and receive data over a network. Supports both synchronous and asynchronous operations |
| CIWsClient | Defines the interface for a WebSocket client that can send and receive various types of data frames over a network |
| CSslClient | Implements an SSL/TLS client for secure communication over a TCP connection |
| CTcpClient | Implements a TCP client for connecting to a server, sending, and receiving data. Provides both synchronous and asynchronous operations |
| CUdpClient | Implements a UDP client for sending and receiving data over a network. Provides both synchronous and asynchronous operations |
| CWsClient | Implements a WebSocket client over an HTTP connection. Supports both synchronous and asynchronous operations |
| CWssClient | Implements a WebSocket Secure (WSS) client over an HTTPS connection. Supports both synchronous and asynchronous operations |
| ►NProtonNetCommon | |
| ►NTypes | |
| CWebSocketOpCodes | This class contains constant byte values representing WebSocket operation codes |
| CChangeNetworkStatistics | Class that implements IChangeNetworkStatistics, providing methods to modify and retrieve network statistics |
| CChangeServerNetworkStatistics | Class that implements IChangeServerNetworkStatistics, providing methods to modify and retrieve server network statistics |
| CHttpRequest | Represents an HTTP request with properties for the method, URL, protocol, headers, cookies, and body |
| CHttpResponse | Represents an HTTP response, encapsulating the protocol, status, headers, cookies, and body of the response |
| CIChangeNetworkStatistics | Interface for modifying network statistics |
| CIChangeServerNetworkStatistics | Interface for modifying server network statistics |
| CIMemoryBuffer | Interface defining the operations for a memory buffer |
| CINetworkStatistics | Interface for retrieving network statistics |
| CIServerNetworkStatistics | Interface for retrieving server network statistics |
| CIWebSocket | Interface defining the contract for WebSocket operations and events |
| CMemoryBuffer | Implementation of the IMemoryBuffer interface, providing methods to manage a byte buffer |
| CNetworkStatistics | Class that implements INetworkStatistics, providing basic retrieval of network statistics |
| CServerNetworkStatistics | Class that implements IServerNetworkStatistics, providing basic retrieval of server network statistics |
| CSslOptions | Represents the SSL/TLS context used for secure communications |
| CWebSocket | An implement of interface WebSocket |
| ►NProtonNetServer | |
| ►NOptions | |
| CTcpServerOptions | Represents the configuration options for the TCP server |
| CUdpServerOptions | Represents the configuration options for the UDP server |
| CHttpServer | Represents an HTTP server, inheriting from the TcpServer class |
| CHttpSession | Represents an HTTP session, inheriting from the TcpSession class |
| CHttpsServer | Represents an HTTPS server, inheriting from the SslServer class |
| CHttpsSession | Represents an HTTPS session, inheriting from the SslSession class |
| CIHttpServer | Represents an interface for an HTTP server, inheriting from the IServer interface |
| CIHttpSession | Represents an interface for an HTTP session, inheriting from the ISession interface |
| CIServer | Represents the interface for a server, providing methods for starting, stopping, and managing connections and data broadcasts |
| CISession | Represents the interface for a session, providing methods for managing the connection, sending data, and retrieving network statistics |
| CITcpServer | Represents the interface for a TCP server |
| CITcpSession | Represents an interface for TCP session operations |
| CIUdpServer | Defines the interface for a UDP server, extending the basic server functionalities |
| CIUdpSession | Represents the interface for a UDP session |
| CIWsServer | Represents the interface for a WebSocket server, providing methods for broadcasting and closing WebSocket connections |
| CIWsSession | Represents the interface for a WebSocket session, providing methods for sending various WebSocket frames |
| CSslServer | Represents an SSL server that can handle multiple secure client sessions |
| CSslSession | Represents a secure SSL session with the ability to manage connection, data transmission, and handshake processes |
| CTcpServer | Represents a TCP server that can handle multiple client sessions |
| CTcpSession | Provides the implementation for a TCP session, handling connection, data transmission, and disconnection |
| CUdpServer | Represents a UDP server that provides functionalities for managing UDP connections and data transmission |
| CUdpSession | Represents a UDP session that handles communication with a remote endpoint |
| CWsServer | Represents a WebSocket server that inherits from HttpServer and implements WebSocket functionality |
| CWsSession | Represents a WebSocket session that inherits from HttpSession and implements WebSocket functionality |
| CWssServer | Represents a secure WebSocket server that inherits from HttpsServer and implements WebSocket functionality |
| CWssSession | Represents a secure WebSocket session that inherits from HttpsSession and implements WebSocket functionality |
| ►NThreading | |
| ►NAgent | |
| CEnqueueAgent | Manages and processes tasks that need to be executed. Implements task enqueuing and processing with statistics tracking |
| CIEnqueueInternal | Provides methods for enqueuing tasks that will be executed |
| CScheduleAgent | Manages and services tasks that are scheduled to run at a specific time |
| CScheduleOnIntervalAgent | Manages and services tasks that are scheduled to run at regular intervals |
| ►NModels | |
| CIScheduleOnIntervalTask | Represents a scheduled task that repeats at regular intervals |
| CIScheduleTask | Represents a scheduled task that can be invoked and checked for its running status |
| CISingleTask | Represents a single task that can be invoked |
| CScheduleOnIntervalTask | Provides an implementation of a scheduled task that repeats at regular intervals |
| CScheduleTask | Provides an implementation of a scheduled task with an action and state management |
| CSingleTask | Provides an implementation of a single task with an action |
| ►NStatisticsCounter | |
| CIStatisticsCounter | Defines methods for accessing statistics related to task execution |
| CIStatisticsCounterChange | Defines methods for changing statistics counters |
| CStatisticsCounterAgent | Implements statistics counters with thread-safe operations |
| CIEnqueue | Defines the contract for enqueuing tasks |
| CIFiber | Defines the contract for a fiber that supports task enqueueing, scheduling, and interval scheduling |
| CIFiberControl | Defines the contract for controlling a fiber, including starting and disposing of it |
| CIFiberStatisticsCounter | Defines the contract for accessing various statistics counters related to fibers |
| CISchedule | Defines the contract for scheduling tasks |
| CIScheduleOnInterval | Defines the contract for scheduling tasks to run at regular intervals |
| CIService | Defines the contract for a service that performs a specific action |
| CPoolFiber | Represents a pool of fibers that can enqueue tasks, schedule tasks, and schedule tasks at regular intervals |
| CRoundRobinEnqueueAgent | Represents an enqueue agent that uses a round-robin scheduling strategy for task execution |
| CRoundRobinFiber | Represents a fiber that uses a round-robin scheduling strategy for task execution |
| CThreadFiber | Represents a fiber that uses a dedicated thread for task execution and scheduling |