Merge pull request #30 from csantero/async-materializer

SphtKr · SphtKr · commit c814108bc4d0 · 2015-01-28T10:39:21.000+01:00
add async method signatures to IMaterializer
diff --git a/JSONAPI.EntityFramework.Tests/EntityConverterTests.cs b/JSONAPI.EntityFramework.Tests/EntityConverterTests.cs
@@ -2,6 +2,7 @@
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Newtonsoft.Json;
 using JSONAPI.Core;
@@ -121,7 +122,7 @@ public void SerializeTest()
 
         [TestMethod]
         [DeploymentItem(@"Data\Post.json")]
-        public void DeserializePostIntegrationTest()
+        public async Task DeserializePostIntegrationTest()
         {
             // Arrange
             JsonApiFormatter formatter = new JSONAPI.Json.JsonApiFormatter();
@@ -144,8 +145,8 @@ public void DeserializePostIntegrationTest()
 
             // Act
             Post pUpdated;
-            pUpdated = (Post)formatter.ReadFromStreamAsync(typeof(Post), stream, (System.Net.Http.HttpContent)null, (System.Net.Http.Formatting.IFormatterLogger)null).Result;
-            pUpdated = materializer.MaterializeUpdate<Post>(pUpdated);
+            pUpdated = (Post)await formatter.ReadFromStreamAsync(typeof(Post), stream, (System.Net.Http.HttpContent)null, (System.Net.Http.Formatting.IFormatterLogger)null);
+            pUpdated = await materializer.MaterializeUpdateAsync<Post>(pUpdated);
 
             // Assert
             Assert.AreEqual(a, pUpdated.Author);
@@ -156,7 +157,7 @@ public void DeserializePostIntegrationTest()
         }
 
         [TestMethod]
-        public void UnderpostingTest()
+        public async Task UnderpostingTest()
         {
             // Arrange
             JsonApiFormatter formatter = new JSONAPI.Json.JsonApiFormatter();
@@ -172,8 +173,8 @@ public void UnderpostingTest()
 
             // Act
             Post pUpdated;
-            pUpdated = (Post)formatter.ReadFromStreamAsync(typeof(Post), stream, (System.Net.Http.HttpContent)null, (System.Net.Http.Formatting.IFormatterLogger)null).Result;
-            pUpdated = materializer.MaterializeUpdate<Post>(pUpdated);
+            pUpdated = (Post)await formatter.ReadFromStreamAsync(typeof(Post), stream, (System.Net.Http.HttpContent)null, (System.Net.Http.Formatting.IFormatterLogger)null);
+            pUpdated = await materializer.MaterializeUpdateAsync<Post>(pUpdated);
 
             // Assert
             Assert.AreEqual(previousCommentsCount, pUpdated.Comments.Count, "Comments were wiped out!");
diff --git a/JSONAPI.EntityFramework/EntityFrameworkMaterializer.cs b/JSONAPI.EntityFramework/EntityFrameworkMaterializer.cs
@@ -35,7 +35,7 @@ public EntityFrameworkMaterializer(DbContext context) : base()
         /// <param name="type"></param>
         /// <param name="idValues"></param>
         /// <returns></returns>
-        public virtual object GetById(Type type, params Object[] idValues)
+        public virtual Task<object> GetByIdAsync(Type type, params Object[] idValues)
         {
             //TODO: How to react if the type isn't in the context?
 
@@ -58,20 +58,20 @@ public virtual object GetById(Type type, params Object[] idValues)
                     i++;
                 }
             }
-            return this.context.Set(type).Find(idv2);
+            return this.context.Set(type).FindAsync(idv2);
         }
 
-        public T GetById<T>(params Object[] idValues)
+        public async Task<T> GetByIdAsync<T>(params Object[] idValues)
         {
-            return (T)GetById(typeof(T), idValues);
+            return (T) await GetByIdAsync(typeof(T), idValues);
         }
 
-        public T Materialize<T>(T ephemeral)
+        public async Task<T> MaterializeAsync<T>(T ephemeral)
         {
-            return (T)Materialize(typeof(T), ephemeral);
+            return (T) await MaterializeAsync(typeof(T), ephemeral);
         }
 
-        public virtual object Materialize(Type type, object ephemeral)
+        public virtual async Task<object> MaterializeAsync(Type type, object ephemeral)
         {
             IEnumerable<string> keyNames = GetKeyNames(type);
             List<Object> idValues = new List<Object>();
@@ -90,7 +90,7 @@ public virtual object Materialize(Type type, object ephemeral)
             object retval = null;
             if (!anyNull)
             {
-                retval = context.Set(type).Find(idValues.ToArray());
+                retval = await context.Set(type).FindAsync(idValues.ToArray());
             }
             if (retval == null)
             {
@@ -101,22 +101,56 @@ public virtual object Materialize(Type type, object ephemeral)
                 {
                     // For a new object, if a key is specified, we want to merge the key, at least.
                     // For simplicity then, make the behavior equivalent to MergeMaterialize in this case.
-                    this.Merge(type, ephemeral, retval);
+                    await this.Merge(type, ephemeral, retval);
                 }
             }
             return retval;
         }
 
+        public async Task<T> MaterializeUpdateAsync<T>(T ephemeral)
+        {
+            return (T) await MaterializeUpdateAsync(typeof(T), ephemeral);
+        }
+
+        public async Task<object> MaterializeUpdateAsync(Type type, object ephemeral)
+        {
+            object material = await MaterializeAsync(type, ephemeral);
+            await this.Merge(type, ephemeral, material);
+            return material;
+        }
+
+        #endregion
+
+        #region Obsolete IMaterializer contract methods
+
+        public T GetById<T>(params object[] keyValues)
+        {
+            return GetByIdAsync<T>(keyValues).Result;
+        }
+
+        public object GetById(Type type, params object[] keyValues)
+        {
+            return GetByIdAsync(type, keyValues).Result;
+        }
+
+        public T Materialize<T>(T ephemeral)
+        {
+            return MaterializeAsync<T>(ephemeral).Result;
+        }
+
+        public object Materialize(Type type, object ephemeral)
+        {
+            return MaterializeAsync(type, ephemeral).Result;
+        }
+
         public T MaterializeUpdate<T>(T ephemeral)
         {
-            return (T)MaterializeUpdate(typeof(T), ephemeral);
+            return MaterializeUpdateAsync<T>(ephemeral).Result;
         }
 
         public object MaterializeUpdate(Type type, object ephemeral)
         {
-            object material = Materialize(type, ephemeral);
-            this.Merge(type, ephemeral, material);
-            return material;
+            return MaterializeUpdateAsync(type, ephemeral).Result;
         }
 
         #endregion
@@ -246,7 +280,7 @@ protected EntityKey MaterializeEntityKey(Type type, object obj)
             return key;
         }
 
-        private void Merge (Type type, object ephemeral, object material)
+        private async Task Merge (Type type, object ephemeral, object material)
         {
             PropertyInfo[] props = type.GetProperties();
             foreach (PropertyInfo prop in props)
@@ -286,15 +320,15 @@ private void Merge (Type type, object ephemeral, object material)
                         foreach (EntityKey key in ephemeralKeys.Except(materialKeys))
                         {
                             object[] idParams = key.EntityKeyValues.Select(ekv => ekv.Value).ToArray();
-                            object obj = GetById(elementType, idParams);
+                            object obj = await GetByIdAsync(elementType, idParams);
                             mmadd.Invoke(materialMany, new object[] { obj });
                         }
                     // Remove from hasMany
                     if (mmremove != null)
                         foreach (EntityKey key in materialKeys.Except(ephemeralKeys))
                         {
                             object[] idParams = key.EntityKeyValues.Select(ekv => ekv.Value).ToArray();
-                            object obj = GetById(elementType, idParams);
+                            object obj = await GetByIdAsync(elementType, idParams);
                             mmremove.Invoke(materialMany, new object[] { obj });
                         }
                 }
@@ -312,7 +346,7 @@ private void Merge (Type type, object ephemeral, object material)
                     if (materialKey != ephemeralKey)
                     {
                         object[] idParams = ephemeralKey.EntityKeyValues.Select(ekv => ekv.Value).ToArray();
-                        prop.SetValue(material, GetById(prop.PropertyType, idParams), null);
+                        prop.SetValue(material, await GetByIdAsync(prop.PropertyType, idParams), null);
                     }
                     // else, 
                 }
@@ -328,6 +362,5 @@ private void Merge (Type type, object ephemeral, object material)
             }
 
         }
-
     }
 }
diff --git a/JSONAPI.EntityFramework/Http/ApiController.cs b/JSONAPI.EntityFramework/Http/ApiController.cs
@@ -37,14 +37,14 @@ protected override IQueryable<T> QueryableFactory(Core.IMaterializer materialize
             return ((EntityFrameworkMaterializer)materializer).DbContext.Set<T>();
         }
 
-        public override IList<T> Post(IList<T> postedObjs)
+        public override async Task<IList<T>> Post(IList<T> postedObjs)
         {
             var materializer = this.MaterializerFactory<EntityFrameworkMaterializer>();
             List<T> materialList = new List<T>();
             foreach (T postedObj in postedObjs)
             {
                 DbContext context = materializer.DbContext;
-                var material = materializer.MaterializeUpdate(postedObj);
+                var material = await materializer.MaterializeUpdateAsync(postedObj);
                 if (context.Entry<T>(material).State == EntityState.Added)
                 {
                     context.SaveChanges();
@@ -61,28 +61,28 @@ public override IList<T> Post(IList<T> postedObjs)
             return materialList;
         }
 
-        public override IList<T> Put(string id, IList<T> putObjs)
+        public override async Task<IList<T>> Put(string id, IList<T> putObjs)
         {
             var materializer = this.MaterializerFactory<EntityFrameworkMaterializer>();
             DbContext context = materializer.DbContext;
             List<T> materialList = new List<T>();
             foreach (T putObj in putObjs)
             {
-                var material = materializer.MaterializeUpdate(putObj);
+                var material = await materializer.MaterializeUpdateAsync(putObj);
                 materialList.Add(material);
             }
             context.SaveChanges();
             return materialList;
         }
 
-        public override void Delete(string id)
+        public override async Task Delete(string id)
         {
             var materializer = this.MaterializerFactory<EntityFrameworkMaterializer>();
             DbContext context = materializer.DbContext;
-            T target = materializer.GetById<T>(id);
+            T target = await materializer.GetByIdAsync<T>(id);
             context.Set<T>().Remove(target);
             context.SaveChanges();
-            base.Delete(id);
+            await base.Delete(id);
         }
 
         protected override void Dispose(bool disposing)
diff --git a/JSONAPI/Core/IMaterializer.cs b/JSONAPI/Core/IMaterializer.cs
@@ -8,12 +8,18 @@ namespace JSONAPI.Core
 {
     public interface IMaterializer
     {
+        Task<T> GetByIdAsync<T>(params Object[] keyValues);
+        Task<object> GetByIdAsync(Type type, params Object[] keyValues);
+        Task<T> MaterializeAsync<T>(T ephemeral);
+        Task<object> MaterializeAsync(Type type, object ephemeral);
+        Task<T> MaterializeUpdateAsync<T>(T ephemeral);
+        Task<object> MaterializeUpdateAsync(Type type, object ephemeral);
 
-        T GetById<T>(params Object[] keyValues);
-        object GetById(Type type, params Object[] keyValues);
-        T Materialize<T>(T ephemeral);
-        object Materialize(Type type, object ephemeral);
-        T MaterializeUpdate<T>(T ephemeral);
-        object MaterializeUpdate(Type type, object ephemeral);
+        [Obsolete]T GetById<T>(params Object[] keyValues);
+        [Obsolete]object GetById(Type type, params Object[] keyValues);
+        [Obsolete]T Materialize<T>(T ephemeral);
+        [Obsolete]object Materialize(Type type, object ephemeral);
+        [Obsolete]T MaterializeUpdate<T>(T ephemeral);
+        [Obsolete]object MaterializeUpdate(Type type, object ephemeral);
     }
 }
diff --git a/JSONAPI/Http/ApiController.cs b/JSONAPI/Http/ApiController.cs
@@ -4,6 +4,7 @@
 using System.Text;
 using System.Net;
 using System.Net.Http;
+using System.Threading.Tasks;
 using System.Web.Http;
 using System.Reflection;
 using JSONAPI.Core;
@@ -51,7 +52,7 @@ public virtual IQueryable<T> Get()
             return es;
         }
 
-        public virtual IEnumerable<T> Get(string id)
+        public virtual async Task<IEnumerable<T>> Get(string id)
         {
             IMaterializer materializer = MaterializerFactory();
 
@@ -67,7 +68,7 @@ public virtual IEnumerable<T> Get(string id)
             }
             foreach (string singleid in arrIds)
             {
-                T hit = materializer.GetById<T>(singleid);
+                T hit = await materializer.GetByIdAsync<T>(singleid);
                 if (hit != null)
                 {
                     results.Add(hit);
@@ -85,29 +86,29 @@ public virtual IEnumerable<T> Get(string id)
         /// </summary>
         /// <param name="postedObj"></param>
         /// <returns></returns>
-        public virtual IList<T> Post([FromBody] IList<T> postedObjs)
+        public virtual Task<IList<T>> Post([FromBody] IList<T> postedObjs)
         {
             foreach(T postedObj in postedObjs)
             {
                 IMaterializer materializer = this.MaterializerFactory();
             }
-            return postedObjs;
+            return Task.FromResult(postedObjs);
         }
 
         /// <summary>
-        /// Similar to Post, this method doesn't do much. It calls MaterializeUpdate() on the
+        /// Similar to Post, this method doesn't do much. It calls MaterializeUpdateAsync() on the
         /// input and returns it. It should probably always be overridden.
         /// </summary>
         /// <param name="id"></param>
         /// <param name="payload"></param>
         /// <returns></returns>
-        public virtual IList<T> Put(string id, IList<T> putObjs)
+        public virtual async Task<IList<T>> Put(string id, IList<T> putObjs)
         {
             IMaterializer materializer = this.MaterializerFactory();
             IList<T> materialList = new List<T>();
             foreach (T putObj in putObjs)
             {
-                materialList.Add(materializer.MaterializeUpdate<T>(putObj));
+                materialList.Add(await materializer.MaterializeUpdateAsync<T>(putObj));
             }
             return materialList;
         }
@@ -116,9 +117,9 @@ public virtual IList<T> Put(string id, IList<T> putObjs)
         /// A no-op method. This should be overriden in subclasses if Delete is to be supported.
         /// </summary>
         /// <param name="id"></param>
-        public virtual void Delete(string id)
+        public virtual Task Delete(string id)
         {
-            return;
+            return Task.FromResult(0);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public EntityFrameworkMaterializer(DbContext context) : base()`
`35`	`35`	`/// <param name="type"></param>`
`36`	`36`	`/// <param name="idValues"></param>`
`37`	`37`	`/// <returns></returns>`
`38`		`- public virtual object GetById(Type type, params Object[] idValues)`
	`38`	`+ public virtual Task<object> GetByIdAsync(Type type, params Object[] idValues)`
`39`	`39`	`{`
`40`	`40`	`//TODO: How to react if the type isn't in the context?`
`41`	`41`
`@@ -58,20 +58,20 @@ public virtual object GetById(Type type, params Object[] idValues)`
`58`	`58`	`i++;`
`59`	`59`	`}`
`60`	`60`	`}`
`61`		`- return this.context.Set(type).Find(idv2);`
	`61`	`+ return this.context.Set(type).FindAsync(idv2);`
`62`	`62`	`}`
`63`	`63`
`64`		`- public T GetById<T>(params Object[] idValues)`
	`64`	`+ public async Task<T> GetByIdAsync<T>(params Object[] idValues)`
`65`	`65`	`{`
`66`		`- return (T)GetById(typeof(T), idValues);`
	`66`	`+ return (T) await GetByIdAsync(typeof(T), idValues);`
`67`	`67`	`}`
`68`	`68`
`69`		`- public T Materialize<T>(T ephemeral)`
	`69`	`+ public async Task<T> MaterializeAsync<T>(T ephemeral)`
`70`	`70`	`{`
`71`		`- return (T)Materialize(typeof(T), ephemeral);`
	`71`	`+ return (T) await MaterializeAsync(typeof(T), ephemeral);`
`72`	`72`	`}`
`73`	`73`
`74`		`- public virtual object Materialize(Type type, object ephemeral)`
	`74`	`+ public virtual async Task<object> MaterializeAsync(Type type, object ephemeral)`
`75`	`75`	`{`
`76`	`76`	`IEnumerable<string> keyNames = GetKeyNames(type);`
`77`	`77`	`List<Object> idValues = new List<Object>();`
`@@ -90,7 +90,7 @@ public virtual object Materialize(Type type, object ephemeral)`
`90`	`90`	`object retval = null;`
`91`	`91`	`if (!anyNull)`
`92`	`92`	`{`
`93`		`- retval = context.Set(type).Find(idValues.ToArray());`
	`93`	`+ retval = await context.Set(type).FindAsync(idValues.ToArray());`
`94`	`94`	`}`
`95`	`95`	`if (retval == null)`
`96`	`96`	`{`
`@@ -101,22 +101,56 @@ public virtual object Materialize(Type type, object ephemeral)`
`101`	`101`	`{`
`102`	`102`	`// For a new object, if a key is specified, we want to merge the key, at least.`
`103`	`103`	`// For simplicity then, make the behavior equivalent to MergeMaterialize in this case.`
`104`		`- this.Merge(type, ephemeral, retval);`
	`104`	`+ await this.Merge(type, ephemeral, retval);`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`	`return retval;`
`108`	`108`	`}`
`109`	`109`
	`110`	`+ public async Task<T> MaterializeUpdateAsync<T>(T ephemeral)`
	`111`	`+ {`
	`112`	`+ return (T) await MaterializeUpdateAsync(typeof(T), ephemeral);`
	`113`	`+ }`
	`114`	`+`
	`115`	`+ public async Task<object> MaterializeUpdateAsync(Type type, object ephemeral)`
	`116`	`+ {`
	`117`	`+ object material = await MaterializeAsync(type, ephemeral);`
	`118`	`+ await this.Merge(type, ephemeral, material);`
	`119`	`+ return material;`
	`120`	`+ }`
	`121`	`+`
	`122`	`+ #endregion`
	`123`	`+`
	`124`	`+ #region Obsolete IMaterializer contract methods`
	`125`	`+`
	`126`	`+ public T GetById<T>(params object[] keyValues)`
	`127`	`+ {`
	`128`	`+ return GetByIdAsync<T>(keyValues).Result;`
	`129`	`+ }`
	`130`	`+`
	`131`	`+ public object GetById(Type type, params object[] keyValues)`
	`132`	`+ {`
	`133`	`+ return GetByIdAsync(type, keyValues).Result;`
	`134`	`+ }`
	`135`	`+`
	`136`	`+ public T Materialize<T>(T ephemeral)`
	`137`	`+ {`
	`138`	`+ return MaterializeAsync<T>(ephemeral).Result;`
	`139`	`+ }`
	`140`	`+`
	`141`	`+ public object Materialize(Type type, object ephemeral)`
	`142`	`+ {`
	`143`	`+ return MaterializeAsync(type, ephemeral).Result;`
	`144`	`+ }`
	`145`	`+`
`110`	`146`	`public T MaterializeUpdate<T>(T ephemeral)`
`111`	`147`	`{`
`112`		`- return (T)MaterializeUpdate(typeof(T), ephemeral);`
	`148`	`+ return MaterializeUpdateAsync<T>(ephemeral).Result;`
`113`	`149`	`}`
`114`	`150`
`115`	`151`	`public object MaterializeUpdate(Type type, object ephemeral)`
`116`	`152`	`{`
`117`		`- object material = Materialize(type, ephemeral);`
`118`		`- this.Merge(type, ephemeral, material);`
`119`		`- return material;`
	`153`	`+ return MaterializeUpdateAsync(type, ephemeral).Result;`
`120`	`154`	`}`
`121`	`155`
`122`	`156`	`#endregion`
`@@ -246,7 +280,7 @@ protected EntityKey MaterializeEntityKey(Type type, object obj)`
`246`	`280`	`return key;`
`247`	`281`	`}`
`248`	`282`
`249`		`- private void Merge (Type type, object ephemeral, object material)`
	`283`	`+ private async Task Merge (Type type, object ephemeral, object material)`
`250`	`284`	`{`
`251`	`285`	`PropertyInfo[] props = type.GetProperties();`
`252`	`286`	`foreach (PropertyInfo prop in props)`
`@@ -286,15 +320,15 @@ private void Merge (Type type, object ephemeral, object material)`
`286`	`320`	`foreach (EntityKey key in ephemeralKeys.Except(materialKeys))`
`287`	`321`	`{`
`288`	`322`	`object[] idParams = key.EntityKeyValues.Select(ekv => ekv.Value).ToArray();`
`289`		`- object obj = GetById(elementType, idParams);`
	`323`	`+ object obj = await GetByIdAsync(elementType, idParams);`
`290`	`324`	`mmadd.Invoke(materialMany, new object[] { obj });`
`291`	`325`	`}`
`292`	`326`	`// Remove from hasMany`
`293`	`327`	`if (mmremove != null)`
`294`	`328`	`foreach (EntityKey key in materialKeys.Except(ephemeralKeys))`
`295`	`329`	`{`
`296`	`330`	`object[] idParams = key.EntityKeyValues.Select(ekv => ekv.Value).ToArray();`
`297`		`- object obj = GetById(elementType, idParams);`
	`331`	`+ object obj = await GetByIdAsync(elementType, idParams);`
`298`	`332`	`mmremove.Invoke(materialMany, new object[] { obj });`
`299`	`333`	`}`
`300`	`334`	`}`
`@@ -312,7 +346,7 @@ private void Merge (Type type, object ephemeral, object material)`
`312`	`346`	`if (materialKey != ephemeralKey)`
`313`	`347`	`{`
`314`	`348`	`object[] idParams = ephemeralKey.EntityKeyValues.Select(ekv => ekv.Value).ToArray();`
`315`		`- prop.SetValue(material, GetById(prop.PropertyType, idParams), null);`
	`349`	`+ prop.SetValue(material, await GetByIdAsync(prop.PropertyType, idParams), null);`
`316`	`350`	`}`
`317`	`351`	`// else,`
`318`	`352`	`}`
`@@ -328,6 +362,5 @@ private void Merge (Type type, object ephemeral, object material)`
`328`	`362`	`}`
`329`	`363`
`330`	`364`	`}`
`331`		`-`
`332`	`365`	`}`
`333`	`366`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,14 +37,14 @@ protected override IQueryable<T> QueryableFactory(Core.IMaterializer materialize`
`37`	`37`	`return ((EntityFrameworkMaterializer)materializer).DbContext.Set<T>();`
`38`	`38`	`}`
`39`	`39`
`40`		`- public override IList<T> Post(IList<T> postedObjs)`
	`40`	`+ public override async Task<IList<T>> Post(IList<T> postedObjs)`
`41`	`41`	`{`
`42`	`42`	`var materializer = this.MaterializerFactory<EntityFrameworkMaterializer>();`
`43`	`43`	`List<T> materialList = new List<T>();`
`44`	`44`	`foreach (T postedObj in postedObjs)`
`45`	`45`	`{`
`46`	`46`	`DbContext context = materializer.DbContext;`
`47`		`- var material = materializer.MaterializeUpdate(postedObj);`
	`47`	`+ var material = await materializer.MaterializeUpdateAsync(postedObj);`
`48`	`48`	`if (context.Entry<T>(material).State == EntityState.Added)`
`49`	`49`	`{`
`50`	`50`	`context.SaveChanges();`
`@@ -61,28 +61,28 @@ public override IList<T> Post(IList<T> postedObjs)`
`61`	`61`	`return materialList;`
`62`	`62`	`}`
`63`	`63`
`64`		`- public override IList<T> Put(string id, IList<T> putObjs)`
	`64`	`+ public override async Task<IList<T>> Put(string id, IList<T> putObjs)`
`65`	`65`	`{`
`66`	`66`	`var materializer = this.MaterializerFactory<EntityFrameworkMaterializer>();`
`67`	`67`	`DbContext context = materializer.DbContext;`
`68`	`68`	`List<T> materialList = new List<T>();`
`69`	`69`	`foreach (T putObj in putObjs)`
`70`	`70`	`{`
`71`		`- var material = materializer.MaterializeUpdate(putObj);`
	`71`	`+ var material = await materializer.MaterializeUpdateAsync(putObj);`
`72`	`72`	`materialList.Add(material);`
`73`	`73`	`}`
`74`	`74`	`context.SaveChanges();`
`75`	`75`	`return materialList;`
`76`	`76`	`}`
`77`	`77`
`78`		`- public override void Delete(string id)`
	`78`	`+ public override async Task Delete(string id)`
`79`	`79`	`{`
`80`	`80`	`var materializer = this.MaterializerFactory<EntityFrameworkMaterializer>();`
`81`	`81`	`DbContext context = materializer.DbContext;`
`82`		`- T target = materializer.GetById<T>(id);`
	`82`	`+ T target = await materializer.GetByIdAsync<T>(id);`
`83`	`83`	`context.Set<T>().Remove(target);`
`84`	`84`	`context.SaveChanges();`
`85`		`- base.Delete(id);`
	`85`	`+ await base.Delete(id);`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`protected override void Dispose(bool disposing)`
Original file line number	Diff line number	Diff line change
`@@ -8,12 +8,18 @@ namespace JSONAPI.Core`
`8`	`8`	`{`
`9`	`9`	`public interface IMaterializer`
`10`	`10`	`{`
	`11`	`+ Task<T> GetByIdAsync<T>(params Object[] keyValues);`
	`12`	`+ Task<object> GetByIdAsync(Type type, params Object[] keyValues);`
	`13`	`+ Task<T> MaterializeAsync<T>(T ephemeral);`
	`14`	`+ Task<object> MaterializeAsync(Type type, object ephemeral);`
	`15`	`+ Task<T> MaterializeUpdateAsync<T>(T ephemeral);`
	`16`	`+ Task<object> MaterializeUpdateAsync(Type type, object ephemeral);`
`11`	`17`
`12`		`- T GetById<T>(params Object[] keyValues);`
`13`		`- object GetById(Type type, params Object[] keyValues);`
`14`		`- T Materialize<T>(T ephemeral);`
`15`		`- object Materialize(Type type, object ephemeral);`
`16`		`- T MaterializeUpdate<T>(T ephemeral);`
`17`		`- object MaterializeUpdate(Type type, object ephemeral);`
	`18`	`+ [Obsolete]T GetById<T>(params Object[] keyValues);`
	`19`	`+ [Obsolete]object GetById(Type type, params Object[] keyValues);`
	`20`	`+ [Obsolete]T Materialize<T>(T ephemeral);`
	`21`	`+ [Obsolete]object Materialize(Type type, object ephemeral);`
	`22`	`+ [Obsolete]T MaterializeUpdate<T>(T ephemeral);`
	`23`	`+ [Obsolete]object MaterializeUpdate(Type type, object ephemeral);`
`18`	`24`	`}`
`19`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Text;`
`5`	`5`	`using System.Net;`
`6`	`6`	`using System.Net.Http;`
	`7`	`+using System.Threading.Tasks;`
`7`	`8`	`using System.Web.Http;`
`8`	`9`	`using System.Reflection;`
`9`	`10`	`using JSONAPI.Core;`
`@@ -51,7 +52,7 @@ public virtual IQueryable<T> Get()`
`51`	`52`	`return es;`
`52`	`53`	`}`
`53`	`54`
`54`		`- public virtual IEnumerable<T> Get(string id)`
	`55`	`+ public virtual async Task<IEnumerable<T>> Get(string id)`
`55`	`56`	`{`
`56`	`57`	`IMaterializer materializer = MaterializerFactory();`
`57`	`58`
`@@ -67,7 +68,7 @@ public virtual IEnumerable<T> Get(string id)`
`67`	`68`	`}`
`68`	`69`	`foreach (string singleid in arrIds)`
`69`	`70`	`{`
`70`		`- T hit = materializer.GetById<T>(singleid);`
	`71`	`+ T hit = await materializer.GetByIdAsync<T>(singleid);`
`71`	`72`	`if (hit != null)`
`72`	`73`	`{`
`73`	`74`	`results.Add(hit);`
`@@ -85,29 +86,29 @@ public virtual IEnumerable<T> Get(string id)`
`85`	`86`	`/// </summary>`
`86`	`87`	`/// <param name="postedObj"></param>`
`87`	`88`	`/// <returns></returns>`
`88`		`- public virtual IList<T> Post([FromBody] IList<T> postedObjs)`
	`89`	`+ public virtual Task<IList<T>> Post([FromBody] IList<T> postedObjs)`
`89`	`90`	`{`
`90`	`91`	`foreach(T postedObj in postedObjs)`
`91`	`92`	`{`
`92`	`93`	`IMaterializer materializer = this.MaterializerFactory();`
`93`	`94`	`}`
`94`		`- return postedObjs;`
	`95`	`+ return Task.FromResult(postedObjs);`
`95`	`96`	`}`
`96`	`97`
`97`	`98`	`/// <summary>`
`98`		`- /// Similar to Post, this method doesn't do much. It calls MaterializeUpdate() on the`
	`99`	`+ /// Similar to Post, this method doesn't do much. It calls MaterializeUpdateAsync() on the`
`99`	`100`	`/// input and returns it. It should probably always be overridden.`
`100`	`101`	`/// </summary>`
`101`	`102`	`/// <param name="id"></param>`
`102`	`103`	`/// <param name="payload"></param>`
`103`	`104`	`/// <returns></returns>`
`104`		`- public virtual IList<T> Put(string id, IList<T> putObjs)`
	`105`	`+ public virtual async Task<IList<T>> Put(string id, IList<T> putObjs)`
`105`	`106`	`{`
`106`	`107`	`IMaterializer materializer = this.MaterializerFactory();`
`107`	`108`	`IList<T> materialList = new List<T>();`
`108`	`109`	`foreach (T putObj in putObjs)`
`109`	`110`	`{`
`110`		`- materialList.Add(materializer.MaterializeUpdate<T>(putObj));`
	`111`	`+ materialList.Add(await materializer.MaterializeUpdateAsync<T>(putObj));`
`111`	`112`	`}`
`112`	`113`	`return materialList;`
`113`	`114`	`}`
`@@ -116,9 +117,9 @@ public virtual IList<T> Put(string id, IList<T> putObjs)`
`116`	`117`	`/// A no-op method. This should be overriden in subclasses if Delete is to be supported.`
`117`	`118`	`/// </summary>`
`118`	`119`	`/// <param name="id"></param>`
`119`		`- public virtual void Delete(string id)`
	`120`	`+ public virtual Task Delete(string id)`
`120`	`121`	`{`
`121`		`- return;`
	`122`	`+ return Task.FromResult(0);`
`122`	`123`	`}`
`123`	`124`	`}`
`124`	`125`	`}`