InvalidProgramException on RPCs when using serialization extensions

[Taenebron]

Describe the bug
Types serialized via ReadValueSafe and WriteValueSafe cannot be used in RPCs. InvalidProgramException is thrown.

To Reproduce
Steps to reproduce the behavior:

1. Create a custom type to serialize (class/struct).
2. Create custom type serialization extensions ReadValueSafe and WriteValueSafe for that type, placed in a static class SerializationExtensions as in documentation examples.
3. Create Server/Client RPCs that pass our custom type as one of the parameters.
4. At runtime, call the RPC.

Actual outcome
When RPC is called Unity throws the following exception (in my case):
InvalidProgramException: Invalid IL code in Code.Eclipse.ItemSystem.Player.PlayerDetails:DropItemServerRpc (Code.Eclipse.ItemSystem.EclipseItemSystem.ItemBase): IL_00dd: call 0x06000b65
RPC is not sent.

Expected outcome
The client and server should be able to send RPC containing custom type successfully,

Environment:

• OS: Windows 10
• Unity Version: 2021.2.0b16
• Netcode Version: v1.0.0-pre.2

Additional context
I use this serialization method for various purposes like replicating items via factory method pattern (classes), sending player-data (struct), or passing player object context. None of these can be passed via RPCs. Passing them via a named messaging system works as expected. Passing INetworkSerializable types in RPCs works as expected.

[ShadauxCat]

Can you give me a specific code example? We have some tests that exercise the extension method procedure and they don't cause this, so I'd like to see an example of a type definition you're trying to serialize and the ReadValueSafe and WriteValueSafe implementations for it so I can try to reproduce the issue and figure out what's up.

[deibu]

I am also running into this issue. I created a class with byte and string fields, and was only able to get it to serialize via RPC if I created a BufferSerializer extension method. When I created a FastBufferReader extension method for my class, it would throw the Invalid IL code error.

edit: the extension method to BufferSerializer was doing nothing. I actually was RPCing a struct and not a class.

[ShadauxCat]

@deibu RPCs don't even use BufferSerializer, so I'm surprised that compiled and didn't throw an error about not knowing how to serialize your type. But same ask - can you provide some specific example code that doesn't work? (Also, I would be interested in seeing specific example code that does work using BufferSerializer, because it shouldn't work and I would like to try to understand why it does. I'm suspicious it might not be doing quite what you think, but without seeing it, I can't say for sure.)

[Taenebron]

In my case, code as simple as:

//namespace Code.Eclipse.ItemSystem.Player
//Code from: pulic class PlayerDetails : NetworkBehaviour
public override void OnNetworkSpawn()
{
    TestingStruct str = new TestingStruct();
    str.txt = "Hello world!";
    str.a = 0;
    str.b = 4;
    str.c = 4.0f;
    //Sending from server to server. Replacing it with type like string fixes the issue.
    //Also tried to use it from other functions.
    SendTestDataServerRpc(str);
}

[ServerRpc]
public void SendTestDataServerRpc(TestingStruct testingStruct)
{
    Debug.Log($"Message is:{testingStruct.txt}");
}

//Outside of class. Same file.
public struct TestingStruct
{
    public ushort a;
    public int b;
    public float c;
    public string txt;
}

//Code from: public static class SerializationExtensions
//namespace Code.Eclipse.Networking

//When the test type is a struct and serialization not implemented: serialization seems to be automatic.
//When test type is class and serialization not implemented: compilation error occurs: 'Don't know how to serialize TestingStruct'.
//When Read/WriteValueSafe are implemented to define serialization IL errors occur on Rpc calls.

public static void ReadValueSafe(this FastBufferReader reader, out TestingStruct value)
{
    value = new TestingStruct();
    reader.ReadValueSafe(out value.a);
    reader.ReadValueSafe(out value.b);
    reader.ReadValueSafe(out value.c);
    reader.ReadValueSafe(out value.txt);
}

public static void WriteValueSafe(this FastBufferWriter writer, in TestingStruct value)
{
    writer.WriteValueSafe(value.a);
    writer.WriteValueSafe(value.b);
    writer.WriteValueSafe(value.c);
    writer.WriteValueSafe(value.txt);
}

Causes the same IL error at the SendTestDataServerRPC call. I did not try it in an isolated project.

InvalidProgramException: Invalid IL code in Code.Eclipse.ItemSystem.Player.PlayerDetails:SendTestDataServerRpc (Code.Eclipse.ItemSystem.TestingStruct): IL_00dd: call      0x06000b73

Code.Eclipse.ItemSystem.Player.PlayerDetails.OnNetworkSpawn () (at Assets/Code/Eclipse/ItemSystem/Player/PlayerDetails.cs:132)

This example, of course, works when a custom type is replaced by a string or int in RPC parameters.

[deibu]

@deibu RPCs don't even use BufferSerializer, so I'm surprised that compiled and didn't throw an error about not knowing how to serialize your type. But same ask - can you provide some specific example code that doesn't work? (Also, I would be interested in seeing specific example code that does work using BufferSerializer, because it shouldn't work and I would like to try to understand why it does. I'm suspicious it might not be doing quite what you think, but without seeing it, I can't say for sure.)

public class Foo
{
    public string Text;
}

public static class SerializationExtensions
{
    public static void ReadValueSafe(this FastBufferReader reader, out Foo value)
    {
        reader.ReadValueSafe(out string text);
        value = new Foo() { Text = text};
    }

    public static void WriteValueSafe(this FastBufferWriter writer, in Foo value)
    {
        writer.WriteValueSafe(value.Text);
    }
}

Here's a basic example of what I'm doing.

In the case of it working without having the extension method to FastBufferReader/Writer, I actually changed Foo to be a struct instead of a class.

[ShadauxCat]

In the case of it working without having the extension method to FastBufferReader/Writer, I actually changed Foo to be a struct instead of a class (not sure why that allowed it to send over an RPC though).

edit: I removed the extension method I wrote to BufferSerializer, and the struct is still able to be sent over an RPC.

So any struct that's unmanaged can be serialized automatically via memcpy. This is what I was worried was happening for you... because your struct includes a string, it shouldn't be considered unmanaged. So the fact that this value is accepted is also a bug. I'll have to look at the code generation to see why it's thinking that struct is unmanaged - I have a strong suspicion the string you get on the other end is probably not valid.

[Taenebron]

In the case of it working without having the extension method to FastBufferReader/Writer, I actually changed Foo to be a struct instead of a class (not sure why that allowed it to send over an RPC though).

edit: I removed the extension method I wrote to BufferSerializer, and the struct is still able to be sent over an RPC.

So any struct that's unmanaged can be serialized automatically via memcpy. This is what I was worried was happening for you... because your struct includes a string, it shouldn't be considered unmanaged. So the fact that this value is accepted is also a bug. I'll have to look at the code generation to see why it's thinking that struct is unmanaged - I have a strong suspicion the string you get on the other end is probably not valid.

In my case, exception still happened, even if I removed any string: either in struct or class.

[ShadauxCat]

Right, if you have a FastBufferWriter or FastBufferReader extension method, for RPCs, that'll override the normal memcpy implementation, so even if it's eligible for memcpy, you would get the exception because it'd choose your extension instead.

[ShadauxCat]

@Taenebron Thank you for the sample code. I have managed to reproduce it and am working on a fix.

In the mean time, you can get around the issue by making the first parameter this ref instead of this.