Tukukkk

This a Dictionary<string,string> I can attach to GameObject and that is serializable since Unity cannot serialize them by default.

I decided to leverage TypeDescriptor to be able to convert any type of convertible object instead of adding numerous overloads such as GetInt, GetFloat, GetBool, GetString.

Small drawback: it is inherently slower since TypeDescriptor uses reflection.

I decided to not implement IDictionary<TKey,TValue> for a couple of reasons:

• exposing Keys property would be confusing since values are not all string
  


• the enumerator makes little sense as well unless it returns object values


• there are many members that I will never use from it

It works as expected, simple and straightforward but improvements are welcome!

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Diagnostics.CodeAnalysis;

using System.Linq;

using JetBrains.Annotations;

using UnityEngine;



namespace ZeroAG.Scene

{

    [SuppressMessage("ReSharper", "IdentifierTypo")]

    public class PropertySet : MonoBehaviour, IPropertySet, ISerializationCallbackReceiver

    {

        internal const string DictionaryKeysProperty = nameof(_dictionaryKeys);

        internal const string DictionaryValsProperty = nameof(_dictionaryVals);



        private Dictionary<string, string> _dictionary = new Dictionary<string, string>();



        [SerializeField]

        [HideInInspector]

        private List<string> _dictionaryKeys = new List<string>();



        [SerializeField]

        [HideInInspector]

        private List<string> _dictionaryVals = new List<string>();



        #region IPropertySet Members



        public void Clear()

        {

            _dictionary.Clear();

        }



        public bool ContainsKey(string key)

        {

            if (key == null)

                throw new ArgumentNullException(nameof(key));



            return _dictionary.ContainsKey(key);

        }



        public T GetValue<T>(string key)

        {

            if (key == null)

                throw new ArgumentNullException(nameof(key));



            var converter = TypeDescriptor.GetConverter(typeof(T));



            if (!converter.CanConvertFrom(typeof(string)))

                throw new InvalidCastException($"Cannot convert from {typeof(string)} to {typeof(T)}.");



            var value = _dictionary[key];



            var o = converter.ConvertFromInvariantString(value);

            if (o is T result)

                return result;



            throw new InvalidCastException($"Converted value is not of type {typeof(T)}.");

        }



        public bool Remove(string key)

        {

            if (key == null)

                throw new ArgumentNullException(nameof(key));



            return _dictionary.Remove(key);

        }



        public void SetValue<T>(string key, T value)

        {

            if (key == null)

                throw new ArgumentNullException(nameof(key));



            if (value == null)

                throw new ArgumentNullException(nameof(value));



            var converter = TypeDescriptor.GetConverter(typeof(T));



            if (!converter.CanConvertTo(typeof(string)))

                throw new InvalidOperationException($"Cannot convert from {typeof(T)} to {typeof(string)}.");



            var result = converter.ConvertToInvariantString(value);



            AddOrUpdate(key, result);

        }



        public bool TryGetValue<T>(string key, out T result)

        {

            if (key == null)

                throw new ArgumentNullException(nameof(key));



            try

            {

                result = GetValue<T>(key);

                return true;

            }

            catch

            {

                result = default(T);

                return false;

            }

        }



        #endregion



        #region ISerializationCallbackReceiver Members



        void ISerializationCallbackReceiver.OnAfterDeserialize()

        {

            _dictionary = _dictionaryKeys.Zip(_dictionaryVals, (k, v) => new {k, v}).ToDictionary(s => s.k, s => s.v);

        }



        void ISerializationCallbackReceiver.OnBeforeSerialize()

        {

            _dictionaryKeys = _dictionary.Keys.ToList();

            _dictionaryVals = _dictionary.Values.ToList();

        }



        #endregion



        private void AddOrUpdate([NotNull] string key, string value)

        {

            if (key == null)

                throw new ArgumentNullException(nameof(key));



            if (_dictionary.ContainsKey(key))

            {

                _dictionary[key] = value;

            }

            else

            {

                _dictionary.Add(key, value);

            }

        }

    }

}