Make batch requests no longer require manual encoding.

Now leverages the existing 'ParseCommand' class instead of constructing improperly typed dictionaries.

TODO: Split this into its own class.

Author: richardjrossiii

Parse/Internal/Command/ParseCommand.cs

@@ -13,6 +13,20 @@ namespace Parse.Internal {
   internal class ParseCommand : HttpRequest {
     private const string revocableSessionTokenTrueValue = "1";
 
+    public IDictionary<string, object> DataObject { get; private set; }
+    public override Stream Data {
+      get {
+        if (base.Data != null) {
+          return base.Data;
+        }
+
+        return base.Data = DataObject != null
+          ? new MemoryStream(Encoding.UTF8.GetBytes(Json.Encode(DataObject)))
+          : null;
+      }
+      internal set { base.Data = value; }
+    }
+
     public ParseCommand(string relativeUri,
         string method,
         string sessionToken = null,
@@ -21,8 +35,9 @@ public ParseCommand(string relativeUri,
             method: method,
             sessionToken: sessionToken,
             headers: headers,
-            stream: data != null ? new MemoryStream(UTF8Encoding.UTF8.GetBytes(Json.Encode(data))) : null,
+            stream: null,
             contentType: data != null ? "application/json" : null) {
+      DataObject = data;
     }
 
     public ParseCommand(string relativeUri,

Parse/Internal/HttpRequest.cs

@@ -3,9 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Net;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace Parse.Internal {
   /// <summary>
@@ -18,7 +15,7 @@ internal class HttpRequest {
     /// <summary>
     /// Data stream to be uploaded.
     /// </summary>
-    public Stream Data { get; internal set; }
+    public virtual Stream Data { get; internal set; }
 
     /// <summary>
     /// HTTP method. One of <c>DELETE</c>, <c>GET</c>, <c>HEAD</c>, <c>POST</c> or <c>PUT</c>

Parse/Internal/Object/Controller/ParseObjectController.cs

@@ -55,14 +55,15 @@ public IList<Task<IObjectState>> SaveAllAsync(IList<IObjectState> states,
         IList<IDictionary<string, IParseFieldOperation>> operationsList,
         string sessionToken,
         CancellationToken cancellationToken) {
-      var requests = states.Zip(operationsList, (item, ops) => new Dictionary<string, object> {
-        { "method", (item.ObjectId == null ? "POST" : "PUT") },
-        { "path",  (item.ObjectId == null ?
-            string.Format("/1/classes/{0}", Uri.EscapeDataString(item.ClassName)) :
-            string.Format("/1/classes/{0}/{1}", Uri.EscapeDataString(item.ClassName),
-                Uri.EscapeDataString(item.ObjectId))) },
-        { "body", ParseObject.ToJSONObjectForSaving(ops) }
-      }).Cast<object>().ToList();
+
+      var requests = states
+        .Zip(operationsList, (item, ops) => new ParseCommand(
+          item.ObjectId == null
+            ? string.Format("classes/{0}", Uri.EscapeDataString(item.ClassName))
+            : string.Format("classes/{0}/{1}", Uri.EscapeDataString(item.ClassName), Uri.EscapeDataString(item.ObjectId)),
+          method: item.ObjectId == null ? "POST" : "PUT",
+          data: ParseObject.ToJSONObjectForSaving(ops)))
+        .ToList();
 
       var batchTasks = ExecuteBatchRequests(requests, sessionToken, cancellationToken);
       var stateTasks = new List<Task<IObjectState>>();
@@ -90,24 +91,25 @@ public Task DeleteAsync(IObjectState state,
     public IList<Task> DeleteAllAsync(IList<IObjectState> states,
         string sessionToken,
         CancellationToken cancellationToken) {
-      var requests = states.Where(item => item.ObjectId != null).Select(item => new Dictionary<string, object> {
-        { "method", "DELETE" },
-        { "path", string.Format("/1/classes/{0}/{1}", Uri.EscapeDataString(item.ClassName),
-            Uri.EscapeDataString(item.ObjectId)) }
-      }).Cast<object>().ToList();
-
+      var requests = states
+        .Where(item => item.ObjectId != null)
+        .Select(item => new ParseCommand(
+          string.Format("classes/{0}/{1}", Uri.EscapeDataString(item.ClassName), Uri.EscapeDataString(item.ObjectId)),
+            method: "DELETE",
+            data: null))
+        .ToList();
       return ExecuteBatchRequests(requests, sessionToken, cancellationToken).Cast<Task>().ToList();
     }
 
     // TODO (hallucinogen): move this out to a class to be used by Analytics
     private const int MaximumBatchSize = 50;
-    internal IList<Task<IDictionary<string, object>>> ExecuteBatchRequests(IList<object> requests,
+    internal IList<Task<IDictionary<string, object>>> ExecuteBatchRequests(IList<ParseCommand> requests,
         string sessionToken,
         CancellationToken cancellationToken) {
       var tasks = new List<Task<IDictionary<string, object>>>();
       int batchSize = requests.Count;
 
-      IEnumerable<object> remaining = requests;
+      IEnumerable<ParseCommand> remaining = requests;
       while (batchSize > MaximumBatchSize) {
         var process = remaining.Take(MaximumBatchSize).ToList();
         remaining = remaining.Skip(MaximumBatchSize);
@@ -121,7 +123,7 @@ internal IList<Task<IDictionary<string, object>>> ExecuteBatchRequests(IList<obj
       return tasks;
     }
 
-    private IList<Task<IDictionary<string, object>>> ExecuteBatchRequest(IList<object> requests,
+    private IList<Task<IDictionary<string, object>>> ExecuteBatchRequest(IList<ParseCommand> requests,
         string sessionToken,
         CancellationToken cancellationToken) {
       var tasks = new List<Task<IDictionary<string, object>>>();
@@ -133,10 +135,21 @@ private IList<Task<IDictionary<string, object>>> ExecuteBatchRequest(IList<objec
         tasks.Add(tcs.Task);
       }
 
-      var command = new ParseCommand("/1/batch",
+      var encodedRequests = requests.Select(r => {
+        var results = new Dictionary<string, object> {
+          { "method", r.Method },
+          { "path", r.Uri.AbsolutePath },
+        };
+
+        if (r.DataObject != null) {
+          results["body"] = r.DataObject;
+        }
+        return results;
+      }).Cast<object>().ToList();
+      var command = new ParseCommand("batch",
         method: "POST",
         sessionToken: sessionToken,
-        data: new Dictionary<string, object> { { "requests", requests } });
+        data: new Dictionary<string, object> { { "requests", encodedRequests } });
 
       commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken).ContinueWith(t => {
         if (t.IsFaulted || t.IsCanceled) {