Parse

Authenticates with the service.

The cancellation token.

Deauthenticates (logs out) the user associated with this provider. This call may block.

Restores authentication that has been serialized, such as session keys, etc.

The auth data for the provider. This value may be null when unlinking an account. true iff the authData was successfully synchronized. A false return value indicates that the user should no longer be associated because of bad auth data.

Provides a unique name for the type of authentication the provider does. For example, the FacebookAuthenticationProvider would return "facebook".

Parses a uri, looking for a base uri that represents facebook login completion, and then converting the query string into a dictionary of key-value pairs. (e.g. access_token)

Provides a Dictionary implementation that can delegate to any other dictionary, regardless of its value type. Used for coercion of dictionaries when returning them to users.

The resulting type of value in the dictionary. The original type of value in the dictionary.

Provides a List implementation that can delegate to any other list, regardless of its value type. Used for coercion of lists when returning them to users.

The resulting type of value in the list. The original type of value in the list.

An equality comparer that uses the object identity (i.e. ReferenceEquals) rather than .Equals, allowing identity to be used for checking equality in ISets and IDictionaries.

Provides helper methods that allow us to use terser code elsewhere.

Ensures a task (even null) is awaitable.

Partial methods cannot return a value, so we instead make partial accessors use ref params. This helper can be used to write code more normally so we get the out-param or default when calling a partial method. Given a partial method: partial void GetFoo(ref string foo) we can say string foo = this.GetPartial<string>(GetFoo);

Partial methods cannot return a value, so we instead make partial accessors use ref params. This means you cannot effectively make a partial which is async. This code helps create a design pattern where a partial takes a ref Task param and we can await the PartialAsync of it. Given a partial method: partial void FooAsync(ref Task<string> task) we can say string foo = await PartialAsync<string>(FooAsync);

A ParseFieldOperation represents a modification to a value in a ParseObject. For example, setting, deleting, or incrementing a value are all different kinds of ParseFieldOperations. ParseFieldOperations themselves can be considered to be immutable.

Converts the ParseFieldOperation to a data structure that can be converted to JSON and sent to Parse as part of a save operation.

An object to be JSONified.

Returns a field operation that is composed of a previous operation followed by this operation. This will not mutate either operation. However, it may return this if the current operation is not affected by previous changes. For example: {increment by 2}.MergeWithPrevious({set to 5}) -> {set to 7} {set to 5}.MergeWithPrevious({increment by 2}) -> {set to 5} {add "foo"}.MergeWithPrevious({delete}) -> {set to ["foo"]} {delete}.MergeWithPrevious({add "foo"}) -> {delete} ///

The most recent operation on the field, or null if none. A new ParseFieldOperation or this.

Returns a new estimated value based on a previous value and this operation. This value is not intended to be sent to Parse, but it is used locally on the client to inspect the most likely current value for a field. The key and object are used solely for ParseRelation to be able to construct objects that refer back to their parents.

The previous value for the field. The object that contains this value. The key that this value is for. The new value for the field.

A simple recursive-descent JSON Parser based on the grammar defined at http://www.json.org and http://tools.ietf.org/html/rfc4627

Place at the start of a regex to force the match to begin wherever the search starts (i.e. anchored at the index of the first character of the search, even when that search starts in the middle of the string).

Parses a JSON-text as defined in http://tools.ietf.org/html/rfc4627, returning an IDictionary<string, object> or an IList<object> depending on whether the value was an array or dictionary. Nested objects also match these types.

Encodes a dictionary into a JSON string. Suppots values that are IDictionary<string, object>, IList<object>, strings, nulls, and any of the primitive types.

Encodes a list into a JSON string. Suppots values that are IDictionary<string, object>, IList<object>, strings, nulls, and any of the primitive types.

Encodes an object into a JSON string.

Parses JSON object syntax (e.g. '{}')

Parses JSON member syntax (e.g. '"keyname" : null')

Parses JSON array syntax (e.g. '[]')

Parses a value (i.e. the right-hand side of an object member assignment or an element in an array)

Parses a JSON string (e.g. '"foo\u1234bar\n"')

Parses a number. Returns a long if the number is an integer or has an exponent, otherwise returns a double.

Matches the string to a regex, consuming part of the string and returning the match.

Find the first occurences of a character, consuming part of the string.

Find the first occurences of a string, consuming part of the string.

An operation where a field is deleted from the object.

The ParseConfig is a representation of the remote configuration object, that enables you to add things like feature gating, a/b testing or simple "Message of the day".

Retrieves the ParseConfig asynchronously from the server.

ParseConfig object that was fetched

Retrieves the ParseConfig asynchronously from the server.

The cancellation token. ParseConfig object that was fetched

Gets a value for the key of a particular type.

The type to convert the value to. Supported types are ParseObject and its descendents, Parse types such as ParseRelation and ParseGeopoint, primitive types,IList<T>, IDictionary<string, T> and strings. The key of the element to get. The property is retrieved and is not found. The property under this key was found, but of a different type.

Populates result with the value for the key, if possible.

The desired type for the value. The key to retrieve a value for. The value for the given key, converted to the requested type, or null if unsuccessful. true if the lookup and conversion succeeded, otherwise false.

Gets the latest fetched ParseConfig.

ParseConfig object

Gets a value on the config.

The key for the parameter. The property is retrieved and is not found. The value for the key.

Specifies a field name for a property on a ParseObject subclass.

Constructs a new ParseFieldName attribute.

The name of the field on the ParseObject that the property represents.

Gets the name of the field represented by this property.

This method helps simplify the process of getting a constructor for a type. A method like this exists in .NET but is not allowed in a Portable Class Library, so we've built our own.

Represents an event handler that calls back from the synchronization context that subscribed. Should look like an EventArgs, but may not inherit EventArgs if T is implemented by the Windows team.

A helper class for enqueuing tasks

We only need to keep the tail of the queue. Cancelled tasks will just complete normally/immediately when their turn arrives.

Gets a cancellable task that can be safely awaited and is dependent on the current tail of the queue. This essentially gives us a proxy for the tail end of the queue whose awaiting can be cancelled.

A cancellation token that cancels the task even if the task is still in the queue. This allows the running task to return immediately without breaking the dependency chain. It also ensures that errors do not propagate. A new task that should be awaited by enqueued tasks.

Enqueues a task created by . If the task is cancellable (or should be able to be cancelled while it is waiting in the queue), pass a cancellationToken.

The type of task. A function given a task to await once state is snapshotted (e.g. after capturing session tokens at the time of the save call). Awaiting this task will wait for the created task's turn in the queue. A cancellation token that can be used to cancel waiting in the queue. The task created by the taskStart function.

Defines the class name for a subclass of ParseObject.

Constructs a new ParseClassName attribute.

The class name to associate with the ParseObject subclass.

Gets the class name to associate with the ParseObject subclass.

ParseFile is a local representation of a file that is saved to the Parse cloud.

The workflow is to construct a with data and a filename, then save it and set it as a field on a ParseObject:


            var file = new ParseFile("hello.txt",
                new MemoryStream(Encoding.UTF8.GetBytes("hello")));
            await file.SaveAsync();
            var obj = new ParseObject("TestObject");
            obj["file"] = file;
            await obj.SaveAsync();

Creates a new file from a byte array and a name.

The file's name, ideally with an extension. The file name must begin with an alphanumeric character, and consist of alphanumeric characters, periods, spaces, underscores, or dashes. The file's data. To specify the content-type used when uploading the file, provide this parameter.

Creates a new file from a stream and a name.

Saves the file to the Parse cloud.

The cancellation token.

Saves the file to the Parse cloud.

The progress callback.

Saves the file to the Parse cloud.

The progress callback. The cancellation token.

Gets whether the file still needs to be saved.

Gets the name of the file. Before save is called, this is the filename given by the user. After save is called, that name gets prefixed with a unique identifier.

Gets the MIME type of the file. This is either passed in to the constructor or inferred from the file extension. "unknown/unknown" will be used if neither is available.

Gets the url of the file. It is only available after you save the file or after you get the file from a .

A wrapper around Parse push notification payload.

The payload of the push notification as IDictionary.

The payload of the push notification as string.

Provides extension methods for to support Linq-style queries.

Gets a MethodInfo for a top-level method call.

When a query is normalized, this is a placeholder to indicate we should add a WhereContainedIn() clause.

When a query is normalized, this is a placeholder to indicate we should add a WhereNotContainedIn() clause.

When a query is normalized, this is a placeholder to indicate that we should add a WhereExists() clause.

When a query is normalized, this is a placeholder to indicate that we should add a WhereDoesNotExist() clause.

Evaluates an expression and throws if the expression has components that can't be evaluated (e.g. uses the parameter that's only represented by an object on the server).

Checks whether the MethodCallExpression is a call to ParseObject.Get(), which is the call we normalize all indexing into the ParseObject to.

Converts a normalized method call expression into the appropriate ParseQuery clause.

Converts a normalized binary expression into the appropriate ParseQuery clause.

Filters a query based upon the predicate provided.

The type of ParseObject being queried for. The base to which the predicate will be added. A function to test each ParseObject for a condition. The predicate must be able to be represented by one of the standard Where functions on ParseQuery A new ParseQuery whose results will match the given predicate as well as the source's filters.

Normalizes an OrderBy's keySelector expression and then extracts the path from the ParseObject.Get() call.

Orders a query based upon the key selector provided.

The type of ParseObject being queried for. The type of key returned by keySelector. The query to order. A function to extract a key from the ParseObject. A new ParseQuery based on source whose results will be ordered by the key specified in the keySelector.

Orders a query based upon the key selector provided.

Performs a subsequent ordering of a query based upon the key selector provided.

Correlates the elements of two queries based on matching keys.

The type of ParseObjects of the first query. The type of ParseObjects of the second query. The type of the keys returned by the key selector functions. The type of the result. This must match either TOuter or TInner The first query to join. The query to join to the first query. A function to extract a join key from the results of the first query. A function to extract a join key from the results of the second query. A function to select either the outer or inner query result to determine which query is the base query. A new ParseQuery with a WhereMatchesQuery or WhereMatchesKeyInQuery clause based upon the query indicated in the .

Visits an Expression, converting ParseObject.Get/ParseObject[]/ParseObject.Property, and nested indices into a single call to ParseObject.Get() with a "field path" like "foo.bar.baz"

Check for a ParseFieldName attribute and use that as the path component, turning properties like foo.ObjectId into foo.Get("objectId")

If a ParseObject.Get() call has been cast, just change the generic parameter.

Normalizes Where expressions.

Normalizes binary operators. <, >, <=, >= !=, and == This puts the ParseObject.Get() on the left side of the operation (reversing it if necessary), and normalizes the ParseObject.Get()

If a ! operator is used, this removes the ! and instead calls the equivalent function (so e.g. == becomes !=, < becomes >=, Contains becomes NotContains)

Normalizes .Equals into == and Contains() into the appropriate stub.

A ParseACL is used to control which users and roles can access or modify a particular object. Each can have its own ParseACL. You can grant read and write permissions separately to specific users, to groups of users that belong to roles, or you can grant permissions to "the public" so that, for example, any user could read a particular object but only a particular set of users could write to that object.

Creates an ACL with no permissions granted.

Creates an ACL where only the provided user has access.

The only user that can read or write objects governed by this ACL.

Sets whether the given user id is allowed to read this object.

The objectId of the user. Whether the user has permission.

Sets whether the given user is allowed to read this object.

The user. Whether the user has permission.

Sets whether the given user id is allowed to write this object.

The objectId of the user. Whether the user has permission.

Sets whether the given user is allowed to write this object.

The user. Whether the user has permission.

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.

The user objectId to check. Whether the user has access.

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.

The user to check. Whether the user has access.

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.

The user objectId to check. Whether the user has access.

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.

The user to check. Whether the user has access.

Sets whether users belonging to the role with the given are allowed to read this object.