From 5f9eba90b08c4712d5d34b28d732aed6575509f2 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sat, 25 Jan 2025 16:00:36 +0100
Subject: [PATCH 01/22] Add INotifyValueChanged interface and events args for
 wrapper objects

---
 MonkeyLoader/Meta/NotifyValueChangedEvent.cs | 165 +++++++++++++++++++
 1 file changed, 165 insertions(+)
 create mode 100644 MonkeyLoader/Meta/NotifyValueChangedEvent.cs

diff --git a/MonkeyLoader/Meta/NotifyValueChangedEvent.cs b/MonkeyLoader/Meta/NotifyValueChangedEvent.cs
new file mode 100644
index 0000000..b6a7a34
--- /dev/null
+++ b/MonkeyLoader/Meta/NotifyValueChangedEvent.cs
@@ -0,0 +1,165 @@
+using MonkeyLoader.Configuration;
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+
+namespace MonkeyLoader.Meta
+{
+    /// <summary>
+    /// The delegate that is called for an <see cref="INotifyValueChanged"/>'s
+    /// <see cref="INotifyValueChanged.Changed">changed event</see>.
+    /// </summary>
+    /// <param name="sender">The object that sent the event.</param>
+    /// <param name="valueChangedEventArgs">The event containing details about the change.</param>
+    public delegate void ValueChangedEventHandler(object sender, IValueChangedEventArgs valueChangedEventArgs);
+
+    /// <summary>
+    /// The delegate that is called for an <see cref="INotifyValueChanged{T}"/>'s
+    /// <see cref="INotifyValueChanged{T}.Changed">changed event</see>.
+    /// </summary>
+    /// <typeparam name="T">The type of the key's value.</typeparam>
+    /// <param name="sender">The object that sent the event.</param>
+    /// <param name="valueChangedEventArgs">The event containing details about the change.</param>
+    public delegate void ValueChangedEventHandler<T>(object sender, ValueChangedEventArgs<T> valueChangedEventArgs);
+
+    /// <summary>
+    /// Defines the generic interface for objects that wrap another value
+    /// and <see cref="Changed">notify</see> others about changes to it.
+    /// </summary>
+    /// <typeparam name="T">The type of the wrapped value.</typeparam>
+    public interface INotifyValueChanged<T> : INotifyValueChanged
+    {
+        /// <summary>
+        /// Triggered when the internal value wrapped by this object changes.
+        /// </summary>
+        public new event ConfigKeyChangedEventHandler<T>? Changed;
+    }
+
+    /// <summary>
+    /// Defines the non-generic interface for objects that wrap another value
+    /// and <see cref="Changed">notify</see> others about changes to it.
+    /// </summary>
+    public interface INotifyValueChanged
+    {
+        /// <summary>
+        /// Triggered when the internal value wrapped by this object changes.
+        /// </summary>
+        public event ValueChangedEventHandler? Changed;
+    }
+
+    /// <summary>
+    /// Represents a non-generic <see cref="ValueChangedEventArgs{T}"/>.
+    /// </summary>
+    public interface IValueChangedEventArgs
+    {
+        /// <summary>
+        /// Gets the changed collection event arguments,
+        /// if this configuration item's changed value originated
+        /// from an <see cref="INotifyCollectionChanged.CollectionChanged"/> event.
+        /// </summary>
+        public NotifyCollectionChangedEventArgs? ChangedCollection { get; }
+
+        /// <summary>
+        /// Gets the name of the property that changed,
+        /// if this configuration item's changed value originated
+        /// from an <see cref="INotifyPropertyChanged.PropertyChanged"/> event.
+        /// </summary>
+        public string? ChangedProperty { get; }
+
+        /// <summary>
+        /// Gets whether this configuration item's changed value originated
+        /// from an <see cref="INotifyCollectionChanged.CollectionChanged"/> event.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if <see cref="ChangedCollection">ChangedCollection</see> is not <c>null</c>; otherwise, <c>false</c>.
+        /// </value>
+        [MemberNotNullWhen(true, nameof(ChangedCollection))]
+        public bool IsChangedCollection { get; }
+
+        /// <summary>
+        /// Gets whether this configuration item's changed value originated
+        /// from an <see cref="INotifyPropertyChanged.PropertyChanged"/> event.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if <see cref="ChangedProperty">ChangedProperty</see> is not <c>null</c>; otherwise, <c>false</c>.
+        /// </value>
+        [MemberNotNullWhen(true, nameof(ChangedProperty))]
+        public bool IsChangedProperty { get; }
+
+        /// <summary>
+        /// Gets the new value of the configuration item.<br/>
+        /// This can be the default value.
+        /// </summary>
+        public object? NewValue { get; }
+
+        /// <summary>
+        /// Gets the old value of the configuration item.<br/>
+        /// This can be the default value.
+        /// </summary>
+        public object? OldValue { get; }
+    }
+
+    /// <summary>
+    /// Represents the data for the <see cref="INotifyValueChanged.Changed"/>
+    /// and <see cref="INotifyValueChanged{T}.Changed"/> events.
+    /// </summary>
+    /// <typeparam name="T">The type of the wrapped value.</typeparam>
+    public class ValueChangedEventArgs<T> : IValueChangedEventArgs
+    {
+        /// <inheritdoc/>
+        public NotifyCollectionChangedEventArgs? ChangedCollection { get; }
+
+        /// <inheritdoc/>
+        public string? ChangedProperty { get; }
+
+        /// <inheritdoc/>
+        public bool HadValue { get; }
+
+        /// <inheritdoc/>
+        public bool HasValue { get; }
+
+        /// <inheritdoc/>
+        [MemberNotNullWhen(true, nameof(ChangedCollection))]
+        public bool IsChangedCollection => ChangedCollection is not null;
+
+        /// <inheritdoc/>
+        [MemberNotNullWhen(true, nameof(ChangedProperty))]
+        public bool IsChangedProperty => ChangedProperty is not null;
+
+        /// <summary>
+        /// Gets the new value of the <see cref="DefiningConfigKey{T}"/>.<br/>
+        /// This can be the default value.
+        /// </summary>
+        public T? NewValue { get; }
+
+        object? IValueChangedEventArgs.NewValue => NewValue;
+
+        /// <summary>
+        /// Gets the old value of the <see cref="DefiningConfigKey{T}"/>.<br/>
+        /// This can be the default value.
+        /// </summary>
+        public T? OldValue { get; }
+
+        object? IValueChangedEventArgs.OldValue => OldValue;
+
+        /// <summary>
+        /// Creates a new event args instance for a changed config item.
+        /// </summary>
+        /// <param name="oldValue">The optional old value.</param>
+        /// <param name="newValue">The optional new value.</param>
+        /// <param name="changedProperty">The name of the changed property on the value.</param>
+        /// <param name="changedCollection">The collection change arguments for the value.</param>
+        public ValueChangedEventArgs(T? oldValue, T? newValue,
+            string? changedProperty, NotifyCollectionChangedEventArgs? changedCollection)
+        {
+            OldValue = oldValue;
+            NewValue = newValue;
+
+            ChangedProperty = changedProperty;
+            ChangedCollection = changedCollection;
+        }
+    }
+}
\ No newline at end of file

From 5a53d068d04cc3ad744a195ee47d7e43063faea3 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sat, 25 Jan 2025 16:00:48 +0100
Subject: [PATCH 02/22] Add initial objects for MonkeySync system

---
 .../Sync/MonkeySyncMethodAttribute.cs         | 12 +++
 MonkeyLoader/Sync/MonkeySyncObject.cs         | 85 +++++++++++++++++++
 MonkeyLoader/Sync/MonkeySyncValue.cs          | 82 ++++++++++++++++++
 3 files changed, 179 insertions(+)
 create mode 100644 MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
 create mode 100644 MonkeyLoader/Sync/MonkeySyncObject.cs
 create mode 100644 MonkeyLoader/Sync/MonkeySyncValue.cs

diff --git a/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs b/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
new file mode 100644
index 0000000..e653956
--- /dev/null
+++ b/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace MonkeyLoader.Sync
+{
+    /// <summary>
+    /// Marks a <see cref="MonkeySyncObject{T}"/>'s instance method as
+    /// being triggerable through the Sync system.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
+    public sealed class MonkeySyncMethodAttribute : MonkeyLoaderAttribute
+    { }
+}
\ No newline at end of file
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
new file mode 100644
index 0000000..8e10af3
--- /dev/null
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+
+namespace MonkeyLoader.Sync
+{
+    /// <summary>
+    /// Defines the non-generic interface for <see cref="MonkeySyncObject{TLink}">MonkeySync objects</see>.
+    /// </summary>
+    public interface IMonkeySyncObject : INotifyPropertyChanged
+    {
+        /// <summary>
+        /// Gets whether this sync object has a <see cref="LinkObject">link object</see>.
+        /// </summary>
+        [MemberNotNullWhen(true, nameof(LinkObject))]
+        public bool HasLinkObject { get; }
+
+        /// <summary>
+        /// Gets whether this sync object has a valid link.
+        /// </summary>
+        public bool IsLinkValid { get; }
+
+        /// <summary>
+        /// Gets the link object used by this sync object.
+        /// </summary>
+        [MaybeNull]
+        public object LinkObject { get; }
+    }
+
+    /// <summary>
+    /// Defines the generic interface for <see cref="MonkeySyncObject{TLink}">MonkeySync objects</see>.
+    /// </summary>
+    public interface IMonkeySyncObject<out TLink> : IMonkeySyncObject
+        where TLink : class
+    {
+        /// <inheritdoc cref="IMonkeySyncObject.LinkObject"/>
+        [MaybeNull]
+        public new TLink LinkObject { get; }
+    }
+
+    public abstract class MonkeySyncObject<TLink> : IMonkeySyncObject<TLink>
+        where TLink : class
+    {
+        /// <inheritdoc/>
+        [MemberNotNullWhen(true, nameof(LinkObject))]
+        public bool HasLinkObject => LinkObject is not null;
+
+        /// <inheritdoc/>
+        public abstract bool IsLinkValid { get; }
+
+        /// <inheritdoc/>
+        public TLink LinkObject { get; }
+
+        object IMonkeySyncObject.LinkObject => LinkObject;
+
+        /// <summary>
+        /// Creates a new instance of this sync object with the given link object.
+        /// </summary>
+        /// <param name="linkObject">The link object used by this sync object.</param>
+        protected MonkeySyncObject(TLink linkObject)
+        {
+            LinkObject = linkObject;
+        }
+
+        /// <summary>
+        /// Triggers the <see cref="PropertyChanged">PropertyChanged</see>
+        /// event with the given <paramref name="propertyName"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is automatically called for any <see cref="MonkeySyncValue{T}"/> properties.
+        /// </remarks>
+        /// <param name="propertyName"></param>
+        protected void OnPropertyChanged(string propertyName)
+        {
+            var eventData = new PropertyChangedEventArgs(propertyName);
+
+            PropertyChanged?.Invoke(this, eventData);
+        }
+
+        /// <inheritdoc/>
+        public event PropertyChangedEventHandler? PropertyChanged;
+    }
+}
\ No newline at end of file
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
new file mode 100644
index 0000000..a5bca10
--- /dev/null
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -0,0 +1,82 @@
+using MonkeyLoader.Meta;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MonkeyLoader.Sync
+{
+    /// <summary>
+    /// Defines the non-generic interface for <see cref="IMonkeySyncValue"/>s.
+    /// </summary>
+    public interface IMonkeySyncValue : INotifyValueChanged
+    {
+        /// <summary>
+        /// Gets or sets the internal value of this sync value.
+        /// </summary>
+        public object? Value { get; set; }
+    }
+
+    /// <summary>
+    /// Defines the generic interface for <see cref="IMonkeySyncValue"/>s.
+    /// </summary>
+    /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
+    public interface IMonkeySyncValue<T> : IReadOnlyMonkeySyncValue<T>, IWriteOnlyMonkeySyncValue<T>
+    {
+        /// <inheritdoc cref="IMonkeySyncValue.Value"/>
+        public new T Value { get; set; }
+    }
+
+    /// <summary>
+    /// Defines the interface for readonly <see cref="IMonkeySyncValue"/>s.
+    /// </summary>
+    /// <remarks>
+    /// This interface exists purely to facilitate keeping a covariant list of sync values.
+    /// </remarks>
+    /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
+    public interface IReadOnlyMonkeySyncValue<out T> : IMonkeySyncValue
+    {
+        /// <summary>
+        /// Gets the internal value of this sync value.
+        /// </summary>
+        public new T Value { get; }
+    }
+
+    /// <summary>
+    /// Defines the interface for writeonly <see cref="IMonkeySyncValue"/>s.
+    /// </summary>
+    /// <remarks>
+    /// This interface exists purely to facilitate keeping a contravariant list of sync values.
+    /// </remarks>
+    /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
+    public interface IWriteOnlyMonkeySyncValue<in T> : IMonkeySyncValue
+    {
+        /// <summary>
+        /// Sets the internal value of this sync value.
+        /// </summary>
+        public new T Value { set; }
+    }
+
+    public class MonkeySyncValue<T> : IMonkeySyncValue<T>
+    {
+        private T _value;
+
+        /// <inheritdoc/>
+        public T Value
+        {
+            get => _value;
+            set
+            {
+                if (ReferenceEquals(_value, value))
+                    return;
+
+                _value = value;
+            }
+        }
+
+        object? IMonkeySyncValue.Value
+        {
+            get => Value;
+            set => Value = (T)value!;
+        }
+    }
+}
\ No newline at end of file

From 98e056f6867715afa310ccd8f860214e58438486 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sat, 25 Jan 2025 18:50:14 +0100
Subject: [PATCH 03/22] Make use of NotifyValueChanged as base for
 ConfigKeyChanged

---
 .../Configuration/ConfigKeyChangedEvent.cs    | 88 +------------------
 .../Configuration/DefiningConfigKey.cs        | 77 ++++++++++++----
 MonkeyLoader/Meta/NotifyValueChangedEvent.cs  |  8 +-
 3 files changed, 64 insertions(+), 109 deletions(-)

diff --git a/MonkeyLoader/Configuration/ConfigKeyChangedEvent.cs b/MonkeyLoader/Configuration/ConfigKeyChangedEvent.cs
index 612b379..00d5871 100644
--- a/MonkeyLoader/Configuration/ConfigKeyChangedEvent.cs
+++ b/MonkeyLoader/Configuration/ConfigKeyChangedEvent.cs
@@ -1,7 +1,7 @@
 using System.Collections.Specialized;
-using System.ComponentModel;
 using System;
 using System.Diagnostics.CodeAnalysis;
+using MonkeyLoader.Meta;
 
 namespace MonkeyLoader.Configuration
 {
@@ -24,14 +24,8 @@ namespace MonkeyLoader.Configuration
     /// Represents the data for the <see cref="Config.ItemChanged"/> and <see cref="MonkeyLoader.AnyConfigChanged"/> events.
     /// </summary>
     /// <typeparam name="T">The type of the key's value.</typeparam>
-    public sealed class ConfigKeyChangedEventArgs<T> : IConfigKeyChangedEventArgs
+    public sealed class ConfigKeyChangedEventArgs<T> : ValueChangedEventArgs<T>, IConfigKeyChangedEventArgs
     {
-        /// <inheritdoc/>
-        public NotifyCollectionChangedEventArgs? ChangedCollection { get; }
-
-        /// <inheritdoc/>
-        public string? ChangedProperty { get; }
-
         /// <inheritdoc/>
         public Config Config { get; }
 
@@ -45,14 +39,6 @@ public sealed class ConfigKeyChangedEventArgs<T> : IConfigKeyChangedEventArgs
         /// <inheritdoc/>
         public bool HasValue { get; }
 
-        /// <inheritdoc/>
-        [MemberNotNullWhen(true, nameof(ChangedCollection))]
-        public bool IsChangedCollection => ChangedCollection is not null;
-
-        /// <inheritdoc/>
-        [MemberNotNullWhen(true, nameof(ChangedProperty))]
-        public bool IsChangedProperty => ChangedProperty is not null;
-
         /// <summary>
         /// Gets the configuration item who's value changed.
         /// </summary>
@@ -63,22 +49,6 @@ public sealed class ConfigKeyChangedEventArgs<T> : IConfigKeyChangedEventArgs
         /// <inheritdoc/>
         public string? Label { get; }
 
-        /// <summary>
-        /// Gets the new value of the <see cref="DefiningConfigKey{T}"/>.<br/>
-        /// This can be the default value.
-        /// </summary>
-        public T? NewValue { get; }
-
-        object? IConfigKeyChangedEventArgs.NewValue => NewValue;
-
-        /// <summary>
-        /// Gets the old value of the <see cref="DefiningConfigKey{T}"/>.<br/>
-        /// This can be the default value.
-        /// </summary>
-        public T? OldValue { get; }
-
-        object? IConfigKeyChangedEventArgs.OldValue => OldValue;
-
         /// <summary>
         /// Creates a new event args instance for a changed config item.
         /// </summary>
@@ -94,41 +64,23 @@ public sealed class ConfigKeyChangedEventArgs<T> : IConfigKeyChangedEventArgs
         public ConfigKeyChangedEventArgs(Config config, IDefiningConfigKey<T> key,
             bool hadValue, T? oldValue, bool hasValue, T? newValue, string? label,
             string? changedProperty, NotifyCollectionChangedEventArgs? changedCollection)
+                : base(oldValue, newValue, changedProperty, changedCollection)
         {
             Config = config;
             Key = key;
 
-            OldValue = oldValue;
             HadValue = hadValue;
-            NewValue = newValue;
             HasValue = hasValue;
 
             Label = label;
-
-            ChangedProperty = changedProperty;
-            ChangedCollection = changedCollection;
         }
     }
 
     /// <summary>
     /// Represents a non-generic <see cref="ConfigKeyChangedEventArgs{T}"/>.
     /// </summary>
-    public interface IConfigKeyChangedEventArgs
+    public interface IConfigKeyChangedEventArgs : IValueChangedEventArgs
     {
-        /// <summary>
-        /// Gets the changed collection event arguments,
-        /// if this configuration item's changed value originated
-        /// from an <see cref="INotifyCollectionChanged.CollectionChanged"/> event.
-        /// </summary>
-        public NotifyCollectionChangedEventArgs? ChangedCollection { get; }
-
-        /// <summary>
-        /// Gets the name of the property that changed,
-        /// if this configuration item's changed value originated
-        /// from an <see cref="INotifyPropertyChanged.PropertyChanged"/> event.
-        /// </summary>
-        public string? ChangedProperty { get; }
-
         /// <summary>
         /// Gets the <see cref="Configuration.Config"/> in which the change occured.
         /// </summary>
@@ -153,26 +105,6 @@ public interface IConfigKeyChangedEventArgs
         /// </summary>
         public bool HasValue { get; }
 
-        /// <summary>
-        /// Gets whether this configuration item's changed value originated
-        /// from an <see cref="INotifyCollectionChanged.CollectionChanged"/> event.
-        /// </summary>
-        /// <value>
-        /// <c>true</c> if <see cref="ChangedCollection">ChangedCollection</see> is not <c>null</c>; otherwise, <c>false</c>.
-        /// </value>
-        [MemberNotNullWhen(true, nameof(ChangedCollection))]
-        public bool IsChangedCollection { get; }
-
-        /// <summary>
-        /// Gets whether this configuration item's changed value originated
-        /// from an <see cref="INotifyPropertyChanged.PropertyChanged"/> event.
-        /// </summary>
-        /// <value>
-        /// <c>true</c> if <see cref="ChangedProperty">ChangedProperty</see> is not <c>null</c>; otherwise, <c>false</c>.
-        /// </value>
-        [MemberNotNullWhen(true, nameof(ChangedProperty))]
-        public bool IsChangedProperty { get; }
-
         /// <summary>
         /// Gets the configuration item who's value changed.
         /// </summary>
@@ -182,17 +114,5 @@ public interface IConfigKeyChangedEventArgs
         /// Gets a custom label that may be set by whoever changed the configuration.
         /// </summary>
         public string? Label { get; }
-
-        /// <summary>
-        /// Gets the new value of the configuration item.<br/>
-        /// This can be the default value.
-        /// </summary>
-        public object? NewValue { get; }
-
-        /// <summary>
-        /// Gets the old value of the configuration item.<br/>
-        /// This can be the default value.
-        /// </summary>
-        public object? OldValue { get; }
     }
 }
\ No newline at end of file
diff --git a/MonkeyLoader/Configuration/DefiningConfigKey.cs b/MonkeyLoader/Configuration/DefiningConfigKey.cs
index 00d05bf..06ec25e 100644
--- a/MonkeyLoader/Configuration/DefiningConfigKey.cs
+++ b/MonkeyLoader/Configuration/DefiningConfigKey.cs
@@ -35,8 +35,11 @@ public sealed class DefiningConfigKey<T> : Entity<DefiningConfigKey<T>>, IDefini
         private ConfigSection? _configSection;
         private bool _hasChanges;
         private ConfigKeyChangedEventHandler? _untypedChanged;
+        private ValueChangedEventHandler? _untypedValueChanged;
         private T? _value;
 
+        private ValueChangedEventHandler<T>? _valueChanged;
+
         /// <inheritdoc/>
         public IConfigKey AsUntyped { get; }
 
@@ -367,27 +370,34 @@ public bool Validate(T value)
         /// <param name="changedCollection">The collection change arguments for the value.</param>
         private void OnChanged(bool hadValue, T? oldValue, string? eventLabel, string? changedProperty = null, NotifyCollectionChangedEventArgs? changedCollection = null)
         {
-            // Add notify changed integration
-            if (hadValue)
+            var sameReferences = ReferenceEquals(oldValue, _value);
+
+            if (!sameReferences)
             {
-                if (oldValue is INotifyPropertyChanged oldPropertyChanged)
-                    oldPropertyChanged.PropertyChanged -= ValuePropertyChanged;
+                // Remove NotifyChanged integration from old value
+                if (hadValue)
+                {
+                    if (oldValue is INotifyPropertyChanged oldPropertyChanged)
+                        oldPropertyChanged.PropertyChanged -= ValuePropertyChanged;
 
-                if (oldValue is INotifyCollectionChanged oldCollectionChanged)
-                    oldCollectionChanged.CollectionChanged -= ValueCollectionChanged;
-            }
+                    if (oldValue is INotifyCollectionChanged oldCollectionChanged)
+                        oldCollectionChanged.CollectionChanged -= ValueCollectionChanged;
+                }
 
-            if (HasValue)
-            {
-                if (_value is INotifyPropertyChanged newPropertyChanged)
-                    newPropertyChanged.PropertyChanged += ValuePropertyChanged;
+                // Add NotifyChanged integration to new value
+                if (HasValue)
+                {
+                    if (_value is INotifyPropertyChanged newPropertyChanged)
+                        newPropertyChanged.PropertyChanged += ValuePropertyChanged;
 
-                if (_value is INotifyCollectionChanged newCollectionChanged)
-                    newCollectionChanged.CollectionChanged += ValueCollectionChanged;
+                    if (_value is INotifyCollectionChanged newCollectionChanged)
+                        newCollectionChanged.CollectionChanged += ValueCollectionChanged;
+                }
             }
 
-            // Don't fire event if value didn't change
-            if (ReferenceEquals(oldValue, _value) || (oldValue is not null && _value is not null && _value.Equals(oldValue)))
+            // Don't fire event if it wasn't triggered by event and the value didn't change
+            if ((sameReferences && changedProperty is null && changedCollection is null)
+             || (oldValue is not null && _value is not null && _value.Equals(oldValue)))
                 return;
 
             HasChanges = true;
@@ -411,6 +421,24 @@ private void OnChanged(bool hadValue, T? oldValue, string? eventLabel, string? c
                 Logger.Error(ex.LogFormat($"Some untyped {nameof(Changed)} event subscriber(s) of key [{Id}] threw an exception:"));
             }
 
+            try
+            {
+                _valueChanged?.TryInvokeAll(this, eventArgs);
+            }
+            catch (AggregateException ex)
+            {
+                Logger.Error(ex.LogFormat($"Some typed {nameof(INotifyValueChanged)}<T>.{nameof(Changed)} event subscriber(s) of key [{Id}] threw an exception:"));
+            }
+
+            try
+            {
+                _untypedValueChanged?.TryInvokeAll(this, eventArgs);
+            }
+            catch (AggregateException ex)
+            {
+                Logger.Error(ex.LogFormat($"Some untyped {nameof(INotifyValueChanged)}<T>.{nameof(Changed)} event subscriber(s) of key [{Id}] threw an exception:"));
+            }
+
             Section.OnItemChanged(eventArgs);
         }
 
@@ -431,13 +459,25 @@ event ConfigKeyChangedEventHandler? IDefiningConfigKey.Changed
             add => _untypedChanged += value;
             remove => _untypedChanged -= value;
         }
+
+        event ValueChangedEventHandler? INotifyValueChanged.Changed
+        {
+            add => _untypedValueChanged += value;
+            remove => _untypedValueChanged -= value;
+        }
+
+        event ValueChangedEventHandler<T>? INotifyValueChanged<T>.Changed
+        {
+            add => _valueChanged += value;
+            remove => _valueChanged -= value;
+        }
     }
 
     /// <summary>
     /// Defines the definition for a config item.
     /// </summary>
     public interface IDefiningConfigKey : ITypedConfigKey, IEntity<IDefiningConfigKey>,
-        INestedIdentifiable<ConfigSection>, IPrioritizable
+        INestedIdentifiable<ConfigSection>, IPrioritizable, INotifyValueChanged
     {
         /// <summary>
         /// Gets the config this item belongs to.
@@ -541,14 +581,15 @@ public interface IDefiningConfigKey : ITypedConfigKey, IEntity<IDefiningConfigKe
         /// <summary>
         /// Triggered when the internal value of this config item changes.
         /// </summary>
-        public event ConfigKeyChangedEventHandler? Changed;
+        public new event ConfigKeyChangedEventHandler? Changed;
     }
 
     /// <summary>
     /// Defines the typed definition for a config item.
     /// </summary>
     /// <typeparam name="T">The type of the config item's value.</typeparam>
-    public interface IDefiningConfigKey<T> : IDefiningConfigKey, ITypedConfigKey<T>, IEntity<IDefiningConfigKey<T>>
+    public interface IDefiningConfigKey<T> : IDefiningConfigKey, ITypedConfigKey<T>,
+        IEntity<IDefiningConfigKey<T>>, INotifyValueChanged<T>
     {
         /// <summary>
         /// Gets this config item's set value, falling back to the <see cref="TryComputeDefault">computed default</see>.
diff --git a/MonkeyLoader/Meta/NotifyValueChangedEvent.cs b/MonkeyLoader/Meta/NotifyValueChangedEvent.cs
index b6a7a34..d641543 100644
--- a/MonkeyLoader/Meta/NotifyValueChangedEvent.cs
+++ b/MonkeyLoader/Meta/NotifyValueChangedEvent.cs
@@ -35,7 +35,7 @@ public interface INotifyValueChanged<T> : INotifyValueChanged
         /// <summary>
         /// Triggered when the internal value wrapped by this object changes.
         /// </summary>
-        public new event ConfigKeyChangedEventHandler<T>? Changed;
+        public new event ValueChangedEventHandler<T>? Changed;
     }
 
     /// <summary>
@@ -115,12 +115,6 @@ public class ValueChangedEventArgs<T> : IValueChangedEventArgs
         /// <inheritdoc/>
         public string? ChangedProperty { get; }
 
-        /// <inheritdoc/>
-        public bool HadValue { get; }
-
-        /// <inheritdoc/>
-        public bool HasValue { get; }
-
         /// <inheritdoc/>
         [MemberNotNullWhen(true, nameof(ChangedCollection))]
         public bool IsChangedCollection => ChangedCollection is not null;

From a9c2db1e02ebae4ab386e2111824a9a4fab3bba0 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sat, 25 Jan 2025 18:51:24 +0100
Subject: [PATCH 04/22] Finish implementation of MonkeySyncValue

---
 MonkeyLoader/MonkeyLoader.csproj     |   4 +
 MonkeyLoader/Sync/MonkeySyncValue.cs | 118 +++++++++++++++++++++++++--
 2 files changed, 117 insertions(+), 5 deletions(-)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 7c6495b..5ea7cec 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -77,6 +77,10 @@
     <PackageReference Include="EnumerableToolkit.Builder" Version="2.0.2" />
     <PackageReference Include="EnumerableToolkit.Builder.Async" Version="2.0.2" />
     <PackageReference Include="Lib.Harmony.Thin" Version="2.3.6" />
+    <PackageReference Include="MicroUtils.HarmonyAnalyzers" Version="1.3.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="NuGet.Protocol" Version="6.13.2" />
     <PackageReference Include="PolySharp" Version="1.15.0">
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index a5bca10..5c9e9d9 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -1,6 +1,10 @@
-using MonkeyLoader.Meta;
+using EnumerableToolkit;
+using MonkeyLoader.Meta;
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
 namespace MonkeyLoader.Sync
@@ -20,7 +24,8 @@ public interface IMonkeySyncValue : INotifyValueChanged
     /// Defines the generic interface for <see cref="IMonkeySyncValue"/>s.
     /// </summary>
     /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
-    public interface IMonkeySyncValue<T> : IReadOnlyMonkeySyncValue<T>, IWriteOnlyMonkeySyncValue<T>
+    public interface IMonkeySyncValue<T> : INotifyValueChanged<T>,
+        IReadOnlyMonkeySyncValue<T>, IWriteOnlyMonkeySyncValue<T>
     {
         /// <inheritdoc cref="IMonkeySyncValue.Value"/>
         public new T Value { get; set; }
@@ -56,20 +61,27 @@ public interface IWriteOnlyMonkeySyncValue<in T> : IMonkeySyncValue
         public new T Value { set; }
     }
 
+    /// <summary>
+    /// Implements a basic version of an <see cref="IMonkeySyncValue{T}"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
     public class MonkeySyncValue<T> : IMonkeySyncValue<T>
     {
+        private ValueChangedEventHandler? _untypedChanged;
         private T _value;
 
         /// <inheritdoc/>
         public T Value
         {
             get => _value;
+
+            [MemberNotNull(nameof(_value))]
             set
             {
-                if (ReferenceEquals(_value, value))
-                    return;
-
+                var oldValue = _value;
                 _value = value;
+
+                OnChanged(oldValue);
             }
         }
 
@@ -78,5 +90,101 @@ public T Value
             get => Value;
             set => Value = (T)value!;
         }
+
+        /// <summary>
+        /// Creates a new sync object instance that wraps the given <paramref name="value"/>.
+        /// </summary>
+        /// <param name="value">The value to wrap.</param>
+        public MonkeySyncValue(T value)
+        {
+            Value = value;
+        }
+
+        /// <summary>
+        /// Wraps the given <paramref name="value"/> into a sync object.
+        /// </summary>
+        /// <param name="value">The value to wrap.</param>
+        public static implicit operator MonkeySyncValue<T>(T value) => new(value);
+
+        /// <summary>
+        /// Unwraps the <see cref="Value">Value</see> from the given sync object.
+        /// </summary>
+        /// <param name="syncValue">The sync object to unwrap.</param>
+        public static implicit operator T(MonkeySyncValue<T> syncValue) => syncValue.Value;
+
+        /// <summary>
+        /// Handles the value of this config item potentially having changed.
+        /// If the <paramref name="oldValue"/> and new value are different:<br/>
+        /// Triggers this sync object's typed and untyped <see cref="Changed">Changed</see> events.
+        /// </summary>
+        /// <param name="oldValue">The old value.</param>
+        /// <param name="changedProperty">The name of the changed property on the value.</param>
+        /// <param name="changedCollection">The collection change arguments for the value.</param>
+        private void OnChanged(T? oldValue, string? changedProperty = null, NotifyCollectionChangedEventArgs? changedCollection = null)
+        {
+            var sameReferences = ReferenceEquals(oldValue, _value);
+
+            if (!sameReferences)
+            {
+                // Remove NotifyChanged integration from old value
+                if (oldValue is INotifyPropertyChanged oldPropertyChanged)
+                    oldPropertyChanged.PropertyChanged -= ValuePropertyChanged;
+
+                if (oldValue is INotifyCollectionChanged oldCollectionChanged)
+                    oldCollectionChanged.CollectionChanged -= ValueCollectionChanged;
+
+                // Add NotifyChanged integration to new value
+                if (_value is INotifyPropertyChanged newPropertyChanged)
+                    newPropertyChanged.PropertyChanged += ValuePropertyChanged;
+
+                if (_value is INotifyCollectionChanged newCollectionChanged)
+                    newCollectionChanged.CollectionChanged += ValueCollectionChanged;
+            }
+
+            // Don't fire event if it wasn't triggered by event and the value didn't change
+            if ((sameReferences && changedProperty is null && changedCollection is null)
+             || (oldValue is not null && _value is not null && _value.Equals(oldValue)))
+                return;
+
+            var eventArgs = new ValueChangedEventArgs<T>(oldValue, _value, changedProperty, changedCollection);
+
+            var exceptions = new List<Exception>();
+
+            try
+            {
+                Changed?.TryInvokeAll(this, eventArgs);
+            }
+            catch (AggregateException ex)
+            {
+                exceptions.Add(ex);
+            }
+
+            try
+            {
+                _untypedChanged?.TryInvokeAll(this, eventArgs);
+            }
+            catch (AggregateException ex)
+            {
+                exceptions.Add(ex);
+            }
+
+            if (exceptions.Count > 0)
+                throw new AggregateException($"Some {nameof(Changed)} event subscriber(s) of this MonkeySyncValue threw an exception.", exceptions);
+        }
+
+        private void ValueCollectionChanged(object sender, NotifyCollectionChangedEventArgs eventArgs)
+            => OnChanged(_value, null, eventArgs);
+
+        private void ValuePropertyChanged(object sender, PropertyChangedEventArgs eventArgs)
+            => OnChanged(_value, eventArgs.PropertyName);
+
+        /// <inheritdoc/>
+        public event ValueChangedEventHandler<T>? Changed;
+
+        event ValueChangedEventHandler? INotifyValueChanged.Changed
+        {
+            add => _untypedChanged += value;
+            remove => _untypedChanged -= value;
+        }
     }
 }
\ No newline at end of file

From 03775f2acc1e2cd2548d41f9d0b8e4adf0e85e8d Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sat, 25 Jan 2025 20:30:14 +0100
Subject: [PATCH 05/22] Finish pre-release version of MonkeySync feature

---
 MonkeyLoader/MonkeyLoader.csproj      |   2 +-
 MonkeyLoader/Sync/MonkeySyncObject.cs | 111 ++++++++++++++++++++++++--
 MonkeyLoader/Sync/MonkeySyncValue.cs  |   2 +-
 3 files changed, 105 insertions(+), 10 deletions(-)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 5ea7cec..ad19951 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.25.0-beta</Version>
+    <Version>0.24.2-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index 8e10af3..a76489b 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -1,13 +1,16 @@
-using System;
+using HarmonyLib;
+using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Text;
 
 namespace MonkeyLoader.Sync
 {
     /// <summary>
-    /// Defines the non-generic interface for <see cref="MonkeySyncObject{TLink}">MonkeySync objects</see>.
+    /// Defines the non-generic interface for <see cref="MonkeySyncObject{TSyncObject,
+    /// TSyncValues, TLink}">MonkeySync objects</see>.
     /// </summary>
     public interface IMonkeySyncObject : INotifyPropertyChanged
     {
@@ -30,8 +33,10 @@ public interface IMonkeySyncObject : INotifyPropertyChanged
     }
 
     /// <summary>
-    /// Defines the generic interface for <see cref="MonkeySyncObject{TLink}">MonkeySync objects</see>.
+    /// Defines the generic interface for <see cref="MonkeySyncObject{TSyncObject,
+    /// TSyncValues, TLink}">MonkeySync objects</see>.
     /// </summary>
+    /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
     public interface IMonkeySyncObject<out TLink> : IMonkeySyncObject
         where TLink : class
     {
@@ -40,9 +45,30 @@ public interface IMonkeySyncObject<out TLink> : IMonkeySyncObject
         public new TLink LinkObject { get; }
     }
 
-    public abstract class MonkeySyncObject<TLink> : IMonkeySyncObject<TLink>
+    /// <summary>
+    /// Implements the abstract base for MonkeySync objects.
+    /// </summary>
+    /// <typeparam name="TSyncObject">The concrete type of the MonkeySync object.</typeparam>
+    /// <typeparam name="TSyncValue">
+    /// The <see cref="IMonkeySyncValue"/>-derived interface
+    /// that the MonkeySync values of this object must implement.
+    /// </typeparam>
+    /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+    public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IMonkeySyncObject<TLink>
+        where TSyncObject : MonkeySyncObject<TSyncObject, TSyncValue, TLink>
+        where TSyncValue : IMonkeySyncValue
         where TLink : class
     {
+        /// <summary>
+        /// The detected <see cref="MonkeySyncMethodAttribute">MonkeySync nethods</see> by their name.
+        /// </summary>
+        protected static readonly Dictionary<string, Action<TSyncObject>> methodsByName = new(StringComparer.Ordinal);
+
+        /// <summary>
+        /// The getters for the detected <typeparamref name="TSyncValue"/> instance properties by their name.
+        /// </summary>
+        protected static readonly Dictionary<string, Func<TSyncObject, TSyncValue>> propertyAccessorsByName = new(StringComparer.Ordinal);
+
         /// <inheritdoc/>
         [MemberNotNullWhen(true, nameof(LinkObject))]
         public bool HasLinkObject => LinkObject is not null;
@@ -51,17 +77,86 @@ public abstract class MonkeySyncObject<TLink> : IMonkeySyncObject<TLink>
         public abstract bool IsLinkValid { get; }
 
         /// <inheritdoc/>
-        public TLink LinkObject { get; }
+        [MaybeNull]
+        public TLink LinkObject { get; private set; }
 
+        [MaybeNull]
         object IMonkeySyncObject.LinkObject => LinkObject;
 
+        static MonkeySyncObject()
+        {
+            var syncValueType = typeof(TSyncValue);
+            var syncValueProperties = AccessTools.GetDeclaredProperties(typeof(TSyncObject))
+                .Where(property => syncValueType.IsAssignableFrom(property.PropertyType) && (!(property.GetGetMethod()?.IsStatic ?? true)));
+
+            foreach (var property in syncValueProperties)
+                propertyAccessorsByName.Add(property.Name, (TSyncObject instance) => (TSyncValue)property.GetValue(instance));
+
+            var syncMethods = AccessTools.GetDeclaredMethods(typeof(TSyncObject))
+                .Where(method => !method.IsStatic && !method.ContainsGenericParameters && method.ReturnType == typeof(void) && method.GetParameters().Length == 0);
+
+            foreach (var method in syncMethods)
+                methodsByName.Add(method.Name, (TSyncObject instance) => method.Invoke(instance, null));
+        }
+
         /// <summary>
-        /// Creates a new instance of this sync object with the given link object.
+        /// Establishes this sync object's link with the given object.
         /// </summary>
-        /// <param name="linkObject">The link object used by this sync object.</param>
-        protected MonkeySyncObject(TLink linkObject)
+        /// <remarks>
+        /// If the link fails or gets broken, a new instance has to be created.
+        /// </remarks>
+        /// <param name="linkObject">The link object to be used by this sync object.</param>
+        /// <returns><c>true</c> if the established link is valid; otherwise, <c>false</c>.</returns>
+        public bool LinkWith(TLink linkObject)
         {
+            if (HasLinkObject)
+                throw new InvalidOperationException("Can only assign a link object once!");
+
             LinkObject = linkObject;
+
+            return EstablishLinkWith(linkObject);
+        }
+
+        /// <summary>
+        /// Creates a link for the given sync value of the given name.
+        /// </summary>
+        /// <param name="propertyName">The name of the sync value to link.</param>
+        /// <param name="syncValue">The sync value to link.</param>
+        /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
+        protected abstract bool EstablishLinkFor(string propertyName, TSyncValue syncValue);
+
+        /// <summary>
+        /// Creates a link for the given sync method of the given name.
+        /// </summary>
+        /// <param name="methodName">The name of the sync method to link.</param>
+        /// <param name="syncMethod">The sync method to link.</param>
+        /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
+        protected abstract bool EstablishLinkFor(string methodName, Action<TSyncObject> syncMethod);
+
+        /// <remarks><para>
+        /// <i>By default:</i> Calls <see cref="EstablishLinkFor(string, TSyncValue)">EstablishLinkFor</see>
+        /// for every readable <typeparamref name="TSyncValue"/> instance property and
+        /// <see cref="EstablishLinkFor(string, TSyncValue)">its overload</see> for every
+        /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
+        /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
+        /// while the detected methods are stored in <see cref="methodsByName">methodsByName</see>.
+        /// </para><para>
+        /// This method is called by <see cref="LinkWith">LinkWith</see>
+        /// after the <see cref="LinkObject">LinkObject</see> has been assigned.
+        /// </para>
+        /// </remarks>
+        /// <inheritdoc cref="LinkWith"/>
+        protected virtual bool EstablishLinkWith(TLink linkObject)
+        {
+            var success = true;
+
+            foreach (var syncValueProperty in propertyAccessorsByName)
+                success &= EstablishLinkFor(syncValueProperty.Key, syncValueProperty.Value((TSyncObject)this));
+
+            foreach (var syncMethod in methodsByName)
+                success &= EstablishLinkFor(syncMethod.Key, syncMethod.Value);
+
+            return success;
         }
 
         /// <summary>
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index 5c9e9d9..d6c17cf 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -79,7 +79,7 @@ public T Value
             set
             {
                 var oldValue = _value;
-                _value = value;
+                _value = value!;
 
                 OnChanged(oldValue);
             }

From d4f9ee0e238987810f54a201e92bc9db6b990062 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sun, 26 Jan 2025 22:41:22 +0100
Subject: [PATCH 06/22] Tweak MonkeySync base

---
 MonkeyLoader/Configuration/DefiningConfigKey.cs |  6 +++---
 MonkeyLoader/MonkeyLoader.csproj                |  2 +-
 MonkeyLoader/Sync/MonkeySyncObject.cs           |  6 +-----
 MonkeyLoader/Sync/MonkeySyncValue.cs            | 14 ++++++++++++++
 4 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/MonkeyLoader/Configuration/DefiningConfigKey.cs b/MonkeyLoader/Configuration/DefiningConfigKey.cs
index 06ec25e..128e7e7 100644
--- a/MonkeyLoader/Configuration/DefiningConfigKey.cs
+++ b/MonkeyLoader/Configuration/DefiningConfigKey.cs
@@ -29,15 +29,15 @@ namespace MonkeyLoader.Configuration
     /// <typeparam name="T">The type of the config item's value.</typeparam>
     public sealed class DefiningConfigKey<T> : Entity<DefiningConfigKey<T>>, IDefiningConfigKey<T>
     {
-        private readonly bool _canAlwaysHaveChanges;
+        private static readonly Type _valueType = typeof(T);
 
+        private readonly bool _canAlwaysHaveChanges;
         private readonly Lazy<string> _fullId;
         private ConfigSection? _configSection;
         private bool _hasChanges;
         private ConfigKeyChangedEventHandler? _untypedChanged;
         private ValueChangedEventHandler? _untypedValueChanged;
         private T? _value;
-
         private ValueChangedEventHandler<T>? _valueChanged;
 
         /// <inheritdoc/>
@@ -120,7 +120,7 @@ public ConfigSection Section
         IDefiningConfigKey<T> IEntity<IDefiningConfigKey<T>>.Self => this;
 
         /// <inheritdoc/>
-        public Type ValueType { get; } = typeof(T);
+        public Type ValueType => _valueType;
 
         /// <summary>
         /// Gets the logger of the config this item belongs to.
diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index ad19951..22ad9b0 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.2-MonkeySync-beta</Version>
+    <Version>0.24.3-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index a76489b..9f71911 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -28,7 +28,6 @@ public interface IMonkeySyncObject : INotifyPropertyChanged
         /// <summary>
         /// Gets the link object used by this sync object.
         /// </summary>
-        [MaybeNull]
         public object LinkObject { get; }
     }
 
@@ -41,7 +40,6 @@ public interface IMonkeySyncObject<out TLink> : IMonkeySyncObject
         where TLink : class
     {
         /// <inheritdoc cref="IMonkeySyncObject.LinkObject"/>
-        [MaybeNull]
         public new TLink LinkObject { get; }
     }
 
@@ -77,10 +75,8 @@ public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IMonkey
         public abstract bool IsLinkValid { get; }
 
         /// <inheritdoc/>
-        [MaybeNull]
-        public TLink LinkObject { get; private set; }
+        public TLink LinkObject { get; private set; } = null!;
 
-        [MaybeNull]
         object IMonkeySyncObject.LinkObject => LinkObject;
 
         static MonkeySyncObject()
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index d6c17cf..dcb2aac 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -18,6 +18,12 @@ public interface IMonkeySyncValue : INotifyValueChanged
         /// Gets or sets the internal value of this sync value.
         /// </summary>
         public object? Value { get; set; }
+
+        /// <summary>
+        /// Gets the concrete <see cref="Type"/> of
+        /// the wrapped <see cref="Value">Value</see>.
+        /// </summary>
+        public Type ValueType { get; }
     }
 
     /// <summary>
@@ -67,6 +73,8 @@ public interface IWriteOnlyMonkeySyncValue<in T> : IMonkeySyncValue
     /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
     public class MonkeySyncValue<T> : IMonkeySyncValue<T>
     {
+        private static readonly Type _valueType = typeof(T);
+
         private ValueChangedEventHandler? _untypedChanged;
         private T _value;
 
@@ -91,6 +99,9 @@ public T Value
             set => Value = (T)value!;
         }
 
+        /// <inheritdoc/>
+        public Type ValueType => _valueType;
+
         /// <summary>
         /// Creates a new sync object instance that wraps the given <paramref name="value"/>.
         /// </summary>
@@ -112,6 +123,9 @@ public MonkeySyncValue(T value)
         /// <param name="syncValue">The sync object to unwrap.</param>
         public static implicit operator T(MonkeySyncValue<T> syncValue) => syncValue.Value;
 
+        /// <inheritdoc/>
+        public override string ToString() => Value?.ToString() ?? "";
+
         /// <summary>
         /// Handles the value of this config item potentially having changed.
         /// If the <paramref name="oldValue"/> and new value are different:<br/>

From f8e82127dc67c20d7030e0a1c5a582a6afb91fed Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Tue, 28 Jan 2025 14:32:40 +0100
Subject: [PATCH 07/22] Add more features to MonkeySyncObject

---
 MonkeyLoader/MonkeyLoader.csproj      |   2 +-
 MonkeyLoader/Sync/MonkeySyncObject.cs | 204 ++++++++++++++++++++++----
 2 files changed, 180 insertions(+), 26 deletions(-)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 22ad9b0..2d405c9 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.3-MonkeySync-beta</Version>
+    <Version>0.24.4-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index 9f71911..be3eda7 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -1,4 +1,6 @@
-using HarmonyLib;
+using EnumerableToolkit;
+using HarmonyLib;
+using MonkeyLoader.Meta;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -8,11 +10,22 @@
 
 namespace MonkeyLoader.Sync
 {
+    /// <summary>
+    /// Defines the generic interface for <see cref="MonkeySyncObject{TSyncObject,
+    /// TSyncValues, TLink}">MonkeySync objects</see> that have been linked.
+    /// </summary>
+    /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+    public interface ILinkedMonkeySyncObject<out TLink> : IMonkeySyncObject
+    {
+        /// <inheritdoc cref="IMonkeySyncObject.LinkObject"/>
+        public new TLink LinkObject { get; }
+    }
+
     /// <summary>
     /// Defines the non-generic interface for <see cref="MonkeySyncObject{TSyncObject,
     /// TSyncValues, TLink}">MonkeySync objects</see>.
     /// </summary>
-    public interface IMonkeySyncObject : INotifyPropertyChanged
+    public interface IMonkeySyncObject : INotifyPropertyChanged, IDisposable
     {
         /// <summary>
         /// Gets whether this sync object has a <see cref="LinkObject">link object</see>.
@@ -33,14 +46,22 @@ public interface IMonkeySyncObject : INotifyPropertyChanged
 
     /// <summary>
     /// Defines the generic interface for <see cref="MonkeySyncObject{TSyncObject,
-    /// TSyncValues, TLink}">MonkeySync objects</see>.
+    /// TSyncValues, TLink}">MonkeySync objects</see> that are yet to be linked.
     /// </summary>
-    /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
-    public interface IMonkeySyncObject<out TLink> : IMonkeySyncObject
+    /// <inheritdoc/>
+    public interface IUnlinkedMonkeySyncObject<TLink> : ILinkedMonkeySyncObject<TLink>
         where TLink : class
     {
-        /// <inheritdoc cref="IMonkeySyncObject.LinkObject"/>
-        public new TLink LinkObject { get; }
+        /// <summary>
+        /// Establishes this sync object's link with the given object.
+        /// </summary>
+        /// <remarks>
+        /// If the link fails or gets broken, a new instance has to be created.
+        /// </remarks>
+        /// <param name="linkObject">The link object to be used by this sync object.</param>
+        /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
+        /// <returns><c>true</c> if the established link is valid; otherwise, <c>false</c>.</returns>
+        public bool LinkWith(TLink linkObject, bool fromRemote = false);
     }
 
     /// <summary>
@@ -52,7 +73,7 @@ public interface IMonkeySyncObject<out TLink> : IMonkeySyncObject
     /// that the MonkeySync values of this object must implement.
     /// </typeparam>
     /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
-    public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IMonkeySyncObject<TLink>
+    public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlinkedMonkeySyncObject<TLink>
         where TSyncObject : MonkeySyncObject<TSyncObject, TSyncValue, TLink>
         where TSyncValue : IMonkeySyncValue
         where TLink : class
@@ -67,6 +88,8 @@ public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IMonkey
         /// </summary>
         protected static readonly Dictionary<string, Func<TSyncObject, TSyncValue>> propertyAccessorsByName = new(StringComparer.Ordinal);
 
+        private bool _disposedValue;
+
         /// <inheritdoc/>
         [MemberNotNullWhen(true, nameof(LinkObject))]
         public bool HasLinkObject => LinkObject is not null;
@@ -96,21 +119,30 @@ static MonkeySyncObject()
         }
 
         /// <summary>
-        /// Establishes this sync object's link with the given object.
+        /// Ensures any unmanaged resources are <see cref="Dispose(bool)">disposed</see>.
         /// </summary>
-        /// <remarks>
-        /// If the link fails or gets broken, a new instance has to be created.
-        /// </remarks>
-        /// <param name="linkObject">The link object to be used by this sync object.</param>
-        /// <returns><c>true</c> if the established link is valid; otherwise, <c>false</c>.</returns>
-        public bool LinkWith(TLink linkObject)
+        ~MonkeySyncObject()
+        {
+            Dispose(false);
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            // Do not change this code. Put cleanup code in the 'OnDisposing()' or 'OnFinalizing()' methods
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <inheritdoc/>
+        public bool LinkWith(TLink linkObject, bool fromRemote = false)
         {
             if (HasLinkObject)
                 throw new InvalidOperationException("Can only assign a link object once!");
 
             LinkObject = linkObject;
 
-            return EstablishLinkWith(linkObject);
+            return EstablishLinkWith(linkObject, fromRemote);
         }
 
         /// <summary>
@@ -118,43 +150,93 @@ public bool LinkWith(TLink linkObject)
         /// </summary>
         /// <param name="propertyName">The name of the sync value to link.</param>
         /// <param name="syncValue">The sync value to link.</param>
+        /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
         /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
-        protected abstract bool EstablishLinkFor(string propertyName, TSyncValue syncValue);
+        protected abstract bool EstablishLinkFor(string propertyName, TSyncValue syncValue, bool fromRemote);
 
         /// <summary>
         /// Creates a link for the given sync method of the given name.
         /// </summary>
         /// <param name="methodName">The name of the sync method to link.</param>
         /// <param name="syncMethod">The sync method to link.</param>
+        /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
         /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
-        protected abstract bool EstablishLinkFor(string methodName, Action<TSyncObject> syncMethod);
+        protected abstract bool EstablishLinkFor(string methodName, Action<TSyncObject> syncMethod, bool fromRemote);
 
         /// <remarks><para>
-        /// <i>By default:</i> Calls <see cref="EstablishLinkFor(string, TSyncValue)">EstablishLinkFor</see>
+        /// <i>By default:</i> Sets up the <see cref="INotifyValueChanged.Changed"/> event handlers
+        /// and calls <see cref="EstablishLinkFor(string, TSyncValue, bool)">EstablishLinkFor</see>
         /// for every readable <typeparamref name="TSyncValue"/> instance property and
-        /// <see cref="EstablishLinkFor(string, TSyncValue)">its overload</see> for every
+        /// <see cref="EstablishLinkFor(string, TSyncValue, bool)">its overload</see> for every
         /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
         /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
         /// while the detected methods are stored in <see cref="methodsByName">methodsByName</see>.
         /// </para><para>
         /// This method is called by <see cref="LinkWith">LinkWith</see>
-        /// after the <see cref="LinkObject">LinkObject</see> has been assigned.
+        /// after the <see cref="LinkObject">LinkObject</see> has been assigned.<br/>
+        /// It should ensure that a link object created from the remote side
+        /// is handled appropriately and without duplications as well.
         /// </para>
         /// </remarks>
         /// <inheritdoc cref="LinkWith"/>
-        protected virtual bool EstablishLinkWith(TLink linkObject)
+        protected virtual bool EstablishLinkWith(TLink linkObject, bool fromRemote)
         {
             var success = true;
 
             foreach (var syncValueProperty in propertyAccessorsByName)
-                success &= EstablishLinkFor(syncValueProperty.Key, syncValueProperty.Value((TSyncObject)this));
+            {
+                var syncValue = syncValueProperty.Value((TSyncObject)this);
+
+                syncValue.Changed += (sender, changedArgs)
+                    => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(syncValueProperty.Key));
+
+                success &= EstablishLinkFor(syncValueProperty.Key, syncValue, fromRemote);
+            }
 
             foreach (var syncMethod in methodsByName)
-                success &= EstablishLinkFor(syncMethod.Key, syncMethod.Value);
+                success &= EstablishLinkFor(syncMethod.Key, syncMethod.Value, fromRemote);
 
             return success;
         }
 
+        /// <summary>
+        /// Cleans up any managed resources as part of <see cref="Dispose()">disposing</see>.
+        /// </summary>
+        /// <remarks>
+        /// <i>By default:</i> Disposes the <see cref="LinkObject">LinkObject</see> if it's <see cref="IDisposable"/>.
+        /// </remarks>
+        protected virtual void OnDisposing()
+        {
+            if (LinkObject is IDisposable disposable)
+                disposable.Dispose();
+        }
+
+        /// <summary>
+        /// Cleans up any unmanaged resources as part of
+        /// <see cref="Dispose()">disposing</see> or <see cref="~MonkeySyncObject()"/>finalization.
+        /// </summary>
+        protected virtual void OnFinalizing()
+        { }
+
+        /// <summary>
+        /// <see cref="TryRestoreLink">Tries to restore the link</see> when it becomes invalidated
+        /// and triggers the <see cref="Invalidated">Invalidated</see> when that fails.<br/>
+        /// Afterwards, the object is automatically <see cref="Dispose()">disposed</see>.
+        /// </summary>
+        /// <remarks>
+        /// Should be called from a derived class when something happens
+        /// that makes <see cref="IsLinkValid">IsLinkValid</see> <c>false</c>.
+        /// </remarks>
+        protected void OnLinkInvalidated()
+        {
+            if (!IsLinkValid && TryRestoreLink() && IsLinkValid)
+                return;
+
+            Invalidated.TryInvokeAll();
+
+            Dispose();
+        }
+
         /// <summary>
         /// Triggers the <see cref="PropertyChanged">PropertyChanged</see>
         /// event with the given <paramref name="propertyName"/>.
@@ -162,14 +244,86 @@ protected virtual bool EstablishLinkWith(TLink linkObject)
         /// <remarks>
         /// This is automatically called for any <see cref="MonkeySyncValue{T}"/> properties.
         /// </remarks>
-        /// <param name="propertyName"></param>
+        /// <param name="propertyName">The name of the property that changed.</param>
         protected void OnPropertyChanged(string propertyName)
         {
+            // Still needs to be hooked up somewhere
             var eventData = new PropertyChangedEventArgs(propertyName);
 
             PropertyChanged?.Invoke(this, eventData);
         }
 
+        /// <remarks><para>
+        /// <i>By default:</i> Calls <see cref="TryRestoreLinkFor(string, TSyncValue)">TryRestoreLinkFor</see>
+        /// for every readable <typeparamref name="TSyncValue"/> instance property and
+        /// <see cref="TryRestoreLinkFor(string, TSyncValue)">its overload</see> for every
+        /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
+        /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
+        /// while the detected methods are stored in <see cref="methodsByName">methodsByName</see>.
+        /// </para><para>
+        /// This method is called by <see cref="OnLinkInvalidated">OnLinkInvalidated</see>
+        /// if <see cref="IsLinkValid">IsLinkValid</see> has become <c>false</c>.<br/>
+        /// It should ensure that any still valid links are
+        /// handled appropriately and without duplications as well.
+        /// </para>
+        /// </remarks>
+        /// <inheritdoc cref="OnLinkInvalidated"/>
+        protected virtual bool TryRestoreLink()
+        {
+            var success = true;
+
+            foreach (var syncValueProperty in propertyAccessorsByName)
+                success &= TryRestoreLinkFor(syncValueProperty.Key, syncValueProperty.Value((TSyncObject)this));
+
+            foreach (var syncMethod in methodsByName)
+                success &= TryRestoreLinkFor(syncMethod.Key, syncMethod.Value);
+
+            return success;
+        }
+
+        /// <summary>
+        /// Tries to restore the link for the given sync value of the given name.
+        /// </summary>
+        /// <param name="propertyName">The name of the sync value to link.</param>
+        /// <param name="syncValue">The sync value to link.</param>
+        /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
+        protected abstract bool TryRestoreLinkFor(string propertyName, TSyncValue syncValue);
+
+        /// <summary>
+        /// Tries to restore the link for the given sync method of the given name.
+        /// </summary>
+        /// <param name="methodName">The name of the sync method to link.</param>
+        /// <param name="syncMethod">The sync method to link.</param>
+        /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
+        protected abstract bool TryRestoreLinkFor(string methodName, Action<TSyncObject> syncMethod);
+
+        private void Dispose(bool disposing)
+        {
+            if (_disposedValue)
+                return;
+
+            if (disposing)
+                OnDisposing();
+
+            OnFinalizing();
+
+            _disposedValue = true;
+        }
+
+        /// <summary>
+        /// Occurs when <see cref="IsLinkValid">IsLinkValid</see> becomes <c>false</c>
+        /// and it could not be <see cref="TryRestoreLink">restored</see>.
+        /// </summary>
+        public event InvalidatedHandler? Invalidated;
+
+        /// <summary>
+        /// Represents the method that will handle the <see cref="Invalidated">Invalidated</see>
+        /// event raised when <see cref="IsLinkValid">IsLinkValid</see> becomes <c>false</c>
+        /// and it could not be <see cref="TryRestoreLink">restored</see>.
+        /// </summary>
+        /// <param name="syncObject"></param>
+        public delegate void InvalidatedHandler(TSyncObject syncObject);
+
         /// <inheritdoc/>
         public event PropertyChangedEventHandler? PropertyChanged;
     }

From 42a0d2ac7d9190714e8321073d6735e93e7ae193 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Tue, 28 Jan 2025 23:05:33 +0100
Subject: [PATCH 08/22] Add MonkeySyncObjectRegistry

---
 MonkeyLoader/MonkeyLoader.csproj              |   2 +-
 .../Sync/MonkeySyncMethodAttribute.cs         |   4 +-
 MonkeyLoader/Sync/MonkeySyncObject.cs         |  11 +-
 MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs | 165 ++++++++++++++++++
 MonkeyLoader/Sync/RegisteredSyncObject.cs     |  51 ++++++
 5 files changed, 229 insertions(+), 4 deletions(-)
 create mode 100644 MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs
 create mode 100644 MonkeyLoader/Sync/RegisteredSyncObject.cs

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 2d405c9..a591c4c 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.4-MonkeySync-beta</Version>
+    <Version>0.24.5-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs b/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
index e653956..c1cb079 100644
--- a/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
+++ b/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
@@ -3,8 +3,8 @@
 namespace MonkeyLoader.Sync
 {
     /// <summary>
-    /// Marks a <see cref="MonkeySyncObject{T}"/>'s instance method as
-    /// being triggerable through the Sync system.
+    /// Marks a <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync
+    /// object's</see> instance method as being triggerable through the MonkeySync system.
     /// </summary>
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
     public sealed class MonkeySyncMethodAttribute : MonkeyLoaderAttribute
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index be3eda7..e1e76be 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -10,6 +10,15 @@
 
 namespace MonkeyLoader.Sync
 {
+    /// <summary>
+    /// Represents the method that will create new instances
+    /// of sync objects linking via <typeparamref name="TLink"/>.
+    /// </summary>
+    /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+    /// <returns>The created but not yet linked sync object.</returns>
+    public delegate IUnlinkedMonkeySyncObject<TLink> SyncObjectFactory<TLink>()
+        where TLink : class;
+
     /// <summary>
     /// Defines the generic interface for <see cref="MonkeySyncObject{TSyncObject,
     /// TSyncValues, TLink}">MonkeySync objects</see> that have been linked.
@@ -321,7 +330,7 @@ private void Dispose(bool disposing)
         /// event raised when <see cref="IsLinkValid">IsLinkValid</see> becomes <c>false</c>
         /// and it could not be <see cref="TryRestoreLink">restored</see>.
         /// </summary>
-        /// <param name="syncObject"></param>
+        /// <param name="syncObject">The sync object that got invalidated.</param>
         public delegate void InvalidatedHandler(TSyncObject syncObject);
 
         /// <inheritdoc/>
diff --git a/MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs b/MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs
new file mode 100644
index 0000000..164cfe7
--- /dev/null
+++ b/MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs
@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+
+namespace MonkeyLoader.Sync
+{
+    /// <summary>
+    /// Handles globally registering <see cref="MonkeySyncObject{TSyncObject,
+    /// TSyncValue, TLink}">MonkeySync objects</see> for particular link types,
+    /// so that the link implementations can create them.
+    /// </summary>
+    public static class MonkeySyncRegistry
+    {
+        /// <summary>
+        /// Gets the <see cref="RegisteredSyncObject{TLink}"/> for the given <paramref name="name"/>.
+        /// </summary>
+        /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+        /// <param name="name">The name of the registered sync object.</param>
+        /// <returns>The found <see cref="RegisteredSyncObject{TLink}"/>.</returns>
+        /// <exception cref="KeyNotFoundException">When no sync object with the given <paramref name="name"/> has been registered.</exception>
+        public static RegisteredSyncObject<TLink> GetRegisteredSyncObject<TLink>(string name)
+                where TLink : class
+            => Library<TLink>.GetRegisteredSyncObject(name);
+
+        /// <summary>
+        /// Gets the <see cref="RegisteredSyncObject{TLink}"/> for the given <paramref name="syncObjectType"/>.
+        /// </summary>
+        /// <param name="syncObjectType">The type of registered sync object.</param>
+        /// <inheritdoc cref="GetRegisteredSyncObject{TLink}(string)"/>
+        public static RegisteredSyncObject<TLink> GetRegisteredSyncObject<TLink>(Type syncObjectType)
+                where TLink : class
+            => Library<TLink>.GetRegisteredSyncObject(syncObjectType);
+
+        /// <summary>
+        /// Registers a <see cref="MonkeySyncObject{TSyncObject, TSyncValue,
+        /// TLink}">MonkeySync object</see> type with the given details for it.
+        /// </summary>
+        /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+        /// <param name="name">The <typeparamref name="TLink"/>-unique name for the sync object type.</param>
+        /// <param name="syncObjectType">The type of the sync object.</param>
+        /// <param name="createSyncObject">A factory method that creates new instances of this sync object type.</param>
+        /// <returns>The data of the newly registered sync object type.</returns>
+        /// <exception cref="ArgumentException">
+        /// When the <paramref name="syncObjectType"/> or one with the same
+        /// <paramref name="name"/> has already been registered.
+        /// </exception>
+        public static RegisteredSyncObject<TLink> RegisterSyncObject<TLink>(string name, Type syncObjectType, SyncObjectFactory<TLink> createSyncObject)
+                where TLink : class
+            => Library<TLink>.RegisterSyncObject(name, syncObjectType, createSyncObject);
+
+        /// <summary>
+        /// Tries to get the <see cref="RegisteredSyncObject{TLink}"/> for the given <paramref name="name"/>.
+        /// </summary>
+        /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+        /// <param name="name">The name of the registered sync object.</param>
+        /// <param name="registeredSyncObject">The found <see cref="RegisteredSyncObject{TLink}"/>; otherwise, <c>null</c>.</param>
+        /// <returns><c>true</c> if the registered sync object type was found; otherwise, <c>false</c>.</returns>
+        public static bool TryGetRegisteredSyncObject<TLink>(string name, [NotNullWhen(true)] out RegisteredSyncObject<TLink>? registeredSyncObject)
+                where TLink : class
+            => Library<TLink>.TryGetRegisteredSyncObject(name, out registeredSyncObject);
+
+        /// <summary>
+        /// Tries to get the <see cref="RegisteredSyncObject{TLink}"/> for the given <paramref name="syncObjectType"/>.
+        /// </summary>
+        /// <param name="syncObjectType"></param>
+        /// <param name="registeredSyncObject">The found <see cref="RegisteredSyncObject{TLink}"/>; otherwise, <c>null</c>.</param>
+        /// <returns><c>true</c> if the registered sync object type was found; otherwise, <c>false</c>.</returns>
+        public static bool TryGetRegisteredSyncObject<TLink>(Type syncObjectType, [NotNullWhen(true)] out RegisteredSyncObject<TLink>? registeredSyncObject)
+                where TLink : class
+            => Library<TLink>.TryGetRegisteredSyncObject(syncObjectType, out registeredSyncObject);
+
+        /// <summary>
+        /// Removes the sync object type with the given <paramref name="name"/>.
+        /// </summary>
+        /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+        /// <param name="name">The name of the registered sync object.</param>
+        /// <returns>
+        /// <c>true</c> if the registered sync object type with the given <paramref name="name"/> was removed; otherwise, <c>false</c>.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">
+        /// When there's a registered sync object type with the given <paramref name="name"/>,
+        /// but none with the associated <see cref="Type"/> - or there's a <see cref="RegisteredSyncObject{TLink}.Name">Name</see> mismatch.
+        /// </exception>
+        public static bool UnregisterSyncObject<TLink>(string name)
+                where TLink : class
+            => Library<TLink>.UnregisterSyncObject(name);
+
+        /// <summary>
+        /// Removes the sync object type for the given <paramref name="syncObjectType"/>.
+        /// </summary>
+        /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+        /// <param name="syncObjectType">The type of the registered sync object.</param>
+        /// <returns>
+        /// <c>true</c> if the registered sync object type for the given <paramref name="syncObjectType"/> was removed; otherwise, <c>false</c>.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">
+        /// When there's a registered sync object type for the given <paramref name="syncObjectType"/>,
+        /// but none with the associated Name - or there's a <see cref="RegisteredSyncObject{TLink}.SyncObjectType">Type</see> mismatch.
+        /// </exception>
+        public static bool UnregisterSyncObject<TLink>(Type syncObjectType)
+                where TLink : class
+            => Library<TLink>.UnregisterSyncObject(syncObjectType);
+
+        private static class Library<TLink>
+            where TLink : class
+        {
+            private static readonly Dictionary<Type, RegisteredSyncObject<TLink>> _registeredObjectByType = [];
+            private static readonly Dictionary<string, RegisteredSyncObject<TLink>> _registeredObjectsByName = new(StringComparer.Ordinal);
+
+            public static RegisteredSyncObject<TLink> GetRegisteredSyncObject(string name)
+                => _registeredObjectsByName[name];
+
+            public static RegisteredSyncObject<TLink> GetRegisteredSyncObject(Type type)
+                => _registeredObjectByType[type];
+
+            public static RegisteredSyncObject<TLink> RegisterSyncObject(string name, Type syncObjectType, SyncObjectFactory<TLink> createSyncObject)
+            {
+                if (_registeredObjectsByName.ContainsKey(name) || _registeredObjectByType.ContainsKey(syncObjectType))
+                    throw new ArgumentException($"Sync Object type [{syncObjectType.CompactDescription()}] with name [{name}] has already been registered!");
+
+                var registeredObject = new RegisteredSyncObject<TLink>(name, syncObjectType, createSyncObject);
+
+                _registeredObjectsByName.Add(name, registeredObject);
+                _registeredObjectByType.Add(syncObjectType, registeredObject);
+
+                return registeredObject;
+            }
+
+            public static bool TryGetRegisteredSyncObject(string name, [NotNullWhen(true)] out RegisteredSyncObject<TLink>? registeredSyncObject)
+                => _registeredObjectsByName.TryGetValue(name, out registeredSyncObject);
+
+            public static bool TryGetRegisteredSyncObject(Type type, [NotNullWhen(true)] out RegisteredSyncObject<TLink>? registeredSyncObject)
+                => _registeredObjectByType.TryGetValue(type, out registeredSyncObject);
+
+            internal static bool UnregisterSyncObject(string name)
+            {
+                if (!TryGetRegisteredSyncObject(name, out var registeredObject))
+                    return false;
+
+                if (!TryGetRegisteredSyncObject(registeredObject.SyncObjectType, out var registeredObject2) || registeredObject.Name != registeredObject2.Name)
+                    throw new InvalidOperationException($"No Sync Object type found using type [{registeredObject.SyncObjectType.CompactDescription()} based on the name [{name}], or name [{registeredObject2?.Name ?? "N/A"}] doesn't match!");
+
+                _registeredObjectsByName.Remove(name);
+                _registeredObjectByType.Remove(registeredObject.SyncObjectType);
+
+                return true;
+            }
+
+            internal static bool UnregisterSyncObject(Type syncObjectType)
+            {
+                if (!TryGetRegisteredSyncObject(syncObjectType, out var registeredObject))
+                    return false;
+
+                if (!TryGetRegisteredSyncObject(registeredObject.Name, out var registeredObject2) || registeredObject.SyncObjectType != registeredObject2.SyncObjectType)
+                    throw new InvalidOperationException($"No Sync Object type found using name [{registeredObject.Name} based on the type [{syncObjectType.CompactDescription()}], or type [{registeredObject2?.SyncObjectType.CompactDescription() ?? "N/A"}] doesn't match!");
+
+                _registeredObjectByType.Remove(syncObjectType);
+                _registeredObjectsByName.Remove(registeredObject.Name);
+
+                return true;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonkeyLoader/Sync/RegisteredSyncObject.cs b/MonkeyLoader/Sync/RegisteredSyncObject.cs
new file mode 100644
index 0000000..9bd9ccc
--- /dev/null
+++ b/MonkeyLoader/Sync/RegisteredSyncObject.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MonkeyLoader.Sync
+{
+    /// <summary>
+    /// A simple data class that allows the <see cref="MonkeySyncRegistry"/> to track the known
+    /// <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync object</see> types.
+    /// </summary>
+    /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+    public sealed class RegisteredSyncObject<TLink>
+        where TLink : class
+    {
+        private readonly SyncObjectFactory<TLink> _createSyncObject;
+
+        /// <summary>
+        /// Gets the <typeparamref name="TLink"/>-unique name for the registered
+        /// <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync object</see> type.
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Gets the <see cref="Type"/> of the registered
+        /// <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync object</see>.
+        /// </summary>
+        public Type SyncObjectType { get; }
+
+        /// <summary>
+        /// Creates a new instance of this data class with the given details for a
+        /// <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync object</see> type.
+        /// </summary>
+        /// <param name="name">The <typeparamref name="TLink"/>-unique name for the sync object type.</param>
+        /// <param name="syncObjectType">The type of the sync object.</param>
+        /// <param name="createSyncObject">A factory method that creates new instances of this sync object type.</param>
+        public RegisteredSyncObject(string name, Type syncObjectType, SyncObjectFactory<TLink> createSyncObject)
+        {
+            Name = name;
+            SyncObjectType = syncObjectType;
+            _createSyncObject = createSyncObject;
+        }
+
+        /// <summary>
+        /// Creates a new instance of the registered
+        /// <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync object</see>.
+        /// </summary>
+        /// <returns>The created but not yet linked sync object.</returns>
+        public IUnlinkedMonkeySyncObject<TLink> CreateSyncObject()
+            => _createSyncObject();
+    }
+}
\ No newline at end of file

From 8e6e5cd91d66dafe81eff884f4dd24181705befd Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Thu, 30 Jan 2025 20:48:10 +0100
Subject: [PATCH 09/22] Add linked SyncObject instance registration to
 SyncObjectRegistry

---
 MonkeyLoader/MonkeyLoader.csproj              |   2 +-
 MonkeyLoader/Sync/MonkeySyncObject.cs         |  13 ++
 ...ect.cs => MonkeySyncObjectRegistration.cs} |   4 +-
 MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs | 175 ++++++++++++++----
 4 files changed, 154 insertions(+), 40 deletions(-)
 rename MonkeyLoader/Sync/{RegisteredSyncObject.cs => MonkeySyncObjectRegistration.cs} (92%)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index a591c4c..5e70f9f 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.5-MonkeySync-beta</Version>
+    <Version>0.24.6-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index e1e76be..c4bd080 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -1,6 +1,7 @@
 using EnumerableToolkit;
 using HarmonyLib;
 using MonkeyLoader.Meta;
+using MonkeyLoader.Patching;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -127,6 +128,18 @@ static MonkeySyncObject()
                 methodsByName.Add(method.Name, (TSyncObject instance) => method.Invoke(instance, null));
         }
 
+        /// <summary>
+        /// Initializes a new instance of this MonkeySync object.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// When <typeparamref name="TSyncObject"/> is not the type being instantiated.
+        /// </exception>
+        protected MonkeySyncObject()
+        {
+            if (GetType() != typeof(TSyncObject))
+                throw new InvalidOperationException("TSyncObject must be the concrete Type being instantiated!");
+        }
+
         /// <summary>
         /// Ensures any unmanaged resources are <see cref="Dispose(bool)">disposed</see>.
         /// </summary>
diff --git a/MonkeyLoader/Sync/RegisteredSyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObjectRegistration.cs
similarity index 92%
rename from MonkeyLoader/Sync/RegisteredSyncObject.cs
rename to MonkeyLoader/Sync/MonkeySyncObjectRegistration.cs
index 9bd9ccc..7c4b2ae 100644
--- a/MonkeyLoader/Sync/RegisteredSyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObjectRegistration.cs
@@ -9,7 +9,7 @@ namespace MonkeyLoader.Sync
     /// <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync object</see> types.
     /// </summary>
     /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
-    public sealed class RegisteredSyncObject<TLink>
+    public sealed class MonkeySyncObjectRegistration<TLink>
         where TLink : class
     {
         private readonly SyncObjectFactory<TLink> _createSyncObject;
@@ -33,7 +33,7 @@ public sealed class RegisteredSyncObject<TLink>
         /// <param name="name">The <typeparamref name="TLink"/>-unique name for the sync object type.</param>
         /// <param name="syncObjectType">The type of the sync object.</param>
         /// <param name="createSyncObject">A factory method that creates new instances of this sync object type.</param>
-        public RegisteredSyncObject(string name, Type syncObjectType, SyncObjectFactory<TLink> createSyncObject)
+        public MonkeySyncObjectRegistration(string name, Type syncObjectType, SyncObjectFactory<TLink> createSyncObject)
         {
             Name = name;
             SyncObjectType = syncObjectType;
diff --git a/MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs b/MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs
index 164cfe7..832757e 100644
--- a/MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObjectRegistry.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Text;
 
 namespace MonkeyLoader.Sync
@@ -8,29 +9,69 @@ namespace MonkeyLoader.Sync
     /// <summary>
     /// Handles globally registering <see cref="MonkeySyncObject{TSyncObject,
     /// TSyncValue, TLink}">MonkeySync objects</see> for particular link types,
-    /// so that the link implementations can create them.
+    /// so that the link implementations can create and reference them.
     /// </summary>
     public static class MonkeySyncRegistry
     {
         /// <summary>
-        /// Gets the <see cref="RegisteredSyncObject{TLink}"/> for the given <paramref name="name"/>.
+        /// Gets the <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync
+        /// object</see> linked with the given link object.
+        /// </summary>
+        /// <returns>The found <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync object</see>.</returns>
+        /// <exception cref="KeyNotFoundException">When no sync object is registered for the link object.</exception>
+        /// <inheritdoc cref="TryGetLinkedSyncObject{TLink}"/>
+        public static ILinkedMonkeySyncObject<TLink> GetLinkedSyncObject<TLink>(TLink linkObject)
+            where TLink : class
+        {
+            if (Library<TLink>.TryGetLinkedSyncObject(linkObject, out var syncObject))
+                return syncObject;
+
+            throw new KeyNotFoundException("No sync object found for the given link object!");
+        }
+
+        /// <summary>
+        /// Gets the <see cref="MonkeySyncObjectRegistration{TLink}"/> for the given <paramref name="syncObjectType"/>.
+        /// </summary>
+        /// <param name="syncObjectType">The type of registered sync object.</param>
+        /// <inheritdoc cref="GetSyncObjectRegistration{TLink}(string)"/>
+        public static MonkeySyncObjectRegistration<TLink> GetSyncObjectRegistration<TLink>(Type syncObjectType)
+                where TLink : class
+            => Library<TLink>.GetSyncObjectRegistration(syncObjectType);
+
+        /// <summary>
+        /// Gets the <see cref="MonkeySyncObjectRegistration{TLink}"/> for the given <paramref name="name"/>.
         /// </summary>
         /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
         /// <param name="name">The name of the registered sync object.</param>
-        /// <returns>The found <see cref="RegisteredSyncObject{TLink}"/>.</returns>
+        /// <returns>The found <see cref="MonkeySyncObjectRegistration{TLink}"/>.</returns>
         /// <exception cref="KeyNotFoundException">When no sync object with the given <paramref name="name"/> has been registered.</exception>
-        public static RegisteredSyncObject<TLink> GetRegisteredSyncObject<TLink>(string name)
+        public static MonkeySyncObjectRegistration<TLink> GetSyncObjectRegistration<TLink>(string name)
                 where TLink : class
-            => Library<TLink>.GetRegisteredSyncObject(name);
+            => Library<TLink>.GetSyncObjectRegistration(name);
 
         /// <summary>
-        /// Gets the <see cref="RegisteredSyncObject{TLink}"/> for the given <paramref name="syncObjectType"/>.
+        /// Determines whether there is a registered <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync
+        /// object</see> that is linked to the given <see cref="ILinkedMonkeySyncObject{TLink}.LinkObject">link object</see>.
         /// </summary>
-        /// <param name="syncObjectType">The type of registered sync object.</param>
-        /// <inheritdoc cref="GetRegisteredSyncObject{TLink}(string)"/>
-        public static RegisteredSyncObject<TLink> GetRegisteredSyncObject<TLink>(Type syncObjectType)
+        /// <inheritdoc cref="TryGetLinkedSyncObject{TLink}"/>
+        public static bool HasLinkedSyncObject<TLink>(TLink linkObject)
+                where TLink : class
+            => Library<TLink>.TryGetLinkedSyncObject(linkObject, out _);
+
+        /// <summary>
+        /// Registers a linked <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync
+        /// object</see> so that it can be <see cref="TryGetLinkedSyncObject{TLink}">accessed</see>
+        /// through a reference to its <see cref="ILinkedMonkeySyncObject{TLink}.LinkObject">link object</see>.
+        /// </summary>
+        /// <remarks>
+        /// The link is held in a <see cref="ConditionalWeakTable{TKey, TValue}"/> -
+        /// as such, the sync object may be garbage collected when the link object is.
+        /// </remarks>
+        /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+        /// <param name="syncObject">The linked sync object to register.</param>
+        public static void RegisterLinkedSyncObject<TLink>(ILinkedMonkeySyncObject<TLink> syncObject)
                 where TLink : class
-            => Library<TLink>.GetRegisteredSyncObject(syncObjectType);
+            => Library<TLink>.RegisterLinkedSyncObject(syncObject);
 
         /// <summary>
         /// Registers a <see cref="MonkeySyncObject{TSyncObject, TSyncValue,
@@ -45,30 +86,67 @@ public static RegisteredSyncObject<TLink> GetRegisteredSyncObject<TLink>(Type sy
         /// When the <paramref name="syncObjectType"/> or one with the same
         /// <paramref name="name"/> has already been registered.
         /// </exception>
-        public static RegisteredSyncObject<TLink> RegisterSyncObject<TLink>(string name, Type syncObjectType, SyncObjectFactory<TLink> createSyncObject)
+        public static MonkeySyncObjectRegistration<TLink> RegisterSyncObject<TLink>(string name, Type syncObjectType, SyncObjectFactory<TLink> createSyncObject)
                 where TLink : class
             => Library<TLink>.RegisterSyncObject(name, syncObjectType, createSyncObject);
 
         /// <summary>
-        /// Tries to get the <see cref="RegisteredSyncObject{TLink}"/> for the given <paramref name="name"/>.
+        /// Tries to get the <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync
+        /// object</see> linked with the given link object.
+        /// </summary>
+        /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+        /// <param name="linkObject">The link object used by the sync object.</param>
+        /// <param name="syncObject">The found <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync object</see>; otherwise, <c>null</c>.</param>
+        /// <returns><c>true</c> if a sync object is registered for the given link object; otherwise, <c>false</c>.</returns>
+        public static bool TryGetLinkedSyncObject<TLink>(TLink linkObject, [NotNullWhen(true)] out ILinkedMonkeySyncObject<TLink>? syncObject)
+                where TLink : class
+            => Library<TLink>.TryGetLinkedSyncObject(linkObject, out syncObject);
+
+        /// <summary>
+        /// Tries to get the <see cref="MonkeySyncObjectRegistration{TLink}"/> for the given <paramref name="name"/>.
         /// </summary>
         /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
         /// <param name="name">The name of the registered sync object.</param>
-        /// <param name="registeredSyncObject">The found <see cref="RegisteredSyncObject{TLink}"/>; otherwise, <c>null</c>.</param>
+        /// <param name="registeredSyncObject">The found <see cref="MonkeySyncObjectRegistration{TLink}"/>; otherwise, <c>null</c>.</param>
         /// <returns><c>true</c> if the registered sync object type was found; otherwise, <c>false</c>.</returns>
-        public static bool TryGetRegisteredSyncObject<TLink>(string name, [NotNullWhen(true)] out RegisteredSyncObject<TLink>? registeredSyncObject)
+        public static bool TryGetSyncObjectRegistration<TLink>(string name, [NotNullWhen(true)] out MonkeySyncObjectRegistration<TLink>? registeredSyncObject)
                 where TLink : class
-            => Library<TLink>.TryGetRegisteredSyncObject(name, out registeredSyncObject);
+            => Library<TLink>.TryGetSyncObjectRegistration(name, out registeredSyncObject);
 
         /// <summary>
-        /// Tries to get the <see cref="RegisteredSyncObject{TLink}"/> for the given <paramref name="syncObjectType"/>.
+        /// Tries to get the <see cref="MonkeySyncObjectRegistration{TLink}"/> for the given <paramref name="syncObjectType"/>.
         /// </summary>
-        /// <param name="syncObjectType"></param>
-        /// <param name="registeredSyncObject">The found <see cref="RegisteredSyncObject{TLink}"/>; otherwise, <c>null</c>.</param>
+        /// <param name="syncObjectType">The type of the sync object.</param>
+        /// <param name="registeredSyncObject">The found <see cref="MonkeySyncObjectRegistration{TLink}"/>; otherwise, <c>null</c>.</param>
         /// <returns><c>true</c> if the registered sync object type was found; otherwise, <c>false</c>.</returns>
-        public static bool TryGetRegisteredSyncObject<TLink>(Type syncObjectType, [NotNullWhen(true)] out RegisteredSyncObject<TLink>? registeredSyncObject)
+        public static bool TryGetSyncObjectRegistration<TLink>(Type syncObjectType, [NotNullWhen(true)] out MonkeySyncObjectRegistration<TLink>? registeredSyncObject)
                 where TLink : class
-            => Library<TLink>.TryGetRegisteredSyncObject(syncObjectType, out registeredSyncObject);
+            => Library<TLink>.TryGetSyncObjectRegistration(syncObjectType, out registeredSyncObject);
+
+        /// <summary>
+        /// Unregisters a linked <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync
+        /// object</see> so that it can't be <see cref="TryGetLinkedSyncObject{TLink}">accessed</see>
+        /// through a reference to its <see cref="ILinkedMonkeySyncObject{TLink}.LinkObject">link object</see> anymore.
+        /// </summary>
+        /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+        /// <param name="syncObject">The linked sync object to unregister.</param>
+        public static bool UnregisterLinkedSyncObject<TLink>(ILinkedMonkeySyncObject<TLink> syncObject)
+                where TLink : class
+            => Library<TLink>.UnregisterLinkedSyncObject(syncObject);
+
+        /// <summary>
+        /// Removes the registered <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync
+        /// object</see> that was linked to the given <see cref="ILinkedMonkeySyncObject{TLink}.LinkObject">link object</see>,
+        /// so that it can't be accessed through a reference to it anymore.<br/>
+        /// Optionally <see cref="IDisposable.Dispose">disposes</see> of the sync object if necessary.
+        /// </summary>
+        /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+        /// <param name="linkObject">The link object used by the sync object.</param>
+        /// <param name="dispose">Whether to dispose the <see cref="IDisposable.Dispose">dispose</see> of the sync object if necessary.</param>
+        /// <returns><c>true</c> if a sync object was registered for the given link object; otherwise, <c>false</c>.</returns>
+        public static bool UnregisterLinkedSyncObject<TLink>(TLink linkObject, bool dispose = false)
+                where TLink : class
+            => Library<TLink>.UnregisterLinkedSyncObject(linkObject, dispose);
 
         /// <summary>
         /// Removes the sync object type with the given <paramref name="name"/>.
@@ -80,7 +158,7 @@ public static bool TryGetRegisteredSyncObject<TLink>(Type syncObjectType, [NotNu
         /// </returns>
         /// <exception cref="InvalidOperationException">
         /// When there's a registered sync object type with the given <paramref name="name"/>,
-        /// but none with the associated <see cref="Type"/> - or there's a <see cref="RegisteredSyncObject{TLink}.Name">Name</see> mismatch.
+        /// but none with the associated <see cref="Type"/> - or there's a <see cref="MonkeySyncObjectRegistration{TLink}.Name">Name</see> mismatch.
         /// </exception>
         public static bool UnregisterSyncObject<TLink>(string name)
                 where TLink : class
@@ -96,7 +174,7 @@ public static bool UnregisterSyncObject<TLink>(string name)
         /// </returns>
         /// <exception cref="InvalidOperationException">
         /// When there's a registered sync object type for the given <paramref name="syncObjectType"/>,
-        /// but none with the associated Name - or there's a <see cref="RegisteredSyncObject{TLink}.SyncObjectType">Type</see> mismatch.
+        /// but none with the associated Name - or there's a <see cref="MonkeySyncObjectRegistration{TLink}.SyncObjectType">Type</see> mismatch.
         /// </exception>
         public static bool UnregisterSyncObject<TLink>(Type syncObjectType)
                 where TLink : class
@@ -105,21 +183,25 @@ public static bool UnregisterSyncObject<TLink>(Type syncObjectType)
         private static class Library<TLink>
             where TLink : class
         {
-            private static readonly Dictionary<Type, RegisteredSyncObject<TLink>> _registeredObjectByType = [];
-            private static readonly Dictionary<string, RegisteredSyncObject<TLink>> _registeredObjectsByName = new(StringComparer.Ordinal);
+            private static readonly Dictionary<Type, MonkeySyncObjectRegistration<TLink>> _registeredObjectByType = [];
+            private static readonly Dictionary<string, MonkeySyncObjectRegistration<TLink>> _registeredObjectsByName = new(StringComparer.Ordinal);
+            private static readonly ConditionalWeakTable<TLink, ILinkedMonkeySyncObject<TLink>> _syncObjectsByLinkObject = new();
+
+            public static MonkeySyncObjectRegistration<TLink> GetSyncObjectRegistration(Type type)
+                => _registeredObjectByType[type];
 
-            public static RegisteredSyncObject<TLink> GetRegisteredSyncObject(string name)
+            public static MonkeySyncObjectRegistration<TLink> GetSyncObjectRegistration(string name)
                 => _registeredObjectsByName[name];
 
-            public static RegisteredSyncObject<TLink> GetRegisteredSyncObject(Type type)
-                => _registeredObjectByType[type];
+            public static void RegisterLinkedSyncObject(ILinkedMonkeySyncObject<TLink> syncObject)
+                => _syncObjectsByLinkObject.Add(syncObject.LinkObject, syncObject);
 
-            public static RegisteredSyncObject<TLink> RegisterSyncObject(string name, Type syncObjectType, SyncObjectFactory<TLink> createSyncObject)
+            public static MonkeySyncObjectRegistration<TLink> RegisterSyncObject(string name, Type syncObjectType, SyncObjectFactory<TLink> createSyncObject)
             {
                 if (_registeredObjectsByName.ContainsKey(name) || _registeredObjectByType.ContainsKey(syncObjectType))
                     throw new ArgumentException($"Sync Object type [{syncObjectType.CompactDescription()}] with name [{name}] has already been registered!");
 
-                var registeredObject = new RegisteredSyncObject<TLink>(name, syncObjectType, createSyncObject);
+                var registeredObject = new MonkeySyncObjectRegistration<TLink>(name, syncObjectType, createSyncObject);
 
                 _registeredObjectsByName.Add(name, registeredObject);
                 _registeredObjectByType.Add(syncObjectType, registeredObject);
@@ -127,18 +209,37 @@ public static RegisteredSyncObject<TLink> RegisterSyncObject(string name, Type s
                 return registeredObject;
             }
 
-            public static bool TryGetRegisteredSyncObject(string name, [NotNullWhen(true)] out RegisteredSyncObject<TLink>? registeredSyncObject)
+            public static bool TryGetLinkedSyncObject(TLink linkObject, [NotNullWhen(true)] out ILinkedMonkeySyncObject<TLink>? syncObject)
+                => _syncObjectsByLinkObject.TryGetValue(linkObject, out syncObject);
+
+            public static bool TryGetSyncObjectRegistration(string name, [NotNullWhen(true)] out MonkeySyncObjectRegistration<TLink>? registeredSyncObject)
                 => _registeredObjectsByName.TryGetValue(name, out registeredSyncObject);
 
-            public static bool TryGetRegisteredSyncObject(Type type, [NotNullWhen(true)] out RegisteredSyncObject<TLink>? registeredSyncObject)
+            public static bool TryGetSyncObjectRegistration(Type type, [NotNullWhen(true)] out MonkeySyncObjectRegistration<TLink>? registeredSyncObject)
                 => _registeredObjectByType.TryGetValue(type, out registeredSyncObject);
 
-            internal static bool UnregisterSyncObject(string name)
+            public static bool UnregisterLinkedSyncObject(TLink linkObject, bool dispose)
+            {
+                if (!dispose)
+                    return _syncObjectsByLinkObject.Remove(linkObject);
+
+                if (!_syncObjectsByLinkObject.TryGetValue(linkObject, out var syncObject))
+                    return false;
+
+                (syncObject as IDisposable)?.Dispose();
+
+                return true;
+            }
+
+            public static bool UnregisterLinkedSyncObject(ILinkedMonkeySyncObject<TLink> syncObject)
+                => _syncObjectsByLinkObject.Remove(syncObject.LinkObject);
+
+            public static bool UnregisterSyncObject(string name)
             {
-                if (!TryGetRegisteredSyncObject(name, out var registeredObject))
+                if (!TryGetSyncObjectRegistration(name, out var registeredObject))
                     return false;
 
-                if (!TryGetRegisteredSyncObject(registeredObject.SyncObjectType, out var registeredObject2) || registeredObject.Name != registeredObject2.Name)
+                if (!TryGetSyncObjectRegistration(registeredObject.SyncObjectType, out var registeredObject2) || registeredObject.Name != registeredObject2.Name)
                     throw new InvalidOperationException($"No Sync Object type found using type [{registeredObject.SyncObjectType.CompactDescription()} based on the name [{name}], or name [{registeredObject2?.Name ?? "N/A"}] doesn't match!");
 
                 _registeredObjectsByName.Remove(name);
@@ -147,12 +248,12 @@ internal static bool UnregisterSyncObject(string name)
                 return true;
             }
 
-            internal static bool UnregisterSyncObject(Type syncObjectType)
+            public static bool UnregisterSyncObject(Type syncObjectType)
             {
-                if (!TryGetRegisteredSyncObject(syncObjectType, out var registeredObject))
+                if (!TryGetSyncObjectRegistration(syncObjectType, out var registeredObject))
                     return false;
 
-                if (!TryGetRegisteredSyncObject(registeredObject.Name, out var registeredObject2) || registeredObject.SyncObjectType != registeredObject2.SyncObjectType)
+                if (!TryGetSyncObjectRegistration(registeredObject.Name, out var registeredObject2) || registeredObject.SyncObjectType != registeredObject2.SyncObjectType)
                     throw new InvalidOperationException($"No Sync Object type found using name [{registeredObject.Name} based on the type [{syncObjectType.CompactDescription()}], or type [{registeredObject2?.SyncObjectType.CompactDescription() ?? "N/A"}] doesn't match!");
 
                 _registeredObjectByType.Remove(syncObjectType);

From 7aa2361d97c99fa8606838abc7d7ad82c69be0b5 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sun, 2 Feb 2025 14:46:17 +0100
Subject: [PATCH 10/22] Tweak registry behavior and make MonkeySyncValue.Value
 virtual

---
 MonkeyLoader/MonkeyLoader.csproj      | 2 +-
 MonkeyLoader/Sync/MonkeySyncObject.cs | 9 ++++++++-
 MonkeyLoader/Sync/MonkeySyncValue.cs  | 2 +-
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 5e70f9f..26a7836 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.6-MonkeySync-beta</Version>
+    <Version>0.24.7-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index c4bd080..126637b 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -191,6 +191,10 @@ public bool LinkWith(TLink linkObject, bool fromRemote = false)
         /// for every readable <typeparamref name="TSyncValue"/> instance property and
         /// <see cref="EstablishLinkFor(string, TSyncValue, bool)">its overload</see> for every
         /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
+        /// If the link is successfully created, this linked sync object will be
+        /// <see cref="MonkeySyncRegistry.RegisterLinkedSyncObject{TLink}">added</see>
+        /// to the <see cref="MonkeySyncRegistry"/> automatically.
+        /// </para><para>
         /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
         /// while the detected methods are stored in <see cref="methodsByName">methodsByName</see>.
         /// </para><para>
@@ -218,6 +222,9 @@ protected virtual bool EstablishLinkWith(TLink linkObject, bool fromRemote)
             foreach (var syncMethod in methodsByName)
                 success &= EstablishLinkFor(syncMethod.Key, syncMethod.Value, fromRemote);
 
+            if (success)
+                MonkeySyncRegistry.RegisterLinkedSyncObject(this);
+
             return success;
         }
 
@@ -235,7 +242,7 @@ protected virtual void OnDisposing()
 
         /// <summary>
         /// Cleans up any unmanaged resources as part of
-        /// <see cref="Dispose()">disposing</see> or <see cref="~MonkeySyncObject()"/>finalization.
+        /// <see cref="Dispose()">disposing</see> or finalization.
         /// </summary>
         protected virtual void OnFinalizing()
         { }
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index dcb2aac..fe023b9 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -79,7 +79,7 @@ public class MonkeySyncValue<T> : IMonkeySyncValue<T>
         private T _value;
 
         /// <inheritdoc/>
-        public T Value
+        public virtual T Value
         {
             get => _value;
 

From abbe1c8d968acab623a9903ef7ea18ce3bab6cb3 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sun, 2 Feb 2025 21:31:41 +0100
Subject: [PATCH 11/22] Restructure how SyncValues work

---
 MonkeyLoader/MonkeyLoader.csproj      |  2 +-
 MonkeyLoader/Sync/MonkeySyncObject.cs | 20 +++---
 MonkeyLoader/Sync/MonkeySyncValue.cs  | 97 ++++++++++++++++++++-------
 3 files changed, 86 insertions(+), 33 deletions(-)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 26a7836..6a5ae82 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.7-MonkeySync-beta</Version>
+    <Version>0.24.8-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index 126637b..07fd210 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -79,13 +79,13 @@ public interface IUnlinkedMonkeySyncObject<TLink> : ILinkedMonkeySyncObject<TLin
     /// </summary>
     /// <typeparam name="TSyncObject">The concrete type of the MonkeySync object.</typeparam>
     /// <typeparam name="TSyncValue">
-    /// The <see cref="IMonkeySyncValue"/>-derived interface
+    /// The <see cref="IUnlinkedMonkeySyncValue{TLink}"/>-derived interface
     /// that the MonkeySync values of this object must implement.
     /// </typeparam>
     /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
     public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlinkedMonkeySyncObject<TLink>
         where TSyncObject : MonkeySyncObject<TSyncObject, TSyncValue, TLink>
-        where TSyncValue : IMonkeySyncValue
+        where TSyncValue : IUnlinkedMonkeySyncValue<TLink>
         where TLink : class
     {
         /// <summary>
@@ -115,13 +115,13 @@ public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlink
         static MonkeySyncObject()
         {
             var syncValueType = typeof(TSyncValue);
-            var syncValueProperties = AccessTools.GetDeclaredProperties(typeof(TSyncObject))
+            var syncValueProperties = typeof(TSyncObject).GetProperties(AccessTools.all)
                 .Where(property => syncValueType.IsAssignableFrom(property.PropertyType) && (!(property.GetGetMethod()?.IsStatic ?? true)));
 
             foreach (var property in syncValueProperties)
                 propertyAccessorsByName.Add(property.Name, (TSyncObject instance) => (TSyncValue)property.GetValue(instance));
 
-            var syncMethods = AccessTools.GetDeclaredMethods(typeof(TSyncObject))
+            var syncMethods = typeof(TSyncObject).GetMethods(AccessTools.all)
                 .Where(method => !method.IsStatic && !method.ContainsGenericParameters && method.ReturnType == typeof(void) && method.GetParameters().Length == 0);
 
             foreach (var method in syncMethods)
@@ -170,11 +170,16 @@ public bool LinkWith(TLink linkObject, bool fromRemote = false)
         /// <summary>
         /// Creates a link for the given sync value of the given name.
         /// </summary>
+        /// <remarks>
+        /// <i>By default:</i> Calls
+        /// <c><paramref name="syncValue"/>.<see cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor">EstablishLinkFor</see>()</c>.
+        /// </remarks>
         /// <param name="propertyName">The name of the sync value to link.</param>
         /// <param name="syncValue">The sync value to link.</param>
         /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
         /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
-        protected abstract bool EstablishLinkFor(string propertyName, TSyncValue syncValue, bool fromRemote);
+        protected virtual bool EstablishLinkFor(string propertyName, TSyncValue syncValue, bool fromRemote)
+            => syncValue.EstablishLinkFor(this, propertyName, fromRemote);
 
         /// <summary>
         /// Creates a link for the given sync method of the given name.
@@ -214,7 +219,7 @@ protected virtual bool EstablishLinkWith(TLink linkObject, bool fromRemote)
                 var syncValue = syncValueProperty.Value((TSyncObject)this);
 
                 syncValue.Changed += (sender, changedArgs)
-                    => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(syncValueProperty.Key));
+                    => OnPropertyChanged(syncValueProperty.Key);
 
                 success &= EstablishLinkFor(syncValueProperty.Key, syncValue, fromRemote);
             }
@@ -271,12 +276,11 @@ protected void OnLinkInvalidated()
         /// event with the given <paramref name="propertyName"/>.
         /// </summary>
         /// <remarks>
-        /// This is automatically called for any <see cref="MonkeySyncValue{T}"/> properties.
+        /// This is automatically called for any <typeparamref name="TSyncValue"/> properties.
         /// </remarks>
         /// <param name="propertyName">The name of the property that changed.</param>
         protected void OnPropertyChanged(string propertyName)
         {
-            // Still needs to be hooked up somewhere
             var eventData = new PropertyChangedEventArgs(propertyName);
 
             PropertyChanged?.Invoke(this, eventData);
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index fe023b9..b91a115 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -10,10 +10,21 @@
 namespace MonkeyLoader.Sync
 {
     /// <summary>
-    /// Defines the non-generic interface for <see cref="IMonkeySyncValue"/>s.
+    /// Defines the non-generic interface for <see cref="ILinkedMonkeySyncValue{TLink, T}"/>s.
     /// </summary>
-    public interface IMonkeySyncValue : INotifyValueChanged
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
+    public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged
     {
+        /// <summary>
+        /// Gets the property name of this sync value.
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Gets the sync object that this value belongs to.
+        /// </summary>
+        public ILinkedMonkeySyncObject<TLink> SyncObject { get; }
+
         /// <summary>
         /// Gets or sets the internal value of this sync value.
         /// </summary>
@@ -27,24 +38,25 @@ public interface IMonkeySyncValue : INotifyValueChanged
     }
 
     /// <summary>
-    /// Defines the generic interface for <see cref="IMonkeySyncValue"/>s.
+    /// Defines the generic interface for linked <see cref="MonkeySyncValue{TLink, T}"/>s.
     /// </summary>
-    /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
-    public interface IMonkeySyncValue<T> : INotifyValueChanged<T>,
-        IReadOnlyMonkeySyncValue<T>, IWriteOnlyMonkeySyncValue<T>
+    /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+    /// <typeparam name="T">The type of the <see cref="ILinkedMonkeySyncValue{T}.Value">Value</see>.</typeparam>
+    public interface ILinkedMonkeySyncValue<out TLink, T> : INotifyValueChanged<T>,
+        IReadOnlyMonkeySyncValue<TLink, T>, IWriteOnlyMonkeySyncValue<TLink, T>
     {
-        /// <inheritdoc cref="IMonkeySyncValue.Value"/>
+        /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink}.Value"/>
         public new T Value { get; set; }
     }
 
     /// <summary>
-    /// Defines the interface for readonly <see cref="IMonkeySyncValue"/>s.
+    /// Defines the interface for readonly <see cref="ILinkedMonkeySyncValue{TLink}"/>s.
     /// </summary>
     /// <remarks>
     /// This interface exists purely to facilitate keeping a covariant list of sync values.
     /// </remarks>
-    /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
-    public interface IReadOnlyMonkeySyncValue<out T> : IMonkeySyncValue
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
+    public interface IReadOnlyMonkeySyncValue<out TLink, out T> : ILinkedMonkeySyncValue<TLink>
     {
         /// <summary>
         /// Gets the internal value of this sync value.
@@ -53,13 +65,29 @@ public interface IReadOnlyMonkeySyncValue<out T> : IMonkeySyncValue
     }
 
     /// <summary>
-    /// Defines the interface for writeonly <see cref="IMonkeySyncValue"/>s.
+    /// Defines the interface for not yet linked <see cref="MonkeySyncValue{TLink, T}"/>s.
+    /// </summary>
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
+    public interface IUnlinkedMonkeySyncValue<TLink> : ILinkedMonkeySyncValue<TLink>
+    {
+        /// <summary>
+        /// Establishes this sync value's association and link through the given sync object.
+        /// </summary>
+        /// <param name="syncObject">The sync object that this value belongs to.</param>
+        /// <param name="propertyName">The property name of this sync value.</param>
+        /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
+        /// <returns><c>true</c> if the established link is valid; otherwise, <c>false</c>.</returns>
+        public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string propertyName, bool fromRemote);
+    }
+
+    /// <summary>
+    /// Defines the interface for writeonly <see cref="ILinkedMonkeySyncValue{TLink}"/>s.
     /// </summary>
     /// <remarks>
     /// This interface exists purely to facilitate keeping a contravariant list of sync values.
     /// </remarks>
-    /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
-    public interface IWriteOnlyMonkeySyncValue<in T> : IMonkeySyncValue
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
+    public interface IWriteOnlyMonkeySyncValue<out TLink, in T> : ILinkedMonkeySyncValue<TLink>
     {
         /// <summary>
         /// Sets the internal value of this sync value.
@@ -68,16 +96,22 @@ public interface IWriteOnlyMonkeySyncValue<in T> : IMonkeySyncValue
     }
 
     /// <summary>
-    /// Implements a basic version of an <see cref="IMonkeySyncValue{T}"/>.
+    /// Implements an abstract base for <see cref="ILinkedMonkeySyncValue{TLink, T}"/>s.
     /// </summary>
-    /// <typeparam name="T">The type of the <see cref="Value">Value</see>.</typeparam>
-    public class MonkeySyncValue<T> : IMonkeySyncValue<T>
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
+    public abstract class MonkeySyncValue<TLink, T> : IUnlinkedMonkeySyncValue<TLink>, ILinkedMonkeySyncValue<TLink, T>
     {
         private static readonly Type _valueType = typeof(T);
 
         private ValueChangedEventHandler? _untypedChanged;
         private T _value;
 
+        /// <inheritdoc/>
+        public string Name { get; private set; } = null!;
+
+        /// <inheritdoc/>
+        public ILinkedMonkeySyncObject<TLink> SyncObject { get; private set; } = null!;
+
         /// <inheritdoc/>
         public virtual T Value
         {
@@ -93,7 +127,7 @@ public virtual T Value
             }
         }
 
-        object? IMonkeySyncValue.Value
+        object? ILinkedMonkeySyncValue<TLink>.Value
         {
             get => Value;
             set => Value = (T)value!;
@@ -111,21 +145,36 @@ public MonkeySyncValue(T value)
             Value = value;
         }
 
-        /// <summary>
-        /// Wraps the given <paramref name="value"/> into a sync object.
-        /// </summary>
-        /// <param name="value">The value to wrap.</param>
-        public static implicit operator MonkeySyncValue<T>(T value) => new(value);
-
         /// <summary>
         /// Unwraps the <see cref="Value">Value</see> from the given sync object.
         /// </summary>
         /// <param name="syncValue">The sync object to unwrap.</param>
-        public static implicit operator T(MonkeySyncValue<T> syncValue) => syncValue.Value;
+        public static implicit operator T(MonkeySyncValue<TLink, T> syncValue) => syncValue.Value;
+
+        /// <remarks>
+        /// Sets this sync value's <see cref="SyncObject">SyncObject</see>
+        /// and <see cref="Name">Name</see> to the ones provided.<br/>
+        /// Then calls the <see cref="EstablishLinkForInternal">internal link method</see>.
+        /// </remarks>
+        /// <inheritdoc/>
+        public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string propertyName, bool fromRemote)
+        {
+            SyncObject = syncObject;
+            Name = propertyName;
+
+            return EstablishLinkForInternal(syncObject, propertyName, fromRemote);
+        }
 
         /// <inheritdoc/>
         public override string ToString() => Value?.ToString() ?? "";
 
+        /// <remarks>
+        /// Handles the aspects of establishing a link that are
+        /// particular to <typeparamref name="TLink"/>s as a link object.
+        /// </remarks>
+        /// <inheritdoc cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor"/>
+        protected abstract bool EstablishLinkForInternal(ILinkedMonkeySyncObject<TLink> syncObject, string propertyName, bool fromRemote);
+
         /// <summary>
         /// Handles the value of this config item potentially having changed.
         /// If the <paramref name="oldValue"/> and new value are different:<br/>

From 3a8949ccb11d1bf2e36dcfc8a99809217e947822 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sun, 2 Feb 2025 21:45:14 +0100
Subject: [PATCH 12/22] Tweak MonkeySyncValue link establishing

---
 MonkeyLoader/MonkeyLoader.csproj     |  2 +-
 MonkeyLoader/Sync/MonkeySyncValue.cs | 11 +++++++----
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 6a5ae82..fa5079f 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.8-MonkeySync-beta</Version>
+    <Version>0.24.9-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index b91a115..c913dea 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -154,7 +154,7 @@ public MonkeySyncValue(T value)
         /// <remarks>
         /// Sets this sync value's <see cref="SyncObject">SyncObject</see>
         /// and <see cref="Name">Name</see> to the ones provided.<br/>
-        /// Then calls the <see cref="EstablishLinkForInternal">internal link method</see>.
+        /// Then calls the <see cref="EstablishLinkInternal">internal link method</see>.
         /// </remarks>
         /// <inheritdoc/>
         public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string propertyName, bool fromRemote)
@@ -162,7 +162,7 @@ public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string p
             SyncObject = syncObject;
             Name = propertyName;
 
-            return EstablishLinkForInternal(syncObject, propertyName, fromRemote);
+            return EstablishLinkInternal(fromRemote);
         }
 
         /// <inheritdoc/>
@@ -170,10 +170,13 @@ public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string p
 
         /// <remarks>
         /// Handles the aspects of establishing a link that are
-        /// particular to <typeparamref name="TLink"/>s as a link object.
+        /// particular to <typeparamref name="TLink"/>s as a link object.<br/>
+        /// The <see cref="SyncObject">SyncObject</see> and <see cref="Name">Name</see>
+        /// have already been assigned by the <see cref="EstablishLinkFor">EstablishLinkFor</see>
+        /// method that calls this.
         /// </remarks>
         /// <inheritdoc cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor"/>
-        protected abstract bool EstablishLinkForInternal(ILinkedMonkeySyncObject<TLink> syncObject, string propertyName, bool fromRemote);
+        protected abstract bool EstablishLinkInternal(bool fromRemote);
 
         /// <summary>
         /// Handles the value of this config item potentially having changed.

From 610e2d081cebde18bf619c9419932b6890e91f77 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sun, 2 Feb 2025 22:38:43 +0100
Subject: [PATCH 13/22] Fix missing MonkeySyncMethodAttribute check

---
 MonkeyLoader/Sync/MonkeySyncObject.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index 07fd210..450b11c 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -7,6 +7,7 @@
 using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 
 namespace MonkeyLoader.Sync
@@ -122,7 +123,7 @@ static MonkeySyncObject()
                 propertyAccessorsByName.Add(property.Name, (TSyncObject instance) => (TSyncValue)property.GetValue(instance));
 
             var syncMethods = typeof(TSyncObject).GetMethods(AccessTools.all)
-                .Where(method => !method.IsStatic && !method.ContainsGenericParameters && method.ReturnType == typeof(void) && method.GetParameters().Length == 0);
+                .Where(method => !method.IsStatic && !method.ContainsGenericParameters && method.ReturnType == typeof(void) && method.GetParameters().Length == 0 && method.GetCustomAttribute<MonkeySyncMethodAttribute>() is not null);
 
             foreach (var method in syncMethods)
                 methodsByName.Add(method.Name, (TSyncObject instance) => method.Invoke(instance, null));

From 61aa20337e92d4abe91c5e82f8e8e816e87f1db9 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Thu, 6 Feb 2025 21:23:50 +0100
Subject: [PATCH 14/22] Adjust link establishment

---
 MonkeyLoader/Sync/MonkeySyncObject.cs | 84 +++++++++++++++------------
 MonkeyLoader/Sync/MonkeySyncValue.cs  |  9 +++
 2 files changed, 55 insertions(+), 38 deletions(-)

diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index 450b11c..eb4332d 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -47,6 +47,7 @@ public interface IMonkeySyncObject : INotifyPropertyChanged, IDisposable
         /// <summary>
         /// Gets whether this sync object has a valid link.
         /// </summary>
+        [MemberNotNullWhen(true, nameof(LinkObject))]
         public bool IsLinkValid { get; }
 
         /// <summary>
@@ -106,6 +107,7 @@ public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlink
         public bool HasLinkObject => LinkObject is not null;
 
         /// <inheritdoc/>
+        [MemberNotNullWhen(true, nameof(LinkObject))]
         public abstract bool IsLinkValid { get; }
 
         /// <inheritdoc/>
@@ -165,37 +167,14 @@ public bool LinkWith(TLink linkObject, bool fromRemote = false)
 
             LinkObject = linkObject;
 
-            return EstablishLinkWith(linkObject, fromRemote);
+            return EstablishLink(fromRemote);
         }
 
-        /// <summary>
-        /// Creates a link for the given sync value of the given name.
-        /// </summary>
-        /// <remarks>
-        /// <i>By default:</i> Calls
-        /// <c><paramref name="syncValue"/>.<see cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor">EstablishLinkFor</see>()</c>.
-        /// </remarks>
-        /// <param name="propertyName">The name of the sync value to link.</param>
-        /// <param name="syncValue">The sync value to link.</param>
-        /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
-        /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
-        protected virtual bool EstablishLinkFor(string propertyName, TSyncValue syncValue, bool fromRemote)
-            => syncValue.EstablishLinkFor(this, propertyName, fromRemote);
-
-        /// <summary>
-        /// Creates a link for the given sync method of the given name.
-        /// </summary>
-        /// <param name="methodName">The name of the sync method to link.</param>
-        /// <param name="syncMethod">The sync method to link.</param>
-        /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
-        /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
-        protected abstract bool EstablishLinkFor(string methodName, Action<TSyncObject> syncMethod, bool fromRemote);
-
         /// <remarks><para>
         /// <i>By default:</i> Sets up the <see cref="INotifyValueChanged.Changed"/> event handlers
-        /// and calls <see cref="EstablishLinkFor(string, TSyncValue, bool)">EstablishLinkFor</see>
+        /// and calls <see cref="EstablishLinkFor(TSyncValue, string, bool)">EstablishLinkFor</see>
         /// for every readable <typeparamref name="TSyncValue"/> instance property and
-        /// <see cref="EstablishLinkFor(string, TSyncValue, bool)">its overload</see> for every
+        /// <see cref="EstablishLinkFor(TSyncValue, string, bool)">its overload</see> for every
         /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
         /// If the link is successfully created, this linked sync object will be
         /// <see cref="MonkeySyncRegistry.RegisterLinkedSyncObject{TLink}">added</see>
@@ -211,7 +190,7 @@ protected virtual bool EstablishLinkFor(string propertyName, TSyncValue syncValu
         /// </para>
         /// </remarks>
         /// <inheritdoc cref="LinkWith"/>
-        protected virtual bool EstablishLinkWith(TLink linkObject, bool fromRemote)
+        protected virtual bool EstablishLink(bool fromRemote)
         {
             var success = true;
 
@@ -222,11 +201,11 @@ protected virtual bool EstablishLinkWith(TLink linkObject, bool fromRemote)
                 syncValue.Changed += (sender, changedArgs)
                     => OnPropertyChanged(syncValueProperty.Key);
 
-                success &= EstablishLinkFor(syncValueProperty.Key, syncValue, fromRemote);
+                success &= EstablishLinkFor(syncValue, syncValueProperty.Key, fromRemote);
             }
 
             foreach (var syncMethod in methodsByName)
-                success &= EstablishLinkFor(syncMethod.Key, syncMethod.Value, fromRemote);
+                success &= EstablishLinkFor(syncMethod.Value, syncMethod.Key, fromRemote);
 
             if (success)
                 MonkeySyncRegistry.RegisterLinkedSyncObject(this);
@@ -234,6 +213,29 @@ protected virtual bool EstablishLinkWith(TLink linkObject, bool fromRemote)
             return success;
         }
 
+        /// <summary>
+        /// Creates a link for the given sync value of the given name.
+        /// </summary>
+        /// <remarks>
+        /// <i>By default:</i> Calls
+        /// <c><paramref name="syncValue"/>.<see cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor">EstablishLinkFor</see>()</c>.
+        /// </remarks>
+        /// <param name="syncValue">The sync value to link.</param>
+        /// <param name="propertyName">The name of the sync value to link.</param>
+        /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
+        /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
+        protected virtual bool EstablishLinkFor(TSyncValue syncValue, string propertyName, bool fromRemote)
+            => syncValue.EstablishLinkFor(this, propertyName, fromRemote);
+
+        /// <summary>
+        /// Creates a link for the given sync method of the given name.
+        /// </summary>
+        /// <param name="syncMethod">The sync method to link.</param>
+        /// <param name="methodName">The name of the sync method to link.</param>
+        /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
+        /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
+        protected abstract bool EstablishLinkFor(Action<TSyncObject> syncMethod, string methodName, bool fromRemote);
+
         /// <summary>
         /// Cleans up any managed resources as part of <see cref="Dispose()">disposing</see>.
         /// </summary>
@@ -267,7 +269,11 @@ protected void OnLinkInvalidated()
             if (!IsLinkValid && TryRestoreLink() && IsLinkValid)
                 return;
 
-            Invalidated.TryInvokeAll();
+            try
+            {
+                Invalidated.TryInvokeAll();
+            }
+            catch { }
 
             Dispose();
         }
@@ -288,9 +294,9 @@ protected void OnPropertyChanged(string propertyName)
         }
 
         /// <remarks><para>
-        /// <i>By default:</i> Calls <see cref="TryRestoreLinkFor(string, TSyncValue)">TryRestoreLinkFor</see>
+        /// <i>By default:</i> Calls <see cref="TryRestoreLinkFor(TSyncValue, string)">TryRestoreLinkFor</see>
         /// for every readable <typeparamref name="TSyncValue"/> instance property and
-        /// <see cref="TryRestoreLinkFor(string, TSyncValue)">its overload</see> for every
+        /// <see cref="TryRestoreLinkFor(TSyncValue, string)">its overload</see> for every
         /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
         /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
         /// while the detected methods are stored in <see cref="methodsByName">methodsByName</see>.
@@ -307,29 +313,31 @@ protected virtual bool TryRestoreLink()
             var success = true;
 
             foreach (var syncValueProperty in propertyAccessorsByName)
-                success &= TryRestoreLinkFor(syncValueProperty.Key, syncValueProperty.Value((TSyncObject)this));
+                success &= TryRestoreLinkFor(syncValueProperty.Value((TSyncObject)this), syncValueProperty.Key);
 
             foreach (var syncMethod in methodsByName)
-                success &= TryRestoreLinkFor(syncMethod.Key, syncMethod.Value);
+                success &= TryRestoreLinkFor(syncMethod.Value, syncMethod.Key);
 
             return success;
         }
 
+        // Implement the sync value one through a method on sync values
+
         /// <summary>
         /// Tries to restore the link for the given sync value of the given name.
         /// </summary>
-        /// <param name="propertyName">The name of the sync value to link.</param>
         /// <param name="syncValue">The sync value to link.</param>
+        /// <param name="propertyName">The name of the sync value to link.</param>
         /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
-        protected abstract bool TryRestoreLinkFor(string propertyName, TSyncValue syncValue);
+        protected abstract bool TryRestoreLinkFor(TSyncValue syncValue, string propertyName);
 
         /// <summary>
         /// Tries to restore the link for the given sync method of the given name.
         /// </summary>
-        /// <param name="methodName">The name of the sync method to link.</param>
         /// <param name="syncMethod">The sync method to link.</param>
+        /// <param name="methodName">The name of the sync method to link.</param>
         /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
-        protected abstract bool TryRestoreLinkFor(string methodName, Action<TSyncObject> syncMethod);
+        protected abstract bool TryRestoreLinkFor(Action<TSyncObject> syncMethod, string methodName);
 
         private void Dispose(bool disposing)
         {
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index c913dea..d53f501 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -45,6 +45,12 @@ public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged
     public interface ILinkedMonkeySyncValue<out TLink, T> : INotifyValueChanged<T>,
         IReadOnlyMonkeySyncValue<TLink, T>, IWriteOnlyMonkeySyncValue<TLink, T>
     {
+        /// <summary>
+        /// Gets the <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}.LinkObject">LinkObject</see>
+        /// of the <see cref="ILinkedMonkeySyncValue{TLink}.SyncObject">SyncObject</see> that this value belongs to.
+        /// </summary>
+        public TLink LinkObject { get; }
+
         /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink}.Value"/>
         public new T Value { get; set; }
     }
@@ -106,6 +112,9 @@ public abstract class MonkeySyncValue<TLink, T> : IUnlinkedMonkeySyncValue<TLink
         private ValueChangedEventHandler? _untypedChanged;
         private T _value;
 
+        /// <inheritdoc/>
+        public TLink LinkObject => SyncObject.LinkObject;
+
         /// <inheritdoc/>
         public string Name { get; private set; } = null!;
 

From 83567b289bfbae2e631cf39d314f5e073d293f6c Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Thu, 13 Feb 2025 17:33:18 +0100
Subject: [PATCH 15/22] Add link restoring method to SyncValue and
 automatically dispose them from sync object

---
 MonkeyLoader/Sync/MonkeySyncObject.cs | 46 ++++++++++++-----
 MonkeyLoader/Sync/MonkeySyncValue.cs  | 73 ++++++++++++++++++++++++---
 2 files changed, 98 insertions(+), 21 deletions(-)

diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index eb4332d..d3b53b5 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -1,7 +1,6 @@
 using EnumerableToolkit;
 using HarmonyLib;
 using MonkeyLoader.Meta;
-using MonkeyLoader.Patching;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -100,6 +99,11 @@ public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlink
         /// </summary>
         protected static readonly Dictionary<string, Func<TSyncObject, TSyncValue>> propertyAccessorsByName = new(StringComparer.Ordinal);
 
+        /// <summary>
+        /// The <typeparamref name="TSyncValue"/> instances associated with this sync object.
+        /// </summary>
+        protected readonly HashSet<TSyncValue> syncValues = [];
+
         private bool _disposedValue;
 
         /// <inheritdoc/>
@@ -217,19 +221,26 @@ protected virtual bool EstablishLink(bool fromRemote)
         /// Creates a link for the given sync value of the given name.
         /// </summary>
         /// <remarks>
-        /// <i>By default:</i> Calls
-        /// <c><paramref name="syncValue"/>.<see cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor">EstablishLinkFor</see>()</c>.
+        /// <i>By default:</i> Adds the given sync value to the <see cref="syncValues">set of instances</see> and calls
+        /// <c><paramref name="syncValue"/>.<see cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor">EstablishLinkFor</see>(…)</c>.
         /// </remarks>
         /// <param name="syncValue">The sync value to link.</param>
         /// <param name="propertyName">The name of the sync value to link.</param>
         /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
         /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
         protected virtual bool EstablishLinkFor(TSyncValue syncValue, string propertyName, bool fromRemote)
-            => syncValue.EstablishLinkFor(this, propertyName, fromRemote);
+        {
+            syncValues.Add(syncValue);
+            return syncValue.EstablishLinkFor(this, propertyName, fromRemote);
+        }
 
         /// <summary>
         /// Creates a link for the given sync method of the given name.
         /// </summary>
+        /// <remarks>
+        /// Any <typeparamref name="TSyncValue"/>s created for this
+        /// must be added to the <see cref="syncValues">set of instances</see>.
+        /// </remarks>
         /// <param name="syncMethod">The sync method to link.</param>
         /// <param name="methodName">The name of the sync method to link.</param>
         /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
@@ -240,10 +251,15 @@ protected virtual bool EstablishLinkFor(TSyncValue syncValue, string propertyNam
         /// Cleans up any managed resources as part of <see cref="Dispose()">disposing</see>.
         /// </summary>
         /// <remarks>
-        /// <i>By default:</i> Disposes the <see cref="LinkObject">LinkObject</see> if it's <see cref="IDisposable"/>.
+        /// <i>By default:</i> Disposes all <typeparamref name="TSyncValue"/> instances
+        /// that were added to the <see cref="syncValues">set of instances</see>,
+        /// and the <see cref="LinkObject">LinkObject</see> if it's <see cref="IDisposable"/>.
         /// </remarks>
         protected virtual void OnDisposing()
         {
+            foreach (var syncValue in syncValues)
+                syncValue.Dispose();
+
             if (LinkObject is IDisposable disposable)
                 disposable.Dispose();
         }
@@ -294,9 +310,9 @@ protected void OnPropertyChanged(string propertyName)
         }
 
         /// <remarks><para>
-        /// <i>By default:</i> Calls <see cref="TryRestoreLinkFor(TSyncValue, string)">TryRestoreLinkFor</see>
+        /// <i>By default:</i> Calls <see cref="TryRestoreLinkFor(TSyncValue)">TryRestoreLinkFor</see>
         /// for every readable <typeparamref name="TSyncValue"/> instance property and
-        /// <see cref="TryRestoreLinkFor(TSyncValue, string)">its overload</see> for every
+        /// <see cref="TryRestoreLinkFor(Action{TSyncObject}, string)">its overload</see> for every
         /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
         /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
         /// while the detected methods are stored in <see cref="methodsByName">methodsByName</see>.
@@ -312,8 +328,8 @@ protected virtual bool TryRestoreLink()
         {
             var success = true;
 
-            foreach (var syncValueProperty in propertyAccessorsByName)
-                success &= TryRestoreLinkFor(syncValueProperty.Value((TSyncObject)this), syncValueProperty.Key);
+            foreach (var syncValues in propertyAccessorsByName.Values)
+                success &= TryRestoreLinkFor(syncValues((TSyncObject)this));
 
             foreach (var syncMethod in methodsByName)
                 success &= TryRestoreLinkFor(syncMethod.Value, syncMethod.Key);
@@ -321,15 +337,17 @@ protected virtual bool TryRestoreLink()
             return success;
         }
 
-        // Implement the sync value one through a method on sync values
-
         /// <summary>
-        /// Tries to restore the link for the given sync value of the given name.
+        /// Tries to restore the link for the given sync value.
         /// </summary>
+        /// <remarks>
+        /// <i>By default:</i> Calls
+        /// <c><paramref name="syncValue"/>.<see cref="ILinkedMonkeySyncValue{TLink}.TryRestoreLink">TryRestoreLink</see>()</c>.
+        /// </remarks>
         /// <param name="syncValue">The sync value to link.</param>
-        /// <param name="propertyName">The name of the sync value to link.</param>
         /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
-        protected abstract bool TryRestoreLinkFor(TSyncValue syncValue, string propertyName);
+        protected virtual bool TryRestoreLinkFor(TSyncValue syncValue)
+            => syncValue.TryRestoreLink();
 
         /// <summary>
         /// Tries to restore the link for the given sync method of the given name.
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index d53f501..ba2f06e 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -13,8 +13,14 @@ namespace MonkeyLoader.Sync
     /// Defines the non-generic interface for <see cref="ILinkedMonkeySyncValue{TLink, T}"/>s.
     /// </summary>
     /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
-    public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged
+    public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged, IDisposable
     {
+        /// <summary>
+        /// Gets the <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}.LinkObject">LinkObject</see>
+        /// of the <see cref="ILinkedMonkeySyncValue{TLink}.SyncObject">SyncObject</see> that this value belongs to.
+        /// </summary>
+        public TLink LinkObject { get; }
+
         /// <summary>
         /// Gets the property name of this sync value.
         /// </summary>
@@ -35,6 +41,12 @@ public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged
         /// the wrapped <see cref="Value">Value</see>.
         /// </summary>
         public Type ValueType { get; }
+
+        /// <summary>
+        /// Tries to restore the link of this sync value.
+        /// </summary>
+        /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
+        public bool TryRestoreLink();
     }
 
     /// <summary>
@@ -45,12 +57,6 @@ public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged
     public interface ILinkedMonkeySyncValue<out TLink, T> : INotifyValueChanged<T>,
         IReadOnlyMonkeySyncValue<TLink, T>, IWriteOnlyMonkeySyncValue<TLink, T>
     {
-        /// <summary>
-        /// Gets the <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}.LinkObject">LinkObject</see>
-        /// of the <see cref="ILinkedMonkeySyncValue{TLink}.SyncObject">SyncObject</see> that this value belongs to.
-        /// </summary>
-        public TLink LinkObject { get; }
-
         /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink}.Value"/>
         public new T Value { get; set; }
     }
@@ -109,6 +115,7 @@ public abstract class MonkeySyncValue<TLink, T> : IUnlinkedMonkeySyncValue<TLink
     {
         private static readonly Type _valueType = typeof(T);
 
+        private bool _disposedValue;
         private ValueChangedEventHandler? _untypedChanged;
         private T _value;
 
@@ -154,12 +161,28 @@ public MonkeySyncValue(T value)
             Value = value;
         }
 
+        /// <summary>
+        /// Ensures any unmanaged resources are <see cref="Dispose(bool)">disposed</see>.
+        /// </summary>
+        ~MonkeySyncValue()
+        {
+            Dispose(false);
+        }
+
         /// <summary>
         /// Unwraps the <see cref="Value">Value</see> from the given sync object.
         /// </summary>
         /// <param name="syncValue">The sync object to unwrap.</param>
         public static implicit operator T(MonkeySyncValue<TLink, T> syncValue) => syncValue.Value;
 
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            // Do not change this code. Put cleanup code in the 'OnDisposing()' or 'OnFinalizing()' methods
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
         /// <remarks>
         /// Sets this sync value's <see cref="SyncObject">SyncObject</see>
         /// and <see cref="Name">Name</see> to the ones provided.<br/>
@@ -177,6 +200,9 @@ public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string p
         /// <inheritdoc/>
         public override string ToString() => Value?.ToString() ?? "";
 
+        /// <inheritdoc/>
+        public abstract bool TryRestoreLink();
+
         /// <remarks>
         /// Handles the aspects of establishing a link that are
         /// particular to <typeparamref name="TLink"/>s as a link object.<br/>
@@ -187,6 +213,39 @@ public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string p
         /// <inheritdoc cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor"/>
         protected abstract bool EstablishLinkInternal(bool fromRemote);
 
+        /// <summary>
+        /// Cleans up any managed resources as part of <see cref="Dispose()">disposing</see>.
+        /// </summary>
+        /// <remarks>
+        /// <i>By default:</i> Sets the <see cref="SyncObject">SyncObject</see> to <c>null</c>
+        /// and the internal <see cref="Value">value</see> to its <c>default</c>.
+        /// </remarks>
+        protected virtual void OnDisposing()
+        {
+            SyncObject = null!;
+            _value = default!;
+        }
+
+        /// <summary>
+        /// Cleans up any unmanaged resources as part of
+        /// <see cref="Dispose()">disposing</see> or finalization.
+        /// </summary>
+        protected virtual void OnFinalizing()
+        { }
+
+        private void Dispose(bool disposing)
+        {
+            if (_disposedValue)
+                return;
+
+            if (disposing)
+                OnDisposing();
+
+            OnFinalizing();
+
+            _disposedValue = true;
+        }
+
         /// <summary>
         /// Handles the value of this config item potentially having changed.
         /// If the <paramref name="oldValue"/> and new value are different:<br/>

From e9aca64925e3c6e2498b42a056a5a22775df7152 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Fri, 7 Mar 2025 19:54:28 +0100
Subject: [PATCH 16/22] Tweak sync method system

---
 MonkeyLoader/MonkeyLoader.csproj              |  2 +-
 .../Sync/MonkeySyncMethodAttribute.cs         | 21 +++++++++++++-
 MonkeyLoader/Sync/MonkeySyncObject.cs         | 28 +++++++++++++------
 3 files changed, 40 insertions(+), 11 deletions(-)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index fa5079f..0622d69 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.9-MonkeySync-beta</Version>
+    <Version>0.24.10-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs b/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
index c1cb079..d482495 100644
--- a/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
+++ b/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Reflection;
 
 namespace MonkeyLoader.Sync
 {
@@ -6,7 +7,25 @@ namespace MonkeyLoader.Sync
     /// Marks a <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync
     /// object's</see> instance method as being triggerable through the MonkeySync system.
     /// </summary>
+    /// <remarks>
+    /// The method must be
+    /// </remarks>
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
     public sealed class MonkeySyncMethodAttribute : MonkeyLoaderAttribute
-    { }
+    {
+        /// <summary>
+        /// Determines whether the given <paramref name="method"/>
+        /// is suitable to be triggerable through the MonkeySync system.
+        /// </summary>
+        /// <remarks>
+        /// To be suitable, a method must be a non-generic parameterless void instance method,
+        /// which is decorated with <see cref="MonkeySyncMethodAttribute">this attribute</see>.
+        /// </remarks>
+        /// <param name="method">The method to check for suitability.</param>
+        /// <returns><c>true</c> if the method is suitable; otherwise, <c>false</c>.</returns>
+        public static bool IsValid(MethodInfo method)
+            => !method.IsStatic && !method.ContainsGenericParameters
+             && method.ReturnType == typeof(void) && method.GetParameters().Length == 0
+             && method.GetCustomAttribute<MonkeySyncMethodAttribute>() is not null;
+    }
 }
\ No newline at end of file
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index d3b53b5..65783e0 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -90,15 +90,22 @@ public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlink
         where TLink : class
     {
         /// <summary>
-        /// The detected <see cref="MonkeySyncMethodAttribute">MonkeySync nethods</see> by their name.
+        /// The <see cref="MethodInfo"/>s of the detected <see cref="MonkeySyncMethodAttribute">MonkeySync
+        /// methods</see> of this type by their name.
         /// </summary>
-        protected static readonly Dictionary<string, Action<TSyncObject>> methodsByName = new(StringComparer.Ordinal);
+        protected static readonly Dictionary<string, MethodInfo> methodInfosByName = new(StringComparer.Ordinal);
 
         /// <summary>
         /// The getters for the detected <typeparamref name="TSyncValue"/> instance properties by their name.
         /// </summary>
         protected static readonly Dictionary<string, Func<TSyncObject, TSyncValue>> propertyAccessorsByName = new(StringComparer.Ordinal);
 
+        /// <summary>
+        /// The <see cref="Action"/>s to invoke the detected <see cref="MonkeySyncMethodAttribute">MonkeySync
+        /// methods</see> of this type by their name.
+        /// </summary>
+        protected readonly Dictionary<string, Action> methodsByName = new(StringComparer.Ordinal);
+
         /// <summary>
         /// The <typeparamref name="TSyncValue"/> instances associated with this sync object.
         /// </summary>
@@ -129,10 +136,10 @@ static MonkeySyncObject()
                 propertyAccessorsByName.Add(property.Name, (TSyncObject instance) => (TSyncValue)property.GetValue(instance));
 
             var syncMethods = typeof(TSyncObject).GetMethods(AccessTools.all)
-                .Where(method => !method.IsStatic && !method.ContainsGenericParameters && method.ReturnType == typeof(void) && method.GetParameters().Length == 0 && method.GetCustomAttribute<MonkeySyncMethodAttribute>() is not null);
+                .Where(MonkeySyncMethodAttribute.IsValid);
 
             foreach (var method in syncMethods)
-                methodsByName.Add(method.Name, (TSyncObject instance) => method.Invoke(instance, null));
+                methodInfosByName.Add(method.Name, method);
         }
 
         /// <summary>
@@ -145,6 +152,9 @@ protected MonkeySyncObject()
         {
             if (GetType() != typeof(TSyncObject))
                 throw new InvalidOperationException("TSyncObject must be the concrete Type being instantiated!");
+
+            foreach (var methodEntry in methodInfosByName)
+                methodsByName.Add(methodEntry.Key, AccessTools.MethodDelegate<Action>(methodEntry.Value, this));
         }
 
         /// <summary>
@@ -185,7 +195,7 @@ public bool LinkWith(TLink linkObject, bool fromRemote = false)
         /// to the <see cref="MonkeySyncRegistry"/> automatically.
         /// </para><para>
         /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
-        /// while the detected methods are stored in <see cref="methodsByName">methodsByName</see>.
+        /// while the detected methods are stored in <see cref="methodInfosByName">methodsByName</see>.
         /// </para><para>
         /// This method is called by <see cref="LinkWith">LinkWith</see>
         /// after the <see cref="LinkObject">LinkObject</see> has been assigned.<br/>
@@ -245,7 +255,7 @@ protected virtual bool EstablishLinkFor(TSyncValue syncValue, string propertyNam
         /// <param name="methodName">The name of the sync method to link.</param>
         /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
         /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
-        protected abstract bool EstablishLinkFor(Action<TSyncObject> syncMethod, string methodName, bool fromRemote);
+        protected abstract bool EstablishLinkFor(Action syncMethod, string methodName, bool fromRemote);
 
         /// <summary>
         /// Cleans up any managed resources as part of <see cref="Dispose()">disposing</see>.
@@ -312,10 +322,10 @@ protected void OnPropertyChanged(string propertyName)
         /// <remarks><para>
         /// <i>By default:</i> Calls <see cref="TryRestoreLinkFor(TSyncValue)">TryRestoreLinkFor</see>
         /// for every readable <typeparamref name="TSyncValue"/> instance property and
-        /// <see cref="TryRestoreLinkFor(Action{TSyncObject}, string)">its overload</see> for every
+        /// <see cref="TryRestoreLinkFor(Action, string)">its overload</see> for every
         /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
         /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
-        /// while the detected methods are stored in <see cref="methodsByName">methodsByName</see>.
+        /// while the detected methods are stored in <see cref="methodInfosByName">methodsByName</see>.
         /// </para><para>
         /// This method is called by <see cref="OnLinkInvalidated">OnLinkInvalidated</see>
         /// if <see cref="IsLinkValid">IsLinkValid</see> has become <c>false</c>.<br/>
@@ -355,7 +365,7 @@ protected virtual bool TryRestoreLinkFor(TSyncValue syncValue)
         /// <param name="syncMethod">The sync method to link.</param>
         /// <param name="methodName">The name of the sync method to link.</param>
         /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
-        protected abstract bool TryRestoreLinkFor(Action<TSyncObject> syncMethod, string methodName);
+        protected abstract bool TryRestoreLinkFor(Action syncMethod, string methodName);
 
         private void Dispose(bool disposing)
         {

From 5f13612bbad78c101615daec3db413cb0b1bed0f Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Fri, 7 Mar 2025 23:18:09 +0100
Subject: [PATCH 17/22] Move SyncObject registration

---
 MonkeyLoader/Sync/MonkeySyncObject.cs | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index 65783e0..75a829d 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -64,7 +64,10 @@ public interface IUnlinkedMonkeySyncObject<TLink> : ILinkedMonkeySyncObject<TLin
         where TLink : class
     {
         /// <summary>
-        /// Establishes this sync object's link with the given object.
+        /// Establishes this sync object's link with the given object.<br/>
+        /// If the link is successfully created, the now linked sync object will be
+        /// <see cref="MonkeySyncRegistry.RegisterLinkedSyncObject{TLink}">added</see>
+        /// to the <see cref="MonkeySyncRegistry"/>.
         /// </summary>
         /// <remarks>
         /// If the link fails or gets broken, a new instance has to be created.
@@ -135,6 +138,8 @@ static MonkeySyncObject()
             foreach (var property in syncValueProperties)
                 propertyAccessorsByName.Add(property.Name, (TSyncObject instance) => (TSyncValue)property.GetValue(instance));
 
+            // Replace this with a special MonkeySyncMethod type that takes an action as the target
+            // The invoke method can then be overridden to for example set the user field that triggers the method.
             var syncMethods = typeof(TSyncObject).GetMethods(AccessTools.all)
                 .Where(MonkeySyncMethodAttribute.IsValid);
 
@@ -181,7 +186,11 @@ public bool LinkWith(TLink linkObject, bool fromRemote = false)
 
             LinkObject = linkObject;
 
-            return EstablishLink(fromRemote);
+            if (!EstablishLink(fromRemote))
+                return false;
+
+            MonkeySyncRegistry.RegisterLinkedSyncObject(this);
+            return true;
         }
 
         /// <remarks><para>
@@ -189,10 +198,7 @@ public bool LinkWith(TLink linkObject, bool fromRemote = false)
         /// and calls <see cref="EstablishLinkFor(TSyncValue, string, bool)">EstablishLinkFor</see>
         /// for every readable <typeparamref name="TSyncValue"/> instance property and
         /// <see cref="EstablishLinkFor(TSyncValue, string, bool)">its overload</see> for every
-        /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
-        /// If the link is successfully created, this linked sync object will be
-        /// <see cref="MonkeySyncRegistry.RegisterLinkedSyncObject{TLink}">added</see>
-        /// to the <see cref="MonkeySyncRegistry"/> automatically.
+        /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.
         /// </para><para>
         /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
         /// while the detected methods are stored in <see cref="methodInfosByName">methodsByName</see>.
@@ -221,9 +227,6 @@ protected virtual bool EstablishLink(bool fromRemote)
             foreach (var syncMethod in methodsByName)
                 success &= EstablishLinkFor(syncMethod.Value, syncMethod.Key, fromRemote);
 
-            if (success)
-                MonkeySyncRegistry.RegisterLinkedSyncObject(this);
-
             return success;
         }
 

From f00fe3e83ed8745b4a3f19f4f30029f983dc7e45 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sat, 8 Mar 2025 18:34:17 +0100
Subject: [PATCH 18/22] Make MonkeySync methods tied to a value and support
 fields + properties

---
 MonkeyLoader/MonkeyLoader.csproj              |  2 +-
 MonkeyLoader/Sync/IMonkeySyncMethod.cs        | 88 +++++++++++++++++
 MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs | 13 +++
 .../Sync/MonkeySyncMethodAttribute.cs         | 31 ------
 MonkeyLoader/Sync/MonkeySyncObject.cs         | 94 +++++++++----------
 MonkeyLoader/Sync/MonkeySyncValue.cs          |  8 +-
 6 files changed, 149 insertions(+), 87 deletions(-)
 create mode 100644 MonkeyLoader/Sync/IMonkeySyncMethod.cs
 create mode 100644 MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs
 delete mode 100644 MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 0622d69..6c5ae36 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.10-MonkeySync-beta</Version>
+    <Version>0.24.11-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/IMonkeySyncMethod.cs b/MonkeyLoader/Sync/IMonkeySyncMethod.cs
new file mode 100644
index 0000000..7969774
--- /dev/null
+++ b/MonkeyLoader/Sync/IMonkeySyncMethod.cs
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MonkeyLoader.Sync
+{
+    /// <summary>
+    /// The delegate that is represented by MonkeySync methods.
+    /// </summary>
+    public delegate void MonkeySyncAction();
+
+    /// <summary>
+    /// The delegate that is represented by MonkeySync methods.
+    /// </summary>
+    /// <param name="trigger">The value that triggered this method.</param>
+    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
+    public delegate void MonkeySyncFunc<T>(T trigger);
+
+    /// <summary>
+    /// Defines the non-generic interface for <see cref="ILinkedMonkeySyncMethod{TLink, T}"/>s.
+    /// </summary>
+    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
+    public interface ILinkedMonkeySyncMethod<out TLink> : ILinkedMonkeySyncValue<TLink>
+    {
+    }
+
+    /// <summary>
+    /// Defines the generic interface for linked <see cref="MonkeySyncMethod{TLink, T}"/>s.
+    /// </summary>
+    /// <typeparam name="TLink">The type of the link object used by the sync object that this sync value links to.</typeparam>
+    /// <typeparam name="T">The type of the <see cref="ILinkedMonkeySyncValue{T}.Value">Value</see> that can trigger this sync method.</typeparam>
+    public interface ILinkedMonkeySyncMethod<out TLink, T> : ILinkedMonkeySyncMethod<TLink>, ILinkedMonkeySyncValue<TLink, T>
+    {
+        /// <summary>
+        /// Gets the delegate that can be triggered by this sync method.
+        /// </summary>
+        public MonkeySyncFunc<T> Function { get; }
+    }
+
+    /// <summary>
+    /// Defines the interface for not yet linked <see cref="MonkeySyncMethod{TLink, T}"/>s.
+    /// </summary>
+    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
+    public interface IUnlinkedMonkeySyncMethod<TLink> : ILinkedMonkeySyncMethod<TLink>, IUnlinkedMonkeySyncValue<TLink>
+    { }
+
+    /// <summary>
+    /// Implements an abstract example for <see cref="ILinkedMonkeySyncMethod{TLink, T}"/>s.
+    /// </summary>
+    /// <remarks>
+    /// This class is in all likelihood not useful to actually derive from.<br/>
+    /// It mainly serves as an example for how an implementation could look.
+    /// </remarks>
+    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
+    public abstract class MonkeySyncMethod<TLink, T> : MonkeySyncValue<TLink, T>,
+        IUnlinkedMonkeySyncMethod<TLink>, ILinkedMonkeySyncMethod<TLink, T>
+    {
+        /// <inheritdoc/>
+        public MonkeySyncFunc<T> Function { get; }
+
+        /// <summary>
+        /// Creates a new sync method instance that wraps the given <paramref name="value"/>,
+        /// changes of which can trigger the target <paramref name="function"/>.
+        /// </summary>
+        /// <param name="function">The delegate that can be triggered by this sync method.</param>
+        /// <param name="value">The value to wrap.</param>
+        protected MonkeySyncMethod(MonkeySyncFunc<T> function, T value) : base(value)
+        {
+            Function = function;
+        }
+
+        /// <summary>
+        /// Creates a new sync method instance that wraps the given <paramref name="value"/>,
+        /// changes of which can trigger the target <paramref name="action"/>.
+        /// </summary>
+        /// <param name="action">The delegate that can be triggered by this sync method.</param>
+        /// <param name="value">The value to wrap.</param>
+        protected MonkeySyncMethod(MonkeySyncAction action, T value)
+            : this(_ => action(), value)
+        { }
+
+        /// <summary>
+        /// Creates structures that make this method triggerable by others locally or in shared environments,
+        /// whether they have the mod implementing the method or not.
+        /// </summary>
+        public abstract void MakeInvocation();
+    }
+}
\ No newline at end of file
diff --git a/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs b/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs
new file mode 100644
index 0000000..9aac0ee
--- /dev/null
+++ b/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace MonkeyLoader.Sync
+{
+    /// <summary>
+    /// Marks a field or property with a compatible <see cref="IUnlinkedMonkeySyncValue{TLink}"/> type
+    /// on a class deriving from <see cref="MonkeySyncValue{TLink, T}"/>
+    /// to be excluded from the automatically detected fields and properties.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
+    public sealed class IgnoreSyncValueAttribute : MonkeyLoaderAttribute
+    { }
+}
\ No newline at end of file
diff --git a/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs b/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
deleted file mode 100644
index d482495..0000000
--- a/MonkeyLoader/Sync/MonkeySyncMethodAttribute.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System;
-using System.Reflection;
-
-namespace MonkeyLoader.Sync
-{
-    /// <summary>
-    /// Marks a <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}">MonkeySync
-    /// object's</see> instance method as being triggerable through the MonkeySync system.
-    /// </summary>
-    /// <remarks>
-    /// The method must be
-    /// </remarks>
-    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
-    public sealed class MonkeySyncMethodAttribute : MonkeyLoaderAttribute
-    {
-        /// <summary>
-        /// Determines whether the given <paramref name="method"/>
-        /// is suitable to be triggerable through the MonkeySync system.
-        /// </summary>
-        /// <remarks>
-        /// To be suitable, a method must be a non-generic parameterless void instance method,
-        /// which is decorated with <see cref="MonkeySyncMethodAttribute">this attribute</see>.
-        /// </remarks>
-        /// <param name="method">The method to check for suitability.</param>
-        /// <returns><c>true</c> if the method is suitable; otherwise, <c>false</c>.</returns>
-        public static bool IsValid(MethodInfo method)
-            => !method.IsStatic && !method.ContainsGenericParameters
-             && method.ReturnType == typeof(void) && method.GetParameters().Length == 0
-             && method.GetCustomAttribute<MonkeySyncMethodAttribute>() is not null;
-    }
-}
\ No newline at end of file
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index 75a829d..b4ca178 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -81,6 +81,13 @@ public interface IUnlinkedMonkeySyncObject<TLink> : ILinkedMonkeySyncObject<TLin
     /// <summary>
     /// Implements the abstract base for MonkeySync objects.
     /// </summary>
+    /// <remarks>
+    /// Automatically detects any instance fields / properties containing
+    /// MonkeySync values or methods compatible with <typeparamref name="TSyncValue"/>.<br/>
+    /// Property names take precedence over their backing fields.<br/>
+    /// Use the <see cref="IgnoreSyncValueAttribute"/> to mark fields / properties that should be ignored.
+    /// If a property is marked, its backing field will be ignored too.
+    /// </remarks>
     /// <typeparam name="TSyncObject">The concrete type of the MonkeySync object.</typeparam>
     /// <typeparam name="TSyncValue">
     /// The <see cref="IUnlinkedMonkeySyncValue{TLink}"/>-derived interface
@@ -93,21 +100,14 @@ public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlink
         where TLink : class
     {
         /// <summary>
-        /// The <see cref="MethodInfo"/>s of the detected <see cref="MonkeySyncMethodAttribute">MonkeySync
-        /// methods</see> of this type by their name.
+        /// The getters for the automatically detected <typeparamref name="TSyncValue"/> instance fields / properties by their name.
         /// </summary>
-        protected static readonly Dictionary<string, MethodInfo> methodInfosByName = new(StringComparer.Ordinal);
-
-        /// <summary>
-        /// The getters for the detected <typeparamref name="TSyncValue"/> instance properties by their name.
-        /// </summary>
-        protected static readonly Dictionary<string, Func<TSyncObject, TSyncValue>> propertyAccessorsByName = new(StringComparer.Ordinal);
-
-        /// <summary>
-        /// The <see cref="Action"/>s to invoke the detected <see cref="MonkeySyncMethodAttribute">MonkeySync
-        /// methods</see> of this type by their name.
-        /// </summary>
-        protected readonly Dictionary<string, Action> methodsByName = new(StringComparer.Ordinal);
+        /// <remarks>
+        /// Property names take precedence over their backing fields.<br/>
+        /// Use the <see cref="IgnoreSyncValueAttribute"/> to mark fields / properties that should be ignored.
+        /// If a property is marked, its backing field will be ignored too.
+        /// </remarks>
+        protected static readonly Dictionary<string, Func<TSyncObject, TSyncValue>> syncValueAccessorsByName = new(StringComparer.Ordinal);
 
         /// <summary>
         /// The <typeparamref name="TSyncValue"/> instances associated with this sync object.
@@ -132,19 +132,34 @@ public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlink
         static MonkeySyncObject()
         {
             var syncValueType = typeof(TSyncValue);
+            var syncValueFields = typeof(TSyncObject).GetFields(AccessTools.all)
+                .Where(field => !field.IsStatic && syncValueType.IsAssignableFrom(field.FieldType) && field.GetCustomAttribute<IgnoreSyncValueAttribute>() is null);
+
             var syncValueProperties = typeof(TSyncObject).GetProperties(AccessTools.all)
                 .Where(property => syncValueType.IsAssignableFrom(property.PropertyType) && (!(property.GetGetMethod()?.IsStatic ?? true)));
 
+            foreach (var field in syncValueFields)
+                syncValueAccessorsByName.Add(field.Name, (TSyncObject instance) => (TSyncValue)field.GetValue(instance));
+
             foreach (var property in syncValueProperties)
-                propertyAccessorsByName.Add(property.Name, (TSyncObject instance) => (TSyncValue)property.GetValue(instance));
+            {
+                var fieldName = $"<{property.Name}>";
+                var potentialField = syncValueAccessorsByName.FirstOrDefault(entry => entry.Key.Contains(fieldName));
+                var hasIgnoreAttribute = property.GetCustomAttribute<IgnoreSyncValueAttribute>() is null;
+
+                if (potentialField.Value is not null)
+                {
+                    syncValueAccessorsByName.Remove(potentialField.Key);
 
-            // Replace this with a special MonkeySyncMethod type that takes an action as the target
-            // The invoke method can then be overridden to for example set the user field that triggers the method.
-            var syncMethods = typeof(TSyncObject).GetMethods(AccessTools.all)
-                .Where(MonkeySyncMethodAttribute.IsValid);
+                    if (!hasIgnoreAttribute)
+                        syncValueAccessorsByName.Add(property.Name, potentialField.Value);
 
-            foreach (var method in syncMethods)
-                methodInfosByName.Add(method.Name, method);
+                    continue;
+                }
+
+                if (!hasIgnoreAttribute)
+                    syncValueAccessorsByName.Add(property.Name, (TSyncObject instance) => (TSyncValue)property.GetValue(instance));
+            }
         }
 
         /// <summary>
@@ -157,9 +172,6 @@ protected MonkeySyncObject()
         {
             if (GetType() != typeof(TSyncObject))
                 throw new InvalidOperationException("TSyncObject must be the concrete Type being instantiated!");
-
-            foreach (var methodEntry in methodInfosByName)
-                methodsByName.Add(methodEntry.Key, AccessTools.MethodDelegate<Action>(methodEntry.Value, this));
         }
 
         /// <summary>
@@ -196,12 +208,9 @@ public bool LinkWith(TLink linkObject, bool fromRemote = false)
         /// <remarks><para>
         /// <i>By default:</i> Sets up the <see cref="INotifyValueChanged.Changed"/> event handlers
         /// and calls <see cref="EstablishLinkFor(TSyncValue, string, bool)">EstablishLinkFor</see>
-        /// for every readable <typeparamref name="TSyncValue"/> instance property and
-        /// <see cref="EstablishLinkFor(TSyncValue, string, bool)">its overload</see> for every
-        /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.
+        /// for every <typeparamref name="TSyncValue"/> instance field / property on <typeparamref name="TSyncObject"/>.
         /// </para><para>
-        /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
-        /// while the detected methods are stored in <see cref="methodInfosByName">methodsByName</see>.
+        /// The detected fields / properties are stored in <see cref="syncValueAccessorsByName">syncValueAccessorsByName</see>.
         /// </para><para>
         /// This method is called by <see cref="LinkWith">LinkWith</see>
         /// after the <see cref="LinkObject">LinkObject</see> has been assigned.<br/>
@@ -214,7 +223,7 @@ protected virtual bool EstablishLink(bool fromRemote)
         {
             var success = true;
 
-            foreach (var syncValueProperty in propertyAccessorsByName)
+            foreach (var syncValueProperty in syncValueAccessorsByName)
             {
                 var syncValue = syncValueProperty.Value((TSyncObject)this);
 
@@ -224,9 +233,6 @@ protected virtual bool EstablishLink(bool fromRemote)
                 success &= EstablishLinkFor(syncValue, syncValueProperty.Key, fromRemote);
             }
 
-            foreach (var syncMethod in methodsByName)
-                success &= EstablishLinkFor(syncMethod.Value, syncMethod.Key, fromRemote);
-
             return success;
         }
 
@@ -312,7 +318,7 @@ protected void OnLinkInvalidated()
         /// event with the given <paramref name="propertyName"/>.
         /// </summary>
         /// <remarks>
-        /// This is automatically called for any <typeparamref name="TSyncValue"/> properties.
+        /// This is automatically called for any <typeparamref name="TSyncValue"/> fields / properties.
         /// </remarks>
         /// <param name="propertyName">The name of the property that changed.</param>
         protected void OnPropertyChanged(string propertyName)
@@ -324,11 +330,8 @@ protected void OnPropertyChanged(string propertyName)
 
         /// <remarks><para>
         /// <i>By default:</i> Calls <see cref="TryRestoreLinkFor(TSyncValue)">TryRestoreLinkFor</see>
-        /// for every readable <typeparamref name="TSyncValue"/> instance property and
-        /// <see cref="TryRestoreLinkFor(Action, string)">its overload</see> for every
-        /// <see cref="MonkeySyncMethodAttribute">MonkeySync method</see> on <typeparamref name="TSyncObject"/>.<br/>
-        /// The detected properties are stored in <see cref="propertyAccessorsByName">propertyAccessorsByName</see>,
-        /// while the detected methods are stored in <see cref="methodInfosByName">methodsByName</see>.
+        /// for every <typeparamref name="TSyncValue"/> instance field on <typeparamref name="TSyncObject"/>.<br/>
+        /// The detected fields / properties are stored in <see cref="syncValueAccessorsByName">syncValueAccessorsByName</see>.
         /// </para><para>
         /// This method is called by <see cref="OnLinkInvalidated">OnLinkInvalidated</see>
         /// if <see cref="IsLinkValid">IsLinkValid</see> has become <c>false</c>.<br/>
@@ -341,12 +344,9 @@ protected virtual bool TryRestoreLink()
         {
             var success = true;
 
-            foreach (var syncValues in propertyAccessorsByName.Values)
+            foreach (var syncValues in syncValueAccessorsByName.Values)
                 success &= TryRestoreLinkFor(syncValues((TSyncObject)this));
 
-            foreach (var syncMethod in methodsByName)
-                success &= TryRestoreLinkFor(syncMethod.Value, syncMethod.Key);
-
             return success;
         }
 
@@ -362,14 +362,6 @@ protected virtual bool TryRestoreLink()
         protected virtual bool TryRestoreLinkFor(TSyncValue syncValue)
             => syncValue.TryRestoreLink();
 
-        /// <summary>
-        /// Tries to restore the link for the given sync method of the given name.
-        /// </summary>
-        /// <param name="syncMethod">The sync method to link.</param>
-        /// <param name="methodName">The name of the sync method to link.</param>
-        /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
-        protected abstract bool TryRestoreLinkFor(Action syncMethod, string methodName);
-
         private void Dispose(bool disposing)
         {
             if (_disposedValue)
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index ba2f06e..50f25d6 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -52,7 +52,7 @@ public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged, IDispo
     /// <summary>
     /// Defines the generic interface for linked <see cref="MonkeySyncValue{TLink, T}"/>s.
     /// </summary>
-    /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
+    /// <typeparam name="TLink">The type of the link object used by the sync object that this sync value links to.</typeparam>
     /// <typeparam name="T">The type of the <see cref="ILinkedMonkeySyncValue{T}.Value">Value</see>.</typeparam>
     public interface ILinkedMonkeySyncValue<out TLink, T> : INotifyValueChanged<T>,
         IReadOnlyMonkeySyncValue<TLink, T>, IWriteOnlyMonkeySyncValue<TLink, T>
@@ -86,10 +86,10 @@ public interface IUnlinkedMonkeySyncValue<TLink> : ILinkedMonkeySyncValue<TLink>
         /// Establishes this sync value's association and link through the given sync object.
         /// </summary>
         /// <param name="syncObject">The sync object that this value belongs to.</param>
-        /// <param name="propertyName">The property name of this sync value.</param>
+        /// <param name="name">The name of this sync value.</param>
         /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
         /// <returns><c>true</c> if the established link is valid; otherwise, <c>false</c>.</returns>
-        public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string propertyName, bool fromRemote);
+        public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string name, bool fromRemote);
     }
 
     /// <summary>
@@ -153,7 +153,7 @@ public virtual T Value
         public Type ValueType => _valueType;
 
         /// <summary>
-        /// Creates a new sync object instance that wraps the given <paramref name="value"/>.
+        /// Creates a new sync value instance that wraps the given <paramref name="value"/>.
         /// </summary>
         /// <param name="value">The value to wrap.</param>
         public MonkeySyncValue(T value)

From 8d831b1010aa635e6c8e637d30ceda6ce022075f Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sat, 8 Mar 2025 19:29:12 +0100
Subject: [PATCH 19/22] Add SyncObject type parameter to sync values

---
 MonkeyLoader/MonkeyLoader.csproj              |  2 +-
 MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs |  4 +-
 ...onkeySyncMethod.cs => MonkeySyncMethod.cs} | 21 +++++---
 MonkeyLoader/Sync/MonkeySyncObject.cs         | 10 ++--
 MonkeyLoader/Sync/MonkeySyncValue.cs          | 49 +++++++++++--------
 5 files changed, 49 insertions(+), 37 deletions(-)
 rename MonkeyLoader/Sync/{IMonkeySyncMethod.cs => MonkeySyncMethod.cs} (72%)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 6c5ae36..6f84a74 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.11-MonkeySync-beta</Version>
+    <Version>0.24.12-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs b/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs
index 9aac0ee..d70ed20 100644
--- a/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs
+++ b/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs
@@ -3,8 +3,8 @@
 namespace MonkeyLoader.Sync
 {
     /// <summary>
-    /// Marks a field or property with a compatible <see cref="IUnlinkedMonkeySyncValue{TLink}"/> type
-    /// on a class deriving from <see cref="MonkeySyncValue{TLink, T}"/>
+    /// Marks a field or property with a compatible <see cref="IUnlinkedMonkeySyncValue{TLink, TSyncValue}"/> type
+    /// on a class deriving from <see cref="MonkeySyncValue{TLink, TSyncValue, T}"/>
     /// to be excluded from the automatically detected fields and properties.
     /// </summary>
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
diff --git a/MonkeyLoader/Sync/IMonkeySyncMethod.cs b/MonkeyLoader/Sync/MonkeySyncMethod.cs
similarity index 72%
rename from MonkeyLoader/Sync/IMonkeySyncMethod.cs
rename to MonkeyLoader/Sync/MonkeySyncMethod.cs
index 7969774..9954442 100644
--- a/MonkeyLoader/Sync/IMonkeySyncMethod.cs
+++ b/MonkeyLoader/Sync/MonkeySyncMethod.cs
@@ -20,16 +20,19 @@ namespace MonkeyLoader.Sync
     /// Defines the non-generic interface for <see cref="ILinkedMonkeySyncMethod{TLink, T}"/>s.
     /// </summary>
     /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
-    public interface ILinkedMonkeySyncMethod<out TLink> : ILinkedMonkeySyncValue<TLink>
+    public interface ILinkedMonkeySyncMethod<out TLink, out TSyncObject> : ILinkedMonkeySyncValue<TLink, TSyncObject>
+        where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
     }
 
     /// <summary>
-    /// Defines the generic interface for linked <see cref="MonkeySyncMethod{TLink, T}"/>s.
+    /// Defines the generic interface for linked <see cref="MonkeySyncMethod{TLink, TSyncObject, T}"/>s.
     /// </summary>
     /// <typeparam name="TLink">The type of the link object used by the sync object that this sync value links to.</typeparam>
-    /// <typeparam name="T">The type of the <see cref="ILinkedMonkeySyncValue{T}.Value">Value</see> that can trigger this sync method.</typeparam>
-    public interface ILinkedMonkeySyncMethod<out TLink, T> : ILinkedMonkeySyncMethod<TLink>, ILinkedMonkeySyncValue<TLink, T>
+    /// <typeparam name="TSyncObject">The type of the sync object that may contain this sync value.</typeparam>
+    /// <typeparam name="T">The type of the <see cref="ILinkedMonkeySyncValue{T, TSyncObject}.Value">Value</see> that can trigger this sync method.</typeparam>
+    public interface ILinkedMonkeySyncMethod<out TLink, out TSyncObject, T> : ILinkedMonkeySyncMethod<TLink, TSyncObject>, ILinkedMonkeySyncValue<TLink, TSyncObject, T>
+        where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
         /// <summary>
         /// Gets the delegate that can be triggered by this sync method.
@@ -38,10 +41,11 @@ public interface ILinkedMonkeySyncMethod<out TLink, T> : ILinkedMonkeySyncMethod
     }
 
     /// <summary>
-    /// Defines the interface for not yet linked <see cref="MonkeySyncMethod{TLink, T}"/>s.
+    /// Defines the interface for not yet linked <see cref="MonkeySyncMethod{TLink, TSyncObject, T}"/>s.
     /// </summary>
     /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
-    public interface IUnlinkedMonkeySyncMethod<TLink> : ILinkedMonkeySyncMethod<TLink>, IUnlinkedMonkeySyncValue<TLink>
+    public interface IUnlinkedMonkeySyncMethod<TLink, TSyncObject> : ILinkedMonkeySyncMethod<TLink, TSyncObject>, IUnlinkedMonkeySyncValue<TLink, TSyncObject>
+        where TSyncObject : ILinkedMonkeySyncObject<TLink>
     { }
 
     /// <summary>
@@ -52,8 +56,9 @@ public interface IUnlinkedMonkeySyncMethod<TLink> : ILinkedMonkeySyncMethod<TLin
     /// It mainly serves as an example for how an implementation could look.
     /// </remarks>
     /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
-    public abstract class MonkeySyncMethod<TLink, T> : MonkeySyncValue<TLink, T>,
-        IUnlinkedMonkeySyncMethod<TLink>, ILinkedMonkeySyncMethod<TLink, T>
+    public abstract class MonkeySyncMethod<TLink, TSyncObject, T> : MonkeySyncValue<TLink, TSyncObject, T>,
+            IUnlinkedMonkeySyncMethod<TLink, TSyncObject>, ILinkedMonkeySyncMethod<TLink, TSyncObject, T>
+        where TSyncObject : class, ILinkedMonkeySyncObject<TLink>
     {
         /// <inheritdoc/>
         public MonkeySyncFunc<T> Function { get; }
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index b4ca178..14726c2 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -90,13 +90,13 @@ public interface IUnlinkedMonkeySyncObject<TLink> : ILinkedMonkeySyncObject<TLin
     /// </remarks>
     /// <typeparam name="TSyncObject">The concrete type of the MonkeySync object.</typeparam>
     /// <typeparam name="TSyncValue">
-    /// The <see cref="IUnlinkedMonkeySyncValue{TLink}"/>-derived interface
+    /// The <see cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject}"/>-derived interface
     /// that the MonkeySync values of this object must implement.
     /// </typeparam>
     /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
     public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlinkedMonkeySyncObject<TLink>
         where TSyncObject : MonkeySyncObject<TSyncObject, TSyncValue, TLink>
-        where TSyncValue : IUnlinkedMonkeySyncValue<TLink>
+        where TSyncValue : IUnlinkedMonkeySyncValue<TLink, TSyncObject>
         where TLink : class
     {
         /// <summary>
@@ -241,7 +241,7 @@ protected virtual bool EstablishLink(bool fromRemote)
         /// </summary>
         /// <remarks>
         /// <i>By default:</i> Adds the given sync value to the <see cref="syncValues">set of instances</see> and calls
-        /// <c><paramref name="syncValue"/>.<see cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor">EstablishLinkFor</see>(…)</c>.
+        /// <c><paramref name="syncValue"/>.<see cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject}.EstablishLinkFor">EstablishLinkFor</see>(…)</c>.
         /// </remarks>
         /// <param name="syncValue">The sync value to link.</param>
         /// <param name="propertyName">The name of the sync value to link.</param>
@@ -250,7 +250,7 @@ protected virtual bool EstablishLink(bool fromRemote)
         protected virtual bool EstablishLinkFor(TSyncValue syncValue, string propertyName, bool fromRemote)
         {
             syncValues.Add(syncValue);
-            return syncValue.EstablishLinkFor(this, propertyName, fromRemote);
+            return syncValue.EstablishLinkFor((TSyncObject)this, propertyName, fromRemote);
         }
 
         /// <summary>
@@ -355,7 +355,7 @@ protected virtual bool TryRestoreLink()
         /// </summary>
         /// <remarks>
         /// <i>By default:</i> Calls
-        /// <c><paramref name="syncValue"/>.<see cref="ILinkedMonkeySyncValue{TLink}.TryRestoreLink">TryRestoreLink</see>()</c>.
+        /// <c><paramref name="syncValue"/>.<see cref="ILinkedMonkeySyncValue{TLink, TSyncObject}.TryRestoreLink">TryRestoreLink</see>()</c>.
         /// </remarks>
         /// <param name="syncValue">The sync value to link.</param>
         /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index 50f25d6..947a663 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -13,11 +13,12 @@ namespace MonkeyLoader.Sync
     /// Defines the non-generic interface for <see cref="ILinkedMonkeySyncValue{TLink, T}"/>s.
     /// </summary>
     /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
-    public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged, IDisposable
+    public interface ILinkedMonkeySyncValue<out TLink, out TSyncObject> : INotifyValueChanged, IDisposable
+        where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
         /// <summary>
         /// Gets the <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}.LinkObject">LinkObject</see>
-        /// of the <see cref="ILinkedMonkeySyncValue{TLink}.SyncObject">SyncObject</see> that this value belongs to.
+        /// of the <see cref="ILinkedMonkeySyncValue{TLink, TSyncObject}.SyncObject">SyncObject</see> that this value belongs to.
         /// </summary>
         public TLink LinkObject { get; }
 
@@ -29,7 +30,7 @@ public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged, IDispo
         /// <summary>
         /// Gets the sync object that this value belongs to.
         /// </summary>
-        public ILinkedMonkeySyncObject<TLink> SyncObject { get; }
+        public TSyncObject SyncObject { get; }
 
         /// <summary>
         /// Gets or sets the internal value of this sync value.
@@ -50,25 +51,28 @@ public interface ILinkedMonkeySyncValue<out TLink> : INotifyValueChanged, IDispo
     }
 
     /// <summary>
-    /// Defines the generic interface for linked <see cref="MonkeySyncValue{TLink, T}"/>s.
+    /// Defines the generic interface for linked <see cref="MonkeySyncValue{TLink, TSyncObject, T}"/>s.
     /// </summary>
     /// <typeparam name="TLink">The type of the link object used by the sync object that this sync value links to.</typeparam>
-    /// <typeparam name="T">The type of the <see cref="ILinkedMonkeySyncValue{T}.Value">Value</see>.</typeparam>
-    public interface ILinkedMonkeySyncValue<out TLink, T> : INotifyValueChanged<T>,
-        IReadOnlyMonkeySyncValue<TLink, T>, IWriteOnlyMonkeySyncValue<TLink, T>
+    /// <typeparam name="TSyncObject">The type of the sync object that may contain this sync value.</typeparam>
+    /// <typeparam name="T">The type of the <see cref="ILinkedMonkeySyncValue{T, TSyncObject}.Value">Value</see>.</typeparam>
+    public interface ILinkedMonkeySyncValue<out TLink, out TSyncObject, T> : INotifyValueChanged<T>,
+            IReadOnlyMonkeySyncValue<TLink, TSyncObject, T>, IWriteOnlyMonkeySyncValue<TLink, TSyncObject, T>
+        where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
-        /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink}.Value"/>
+        /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, TSyncObject}.Value"/>
         public new T Value { get; set; }
     }
 
     /// <summary>
-    /// Defines the interface for readonly <see cref="ILinkedMonkeySyncValue{TLink}"/>s.
+    /// Defines the interface for readonly <see cref="ILinkedMonkeySyncValue{TLink, TSyncObject}"/>s.
     /// </summary>
     /// <remarks>
     /// This interface exists purely to facilitate keeping a covariant list of sync values.
     /// </remarks>
     /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
-    public interface IReadOnlyMonkeySyncValue<out TLink, out T> : ILinkedMonkeySyncValue<TLink>
+    public interface IReadOnlyMonkeySyncValue<out TLink, out TSyncObject, out T> : ILinkedMonkeySyncValue<TLink, TSyncObject>
+        where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
         /// <summary>
         /// Gets the internal value of this sync value.
@@ -77,10 +81,11 @@ public interface IReadOnlyMonkeySyncValue<out TLink, out T> : ILinkedMonkeySyncV
     }
 
     /// <summary>
-    /// Defines the interface for not yet linked <see cref="MonkeySyncValue{TLink, T}"/>s.
+    /// Defines the interface for not yet linked <see cref="MonkeySyncValue{TLink, TSyncObject, T}"/>s.
     /// </summary>
     /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
-    public interface IUnlinkedMonkeySyncValue<TLink> : ILinkedMonkeySyncValue<TLink>
+    public interface IUnlinkedMonkeySyncValue<TLink, TSyncObject> : ILinkedMonkeySyncValue<TLink, TSyncObject>
+        where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
         /// <summary>
         /// Establishes this sync value's association and link through the given sync object.
@@ -89,17 +94,18 @@ public interface IUnlinkedMonkeySyncValue<TLink> : ILinkedMonkeySyncValue<TLink>
         /// <param name="name">The name of this sync value.</param>
         /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
         /// <returns><c>true</c> if the established link is valid; otherwise, <c>false</c>.</returns>
-        public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string name, bool fromRemote);
+        public bool EstablishLinkFor(TSyncObject syncObject, string name, bool fromRemote);
     }
 
     /// <summary>
-    /// Defines the interface for writeonly <see cref="ILinkedMonkeySyncValue{TLink}"/>s.
+    /// Defines the interface for writeonly <see cref="ILinkedMonkeySyncValue{TLink, TSyncObject}"/>s.
     /// </summary>
     /// <remarks>
     /// This interface exists purely to facilitate keeping a contravariant list of sync values.
     /// </remarks>
     /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
-    public interface IWriteOnlyMonkeySyncValue<out TLink, in T> : ILinkedMonkeySyncValue<TLink>
+    public interface IWriteOnlyMonkeySyncValue<out TLink, out TSyncObject, in T> : ILinkedMonkeySyncValue<TLink, TSyncObject>
+        where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
         /// <summary>
         /// Sets the internal value of this sync value.
@@ -111,7 +117,8 @@ public interface IWriteOnlyMonkeySyncValue<out TLink, in T> : ILinkedMonkeySyncV
     /// Implements an abstract base for <see cref="ILinkedMonkeySyncValue{TLink, T}"/>s.
     /// </summary>
     /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
-    public abstract class MonkeySyncValue<TLink, T> : IUnlinkedMonkeySyncValue<TLink>, ILinkedMonkeySyncValue<TLink, T>
+    public abstract class MonkeySyncValue<TLink, TSyncObject, T> : IUnlinkedMonkeySyncValue<TLink, TSyncObject>, ILinkedMonkeySyncValue<TLink, TSyncObject, T>
+        where TSyncObject : class, ILinkedMonkeySyncObject<TLink>
     {
         private static readonly Type _valueType = typeof(T);
 
@@ -126,7 +133,7 @@ public abstract class MonkeySyncValue<TLink, T> : IUnlinkedMonkeySyncValue<TLink
         public string Name { get; private set; } = null!;
 
         /// <inheritdoc/>
-        public ILinkedMonkeySyncObject<TLink> SyncObject { get; private set; } = null!;
+        public TSyncObject SyncObject { get; private set; } = null!;
 
         /// <inheritdoc/>
         public virtual T Value
@@ -143,7 +150,7 @@ public virtual T Value
             }
         }
 
-        object? ILinkedMonkeySyncValue<TLink>.Value
+        object? ILinkedMonkeySyncValue<TLink, TSyncObject>.Value
         {
             get => Value;
             set => Value = (T)value!;
@@ -173,7 +180,7 @@ public MonkeySyncValue(T value)
         /// Unwraps the <see cref="Value">Value</see> from the given sync object.
         /// </summary>
         /// <param name="syncValue">The sync object to unwrap.</param>
-        public static implicit operator T(MonkeySyncValue<TLink, T> syncValue) => syncValue.Value;
+        public static implicit operator T(MonkeySyncValue<TLink, TSyncObject, T> syncValue) => syncValue.Value;
 
         /// <inheritdoc/>
         public void Dispose()
@@ -189,7 +196,7 @@ public void Dispose()
         /// Then calls the <see cref="EstablishLinkInternal">internal link method</see>.
         /// </remarks>
         /// <inheritdoc/>
-        public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string propertyName, bool fromRemote)
+        public bool EstablishLinkFor(TSyncObject syncObject, string propertyName, bool fromRemote)
         {
             SyncObject = syncObject;
             Name = propertyName;
@@ -210,7 +217,7 @@ public bool EstablishLinkFor(ILinkedMonkeySyncObject<TLink> syncObject, string p
         /// have already been assigned by the <see cref="EstablishLinkFor">EstablishLinkFor</see>
         /// method that calls this.
         /// </remarks>
-        /// <inheritdoc cref="IUnlinkedMonkeySyncValue{TLink}.EstablishLinkFor"/>
+        /// <inheritdoc cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject}.EstablishLinkFor"/>
         protected abstract bool EstablishLinkInternal(bool fromRemote);
 
         /// <summary>

From d2850a3aeb60aa85e3285e92ae115c36aeb26cf4 Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sat, 8 Mar 2025 22:11:51 +0100
Subject: [PATCH 20/22] More generics make everything better... right?

---
 MonkeyLoader/MonkeyLoader.csproj              |  2 +-
 MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs |  4 +-
 MonkeyLoader/Sync/MonkeySyncMethod.cs         | 22 +++--
 MonkeyLoader/Sync/MonkeySyncObject.cs         | 94 +++++++++----------
 MonkeyLoader/Sync/MonkeySyncValue.cs          | 34 ++++---
 5 files changed, 82 insertions(+), 74 deletions(-)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index 6f84a74..fe26000 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.12-MonkeySync-beta</Version>
+    <Version>0.24.13-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs b/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs
index d70ed20..8fd5cd0 100644
--- a/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs
+++ b/MonkeyLoader/Sync/IgnoreSyncValueAttribute.cs
@@ -3,8 +3,8 @@
 namespace MonkeyLoader.Sync
 {
     /// <summary>
-    /// Marks a field or property with a compatible <see cref="IUnlinkedMonkeySyncValue{TLink, TSyncValue}"/> type
-    /// on a class deriving from <see cref="MonkeySyncValue{TLink, TSyncValue, T}"/>
+    /// Marks a field or property with a compatible <see cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject, TLinkedSyncValue}"/> type
+    /// on a class deriving from <see cref="MonkeySyncValue{TLink, TUnlinkedSyncValue, TLinkedSyncValue, T}"/>
     /// to be excluded from the automatically detected fields and properties.
     /// </summary>
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
diff --git a/MonkeyLoader/Sync/MonkeySyncMethod.cs b/MonkeyLoader/Sync/MonkeySyncMethod.cs
index 9954442..56789a3 100644
--- a/MonkeyLoader/Sync/MonkeySyncMethod.cs
+++ b/MonkeyLoader/Sync/MonkeySyncMethod.cs
@@ -19,14 +19,14 @@ namespace MonkeyLoader.Sync
     /// <summary>
     /// Defines the non-generic interface for <see cref="ILinkedMonkeySyncMethod{TLink, T}"/>s.
     /// </summary>
-    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
+    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, TLinkedSyncValue, T}"/>
     public interface ILinkedMonkeySyncMethod<out TLink, out TSyncObject> : ILinkedMonkeySyncValue<TLink, TSyncObject>
         where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
     }
 
     /// <summary>
-    /// Defines the generic interface for linked <see cref="MonkeySyncMethod{TLink, TSyncObject, T}"/>s.
+    /// Defines the generic interface for linked <see cref="MonkeySyncMethod{TLink, TSyncObject, TLinkedSyncValue, T}"/>s.
     /// </summary>
     /// <typeparam name="TLink">The type of the link object used by the sync object that this sync value links to.</typeparam>
     /// <typeparam name="TSyncObject">The type of the sync object that may contain this sync value.</typeparam>
@@ -41,11 +41,12 @@ public interface ILinkedMonkeySyncMethod<out TLink, out TSyncObject, T> : ILinke
     }
 
     /// <summary>
-    /// Defines the interface for not yet linked <see cref="MonkeySyncMethod{TLink, TSyncObject, T}"/>s.
+    /// Defines the interface for not yet linked <see cref="MonkeySyncMethod{TLink, TSyncObject, TLinkedSyncValue, T}"/>s.
     /// </summary>
-    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
-    public interface IUnlinkedMonkeySyncMethod<TLink, TSyncObject> : ILinkedMonkeySyncMethod<TLink, TSyncObject>, IUnlinkedMonkeySyncValue<TLink, TSyncObject>
+    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, TLinkedSyncValue, T}"/>
+    public interface IUnlinkedMonkeySyncMethod<in TLink, in TSyncObject, out TLinkedSyncValue> : IUnlinkedMonkeySyncValue<TLink, TSyncObject, TLinkedSyncValue>
         where TSyncObject : ILinkedMonkeySyncObject<TLink>
+        where TLinkedSyncValue : ILinkedMonkeySyncValue<TLink, TSyncObject>
     { }
 
     /// <summary>
@@ -55,10 +56,12 @@ public interface IUnlinkedMonkeySyncMethod<TLink, TSyncObject> : ILinkedMonkeySy
     /// This class is in all likelihood not useful to actually derive from.<br/>
     /// It mainly serves as an example for how an implementation could look.
     /// </remarks>
-    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, T}"/>
-    public abstract class MonkeySyncMethod<TLink, TSyncObject, T> : MonkeySyncValue<TLink, TSyncObject, T>,
-            IUnlinkedMonkeySyncMethod<TLink, TSyncObject>, ILinkedMonkeySyncMethod<TLink, TSyncObject, T>
+    /// <inheritdoc cref="ILinkedMonkeySyncMethod{TLink, TLinkedSyncValue, T}"/>
+    public abstract class MonkeySyncMethod<TLink, TSyncObject, TSyncValue, T> : MonkeySyncValue<TLink, TSyncObject, TSyncValue, T>,
+            IUnlinkedMonkeySyncMethod<TLink, TSyncObject, TSyncValue>,
+            ILinkedMonkeySyncMethod<TLink, TSyncObject, T>
         where TSyncObject : class, ILinkedMonkeySyncObject<TLink>
+        where TSyncValue : MonkeySyncMethod<TLink, TSyncObject, TSyncValue, T>
     {
         /// <inheritdoc/>
         public MonkeySyncFunc<T> Function { get; }
@@ -84,6 +87,9 @@ protected MonkeySyncMethod(MonkeySyncAction action, T value)
             : this(_ => action(), value)
         { }
 
+        TSyncValue? IUnlinkedMonkeySyncValue<TLink, TSyncObject, TSyncValue>.EstablishLinkFor(TSyncObject syncObject, string name, bool fromRemote)
+            => EstablishLinkFor(syncObject, name, fromRemote);
+
         /// <summary>
         /// Creates structures that make this method triggerable by others locally or in shared environments,
         /// whether they have the mod implementing the method or not.
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index 14726c2..d921705 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -83,36 +83,41 @@ public interface IUnlinkedMonkeySyncObject<TLink> : ILinkedMonkeySyncObject<TLin
     /// </summary>
     /// <remarks>
     /// Automatically detects any instance fields / properties containing
-    /// MonkeySync values or methods compatible with <typeparamref name="TSyncValue"/>.<br/>
+    /// MonkeySync values or methods compatible with <typeparamref name="TUnlinkedSyncValue"/>.<br/>
     /// Property names take precedence over their backing fields.<br/>
     /// Use the <see cref="IgnoreSyncValueAttribute"/> to mark fields / properties that should be ignored.
     /// If a property is marked, its backing field will be ignored too.
     /// </remarks>
     /// <typeparam name="TSyncObject">The concrete type of the MonkeySync object.</typeparam>
-    /// <typeparam name="TSyncValue">
-    /// The <see cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject}"/>-derived interface
-    /// that the MonkeySync values of this object must implement.
+    /// <typeparam name="TUnlinkedSyncValue">
+    /// The <see cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject, TLinkedSyncValue}"/>-derived interface
+    /// that the unlinked MonkeySync values of this object must implement.
+    /// </typeparam>
+    /// <typeparam name="TLinkedSyncValue">
+    /// The <see cref="ILinkedMonkeySyncValue{TLink, TSyncObject}"/>-derived interface
+    /// that the linked MonkeySync values of this object must implement.
     /// </typeparam>
     /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
-    public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlinkedMonkeySyncObject<TLink>
-        where TSyncObject : MonkeySyncObject<TSyncObject, TSyncValue, TLink>
-        where TSyncValue : IUnlinkedMonkeySyncValue<TLink, TSyncObject>
+    public abstract class MonkeySyncObject<TSyncObject, TUnlinkedSyncValue, TLinkedSyncValue, TLink> : IUnlinkedMonkeySyncObject<TLink>
+        where TSyncObject : MonkeySyncObject<TSyncObject, TUnlinkedSyncValue, TLinkedSyncValue, TLink>
+        where TLinkedSyncValue : ILinkedMonkeySyncValue<TLink, TSyncObject>
+        where TUnlinkedSyncValue : IUnlinkedMonkeySyncValue<TLink, TSyncObject, TLinkedSyncValue>
         where TLink : class
     {
         /// <summary>
-        /// The getters for the automatically detected <typeparamref name="TSyncValue"/> instance fields / properties by their name.
+        /// The getters for the automatically detected <typeparamref name="TUnlinkedSyncValue"/> instance fields / properties by their name.
         /// </summary>
         /// <remarks>
         /// Property names take precedence over their backing fields.<br/>
         /// Use the <see cref="IgnoreSyncValueAttribute"/> to mark fields / properties that should be ignored.
         /// If a property is marked, its backing field will be ignored too.
         /// </remarks>
-        protected static readonly Dictionary<string, Func<TSyncObject, TSyncValue>> syncValueAccessorsByName = new(StringComparer.Ordinal);
+        protected static readonly Dictionary<string, Func<TSyncObject, TUnlinkedSyncValue>> syncValueAccessorsByName = new(StringComparer.Ordinal);
 
         /// <summary>
-        /// The <typeparamref name="TSyncValue"/> instances associated with this sync object.
+        /// The <typeparamref name="TUnlinkedSyncValue"/> instances associated with this sync object.
         /// </summary>
-        protected readonly HashSet<TSyncValue> syncValues = [];
+        protected readonly HashSet<TLinkedSyncValue> syncValues = [];
 
         private bool _disposedValue;
 
@@ -131,7 +136,7 @@ public abstract class MonkeySyncObject<TSyncObject, TSyncValue, TLink> : IUnlink
 
         static MonkeySyncObject()
         {
-            var syncValueType = typeof(TSyncValue);
+            var syncValueType = typeof(TUnlinkedSyncValue);
             var syncValueFields = typeof(TSyncObject).GetFields(AccessTools.all)
                 .Where(field => !field.IsStatic && syncValueType.IsAssignableFrom(field.FieldType) && field.GetCustomAttribute<IgnoreSyncValueAttribute>() is null);
 
@@ -139,7 +144,7 @@ static MonkeySyncObject()
                 .Where(property => syncValueType.IsAssignableFrom(property.PropertyType) && (!(property.GetGetMethod()?.IsStatic ?? true)));
 
             foreach (var field in syncValueFields)
-                syncValueAccessorsByName.Add(field.Name, (TSyncObject instance) => (TSyncValue)field.GetValue(instance));
+                syncValueAccessorsByName.Add(field.Name, (TSyncObject instance) => (TUnlinkedSyncValue)field.GetValue(instance));
 
             foreach (var property in syncValueProperties)
             {
@@ -158,7 +163,7 @@ static MonkeySyncObject()
                 }
 
                 if (!hasIgnoreAttribute)
-                    syncValueAccessorsByName.Add(property.Name, (TSyncObject instance) => (TSyncValue)property.GetValue(instance));
+                    syncValueAccessorsByName.Add(property.Name, (TSyncObject instance) => (TUnlinkedSyncValue)property.GetValue(instance));
             }
         }
 
@@ -207,8 +212,8 @@ public bool LinkWith(TLink linkObject, bool fromRemote = false)
 
         /// <remarks><para>
         /// <i>By default:</i> Sets up the <see cref="INotifyValueChanged.Changed"/> event handlers
-        /// and calls <see cref="EstablishLinkFor(TSyncValue, string, bool)">EstablishLinkFor</see>
-        /// for every <typeparamref name="TSyncValue"/> instance field / property on <typeparamref name="TSyncObject"/>.
+        /// and calls <see cref="EstablishLinkFor">EstablishLinkFor</see>
+        /// for every <typeparamref name="TUnlinkedSyncValue"/> instance field / property on <typeparamref name="TSyncObject"/>.
         /// </para><para>
         /// The detected fields / properties are stored in <see cref="syncValueAccessorsByName">syncValueAccessorsByName</see>.
         /// </para><para>
@@ -223,14 +228,11 @@ protected virtual bool EstablishLink(bool fromRemote)
         {
             var success = true;
 
-            foreach (var syncValueProperty in syncValueAccessorsByName)
+            foreach (var syncValueAccessor in syncValueAccessorsByName)
             {
-                var syncValue = syncValueProperty.Value((TSyncObject)this);
-
-                syncValue.Changed += (sender, changedArgs)
-                    => OnPropertyChanged(syncValueProperty.Key);
+                var syncValue = syncValueAccessor.Value((TSyncObject)this);
 
-                success &= EstablishLinkFor(syncValue, syncValueProperty.Key, fromRemote);
+                success &= EstablishLinkFor(syncValue, syncValueAccessor.Key, fromRemote);
             }
 
             return success;
@@ -241,36 +243,33 @@ protected virtual bool EstablishLink(bool fromRemote)
         /// </summary>
         /// <remarks>
         /// <i>By default:</i> Adds the given sync value to the <see cref="syncValues">set of instances</see> and calls
-        /// <c><paramref name="syncValue"/>.<see cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject}.EstablishLinkFor">EstablishLinkFor</see>(…)</c>.
+        /// <c><paramref name="unlinkedSyncValue"/>.<see cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject, TLinkedSyncValue}.EstablishLinkFor">EstablishLinkFor</see>(…)</c>.<br/>
+        /// If successful, the <see cref="OnPropertyChanged"/> handler is subscribed to
+        /// the <see cref="INotifyValueChanged.Changed"/> event of the linked value as well.
         /// </remarks>
-        /// <param name="syncValue">The sync value to link.</param>
+        /// <param name="unlinkedSyncValue">The sync value to link.</param>
         /// <param name="propertyName">The name of the sync value to link.</param>
         /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
         /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
-        protected virtual bool EstablishLinkFor(TSyncValue syncValue, string propertyName, bool fromRemote)
+        protected virtual bool EstablishLinkFor(TUnlinkedSyncValue unlinkedSyncValue, string propertyName, bool fromRemote)
         {
-            syncValues.Add(syncValue);
-            return syncValue.EstablishLinkFor((TSyncObject)this, propertyName, fromRemote);
-        }
+            var linkedValue = unlinkedSyncValue.EstablishLinkFor((TSyncObject)this, propertyName, fromRemote);
 
-        /// <summary>
-        /// Creates a link for the given sync method of the given name.
-        /// </summary>
-        /// <remarks>
-        /// Any <typeparamref name="TSyncValue"/>s created for this
-        /// must be added to the <see cref="syncValues">set of instances</see>.
-        /// </remarks>
-        /// <param name="syncMethod">The sync method to link.</param>
-        /// <param name="methodName">The name of the sync method to link.</param>
-        /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
-        /// <returns><c>true</c> if the link was successfully created; otherwise, <c>false</c>.</returns>
-        protected abstract bool EstablishLinkFor(Action syncMethod, string methodName, bool fromRemote);
+            if (linkedValue is null)
+                return false;
+
+            syncValues.Add(linkedValue);
+            linkedValue.Changed += (sender, changedArgs)
+                => OnPropertyChanged(propertyName);
+
+            return true;
+        }
 
         /// <summary>
         /// Cleans up any managed resources as part of <see cref="Dispose()">disposing</see>.
         /// </summary>
         /// <remarks>
-        /// <i>By default:</i> Disposes all <typeparamref name="TSyncValue"/> instances
+        /// <i>By default:</i> Disposes all <typeparamref name="TUnlinkedSyncValue"/> instances
         /// that were added to the <see cref="syncValues">set of instances</see>,
         /// and the <see cref="LinkObject">LinkObject</see> if it's <see cref="IDisposable"/>.
         /// </remarks>
@@ -318,7 +317,7 @@ protected void OnLinkInvalidated()
         /// event with the given <paramref name="propertyName"/>.
         /// </summary>
         /// <remarks>
-        /// This is automatically called for any <typeparamref name="TSyncValue"/> fields / properties.
+        /// This is automatically called for any <typeparamref name="TUnlinkedSyncValue"/> fields / properties.
         /// </remarks>
         /// <param name="propertyName">The name of the property that changed.</param>
         protected void OnPropertyChanged(string propertyName)
@@ -329,9 +328,8 @@ protected void OnPropertyChanged(string propertyName)
         }
 
         /// <remarks><para>
-        /// <i>By default:</i> Calls <see cref="TryRestoreLinkFor(TSyncValue)">TryRestoreLinkFor</see>
-        /// for every <typeparamref name="TSyncValue"/> instance field on <typeparamref name="TSyncObject"/>.<br/>
-        /// The detected fields / properties are stored in <see cref="syncValueAccessorsByName">syncValueAccessorsByName</see>.
+        /// <i>By default:</i> Calls <see cref="TryRestoreLinkFor">TryRestoreLinkFor</see>
+        /// for every <typeparamref name="TLinkedSyncValue"/> in <see cref="syncValues"/>.
         /// </para><para>
         /// This method is called by <see cref="OnLinkInvalidated">OnLinkInvalidated</see>
         /// if <see cref="IsLinkValid">IsLinkValid</see> has become <c>false</c>.<br/>
@@ -344,8 +342,8 @@ protected virtual bool TryRestoreLink()
         {
             var success = true;
 
-            foreach (var syncValues in syncValueAccessorsByName.Values)
-                success &= TryRestoreLinkFor(syncValues((TSyncObject)this));
+            foreach (var syncValue in syncValues)
+                success &= TryRestoreLinkFor(syncValue);
 
             return success;
         }
@@ -359,7 +357,7 @@ protected virtual bool TryRestoreLink()
         /// </remarks>
         /// <param name="syncValue">The sync value to link.</param>
         /// <returns><c>true</c> if the link was successfully restored; otherwise, <c>false</c>.</returns>
-        protected virtual bool TryRestoreLinkFor(TSyncValue syncValue)
+        protected virtual bool TryRestoreLinkFor(TLinkedSyncValue syncValue)
             => syncValue.TryRestoreLink();
 
         private void Dispose(bool disposing)
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index 947a663..aa99fec 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -12,12 +12,12 @@ namespace MonkeyLoader.Sync
     /// <summary>
     /// Defines the non-generic interface for <see cref="ILinkedMonkeySyncValue{TLink, T}"/>s.
     /// </summary>
-    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, TSyncObject, T}"/>
     public interface ILinkedMonkeySyncValue<out TLink, out TSyncObject> : INotifyValueChanged, IDisposable
         where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
         /// <summary>
-        /// Gets the <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLink}.LinkObject">LinkObject</see>
+        /// Gets the <see cref="MonkeySyncObject{TSyncObject, TSyncValue, TLinkedSyncValue, TLink}.LinkObject">LinkObject</see>
         /// of the <see cref="ILinkedMonkeySyncValue{TLink, TSyncObject}.SyncObject">SyncObject</see> that this value belongs to.
         /// </summary>
         public TLink LinkObject { get; }
@@ -70,7 +70,7 @@ public interface ILinkedMonkeySyncValue<out TLink, out TSyncObject, T> : INotify
     /// <remarks>
     /// This interface exists purely to facilitate keeping a covariant list of sync values.
     /// </remarks>
-    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, TSyncObject, T}"/>
     public interface IReadOnlyMonkeySyncValue<out TLink, out TSyncObject, out T> : ILinkedMonkeySyncValue<TLink, TSyncObject>
         where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
@@ -81,11 +81,12 @@ public interface IReadOnlyMonkeySyncValue<out TLink, out TSyncObject, out T> : I
     }
 
     /// <summary>
-    /// Defines the interface for not yet linked <see cref="MonkeySyncValue{TLink, TSyncObject, T}"/>s.
+    /// Defines the interface for not yet linked <see cref="ILinkedMonkeySyncValue{TLink, TSyncObject, T}"/>s.
     /// </summary>
-    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
-    public interface IUnlinkedMonkeySyncValue<TLink, TSyncObject> : ILinkedMonkeySyncValue<TLink, TSyncObject>
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, TSyncObject, T}"/>
+    public interface IUnlinkedMonkeySyncValue<in TLink, in TSyncObject, out TLinkedSyncValue>
         where TSyncObject : ILinkedMonkeySyncObject<TLink>
+        where TLinkedSyncValue : ILinkedMonkeySyncValue<TLink, TSyncObject>
     {
         /// <summary>
         /// Establishes this sync value's association and link through the given sync object.
@@ -93,8 +94,8 @@ public interface IUnlinkedMonkeySyncValue<TLink, TSyncObject> : ILinkedMonkeySyn
         /// <param name="syncObject">The sync object that this value belongs to.</param>
         /// <param name="name">The name of this sync value.</param>
         /// <param name="fromRemote">Whether the link is being established from the remote side.</param>
-        /// <returns><c>true</c> if the established link is valid; otherwise, <c>false</c>.</returns>
-        public bool EstablishLinkFor(TSyncObject syncObject, string name, bool fromRemote);
+        /// <returns>The linked sync value if the established link is valid; otherwise, <c>null</c>.</returns>
+        public TLinkedSyncValue? EstablishLinkFor(TSyncObject syncObject, string name, bool fromRemote);
     }
 
     /// <summary>
@@ -103,7 +104,7 @@ public interface IUnlinkedMonkeySyncValue<TLink, TSyncObject> : ILinkedMonkeySyn
     /// <remarks>
     /// This interface exists purely to facilitate keeping a contravariant list of sync values.
     /// </remarks>
-    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, TSyncObject, T}"/>
     public interface IWriteOnlyMonkeySyncValue<out TLink, out TSyncObject, in T> : ILinkedMonkeySyncValue<TLink, TSyncObject>
         where TSyncObject : ILinkedMonkeySyncObject<TLink>
     {
@@ -116,9 +117,12 @@ public interface IWriteOnlyMonkeySyncValue<out TLink, out TSyncObject, in T> : I
     /// <summary>
     /// Implements an abstract base for <see cref="ILinkedMonkeySyncValue{TLink, T}"/>s.
     /// </summary>
-    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, T}"/>
-    public abstract class MonkeySyncValue<TLink, TSyncObject, T> : IUnlinkedMonkeySyncValue<TLink, TSyncObject>, ILinkedMonkeySyncValue<TLink, TSyncObject, T>
+    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, TSyncObject, T}"/>
+    public abstract class MonkeySyncValue<TLink, TSyncObject, TSyncValue, T>
+        : IUnlinkedMonkeySyncValue<TLink, TSyncObject, TSyncValue>,
+            ILinkedMonkeySyncValue<TLink, TSyncObject, T>
         where TSyncObject : class, ILinkedMonkeySyncObject<TLink>
+        where TSyncValue : MonkeySyncValue<TLink, TSyncObject, TSyncValue, T>
     {
         private static readonly Type _valueType = typeof(T);
 
@@ -180,7 +184,7 @@ public MonkeySyncValue(T value)
         /// Unwraps the <see cref="Value">Value</see> from the given sync object.
         /// </summary>
         /// <param name="syncValue">The sync object to unwrap.</param>
-        public static implicit operator T(MonkeySyncValue<TLink, TSyncObject, T> syncValue) => syncValue.Value;
+        public static implicit operator T(MonkeySyncValue<TLink, TSyncObject, TSyncValue, T> syncValue) => syncValue.Value;
 
         /// <inheritdoc/>
         public void Dispose()
@@ -196,12 +200,12 @@ public void Dispose()
         /// Then calls the <see cref="EstablishLinkInternal">internal link method</see>.
         /// </remarks>
         /// <inheritdoc/>
-        public bool EstablishLinkFor(TSyncObject syncObject, string propertyName, bool fromRemote)
+        public TSyncValue? EstablishLinkFor(TSyncObject syncObject, string propertyName, bool fromRemote)
         {
             SyncObject = syncObject;
             Name = propertyName;
 
-            return EstablishLinkInternal(fromRemote);
+            return (TSyncValue?)(EstablishLinkInternal(fromRemote) ? this : null);
         }
 
         /// <inheritdoc/>
@@ -217,7 +221,7 @@ public bool EstablishLinkFor(TSyncObject syncObject, string propertyName, bool f
         /// have already been assigned by the <see cref="EstablishLinkFor">EstablishLinkFor</see>
         /// method that calls this.
         /// </remarks>
-        /// <inheritdoc cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject}.EstablishLinkFor"/>
+        /// <inheritdoc cref="IUnlinkedMonkeySyncValue{TLink, TSyncObject, TLinkedSyncValue}.EstablishLinkFor"/>
         protected abstract bool EstablishLinkInternal(bool fromRemote);
 
         /// <summary>

From 390e365b35acb124b5e05ef1c5437f59132ab11f Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sun, 9 Mar 2025 12:26:43 +0100
Subject: [PATCH 21/22] Tweak generic signature of SyncObject

---
 MonkeyLoader/MonkeyLoader.csproj      |  2 +-
 MonkeyLoader/Sync/MonkeySyncObject.cs | 10 +++++-----
 MonkeyLoader/Sync/MonkeySyncValue.cs  |  2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/MonkeyLoader/MonkeyLoader.csproj b/MonkeyLoader/MonkeyLoader.csproj
index fe26000..c1df3f2 100644
--- a/MonkeyLoader/MonkeyLoader.csproj
+++ b/MonkeyLoader/MonkeyLoader.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>MonkeyLoader</Title>
     <Authors>Banane9</Authors>
-    <Version>0.24.13-MonkeySync-beta</Version>
+    <Version>0.24.14-MonkeySync-beta</Version>
     <Description>A convenience and extendability focused mod loader using NuGet packages.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
diff --git a/MonkeyLoader/Sync/MonkeySyncObject.cs b/MonkeyLoader/Sync/MonkeySyncObject.cs
index d921705..76418b9 100644
--- a/MonkeyLoader/Sync/MonkeySyncObject.cs
+++ b/MonkeyLoader/Sync/MonkeySyncObject.cs
@@ -22,7 +22,7 @@ public delegate IUnlinkedMonkeySyncObject<TLink> SyncObjectFactory<TLink>()
 
     /// <summary>
     /// Defines the generic interface for <see cref="MonkeySyncObject{TSyncObject,
-    /// TSyncValues, TLink}">MonkeySync objects</see> that have been linked.
+    /// TUnlinkedSyncValue, TLinkedSyncValue, TLink}">MonkeySync objects</see> that have been linked.
     /// </summary>
     /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
     public interface ILinkedMonkeySyncObject<out TLink> : IMonkeySyncObject
@@ -33,7 +33,7 @@ public interface ILinkedMonkeySyncObject<out TLink> : IMonkeySyncObject
 
     /// <summary>
     /// Defines the non-generic interface for <see cref="MonkeySyncObject{TSyncObject,
-    /// TSyncValues, TLink}">MonkeySync objects</see>.
+    /// TUnlinkedSyncValue, TLinkedSyncValue, TLink}">MonkeySync objects</see>.
     /// </summary>
     public interface IMonkeySyncObject : INotifyPropertyChanged, IDisposable
     {
@@ -57,7 +57,7 @@ public interface IMonkeySyncObject : INotifyPropertyChanged, IDisposable
 
     /// <summary>
     /// Defines the generic interface for <see cref="MonkeySyncObject{TSyncObject,
-    /// TSyncValues, TLink}">MonkeySync objects</see> that are yet to be linked.
+    /// TUnlinkedSyncValue, TLinkedSyncValue, TLink}">MonkeySync objects</see> that are yet to be linked.
     /// </summary>
     /// <inheritdoc/>
     public interface IUnlinkedMonkeySyncObject<TLink> : ILinkedMonkeySyncObject<TLink>
@@ -100,8 +100,8 @@ public interface IUnlinkedMonkeySyncObject<TLink> : ILinkedMonkeySyncObject<TLin
     /// <typeparam name="TLink">The type of the link object used by the sync object.</typeparam>
     public abstract class MonkeySyncObject<TSyncObject, TUnlinkedSyncValue, TLinkedSyncValue, TLink> : IUnlinkedMonkeySyncObject<TLink>
         where TSyncObject : MonkeySyncObject<TSyncObject, TUnlinkedSyncValue, TLinkedSyncValue, TLink>
-        where TLinkedSyncValue : ILinkedMonkeySyncValue<TLink, TSyncObject>
-        where TUnlinkedSyncValue : IUnlinkedMonkeySyncValue<TLink, TSyncObject, TLinkedSyncValue>
+        where TLinkedSyncValue : ILinkedMonkeySyncValue<TLink, ILinkedMonkeySyncObject<TLink>>
+        where TUnlinkedSyncValue : IUnlinkedMonkeySyncValue<TLink, ILinkedMonkeySyncObject<TLink>, TLinkedSyncValue>
         where TLink : class
     {
         /// <summary>
diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index aa99fec..2473263 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -51,7 +51,7 @@ public interface ILinkedMonkeySyncValue<out TLink, out TSyncObject> : INotifyVal
     }
 
     /// <summary>
-    /// Defines the generic interface for linked <see cref="MonkeySyncValue{TLink, TSyncObject, T}"/>s.
+    /// Defines the generic interface for linked <see cref="MonkeySyncValue{TLink, TSyncObject, TSyncValue, T}"/>s.
     /// </summary>
     /// <typeparam name="TLink">The type of the link object used by the sync object that this sync value links to.</typeparam>
     /// <typeparam name="TSyncObject">The type of the sync object that may contain this sync value.</typeparam>

From c7e7ce90480aa527c2aa9144ddb3e081bfaf039d Mon Sep 17 00:00:00 2001
From: Arne Kiesewetter <banane9@live.de>
Date: Sun, 9 Mar 2025 21:02:15 +0100
Subject: [PATCH 22/22] Fix typeparam docs

---
 MonkeyLoader/Sync/MonkeySyncValue.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/MonkeyLoader/Sync/MonkeySyncValue.cs b/MonkeyLoader/Sync/MonkeySyncValue.cs
index 2473263..e1d0b91 100644
--- a/MonkeyLoader/Sync/MonkeySyncValue.cs
+++ b/MonkeyLoader/Sync/MonkeySyncValue.cs
@@ -117,7 +117,10 @@ public interface IWriteOnlyMonkeySyncValue<out TLink, out TSyncObject, in T> : I
     /// <summary>
     /// Implements an abstract base for <see cref="ILinkedMonkeySyncValue{TLink, T}"/>s.
     /// </summary>
-    /// <inheritdoc cref="ILinkedMonkeySyncValue{TLink, TSyncObject, T}"/>
+    /// <typeparam name="TLink">The type of the link object used by the sync object that this sync value links to.</typeparam>
+    /// <typeparam name="TSyncObject">The type of the sync object that may contain this sync value.</typeparam>
+    /// <typeparam name="TSyncValue">The concrete type of the sync value.</typeparam>
+    /// <typeparam name="T">The type of the <see cref="ILinkedMonkeySyncValue{T, TSyncObject}.Value">Value</see>.</typeparam>
     public abstract class MonkeySyncValue<TLink, TSyncObject, TSyncValue, T>
         : IUnlinkedMonkeySyncValue<TLink, TSyncObject, TSyncValue>,
             ILinkedMonkeySyncValue<TLink, TSyncObject, T>