Use runtime JIT capability detection for built-in serializer logics.

Author: yfakariya

src/MsgPack/Serialization/CollectionSerializers/DictionaryMessagePackSerializer`3.cs

@@ -83,15 +83,36 @@ protected DictionaryMessagePackSerializer( SerializationContext ownerContext, Po
 		/// <returns>The count of the <paramref name="dictionary"/>.</returns>
 		protected override int GetCount( TDictionary dictionary )
 		{
-#if ( !UNITY ) || AOT_CHECK
+#if !NETSTANDARD2_0
 			return dictionary.Count;
-#else
+#else // NETSTANDARD2_0
+			if ( SerializerOptions.CanEmit )
+			{
+				return this.GetCountCore( dictionary );
+			}
+			else
+			{
+				return this.GetCountCoreAotSafe( dictionary );
+			}
+#endif // !NETSTANDARD2_0
+		}
+
+#if NETSTANDARD2_0
+
+		private int GetCountCore( TDictionary dictionary )
+		{
+			return dictionary.Count;
+		}
+
+		private int GetCountCoreAotSafe( TDictionary dictionary )
+		{
 			// .constraind call for TDictionary.get_Count/TDictionary.GetEnumerator() causes AOT error.
 			// So use cast and invoke as normal call (it might cause boxing, but most collection should be reference type).
 			return ( dictionary as IDictionary<TKey, TValue> ).Count;
-#endif // ( !UNITY ) || AOT_CHECK
 		}
 
+#endif // NETSTANDARD2_0
+
 		/// <summary>
 		///		Adds the deserialized item to the collection on <typeparamref name="TDictionary"/> specific manner
 		///		to implement <see cref="DictionaryMessagePackSerializerBase{TDictionary,TKey,TValue}.UnpackToCore(MsgPack.Unpacker,TDictionary)"/>.
@@ -104,14 +125,36 @@ protected override int GetCount( TDictionary dictionary )
 		/// </exception>
 		protected override void AddItem( TDictionary dictionary, TKey key, TValue value )
 		{
-#if ( !UNITY && !XAMARIN ) || AOT_CHECK
+#if !NETSTANDARD2_0
 			dictionary.Add( key, value );
-#else
+#else // !NETSTANDARD2_0
+			if ( SerializerOptions.CanEmit)
+			{
+				this.AddItemCore( dictionary, key, value );
+			}
+			else
+			{
+				this.AddItemCoreAotSafe( dictionary, key, value );
+			}
+#endif // !NETSTANDARD2_0
+		}
+
+#if NETSTANDARD2_0
+
+		private void AddItemCore( TDictionary dictionary, TKey key, TValue value )
+		{
+			dictionary.Add( key, value );
+		}
+
+		private void AddItemCoreAotSafe( TDictionary dictionary, TKey key, TValue value )
+		{
 			// .constraind call for TDictionary.Add causes AOT error.
 			// So use cast and invoke as normal call (it might cause boxing, but most collection should be reference type).
 			( dictionary as IDictionary<TKey, TValue> ).Add( key, value );
-#endif // ( !UNITY && !XAMARIN ) || AOT_CHECK
 		}
+
+#endif // NETSTANDARD2_0
+
 	}
 
 #if UNITY

src/MsgPack/Serialization/ReflectionSerializers/ReflectionSerializerHelper.cs

@@ -213,18 +213,18 @@ public static Action<object, object> GetAddItem( Type targetType, CollectionTrai
 
 			// CreateDelegate causes AOT error.
 			// So use reflection in AOT environment.
-#if !AOT || AOT_CHECK
-			try
-			{
-				return collectionTraits.AddMethod.CreateDelegate( typeof( Action<TCollection, TItem> ) ) as Action<TCollection, TItem>;
-			}
-			catch ( ArgumentException )
+#if !UNITY
+			if ( SerializerOptions.CanEmit )
 			{
-#endif // !AOT || AOT_CHECK
-				return ( collection, item ) => collectionTraits.AddMethod.InvokePreservingExceptionType( collection, item );
-#if !AOT || AOT_CHECK
+				try
+				{
+					return collectionTraits.AddMethod.CreateDelegate( typeof( Action<TCollection, TItem> ) ) as Action<TCollection, TItem>;
+				}
+				catch ( ArgumentException ) { }
 			}
-#endif // !AOT || AOT_CHECK
+#endif //! UNITY
+
+			return ( collection, item ) => collectionTraits.AddMethod.InvokePreservingExceptionType( collection, item );
 		}
 
 		public static void GetMetadata(
@@ -632,4 +632,4 @@ public MessagePackSerializer Create( SerializationContext context, Type targetTy
 		// ReSharper restore MemberHidesStaticFromOuterClass
 #endif // !UNITY
 	}
-}
+}

src/MsgPack/Serialization/SerializerOptions.cs

@@ -144,7 +144,7 @@ public bool DisableRuntimeCodeGeneration
 			}
 		}
 
-		private static bool CanEmit = DetermineCanEmit();
+		internal static readonly bool CanEmit = DetermineCanEmit();
 
 		[MethodImpl( MethodImplOptions.NoInlining )]
 		private static bool DetermineCanEmit()