Class DocumentClient

If database is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s).

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Database are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the database object supplied. It is likely that an id was not supplied for the new Database.
409	Conflict - This means a Database with an id matching the id field of `database` already existed.

See Also: Database

RequestOptions

ResourceResponse<TResource>

Task

CreateDatabaseIfNotExistsAsync(Database, RequestOptions)

Creates(if doesn't exist) or gets(if already exists) a database resource as an asychronous operation in the Azure Cosmos DB service. You can check the status code from the response to determine whether the database was newly created(201) or existing database was returned(200)

public Task<ResourceResponse<Database>> CreateDatabaseIfNotExistsAsync(Database database, RequestOptions options = null)

Parameters

database Database: The specification for the Database to create.
options RequestOptions: (Optional) The RequestOptions for the request.

Returns

Task<ResourceResponse<Database>>: The Database that was created within a task object representing the service response for the asynchronous operation.

Examples

The example below creates a new Database with an Id property of 'MyDatabase' This code snippet is intended to be used from within an asynchronous method as it uses the await keyword

using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
{
    Database db = await client.CreateDatabaseIfNotExistsAsync(new Database { Id = "MyDatabase" });
}

If you would like to construct a Database from within a synchronous method then you need to use the following code

using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
{
    Database db = client.CreateDatabaseIfNotExistsAsync(new Database { Id = "MyDatabase" }).Result;
}

Exceptions

ArgumentNullException: If database is not set.
AggregateException: Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s).
DocumentClientException: This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property.

See Also: Database

RequestOptions

ResourceResponse<TResource>

Task

CreateDatabaseQuery(FeedOptions)

Overloaded. This method creates a query for database resources under an account in the Azure Cosmos DB service. It returns An IOrderedQueryable{Database}.

public IOrderedQueryable<Database> CreateDatabaseQuery(FeedOptions feedOptions = null)

Parameters

feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<Database>: An IOrderedQueryable{Database} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for databases by id.

Database database = client.CreateDatabaseQuery().Where(d => d.Id == "mydb").AsEnumerable().FirstOrDefault();

See Also: Database

IDocumentQuery

CreateDatabaseQuery(SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for database resources under an Azure Cosmos DB database account by using a SQL statement with parameterized values. It returns an IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<dynamic> CreateDatabaseQuery(SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{dynamic} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for databases by id.

var query = new SqlQuerySpec("SELECT * FROM dbs d WHERE d.id = @id",
    new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@id", Value = "mydb" }}));
dynamic database = client.CreateDatabaseQuery<dynamic>(query).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Database

IDocumentQuery

CreateDatabaseQuery(string, FeedOptions)

Overloaded. This method creates a query for database resources under an Azure Cosmos DB database account by using a SQL statement. It returns an IQueryable{dynamic}.

public IQueryable<dynamic> CreateDatabaseQuery(string sqlExpression, FeedOptions feedOptions = null)

Parameters

sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{dynamic} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for databases by id.

Database database = client.CreateDatabaseQuery("SELECT * FROM dbs d WHERE d.id = 'mydb'").AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Database

IDocumentQuery

CreateDocumentAsync(string, object, RequestOptions, bool, CancellationToken)

Creates a Document as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Document>> CreateDocumentAsync(string documentsFeedOrDatabaseLink, object document, RequestOptions options = null, bool disableAutomaticIdGeneration = false, CancellationToken cancellationToken = default)

Parameters

documentsFeedOrDatabaseLink string: The link of the DocumentCollection to create the document in. E.g. dbs/db_rid/colls/coll_rid/
document object: The document object to create.
options RequestOptions: (Optional) Any request options you wish to set. E.g. Specifying a Trigger to execute when creating the document. RequestOptions
disableAutomaticIdGeneration bool: (Optional) Disables the automatic id generation, If this is True the system will throw an exception if the id property is missing from the Document.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Document>>: The Document that was created contained within a Task object representing the service response for the asynchronous operation.

Examples

Azure Cosmos DB supports a number of different ways to work with documents. A document can extend Resource

public class MyObject : Resource
{
public string MyProperty {get; set;}
}
                                                                                                                                                     using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
                                                                                                                                                     {
                                                                                                                                                         Document doc = await client.CreateDocumentAsync("dbs/db_rid/colls/coll_rid/", new MyObject { MyProperty = "A Value" });
                                                                                                                                                     }</code></pre>

A document can be any POCO object that can be serialized to JSON, even if it doesn't extend from Resource

public class MyPOCO
{
public string MyProperty {get; set;}
}
                                                                                                                                                    using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
                                                                                                                                                    {
                                                                                                                                                        Document doc = await client.CreateDocumentAsync("dbs/db_rid/colls/coll_rid/", new MyPOCO { MyProperty = "A Value" });
                                                                                                                                                    }</code></pre>

Finally, a Document can also be a dynamic object

using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
{
    Document doc = await client.CreateDocumentAsync("dbs/db_rid/colls/coll_rid/", new { SomeProperty = "A Value" } );
}

Create a Document and execute a Pre and Post Trigger

using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
{
    Document doc = await client.CreateDocumentAsync(
        "dbs/db_rid/colls/coll_rid/",
        new { id = "DOC123213443" },
        new RequestOptions
        {
            PreTriggerInclude = new List<string> { "MyPreTrigger" },
            PostTriggerInclude = new List<string> { "MyPostTrigger" }
        });
}

Exceptions

If either documentsFeedOrDatabaseLink or document is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the document supplied. It is likely that `disableAutomaticIdGeneration` was true and an id was not supplied
403	Forbidden - This likely means the collection in to which you were trying to create the document is full.
409	Conflict - This means a Document with an id matching the id field of `document` already existed
413	RequestEntityTooLarge - This means the Document exceeds the current max entity size. Consult documentation for limits and quotas.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Document

RequestOptions

ResourceResponse<TResource>

Task

CreateDocumentAsync(Uri, object, RequestOptions, bool, CancellationToken)

Creates a document as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Document>> CreateDocumentAsync(Uri documentCollectionUri, object document, RequestOptions options = null, bool disableAutomaticIdGeneration = false, CancellationToken cancellationToken = default)

Parameters

documentCollectionUri Uri: the URI of the document collection to create the document in.
document object: the document object.
options RequestOptions: The request options for the request.
disableAutomaticIdGeneration bool: Disables the automatic id generation, will throw an exception if id is missing.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Document>>: The task object representing the service response for the asynchronous operation.

CreateDocumentChangeFeedQuery(string, ChangeFeedOptions)

Overloaded. This method creates a change feed query for documents under a collection in an Azure Cosmos DB service.

public IDocumentQuery<Document> CreateDocumentChangeFeedQuery(string collectionLink, ChangeFeedOptions feedOptions)

Parameters

collectionLink string: Specifies the collection to read documents from.
feedOptions ChangeFeedOptions: The options for processing the query results feed.

Returns

IDocumentQuery<Document>: the query result set.

Examples

string partitionKeyRangeId = "0";   // Use client.ReadPartitionKeyRangeFeedAsync() to obtain the ranges.
string checkpointContinuation = null;
ChangeFeedOptions options = new ChangeFeedOptions
{
    PartitionKeyRangeId = partitionKeyRangeId,
    RequestContinuation = checkpointContinuation,
    StartFromBeginning = true,
};
using(var query = client.CreateDocumentChangeFeedQuery(collection.SelfLink, options))
{
    while (true)
    {
        do
        {
            var response = await query.ExecuteNextAsync<Document>();
            if (response.Count > 0)
            {
                var docs = new List<Document>();
                docs.AddRange(response);
                // Process the documents.
                // Checkpoint response.ResponseContinuation.
            }
        }
        while (query.HasMoreResults);
        Task.Delay(TimeSpan.FromMilliseconds(500)); // Or break here and use checkpointed continuation token later.
    }       
}

Remarks

ChangeFeedOptions.PartitionKeyRangeId must be provided.

See Also: IDocumentQuery<T>

ChangeFeedOptions

PartitionKeyRange

CreateDocumentChangeFeedQuery(Uri, ChangeFeedOptions)

Extension method to create a change feed query for documents in the Azure Cosmos DB service.

public IDocumentQuery<Document> CreateDocumentChangeFeedQuery(Uri collectionLink, ChangeFeedOptions feedOptions)

Parameters

collectionLink Uri: Specifies the collection to read documents from.
feedOptions ChangeFeedOptions: The options for processing the query results feed.

Returns

IDocumentQuery<Document>: the query result set.

CreateDocumentCollectionAsync(string, DocumentCollection, RequestOptions)

Creates a collection as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<DocumentCollection>> CreateDocumentCollectionAsync(string databaseLink, DocumentCollection documentCollection, RequestOptions options = null)

Parameters

databaseLink string: The link of the database to create the collection in. E.g. dbs/db_rid/.
documentCollection DocumentCollection: The DocumentCollection object.
options RequestOptions: (Optional) Any RequestOptions you wish to provide when creating a Collection. E.g. RequestOptions.OfferThroughput = 400.

Returns

Task<ResourceResponse<DocumentCollection>>: The DocumentCollection that was created contained within a Task object representing the service response for the asynchronous operation.

Examples

using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
{
    //Create a new collection with an OfferThroughput set to 10000
    //Not passing in RequestOptions.OfferThroughput will result in a collection with the default OfferThroughput set.
    DocumentCollection coll = await client.CreateDocumentCollectionAsync(databaseLink,
        new DocumentCollection { Id = "My Collection" },
        new RequestOptions { OfferThroughput = 10000} );
}

Exceptions

If either databaseLink or documentCollection is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s).

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a collection are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied. It is likely that an id was not supplied for the new collection.
403	Forbidden - This means you attempted to exceed your quota for collections. Contact support to have this quota increased.
409	Conflict - This means a DocumentCollection with an id matching the id you supplied already existed.

See Also: DocumentCollection

OfferV2

RequestOptions

ResourceResponse<TResource>

Task

CreateDocumentCollectionAsync(Uri, DocumentCollection, RequestOptions)

Creates a collection as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<DocumentCollection>> CreateDocumentCollectionAsync(Uri databaseUri, DocumentCollection documentCollection, RequestOptions options = null)

Parameters

databaseUri Uri: the URI of the database to create the collection in.
documentCollection DocumentCollection: the Microsoft.Azure.Documents.DocumentCollection object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<DocumentCollection>>: The task object representing the service response for the asynchronous operation.

CreateDocumentCollectionIfNotExistsAsync(string, DocumentCollection, RequestOptions)

Creates (if doesn't exist) or gets (if already exists) a collection as an asychronous operation in the Azure Cosmos DB service. You can check the status code from the response to determine whether the collection was newly created (201) or existing collection was returned (200).

public Task<ResourceResponse<DocumentCollection>> CreateDocumentCollectionIfNotExistsAsync(string databaseLink, DocumentCollection documentCollection, RequestOptions options = null)

Parameters

databaseLink string: The link of the database to create the collection in. E.g. dbs/db_rid/.
documentCollection DocumentCollection: The DocumentCollection object.
options RequestOptions: (Optional) Any RequestOptions you wish to provide when creating a Collection. E.g. RequestOptions.OfferThroughput = 400.

Returns

Task<ResourceResponse<DocumentCollection>>: The DocumentCollection that was created contained within a Task object representing the service response for the asynchronous operation.

Examples

using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
{
    //Create a new collection with an OfferThroughput set to 10000
    //Not passing in RequestOptions.OfferThroughput will result in a collection with the default OfferThroughput set.
    DocumentCollection coll = await client.CreateDocumentCollectionIfNotExistsAsync(databaseLink,
        new DocumentCollection { Id = "My Collection" },
        new RequestOptions { OfferThroughput = 10000} );
}

Exceptions

If either databaseLink or documentCollection is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s).

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a DocumentCollection are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied. It is likely that an id was not supplied for the new collection.
403	Forbidden - This means you attempted to exceed your quota for collections. Contact support to have this quota increased.

See Also: DocumentCollection

OfferV2

RequestOptions

ResourceResponse<TResource>

Task

CreateDocumentCollectionIfNotExistsAsync(Uri, DocumentCollection, RequestOptions)

Creates(if doesn't exist) or gets(if already exists) a collection as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<DocumentCollection>> CreateDocumentCollectionIfNotExistsAsync(Uri databaseUri, DocumentCollection documentCollection, RequestOptions options = null)

Parameters

databaseUri Uri: the URI of the database to create the collection in.
documentCollection DocumentCollection: The DocumentCollection object.
options RequestOptions: (Optional) Any RequestOptions you wish to provide when creating a Collection. E.g. RequestOptions.OfferThroughput = 400.

Returns

Task<ResourceResponse<DocumentCollection>>: The DocumentCollection that was created contained within a Task object representing the service response for the asynchronous operation.

CreateDocumentCollectionQuery(string, FeedOptions)

Overloaded. This method creates a query for collections under an Azure Cosmos DB database. It returns An IOrderedQueryable{DocumentCollection}.

public IOrderedQueryable<DocumentCollection> CreateDocumentCollectionQuery(string databaseLink, FeedOptions feedOptions = null)

Parameters

databaseLink string: The link to the parent database resource.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<DocumentCollection>: An IOrderedQueryable{DocumentCollection} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for collections by id.

DocumentCollection collection = client.CreateDocumentCollectionQuery(databaseLink).Where(c => c.Id == "myColl").AsEnumerable().FirstOrDefault();

See Also: DocumentCollection

IDocumentQuery

CreateDocumentCollectionQuery(string, SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for collections under an Azure Cosmos DB database using a SQL statement with parameterized values. It returns an IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<dynamic> CreateDocumentCollectionQuery(string databaseLink, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

databaseLink string: The link to the parent database resource.
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{dynamic} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for collections by id.

var query = new SqlQuerySpec("SELECT * FROM colls c WHERE c.id = @id", new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@id", Value = "mycoll" }}));
DocumentCollection collection = client.CreateDocumentCollectionQuery(databaseLink, query).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: DocumentCollection

IDocumentQuery

CreateDocumentCollectionQuery(string, string, FeedOptions)

Overloaded. This method creates a query for collections under an Azure Cosmos DB database using a SQL statement. It returns an IQueryable{DocumentCollection}.

public IQueryable<dynamic> CreateDocumentCollectionQuery(string databaseLink, string sqlExpression, FeedOptions feedOptions = null)

Parameters

databaseLink string: The link to the parent database resource.
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{dynamic} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for collections by id.

DocumentCollection collection = client.CreateDocumentCollectionQuery(databaseLink, "SELECT * FROM colls c WHERE c.id = 'mycoll'").AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: DocumentCollection

IDocumentQuery

CreateDocumentCollectionQuery(Uri, FeedOptions)

Extension method to create a query for document collections in the Azure Cosmos DB service.

public IOrderedQueryable<DocumentCollection> CreateDocumentCollectionQuery(Uri databaseUri, FeedOptions feedOptions = null)

Parameters

databaseUri Uri: the URI to the database.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IOrderedQueryable<DocumentCollection>: The query result set.

CreateDocumentCollectionQuery(Uri, SqlQuerySpec, FeedOptions)

Extension method to create a query for document collections in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateDocumentCollectionQuery(Uri databaseUri, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

databaseUri Uri: the URI to the database.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateDocumentCollectionQuery(Uri, string, FeedOptions)

Extension method to create a query for document collections in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateDocumentCollectionQuery(Uri databaseUri, string sqlExpression, FeedOptions feedOptions = null)

Parameters

databaseUri Uri: the URI to the database.
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateDocumentQuery(string, FeedOptions)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB service. It returns IOrderedQueryable{Document}.

public IOrderedQueryable<Document> CreateDocumentQuery(string collectionLink, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent document collection.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<Document>: An IOrderedQueryable{Document} that can evaluate the query.

Examples

This example below queries for documents by id.

Document document = client.CreateDocumentQuery<Document>(collectionLink)
    .Where(d => d.Id == "War and Peace").AsEnumerable().FirstOrDefault();

Remarks

This overload should be used when the schema of the queried documents is unknown or when querying by ID and replacing/deleting documents. Since Document is a DynamicObject, it can be dynamically cast back to the original C# object.

See Also: Document

IDocumentQuery

CreateDocumentQuery(string, FeedOptions, object)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB service. It returns IOrderedQueryable{Document}.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IOrderedQueryable<Document> CreateDocumentQuery(string collectionLink, FeedOptions feedOptions, object partitionKey)

Parameters

collectionLink string: The link to the parent document collection. Alternatively, this can be a path link to the database when using an IPartitionResolver.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions
partitionKey object: Optional partition key that can be used with an IPartitionResolver.

Returns

IOrderedQueryable<Document>: An IOrderedQueryable{Document} that can evaluate the query.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery(string, SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB database using a SQL statement with parameterized values. It returns an IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<dynamic> CreateDocumentQuery(string collectionLink, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent document collection.
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: an IQueryable{dynamic> that can evaluate the query.

Examples

This example below queries for book documents.

// SQL querying allows dynamic property access
var query = new SqlQuerySpec(
    "SELECT * FROM books b WHERE b.title = @title", 
    new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@title", Value = "War and Peace" }}));

dynamic document = client.CreateDocumentQuery<dynamic>(collectionLink, query).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Document

IDocumentQuery

CreateDocumentQuery(string, SqlQuerySpec, FeedOptions, object)

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IQueryable<dynamic> CreateDocumentQuery(string collectionLink, SqlQuerySpec querySpec, FeedOptions feedOptions, object partitionKey)

Parameters

collectionLink string: The link to the parent document collection. Alternatively, this can be a path link to the database when using an IPartitionResolver, e.g. dbs/db_rid/
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IQueryable<dynamic>: an IQueryable{dynamic> that can evaluate the query.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery(string, string, FeedOptions)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB database using a SQL statement. It returns an IQueryable{dynamic}.

public IQueryable<dynamic> CreateDocumentQuery(string collectionLink, string sqlExpression, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent document collection.
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: an IQueryable{dynamic> that can evaluate the query.

Examples

This example below queries for book documents.

// SQL querying allows dynamic property access
dynamic document = client.CreateDocumentQuery<dynamic>(collectionLink,
    "SELECT * FROM books b WHERE b.title == 'War and Peace'").AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Document

IDocumentQuery

CreateDocumentQuery(string, string, FeedOptions, object)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB database using a SQL statement. It returns an IQueryable{dynamic}.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IQueryable<dynamic> CreateDocumentQuery(string collectionLink, string sqlExpression, FeedOptions feedOptions, object partitionKey)

Parameters

collectionLink string: The link of the parent document collection. Alternatively, this can be a path link to the database when using an IPartitionResolver, e.g. dbs/db_rid/
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IQueryable<dynamic>: an IQueryable{dynamic> that can evaluate the query.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery(Uri, FeedOptions)

Extension method to create a query for documents in the Azure Cosmos DB service.

public IOrderedQueryable<Document> CreateDocumentQuery(Uri documentCollectionOrDatabaseUri, FeedOptions feedOptions = null)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IOrderedQueryable<Document>: The query result set.

CreateDocumentQuery(Uri, FeedOptions, object)

Extension method to create a query for documents in the Azure Cosmos DB service.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IOrderedQueryable<Document> CreateDocumentQuery(Uri documentCollectionOrDatabaseUri, FeedOptions feedOptions, object partitionKey)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection, e.g. dbs/db_rid/colls/coll_rid/. Alternatively, this can be a URI of the database when using an IPartitionResolver, e.g. dbs/db_rid/
feedOptions FeedOptions: The options for processing the query results feed.
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IOrderedQueryable<Document>: The query result set.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery(Uri, SqlQuerySpec, FeedOptions)

Extension method to create a query for documents in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateDocumentQuery(Uri documentCollectionOrDatabaseUri, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateDocumentQuery(Uri, SqlQuerySpec, FeedOptions, object)

Extension method to create a query for documents in the Azure Cosmos DB service.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IQueryable<dynamic> CreateDocumentQuery(Uri documentCollectionOrDatabaseUri, SqlQuerySpec querySpec, FeedOptions feedOptions, object partitionKey)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection, e.g. dbs/db_rid/colls/coll_rid/. Alternatively, this can be a URI of the database when using an IPartitionResolver, e.g. dbs/db_rid/
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IQueryable<dynamic>: The query result set.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery(Uri, string, FeedOptions)

Extension method to create a query for documents in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateDocumentQuery(Uri documentCollectionOrDatabaseUri, string sqlExpression, FeedOptions feedOptions = null)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection.
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateDocumentQuery(Uri, string, FeedOptions, object)

Extension method to create a query for documents in the Azure Cosmos DB service.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IQueryable<dynamic> CreateDocumentQuery(Uri documentCollectionOrDatabaseUri, string sqlExpression, FeedOptions feedOptions, object partitionKey)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection, e.g. dbs/db_rid/colls/coll_rid/. Alternatively, this can be a URI of the database when using an IPartitionResolver, e.g. dbs/db_rid/
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IQueryable<dynamic>: The query result set.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery<T>(string, FeedOptions)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB service.

public IOrderedQueryable<T> CreateDocumentQuery<T>(string collectionLink, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<T>: An IOrderedQueryable{T} that can evaluate the query.

Type Parameters

T: The type of object to query.

Examples

This example below queries for some book documents.

public class Book 
{
    [JsonProperty("title")]
    public string Title {get; set;}

    public Author Author {get; set;}

    public int Price {get; set;}
}

public class Author
{
    public string FirstName {get; set;}
    public string LastName {get; set;}
}

// Query by the Title property
Book book = client.CreateDocumentQuery<Book>(collectionLink).Where(b => b.Title == "War and Peace").AsEnumerable().FirstOrDefault();

// Query a nested property
Book otherBook = client.CreateDocumentQuery<Book>(collectionLink).Where(b => b.Author.FirstName == "Leo").AsEnumerable().FirstOrDefault();

// Perform a range query (needs an IndexType.Range on price or FeedOptions.EnableScansInQuery)
foreach (Book matchingBook in client.CreateDocumentQuery<Book>(collectionLink).Where(b => b.Price > 100))
{
    // Iterate through books
}

// Query asychronously. Optionally set FeedOptions.MaxItemCount to control page size
using (var queryable = client.CreateDocumentQuery<Book>(
    collectionLink,
    new FeedOptions { MaxItemCount = 10 })
    .Where(b => b.Title == "War and Peace")
    .AsDocumentQuery())
{
    while (queryable.HasMoreResults) 
    {
        foreach(Book b in await queryable.ExecuteNextAsync<Book>())
        {
            // Iterate through books
        }
    }
}

Remarks

The Azure Cosmos DB LINQ provider compiles LINQ to SQL statements. Refer to http://azure.microsoft.com/documentation/articles/documentdb-sql-query/#linq-to-documentdb-sql for the list of expressions supported by the Azure Cosmos DB LINQ provider. ToString() on the generated IQueryable returns the translated SQL statement. The Azure Cosmos DB provider translates JSON.NET and DataContract serialization attributes for members to their JSON property names.

See Also: Document

IDocumentQuery

CreateDocumentQuery<T>(string, FeedOptions, object)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB service.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IOrderedQueryable<T> CreateDocumentQuery<T>(string documentsFeedOrDatabaseLink, FeedOptions feedOptions, object partitionKey)

Parameters

documentsFeedOrDatabaseLink string: The path link for the documents under a collection, e.g. dbs/db_rid/colls/coll_rid/docs/. Alternatively, this can be a path link to the database when using an IPartitionResolver, e.g. dbs/db_rid/
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IOrderedQueryable<T>: An IOrderedQueryable{T} that can evaluate the query.

Type Parameters

T: The type of object to query.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery<T>(string, SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB database using a SQL statement with parameterized values. It returns an IQueryable{T}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<T> CreateDocumentQuery<T>(string collectionLink, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent document collection.
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<T>: An IQueryable{T} that can evaluate the query.

Type Parameters

T: The type of object to query.

Examples

This example below queries for some book documents.

public class Book 
{
    [JsonProperty("title")]
    public string Title {get; set;}

    public Author Author {get; set;}

    public int Price {get; set;}
}

public class Author
{
    public string FirstName {get; set;}
    public string LastName {get; set;}
}

// Query using Title
Book book, otherBook;

var query = new SqlQuerySpec(
    "SELECT * FROM books b WHERE b.title = @title", 
    new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@title", Value = "War and Peace" }}));
book = client.CreateDocumentQuery<Book>(collectionLink, query).AsEnumerable().FirstOrDefault();

// Query a nested property
query = new SqlQuerySpec(
    "SELECT * FROM books b WHERE b.Author.FirstName = @firstName", 
    new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@firstName", Value = "Leo" }}));
otherBook = client.CreateDocumentQuery<Book>(collectionLink, query).AsEnumerable().FirstOrDefault();

// Perform a range query (needs an IndexType.Range on price or FeedOptions.EnableScansInQuery)
query = new SqlQuerySpec(
    "SELECT * FROM books b WHERE b.Price > @minPrice", 
    new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@minPrice", Value = 1000 }}));
foreach (Book b in client.CreateDocumentQuery<Book>(
    collectionLink, query))
{
    // Iterate through books
}

// Query asychronously. Optionally set FeedOptions.MaxItemCount to control page size
query = new SqlQuerySpec(
    "SELECT * FROM books b WHERE b.title = @title", 
    new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@title", Value = "War and Peace" }}));

using (var queryable = client.CreateDocumentQuery<Book>(collectionLink, query, 
    new FeedOptions { MaxItemCount = 10 }).AsDocumentQuery())
{
    while (queryable.HasMoreResults) 
    {
        foreach(Book b in await queryable.ExecuteNextAsync<Book>())
        {
            // Iterate through books
        }
    }
}

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Document

IDocumentQuery

CreateDocumentQuery<T>(string, SqlQuerySpec, FeedOptions, object)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB database using a SQL statement with parameterized values. It returns an IQueryable{T}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IQueryable<T> CreateDocumentQuery<T>(string collectionLink, SqlQuerySpec querySpec, FeedOptions feedOptions, object partitionKey)

Parameters

collectionLink string: The link to the parent document collection. Alternatively, this can be a path link to the database when using an IPartitionResolver.
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IQueryable<T>: An IQueryable{T} that can evaluate the query.

Type Parameters

T: The type of object to query.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery<T>(string, string, FeedOptions)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB database using a SQL statement. It returns an IQueryable{T}.

public IQueryable<T> CreateDocumentQuery<T>(string collectionLink, string sqlExpression, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection.
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<T>: An IQueryable{T} that can evaluate the query.

Type Parameters

T: The type of object to query.

Examples

This example below queries for some book documents.

public class Book 
{
    [JsonProperty("title")]
    public string Title {get; set;}

    public Author Author {get; set;}

    public int Price {get; set;}
}

public class Author
{
    public string FirstName {get; set;}
    public string LastName {get; set;}
}

// Query by the Title property
Book book = client.CreateDocumentQuery<Book>(collectionLink, 
    "SELECT * FROM books b WHERE b.title  = 'War and Peace'").AsEnumerable().FirstOrDefault();

// Query a nested property
Book otherBook = client.CreateDocumentQuery<Book>(collectionLink,
    "SELECT * FROM books b WHERE b.Author.FirstName = 'Leo'").AsEnumerable().FirstOrDefault();

// Perform a range query (needs an IndexType.Range on price or FeedOptions.EnableScansInQuery)
foreach (Book matchingBook in client.CreateDocumentQuery<Book>(
    collectionLink, "SELECT * FROM books b where b.Price > 1000"))
{
    // Iterate through books
}

// Query asychronously. Optionally set FeedOptions.MaxItemCount to control page size
using (var queryable = client.CreateDocumentQuery<Book>(collectionLink, 
    "SELECT * FROM books b WHERE b.title  = 'War and Peace'", 
    new FeedOptions { MaxItemCount = 10 }).AsDocumentQuery())
{
    while (queryable.HasMoreResults) 
    {
        foreach(Book b in await queryable.ExecuteNextAsync<Book>())
        {
            // Iterate through books
        }
    }
}

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Document

IDocumentQuery

CreateDocumentQuery<T>(string, string, FeedOptions, object)

Overloaded. This method creates a query for documents under a collection in an Azure Cosmos DB database using a SQL statement. It returns an IQueryable{T}.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IQueryable<T> CreateDocumentQuery<T>(string collectionLink, string sqlExpression, FeedOptions feedOptions, object partitionKey)

Parameters

collectionLink string: The path link for the documents under a collection, e.g. dbs/db_rid/colls/coll_rid/docs/. Alternatively, this can be a path link to the database when using an IPartitionResolver, e.g. dbs/db_rid/
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IQueryable<T>: An IQueryable{T} that can evaluate the query.

Type Parameters

T: The type of object to query.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery<T>(Uri, FeedOptions)

Extension method to create a query for documents in the Azure Cosmos DB service.

public IOrderedQueryable<T> CreateDocumentQuery<T>(Uri documentCollectionUri, FeedOptions feedOptions = null)

Parameters

documentCollectionUri Uri: The URI of the document collection.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IOrderedQueryable<T>: The query result set.

Type Parameters

T: the type of object to query.

CreateDocumentQuery<T>(Uri, FeedOptions, object)

Extension method to create a query for documents in the Azure Cosmos DB service.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. Please use the override that does not take a partitionKey parameter.")]
public IOrderedQueryable<T> CreateDocumentQuery<T>(Uri documentCollectionOrDatabaseUri, FeedOptions feedOptions, object partitionKey)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection, e.g. dbs/db_rid/colls/coll_rid/. Alternatively, this can be a URI of the database when using an IPartitionResolver, e.g. dbs/db_rid/
feedOptions FeedOptions: The options for processing the query results feed.
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IOrderedQueryable<T>: The query result set.

Type Parameters

T: the type of object to query.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery<T>(Uri, SqlQuerySpec, FeedOptions)

Extension method to create a query for documents in the Azure Cosmos DB service.

public IQueryable<T> CreateDocumentQuery<T>(Uri documentCollectionOrDatabaseUri, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<T>: The query result set.

Type Parameters

T: The type of object to query.

CreateDocumentQuery<T>(Uri, SqlQuerySpec, FeedOptions, object)

Extension method to create a query for documents for the Azure Cosmos DB service.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IQueryable<T> CreateDocumentQuery<T>(Uri documentCollectionOrDatabaseUri, SqlQuerySpec querySpec, FeedOptions feedOptions, object partitionKey)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection, e.g. dbs/db_rid/colls/coll_rid/. Alternatively, this can be a URI of the database when using an IPartitionResolver, e.g. dbs/db_rid/
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IQueryable<T>: The query result set.

Type Parameters

T: The type of object to query.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateDocumentQuery<T>(Uri, string, FeedOptions)

Extension method to create a query for documents in the Azure Cosmos DB service.

public IQueryable<T> CreateDocumentQuery<T>(Uri documentCollectionOrDatabaseUri, string sqlExpression, FeedOptions feedOptions = null)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection.
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<T>: The query result set.

Type Parameters

T: the type of object to query.

CreateDocumentQuery<T>(Uri, string, FeedOptions, object)

Extension method to create a query for documents in the Azure Cosmos DB service.

[Obsolete("Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use partitioned collections for higher storage and throughput. Please use the override that does not take a partitionKey parameter.")]
public IQueryable<T> CreateDocumentQuery<T>(Uri documentCollectionOrDatabaseUri, string sqlExpression, FeedOptions feedOptions, object partitionKey)

Parameters

documentCollectionOrDatabaseUri Uri: The URI of the document collection, e.g. dbs/db_rid/colls/coll_rid/. Alternatively, this can be a URI of the database when using an IPartitionResolver, e.g. dbs/db_rid/
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.
partitionKey object: The partition key that can be used with an IPartitionResolver.

Returns

IQueryable<T>: The query result set.

Type Parameters

T: The type of object to query.

Remarks

Support for IPartitionResolver based method overloads is now obsolete. It's recommended that you use Partitioned Collections for higher storage and throughput.

CreateOfferQuery(FeedOptions)

Overloaded. This method creates a query for offers under an Azure Cosmos DB database account. It returns IOrderedQueryable{Offer}.

public IOrderedQueryable<Offer> CreateOfferQuery(FeedOptions feedOptions = null)

Parameters

feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<Offer>: An IOrderedQueryable{Offer} that can evaluate the query.

Examples

This example below queries for offers

// Find the offer for the collection by SelfLink
Offer offer = client.CreateOfferQuery().Where(o => o.Resource == collectionSelfLink).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Offer

IDocumentQuery

CreateOfferQuery(SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for offers under an Azure Cosmos DB database account using a SQL statement with parameterized values. It returns IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<dynamic> CreateOfferQuery(SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: an IQueryable{dynamic} that can evaluate the query.

Examples

This example below queries for offers

// Find the offer for the collection by SelfLink
Offer offer = client.CreateOfferQuery("SELECT * FROM offers o WHERE o.resource = @collectionSelfLink",
new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@collectionSelfLink", Value = collection.SelfLink }}))
.AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Offer

IDocumentQuery

CreateOfferQuery(string, FeedOptions)

Overloaded. This method creates a query for offers under an Azure Cosmos DB database account using a SQL statement. It returns IQueryable{dynamic}.

public IQueryable<dynamic> CreateOfferQuery(string sqlExpression, FeedOptions feedOptions = null)

Parameters

sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: an IQueryable{dynamic} that can evaluate the query.

Examples

This example below queries for offers

// Find the offer for the collection by SelfLink
Offer offer = client.CreateOfferQuery(
    string.Format("SELECT * FROM offers o WHERE o.resource = '{0}'", collectionSelfLink)).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Offer

IDocumentQuery

CreatePermissionAsync(string, Permission, RequestOptions)

Creates a permission on a user object as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Permission>> CreatePermissionAsync(string userLink, Permission permission, RequestOptions options = null)

Parameters

userLink string: The link of the user to create the permission for. E.g. dbs/db_rid/users/user_rid/
permission Permission: The Permission object.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Permission>>: A task object representing the service response for the asynchronous operation which contains the created Permission object.

Examples

//Create a read-only permission object for a specific user
Permission p = await client.CreatePermissionAsync(userLink, new Permission { Id = "ReadPermission", PermissionMode = PermissionMode.Read });

Exceptions

If either userLink or permission is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied.
403	Forbidden - You have reached your quota of permission objects. Contact support to have this quota increased.
409	Conflict - This means a Permission with an id matching the id you supplied already existed.

See Also: Permission

RequestOptions

ResourceResponse<TResource>

Task

CreatePermissionAsync(Uri, Permission, RequestOptions)

Creates a permission as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Permission>> CreatePermissionAsync(Uri userUri, Permission permission, RequestOptions options = null)

Parameters

userUri Uri: the URI of the user to create the permission for.
permission Permission: the Microsoft.Azure.Documents.Permission object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Permission>>: The task object representing the service response for the asynchronous operation.

CreatePermissionQuery(string, FeedOptions)

Overloaded. This method creates a query for permissions under a user in an Azure Cosmos DB service. It returns IOrderedQueryable{Permission}.

public IOrderedQueryable<Permission> CreatePermissionQuery(string permissionsLink, FeedOptions feedOptions = null)

Parameters

permissionsLink string: The path link for the persmissions under a user, e.g. dbs/db_rid/users/user_rid/permissions/.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<Permission>: An IOrderedQueryable{Permission} that can evaluate the query.

Examples

This example below queries for permissions by id.

Permission perm = client.CreatePermissionQuery(userLink).Where(p => p.id == "readonly").AsEnumerable().FirstOrDefault();

See Also: Permission

IDocumentQuery

CreatePermissionQuery(string, SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for permissions under a user in an Azure Cosmos DB database using a SQL statement with parameterized values. It returns an IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<dynamic> CreatePermissionQuery(string permissionsLink, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

permissionsLink string: The path link for the persmissions under a user, e.g. dbs/db_rid/users/user_rid/permissions/.
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: an IQueryable{dynamic} that can evaluate the query.

Examples

This example below queries for permissions by id.

var query = new SqlQuerySpec(
    "SELECT * FROM perms p WHERE p.id = @id", 
    new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@id", Value = "readonly" }}));

Permission perm = client.CreatePermissionQuery(usersLink, query).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Permission

IDocumentQuery

CreatePermissionQuery(string, string, FeedOptions)

Overloaded. This method creates a query for permissions under a user in an Azure Cosmos DB database using a SQL statement. It returns IQueryable{dynamic}.

public IQueryable<dynamic> CreatePermissionQuery(string permissionsLink, string sqlExpression, FeedOptions feedOptions = null)

Parameters

permissionsLink string: The path link for the persmissions under a user, e.g. dbs/db_rid/users/user_rid/permissions/.
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: an IQueryable{dynamic} that can evaluate the query.

Examples

This example below queries for permissions by id.

Permission perm = client.CreatePermissionQuery(userLink, 
    "SELECT * FROM perms p WHERE p.id = 'readonly'").AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Permission

IDocumentQuery

CreatePermissionQuery(Uri, FeedOptions)

Extension method to create a query for permissions in the Azure Cosmos DB service.

public IOrderedQueryable<Permission> CreatePermissionQuery(Uri permissionsUri, FeedOptions feedOptions = null)

Parameters

permissionsUri Uri: the URI to the permissions.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IOrderedQueryable<Permission>: The query result set.

CreatePermissionQuery(Uri, SqlQuerySpec, FeedOptions)

Extension method to create a query for permissions in the Azure Cosmos DB service.

public IQueryable<dynamic> CreatePermissionQuery(Uri permissionsUri, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

permissionsUri Uri: the URI to the permissions.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreatePermissionQuery(Uri, string, FeedOptions)

Extension method to create a query for permissions in the Azure Cosmos DB service.

public IQueryable<dynamic> CreatePermissionQuery(Uri permissionsUri, string sqlExpression, FeedOptions feedOptions = null)

Parameters

permissionsUri Uri: the URI to the permissions.
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateStoredProcedureAsync(string, StoredProcedure, RequestOptions)

Creates a stored procedure as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<StoredProcedure>> CreateStoredProcedureAsync(string collectionLink, StoredProcedure storedProcedure, RequestOptions options = null)

Parameters

collectionLink string: The link of the collection to create the stored procedure in. E.g. dbs/db_rid/colls/col_rid/
storedProcedure StoredProcedure: The StoredProcedure object to create.
options RequestOptions: (Optional) Any RequestOptionsfor this request.

Returns

Task<ResourceResponse<StoredProcedure>>: The StoredProcedure that was created contained within a Task object representing the service response for the asynchronous operation.

Examples

//Create a new stored procedure called "HelloWorldSproc" that takes in a single param called "name".
StoredProcedure sproc = await client.CreateStoredProcedureAsync(collectionLink, new StoredProcedure
{
   Id = "HelloWorldSproc",
   Body = @"function (name){
               var response = getContext().getResponse();
               response.setBody('Hello ' + name);
            }"
});

Exceptions

If either collectionLink or storedProcedure is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied. It is likely that an Id was not supplied for the stored procedure or the Body was malformed.
403	Forbidden - You have reached your quota of stored procedures for the collection supplied. Contact support to have this quota increased.
409	Conflict - This means a StoredProcedure with an id matching the id you supplied already existed.
413	RequestEntityTooLarge - This means the body of the StoredProcedure you tried to create was too large.

See Also: StoredProcedure

RequestOptions

ResourceResponse<TResource>

Task

CreateStoredProcedureAsync(Uri, StoredProcedure, RequestOptions)

Creates a stored procedure as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<StoredProcedure>> CreateStoredProcedureAsync(Uri documentCollectionUri, StoredProcedure storedProcedure, RequestOptions options = null)

Parameters

documentCollectionUri Uri: the URI of the document collection to create the stored procedure in.
storedProcedure StoredProcedure: the Microsoft.Azure.Documents.StoredProcedure object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<StoredProcedure>>: The task object representing the service response for the asynchronous operation.

CreateStoredProcedureQuery(string, FeedOptions)

Overloaded. This method creates a query for stored procedures under a collection in an Azure Cosmos DB service. It returns An IOrderedQueryable{StoredProcedure}.

public IOrderedQueryable<StoredProcedure> CreateStoredProcedureQuery(string collectionLink, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<StoredProcedure>: An IOrderedQueryable{StoredProcedure} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for stored procedures by id.

StoredProcedure storedProcedure = client.CreateStoredProcedureQuery(collectionLink).Where(c => c.Id == "helloWorld").AsEnumerable().FirstOrDefault();

See Also: StoredProcedure

IDocumentQuery

CreateStoredProcedureQuery(string, SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for stored procedures under a collection in an Azure Cosmos DB database using a SQL statement using a SQL statement with parameterized values. It returns an IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<dynamic> CreateStoredProcedureQuery(string collectionLink, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{dynamic} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for stored procedures by id.

var query = new SqlQuerySpec("SELECT * FROM sprocs s WHERE s.id = @id", new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@id", Value = "HelloWorld" }}));
StoredProcedure storedProcedure = client.CreateStoredProcedureQuery(collectionLink, query).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: StoredProcedure

CreateStoredProcedureQuery(string, string, FeedOptions)

Overloaded. This method creates a query for stored procedures under a collection in an Azure Cosmos DB database using a SQL statement. It returns an IQueryable{dynamic}.

public IQueryable<dynamic> CreateStoredProcedureQuery(string collectionLink, string sqlExpression, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{dynamic} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for stored procedures by id.

StoredProcedure storedProcedure = client.CreateStoredProcedureQuery(collectionLink, "SELECT * FROM sprocs s WHERE s.id = 'HelloWorld'").AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: StoredProcedure

CreateStoredProcedureQuery(Uri, FeedOptions)

Extension method to create query for stored procedures in the Azure Cosmos DB service.

public IOrderedQueryable<StoredProcedure> CreateStoredProcedureQuery(Uri storedProceduresUri, FeedOptions feedOptions = null)

Parameters

storedProceduresUri Uri: the URI to the stored procedures.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IOrderedQueryable<StoredProcedure>: The query result set.

CreateStoredProcedureQuery(Uri, SqlQuerySpec, FeedOptions)

Extension method to create query for stored procedures in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateStoredProcedureQuery(Uri storedProceduresUri, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

storedProceduresUri Uri: the URI to the stored procedures.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateStoredProcedureQuery(Uri, string, FeedOptions)

Extension method to create query for stored procedures in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateStoredProcedureQuery(Uri storedProceduresUri, string sqlExpression, FeedOptions feedOptions = null)

Parameters

storedProceduresUri Uri: the URI to the stored procedures.
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateTriggerAsync(string, Trigger, RequestOptions)

Creates a trigger as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Trigger>> CreateTriggerAsync(string collectionLink, Trigger trigger, RequestOptions options = null)

Parameters

collectionLink string: The link of the DocumentCollection to create the trigger in. E.g. dbs/db_rid/colls/col_rid/
trigger Trigger: The Trigger object to create.
options RequestOptions: (Optional) Any RequestOptionsfor this request.

Returns

Task<ResourceResponse<Trigger>>: A task object representing the service response for the asynchronous operation.

Examples

//Create a trigger that validates the contents of a document as it is created and adds a 'timestamp' property if one was not found.
Trigger trig = await client.CreateTriggerAsync(collectionLink, new Trigger
{
    Id = "ValidateDocuments",
    Body = @"function validate() {
                        var context = getContext();
                        var request = context.getRequest();                                                             
                        var documentToCreate = request.getBody();

                        // validate properties
                        if (!('timestamp' in documentToCreate)) {
                            var ts = new Date();
                            documentToCreate['timestamp'] = ts.getTime();
                        }

                        // update the document that will be created
                        request.setBody(documentToCreate);
                      }",
    TriggerType = TriggerType.Pre,
    TriggerOperation = TriggerOperation.Create
});

Exceptions

If either collectionLink or trigger is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied. It is likely that an Id was not supplied for the new trigger or that the Body was malformed.
403	Forbidden - You have reached your quota of triggers for the collection supplied. Contact support to have this quota increased.
409	Conflict - This means a Trigger with an id matching the id you supplied already existed.
413	RequestEntityTooLarge - This means the body of the Trigger you tried to create was too large.

See Also: Trigger

RequestOptions

ResourceResponse<TResource>

Task

CreateTriggerAsync(Uri, Trigger, RequestOptions)

Creates a trigger as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Trigger>> CreateTriggerAsync(Uri documentCollectionUri, Trigger trigger, RequestOptions options = null)

Parameters

documentCollectionUri Uri: the URI of the document collection to create the trigger in.
trigger Trigger: the Microsoft.Azure.Documents.Trigger object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Trigger>>: The task object representing the service response for the asynchronous operation.

CreateTriggerQuery(string, FeedOptions)

Overloaded. This method creates a query for triggers under a collection in an Azure Cosmos DB service. It returns An IOrderedQueryable{Trigger}.

public IOrderedQueryable<Trigger> CreateTriggerQuery(string collectionLink, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<Trigger>: An IOrderedQueryable{Trigger} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for triggers by id.

Trigger trigger = client.CreateTriggerQuery(collectionLink).Where(t => t.Id == "validate").AsEnumerable().FirstOrDefault();

See Also: Trigger

IDocumentQuery

CreateTriggerQuery(string, SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for triggers under a collection in an Azure Cosmos DB database using a SQL statement with parameterized values. It returns an IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<dynamic> CreateTriggerQuery(string collectionLink, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{Trigger} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for triggers by id.

var query = new SqlQuerySpec("SELECT * FROM triggers t WHERE t.id = @id", new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@id", Value = "HelloWorld" }}));
Trigger trigger = client.CreateTriggerQuery(collectionLink, query).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Trigger

IDocumentQuery

CreateTriggerQuery(string, string, FeedOptions)

Overloaded. This method creates a query for triggers under a collection in an Azure Cosmos DB service. It returns an IQueryable{dynamic}.

public IQueryable<dynamic> CreateTriggerQuery(string collectionLink, string sqlExpression, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{dynamic} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for triggers by id.

Trigger trigger = client.CreateTriggerQuery(collectionLink, "SELECT * FROM triggers t WHERE t.id = 'validate'").AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: Trigger

IDocumentQuery

CreateTriggerQuery(Uri, FeedOptions)

Extension method to create query for triggers in the Azure Cosmos DB service.

public IOrderedQueryable<Trigger> CreateTriggerQuery(Uri triggersUri, FeedOptions feedOptions = null)

Parameters

triggersUri Uri: the URI to the triggers.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IOrderedQueryable<Trigger>: The query result set.

CreateTriggerQuery(Uri, SqlQuerySpec, FeedOptions)

Extension method to create query for triggers in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateTriggerQuery(Uri triggersUri, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

triggersUri Uri: the URI to the triggers.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateTriggerQuery(Uri, string, FeedOptions)

Extension method to create query for triggers in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateTriggerQuery(Uri triggersUri, string sqlExpression, FeedOptions feedOptions = null)

Parameters

triggersUri Uri: the URI to the triggers.
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateUserAsync(string, User, RequestOptions)

Creates a user object as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<User>> CreateUserAsync(string databaseLink, User user, RequestOptions options = null)

Parameters

databaseLink string: The link of the database to create the user in. E.g. dbs/db_rid/
user User: The User object to create.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<User>>: A task object representing the service response for the asynchronous operation which contains the created User object.

Examples

//Create a new user called joeBloggs in the specified database
User user = await client.CreateUserAsync(databaseLink, new User { Id = "joeBloggs" });

Exceptions

If either databaseLink or user is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied.
403	Forbidden - You have reached your quota of user objects for this database. Contact support to have this quota increased.
409	Conflict - This means a User with an id matching the id you supplied already existed.

See Also: User

RequestOptions

ResourceResponse<TResource>

Task

CreateUserAsync(Uri, User, RequestOptions)

Creates a user as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<User>> CreateUserAsync(Uri databaseUri, User user, RequestOptions options = null)

Parameters

databaseUri Uri: the URI of the database to create the user in.
user User: the Microsoft.Azure.Documents.User object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<User>>: The task object representing the service response for the asynchronous operation.

CreateUserDefinedFunctionAsync(string, UserDefinedFunction, RequestOptions)

Creates a user defined function as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<UserDefinedFunction>> CreateUserDefinedFunctionAsync(string collectionLink, UserDefinedFunction function, RequestOptions options = null)

Parameters

collectionLink string: The link of the DocumentCollection to create the user defined function in. E.g. dbs/db_rid/colls/col_rid/
function UserDefinedFunction: The UserDefinedFunction object to create.
options RequestOptions: (Optional) Any RequestOptionsfor this request.

Returns

Task<ResourceResponse<UserDefinedFunction>>: A task object representing the service response for the asynchronous operation.

Examples

//Create a user defined function that converts a string to upper case
UserDefinedFunction udf = client.CreateUserDefinedFunctionAsync(collectionLink, new UserDefinedFunction
{
   Id = "ToUpper",
   Body = @"function toUpper(input) {
                       return input.toUpperCase();
                    }",
});

Exceptions

If either collectionLink or function is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied. It is likely that an Id was not supplied for the new user defined function or that the Body was malformed.
403	Forbidden - You have reached your quota of user defined functions for the collection supplied. Contact support to have this quota increased.
409	Conflict - This means a UserDefinedFunction with an id matching the id you supplied already existed.
413	RequestEntityTooLarge - This means the body of the UserDefinedFunction you tried to create was too large.

See Also: UserDefinedFunction

RequestOptions

ResourceResponse<TResource>

Task

CreateUserDefinedFunctionAsync(Uri, UserDefinedFunction, RequestOptions)

Creates a user defined function as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<UserDefinedFunction>> CreateUserDefinedFunctionAsync(Uri documentCollectionUri, UserDefinedFunction function, RequestOptions options = null)

Parameters

documentCollectionUri Uri: the URI of the document collection to create the user defined function in.
function UserDefinedFunction: the Microsoft.Azure.Documents.UserDefinedFunction object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<UserDefinedFunction>>: The task object representing the service response for the asynchronous operation.

CreateUserDefinedFunctionQuery(string, FeedOptions)

Overloaded. This method creates a query for udfs under a collection in an Azure Cosmos DB service. It returns An IOrderedQueryable{UserDefinedFunction}.

public IOrderedQueryable<UserDefinedFunction> CreateUserDefinedFunctionQuery(string collectionLink, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<UserDefinedFunction>: An IOrderedQueryable{UserDefinedFunction} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for user-defined functions by id.

UserDefinedFunction udf = client.CreateUserDefinedFunctionQuery(collectionLink).Where(u => u.Id == "sqrt").AsEnumerable().FirstOrDefault();

See Also: UserDefinedFunction

IDocumentQuery

CreateUserDefinedFunctionQuery(string, SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for udfs under a collection in an Azure Cosmos DB database with parameterized values. It returns an IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<dynamic> CreateUserDefinedFunctionQuery(string collectionLink, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{dynamic} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for user-defined functions by id.

var query = new SqlQuerySpec("SELECT * FROM udfs u WHERE u.id = @id", new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@id", Value = "sqrt" }}));
UserDefinedFunction udf = client.CreateUserDefinedFunctionQuery(collectionLink, query).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: UserDefinedFunction

IDocumentQuery

CreateUserDefinedFunctionQuery(string, string, FeedOptions)

Overloaded. This method creates a query for udfs under a collection in an Azure Cosmos DB database using a SQL statement. It returns an IQueryable{dynamic}.

public IQueryable<dynamic> CreateUserDefinedFunctionQuery(string collectionLink, string sqlExpression, FeedOptions feedOptions = null)

Parameters

collectionLink string: The link to the parent collection resource.
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: An IQueryable{dynamic} that can evaluate the query with the provided SQL statement.

Examples

This example below queries for user-defined functions by id.

UserDefinedFunction udf = client.CreateUserDefinedFunctionQuery(collectionLink, "SELECT * FROM udfs u WHERE u.id = 'sqrt'").AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: UserDefinedFunction

IDocumentQuery

CreateUserDefinedFunctionQuery(Uri, FeedOptions)

Extension method to create a query for user-defined functions in the Azure Cosmos DB service.

public IOrderedQueryable<UserDefinedFunction> CreateUserDefinedFunctionQuery(Uri userDefinedFunctionsUri, FeedOptions feedOptions = null)

Parameters

userDefinedFunctionsUri Uri: the URI to the user-defined functions.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IOrderedQueryable<UserDefinedFunction>: The query result set.

CreateUserDefinedFunctionQuery(Uri, SqlQuerySpec, FeedOptions)

Extension method to create a query for user-defined functions in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateUserDefinedFunctionQuery(Uri userDefinedFunctionsUri, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

userDefinedFunctionsUri Uri: the URI to the user-defined functions.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateUserDefinedFunctionQuery(Uri, string, FeedOptions)

Extension method to create a query for user-defined functions in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateUserDefinedFunctionQuery(Uri userDefinedFunctionsUri, string sqlExpression, FeedOptions feedOptions = null)

Parameters

userDefinedFunctionsUri Uri: the URI to the user-defined functions.
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateUserQuery(string, FeedOptions)

Overloaded. This method creates a query for users under an Azure Cosmos DB service. It returns IOrderedQueryable{User}.

public IOrderedQueryable<User> CreateUserQuery(string usersLink, FeedOptions feedOptions = null)

Parameters

usersLink string: The path link for the users under a database, e.g. dbs/db_rid/users/.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IOrderedQueryable<User>: An IOrderedQueryable{User} that can evaluate the query.

Examples

This example below queries for users by id.

User user = client.CreateUserQuery(usersLink).Where(u => u.Id == "userid5").AsEnumerable().FirstOrDefault();

See Also: User

IDocumentQuery

CreateUserQuery(string, SqlQuerySpec, FeedOptions)

Overloaded. This method creates a query for users under an Azure Cosmos DB database using a SQL statement with parameterized values. It returns an IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

public IQueryable<dynamic> CreateUserQuery(string usersLink, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

usersLink string: The path link for the users under a database, e.g. dbs/db_rid/users/.
querySpec SqlQuerySpec: The SqlQuerySpec instance containing the SQL expression.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: an IQueryable{dynamic> that can evaluate the query.

Examples

This example below queries for users by id.

var query = new SqlQuerySpec(
    "SELECT * FROM users u WHERE u.id = @id", 
    new SqlParameterCollection(new SqlParameter[] { new SqlParameter { Name = "@id", Value = "userid5" }}));

User user = client.CreateUserQuery(usersLink, query).AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: User

IDocumentQuery

CreateUserQuery(string, string, FeedOptions)

Overloaded. This method creates a query for users under an Azure Cosmos DB service. It returns IQueryable{dynamic}.

public IQueryable<dynamic> CreateUserQuery(string usersLink, string sqlExpression, FeedOptions feedOptions = null)

Parameters

usersLink string: The path link for the users under a database, e.g. dbs/db_rid/users/.
sqlExpression string: The SQL statement.
feedOptions FeedOptions: The options for processing the query result feed. For details, see FeedOptions

Returns

IQueryable<dynamic>: an IQueryable{dynamic} that can evaluate the query.

Examples

This example below queries for users by id.

User user = client.CreateUserQuery(usersLink, "SELECT * FROM users u WHERE u.id = 'userid5'").AsEnumerable().FirstOrDefault();

Remarks

Refer to https://msdn.microsoft.com/en-us/library/azure/dn782250.aspx and http://azure.microsoft.com/documentation/articles/documentdb-sql-query/ for syntax and examples.

See Also: User

IDocumentQuery

CreateUserQuery(Uri, FeedOptions)

Extension method to create a query for users in the Azure Cosmos DB service.

public IOrderedQueryable<User> CreateUserQuery(Uri usersUri, FeedOptions feedOptions = null)

Parameters

usersUri Uri: the URI to the users.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IOrderedQueryable<User>: The query result set.

CreateUserQuery(Uri, SqlQuerySpec, FeedOptions)

Extension method to create a query for users in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateUserQuery(Uri usersUri, SqlQuerySpec querySpec, FeedOptions feedOptions = null)

Parameters

usersUri Uri: the URI to the users.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateUserQuery(Uri, string, FeedOptions)

Extension method to create a query for users in the Azure Cosmos DB service.

public IQueryable<dynamic> CreateUserQuery(Uri usersUri, string sqlExpression, FeedOptions feedOptions = null)

Parameters

usersUri Uri: the URI to the users.
sqlExpression string: The sql query.
feedOptions FeedOptions: The options for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

DeleteAttachmentAsync(string, RequestOptions, CancellationToken)

Delete an Attachment from the the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Attachment>> DeleteAttachmentAsync(string attachmentLink, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

attachmentLink string: The link of the Attachment to delete. E.g. dbs/db_rid/colls/col_rid/docs/doc_rid/attachments/attachment_rid/
options RequestOptions: (Optional) Any options you wish to set for this request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Attachment>>

Examples

//Delete an attachment using its selfLink property
//To get the attachmentLink you would have to query for the Attachment, using CreateAttachmentQuery(),  and then refer to its .SelfLink property
await client.DeleteAttachmentAsync(attachmentLink);

Exceptions

If attachmentLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Attachment

RequestOptions

ResourceResponse<TResource>

Task

DeleteAttachmentAsync(Uri, RequestOptions, CancellationToken)

Delete an attachment as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Attachment>> DeleteAttachmentAsync(Uri attachmentUri, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

attachmentUri Uri: the URI of the attachment to delete.
options RequestOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Attachment>>: The task object representing the service response for the asynchronous operation.

DeleteConflictAsync(string, RequestOptions)

Delete a Conflict from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Conflict>> DeleteConflictAsync(string conflictLink, RequestOptions options = null)

Parameters

conflictLink string: The link of the Conflict to delete. E.g. dbs/db_rid/colls/coll_rid/conflicts/
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Conflict>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which will contain information about the request issued.

Examples

//Delete a conflict using its selfLink property.
//To get the conflictLink you would have to query for the Conflict object, using CreateConflictQuery(), and then refer to its .SelfLink property
await client.DeleteConflictAsync(conflictLink);

Exceptions

If conflictLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Conflict

RequestOptions

ResourceResponse<TResource>

Task

DeleteConflictAsync(Uri, RequestOptions)

Delete a conflict as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Conflict>> DeleteConflictAsync(Uri conflictUri, RequestOptions options = null)

Parameters

conflictUri Uri: the URI of the conflict to delete.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Conflict>>: The task object representing the service response for the asynchronous operation.

DeleteDatabaseAsync(string, RequestOptions)

Delete a Database from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Database>> DeleteDatabaseAsync(string databaseLink, RequestOptions options = null)

Parameters

databaseLink string: The link of the Database to delete. E.g. dbs/db_rid/
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Database>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which will contain information about the request issued.

Examples

//Delete a database using its selfLink property
//To get the databaseLink you would have to query for the Database, using CreateDatabaseQuery(),  and then refer to its .SelfLink property
await client.DeleteDatabaseAsync(databaseLink);

Exceptions

If databaseLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Database

RequestOptions

ResourceResponse<TResource>

Task

DeleteDatabaseAsync(Uri, RequestOptions)

Delete a database as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Database>> DeleteDatabaseAsync(Uri databaseUri, RequestOptions options = null)

Parameters

databaseUri Uri: the URI of the database to delete.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Database>>: The task object representing the service response for the asynchronous operation.

DeleteDocumentAsync(string, RequestOptions, CancellationToken)

Delete a Document from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Document>> DeleteDocumentAsync(string documentLink, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentLink string: The link of the Document to delete. E.g. dbs/db_rid/colls/col_rid/docs/doc_rid/
options RequestOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Document>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which will contain information about the request issued.

Examples

//Delete a document using its selfLink property
//To get the documentLink you would have to query for the Document, using CreateDocumentQuery(),  and then refer to its .SelfLink property
await client.DeleteDocumentAsync(documentLink);

Exceptions

If documentLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Database

RequestOptions

ResourceResponse<TResource>

Task

DeleteDocumentAsync(Uri, RequestOptions, CancellationToken)

Delete a document as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Document>> DeleteDocumentAsync(Uri documentUri, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentUri Uri: the URI of the document to delete.
options RequestOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Document>>: The task object representing the service response for the asynchronous operation.

DeleteDocumentCollectionAsync(string, RequestOptions)

Delete a DocumentCollection from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<DocumentCollection>> DeleteDocumentCollectionAsync(string documentCollectionLink, RequestOptions options = null)

Parameters

documentCollectionLink string: The link of the Document to delete. E.g. dbs/db_rid/colls/col_rid/
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<DocumentCollection>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which will contain information about the request issued.

Examples

//Delete a collection using its selfLink property
//To get the collectionLink you would have to query for the Collection, using CreateDocumentCollectionQuery(),  and then refer to its .SelfLink property
await client.DeleteDocumentCollectionAsync(collectionLink);

Exceptions

If documentCollectionLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: DocumentCollection

RequestOptions

ResourceResponse<TResource>

Task

DeleteDocumentCollectionAsync(Uri, RequestOptions)

Delete a collection as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<DocumentCollection>> DeleteDocumentCollectionAsync(Uri documentCollectionUri, RequestOptions options = null)

Parameters

documentCollectionUri Uri: the URI of the document collection to delete.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<DocumentCollection>>: The task object representing the service response for the asynchronous operation.

DeletePermissionAsync(string, RequestOptions)

Delete a Permission from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Permission>> DeletePermissionAsync(string permissionLink, RequestOptions options = null)

Parameters

permissionLink string: The link of the Permission to delete. E.g. dbs/db_rid/users/user_rid/permissions/permission_rid/
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Permission>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which will contain information about the request issued.

Examples

//Delete a permission using its selfLink property.
//To get the permissionLink you would have to query for the Permission object, using CreateStoredProcedureQuery(), and then refer to its .SelfLink property
await client.DeletePermissionAsync(permissionLink);

Exceptions

If permissionLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Permission

RequestOptions

ResourceResponse<TResource>

Task

DeletePermissionAsync(Uri, RequestOptions)

Delete a permission as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Permission>> DeletePermissionAsync(Uri permissionUri, RequestOptions options = null)

Parameters

permissionUri Uri: the URI of the permission to delete.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Permission>>: The task object representing the service response for the asynchronous operation.

DeleteStoredProcedureAsync(string, RequestOptions)

Delete a StoredProcedure from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<StoredProcedure>> DeleteStoredProcedureAsync(string storedProcedureLink, RequestOptions options = null)

Parameters

storedProcedureLink string: The link of the StoredProcedure to delete. E.g. dbs/db_rid/colls/col_rid/sprocs/sproc_rid/
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<StoredProcedure>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which will contain information about the request issued.

Examples

//Delete a stored procedure using its selfLink property.
//To get the sprocLink you would have to query for the Stored Procedure, using CreateStoredProcedureQuery(),  and then refer to its .SelfLink property
await client.DeleteStoredProcedureAsync(sprocLink);

Exceptions

If storedProcedureLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: StoredProcedure

RequestOptions

ResourceResponse<TResource>

Task

DeleteStoredProcedureAsync(Uri, RequestOptions)

Delete a stored procedure as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<StoredProcedure>> DeleteStoredProcedureAsync(Uri storedProcedureUri, RequestOptions options = null)

Parameters

storedProcedureUri Uri: the URI of the stored procedure to delete.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<StoredProcedure>>: The task object representing the service response for the asynchronous operation.

DeleteTriggerAsync(string, RequestOptions)

Delete a Trigger from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Trigger>> DeleteTriggerAsync(string triggerLink, RequestOptions options = null)

Parameters

triggerLink string: The link of the Trigger to delete. E.g. dbs/db_rid/colls/col_rid/triggers/trigger_rid/
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Trigger>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which will contain information about the request issued.

Examples

//Delete a trigger using its selfLink property.
//To get the triggerLink you would have to query for the Trigger, using CreateTriggerQuery(),  and then refer to its .SelfLink property
await client.DeleteTriggerAsync(triggerLink);

Exceptions

If triggerLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Trigger

RequestOptions

ResourceResponse<TResource>

Task

DeleteTriggerAsync(Uri, RequestOptions)

Delete a trigger as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Trigger>> DeleteTriggerAsync(Uri triggerUri, RequestOptions options = null)

Parameters

triggerUri Uri: the URI of the trigger to delete.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Trigger>>: The task object representing the service response for the asynchronous operation.

DeleteUserAsync(string, RequestOptions)

Delete a User from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<User>> DeleteUserAsync(string userLink, RequestOptions options = null)

Parameters

userLink string: The link of the User to delete. E.g. dbs/db_rid/users/user_rid/
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<User>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which will contain information about the request issued.

Examples

//Delete a user using its selfLink property.
//To get the userLink you would have to query for the User object, using CreateUserQuery(), and then refer to its .SelfLink property
await client.DeleteUserAsync(userLink);

Exceptions

If userLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Permission

RequestOptions

ResourceResponse<TResource>

Task

DeleteUserAsync(Uri, RequestOptions)

Delete a user as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<User>> DeleteUserAsync(Uri userUri, RequestOptions options = null)

Parameters

userUri Uri: the URI of the user to delete.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<User>>: The task object representing the service response for the asynchronous operation.

DeleteUserDefinedFunctionAsync(string, RequestOptions)

Delete a UserDefinedFunction from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<UserDefinedFunction>> DeleteUserDefinedFunctionAsync(string functionLink, RequestOptions options = null)

Parameters

functionLink string: The link of the UserDefinedFunction to delete. E.g. dbs/db_rid/colls/col_rid/udfs/udf_rid/
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<UserDefinedFunction>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which will contain information about the request issued.

Examples

//Delete a user defined function using its selfLink property.
//To get the functionLink you would have to query for the User Defined Function, using CreateUserDefinedFunctionQuery(),  and then refer to its .SelfLink property
await client.DeleteUserDefinedFunctionAsync(functionLink);

Exceptions

If functionLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: UserDefinedFunction

RequestOptions

ResourceResponse<TResource>

Task

DeleteUserDefinedFunctionAsync(Uri, RequestOptions)

Delete a user defined function as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<UserDefinedFunction>> DeleteUserDefinedFunctionAsync(Uri functionUri, RequestOptions options = null)

Parameters

functionUri Uri: the URI of the user defined function to delete.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<UserDefinedFunction>>: The task object representing the service response for the asynchronous operation.

Dispose()

Disposes the client for the Azure Cosmos DB service.

public void Dispose()

Examples

IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key");
if (client != null) client.Dispose();

ExecuteStoredProcedureAsync<TValue>(string, RequestOptions, params dynamic[])

Executes a stored procedure against a partitioned collection in the Azure Cosmos DB service as an asynchronous operation, specifiying a target partition.

public Task<StoredProcedureResponse<TValue>> ExecuteStoredProcedureAsync<TValue>(string storedProcedureLink, RequestOptions options, params dynamic[] procedureParams)

Parameters

storedProcedureLink string: The link to the stored procedure to execute.
options RequestOptions: (Optional) The request options for the request.
procedureParams dynamic[]: (Optional) An array of dynamic objects representing the parameters for the stored procedure.

Returns

Task<StoredProcedureResponse<TValue>>: The task object representing the service response for the asynchronous operation which would contain any response set in the stored procedure.

Type Parameters

TValue: The type of the stored procedure's return value.

Examples

//Execute a StoredProcedure with ResourceId of "sproc_rid" that takes two "Player" documents, does some stuff, and returns a bool
StoredProcedureResponse<bool> sprocResponse = await client.ExecuteStoredProcedureAsync<bool>(
                                                        "/dbs/db_rid/colls/col_rid/sprocs/sproc_rid/",
                                                        new RequestOptions { PartitionKey = new PartitionKey(1) },
                                                        new Player { id="1", name="joe" } ,
                                                        new Player { id="2", name="john" }
                                                    );

if (sprocResponse.Response) Console.WriteLine("Congrats, the stored procedure did some stuff");

Exceptions

ArgumentNullException: If storedProcedureLink is not set.

See Also: StoredProcedure

RequestOptions

StoredProcedureResponse<TValue>

Task

ExecuteStoredProcedureAsync<TValue>(string, RequestOptions, CancellationToken, params dynamic[])

Executes a stored procedure against a partitioned collection in the Azure Cosmos DB service as an asynchronous operation, specifiying a target partition.

public Task<StoredProcedureResponse<TValue>> ExecuteStoredProcedureAsync<TValue>(string storedProcedureLink, RequestOptions options, CancellationToken cancellationToken, params dynamic[] procedureParams)

Parameters

storedProcedureLink string: The link to the stored procedure to execute.
options RequestOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.
procedureParams dynamic[]: (Optional) An array of dynamic objects representing the parameters for the stored procedure.

Returns

Task<StoredProcedureResponse<TValue>>: The task object representing the service response for the asynchronous operation which would contain any response set in the stored procedure.

Type Parameters

TValue: The type of the stored procedure's return value.

Examples

//Execute a StoredProcedure with ResourceId of "sproc_rid" that takes two "Player" documents, does some stuff, and returns a bool
StoredProcedureResponse<bool> sprocResponse = await client.ExecuteStoredProcedureAsync<bool>(
                                                        "/dbs/db_rid/colls/col_rid/sprocs/sproc_rid/",
                                                        new RequestOptions { PartitionKey = new PartitionKey(1) },
                                                        new Player { id="1", name="joe" } ,
                                                        new Player { id="2", name="john" }
                                                    );

if (sprocResponse.Response) Console.WriteLine("Congrats, the stored procedure did some stuff");

Exceptions

ArgumentNullException: If storedProcedureLink is not set.

See Also: StoredProcedure

RequestOptions

StoredProcedureResponse<TValue>

Task

ExecuteStoredProcedureAsync<TValue>(string, params dynamic[])

Executes a stored procedure against a collection as an asynchronous operation in the Azure Cosmos DB service.

public Task<StoredProcedureResponse<TValue>> ExecuteStoredProcedureAsync<TValue>(string storedProcedureLink, params dynamic[] procedureParams)

Parameters

storedProcedureLink string: The link to the stored procedure to execute.
procedureParams dynamic[]: (Optional) An array of dynamic objects representing the parameters for the stored procedure.

Returns

Task<StoredProcedureResponse<TValue>>: The task object representing the service response for the asynchronous operation which would contain any response set in the stored procedure.

Type Parameters

TValue: The type of the stored procedure's return value.

Examples

//Execute a StoredProcedure with ResourceId of "sproc_rid" that takes two "Player" documents, does some stuff, and returns a bool
StoredProcedureResponse<bool> sprocResponse = await client.ExecuteStoredProcedureAsync<bool>(
                                                        "/dbs/db_rid/colls/col_rid/sprocs/sproc_rid/",
                                                        new Player { id="1", name="joe" } ,
                                                        new Player { id="2", name="john" }
                                                    );

if (sprocResponse.Response) Console.WriteLine("Congrats, the stored procedure did some stuff");

Exceptions

ArgumentNullException: If storedProcedureLink is not set.

See Also: StoredProcedure

StoredProcedureResponse<TValue>

Task

ExecuteStoredProcedureAsync<TValue>(Uri, RequestOptions, params dynamic[])

Executes a stored procedure against a collection as an asynchronous operation from the Azure Cosmos DB service.

public Task<StoredProcedureResponse<TValue>> ExecuteStoredProcedureAsync<TValue>(Uri storedProcedureUri, RequestOptions options, params dynamic[] procedureParams)

Parameters

storedProcedureUri Uri: the URI of the stored procedure to be executed.
options RequestOptions: The request options for the request.
procedureParams dynamic[]: the parameters for the stored procedure execution.

Returns

Task<StoredProcedureResponse<TValue>>: The task object representing the service response for the asynchronous operation.

Type Parameters

TValue: the type of the stored procedure's return value.

ExecuteStoredProcedureAsync<TValue>(Uri, RequestOptions, CancellationToken, params dynamic[])

Executes a stored procedure against a collection as an asynchronous operation from the Azure Cosmos DB service.

public Task<StoredProcedureResponse<TValue>> ExecuteStoredProcedureAsync<TValue>(Uri storedProcedureUri, RequestOptions options, CancellationToken cancellationToken = default, params dynamic[] procedureParams)

Parameters

storedProcedureUri Uri: the URI of the stored procedure to be executed.
options RequestOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.
procedureParams dynamic[]: the parameters for the stored procedure execution.

Returns

Task<StoredProcedureResponse<TValue>>: The task object representing the service response for the asynchronous operation.

Type Parameters

TValue: the type of the stored procedure's return value.

ExecuteStoredProcedureAsync<TValue>(Uri, params dynamic[])

Executes a stored procedure against a collection as an asynchronous operation from the Azure Cosmos DB service.

public Task<StoredProcedureResponse<TValue>> ExecuteStoredProcedureAsync<TValue>(Uri storedProcedureUri, params dynamic[] procedureParams)

Parameters

storedProcedureUri Uri: the URI of the stored procedure to be executed.
procedureParams dynamic[]: the parameters for the stored procedure execution.

Returns

Task<StoredProcedureResponse<TValue>>: The task object representing the service response for the asynchronous operation.

Type Parameters

TValue: the type of the stored procedure's return value.

GetDatabaseAccountAsync()

Read the DatabaseAccount from the Azure Cosmos DB service as an asynchronous operation.

public Task<DatabaseAccount> GetDatabaseAccountAsync()

Returns

Task<DatabaseAccount>: A DatabaseAccount wrapped in a Task object.

OpenAsync(CancellationToken)

Open the connection to validate that the client initialization is successful in the Azure Cosmos DB service.

public Task OpenAsync(CancellationToken cancellationToken = default)

Parameters

cancellationToken CancellationToken

Returns

Task: A Task object.

Examples

using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
{
    await client.OpenAsync();
}

Remarks

This method is recommended to be called, after the constructor, but before calling any other methods on the DocumentClient instance. If there are any initialization exceptions, this method will throw them (set on the task). Alternately, calling any API will throw initialization exception at the first call.

ReadAttachmentAsync(string, RequestOptions, CancellationToken)

Reads an Attachment from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Attachment>> ReadAttachmentAsync(string attachmentLink, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

attachmentLink string: The link to the attachment to be read.
options RequestOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Attachment>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Attachment containing the read resource record.

Examples

//Reads an Attachment resource where
// - sample_db is the ID property of the Database
// - sample_coll is the ID property of the DocumentCollection
// - sample_doc is the ID property of the Document
// - attachment_id is the ID property of the Attachment resource you wish to read.
var attachLink = "/dbs/sample_db/colls/sample_coll/docs/sample_doc/attachments/attachment_id/";
Attachment attachment = await client.ReadAttachmentAsync(attachLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the Database if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for attachmentLink is always "/dbs/{db identifier}/colls/{coll identifier}/docs/{doc identifier}/attachments/{attachment identifier}" only the values within the {} change depending on which method you wish to use to address the resource.

Exceptions

If attachmentLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Attachment

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadAttachmentAsync(Uri, RequestOptions, CancellationToken)

Reads an Attachment as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Attachment>> ReadAttachmentAsync(Uri attachmentUri, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

attachmentUri Uri: A URI to the Attachment resource to be read.
options RequestOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Attachment>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps an Attachment containing the read resource record.

Examples

//Reads an Attachment resource where 
// - db_id is the ID property of the Database
// - coll_id is the ID property of the DocumentCollection
// - doc_id is the ID property of the Document
// - attachment_id is the ID property of the Attachment resource you wish to read. 
var attachLink = UriFactory.CreateAttachmentUri("db_id", "coll_id", "doc_id", "attachment_id");
Attachment attachment = await client.ReadAttachmentAsync(attachLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If attachmentUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Attachment

RequestOptions

ResourceResponse<TResource>

Task

ReadAttachmentFeedAsync(string, FeedOptions, CancellationToken)

Reads the feed (sequence) of Attachment for a document from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<Attachment>> ReadAttachmentFeedAsync(string attachmentsLink, FeedOptions options = null, CancellationToken cancellationToken = default)

Parameters

attachmentsLink string: The SelfLink of the resources to be read. E.g. /dbs/db_rid/colls/coll_rid/docs/doc_rid/attachments/
options FeedOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<FeedResponse<Attachment>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Attachment containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read Attachment feed 10 items at a time until there are no more to read
    FeedResponse<Attachment> response = await client.ReadAttachmentFeedAsync("/dbs/db_rid/colls/coll_rid/docs/doc_rid/attachments/ ",
                                                    new FeedOptions
                                                    {
                                                        MaxItemCount = 10,
                                                        RequestContinuation = continuation
                                                    });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

If attachmentsLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource feed you tried to read did not exist. Check the parent rids are correct.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Attachment

RequestOptions

ResourceResponse<TResource>

Task

ReadAttachmentFeedAsync(Uri, FeedOptions, CancellationToken)

Reads the feed (sequence) of attachments for a document as an asynchronous operation from the Azure Cosmos DB service.

public Task<FeedResponse<Attachment>> ReadAttachmentFeedAsync(Uri attachmentsUri, FeedOptions options = null, CancellationToken cancellationToken = default)

Parameters

attachmentsUri Uri: the URI for the attachments.
options FeedOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<FeedResponse<Attachment>>: The task object representing the service response for the asynchronous operation.

ReadConflictAsync(string, RequestOptions)

Reads a Conflict from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Conflict>> ReadConflictAsync(string conflictLink, RequestOptions options = null)

Parameters

conflictLink string: The link to the Conflict to be read.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Conflict>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Conflict containing the read resource record.

Examples

//Reads a Conflict resource from a Database
// - sample_database is the ID of the database
// - sample_collection is the ID of the collection
// - conflict_id is the ID of the conflict to be read
var conflictLink = "/dbs/sample_database/colls/sample_collection/conflicts/conflict_id";
Conflict conflict = await client.ReadConflictAsync(conflictLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the Conflict if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for conflictLink is always "/dbs/{db identifier}/colls/{collectioon identifier}/conflicts/{conflict identifier}" only the values within the {...} change depending on which method you wish to use to address the resource.

Exceptions

If conflictLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Conflict

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadConflictAsync(Uri, RequestOptions)

Reads a Conflict as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Conflict>> ReadConflictAsync(Uri conflictUri, RequestOptions options = null)

Parameters

conflictUri Uri: A URI to the Conflict resource to be read.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Conflict>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Conflict containing the read resource record.

Examples

//Reads a Conflict resource where 
// - db_id is the ID property of the Database
// - coll_id is the ID property of the DocumentCollection
// - conflict_id is the ID property of the Conflict you wish to read. 
var conflictLink = UriFactory.CreateConflictUri("db_id", "coll_id", "conflict_id");
Conflict conflict = await client.ReadConflictAsync(conflictLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If conflictUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Conflict

RequestOptions

ResourceResponse<TResource>

Task

ReadConflictFeedAsync(string, FeedOptions)

Reads the feed (sequence) of Conflict for a collection from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<Conflict>> ReadConflictFeedAsync(string conflictsLink, FeedOptions options = null)

Parameters

conflictsLink string: The SelfLink of the resources to be read. E.g. /dbs/db_rid/colls/coll_rid/conflicts/
options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<Conflict>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Conflict containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<Conflict> response = await client.ReadConflictAsync("/dbs/db_rid/colls/coll_rid/conflicts/",
                                                    new FeedOptions
                                                    {
                                                        MaxItemCount = 10,
                                                        RequestContinuation = continuation
                                                    });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

If conflictsLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource feed you tried to read did not exist. Check the parent rids are correct.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Conflict

RequestOptions

ResourceResponse<TResource>

Task

ReadConflictFeedAsync(Uri, FeedOptions)

Reads the feed (sequence) of conflicts for a collection as an asynchronous operation from the Azure Cosmos DB service.

public Task<FeedResponse<Conflict>> ReadConflictFeedAsync(Uri conflictsUri, FeedOptions options = null)

Parameters

conflictsUri Uri: the URI for the conflicts.
options FeedOptions: The request options for the request.

Returns

Task<FeedResponse<Conflict>>: The task object representing the service response for the asynchronous operation.

ReadDatabaseAsync(string, RequestOptions)

Reads a Database from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Database>> ReadDatabaseAsync(string databaseLink, RequestOptions options = null)

Parameters

databaseLink string: The link of the Database resource to be read.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Database>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Database containing the read resource record.

Examples

//Reads a Database resource where
// - database_id is the ID property of the Database resource you wish to read.
var dbLink = "/dbs/database_id";
Database database = await client.ReadDatabaseAsync(dbLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the Database if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for databaseLink is always "/dbs/{db identifier}" only the values within the {} change depending on which method you wish to use to address the resource.

Exceptions

If databaseLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Database

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadDatabaseAsync(Uri, RequestOptions)

Reads a Database as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Database>> ReadDatabaseAsync(Uri databaseUri, RequestOptions options = null)

Parameters

databaseUri Uri: A URI to the Database resource to be read.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Database>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Database containing the read resource record.

Examples

//Reads a Database resource where 
// - db_id is the ID property of the Database you wish to read. 
var dbLink = UriFactory.CreateDatabaseUri("db_id");
Database database = await client.ReadDatabaseAsync(dbLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If databaseUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Database

RequestOptions

ResourceResponse<TResource>

Task

ReadDatabaseFeedAsync(FeedOptions)

Reads the feed (sequence) of Database for a database account from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<Database>> ReadDatabaseFeedAsync(FeedOptions options = null)

Parameters

options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<Database>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Database containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<Database> response = await client.ReadDatabaseFeedAsync(new FeedOptions
                                                                {
                                                                    MaxItemCount = 10,
                                                                    RequestContinuation = continuation
                                                                });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Database

RequestOptions

ResourceResponse<TResource>

Task

ReadDocumentAsync(string, RequestOptions, CancellationToken)

Reads a Document from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Document>> ReadDocumentAsync(string documentLink, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentLink string: The link for the document to be read.
options RequestOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Document>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Document containing the read resource record.

Examples

//This reads a document record from a database & collection where
// - sample_database is the ID of the database
// - sample_collection is the ID of the collection
// - document_id is the ID of the document resource
var docLink = "dbs/sample_database/colls/sample_collection/docs/document_id";
Document doc = await client.ReadDocumentAsync(docLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the Document if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for documentLink is always "dbs/{db identifier}/colls/{coll identifier}/docs/{doc identifier}" only the values within the {} change depending on which method you wish to use to address the resource.

Exceptions

If documentLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Document

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadDocumentAsync(Uri, RequestOptions, CancellationToken)

Reads a Document as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Document>> ReadDocumentAsync(Uri documentUri, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentUri Uri: A URI to the Document resource to be read.
options RequestOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Document>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Document containing the read resource record.

Examples

//Reads a Document resource where 
// - db_id is the ID property of the Database
// - coll_id is the ID property of the DocumentCollection
// - doc_id is the ID property of the Document you wish to read. 
var docUri = UriFactory.CreateDocumentUri("db_id", "coll_id", "doc_id");
Document document = await client.ReadDocumentAsync(docUri);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If documentUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when reading a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Document

RequestOptions

ResourceResponse<TResource>

Task

ReadDocumentAsync<T>(string, RequestOptions, CancellationToken)

Reads a Document as a generic type T from the Azure Cosmos DB service as an asynchronous operation.

public Task<DocumentResponse<T>> ReadDocumentAsync<T>(string documentLink, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentLink string: The link for the document to be read.
options RequestOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<DocumentResponse<T>>: A System.Threading.Tasks containing a DocumentResponse<TDocument> which wraps a Document containing the read resource record.

Type Parameters

T

Examples

//This reads a document record from a database & collection where
// - sample_database is the ID of the database
// - sample_collection is the ID of the collection
// - document_id is the ID of the document resource
var docLink = "dbs/sample_database/colls/sample_collection/docs/document_id";
Customer customer = await client.ReadDocumentAsync<Customer>(docLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If documentLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Document

RequestOptions

DocumentResponse<TDocument>

Task

Uri

ReadDocumentAsync<T>(Uri, RequestOptions, CancellationToken)

Reads a Document as a generic type T from the Azure Cosmos DB service as an asynchronous operation.

public Task<DocumentResponse<T>> ReadDocumentAsync<T>(Uri documentUri, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentUri Uri: A URI to the Document resource to be read.
options RequestOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<DocumentResponse<T>>: A System.Threading.Tasks containing a DocumentResponse<TDocument> which wraps a Document containing the read resource record.

Type Parameters

T

Examples

//Reads a Document resource where 
// - db_id is the ID property of the Database
// - coll_id is the ID property of the DocumentCollection
// - doc_id is the ID property of the Document you wish to read. 
var docUri = UriFactory.CreateDocumentUri("db_id", "coll_id", "doc_id");
Customer customer = await client.ReadDocumentAsync<Customer>(docUri);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If documentUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when reading a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Document

RequestOptions

DocumentResponse<TDocument>

Task

ReadDocumentCollectionAsync(string, RequestOptions)

Reads a DocumentCollection from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<DocumentCollection>> ReadDocumentCollectionAsync(string documentCollectionLink, RequestOptions options = null)

Parameters

documentCollectionLink string: The link for the DocumentCollection to be read.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<DocumentCollection>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a DocumentCollection containing the read resource record.

Examples

//This reads a DocumentCollection record from a database where
// - sample_database is the ID of the database
// - collection_id is the ID of the collection resource to be read
var collLink = "/dbs/sample_database/colls/collection_id";
DocumentCollection coll = await client.ReadDocumentCollectionAsync(collLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the DocumentCollection if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for documentCollectionLink is always "/dbs/{db identifier}/colls/{coll identifier}" only the values within the {} change depending on which method you wish to use to address the resource.

Exceptions

If documentCollectionLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: DocumentCollection

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadDocumentCollectionAsync(Uri, RequestOptions)

Reads a DocumentCollection as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<DocumentCollection>> ReadDocumentCollectionAsync(Uri documentCollectionUri, RequestOptions options = null)

Parameters

documentCollectionUri Uri: A URI to the DocumentCollection resource to be read.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<DocumentCollection>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a DocumentCollection containing the read resource record.

Examples

//Reads a Document resource where 
// - db_id is the ID property of the Database
// - coll_id is the ID property of the DocumentCollection you wish to read. 
var collLink = UriFactory.CreateCollectionUri("db_id", "coll_id");
DocumentCollection coll = await client.ReadDocumentCollectionAsync(collLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If documentCollectionUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: DocumentCollection

RequestOptions

ResourceResponse<TResource>

Task

ReadDocumentCollectionFeedAsync(string, FeedOptions)

Reads the feed (sequence) of DocumentCollection for a database from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<DocumentCollection>> ReadDocumentCollectionFeedAsync(string collectionsLink, FeedOptions options = null)

Parameters

collectionsLink string: The SelfLink of the resources to be read. E.g. /dbs/db_rid/colls/
options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<DocumentCollection>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a DocumentCollection containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<DocumentCollection> response = await client.ReadDocumentCollectionFeedAsync("/dbs/db_rid/colls/",
                                                    new FeedOptions
                                                    {
                                                        MaxItemCount = 10,
                                                        RequestContinuation = continuation
                                                    });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

If collectionsLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource feed you tried to read did not exist. Check the parent rids are correct.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: DocumentCollection

RequestOptions

ResourceResponse<TResource>

Task

ReadDocumentCollectionFeedAsync(Uri, FeedOptions)

Reads the feed (sequence) of collections for a database as an asynchronous operation from the Azure Cosmos DB service.

public Task<FeedResponse<DocumentCollection>> ReadDocumentCollectionFeedAsync(Uri documentCollectionsUri, FeedOptions options = null)

Parameters

documentCollectionsUri Uri: the URI for the document collections.
options FeedOptions: The request options for the request.

Returns

Task<FeedResponse<DocumentCollection>>: The task object representing the service response for the asynchronous operation.

ReadDocumentFeedAsync(string, FeedOptions, CancellationToken)

Reads the feed (sequence) of documents for a specified collection from the Azure Cosmos DB service. This takes returns a ResourceResponse<TResource> which will contain an enumerable list of dynamic objects.

public Task<FeedResponse<dynamic>> ReadDocumentFeedAsync(string documentsLink, FeedOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentsLink string: The SelfLink of the resources to be read. E.g. /dbs/db_rid/colls/coll_rid/docs/
options FeedOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<FeedResponse<dynamic>>: A System.Threading.Tasks containing a ResourceResponse<TResource> containing dynamic objects representing the items in the feed.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<dynamic> response = await client.ReadDocumentFeedAsync("/dbs/db_rid/colls/coll_rid/docs/",
                                                    new FeedOptions
                                                    {
                                                        MaxItemCount = 10,
                                                        RequestContinuation = continuation
                                                    });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Remarks

Instead of FeedResponse{Document} this method takes advantage of dynamic objects in .NET. This way a single feed result can contain any kind of Document, or POCO object. This is important becuse a DocumentCollection can contain different kinds of documents.

Exceptions

If documentsLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource feed you tried to read did not exist. Check the parent rids are correct.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: RequestOptions

ResourceResponse<TResource>

Task

ReadDocumentFeedAsync(Uri, FeedOptions, CancellationToken)

Reads the feed (sequence) of documents for a collection as an asynchronous operation from the Azure Cosmos DB service.

public Task<FeedResponse<dynamic>> ReadDocumentFeedAsync(Uri documentsUri, FeedOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentsUri Uri: the URI for the documents.
options FeedOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<FeedResponse<dynamic>>: The task object representing the service response for the asynchronous operation.

ReadMediaAsync(string, CancellationToken)

Retrieves the specified attachment content (aka media) from the Azure Cosmos DB service.

public Task<MediaResponse> ReadMediaAsync(string mediaLink, CancellationToken cancellationToken = default)

Parameters

mediaLink string: The link for the media to read. E.g. /media/media_rid
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<MediaResponse>: The task object representing the service response for the asynchronous operation.

Exceptions

ArgumentNullException: If mediaLink is not set.
ArgumentException: If mediaLink is not in the form of /media/{mediaId}.

See Also: MediaResponse

Task

ReadMediaMetadataAsync(string)

Retrieves the metadata associated with the specified attachment content (aka media) as an asynchronous operation from the Azure Cosmos DB service.

public Task<MediaResponse> ReadMediaMetadataAsync(string mediaLink)

Parameters

mediaLink string: The link for the media to read metadata for. E.g. /media/media_rid

Returns

Task<MediaResponse>: The task object representing the service response for the asynchronous operation.

Exceptions

ArgumentNullException: If mediaLink is not set.
ArgumentException: If mediaLink is not in the form of /media/{mediaId}.

See Also: MediaResponse

Task

ReadOfferAsync(string)

Reads an Offer from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Offer>> ReadOfferAsync(string offerLink)

Parameters

offerLink string: The link to the Offer to be read.

Returns

Task<ResourceResponse<Offer>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Offer containing the read resource record.

Examples

//Reads an Offer resource from a Database
// - offer_id is the ID of the offer to be read
var offerLink = "/offers/offer_id";
Offer offer = await client.ReadOfferAsync(offerLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

For an Offer, id is always generated internally by the system when the linked resource is created. id and _rid are always the same for Offer.

Refer to https://docs.microsoft.com/en-us/azure/cosmos-db/how-to-provision-container-throughput to learn more about minimum throughput of a Cosmos container (or a database) To retrieve the minimum throughput for a collection/database, use the following sample

// Find the offer for the collection by SelfLink
        Offer offer = client.CreateOfferQuery(
            string.Format("SELECT * FROM offers o WHERE o.resource = '{0}'", collectionSelfLink)).AsEnumerable().FirstOrDefault();
        ResourceResponse<Offer> response = await client.ReadOfferAsync(offer.SelfLink);
        string minimumRUsForCollection = response.ResponseHeaders["x-ms-cosmos-min-throughput"];

Exceptions

If offerLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Conflict

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadOffersFeedAsync(FeedOptions)

Reads the feed (sequence) of Offer for a database account from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<Offer>> ReadOffersFeedAsync(FeedOptions options = null)

Parameters

options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<Offer>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Offer containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<Offer> response = await client.ReadOfferAsync(new FeedOptions
                                                                {
                                                                    MaxItemCount = 10,
                                                                    RequestContinuation = continuation
                                                                });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Offer

RequestOptions

ResourceResponse<TResource>

Task

ReadPartitionKeyRangeFeedAsync(string, FeedOptions)

Reads the feed (sequence) of PartitionKeyRange for a database account from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<PartitionKeyRange>> ReadPartitionKeyRangeFeedAsync(string partitionKeyRangesOrCollectionLink, FeedOptions options = null)

Parameters

partitionKeyRangesOrCollectionLink string: The link of the resources to be read, or owner collection link, SelfLink or AltLink. E.g. /dbs/db_rid/colls/coll_rid/pkranges
options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<PartitionKeyRange>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Database containing the read resource record.

Examples

FeedResponse<PartitionKeyRange> response = null;
List<string> ids = new List<string>();
do
{
    response = await client.ReadPartitionKeyRangeFeedAsync(collection.SelfLink, new FeedOptions { MaxItemCount = 1000 });
    foreach (var item in response)
    {
        ids.Add(item.Id);
    }
}
while (!string.IsNullOrEmpty(response.ResponseContinuation));

Exceptions

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: PartitionKeyRange

FeedOptions

FeedResponse<T>

Task

ReadPartitionKeyRangeFeedAsync(Uri, FeedOptions)

Reads the feed (sequence) of PartitionKeyRange for a database account from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<PartitionKeyRange>> ReadPartitionKeyRangeFeedAsync(Uri partitionKeyRangesOrCollectionUri, FeedOptions options = null)

Parameters

partitionKeyRangesOrCollectionUri Uri: The Uri for partition key ranges, or owner collection.
options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<PartitionKeyRange>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a PartitionKeyRange containing the read resource record.

Examples

Uri partitionKeyRangesUri = UriFactory.CreatePartitionKeyRangesUri(database.Id, collection.Id);
FeedResponse<PartitionKeyRange> response = null;
List<string> ids = new List<string>();
do
{
    response = await client.ReadPartitionKeyRangeFeedAsync(partitionKeyRangesUri, new FeedOptions { MaxItemCount = 1000 });
    foreach (var item in response)
    {
        ids.Add(item.Id);
    }
}
while (!string.IsNullOrEmpty(response.ResponseContinuation));

See Also: PartitionKeyRange

FeedOptions

FeedResponse<T>

CreatePartitionKeyRangesUri(string, string)

Task

ReadPermissionAsync(string, RequestOptions)

Reads a Permission from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Permission>> ReadPermissionAsync(string permissionLink, RequestOptions options = null)

Parameters

permissionLink string: The link for the Permission resource to be read.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Permission>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Permission containing the read resource record.

Examples

//Reads a Permission resource from a Database and User where
// - sample_database is the ID of the database
// - sample_user is the ID of the user
// - permission_id is the ID of the permission to be read
var permissionLink = "/dbs/sample_database/users/sample_user/permissions/permission_id";
Permission permission = await client.ReadPermissionAsync(permissionLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the Permission if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for permissionLink is always "/dbs/{db identifier}/users/{user identifier}/permissions/{permission identifier}" only the values within the {...} change depending on which method you wish to use to address the resource.

Exceptions

If permissionLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Permission

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadPermissionAsync(Uri, RequestOptions)

Reads a Permission resource as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Permission>> ReadPermissionAsync(Uri permissionUri, RequestOptions options = null)

Parameters

permissionUri Uri: A URI to the Permission resource to be read.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Permission>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Permission containing the read resource record.

Examples

//Reads a Permission resource where 
// - db_id is the ID property of the Database
// - user_id is the ID property of the User 
// - permission_id is the ID property of the Permission you wish to read. 
var permissionLink = UriFactory.CreatePermissionUri("db_id", "coll_id", "user_id");
Permission permission = await client.ReadPermissionAsync(permissionLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If permissionUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Permission

RequestOptions

ResourceResponse<TResource>

Task

ReadPermissionFeedAsync(string, FeedOptions)

Reads the feed (sequence) of Permission for a user from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<Permission>> ReadPermissionFeedAsync(string permissionsLink, FeedOptions options = null)

Parameters

permissionsLink string: The SelfLink of the resources to be read. E.g. /dbs/db_rid/users/user_rid/permissions/
options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<Permission>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Permission containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<Permission> response = await client.ReadPermissionFeedAsync("/dbs/db_rid/users/user_rid/permissions/",
                                                    new FeedOptions
                                                    {
                                                        MaxItemCount = 10,
                                                        RequestContinuation = continuation
                                                    });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

If permissionsLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource feed you tried to read did not exist. Check the parent rids are correct.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Permission

RequestOptions

ResourceResponse<TResource>

Task

ReadPermissionFeedAsync(Uri, FeedOptions)

Reads the feed (sequence) of permissions for a user as an asynchronous operation from the Azure Cosmos DB service.

public Task<FeedResponse<Permission>> ReadPermissionFeedAsync(Uri permissionsUri, FeedOptions options = null)

Parameters

permissionsUri Uri: the URI for the permissions.
options FeedOptions: The request options for the request.

Returns

Task<FeedResponse<Permission>>: The task object representing the service response for the asynchronous operation.

ReadStoredProcedureAsync(string, RequestOptions)

Reads a StoredProcedure from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<StoredProcedure>> ReadStoredProcedureAsync(string storedProcedureLink, RequestOptions options = null)

Parameters

storedProcedureLink string: The link of the stored procedure to be read.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<StoredProcedure>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a StoredProcedure containing the read resource record.

Examples

//Reads a StoredProcedure from a Database and DocumentCollection where
// - sample_database is the ID of the database
// - sample_collection is the ID of the collection
// - sproc_id is the ID of the stored procedure to be read
var sprocLink = "/dbs/sample_database/colls/sample_collection/sprocs/sproc_id";
StoredProcedure sproc = await client.ReadStoredProcedureAsync(sprocLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the Stored Procedure if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for storedProcedureLink is always "/dbs/{db identifier}/colls/{coll identifier}/sprocs/{sproc identifier}" only the values within the {...} change depending on which method you wish to use to address the resource.

Exceptions

If storedProcedureLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: StoredProcedure

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadStoredProcedureAsync(Uri, RequestOptions)

Reads a StoredProcedure as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<StoredProcedure>> ReadStoredProcedureAsync(Uri storedProcedureUri, RequestOptions options = null)

Parameters

storedProcedureUri Uri: A URI to the StoredProcedure resource to be read.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<StoredProcedure>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a StoredProcedure containing the read resource record.

Examples

//Reads a StoredProcedure resource where 
// - db_id is the ID property of the Database
// - coll_id is the ID property of the DocumentCollection 
// - sproc_id is the ID property of the StoredProcedure you wish to read. 
var sprocLink = UriFactory.CreateStoredProcedureUri("db_id", "coll_id", "sproc_id");
StoredProcedure sproc = await client.ReadStoredProcedureAsync(sprocLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If storedProcedureUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: StoredProcedure

RequestOptions

ResourceResponse<TResource>

Task

ReadStoredProcedureFeedAsync(string, FeedOptions)

Reads the feed (sequence) of StoredProcedure for a collection from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<StoredProcedure>> ReadStoredProcedureFeedAsync(string storedProceduresLink, FeedOptions options = null)

Parameters

storedProceduresLink string: The SelfLink of the resources to be read. E.g. /dbs/db_rid/colls/col_rid/sprocs/
options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<StoredProcedure>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a StoredProcedure containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<StoredProcedure> response = await client.ReadStoredProcedureFeedAsync("/dbs/db_rid/colls/col_rid/sprocs/",
                                                    new FeedOptions
                                                    {
                                                        MaxItemCount = 10,
                                                        RequestContinuation = continuation
                                                    });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

If storedProceduresLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource feed you tried to read did not exist. Check the parent rids are correct.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: StoredProcedure

RequestOptions

ResourceResponse<TResource>

Task

ReadStoredProcedureFeedAsync(Uri, FeedOptions)

Reads the feed (sequence) of stored procedures for a collection as an asynchronous operation from the Azure Cosmos DB service.

public Task<FeedResponse<StoredProcedure>> ReadStoredProcedureFeedAsync(Uri storedProceduresUri, FeedOptions options = null)

Parameters

storedProceduresUri Uri: the URI for the stored procedures.
options FeedOptions: The request options for the request.

Returns

Task<FeedResponse<StoredProcedure>>: The task object representing the service response for the asynchronous operation.

ReadTriggerAsync(string, RequestOptions)

Reads a Trigger from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Trigger>> ReadTriggerAsync(string triggerLink, RequestOptions options = null)

Parameters

triggerLink string: The link to the Trigger to be read.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Trigger>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Trigger containing the read resource record.

Examples

//Reads a Trigger from a Database and DocumentCollection where
// - sample_database is the ID of the database
// - sample_collection is the ID of the collection
// - trigger_id is the ID of the trigger to be read
var triggerLink = "/dbs/sample_database/colls/sample_collection/triggers/trigger_id";
Trigger trigger = await client.ReadTriggerAsync(triggerLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the Trigger if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for triggerLink is always "/dbs/{db identifier}/colls/{coll identifier}/triggers/{trigger identifier}" only the values within the {...} change depending on which method you wish to use to address the resource.

Exceptions

If triggerLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Trigger

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadTriggerAsync(Uri, RequestOptions)

Reads a Trigger as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<Trigger>> ReadTriggerAsync(Uri triggerUri, RequestOptions options = null)

Parameters

triggerUri Uri: A URI to the Trigger resource to be read.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Trigger>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Trigger containing the read resource record.

Examples

//Reads a Trigger resource where 
// - db_id is the ID property of the Database
// - coll_id is the ID property of the DocumentCollection 
// - trigger_id is the ID property of the Trigger you wish to read. 
var triggerLink = UriFactory.CreateTriggerUri("db_id", "coll_id", "trigger_id");
Trigger trigger = await client.ReadTriggerAsync(triggerLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If triggerUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Trigger

RequestOptions

ResourceResponse<TResource>

Task

ReadTriggerFeedAsync(string, FeedOptions)

Reads the feed (sequence) of Trigger for a collection from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<Trigger>> ReadTriggerFeedAsync(string triggersLink, FeedOptions options = null)

Parameters

triggersLink string: The SelfLink of the resources to be read. E.g. /dbs/db_rid/colls/col_rid/triggers/
options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<Trigger>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Trigger containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<Trigger> response = await client.ReadTriggerFeedAsync("/dbs/db_rid/colls/col_rid/triggers/",
                                                    new FeedOptions
                                                    {
                                                        MaxItemCount = 10,
                                                        RequestContinuation = continuation
                                                    });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

If triggersLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource feed you tried to read did not exist. Check the parent rids are correct.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Trigger

RequestOptions

ResourceResponse<TResource>

Task

ReadTriggerFeedAsync(Uri, FeedOptions)

Reads the feed (sequence) of triggers for a collection as an asynchronous operation from the Azure Cosmos DB service.

public Task<FeedResponse<Trigger>> ReadTriggerFeedAsync(Uri triggersUri, FeedOptions options = null)

Parameters

triggersUri Uri: the URI for the triggers.
options FeedOptions: The request options for the request.

Returns

Task<FeedResponse<Trigger>>: The task object representing the service response for the asynchronous operation.

ReadUserAsync(string, RequestOptions)

Reads a User from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<User>> ReadUserAsync(string userLink, RequestOptions options = null)

Parameters

userLink string: The link to the User resource to be read.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<User>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a User containing the read resource record.

Examples

//Reads a User resource from a Database
// - sample_database is the ID of the database
// - user_id is the ID of the user to be read
var userLink = "/dbs/sample_database/users/user_id";
User user = await client.ReadUserAsync(userLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the User if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for userLink is always "/dbs/{db identifier}/users/{user identifier}" only the values within the {...} change depending on which method you wish to use to address the resource.

Exceptions

If userLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: User

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadUserAsync(Uri, RequestOptions)

Reads a User as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<User>> ReadUserAsync(Uri userUri, RequestOptions options = null)

Parameters

userUri Uri: A URI to the User resource to be read.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<User>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a User containing the read resource record.

Examples

//Reads a User resource where 
// - db_id is the ID property of the Database
// - user_id is the ID property of the User you wish to read. 
var userLink = UriFactory.CreateUserUri("db_id", "user_id");
User user = await client.ReadUserAsync(userLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If userUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: User

RequestOptions

ResourceResponse<TResource>

Task

ReadUserDefinedFunctionAsync(string, RequestOptions)

Reads a UserDefinedFunction from the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<UserDefinedFunction>> ReadUserDefinedFunctionAsync(string functionLink, RequestOptions options = null)

Parameters

functionLink string: The link to the User Defined Function to be read.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<UserDefinedFunction>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a UserDefinedFunction containing the read resource record.

Examples

//Reads a User Defined Function from a Database and DocumentCollection where
// - sample_database is the ID of the database
// - sample_collection is the ID of the collection
// - udf_id is the ID of the user-defined function to be read
var udfLink = "/dbs/sample_database/colls/sample_collection/udfs/udf_id";
UserDefinedFunction udf = await client.ReadUserDefinedFunctionAsync(udfLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the Database. If you know the resource's ID, do a read instead of a query by ID.

The example shown uses ID-based links, where the link is composed of the ID properties used when the resources were created. You can still use the SelfLink property of the User Defined Function if you prefer. A self-link is a URI for a resource that is made up of Resource Identifiers (or the _rid properties). ID-based links and SelfLink will both work. The format for functionLink is always "/dbs/{db identifier}/colls/{coll identifier}/udfs/{udf identifier}" only the values within the {...} change depending on which method you wish to use to address the resource.

Exceptions

If functionLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: UserDefinedFunction

RequestOptions

ResourceResponse<TResource>

Task

Uri

ReadUserDefinedFunctionAsync(Uri, RequestOptions)

Reads a UserDefinedFunction as an asynchronous operation from the Azure Cosmos DB service.

public Task<ResourceResponse<UserDefinedFunction>> ReadUserDefinedFunctionAsync(Uri functionUri, RequestOptions options = null)

Parameters

functionUri Uri: A URI to the User Defined Function resource to be read.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<UserDefinedFunction>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a UserDefinedFunction containing the read resource record.

Examples

//Reads a UserDefinedFunction resource where 
// - db_id is the ID property of the Database
// - coll_id is the ID property of the DocumentCollection 
// - udf_id is the ID property of the UserDefinedFunction you wish to read. 
var udfLink = UriFactory.CreateUserDefinedFunctionUri("db_id", "coll_id", "udf_id");
UserDefinedFunction udf = await client.ReadUserDefinedFunctionAsync(udfLink);

Remarks

Doing a read of a resource is the most efficient way to get a resource from the service. If you know the resource's ID, do a read instead of a query by ID.

Exceptions

If functionUri is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to read did not exist.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: UserDefinedFunction

RequestOptions

ResourceResponse<TResource>

Task

ReadUserDefinedFunctionFeedAsync(string, FeedOptions)

Reads the feed (sequence) of UserDefinedFunction for a collection from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<UserDefinedFunction>> ReadUserDefinedFunctionFeedAsync(string userDefinedFunctionsLink, FeedOptions options = null)

Parameters

userDefinedFunctionsLink string: The SelfLink of the resources to be read. E.g. /dbs/db_rid/colls/col_rid/udfs/
options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<UserDefinedFunction>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a UserDefinedFunction containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<UserDefinedFunction> response = await client.ReadUserDefinedFunctionFeedAsync("/dbs/db_rid/colls/col_rid/udfs/",
                                                    new FeedOptions
                                                    {
                                                        MaxItemCount = 10,
                                                        RequestContinuation = continuation
                                                    });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

If userDefinedFunctionsLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource feed you tried to read did not exist. Check the parent rids are correct.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: UserDefinedFunction

RequestOptions

ResourceResponse<TResource>

Task

ReadUserDefinedFunctionFeedAsync(Uri, FeedOptions)

Reads the feed (sequence) of user defined functions for a collection as an asynchronous operation from the Azure Cosmos DB service.

public Task<FeedResponse<UserDefinedFunction>> ReadUserDefinedFunctionFeedAsync(Uri userDefinedFunctionsUri, FeedOptions options = null)

Parameters

userDefinedFunctionsUri Uri: the URI for the user defined functions.
options FeedOptions: The request options for the request.

Returns

Task<FeedResponse<UserDefinedFunction>>: The task object representing the service response for the asynchronous operation.

ReadUserFeedAsync(string, FeedOptions)

Reads the feed (sequence) of User for a database from the Azure Cosmos DB service as an asynchronous operation.

public Task<FeedResponse<User>> ReadUserFeedAsync(string usersLink, FeedOptions options = null)

Parameters

usersLink string: The SelfLink of the resources to be read. E.g. /dbs/db_rid/users/
options FeedOptions: (Optional) The request options for the request.

Returns

Task<FeedResponse<User>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a User containing the read resource record.

Examples

int count = 0;
string continuation = string.Empty;
do
{
    // Read the feed 10 items at a time until there are no more items to read
    FeedResponse<User> response = await client.ReadUserFeedAsync("/dbs/db_rid/users/",
                                                    new FeedOptions
                                                    {
                                                        MaxItemCount = 10,
                                                        RequestContinuation = continuation
                                                    });

    // Append the item count
    count += response.Count;

    // Get the continuation so that we know when to stop.
     continuation = response.ResponseContinuation;
} while (!string.IsNullOrEmpty(continuation));

Exceptions

If usersLink is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource feed you tried to read did not exist. Check the parent rids are correct.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: User

RequestOptions

ResourceResponse<TResource>

Task

ReadUserFeedAsync(Uri, FeedOptions)

Reads the feed (sequence) of users for a database as an asynchronous operation from the Azure Cosmos DB service.

public Task<FeedResponse<User>> ReadUserFeedAsync(Uri usersUri, FeedOptions options = null)

Parameters

usersUri Uri: the URI for the users.
options FeedOptions: The request options for the request.

Returns

Task<FeedResponse<User>>: The task object representing the service response for the asynchronous operation.

ReplaceAttachmentAsync(Attachment, RequestOptions, CancellationToken)

Replaces a Attachment in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Attachment>> ReplaceAttachmentAsync(Attachment attachment, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

attachment Attachment: The updated Attachment to replace the existing resource with.
options RequestOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Attachment>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Attachment containing the updated resource record.

Examples

//Fetch the item to be updated
Attachment attachment = client.CreateAttachmentQuery(attachmentLink)
                            .Where(r => r.Id == "attachment id")
                            .AsEnumerable()
                            .SingleOrDefault();

//Update some properties on the found resource
attachment.MediaLink = "updated value";

//Now persist these changes to the database by replacing the original resource
Attachment updated = await client.ReplaceAttachmentAsync(attachment);

Exceptions

If attachment is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Attachment

RequestOptions

ResourceResponse<TResource>

Task

ReplaceAttachmentAsync(Uri, Attachment, RequestOptions, CancellationToken)

Replaces an attachment as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Attachment>> ReplaceAttachmentAsync(Uri attachmentUri, Attachment attachment, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

attachmentUri Uri: the URI of the attachment to be updated.
attachment Attachment: the attachment resource.
options RequestOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Attachment>>: The task object representing the service response for the asynchronous operation.

ReplaceDocumentAsync(Document, RequestOptions, CancellationToken)

Replaces a Document in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Document>> ReplaceDocumentAsync(Document document, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

document Document: The updated Document to replace the existing resource with.
options RequestOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Document>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Document containing the updated resource record.

Examples

This example uses Document and takes advantage of the fact that it is a dynamic object and uses SetProperty to dynamically update properties on the document

//Fetch the Document to be updated
Document doc = client.CreateDocumentQuery<Document>(collectionLink)
                            .Where(r => r.Id == "doc id")
                            .AsEnumerable()
                            .SingleOrDefault();

//Update some properties on the found resource
doc.SetPropertyValue("MyProperty", "updated value");

//Now persist these changes to the database by replacing the original resource
Document updated = await client.ReplaceDocumentAsync(doc);

Exceptions

If document is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Document

RequestOptions

ResourceResponse<TResource>

Task

ReplaceDocumentAsync(string, object, RequestOptions, CancellationToken)

Replaces a Document in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Document>> ReplaceDocumentAsync(string documentLink, object document, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentLink string: The link of the document to be updated. E.g. dbs/db_rid/colls/col_rid/docs/doc_rid/
document object: The updated Document to replace the existing resource with.
options RequestOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Document>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Document containing the updated resource record.

Examples

In this example, instead of using a strongly typed Document, we will work with our own POCO object and not rely on the dynamic nature of the Document class.

public class MyPoco
{
    public string Id {get; set;}
    public string MyProperty {get; set;}
}

//Get the doc back as a Document so you have access to doc.SelfLink
Document doc = client.CreateDocumentQuery<Document>(collectionLink)
                       .Where(r => r.Id == "doc id")
                       .AsEnumerable()
                       .SingleOrDefault();

//Now dynamically cast doc back to your MyPoco
MyPoco poco = (dynamic)doc;

//Update some properties of the poco object
poco.MyProperty = "updated value";

//Now persist these changes to the database using doc.SelLink and the update poco object
Document updated = await client.ReplaceDocumentAsync(doc.SelfLink, poco);

Exceptions

If either documentLink or document is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Document

RequestOptions

ResourceResponse<TResource>

Task

ReplaceDocumentAsync(Uri, object, RequestOptions, CancellationToken)

Replaces a document as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Document>> ReplaceDocumentAsync(Uri documentUri, object document, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentUri Uri: the URI of the document to be updated.
document object: the updated document.
options RequestOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Document>>: The task object representing the service response for the asynchronous operation.

ReplaceDocumentCollectionAsync(DocumentCollection, RequestOptions)

Replaces a document collection in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<DocumentCollection>> ReplaceDocumentCollectionAsync(DocumentCollection documentCollection, RequestOptions options = null)

Parameters

documentCollection DocumentCollection: the updated document collection.
options RequestOptions: the request options for the request.

Returns

Task<ResourceResponse<DocumentCollection>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a DocumentCollection containing the updated resource record.

ReplaceDocumentCollectionAsync(Uri, DocumentCollection, RequestOptions)

Replaces a document collection as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<DocumentCollection>> ReplaceDocumentCollectionAsync(Uri documentCollectionUri, DocumentCollection documentCollection, RequestOptions options = null)

Parameters

documentCollectionUri Uri: the URI of the document collection to be updated.
documentCollection DocumentCollection: the updated document collection.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<DocumentCollection>>: The task object representing the service response for the asynchronous operation.

ReplaceOfferAsync(Offer)

Replaces a Offer in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Offer>> ReplaceOfferAsync(Offer offer)

Parameters

offer Offer: The updated Offer to replace the existing resource with.

Returns

Task<ResourceResponse<Offer>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Offer containing the updated resource record.

Examples

//Fetch the resource to be updated
Offer offer = client.CreateOfferQuery()
                         .Where(r => r.ResourceLink == "collection selfLink")
                         .AsEnumerable()
                         .SingleOrDefault();

//Create a new offer with the changed throughput
OfferV2 newOffer = new OfferV2(offer, 5000);

//Now persist these changes to the database by replacing the original resource
Offer updated = await client.ReplaceOfferAsync(newOffer);

Exceptions

If offer is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.
423	Locked - This means the scale operation cannot be performed because another scale operation is in progress.

See Also: Offer

RequestOptions

ResourceResponse<TResource>

Task

ReplacePermissionAsync(Permission, RequestOptions)

Replaces a Permission in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Permission>> ReplacePermissionAsync(Permission permission, RequestOptions options = null)

Parameters

permission Permission: The updated Permission to replace the existing resource with.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Permission>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Permission containing the updated resource record.

Examples

//Fetch the resource to be updated
Permission permission = client.CreatePermissionQuery(permissionsLink)
                                    .Where(r => r.Id == "permission id")
                                    .AsEnumerable()
                                    .SingleOrDefault();

//Change the permission mode to All
permission.PermissionMode = PermissionMode.All;

//Now persist these changes to the database by replacing the original resource
Permission updated = await client.ReplacePermissionAsync(permission);

Exceptions

If permission is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Permission

RequestOptions

ResourceResponse<TResource>

Task

ReplacePermissionAsync(Uri, Permission, RequestOptions)

Replaces a permission as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Permission>> ReplacePermissionAsync(Uri permissionUri, Permission permission, RequestOptions options = null)

Parameters

permissionUri Uri: the URI for the permission to be updated.
permission Permission: the updated permission.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Permission>>: The task object representing the service response for the asynchronous operation.

ReplaceStoredProcedureAsync(StoredProcedure, RequestOptions)

Replaces a StoredProcedure in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<StoredProcedure>> ReplaceStoredProcedureAsync(StoredProcedure storedProcedure, RequestOptions options = null)

Parameters

storedProcedure StoredProcedure: The updated StoredProcedure to replace the existing resource with.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<StoredProcedure>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a StoredProcedure containing the updated resource record.

Examples

//Fetch the resource to be updated
StoredProcedure sproc = client.CreateStoredProcedureQuery(sprocsLink)
                                 .Where(r => r.Id == "sproc id")
                                 .AsEnumerable()
                                 .SingleOrDefault();

//Update some properties on the found resource
sproc.Body = "function () {new javascript body for sproc}";

//Now persist these changes to the database by replacing the original resource
StoredProcedure updated = await client.ReplaceStoredProcedureAsync(sproc);

Exceptions

If storedProcedure is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: StoredProcedure

RequestOptions

ResourceResponse<TResource>

Task

ReplaceStoredProcedureAsync(Uri, StoredProcedure, RequestOptions)

Replace the specified stored procedure in the Azure Cosmos DB service.

public Task<ResourceResponse<StoredProcedure>> ReplaceStoredProcedureAsync(Uri storedProcedureUri, StoredProcedure storedProcedure, RequestOptions options = null)

Parameters

storedProcedureUri Uri: the URI for the stored procedure to be updated.
storedProcedure StoredProcedure: the updated stored procedure.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<StoredProcedure>>: The task object representing the service response for the asynchronous operation.

ReplaceTriggerAsync(Trigger, RequestOptions)

Replaces a Trigger in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<Trigger>> ReplaceTriggerAsync(Trigger trigger, RequestOptions options = null)

Parameters

trigger Trigger: The updated Trigger to replace the existing resource with.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Trigger>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a Trigger containing the updated resource record.

Examples

//Fetch the resource to be updated
Trigger trigger = client.CreateTriggerQuery(sprocsLink)
                              .Where(r => r.Id == "trigger id")
                              .AsEnumerable()
                              .SingleOrDefault();

//Update some properties on the found resource
trigger.Body = "function () {new javascript body for trigger}";

//Now persist these changes to the database by replacing the original resource
Trigger updated = await client.ReplaceTriggerAsync(sproc);

Exceptions

If trigger is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: Trigger

RequestOptions

ResourceResponse<TResource>

Task

ReplaceTriggerAsync(Uri, Trigger, RequestOptions)

Replaces a trigger as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Trigger>> ReplaceTriggerAsync(Uri triggerUri, Trigger trigger, RequestOptions options = null)

Parameters

triggerUri Uri: the URI for the trigger to be updated.
trigger Trigger: the updated trigger.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Trigger>>: The task object representing the service response for the asynchronous operation.

ReplaceUserAsync(User, RequestOptions)

Replaces a User in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<User>> ReplaceUserAsync(User user, RequestOptions options = null)

Parameters

user User: The updated User to replace the existing resource with.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<User>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a User containing the updated resource record.

Examples

//Fetch the resource to be updated
User user = client.CreateUserQuery(usersLink)
                         .Where(r => r.Id == "user id")
                         .AsEnumerable()
                         .SingleOrDefault();

//Change the user mode to All
user.Id = "some new method";

//Now persist these changes to the database by replacing the original resource
User updated = await client.ReplaceUserAsync(user);

Exceptions

If user is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: User

RequestOptions

ResourceResponse<TResource>

Task

ReplaceUserAsync(Uri, User, RequestOptions)

Replaces a user as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<User>> ReplaceUserAsync(Uri userUri, User user, RequestOptions options = null)

Parameters

userUri Uri: the URI for the user to be updated.
user User: the updated user.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<User>>: The task object representing the service response for the asynchronous operation.

ReplaceUserDefinedFunctionAsync(UserDefinedFunction, RequestOptions)

Replaces a UserDefinedFunction in the Azure Cosmos DB service as an asynchronous operation.

public Task<ResourceResponse<UserDefinedFunction>> ReplaceUserDefinedFunctionAsync(UserDefinedFunction function, RequestOptions options = null)

Parameters

function UserDefinedFunction: The updated UserDefinedFunction to replace the existing resource with.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<UserDefinedFunction>>: A System.Threading.Tasks containing a ResourceResponse<TResource> which wraps a UserDefinedFunction containing the updated resource record.

Examples

//Fetch the resource to be updated
UserDefinedFunction udf = client.CreateUserDefinedFunctionQuery(functionsLink)
                                    .Where(r => r.Id == "udf id")
                                    .AsEnumerable()
                                    .SingleOrDefault();

//Update some properties on the found resource
udf.Body = "function () {new javascript body for udf}";

//Now persist these changes to the database by replacing the original resource
UserDefinedFunction updated = await client.ReplaceUserDefinedFunctionAsync(udf);

Exceptions

If function is not set.

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
404	NotFound - This means the resource you tried to delete did not exist.

See Also: UserDefinedFunction

RequestOptions

ResourceResponse<TResource>

Task

ReplaceUserDefinedFunctionAsync(Uri, UserDefinedFunction, RequestOptions)

Replaces a user defined function as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<UserDefinedFunction>> ReplaceUserDefinedFunctionAsync(Uri userDefinedFunctionUri, UserDefinedFunction function, RequestOptions options = null)

Parameters

userDefinedFunctionUri Uri: the URI for the user defined function to be updated.
function UserDefinedFunction: the updated user defined function.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<UserDefinedFunction>>: The task object representing the service response for the asynchronous operation.

UpdateMediaAsync(string, Stream, MediaOptions, CancellationToken)

Replaces the specified media's content as an asynchronous operation in the Azure Cosmos DB service.

public Task<MediaResponse> UpdateMediaAsync(string mediaLink, Stream mediaStream, MediaOptions options = null, CancellationToken cancellationToken = default)

Parameters

mediaLink string: The link for the media to be updated. /media/media_rid
mediaStream Stream: The Stream of the attachment media.
options MediaOptions: The MediaOptions for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<MediaResponse>: The task object representing the service response for the asynchronous operation.

Examples

//This attachment could be any binary you want to attach. Like images, videos, word documents, pdfs etc. it doesn't matter
using (FileStream fileStream = new FileStream(@".\something.pdf", FileMode.Open))
{
    //Update the attachment media
    await client.UpdateMediaAsync("/media/media_rid", fileStream,
                    new MediaOptions
                    {
                        ContentType = "application/pdf",
                        Slug = "something.pdf"
                    });
}

Exceptions

ArgumentNullException: If either mediaLink or mediaStream is not set.
ArgumentException: If mediaLink is not in the form of /media/{mediaId}.

See Also: MediaOptions

MediaResponse

Stream

Task

UpsertAttachmentAsync(string, Stream, MediaOptions, RequestOptions, CancellationToken)

Upserts an Attachment with the contents of the provided mediaStream as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Attachment>> UpsertAttachmentAsync(string attachmentsLink, Stream mediaStream, MediaOptions options = null, RequestOptions requestOptions = null, CancellationToken cancellationToken = default)

Parameters

attachmentsLink string: The attachments link for the document. E.g. dbs/db_rid/colls/col_rid/docs/doc_rid/attachments/
mediaStream Stream: the Stream of the attachment media.
options MediaOptions: the MediaOptions for the request.
requestOptions RequestOptions: the RequestOptions for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Attachment>>: The task object representing the service response for the asynchronous operation.

Examples

//This attachment could be any binary you want to attach. Like images, videos, word documents, pdfs etc. it doesn't matter
using (FileStream fileStream = new FileStream(@".\something.pdf", FileMode.Open))
{
    //Upsert the attachment
    Attachment attachment = await client.UpsertAttachmentAsync("dbs/db_rid/colls/coll_rid/docs/doc_rid/attachments/",
                                        fileStream,
                                        new MediaOptions
                                        {
                                            ContentType = "application/pdf",
                                            Slug = "something.pdf"
                                        });
}

Exceptions

ArgumentNullException: If either attachmentsLink or mediaStream is not set.

See Also: Attachment

ResourceResponse<TResource>

Stream

Task

UpsertAttachmentAsync(string, object, RequestOptions, CancellationToken)

Upserts an attachment as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Attachment>> UpsertAttachmentAsync(string documentLink, object attachment, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentLink string: The link of the parent document for this new attachment. E.g. dbs/db_rid/colls/col_rid/docs/doc_rid/
attachment object: The attachment object.
options RequestOptions: (Optional) The request options for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Attachment>>: The Task object representing the service response for the asynchronous operation.

Examples

The example below creates a new document, and then upserts a new attachment for that document

dynamic d = new
{
    id = "DOC1800243243470"
};

Document doc = await client.CreateDocumentAsync(collectionSelfLink, d);

//Upsert an Attachment which links to binary content stored somewhere else
//Use the MediaLink property of Attachment to set where the binary resides
//MediaLink can also point at another Attachment within Azure Cosmos DB.
Attachment a = await client.UpsertAttachmentAsync(doc.SelfLink, new Attachment { Id = "foo", ContentType = "text/plain", MediaLink = "link to your media" });

See Also: Attachment

RequestOptions

ResourceResponse<TResource>

Task

UpsertAttachmentAsync(Uri, Stream, MediaOptions, RequestOptions, CancellationToken)

Upserts an attachment as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Attachment>> UpsertAttachmentAsync(Uri documentUri, Stream mediaStream, MediaOptions options = null, RequestOptions requestOptions = null, CancellationToken cancellationToken = default)

Parameters

documentUri Uri: the URI of the document to upsert an attachment for.
mediaStream Stream: the stream of the attachment media.
options MediaOptions: the media options for the request.
requestOptions RequestOptions: Request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Attachment>>: The task object representing the service response for the asynchronous operation.

UpsertAttachmentAsync(Uri, object, RequestOptions, CancellationToken)

Upserts an attachment as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Attachment>> UpsertAttachmentAsync(Uri documentUri, object attachment, RequestOptions options = null, CancellationToken cancellationToken = default)

Parameters

documentUri Uri: the URI of the document to upsert an attachment for.
attachment object: the attachment object.
options RequestOptions: The request options for the request.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Attachment>>: The task object representing the service response for the asynchronous operation.

UpsertDocumentAsync(string, object, RequestOptions, bool, CancellationToken)

Upserts a Document as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Document>> UpsertDocumentAsync(string documentsFeedOrDatabaseLink, object document, RequestOptions options = null, bool disableAutomaticIdGeneration = false, CancellationToken cancellationToken = default)

Parameters

documentsFeedOrDatabaseLink string: The link of the DocumentCollection to upsert the document in. E.g. dbs/db_rid/colls/coll_rid/
document object: The document object to upsert.
options RequestOptions: (Optional) Any request options you wish to set. E.g. Specifying a Trigger to execute when creating the document. RequestOptions
disableAutomaticIdGeneration bool: (Optional) Disables the automatic id generation, If this is True the system will throw an exception if the id property is missing from the Document.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of cancellation.

Returns

Task<ResourceResponse<Document>>: The Document that was upserted contained within a Task object representing the service response for the asynchronous operation.

Examples

Azure Cosmos DB supports a number of different ways to work with documents. A document can extend Resource

public class MyObject : Resource
{
public string MyProperty {get; set;}
}
                                                                                                                                                     using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
                                                                                                                                                     {
                                                                                                                                                         Document doc = await client.UpsertDocumentAsync("dbs/db_rid/colls/coll_rid/", new MyObject { MyProperty = "A Value" });
                                                                                                                                                     }</code></pre>

A document can be any POCO object that can be serialized to JSON, even if it doesn't extend from Resource

public class MyPOCO
{
public string MyProperty {get; set;}
}
                                                                                                                                                    using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
                                                                                                                                                    {
                                                                                                                                                        Document doc = await client.UpsertDocumentAsync("dbs/db_rid/colls/coll_rid/", new MyPOCO { MyProperty = "A Value" });
                                                                                                                                                    }</code></pre>

A Document can also be a dynamic object

using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
{
    Document doc = await client.UpsertDocumentAsync("dbs/db_rid/colls/coll_rid/", new { SomeProperty = "A Value" } );
}

Upsert a Document and execute a Pre and Post Trigger

using (IDocumentClient client = new DocumentClient(new Uri("service endpoint"), "auth key"))
{
    Document doc = await client.UpsertDocumentAsync(
        "dbs/db_rid/colls/coll_rid/",
        new { id = "DOC123213443" },
        new RequestOptions
        {
            PreTriggerInclude = new List<string> { "MyPreTrigger" },
            PostTriggerInclude = new List<string> { "MyPostTrigger" }
        });
}

Exceptions

If either documentsFeedOrDatabaseLink or document is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the document supplied. It is likely that `disableAutomaticIdGeneration` was true and an id was not supplied
403	Forbidden - This likely means the collection in to which you were trying to upsert the document is full.
409	Conflict - This means a Document with an id matching the id field of `document` already existed
413	RequestEntityTooLarge - This means the Document exceeds the current max entity size. Consult documentation for limits and quotas.
429	TooManyRequests - This means you have exceeded the number of request units per second. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Document

RequestOptions

ResourceResponse<TResource>

Task

UpsertDocumentAsync(Uri, object, RequestOptions, bool, CancellationToken)

Upserts a document as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Document>> UpsertDocumentAsync(Uri documentCollectionUri, object document, RequestOptions options = null, bool disableAutomaticIdGeneration = false, CancellationToken cancellationToken = default)

Parameters

documentCollectionUri Uri: the URI of the document collection to upsert the document in.
document object: the document object.
options RequestOptions: The request options for the request.
disableAutomaticIdGeneration bool: Disables the automatic id generation, will throw an exception if id is missing.
cancellationToken CancellationToken: (Optional) CancellationToken representing request cancellation.

Returns

Task<ResourceResponse<Document>>: The task object representing the service response for the asynchronous operation.

UpsertPermissionAsync(string, Permission, RequestOptions)

Upserts a permission on a user object in the Azure Cosmos DB service as an asychronous operation.

public Task<ResourceResponse<Permission>> UpsertPermissionAsync(string userLink, Permission permission, RequestOptions options = null)

Parameters

userLink string: The link of the user to Upsert the permission for. E.g. dbs/db_rid/users/user_rid/
permission Permission: The Permission object.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<Permission>>: A task object representing the service response for the asynchronous operation which contains the upserted Permission object.

Examples

//Upsert a read-only permission object for a specific user
Permission p = await client.UpsertPermissionAsync(userLink, new Permission { Id = "ReadPermission", PermissionMode = PermissionMode.Read });

Exceptions

If either userLink or permission is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied.
403	Forbidden - You have reached your quota of permission objects. Contact support to have this quota increased.
409	Conflict - This means a Permission with an id matching the id you supplied already existed.

See Also: Permission

RequestOptions

ResourceResponse<TResource>

Task

UpsertPermissionAsync(Uri, Permission, RequestOptions)

Upserts a permission as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Permission>> UpsertPermissionAsync(Uri userUri, Permission permission, RequestOptions options = null)

Parameters

userUri Uri: the URI of the user to upsert the permission for.
permission Permission: the Microsoft.Azure.Documents.Permission object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Permission>>: The task object representing the service response for the asynchronous operation.

UpsertStoredProcedureAsync(string, StoredProcedure, RequestOptions)

Upserts a stored procedure as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<StoredProcedure>> UpsertStoredProcedureAsync(string collectionLink, StoredProcedure storedProcedure, RequestOptions options = null)

Parameters

collectionLink string: The link of the collection to upsert the stored procedure in. E.g. dbs/db_rid/colls/col_rid/
storedProcedure StoredProcedure: The StoredProcedure object to upsert.
options RequestOptions: (Optional) Any RequestOptionsfor this request.

Returns

Task<ResourceResponse<StoredProcedure>>: The StoredProcedure that was upserted contained within a Task object representing the service response for the asynchronous operation.

Examples

//Upsert a new stored procedure called "HelloWorldSproc" that takes in a single param called "name".
StoredProcedure sproc = await client.UpsertStoredProcedureAsync(collectionLink, new StoredProcedure
{
   Id = "HelloWorldSproc",
   Body = @"function (name){
               var response = getContext().getResponse();
               response.setBody('Hello ' + name);
            }"
});

Exceptions

If either collectionLink or storedProcedure is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied. It is likely that an Id was not supplied for the stored procedure or the Body was malformed.
403	Forbidden - You have reached your quota of stored procedures for the collection supplied. Contact support to have this quota increased.
409	Conflict - This means a StoredProcedure with an id matching the id you supplied already existed.
413	RequestEntityTooLarge - This means the body of the StoredProcedure you tried to upsert was too large.

See Also: StoredProcedure

RequestOptions

ResourceResponse<TResource>

Task

UpsertStoredProcedureAsync(Uri, StoredProcedure, RequestOptions)

Upserts a stored procedure as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<StoredProcedure>> UpsertStoredProcedureAsync(Uri documentCollectionUri, StoredProcedure storedProcedure, RequestOptions options = null)

Parameters

documentCollectionUri Uri: the URI of the document collection to upsert the stored procedure in.
storedProcedure StoredProcedure: the Microsoft.Azure.Documents.StoredProcedure object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<StoredProcedure>>: The task object representing the service response for the asynchronous operation.

UpsertTriggerAsync(string, Trigger, RequestOptions)

Upserts a trigger as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Trigger>> UpsertTriggerAsync(string collectionLink, Trigger trigger, RequestOptions options = null)

Parameters

collectionLink string: The link of the DocumentCollection to upsert the trigger in. E.g. dbs/db_rid/colls/col_rid/
trigger Trigger: The Trigger object to upsert.
options RequestOptions: (Optional) Any RequestOptionsfor this request.

Returns

Task<ResourceResponse<Trigger>>: A task object representing the service response for the asynchronous operation.

Examples

//Upsert a trigger that validates the contents of a document as it is created and adds a 'timestamp' property if one was not found.
Trigger trig = await client.UpsertTriggerAsync(collectionLink, new Trigger
{
    Id = "ValidateDocuments",
    Body = @"function validate() {
                        var context = getContext();
                        var request = context.getRequest();                                                             
                        var documentToCreate = request.getBody();

                        // validate properties
                        if (!('timestamp' in documentToCreate)) {
                            var ts = new Date();
                            documentToCreate['timestamp'] = ts.getTime();
                        }

                        // update the document that will be created
                        request.setBody(documentToCreate);
                      }",
    TriggerType = TriggerType.Pre,
    TriggerOperation = TriggerOperation.Create
});

Exceptions

If either collectionLink or trigger is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied. It is likely that an Id was not supplied for the new trigger or that the Body was malformed.
403	Forbidden - You have reached your quota of triggers for the collection supplied. Contact support to have this quota increased.
409	Conflict - This means a Trigger with an id matching the id you supplied already existed.
413	RequestEntityTooLarge - This means the body of the Trigger you tried to upsert was too large.

See Also: Trigger

RequestOptions

ResourceResponse<TResource>

Task

UpsertTriggerAsync(Uri, Trigger, RequestOptions)

Upserts a trigger as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<Trigger>> UpsertTriggerAsync(Uri documentCollectionUri, Trigger trigger, RequestOptions options = null)

Parameters

documentCollectionUri Uri: the URI of the document collection to upsert the trigger in.
trigger Trigger: the Microsoft.Azure.Documents.Trigger object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<Trigger>>: The task object representing the service response for the asynchronous operation.

UpsertUserAsync(string, User, RequestOptions)

Upserts a permission on a user object in the Azure Cosmos DB service as an asychronous operation.

public Task<ResourceResponse<User>> UpsertUserAsync(string databaseLink, User user, RequestOptions options = null)

Parameters

databaseLink string: The link of the database to upsert the user in. E.g. dbs/db_rid/
user User: The User object to upsert.
options RequestOptions: (Optional) The request options for the request.

Returns

Task<ResourceResponse<User>>: A task object representing the service response for the asynchronous operation which contains the upserted User object.

Examples

//Upsert a new user called joeBloggs in the specified database
User user = await client.UpsertUserAsync(databaseLink, new User { Id = "joeBloggs" });

Exceptions

If either databaseLink or user is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)

This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a Document are:

StatusCode	Reason for exception
400	BadRequest - This means something was wrong with the request supplied.
403	Forbidden - You have reached your quota of user objects for this database. Contact support to have this quota increased.
409	Conflict - This means a User with an id matching the id you supplied already existed.

See Also: User

RequestOptions

ResourceResponse<TResource>

Task

UpsertUserAsync(Uri, User, RequestOptions)

Upserts a user as an asynchronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<User>> UpsertUserAsync(Uri databaseUri, User user, RequestOptions options = null)

Parameters

databaseUri Uri: the URI of the database to upsert the user in.
user User: the Microsoft.Azure.Documents.User object.
options RequestOptions: The request options for the request.

Returns

Task<ResourceResponse<User>>: The task object representing the service response for the asynchronous operation.

UpsertUserDefinedFunctionAsync(string, UserDefinedFunction, RequestOptions)

Upserts a user defined function as an asychronous operation in the Azure Cosmos DB service.

public Task<ResourceResponse<UserDefinedFunction>> UpsertUserDefinedFunctionAsync(string collectionLink, UserDefinedFunction function, RequestOptions options = null)

Parameters

collectionLink string: The link of the DocumentCollection to upsert the user defined function in. E.g. dbs/db_rid/colls/col_rid/
function UserDefinedFunction: The UserDefinedFunction object to upsert.
options RequestOptions: (Optional) Any RequestOptionsfor this request.

Returns

Task<ResourceResponse<UserDefinedFunction>>: A task object representing the service response for the asynchronous operation.

Examples

//Upsert a user defined function that converts a string to upper case
UserDefinedFunction udf = client.UpsertUserDefinedFunctionAsync(collectionLink, new UserDefinedFunction
{
   Id = "ToUpper",
   Body = @"function toUpper(input) {
                       return input.toUpperCase();
                    }",
});

Exceptions

If either collectionLink or function is not set.

Represents a consolidation of failures that occured during async processing. Look within InnerExceptions to find the actual exception(s)