docs.unity3d.com
Search Results for

    Show / Hide Table of Contents

    Struct RpcCollection

    The RpcCollection is the set of all available RPCs. It is created by the RpcSystem. It is used to register RPCs and to get queues for sending RPCs. In most cases you do not need to use it directly, the generated code will use it to setup the RPC components.

    Implements
    IComponentData
    IQueryTypeParameter
    Inherited Members
    ValueType.Equals(object)
    ValueType.GetHashCode()
    object.Equals(object, object)
    object.GetType()
    object.ReferenceEquals(object, object)
    Namespace: Unity.NetCode
    Assembly: Unity.NetCode.dll
    Syntax
    public struct RpcCollection : IComponentData, IQueryTypeParameter

    Properties

    DynamicAssemblyList

    Allows the set assemblies loaded on the client and server to differ. This is useful during development when assemblies containing ghost component serializers or RPCs are removed when building standalone. This usually happens during development when you are connecting a standalone player to the Editor. For example, tests are usually not included in a standalone build, but they are still compiled and registered in the Editor, which causes a mismatch in the set of assemblies.

    If set to false (default), the RPC system triggers an RPC version error when connecting to a server with a different set of assemblies. This is more strict and acts as a validation step during handshake.

    If set to true, six bytes is added to the header of each RPC. The RPC system doesn't trigger an RPC version error when connecting to a server with a different set of assemblies. Instead, an error will be triggered if an invalid RPC or serialized component is received.

    Declaration
    public bool DynamicAssemblyList { get; set; }
    Property Value
    Type Description
    bool

    Methods

    GetRpcHeaderLength(bool)

    The RPC "common header" format is 9 bytes:

    • Message Type: byte
    • LocalTime: int (a.k.a. remoteTime on the receiver)

    And then, for each RPC, the header is:

    • RpcHash: [short|long] (based on DynamicAssemblyList)
    • Size: ushort
    • Payload : x bytes

    So for a single message we have:

    • 9 (common header) + 4 => 13 bytes (no DynamicAssemblyList)
    • 9 (common header) + 10 => 19 bytes (with DynamicAssemblyList)
    Declaration
    public static int GetRpcHeaderLength(bool dynamicAssemblyList)
    Parameters
    Type Name Description
    bool dynamicAssemblyList

    Whether or not your project is using DynamicAssemblyList.

    Returns
    Type Description
    int

    If DynamicAssemblyList, 15 bytes, otherwise 9 bytes.

    GetRpcQueue<TActionRequestAndSerializer>()

    Get an RpcQueue which can be used to send RPCs.

    Declaration
    public RpcQueue<TActionRequestAndSerializer, TActionRequestAndSerializer> GetRpcQueue<TActionRequestAndSerializer>() where TActionRequestAndSerializer : struct, IComponentData, IRpcCommandSerializer<TActionRequestAndSerializer>
    Returns
    Type Description
    RpcQueue<TActionRequestAndSerializer, TActionRequestAndSerializer>

    RpcQueue<TActionSerializer, TActionRequest> to be used to send RPCs.

    Type Parameters
    Name Description
    TActionRequestAndSerializer

    Struct of type TActionRequestAndSerializer implementing IRpcCommandSerializer<T>.

    GetRpcQueue<TActionSerializer, TActionRequest>()

    Get an RpcQueue which can be used to send RPCs.

    Declaration
    public RpcQueue<TActionSerializer, TActionRequest> GetRpcQueue<TActionSerializer, TActionRequest>() where TActionSerializer : struct, IRpcCommandSerializer<TActionRequest> where TActionRequest : struct, IComponentData
    Returns
    Type Description
    RpcQueue<TActionSerializer, TActionRequest>

    RpcQueue<TActionSerializer, TActionRequest> to be used to send RPCs.

    Type Parameters
    Name Description
    TActionSerializer

    Struct of type IRpcCommandSerializer<T>

    TActionRequest

    Struct of type Unity.Entities.IComponentData

    RegisterRpc(ComponentType, PortableFunctionPointer<ExecuteDelegate>)

    Register a new RPC type which can be sent over the network. This must be called before any connections are established.

    Declaration
    public void RegisterRpc(ComponentType type, PortableFunctionPointer<RpcExecutor.ExecuteDelegate> exec)
    Parameters
    Type Name Description
    ComponentType type

    Type to register.

    PortableFunctionPointer<RpcExecutor.ExecuteDelegate> exec

    Callback for RPC to execute.

    RegisterRpc<TActionRequestAndSerializer>()

    Register a new RPC type which can be sent over the network. This must be called before any connections are established.

    Declaration
    public void RegisterRpc<TActionRequestAndSerializer>() where TActionRequestAndSerializer : struct, IComponentData, IRpcCommandSerializer<TActionRequestAndSerializer>
    Type Parameters
    Name Description
    TActionRequestAndSerializer

    A struct of type IComponentData, with IRpcCommandSerializer too.

    RegisterRpc<TActionSerializer, TActionRequest>()

    Register a new RPC type which can be sent over the network. This must be called before any connections are established.

    Declaration
    public void RegisterRpc<TActionSerializer, TActionRequest>() where TActionSerializer : struct, IRpcCommandSerializer<TActionRequest> where TActionRequest : struct, IComponentData
    Type Parameters
    Name Description
    TActionSerializer

    A struct of type IRpcCommandSerializer.

    TActionRequest

    A struct of type IComponent.

    Implements

    Unity.Entities.IComponentData
    Unity.Entities.IQueryTypeParameter
    In This Article
    Back to top
    Copyright © 2025 Unity Technologies — Trademarks and terms of use
    • Legal
    • Privacy Policy
    • Cookie Policy
    • Do Not Sell or Share My Personal Information
    • Your Privacy Choices (Cookie Settings)