* AVACL.cs:

* ObjectTest.cs:
* AVObject.cs:
* AVException.cs:
* ObjectControllerTests.cs:

* AVObjectController.cs: chore: AVObject 增加符合条件删除

Storage/Storage.Test/ObjectControllerTests.cs

@@ -1,157 +0,0 @@
-using NUnit.Framework;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using System.Collections.Generic;
-using LeanCloud;
-
-namespace LeanCloud.Test {
-    public class ObjectControllerTests {
-        [SetUp]
-        public void SetUp() {
-            Utils.InitNorthChina();
-        }
-
-        [Test]
-        public async Task Save() {
-            AVObject obj = AVObject.Create("Foo");
-            obj["content"] = "hello, world";
-            obj["list"] = new List<int> { 1, 1, 2, 3, 5, 8 };
-            obj["dict"] = new Dictionary<string, int> {
-                { "hello", 1 },
-                { "world", 2 }
-            };
-            await obj.SaveAsync();
-            Assert.NotNull(obj.ObjectId);
-            Assert.NotNull(obj.CreatedAt);
-            Assert.NotNull(obj.UpdatedAt);
-        }
-
-        [Test]
-        public async Task SaveWithOptions() {
-            AVObject account = AVObject.CreateWithoutData("Account", "5d65fa5330863b008065e476");
-            account["balance"] = 100;
-            await account.SaveAsync();
-            AVQuery<AVObject> query = new AVQuery<AVObject>("Account");
-            query.WhereGreaterThan("balance", 80);
-            account["balance"] = 50;
-            await account.SaveAsync(true, query);
-            TestContext.Out.WriteLine($"balance: {account["balance"]}");
-        }
-
-        [Test]
-        public async Task SaveWithPointer() {
-            AVObject comment = new AVObject("Comment") {
-                { "content", "Hello, Comment" }
-            };
-            
-            AVObject post = new AVObject("Post") {
-                { "name", "New Post" },
-                { "category", new AVObject("Category") {
-                    { "name", "new post category" }
-                } }
-            };
-            comment["post"] = post;
-
-            AVObject testPost = new AVObject("Post") {
-                { "name", "Test Post" },
-                { "category", new AVObject("Category") {
-                    { "name", "test post category" }
-                } }
-            };
-            comment["test_post"] = testPost;
-
-            await comment.SaveAsync();
-            TestContext.Out.WriteLine(post);
-            TestContext.Out.WriteLine(testPost);
-            TestContext.Out.WriteLine(comment);
-        }
-
-        [Test]
-        public async Task SaveBatch() {
-            List<AVObject> objList = new List<AVObject>();
-            for (int i = 0; i < 5; i++) {
-                AVObject obj = AVObject.Create("Foo");
-                obj["content"] = "batch object";
-                objList.Add(obj);
-            }
-            try {
-                await objList.SaveAllAsync();
-                objList.ForEach(obj => {
-                    Assert.NotNull(obj.ObjectId);
-                });
-            } catch (Exception e) {
-                TestContext.Out.WriteLine(e.Message);
-            }
-        }
-
-        [Test]
-        public async Task Fetch() {
-            AVObject obj = AVObject.CreateWithoutData("Todo", "5d5f6039d5de2b006cf29c8f");
-            await obj.FetchAsync();
-            Assert.NotNull(obj["title"]);
-            Assert.NotNull(obj["content"]);
-            TestContext.Out.WriteLine($"{obj["title"]}, {obj["content"]}");
-        }
-
-        [Test]
-        public async Task FetchWithKeys() {
-            AVObject obj = AVObject.CreateWithoutData("Post", "5d3abfa530863b0068e1b326");
-            await obj.FetchAsync(new List<string> { "pubUser" });
-            TestContext.Out.WriteLine($"{obj["pubUser"]}");
-        }
-
-        [Test]
-        public async Task FetchWithIncludes() {
-            AVObject obj = AVObject.CreateWithoutData("Post", "5d3abfa530863b0068e1b326");
-            await obj.FetchAsync(includes: new List<string> { "tag" });
-            AVObject tag = obj["tag"] as AVObject;
-            TestContext.Out.WriteLine($"{tag["name"]}");
-        }
-
-        [Test]
-        public async Task FetchAll() {
-            List<AVObject> objList = new List<AVObject> {
-                AVObject.CreateWithoutData("Tag", "5d64e5ebc05a8000730340ba"),
-                AVObject.CreateWithoutData("Tag", "5d64e5eb12215f0073db271c"),
-                AVObject.CreateWithoutData("Tag", "5d64e57f43e78c0068a14315")
-            };
-            await objList.FetchAllAsync();
-            objList.ForEach(obj => {
-                Assert.NotNull(obj.ObjectId);
-                TestContext.Out.WriteLine($"{obj.ObjectId}, {obj["name"]}");
-            });
-        }
-
-        [Test]
-        public async Task Delete() {
-            AVObject obj = AVObject.Create("Foo");
-            obj["content"] = "hello, world";
-            await obj.SaveAsync();
-            Assert.NotNull(obj);
-            await obj.DeleteAsync();
-        }
-
-        [Test]
-        public async Task DeleteAll() {
-            List<AVObject> objList = new List<AVObject>();
-            for (int i = 0; i < 5; i++) {
-                AVObject obj = AVObject.Create("Foo");
-                obj["content"] = "batch object";
-                objList.Add(obj);
-            }
-            await objList.SaveAllAsync();
-            await AVObject.DeleteAllAsync(objList);
-        }
-
-        [Test]
-        public async Task Set() {
-            AVObject obj = AVObject.Create("Foo");
-            obj["hello"] = "world";
-            await obj.SaveAsync();
-            obj["world"] = "aaa";
-            obj.Revert();
-            TestContext.Out.WriteAsync(obj["hello"] as string);
-        }
-    }
-}

Storage/Storage.Test/ObjectTest.cs

@@ -1,7 +1,8 @@
 using NUnit.Framework;
-using LeanCloud;
+using System;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Collections.Generic;
 
 namespace LeanCloud.Test {
     public class ObjectTests {
@@ -11,22 +12,166 @@ namespace LeanCloud.Test {
         }
 
         [Test]
-        public void TestAVObjectConstructor() {
-            AVObject obj = new AVObject("Foo");
-            Assert.AreEqual("Foo", obj.ClassName);
-            Assert.Null(obj.CreatedAt);
-            Assert.True(obj.IsDataAvailable);
-            Assert.True(obj.IsDirty);
+        public async Task Save() {
+            AVObject obj = AVObject.Create("Foo");
+            obj["content"] = "hello, world";
+            obj["list"] = new List<int> { 1, 1, 2, 3, 5, 8 };
+            obj["dict"] = new Dictionary<string, int> {
+                { "hello", 1 },
+                { "world", 2 }
+            };
+            await obj.SaveAsync();
+            Assert.NotNull(obj.ObjectId);
+            Assert.NotNull(obj.CreatedAt);
+            Assert.NotNull(obj.UpdatedAt);
         }
 
         [Test]
-        public void TestAVObjectCreate() {
-            AVObject obj = AVObject.CreateWithoutData("Foo", "5d356b1cd5de2b00837162ca");
-            Assert.AreEqual("Foo", obj.ClassName);
-            Assert.AreEqual("5d356b1cd5de2b00837162ca", obj.ObjectId);
-            Assert.Null(obj.CreatedAt);
-            Assert.False(obj.IsDataAvailable);
-            Assert.False(obj.IsDirty);
+        public async Task SaveWithOptions() {
+            AVObject account = AVObject.CreateWithoutData("Account", "5d65fa5330863b008065e476");
+            account["balance"] = 100;
+            await account.SaveAsync();
+            AVQuery<AVObject> query = new AVQuery<AVObject>("Account");
+            query.WhereGreaterThan("balance", 80);
+            account["balance"] = 50;
+            await account.SaveAsync(true, query);
+            TestContext.Out.WriteLine($"balance: {account["balance"]}");
+        }
+
+        [Test]
+        public async Task SaveWithPointer() {
+            AVObject comment = new AVObject("Comment") {
+                { "content", "Hello, Comment" }
+            };
+
+            AVObject post = new AVObject("Post") {
+                { "name", "New Post" },
+                { "category", new AVObject("Category") {
+                    { "name", "new post category" }
+                } }
+            };
+            comment["post"] = post;
+
+            AVObject testPost = new AVObject("Post") {
+                { "name", "Test Post" },
+                { "category", new AVObject("Category") {
+                    { "name", "test post category" }
+                } }
+            };
+            comment["test_post"] = testPost;
+
+            await comment.SaveAsync();
+            TestContext.Out.WriteLine(post);
+            TestContext.Out.WriteLine(testPost);
+            TestContext.Out.WriteLine(comment);
+        }
+
+        [Test]
+        public async Task SaveBatch() {
+            List<AVObject> objList = new List<AVObject>();
+            for (int i = 0; i < 5; i++) {
+                AVObject obj = AVObject.Create("Foo");
+                obj["content"] = "batch object";
+                objList.Add(obj);
+            }
+            try {
+                await objList.SaveAllAsync();
+                objList.ForEach(obj => {
+                    Assert.NotNull(obj.ObjectId);
+                });
+            } catch (Exception e) {
+                TestContext.Out.WriteLine(e.Message);
+            }
+        }
+
+        [Test]
+        public async Task Fetch() {
+            AVObject obj = AVObject.CreateWithoutData("Todo", "5d5f6039d5de2b006cf29c8f");
+            await obj.FetchAsync();
+            Assert.NotNull(obj["title"]);
+            Assert.NotNull(obj["content"]);
+            TestContext.Out.WriteLine($"{obj["title"]}, {obj["content"]}");
+        }
+
+        [Test]
+        public async Task FetchWithKeys() {
+            AVObject obj = AVObject.CreateWithoutData("Post", "5d3abfa530863b0068e1b326");
+            await obj.FetchAsync(new List<string> { "pubUser" });
+            TestContext.Out.WriteLine($"{obj["pubUser"]}");
+        }
+
+        [Test]
+        public async Task FetchWithIncludes() {
+            AVObject obj = AVObject.CreateWithoutData("Post", "5d3abfa530863b0068e1b326");
+            await obj.FetchAsync(includes: new List<string> { "tag" });
+            AVObject tag = obj["tag"] as AVObject;
+            TestContext.Out.WriteLine($"{tag["name"]}");
+        }
+
+        [Test]
+        public async Task FetchAll() {
+            List<AVObject> objList = new List<AVObject> {
+                AVObject.CreateWithoutData("Tag", "5d64e5ebc05a8000730340ba"),
+                AVObject.CreateWithoutData("Tag", "5d64e5eb12215f0073db271c"),
+                AVObject.CreateWithoutData("Tag", "5d64e57f43e78c0068a14315")
+            };
+            await objList.FetchAllAsync();
+            objList.ForEach(obj => {
+                Assert.NotNull(obj.ObjectId);
+                TestContext.Out.WriteLine($"{obj.ObjectId}, {obj["name"]}");
+            });
+        }
+
+        [Test]
+        public async Task Delete() {
+            AVObject obj = AVObject.Create("Foo");
+            obj["content"] = "hello, world";
+            await obj.SaveAsync();
+            Assert.NotNull(obj);
+            await obj.DeleteAsync();
+        }
+
+        [Test]
+        public async Task DeleteWithCondition() {
+            AVObject account = new AVObject("Account") {
+                { "balance", 100 },
+            };
+            account.ACL = new AVACL {
+                PublicWriteAccess = true,
+                PublicReadAccess = true
+            };
+            await account.SaveAsync();
+            AVQuery<AVObject> condition = new AVQuery<AVObject>();
+            condition.WhereGreaterThan("balance", 10);
+            await account.DeleteAsync(condition);
+
+            account = new AVObject("Account") {
+                { "balance", 8 },
+            };
+            account.ACL = new AVACL {
+                PublicWriteAccess = true,
+                PublicReadAccess = true
+            };
+            await account.SaveAsync();
+            condition = new AVQuery<AVObject>();
+            condition.WhereGreaterThan("balance", 10);
+            try {
+                await account.DeleteAsync(condition);
+            } catch (AVException e) {
+                Assert.AreEqual(e.Code, AVException.ErrorCode.NoEffectOnUpdatingOrDeleting);
+            }
+        }
+
+        [Test]
+        public async Task DeleteAll() {
+            List<AVObject> objList = new List<AVObject>();
+            for (int i = 0; i < 5; i++) {
+                AVObject obj = AVObject.Create("Foo");
+                obj["content"] = "batch object";
+                objList.Add(obj);
+            }
+            await objList.SaveAllAsync();
+            await AVObject.DeleteAllAsync(objList);
         }
 
         [Test]

Storage/Storage/Internal/Object/Controller/AVObjectController.cs

@@ -74,12 +74,17 @@ namespace LeanCloud.Storage.Internal {
             return stateTasks;
         }
 
-        public async Task DeleteAsync(IObjectState state,
-            CancellationToken cancellationToken) {
+        public async Task DeleteAsync(IObjectState state, AVQuery<AVObject> query, CancellationToken cancellationToken) {
             var command = new AVCommand {
                 Path = $"classes/{state.ClassName}/{state.ObjectId}",
                 Method = HttpMethod.Delete
             };
+            if (query != null) {
+                Dictionary<string, object> where = new Dictionary<string, object> {
+                    { "where", query.BuildWhere() }
+                };
+                command.Path = $"{command.Path}?{AVClient.BuildQueryString(where)}";
+            }
             await AVPlugins.Instance.CommandRunner.RunCommandAsync<IDictionary<string, object>>(command, cancellationToken);
         }
 

Storage/Storage/Public/AVACL.cs

@@ -12,273 +12,273 @@ namespace LeanCloud {
     /// set of users could write to that object.
     /// </summary>
     public class AVACL : IJsonConvertible {
-    private enum AccessKind {
-      Read,
-      Write
-    }
-    private const string publicName = "*";
-    private readonly ICollection<string> readers = new HashSet<string>();
-    private readonly ICollection<string> writers = new HashSet<string>();
-
-    internal AVACL(IDictionary<string, object> jsonObject) {
-      readers = new HashSet<string>(from pair in jsonObject
-                                    where ((IDictionary<string, object>)pair.Value).ContainsKey("read")
-                                    select pair.Key);
-      writers = new HashSet<string>(from pair in jsonObject
-                                    where ((IDictionary<string, object>)pair.Value).ContainsKey("write")
-                                    select pair.Key);
-    }
-
-    /// <summary>
-    /// Creates an ACL with no permissions granted.
-    /// </summary>
-    public AVACL() {
-    }
-
-    /// <summary>
-    /// Creates an ACL where only the provided user has access.
-    /// </summary>
-    /// <param name="owner">The only user that can read or write objects governed by this ACL.</param>
-    public AVACL(AVUser owner) {
-      SetReadAccess(owner, true);
-      SetWriteAccess(owner, true);
-    }
-
-    IDictionary<string, object> IJsonConvertible.ToJSON() {
-      var result = new Dictionary<string, object>();
-      foreach (var user in readers.Union(writers)) {
-        var userPermissions = new Dictionary<string, object>();
-        if (readers.Contains(user)) {
-          userPermissions["read"] = true;
+        private enum AccessKind {
+            Read,
+            Write
         }
-        if (writers.Contains(user)) {
-          userPermissions["write"] = true;
+        private const string publicName = "*";
+        private readonly ICollection<string> readers = new HashSet<string>();
+        private readonly ICollection<string> writers = new HashSet<string>();
+
+        internal AVACL(IDictionary<string, object> jsonObject) {
+            readers = new HashSet<string>(from pair in jsonObject
+                                          where ((IDictionary<string, object>)pair.Value).ContainsKey("read")
+                                          select pair.Key);
+            writers = new HashSet<string>(from pair in jsonObject
+                                          where ((IDictionary<string, object>)pair.Value).ContainsKey("write")
+                                          select pair.Key);
         }
-        result[user] = userPermissions;
-      }
-      return result;
-    }
 
-    private void SetAccess(AccessKind kind, string userId, bool allowed) {
-      if (userId == null) {
-        throw new ArgumentException("Cannot set access for an unsaved user or role.");
-      }
-      ICollection<string> target = null;
-      switch (kind) {
-        case AccessKind.Read:
-          target = readers;
-          break;
-        case AccessKind.Write:
-          target = writers;
-          break;
-        default:
-          throw new NotImplementedException("Unknown AccessKind");
-      }
-      if (allowed) {
-        target.Add(userId);
-      } else {
-        target.Remove(userId);
-      }
-    }
+        /// <summary>
+        /// Creates an ACL with no permissions granted.
+        /// </summary>
+        public AVACL() {
+        }
 
-    private bool GetAccess(AccessKind kind, string userId) {
-      if (userId == null) {
-        throw new ArgumentException("Cannot get access for an unsaved user or role.");
-      }
-      switch (kind) {
-        case AccessKind.Read:
-          return readers.Contains(userId);
-        case AccessKind.Write:
-          return writers.Contains(userId);
-        default:
-          throw new NotImplementedException("Unknown AccessKind");
-      }
-    }
+        /// <summary>
+        /// Creates an ACL where only the provided user has access.
+        /// </summary>
+        /// <param name="owner">The only user that can read or write objects governed by this ACL.</param>
+        public AVACL(AVUser owner) {
+            SetReadAccess(owner, true);
+            SetWriteAccess(owner, true);
+        }
 
-    /// <summary>
-    /// Gets or sets whether the public is allowed to read this object.
-    /// </summary>
-    public bool PublicReadAccess {
-      get {
-        return GetAccess(AccessKind.Read, publicName);
-      }
-      set {
-        SetAccess(AccessKind.Read, publicName, value);
-      }
-    }
+        IDictionary<string, object> IJsonConvertible.ToJSON() {
+            var result = new Dictionary<string, object>();
+            foreach (var user in readers.Union(writers)) {
+                var userPermissions = new Dictionary<string, object>();
+                if (readers.Contains(user)) {
+                    userPermissions["read"] = true;
+                }
+                if (writers.Contains(user)) {
+                    userPermissions["write"] = true;
+                }
+                result[user] = userPermissions;
+            }
+            return result;
+        }
 
-    /// <summary>
-    /// Gets or sets whether the public is allowed to write this object.
-    /// </summary>
-    public bool PublicWriteAccess {
-      get {
-        return GetAccess(AccessKind.Write, publicName);
-      }
-      set {
-        SetAccess(AccessKind.Write, publicName, value);
-      }
-    }
+        private void SetAccess(AccessKind kind, string userId, bool allowed) {
+            if (userId == null) {
+                throw new ArgumentException("Cannot set access for an unsaved user or role.");
+            }
+            ICollection<string> target = null;
+            switch (kind) {
+                case AccessKind.Read:
+                    target = readers;
+                    break;
+                case AccessKind.Write:
+                    target = writers;
+                    break;
+                default:
+                    throw new NotImplementedException("Unknown AccessKind");
+            }
+            if (allowed) {
+                target.Add(userId);
+            } else {
+                target.Remove(userId);
+            }
+        }
 
-    /// <summary>
-    /// Sets whether the given user id is allowed to read this object.
-    /// </summary>
-    /// <param name="userId">The objectId of the user.</param>
-    /// <param name="allowed">Whether the user has permission.</param>
-    public void SetReadAccess(string userId, bool allowed) {
-      SetAccess(AccessKind.Read, userId, allowed);
-    }
+        private bool GetAccess(AccessKind kind, string userId) {
+            if (userId == null) {
+                throw new ArgumentException("Cannot get access for an unsaved user or role.");
+            }
+            switch (kind) {
+                case AccessKind.Read:
+                    return readers.Contains(userId);
+                case AccessKind.Write:
+                    return writers.Contains(userId);
+                default:
+                    throw new NotImplementedException("Unknown AccessKind");
+            }
+        }
 
-    /// <summary>
-    /// Sets whether the given user is allowed to read this object.
-    /// </summary>
-    /// <param name="user">The user.</param>
-    /// <param name="allowed">Whether the user has permission.</param>
-    public void SetReadAccess(AVUser user, bool allowed) {
-      SetReadAccess(user.ObjectId, allowed);
-    }
+        /// <summary>
+        /// Gets or sets whether the public is allowed to read this object.
+        /// </summary>
+        public bool PublicReadAccess {
+            get {
+                return GetAccess(AccessKind.Read, publicName);
+            }
+            set {
+                SetAccess(AccessKind.Read, publicName, value);
+            }
+        }
 
-    /// <summary>
-    /// Sets whether the given user id is allowed to write this object.
-    /// </summary>
-    /// <param name="userId">The objectId of the user.</param>
-    /// <param name="allowed">Whether the user has permission.</param>
-    public void SetWriteAccess(string userId, bool allowed) {
-      SetAccess(AccessKind.Write, userId, allowed);
-    }
+        /// <summary>
+        /// Gets or sets whether the public is allowed to write this object.
+        /// </summary>
+        public bool PublicWriteAccess {
+            get {
+                return GetAccess(AccessKind.Write, publicName);
+            }
+            set {
+                SetAccess(AccessKind.Write, publicName, value);
+            }
+        }
 
-    /// <summary>
-    /// Sets whether the given user is allowed to write this object.
-    /// </summary>
-    /// <param name="user">The user.</param>
-    /// <param name="allowed">Whether the user has permission.</param>
-    public void SetWriteAccess(AVUser user, bool allowed) {
-      SetWriteAccess(user.ObjectId, allowed);
-    }
+        /// <summary>
+        /// Sets whether the given user id is allowed to read this object.
+        /// </summary>
+        /// <param name="userId">The objectId of the user.</param>
+        /// <param name="allowed">Whether the user has permission.</param>
+        public void SetReadAccess(string userId, bool allowed) {
+            SetAccess(AccessKind.Read, userId, allowed);
+        }
 
-    /// <summary>
-    /// Gets whether the given user id is *explicitly* allowed to read this object.
-    /// Even if this returns false, the user may still be able to read it if
-    /// PublicReadAccess is true or a role that the user belongs to has read access.
-    /// </summary>
-    /// <param name="userId">The user objectId to check.</param>
-    /// <returns>Whether the user has access.</returns>
-    public bool GetReadAccess(string userId) {
-      return GetAccess(AccessKind.Read, userId);
-    }
+        /// <summary>
+        /// Sets whether the given user is allowed to read this object.
+        /// </summary>
+        /// <param name="user">The user.</param>
+        /// <param name="allowed">Whether the user has permission.</param>
+        public void SetReadAccess(AVUser user, bool allowed) {
+            SetReadAccess(user.ObjectId, allowed);
+        }
 
-    /// <summary>
-    /// Gets whether the given user is *explicitly* allowed to read this object.
-    /// Even if this returns false, the user may still be able to read it if
-    /// PublicReadAccess is true or a role that the user belongs to has read access.
-    /// </summary>
-    /// <param name="user">The user to check.</param>
-    /// <returns>Whether the user has access.</returns>
-    public bool GetReadAccess(AVUser user) {
-      return GetReadAccess(user.ObjectId);
-    }
+        /// <summary>
+        /// Sets whether the given user id is allowed to write this object.
+        /// </summary>
+        /// <param name="userId">The objectId of the user.</param>
+        /// <param name="allowed">Whether the user has permission.</param>
+        public void SetWriteAccess(string userId, bool allowed) {
+            SetAccess(AccessKind.Write, userId, allowed);
+        }
 
-    /// <summary>
-    /// Gets whether the given user id is *explicitly* allowed to write this object.
-    /// Even if this returns false, the user may still be able to write it if
-    /// PublicReadAccess is true or a role that the user belongs to has write access.
-    /// </summary>
-    /// <param name="userId">The user objectId to check.</param>
-    /// <returns>Whether the user has access.</returns>
-    public bool GetWriteAccess(string userId) {
-      return GetAccess(AccessKind.Write, userId);
-    }
+        /// <summary>
+        /// Sets whether the given user is allowed to write this object.
+        /// </summary>
+        /// <param name="user">The user.</param>
+        /// <param name="allowed">Whether the user has permission.</param>
+        public void SetWriteAccess(AVUser user, bool allowed) {
+            SetWriteAccess(user.ObjectId, allowed);
+        }
 
-    /// <summary>
-    /// Gets whether the given user is *explicitly* allowed to write this object.
-    /// Even if this returns false, the user may still be able to write it if
-    /// PublicReadAccess is true or a role that the user belongs to has write access.
-    /// </summary>
-    /// <param name="user">The user to check.</param>
-    /// <returns>Whether the user has access.</returns>
-    public bool GetWriteAccess(AVUser user) {
-      return GetWriteAccess(user.ObjectId);
-    }
+        /// <summary>
+        /// Gets whether the given user id is *explicitly* allowed to read this object.
+        /// Even if this returns false, the user may still be able to read it if
+        /// PublicReadAccess is true or a role that the user belongs to has read access.
+        /// </summary>
+        /// <param name="userId">The user objectId to check.</param>
+        /// <returns>Whether the user has access.</returns>
+        public bool GetReadAccess(string userId) {
+            return GetAccess(AccessKind.Read, userId);
+        }
 
-    /// <summary>
-    /// Sets whether users belonging to the role with the given <paramref name="roleName"/>
-    /// are allowed to read this object.
-    /// </summary>
-    /// <param name="roleName">The name of the role.</param>
-    /// <param name="allowed">Whether the role has access.</param>
-    public void SetRoleReadAccess(string roleName, bool allowed) {
-      SetAccess(AccessKind.Read, "role:" + roleName, allowed);
-    }
+        /// <summary>
+        /// Gets whether the given user is *explicitly* allowed to read this object.
+        /// Even if this returns false, the user may still be able to read it if
+        /// PublicReadAccess is true or a role that the user belongs to has read access.
+        /// </summary>
+        /// <param name="user">The user to check.</param>
+        /// <returns>Whether the user has access.</returns>
+        public bool GetReadAccess(AVUser user) {
+            return GetReadAccess(user.ObjectId);
+        }
 
-    /// <summary>
-    /// Sets whether users belonging to the given role are allowed to read this object.
-    /// </summary>
-    /// <param name="role">The role.</param>
-    /// <param name="allowed">Whether the role has access.</param>
-    public void SetRoleReadAccess(AVRole role, bool allowed) {
-      SetRoleReadAccess(role.Name, allowed);
-    }
+        /// <summary>
+        /// Gets whether the given user id is *explicitly* allowed to write this object.
+        /// Even if this returns false, the user may still be able to write it if
+        /// PublicReadAccess is true or a role that the user belongs to has write access.
+        /// </summary>
+        /// <param name="userId">The user objectId to check.</param>
+        /// <returns>Whether the user has access.</returns>
+        public bool GetWriteAccess(string userId) {
+            return GetAccess(AccessKind.Write, userId);
+        }
 
-    /// <summary>
-    /// Gets whether users belonging to the role with the given <paramref name="roleName"/>
-    /// are allowed to read this object. Even if this returns false, the role may still be
-    /// able to read it if a parent role has read access.
-    /// </summary>
-    /// <param name="roleName">The name of the role.</param>
-    /// <returns>Whether the role has access.</returns>
-    public bool GetRoleReadAccess(string roleName) {
-      return GetAccess(AccessKind.Read, "role:" + roleName);
-    }
+        /// <summary>
+        /// Gets whether the given user is *explicitly* allowed to write this object.
+        /// Even if this returns false, the user may still be able to write it if
+        /// PublicReadAccess is true or a role that the user belongs to has write access.
+        /// </summary>
+        /// <param name="user">The user to check.</param>
+        /// <returns>Whether the user has access.</returns>
+        public bool GetWriteAccess(AVUser user) {
+            return GetWriteAccess(user.ObjectId);
+        }
 
-    /// <summary>
-    /// Gets whether users belonging to the role are allowed to read this object.
-    /// Even if this returns false, the role may still be able to read it if a
-    /// parent role has read access.
-    /// </summary>
-    /// <param name="role">The name of the role.</param>
-    /// <returns>Whether the role has access.</returns>
-    public bool GetRoleReadAccess(AVRole role) {
-      return GetRoleReadAccess(role.Name);
-    }
+        /// <summary>
+        /// Sets whether users belonging to the role with the given <paramref name="roleName"/>
+        /// are allowed to read this object.
+        /// </summary>
+        /// <param name="roleName">The name of the role.</param>
+        /// <param name="allowed">Whether the role has access.</param>
+        public void SetRoleReadAccess(string roleName, bool allowed) {
+            SetAccess(AccessKind.Read, "role:" + roleName, allowed);
+        }
 
-    /// <summary>
-    /// Sets whether users belonging to the role with the given <paramref name="roleName"/>
-    /// are allowed to write this object.
-    /// </summary>
-    /// <param name="roleName">The name of the role.</param>
-    /// <param name="allowed">Whether the role has access.</param>
-    public void SetRoleWriteAccess(string roleName, bool allowed) {
-      SetAccess(AccessKind.Write, "role:" + roleName, allowed);
-    }
+        /// <summary>
+        /// Sets whether users belonging to the given role are allowed to read this object.
+        /// </summary>
+        /// <param name="role">The role.</param>
+        /// <param name="allowed">Whether the role has access.</param>
+        public void SetRoleReadAccess(AVRole role, bool allowed) {
+            SetRoleReadAccess(role.Name, allowed);
+        }
 
-    /// <summary>
-    /// Sets whether users belonging to the given role are allowed to write this object.
-    /// </summary>
-    /// <param name="role">The role.</param>
-    /// <param name="allowed">Whether the role has access.</param>
-    public void SetRoleWriteAccess(AVRole role, bool allowed) {
-      SetRoleWriteAccess(role.Name, allowed);
-    }
+        /// <summary>
+        /// Gets whether users belonging to the role with the given <paramref name="roleName"/>
+        /// are allowed to read this object. Even if this returns false, the role may still be
+        /// able to read it if a parent role has read access.
+        /// </summary>
+        /// <param name="roleName">The name of the role.</param>
+        /// <returns>Whether the role has access.</returns>
+        public bool GetRoleReadAccess(string roleName) {
+            return GetAccess(AccessKind.Read, "role:" + roleName);
+        }
 
-    /// <summary>
-    /// Gets whether users belonging to the role with the given <paramref name="roleName"/>
-    /// are allowed to write this object. Even if this returns false, the role may still be
-    /// able to write it if a parent role has write access.
-    /// </summary>
-    /// <param name="roleName">The name of the role.</param>
-    /// <returns>Whether the role has access.</returns>
-    public bool GetRoleWriteAccess(string roleName) {
-      return GetAccess(AccessKind.Write, "role:" + roleName);
-    }
+        /// <summary>
+        /// Gets whether users belonging to the role are allowed to read this object.
+        /// Even if this returns false, the role may still be able to read it if a
+        /// parent role has read access.
+        /// </summary>
+        /// <param name="role">The name of the role.</param>
+        /// <returns>Whether the role has access.</returns>
+        public bool GetRoleReadAccess(AVRole role) {
+            return GetRoleReadAccess(role.Name);
+        }
 
-    /// <summary>
-    /// Gets whether users belonging to the role are allowed to write this object.
-    /// Even if this returns false, the role may still be able to write it if a
-    /// parent role has write access.
-    /// </summary>
-    /// <param name="role">The name of the role.</param>
-    /// <returns>Whether the role has access.</returns>
-    public bool GetRoleWriteAccess(AVRole role) {
-      return GetRoleWriteAccess(role.Name);
+        /// <summary>
+        /// Sets whether users belonging to the role with the given <paramref name="roleName"/>
+        /// are allowed to write this object.
+        /// </summary>
+        /// <param name="roleName">The name of the role.</param>
+        /// <param name="allowed">Whether the role has access.</param>
+        public void SetRoleWriteAccess(string roleName, bool allowed) {
+            SetAccess(AccessKind.Write, "role:" + roleName, allowed);
+        }
+
+        /// <summary>
+        /// Sets whether users belonging to the given role are allowed to write this object.
+        /// </summary>
+        /// <param name="role">The role.</param>
+        /// <param name="allowed">Whether the role has access.</param>
+        public void SetRoleWriteAccess(AVRole role, bool allowed) {
+            SetRoleWriteAccess(role.Name, allowed);
+        }
+
+        /// <summary>
+        /// Gets whether users belonging to the role with the given <paramref name="roleName"/>
+        /// are allowed to write this object. Even if this returns false, the role may still be
+        /// able to write it if a parent role has write access.
+        /// </summary>
+        /// <param name="roleName">The name of the role.</param>
+        /// <returns>Whether the role has access.</returns>
+        public bool GetRoleWriteAccess(string roleName) {
+            return GetAccess(AccessKind.Write, "role:" + roleName);
+        }
+
+        /// <summary>
+        /// Gets whether users belonging to the role are allowed to write this object.
+        /// Even if this returns false, the role may still be able to write it if a
+        /// parent role has write access.
+        /// </summary>
+        /// <param name="role">The name of the role.</param>
+        /// <returns>Whether the role has access.</returns>
+        public bool GetRoleWriteAccess(AVRole role) {
+            return GetRoleWriteAccess(role.Name);
+        }
     }
-  }
 }

Storage/Storage/Public/AVException.cs

@@ -258,7 +258,12 @@ namespace LeanCloud
             /// <summary>
             /// 手机号不合法
             /// </summary>
-            MobilePhoneInvalid = 253
+            MobilePhoneInvalid = 253,
+
+            /// <summary>
+            /// 按条件更新/删除失败
+            /// </summary>
+            NoEffectOnUpdatingOrDeleting = 305,
         }
 
         internal AVException(ErrorCode code, string message, Exception cause = null)

Storage/Storage/Public/AVObject.cs

@@ -790,11 +790,11 @@ string propertyName
         /// Deletes this object on the server.
         /// </summary>
         /// <param name="cancellationToken">The cancellation token.</param>
-        public virtual async Task DeleteAsync(CancellationToken cancellationToken = default) {
+        public virtual async Task DeleteAsync(AVQuery<AVObject> query = null, CancellationToken cancellationToken = default) {
             if (ObjectId == null) {
                 return;
             }
-            await ObjectController.DeleteAsync(State, cancellationToken);
+            await ObjectController.DeleteAsync(State, query, cancellationToken);
             IsDirty = true;
         }