com.wallstop-studios.dxmessaging 1.0.0-rc10

package/.gitattributes

@@ -0,0 +1,63 @@
+###############################################################################
+# Set default behavior to automatically normalize line endings.
+###############################################################################
+* text=auto
+
+###############################################################################
+# Set default behavior for command prompt diff.
+#
+# This is need for earlier builds of msysgit that does not have it on by
+# default for csharp files.
+# Note: This is only used by command line
+###############################################################################
+#*.cs     diff=csharp
+
+###############################################################################
+# Set the merge driver for project and solution files
+#
+# Merging from the command prompt will add diff markers to the files if there
+# are conflicts (Merging from VS is not affected by the settings below, in VS
+# the diff markers are never inserted). Diff markers may cause the following 
+# file extensions to fail to load in VS. An alternative would be to treat
+# these files as binary and thus will always conflict and require user
+# intervention with every merge. To do so, just uncomment the entries below
+###############################################################################
+#*.sln       merge=binary
+#*.csproj    merge=binary
+#*.vbproj    merge=binary
+#*.vcxproj   merge=binary
+#*.vcproj    merge=binary
+#*.dbproj    merge=binary
+#*.fsproj    merge=binary
+#*.lsproj    merge=binary
+#*.wixproj   merge=binary
+#*.modelproj merge=binary
+#*.sqlproj   merge=binary
+#*.wwaproj   merge=binary
+
+###############################################################################
+# behavior for image files
+#
+# image files are treated as binary by default.
+###############################################################################
+#*.jpg   binary
+#*.png   binary
+#*.gif   binary
+
+###############################################################################
+# diff behavior for common document formats
+# 
+# Convert binary document formats to text before diffing them. This feature
+# is only available from the command line. Turn it on by uncommenting the 
+# entries below.
+###############################################################################
+#*.doc   diff=astextplain
+#*.DOC   diff=astextplain
+#*.docx  diff=astextplain
+#*.DOCX  diff=astextplain
+#*.dot   diff=astextplain
+#*.DOT   diff=astextplain
+#*.pdf   diff=astextplain
+#*.PDF   diff=astextplain
+#*.rtf   diff=astextplain
+#*.RTF   diff=astextplain

package/CHANGELOG.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 341323775e849a648922d928083dda86
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 41dce8be641afe34ca8363865b8cd5d9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2023 Eli Pinkerton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/LICENSE.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2f7b715fd1838ea49b6fe45bcdd2e7eb
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/README.md

@@ -0,0 +1,76 @@
+# DxMessaging
+Game engine agnostic robust, synchronous pub/sub C# messaging solution, mostly geared towards Unity and XNA/Monogame. See [this recorded talk](https://fathom.video/share/qjs8pn1MAwGb-yTAaW5WpZWdjzxcdwFR).
+
+# Benchmarks
+DxMessaging is currently a bit slower (2-3x) than Unity's built in messaging solution (when running in Unity). [Source](./Tests/Runtime/Core/PerformanceTests.cs).
+| Message Tech | Operations / Second |
+| ------------ | ------------------- |
+| Unity | 1,955,744 |
+| DxMessaging (GameObject) - Normal | 596,409 |
+| DxMessaging (Component) - Normal | 602,120 |
+| DxMessaging (GameObject) - No-Copy | 583,824 |
+| DxMessaging (Component) - No-Copy | 611,504 |
+| DxMessaging (Untargeted) - No-Copy | 1,044,795 |
+
+# Functionality
+While not as fast, DxMessaging offers *additional functionality* as compared to Unity's messaging solution.
+| Feature | Unity | DxMessaging |
+| ------- | ----- | ----------- |
+| Require knowledge of receiver's implementation | ✓ | _ |
+| Send a message to a GameObject | ✓ | ✓ |
+| Send a message to a Component | _ | ✓ |
+| Ignore messages dynamically at runtime | _ | ✓ (multiple ways) |
+| Send messages to all receivers | _ | ✓ |
+| Listen to messages for another GameObject | _ | ✓ (multiple ways)|
+| Listen to messages for another Component | _ | ✓ (multiple ways)|
+| Listen to messages *from* another GameObject | _ | ✓ (multiple ways)|
+| Listen to messages *from* another Component | _ | ✓ (multiple ways)|
+| Send a message without boxing its parameters | _ | ✓ |
+| Listen to all messages | _ | ✓ |
+| View a filter-able history of message registrations | N/A | ✓ |
+| "LateUpdate" style handlers | _ | ✓ |
+
+# Concepts
+There are a few important concepts that DxMessaging provides.
+* **MessageBus**: An implementation of the `IMessageBus` interface, configured to relay messages. There is no limit to these. By default there is only one, the global message bus.
+* **Emitter**: Any piece of code, anywhere can emit messages to any MessageBus. By default messages are emitted to the global message bus.
+* **Receiver**: A piece of code that has registered with a message bus to receive messages of certain types from it.
+* **UntargetedMessage**: Messages that are global, and will be sent to every receiver that is registered for this type.
+* **TargetedMessage**: Messages that are intended *for* a receiver, like a piece of mail or a command.
+* **BroadcastMessage**: Messages that are *from* an emitter, indicating events that happened to the emitter.
+
+## Receivers
+Receivers can subscribe to any number of message types. 
+* For targeted messages, generally receivers listen to their own object as the target, but the receiver can opt to listen to any target, or even all targets.
+* For broadcast messages, receivers can listen to any source, including themselves, or even all sources.
+
+For Unity, we have an easy-to-integrate [MessageAwareComponent](./Runtime/Unity/MessageAwareComponent.cs) - simply extend any component you want off of this base class. This will handle message registration lifetimes automatically for you. 
+If you have your own base classes or aren't using Unity, then you'll need to add lifetimes yourself. Please use the MessageAwareComponent as reference.
+### Integration
+See the [tests](./Tests/Runtime/Scripts/) directory for examples about how to integrate with the MessageAwareComponent. But, for some starters:
+```csharp
+public readonly struct SimpleTargetedMessage : ITargetedMessage<SimpleTargetedMessage>
+{
+}
+
+public sealed class SimpleMessageAwareComponent : MessageAwareComponent
+{
+    protected override void RegisterMessageHandlers()
+    {
+        _ = _messageRegistrationToken.RegisterGameObjectTargeted<SimpleTargetedMessage>(gameObject, HandleSimpleTargetedMessage);
+    }
+-
+    private void HandleSimpleTargetedMessage(ref SimpleTargetedMessage message)
+    {
+        Debug.Log("Received SimpleTargetedMessage.");
+    }
+}
+
+// In some other bit of code
+// Select a target
+SimpleMessageAwareComponent target = Object.FindObjectOfType<SimpleMessageAwareComponent>();
+// Create your message
+SimpleTargetedMessage message = new();
+// Send it - this will synchrously invoke all relevant handlers and return execution once complete
+message.EmitGameObjectTargeted(target.gameObject);
+```

package/README.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4c1ffc4b35b01f34f81f0399aa77b4d0
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Extensions/MessageExtensions.cs

@@ -0,0 +1,275 @@
+namespace DxMessaging.Core.Extensions
+{
+    using Core;
+    using MessageBus;
+    using Messages;
+
+    /// <summary>
+    /// Extensions to smartly go about emitting messages :^)
+    /// </summary>
+    public static class MessageExtensions
+    {
+
+#if UNITY_2017_1_OR_NEWER
+        /// <summary>
+        /// Emits a TargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">TargetedMessage to emit.</param>
+        /// <param name="target">Target that this message is intended for.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitGameObjectTargeted<TMessage>(this TMessage message, UnityEngine.GameObject target, IMessageBus messageBus = null) where TMessage : class, ITargetedMessage
+        {
+            InstanceId targetId = target;
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedTargetedBroadcast(targetId, message);
+                return;
+            }
+
+            messageBus.TargetedBroadcast(ref targetId, ref message);
+        }
+
+        /// <summary>
+        /// Emits a TargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">TargetedMessage to emit.</param>
+        /// <param name="target">Target that this message is intended for.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitGameObjectTargeted<TMessage>(this ref TMessage message, UnityEngine.GameObject target, IMessageBus messageBus = null) where TMessage : struct, ITargetedMessage
+        {
+            InstanceId targetId = target;
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedTargetedBroadcast(targetId, message);
+                return;
+            }
+
+            messageBus.TargetedBroadcast(ref targetId, ref message);
+        }
+
+        /// <summary>
+        /// Emits a TargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">TargetedMessage to emit.</param>
+        /// <param name="target">Target that this message is intended for.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitComponentTargeted<TMessage>(this TMessage message, UnityEngine.Component target, IMessageBus messageBus = null) where TMessage : class, ITargetedMessage
+        {
+            InstanceId targetId = target;
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedTargetedBroadcast(targetId, message);
+                return;
+            }
+
+            messageBus.TargetedBroadcast(ref targetId, ref message);
+        }
+
+        /// <summary>
+        /// Emits a TargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">TargetedMessage to emit.</param>
+        /// <param name="target">Target that this message is intended for.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitComponentTargeted<TMessage>(this ref TMessage message, UnityEngine.Component target, IMessageBus messageBus = null) where TMessage : struct, ITargetedMessage
+        {
+            InstanceId targetId = target;
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedTargetedBroadcast(targetId, message);
+                return;
+            }
+
+            messageBus.TargetedBroadcast(ref targetId, ref message);
+        }
+#endif
+
+
+        /// <summary>
+        /// Emits a TargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">TargetedMessage to emit.</param>
+        /// <param name="target">Target that this message is intended for.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitTargeted<TMessage>(this TMessage message, InstanceId target, IMessageBus messageBus = null) where TMessage : class, ITargetedMessage
+        {
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedTargetedBroadcast(target, message);
+                return;
+            }
+
+            messageBus.TargetedBroadcast(ref target, ref message);
+        }
+
+        /// <summary>
+        /// Emits a TargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">TargetedMessage to emit.</param>
+        /// <param name="target">Target that this message is intended for.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitTargeted<TMessage>(this ref TMessage message, InstanceId target, IMessageBus messageBus = null) where TMessage : struct, ITargetedMessage
+        {
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedTargetedBroadcast(target, message);
+                return;
+            }
+
+            messageBus.TargetedBroadcast(ref target, ref message);
+        }
+
+        /// <summary>
+        /// Emits an UntargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">UntargetedMessage to emit.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitUntargeted<TMessage>(this TMessage message, IMessageBus messageBus = null) where TMessage : class, IUntargetedMessage
+        {
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedUntargetedBroadcast(message);
+                return;
+            }
+
+            messageBus.UntargetedBroadcast(ref message);
+        }
+
+        /// <summary>
+        /// Emits an UntargetedMessage of the given type.
+        /// </summary>
+        /// <param name="message">UntargetedMessage to emit.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitUntargeted<TMessage>(this ref TMessage message, IMessageBus messageBus = null) where TMessage : struct, IUntargetedMessage
+        {
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedUntargetedBroadcast(message);
+                return;
+            }
+
+            messageBus.UntargetedBroadcast(ref message);
+        }
+
+#if UNITY_2017_1_OR_NEWER
+        /// <summary>
+        /// Emits a BroadcastMessage of the given type.
+        /// </summary>
+        /// <param name="message">BroadcastMessage to emit.</param>
+        /// <param name="source">Source of this message.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitGameObjectBroadcast<TMessage>(this TMessage message, UnityEngine.GameObject source, IMessageBus messageBus = null) where TMessage : class, IBroadcastMessage
+        {
+            InstanceId sourceId = source;
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedSourcedBroadcast(sourceId, message);
+                return;
+            }
+
+            messageBus.SourcedBroadcast(ref sourceId, ref message);
+        }
+
+        /// <summary>
+        /// Emits a BroadcastMessage of the given type.
+        /// </summary>
+        /// <param name="message">BroadcastMessage to emit.</param>
+        /// <param name="source">Source of this message.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitGameObjectBroadcast<TMessage>(this ref TMessage message, UnityEngine.GameObject source, IMessageBus messageBus = null) where TMessage : struct, IBroadcastMessage
+        {
+            InstanceId sourceId = source;
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedSourcedBroadcast(sourceId, message);
+                return;
+            }
+
+            messageBus.SourcedBroadcast(ref sourceId, ref message);
+        }
+
+        /// <summary>
+        /// Emits a BroadcastMessage of the given type from the specified component.
+        /// </summary>
+        /// <param name="message">BroadcastMessage to emit.</param>
+        /// <param name="source">Source of this message.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitComponentBroadcast<TMessage>(this TMessage message, UnityEngine.Component source, IMessageBus messageBus = null) where TMessage : class, IBroadcastMessage
+        {
+            InstanceId sourceId = source;
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedSourcedBroadcast(sourceId, message);
+                return;
+            }
+
+            messageBus.SourcedBroadcast(ref sourceId, ref message);
+        }
+
+        /// <summary>
+        /// Emits a BroadcastMessage of the given type from the specified component.
+        /// </summary>
+        /// <param name="message">BroadcastMessage to emit.</param>
+        /// <param name="source">Source of this message.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitComponentBroadcast<TMessage>(this ref TMessage message, UnityEngine.Component source, IMessageBus messageBus = null) where TMessage : struct, IBroadcastMessage
+        {
+            InstanceId sourceId = source;
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedSourcedBroadcast(sourceId, message);
+                return;
+            }
+
+            messageBus.SourcedBroadcast(ref sourceId, ref message);
+        }
+#endif
+        /// <summary>
+        /// Emits a BroadcastMessage of the given type from the specified component.
+        /// </summary>
+        /// <param name="message">BroadcastMessage to emit.</param>
+        /// <param name="source">Source of this message.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitBroadcast<TMessage>(this TMessage message, InstanceId source, IMessageBus messageBus = null) where TMessage : class, IBroadcastMessage
+        {
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedSourcedBroadcast(source, message);
+                return;
+            }
+
+            messageBus.SourcedBroadcast(ref source, ref message);
+        }
+
+        /// <summary>
+        /// Emits a BroadcastMessage of the given type from the specified component.
+        /// </summary>
+        /// <param name="message">BroadcastMessage to emit.</param>
+        /// <param name="source">Source of this message.</param>
+        /// <param name="messageBus">MessageBus to emit to. If null, uses the GlobalMessageBus.</param>
+        public static void EmitBroadcast<TMessage>(this ref TMessage message, InstanceId source, IMessageBus messageBus = null) where TMessage : struct, IBroadcastMessage
+        {
+            messageBus ??= MessageHandler.MessageBus;
+            if (typeof(TMessage) != message.MessageType)
+            {
+                messageBus.UntypedSourcedBroadcast(source, message);
+                return;
+            }
+
+            messageBus.SourcedBroadcast(ref source, ref message);
+        }
+    }
+}

package/Runtime/Core/Extensions/MessageExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 760f3c3fe4dffe647b41eef37728c4f4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Extensions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 963c131823f1c5948a69209dbac6533f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/IMessage.cs

@@ -0,0 +1,12 @@
+namespace DxMessaging.Core
+{
+    using System;
+
+    /// <summary>
+    /// Common base for all Messaging needs. A common base lets us share some implementation details with type safety.
+    /// </summary>
+    public interface IMessage
+    {
+        Type MessageType => GetType();
+    }
+}

package/Runtime/Core/IMessage.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7d57ad19529ae9d4eb2521c7f44af929
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/InstanceId.cs

@@ -0,0 +1,117 @@
+namespace DxMessaging.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// A light abstraction layer over Unity's InstanceId. Meant to uniquely identify a game object.
+    /// </summary>
+    [Serializable]
+    [DataContract]
+    public readonly struct InstanceId : IComparable, IComparable<InstanceId>, IEquatable<InstanceId>
+    {
+        public static readonly InstanceId EmptyId = new(0);
+
+        [DataMember(Name = "id")]
+        private readonly int _id;
+
+#if UNITY_2017_1_OR_NEWER
+        public UnityEngine.Object Object { get; }
+#endif
+        public InstanceId(int id) : this()
+        {
+            _id = id;
+#if UNITY_2017_1_OR_NEWER
+            Object = null;
+#endif
+        }
+
+#if UNITY_2017_1_OR_NEWER
+        private InstanceId(UnityEngine.Object @object) : this()
+        {
+            _id = @object.GetInstanceID();
+            Object = @object;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator InstanceId(UnityEngine.GameObject gameObject)
+        {
+            if (gameObject == null)
+            {
+                throw new ArgumentNullException(nameof(gameObject));
+            }
+
+            return new InstanceId(gameObject);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator InstanceId(UnityEngine.Component component)
+        {
+            if (component == null)
+            {
+                throw new ArgumentNullException(nameof(component));
+            }
+
+            return new InstanceId(component);
+        }
+#endif
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int CompareTo(object rhs)
+        {
+            if (rhs is InstanceId other)
+            {
+                return CompareTo(other);
+            }
+            return -1;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(InstanceId other)
+        {
+            return _id == other._id;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override bool Equals(object other)
+        {
+            return other is InstanceId id && Equals(id);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode()
+        {
+            return _id;
+        }
+
+        public override string ToString()
+        {
+#if UNITY_2017_1_OR_NEWER
+            UnityEngine.Object instance = Object;
+            string objectName = instance == null ? string.Empty : instance.name;
+            return $"{{\"Id\": {_id}, \"Name\": \"{objectName}\"}}";
+#else
+            return $"{{\"Id\": {_id}}}";
+#endif
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator ==(InstanceId lhs, InstanceId rhs)
+        {
+            return lhs.Equals(rhs);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator !=(InstanceId lhs, InstanceId rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int CompareTo(InstanceId other)
+        {
+            return _id.CompareTo(other._id);
+        }
+    }
+}

package/Runtime/Core/InstanceId.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 41b061d3cfb2f244b9806bfda65e3fa3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: