added support for list and removed support for dict

Author: ajaybhargavb

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

@@ -2,14 +2,17 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using Microsoft.AspNet.Http;
 using Microsoft.AspNet.Mvc.Core;
 using Microsoft.Framework.Internal;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Bson;
+using Newtonsoft.Json.Linq;
 
 namespace Microsoft.AspNet.Mvc
 {
@@ -22,9 +25,29 @@ public class SessionStateTempDataProvider : ITempDataProvider
         private readonly JsonSerializer _jsonSerializer = JsonSerializer.Create(
             new JsonSerializerSettings()
             {
-                TypeNameHandling = TypeNameHandling.Auto
+                TypeNameHandling = TypeNameHandling.None
             });
 
+        private static readonly MethodInfo _convertArrayMethodInfo = typeof(SessionStateTempDataProvider).GetMethod(
+            nameof(ConvertArray), BindingFlags.NonPublic | BindingFlags.Static, null, new[] { typeof(JArray) }, null);
+
+        private readonly ConcurrentDictionary<Type, Func<JArray, object>> _arrayConverters =
+            new ConcurrentDictionary<Type, Func<JArray, object>>();
+
+        private static Dictionary<JTokenType, Type> _arrayTypeLookup = new Dictionary<JTokenType, Type>
+        {
+            { JTokenType.String, typeof(string) },
+            { JTokenType.Integer, typeof(int) },
+            { JTokenType.Boolean, typeof(bool) },
+            { JTokenType.Float, typeof(float) },
+            { JTokenType.Guid, typeof(Guid) },
+            { JTokenType.Object, typeof(object) },
+            { JTokenType.Date, typeof(DateTime) },
+            { JTokenType.TimeSpan, typeof(TimeSpan) },
+            { JTokenType.Uri, typeof(Uri) },
+            { JTokenType.Bytes, typeof(Byte) },
+        };
+
         /// <inheritdoc />
         public virtual IDictionary<string, object> LoadTempData([NotNull] HttpContext context)
         {
@@ -45,6 +68,26 @@ public virtual IDictionary<string, object> LoadTempData([NotNull] HttpContext co
                 {
                     tempDataDictionary = _jsonSerializer.Deserialize<Dictionary<string, object>>(writer);
                 }
+                foreach (var item in tempDataDictionary.ToList())
+                {
+                    var jArrayValue = item.Value as JArray;
+                    if (jArrayValue != null && jArrayValue.Count > 0)
+                    {
+                        Type returnType = null;
+                        _arrayTypeLookup.TryGetValue(jArrayValue[0].Type, out returnType);
+                        if (returnType != null)
+                        {
+                            var arrayConverter = _arrayConverters.GetOrAdd(returnType, type =>
+                            {
+                                return (Func<JArray, object>)Delegate.CreateDelegate(typeof(Func<JArray, object>),
+                                    _convertArrayMethodInfo.MakeGenericMethod(type));
+                            });
+                            var result = arrayConverter(jArrayValue);
+
+                            tempDataDictionary[item.Key] = result;
+                        }
+                    }
+                }
 
                 // If we got it from Session, remove it so that no other request gets it
                 session.Remove(TempDataSessionStateKey);
@@ -104,8 +147,7 @@ internal void EnsureObjectCanBeSerialized(object item)
             }
             else if (itemType.GetTypeInfo().IsGenericType)
             {
-                if (itemType.ExtractGenericInterface(typeof(IList<>)) != null ||
-                    itemType.ExtractGenericInterface(typeof(IDictionary<,>)) != null)
+                if (itemType.ExtractGenericInterface(typeof(IList<>)) != null)
                 {
                     actualTypes = itemType.GetGenericArguments();
                 }
@@ -124,5 +166,10 @@ internal void EnsureObjectCanBeSerialized(object item)
                 }
             }
         }
+
+        private static IList<TVal> ConvertArray<TVal>(JArray array)
+        {
+            return array.Values<TVal>().ToArray();
+        }
     }
 }

test/Microsoft.AspNet.Mvc.Core.Test/SessionStateTempDataProviderTest.cs

@@ -86,9 +86,11 @@ public static TheoryData<object, Type> InvalidTypes
                     { new object[3], typeof(object) },
                     { new TestItem(), typeof(TestItem) },
                     { new List<TestItem>(), typeof(TestItem) },
-                    { new Dictionary<string, TestItem>(), typeof(TestItem) },
-                    { new Dictionary<object, string>(), typeof(object) },
-                    { new Dictionary<TestItem, TestItem>(), typeof(TestItem) }
+                    { new Dictionary<string, int>(), typeof(Dictionary<string, int>) },
+                    { new Dictionary<Uri, Guid>(), typeof(Dictionary<Uri, Guid>) },
+                    { new Dictionary<string, TestItem>(), typeof(Dictionary<string, TestItem>) },
+                    { new Dictionary<object, string>(), typeof(Dictionary<object, string>) },
+                    { new Dictionary<TestItem, TestItem>(), typeof(Dictionary<TestItem, TestItem>) }
                 };
             }
         }
@@ -118,13 +120,11 @@ public static TheoryData<object> ValidTypes
                     { 10 },
                     { new int[]{ 10, 20 } },
                     { "FooValue" },
-                    { new Dictionary<string, int>() },
                     { new Uri("http://Foo") },
                     { Guid.NewGuid() },
                     { new List<string> { "foo", "bar" } },
                     { new DateTimeOffset() },
                     { 100.1m },
-                    { new Dictionary<Uri, Guid>() },
                     { new Uri[] { new Uri("http://Foo"), new Uri("http://Bar") } }
                 };
             }