Making collection types serializable to make build green

Author: RogerKratz

Src/NHibernate.Envers.Tests/Integration/Serialization/SerializingCollectionTest.cs

@@ -47,7 +47,7 @@ public void VerifyDetached()
 			// Now serializing and de-serializing the object
 			rev1 = serializeObject(rev1);
 
-			// And checking the colleciton again
+			// And checking the collection again
 			CollectionAssert.AreEqual(new[]{ing1}, rev1.Reffering);
 		}
 

Src/NHibernate.Envers/Entities/Mapper/Relation/Lazy/Proxy/DictionaryProxy.cs

@@ -5,82 +5,140 @@
 
 namespace NHibernate.Envers.Entities.Mapper.Relation.Lazy.Proxy
 {
+	[Serializable]
 	public class DictionaryProxy<K, V> : IDictionary<K, V>
 	{
-		private readonly Lazy<IDictionary<K, V>> _delegate;
+		[NonSerialized]
+		private readonly IInitializor _initializor;
+		private IDictionary<K, V> _delegate;
 
 		public DictionaryProxy(IInitializor initializor)
 		{
-			_delegate = new Lazy<IDictionary<K, V>>(() => (IDictionary<K, V>) initializor.Initialize());
+			_initializor = initializor;
+		}
+		
+		private void checkInit()
+		{
+			if (_delegate == null)
+			{
+				_delegate = (IDictionary<K, V>) _initializor.Initialize();
+			}
 		}
 
 		public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
 		{
-			return _delegate.Value.GetEnumerator();
+			checkInit();
+			return _delegate.GetEnumerator();
 		}
 
 		IEnumerator IEnumerable.GetEnumerator()
 		{
+			checkInit();
 			return GetEnumerator();
 		}
 
 		public void Add(KeyValuePair<K, V> item)
 		{
-			_delegate.Value.Add(item);
+			checkInit();
+			_delegate.Add(item);
 		}
 
 		public void Clear()
 		{
-			_delegate.Value.Clear();
+			checkInit();
+			_delegate.Clear();
 		}
 
 		public bool Contains(KeyValuePair<K, V> item)
 		{
-			return _delegate.Value.Contains(item);
+			checkInit();
+			return _delegate.Contains(item);
 		}
 
 		public void CopyTo(KeyValuePair<K, V>[] array, int arrayIndex)
 		{
-			_delegate.Value.CopyTo(array, arrayIndex);
+			checkInit();
+			_delegate.CopyTo(array, arrayIndex);
 		}
 
 		public bool Remove(KeyValuePair<K, V> item)
 		{
-			return _delegate.Value.Remove(item);
+			checkInit();
+			return _delegate.Remove(item);
 		}
 
-		public int Count => _delegate.Value.Count;
-
-		public bool IsReadOnly => _delegate.Value.IsReadOnly;
+		public int Count
+		{
+			get
+			{
+				checkInit();
+				return _delegate.Count;
+			}
+		}
 
-		public bool ContainsKey(K key)
+		public bool IsReadOnly
 		{
-			return _delegate.Value.ContainsKey(key);
+			get
+			{
+				checkInit();
+				return _delegate.IsReadOnly;
+			}
 		}
 
 		public void Add(K key, V value)
 		{
-			_delegate.Value.Add(key, value);
+			checkInit();
+			_delegate.Add(key, value);
+		}
+
+		public bool ContainsKey(K key)
+		{
+			checkInit();
+			return _delegate.ContainsKey(key);
 		}
 
 		public bool Remove(K key)
 		{
-			return _delegate.Value.Remove(key);
+			checkInit();
+			return _delegate.Remove(key);
 		}
 
 		public bool TryGetValue(K key, out V value)
 		{
-			return _delegate.Value.TryGetValue(key, out value);
+			checkInit();
+			return _delegate.TryGetValue(key, out value);
 		}
 
 		public V this[K key]
 		{
-			get => _delegate.Value[key];
-			set => _delegate.Value[key] = value;
+			get
+			{
+				checkInit();
+				return _delegate[key];
+			}
+			set
+			{
+				checkInit();
+				_delegate[key] = value;
+			}
 		}
 
-		public ICollection<K> Keys => _delegate.Value.Keys;
+		public ICollection<K> Keys
+		{
+			get
+			{
+				checkInit();
+				return _delegate.Keys;
+			}
+		}
 
-		public ICollection<V> Values => _delegate.Value.Values;
+		public ICollection<V> Values
+		{
+			get
+			{
+				checkInit();
+				return _delegate.Values;
+			}
+		}
 	}
 }

Src/NHibernate.Envers/Entities/Mapper/Relation/Lazy/Proxy/ListProxy.cs

@@ -5,73 +5,116 @@
 
 namespace NHibernate.Envers.Entities.Mapper.Relation.Lazy.Proxy
 {
+	[Serializable]
 	public class ListProxy<T> : IList<T>
 	{
-		private readonly Lazy<IList<T>> _delegate;
+		[NonSerialized]
+		private readonly IInitializor _initializor;
+		private IList<T> _delegate;
 
 		public ListProxy(IInitializor initializor)
 		{
-			_delegate = new Lazy<IList<T>>(() => (IList<T>) initializor.Initialize());
+			_initializor = initializor;
+		}
+
+		private void checkInit()
+		{
+			if (_delegate == null)
+			{
+				_delegate = (IList<T>) _initializor.Initialize();
+			}
 		}
 
 		public IEnumerator<T> GetEnumerator()
 		{
-			return _delegate.Value.GetEnumerator();
+			checkInit();
+			return _delegate.GetEnumerator();
 		}
 
 		IEnumerator IEnumerable.GetEnumerator()
 		{
+			checkInit();
 			return GetEnumerator();
 		}
 
 		public void Add(T item)
 		{
-			_delegate.Value.Add(item);
+			checkInit();
+			_delegate.Add(item);
 		}
 
 		public void Clear()
 		{
-			_delegate.Value.Clear();
+			checkInit();
+			_delegate.Clear();
 		}
 
 		public bool Contains(T item)
 		{
-			return _delegate.Value.Contains(item);
+			checkInit();
+			return _delegate.Contains(item);
 		}
 
 		public void CopyTo(T[] array, int arrayIndex)
 		{
-			_delegate.Value.CopyTo(array, arrayIndex);
+			checkInit();
+			_delegate.CopyTo(array, arrayIndex);
 		}
 
 		public bool Remove(T item)
 		{
-			return _delegate.Value.Remove(item);
+			checkInit();
+			return _delegate.Remove(item);
 		}
 
-		public int Count => _delegate.Value.Count;
+		public int Count
+		{
+			get
+			{
+				checkInit();
+				return _delegate.Count;
+			}
+		}
 
-		public bool IsReadOnly => _delegate.Value.IsReadOnly;
+		public bool IsReadOnly
+		{
+			get
+			{
+				checkInit();
+				return _delegate.IsReadOnly;
+			}
+		}
 
 		public int IndexOf(T item)
 		{
-			return _delegate.Value.IndexOf(item);
+			checkInit();
+			return _delegate.IndexOf(item);
 		}
 
 		public void Insert(int index, T item)
 		{
-			_delegate.Value.Insert(index, item);
+			checkInit();
+			_delegate.Insert(index, item);
 		}
 
 		public void RemoveAt(int index)
 		{
-			_delegate.Value.RemoveAt(index);
+			checkInit();
+			_delegate.RemoveAt(index);
 		}
 
 		public T this[int index]
 		{
-			get => _delegate.Value[index];
-			set => _delegate.Value[index] = value;
+			get 
+			{ 				
+				checkInit();
+				return _delegate[index]; 
+			}
+			set
+			{
+				checkInit();
+				_delegate[index] = value;
+			}
 		}
 	}
 }