Reflection caching added to the various reflection classes.

Author: Michael Pham

src/NativeCode.Mobile.AppCompat.Renderers/Extensions/ElementExtensions.cs

@@ -1,7 +1,9 @@
 namespace NativeCode.Mobile.AppCompat.Renderers.Extensions
 {
     using System;
-    using System.Linq;
+    using System.Reflection;
+
+    using NativeCode.Mobile.AppCompat.Renderers.Helpers;
 
     using Xamarin.Forms;
 
@@ -10,10 +12,21 @@ namespace NativeCode.Mobile.AppCompat.Renderers.Extensions
     /// </summary>
     public static class ElementExtensions
     {
-        private const string ButtonController = "IButtonController";
+        private const string ButtonControllerType = "Xamarin.Forms.IButtonController, Xamarin.Forms.Core";
 
         private const string ButtonControllerSendClicked = "SendClicked";
 
+        private static readonly MethodInfo MethodSendClicked;
+
+        /// <summary>
+        /// Initializes static members of the <see cref="ElementExtensions"/> class.
+        /// </summary>
+        static ElementExtensions()
+        {
+            var type = Type.GetType(ButtonControllerType, true);
+            MethodSendClicked = type.GetMethod(ButtonControllerSendClicked);
+        }
+
         /// <summary>
         /// Tries to cast the element to a button controller and invoke the SendClicked method.
         /// </summary>
@@ -22,27 +35,7 @@ public static class ElementExtensions
         /// <remarks>The IButtonController is an internal interface, so we have to use reflection.</remarks>
         public static void InvokeSendClicked(this Element element)
         {
-            var type = GetImplementedInterface(element, ButtonController);
-            var method = type.GetMethod(ButtonControllerSendClicked);
-
-            if (method == null)
-            {
-                throw new MissingMethodException(type.Name, ButtonControllerSendClicked);
-            }
-
-            method.Invoke(element, new object[0]);
-        }
-
-        private static Type GetImplementedInterface(object instance, string name)
-        {
-            var type = instance.GetType().GetInterfaces().Single(x => x.Name == ButtonController);
-
-            if (type == null)
-            {
-                throw new InvalidCastException("Type does not implement interface " + name + ".");
-            }
-
-            return type;
+            MethodSendClicked.Invoke(element, ReflectionHelper.EmptyParameters);
         }
     }
 }

src/NativeCode.Mobile.AppCompat.Renderers/Extensions/EntryExtensions.cs

@@ -1,8 +1,9 @@
 namespace NativeCode.Mobile.AppCompat.Renderers.Extensions
 {
-    using System;
     using System.Reflection;
 
+    using NativeCode.Mobile.AppCompat.Renderers.Helpers;
+
     using Xamarin.Forms;
 
     /// <summary>
@@ -12,21 +13,26 @@ public static class EntryExtensions
     {
         private const string EntrySendCompleted = "SendCompleted";
 
+        private const BindingFlags InstanceNonPublic = BindingFlags.Instance | BindingFlags.NonPublic;
+
+        private static readonly MethodInfo MethodSendCompleted;
+
+        /// <summary>
+        /// Initializes static members of the <see cref="EntryExtensions"/> class.
+        /// </summary>
+        static EntryExtensions()
+        {
+            var type = typeof(Entry);
+            MethodSendCompleted = type.GetMethod(EntrySendCompleted, InstanceNonPublic);
+        }
+
         /// <summary>
         /// Invokes the send completed.
         /// </summary>
         /// <param name="entry">The entry.</param>
         public static void InvokeSendCompleted(this Entry entry)
         {
-            var type = entry.GetType();
-            var method = type.GetMethod(EntrySendCompleted, BindingFlags.Instance | BindingFlags.NonPublic);
-
-            if (method == null)
-            {
-                throw new MissingMethodException(type.Name, EntrySendCompleted);
-            }
-
-            method.Invoke(entry, new object[0]);
+            MethodSendCompleted.Invoke(entry, ReflectionHelper.EmptyParameters);
         }
     }
 }

src/NativeCode.Mobile.AppCompat.Renderers/Helpers/KeyboardHelper.cs

@@ -11,55 +11,50 @@ namespace NativeCode.Mobile.AppCompat.Renderers.Helpers
 
     internal static class KeyboardHelper
     {
-        private const string KeyboardExtensions = "Xamarin.Forms.Platform.Android.KeyboardExtensions, Xamarin.Forms.Platform.Android";
+        private const string KeyboardExtensionsType = "Xamarin.Forms.Platform.Android.KeyboardExtensions, Xamarin.Forms.Platform.Android";
 
         private const string KeyboardExtensionsToInputType = "ToInputType";
 
-        private const string KeyboardManager = "Xamarin.Forms.Platform.Android.KeyboardManager, Xamarin.Forms.Platform.Android";
+        private const string KeyboardManagerType = "Xamarin.Forms.Platform.Android.KeyboardManager, Xamarin.Forms.Platform.Android";
 
         private const string KeyboardManagerHideKeyboard = "HideKeyboard";
 
         private const string KeyboardManagerShowKeyboard = "ShowKeyboard";
 
-        private const BindingFlags StaticMethodBindingFlags = BindingFlags.NonPublic | BindingFlags.Static;
+        private const BindingFlags StaticInternalMethods = BindingFlags.NonPublic | BindingFlags.Static;
 
-        public static InputTypes GetInputType(Keyboard keyboard)
+        private static readonly MethodInfo MethodToInputType;
+
+        private static readonly MethodInfo MethodHideKeyboard;
+
+        private static readonly MethodInfo MethodShowKeyboard;
+
+        /// <summary>
+        /// Initializes static members of the <see cref="KeyboardHelper"/> class.
+        /// </summary>
+        static KeyboardHelper()
         {
-            var type = Type.GetType(KeyboardExtensions, true);
-            var method = type.GetMethod(KeyboardExtensionsToInputType);
+            var keyboardExtensionsType = Type.GetType(KeyboardExtensionsType, true);
+            MethodToInputType = keyboardExtensionsType.GetMethod(KeyboardExtensionsToInputType);
 
-            if (method == null)
-            {
-                throw new MissingMethodException(type.Name, KeyboardExtensionsToInputType);
-            }
+            var keyboardManagerType = Type.GetType(KeyboardManagerType, true);
+            MethodHideKeyboard = keyboardManagerType.GetMethod(KeyboardManagerHideKeyboard, StaticInternalMethods);
+            MethodShowKeyboard = keyboardManagerType.GetMethod(KeyboardManagerShowKeyboard, StaticInternalMethods);
+        }
 
-            return (InputTypes)method.Invoke(null, new object[] { keyboard });
+        public static InputTypes GetInputType(Keyboard keyboard)
+        {
+            return (InputTypes)MethodToInputType.Invoke(null, new object[] { keyboard });
         }
 
         public static void HideKeyboard(View view)
         {
-            var type = Type.GetType(KeyboardManager, true);
-            var method = type.GetMethod(KeyboardManagerHideKeyboard, StaticMethodBindingFlags);
-
-            if (method == null)
-            {
-                throw new MissingMethodException(type.Name, KeyboardManagerHideKeyboard);
-            }
-
-            method.Invoke(null, new object[] { view });
+            MethodHideKeyboard.Invoke(null, new object[] { view });
         }
 
         public static void ShowKeyboard(View view)
         {
-            var type = Type.GetType(KeyboardManager, true);
-            var method = type.GetMethod(KeyboardManagerShowKeyboard, StaticMethodBindingFlags);
-
-            if (method == null)
-            {
-                throw new MissingMethodException(type.Name, KeyboardManagerShowKeyboard);
-            }
-
-            method.Invoke(null, new object[] { view });
+            MethodShowKeyboard.Invoke(null, new object[] { view });
         }
     }
 }

src/NativeCode.Mobile.AppCompat.Renderers/Helpers/ReflectionHelper.cs

@@ -5,6 +5,8 @@ namespace NativeCode.Mobile.AppCompat.Renderers.Helpers
 
     internal static class ReflectionHelper
     {
+        public static readonly object[] EmptyParameters = new object[0];
+
         public static void SetFieldValue(object instance, string name, object value)
         {
             var field = instance.GetType().GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);