Скачать или смотреть How to Correctly Pass a Callback from C# to C in Unity

Discover how to effectively pass a callback from your C# Unity script to a C/DLL. Learn to handle static variables and the One Definition Rule in this comprehensive guide.
---
This video is based on the question https://stackoverflow.com/q/64141126/ asked by the user 'Sirop4ik' ( https://stackoverflow.com/u/5709159/ ) and on the answer https://stackoverflow.com/a/64141394/ provided by the user 'Caleth' ( https://stackoverflow.com/u/2610810/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: How to pass callback from C# to C correctly?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
How to Correctly Pass a Callback from C# to C in Unity

When working with Unity, you may encounter situations where you need to interact with a C/C+ + DLL. One common requirement is to pass callbacks from your C# scripts to the native side. This integration can become confusing, especially when dealing with static variables and function pointers. In this post, we will delve into how to effectively pass a callback delegate from a C# Unity script to a DLL, ensuring smooth communication between the two environments.

The Problem

In a typical scenario, you might define a callback function in your C+ + DLL intended to log messages from Unity. Here's an example of a function pointer defined in a header file for your DLL:

[[See Video to Reveal this Text or Code Snippet]]

This pointer is designed to be assigned to a function that can be invoked later to log messages. However, if you find that after registering the callback the pointer still points to null when you try to use it, you're likely facing the One Definition Rule (ODR) issue. This can lead to the situation where your static variable behaves as though it is local to the translation unit rather than globally accessible.

The Solution

To fix this issue, you need to adhere to proper declarations and ensure that you have only one definition of your static variable across your translation units. Here’s how to do that step by step:

Step 1: Header File Declaration

In your header file, ensure that you declare the function pointer as extern. This tells the compiler that the storage for this variable is defined in another translation unit (your .cpp file). Here’s how your MyApi.h should look:

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Implementation File Definition

In your implementation file (MyApi.cpp), actually define your static variable and implement the behavior of your API functions like so:

[[See Video to Reveal this Text or Code Snippet]]

Step 3: Usage in Other Files

Now, in your other C+ + files (like myfile.cpp), you can freely invoke the debug_in_unity() function, confident that the DebugLog pointer maintains its value:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

By following these steps, you ensure that you are correctly passing callbacks from your C# scripts into your C/C+ + DLL without falling prey to the ODR problem. Keeping your declarations in headers while maintaining definitions in single implementation files allows for consistent variable referencing across your project. Adhering to this structure not only promotes good coding practices but also significantly reduces bugs related to variable scope.

If you are developing with Unity and C/C+ + , remember to carefully manage your interactions between C# and C/C+ + to enable smooth communication and avoid pitfalls related to static variables and callbacks.