Make IValueProvider sync, IValueProviderFactory async

Author: rynowak

src/Microsoft.AspNet.Mvc.Abstractions/ModelBinding/IValueProvider.cs

@@ -15,13 +15,13 @@ public interface IValueProvider
         /// </summary>
         /// <param name="prefix">The prefix to search for.</param>
         /// <returns>true if the collection contains the specified prefix; otherwise, false.</returns>
-        Task<bool> ContainsPrefixAsync(string prefix);
+        bool ContainsPrefix(string prefix);
 
         /// <summary>
         /// Retrieves a value object using the specified key.
         /// </summary>
         /// <param name="key">The key of the value object to retrieve.</param>
         /// <returns>The value object for the specified key. If the exact key is not found, null.</returns>
-        Task<ValueProviderResult> GetValueAsync(string key);
+        ValueProviderResult GetValue(string key);
     }
 }

src/Microsoft.AspNet.Mvc.Abstractions/ModelBinding/IValueProviderFactory.cs

@@ -1,17 +1,20 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System.Threading.Tasks;
 using Microsoft.Framework.Internal;
 
 namespace Microsoft.AspNet.Mvc.ModelBinding
 {
     public interface IValueProviderFactory
     {
         /// <summary>
-        /// Get a value provider with values from the given <paramref name="requestContext"/>.
+        /// Gets a <see cref="IValueProvider"/> with values from the current request.
         /// </summary>
-        /// <param name="context">ValueProviderFactoryContext that value provider will populate from</param>
-        /// <returns>a value provider instance or null</returns>
-        IValueProvider GetValueProvider([NotNull] ValueProviderFactoryContext context);
+        /// <param name="context">The <see cref="ValueProviderFactoryContext"/>.</param>
+        /// <returns>
+        /// A <see cref="Task"/> that when completed will yield a <see cref="IValueProvider"/> instance or <c>null</c>.
+        /// </returns>
+        Task<IValueProvider> GetValueProviderAsync([NotNull] ValueProviderFactoryContext context);
     }
 }

src/Microsoft.AspNet.Mvc.Abstractions/ModelBinding/ValueProviderResult.cs

@@ -11,7 +11,7 @@
 namespace Microsoft.AspNet.Mvc.ModelBinding
 {
     /// <summary>
-    /// Result of an <see cref="IValueProvider.GetValueAsync(string)"/> operation.
+    /// Result of an <see cref="IValueProvider.GetValue(string)"/> operation.
     /// </summary>
     /// <remarks>
     /// <para>

src/Microsoft.AspNet.Mvc.Core/FilterActionInvoker.cs

@@ -333,7 +333,7 @@ await item.FilterAsync.OnResourceExecutionAsync(
                         ActionContext.HttpContext,
                         ActionContext.RouteData.Values);
 
-                    ActionBindingContext.ValueProvider = CompositeValueProvider.Create(
+                    ActionBindingContext.ValueProvider = await CompositeValueProvider.CreateAsync(
                         _resourceExecutingContext.ValueProviderFactories,
                         valueProviderFactoryContext);
 

src/Microsoft.AspNet.Mvc.Core/ModelBinding/BindingSourceValueProvider.cs

@@ -60,10 +60,10 @@ public BindingSourceValueProvider([NotNull] BindingSource bindingSource)
         protected BindingSource BindingSource { get; }
 
         /// <inheritdoc />
-        public abstract Task<bool> ContainsPrefixAsync(string prefix);
+        public abstract bool ContainsPrefix(string prefix);
 
         /// <inheritdoc />
-        public abstract Task<ValueProviderResult> GetValueAsync(string key);
+        public abstract ValueProviderResult GetValue(string key);
 
         /// <inheritdoc />
         public virtual IValueProvider Filter(BindingSource bindingSource)

src/Microsoft.AspNet.Mvc.Core/ModelBinding/ByteArrayModelBinder.cs

@@ -13,7 +13,12 @@ namespace Microsoft.AspNet.Mvc.ModelBinding
     public class ByteArrayModelBinder : IModelBinder
     {
         /// <inheritdoc />
-        public async Task<ModelBindingResult> BindModelAsync([NotNull] ModelBindingContext bindingContext)
+        public Task<ModelBindingResult> BindModelAsync([NotNull] ModelBindingContext bindingContext)
+        {
+            return Task.FromResult(BindModel(bindingContext));
+        }
+
+        private ModelBindingResult BindModel(ModelBindingContext bindingContext)
         {
             // Check if this binder applies.
             if (bindingContext.ModelType != typeof(byte[]))
@@ -22,7 +27,7 @@ public async Task<ModelBindingResult> BindModelAsync([NotNull] ModelBindingConte
             }
 
             // Check for missing data case 1: There was no <input ... /> element containing this data.
-            var valueProviderResult = await bindingContext.ValueProvider.GetValueAsync(bindingContext.ModelName);
+            var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
             if (valueProviderResult == ValueProviderResult.None)
             {
                 return new ModelBindingResult(model: null, key: bindingContext.ModelName, isModelSet: false);

src/Microsoft.AspNet.Mvc.Core/ModelBinding/CollectionModelBinder.cs

@@ -27,7 +27,7 @@ public virtual async Task<ModelBindingResult> BindModelAsync([NotNull] ModelBind
             ModelBindingHelper.ValidateBindingContext(bindingContext);
 
             var model = bindingContext.Model;
-            if (!await bindingContext.ValueProvider.ContainsPrefixAsync(bindingContext.ModelName))
+            if (!bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
             {
                 // If this is the fallback case and we failed to find data for a top-level model, then generate a
                 // default 'empty' model (or use existing Model) and return it.
@@ -53,7 +53,7 @@ public virtual async Task<ModelBindingResult> BindModelAsync([NotNull] ModelBind
                 return null;
             }
 
-            var valueProviderResult = await bindingContext.ValueProvider.GetValueAsync(bindingContext.ModelName);
+            var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
 
             CollectionResult result;
             if (valueProviderResult == ValueProviderResult.None)
@@ -188,7 +188,7 @@ internal async Task<CollectionResult> BindSimpleCollection(
         private async Task<CollectionResult> BindComplexCollection(ModelBindingContext bindingContext)
         {
             var indexPropertyName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, "index");
-            var valueProviderResultIndex = await bindingContext.ValueProvider.GetValueAsync(indexPropertyName);
+            var valueProviderResultIndex = bindingContext.ValueProvider.GetValue(indexPropertyName);
             var indexNames = GetIndexNamesFromValueProviderResult(valueProviderResultIndex);
 
             return await BindComplexCollectionFromIndexes(bindingContext, indexNames);

src/Microsoft.AspNet.Mvc.Core/ModelBinding/CompositeValueProvider.cs

@@ -46,14 +46,14 @@ public CompositeValueProvider(IEnumerable<IValueProvider> valueProviders)
         /// A <see cref="CompositeValueProvider"/> containing all <see cref="IValueProvider"/> instances
         /// created.
         /// </returns>
-        public static CompositeValueProvider Create(
+        public static async Task<CompositeValueProvider> CreateAsync(
             [NotNull] IEnumerable<IValueProviderFactory> factories,
             [NotNull] ValueProviderFactoryContext context)
         {
             var composite = new CompositeValueProvider();
             foreach (var valueProvidersFactory in factories)
             {
-                var valueProvider = valueProvidersFactory.GetValueProvider(context);
+                var valueProvider = await valueProvidersFactory.GetValueProviderAsync(context);
                 if (valueProvider != null)
                 {
                     composite.Add(valueProvider);
@@ -64,11 +64,11 @@ public static CompositeValueProvider Create(
         }
 
         /// <inheritdoc />
-        public virtual async Task<bool> ContainsPrefixAsync(string prefix)
+        public virtual bool ContainsPrefix(string prefix)
         {
             for (var i = 0; i < Count; i++)
             {
-                if (await this[i].ContainsPrefixAsync(prefix))
+                if (this[i].ContainsPrefix(prefix))
                 {
                     return true;
                 }
@@ -77,15 +77,15 @@ public virtual async Task<bool> ContainsPrefixAsync(string prefix)
         }
 
         /// <inheritdoc />
-        public virtual async Task<ValueProviderResult> GetValueAsync(string key)
+        public virtual ValueProviderResult GetValue(string key)
         {
             // Performance-sensitive
             // Caching the count is faster for IList<T>
             var itemCount = Items.Count;
             for (var i = 0; i < itemCount; i++)
             {
                 var valueProvider = Items[i];
-                var result = await valueProvider.GetValueAsync(key);
+                var result = valueProvider.GetValue(key);
                 if (result != ValueProviderResult.None)
                 {
                     return result;
@@ -96,14 +96,14 @@ public virtual async Task<ValueProviderResult> GetValueAsync(string key)
         }
 
         /// <inheritdoc />
-        public virtual async Task<IDictionary<string, string>> GetKeysFromPrefixAsync(string prefix)
+        public virtual IDictionary<string, string> GetKeysFromPrefix(string prefix)
         {
             foreach (var valueProvider in this)
             {
                 var enumeratedProvider = valueProvider as IEnumerableValueProvider;
                 if (enumeratedProvider != null)
                 {
-                    var result = await enumeratedProvider.GetKeysFromPrefixAsync(prefix);
+                    var result = enumeratedProvider.GetKeysFromPrefix(prefix);
                     if (result != null && result.Count > 0)
                     {
                         return result;

src/Microsoft.AspNet.Mvc.Core/ModelBinding/DictionaryBasedValueProvider.cs

@@ -44,27 +44,24 @@ protected PrefixContainer PrefixContainer
         }
 
         /// <inheritdoc />
-        public override Task<bool> ContainsPrefixAsync(string key)
+        public override bool ContainsPrefix(string key)
         {
-            return Task.FromResult(PrefixContainer.ContainsPrefix(key));
+            return PrefixContainer.ContainsPrefix(key);
         }
 
         /// <inheritdoc />
-        public override Task<ValueProviderResult> GetValueAsync([NotNull] string key)
+        public override ValueProviderResult GetValue([NotNull] string key)
         {
             object value;
-            ValueProviderResult result;
             if (_values.TryGetValue(key, out value))
             {
                 var stringValue = value as string ?? value?.ToString() ?? string.Empty;
-                result = new ValueProviderResult(stringValue, CultureInfo.InvariantCulture);
+                return new ValueProviderResult(stringValue, CultureInfo.InvariantCulture);
             }
             else
             {
-                result = ValueProviderResult.None;
+                return ValueProviderResult.None;
             }
-
-            return Task.FromResult(result);
         }
     }
 }

src/Microsoft.AspNet.Mvc.Core/ModelBinding/DictionaryModelBinder.cs

@@ -47,7 +47,7 @@ public override async Task<ModelBindingResult> BindModelAsync([NotNull] ModelBin
             }
 
             // Attempt to bind dictionary from a set of prefix[key]=value entries. Get the short and long keys first.
-            var keys = await enumerableValueProvider.GetKeysFromPrefixAsync(bindingContext.ModelName);
+            var keys = enumerableValueProvider.GetKeysFromPrefix(bindingContext.ModelName);
             if (!keys.Any())
             {
                 // No entries with the expected keys.