Interface IDocumentClient

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)

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}.

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.

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}.

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.

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

Parameters

collectionLink 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 collectionLink 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.

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: (Optional) The RequestOptions for the request.
disableAutomaticIdGeneration bool: A flag to disable automatic id generation.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of 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.

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.

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.

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.

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 DocumentCollection object.
options RequestOptions: (Optional) The RequestOptions 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).

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.

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}.

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.

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}.

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)

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

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

Parameters

databaseUri Uri: The URI of the parent database.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IOrderedQueryable<DocumentCollection>: The query result set.

CreateDocumentCollectionQuery(Uri, SqlQuerySpec, FeedOptions)

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

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: (Optional) The FeedOptions for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateDocumentCollectionQuery(Uri, string, FeedOptions)

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

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: (Optional) The FeedOptions 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}.

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, 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.

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, 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}.

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(Uri, FeedOptions)

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

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

Parameters

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

Returns

IOrderedQueryable<Document>: The query result set.

CreateDocumentQuery(Uri, SqlQuerySpec, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the document collection.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateDocumentQuery(Uri, string, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the document collection.
sqlExpression string: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateDocumentQuery<T>(string, FeedOptions)

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

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, 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.

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, 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}.

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>(Uri, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
feedOptions FeedOptions: (Optional) The FeedOptions 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, SqlQuerySpec, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the document collection.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions 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)

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

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

Parameters

documentCollectionUri Uri: The URI of the document collection.
sqlExpression string: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IQueryable<T>: The query result set.

Type Parameters

T: The type of object to query.

CreateOfferQuery(FeedOptions)

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

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 == collection.SelfLink);

// Find the offer for the database by SelfLink
Offer offer = client.CreateOfferQuery().Where(o => o.Resource == database.SelfLink);

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.

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}.

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.

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.

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 Permission object.
options RequestOptions: (Optional) The RequestOptions 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}.

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.

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}.

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)

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

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

Parameters

userUri Uri: The URI of the parent user.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IOrderedQueryable<Permission>: The query result set.

CreatePermissionQuery(Uri, SqlQuerySpec, FeedOptions)

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

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

Parameters

userUri Uri: The URI of the parent user.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreatePermissionQuery(Uri, string, FeedOptions)

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

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

Parameters

userUri Uri: The URI of the parent user.
sqlExpression string: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions 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.

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.

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 StoredProcedure object.
options RequestOptions: (Optional) The RequestOptions 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}.

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.

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}.

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)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IOrderedQueryable<StoredProcedure>: The query result set.

CreateStoredProcedureQuery(Uri, SqlQuerySpec, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateStoredProcedureQuery(Uri, string, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
sqlExpression string: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions 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.

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.

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 Trigger object.
options RequestOptions: (Optional) The RequestOptions 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}.

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 the Azure Cosmos DB service 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.

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.

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}.

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)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IOrderedQueryable<Trigger>: The query result set.

CreateTriggerQuery(Uri, SqlQuerySpec, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateTriggerQuery(Uri, string, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
sqlExpression string: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions 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.

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.

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 User object.
options RequestOptions: (Optional) The RequestOptions 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.

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.

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 UserDefinedFunction object.
options RequestOptions: (Optional) The RequestOptions 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}.

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 the Azure Cosmos DB service with parameterized values. It returns an IQueryable{dynamic}. For more information on preparing SQL statements with parameterized values, please see SqlQuerySpec.

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}.

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)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IOrderedQueryable<UserDefinedFunction>: The query result set.

CreateUserDefinedFunctionQuery(Uri, SqlQuerySpec, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateUserDefinedFunctionQuery(Uri, string, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
sqlExpression string: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions 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}.

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.

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{dyanamic}.

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)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IOrderedQueryable<User>: The query result set.

CreateUserQuery(Uri, SqlQuerySpec, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
querySpec SqlQuerySpec: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions for processing the query results feed.

Returns

IQueryable<dynamic>: The query result set.

CreateUserQuery(Uri, string, FeedOptions)

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

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
sqlExpression string: The sql query.
feedOptions FeedOptions: (Optional) The FeedOptions 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.

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 in the Azure Cosmos DB service.

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

Parameters

attachmentUri Uri: The URI of the attachment to delete.
options RequestOptions: (Optional) 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.

DeleteConflictAsync(string, RequestOptions)

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

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 in the Azure Cosmos DB service.

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

Parameters

conflictUri Uri: The URI of the conflict to delete.
options RequestOptions: (Optional) The RequestOptions 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.

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 in the Azure Cosmos DB service.

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

Parameters

databaseUri Uri: The URI of the database to delete.
options RequestOptions: (Optional) The RequestOptions 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.

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 in the Azure Cosmos DB service.

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

Parameters

documentUri Uri: The URI of the document to delete.
options RequestOptions: (Optional) 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<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.

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 in the Azure Cosmos DB service.

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

Parameters

documentCollectionUri Uri: The URI of the document collection to delete.
options RequestOptions: (Optional) The RequestOptions 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.

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 in the Azure Cosmos DB service.

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

Parameters

permissionUri Uri: The URI of the permission to delete.
options RequestOptions: (Optional) The RequestOptions 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.

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 in the Azure Cosmos DB service.

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

Parameters

storedProcedureUri Uri: The URI of the stored procedure to delete.
options RequestOptions: (Optional) The RequestOptions 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.

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 in the Azure Cosmos DB service.

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

Parameters

triggerUri Uri: The URI of the trigger to delete.
options RequestOptions: (Optional) The RequestOptions 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.

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 in the Azure Cosmos DB service.

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

Parameters

userUri Uri: The URI of the user to delete.
options RequestOptions: (Optional) The RequestOptions 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.

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 in the Azure Cosmos DB service.

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

Parameters

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

Returns

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

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.

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.

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.

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 in the Azure Cosmos DB service.

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: (Optional) The RequestOptions 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 in the Azure Cosmos DB service.

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

Parameters

storedProcedureUri Uri: The URI of the stored procedure to be executed.
options RequestOptions: (Optional) The RequestOptions for the request.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of 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 in the Azure Cosmos DB service.

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 as an asynchronous operation in the Azure Cosmos DB service.

Task<DatabaseAccount> GetDatabaseAccountAsync()

Returns

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

ReadAttachmentAsync(string, RequestOptions, CancellationToken)

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

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.

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) 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 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.

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 in the Azure Cosmos DB service.

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

Parameters

documentUri Uri: The URI of the parent document.
options FeedOptions: (Optional) The FeedOptions 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>>: 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.

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.

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.

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 in the Azure Cosmos DB service.

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
options FeedOptions: (Optional) The FeedOptions 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.

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.

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.

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.

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.

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) 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

//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.

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.

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) 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

//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.

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.

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.

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 in the Azure Cosmos DB service.

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

Parameters

databaseUri Uri: The URI of the parent Database.
options FeedOptions: (Optional) The FeedOptions 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.

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 in the Azure Cosmos DB service.

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

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
options FeedOptions: (Optional) The FeedOptions 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>>: 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.

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.

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.

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 = readResponse.Headers["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.

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.

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.

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.

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.

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.

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 in the Azure Cosmos DB service.

Task<FeedResponse<Permission>> ReadPermissionFeedAsync(Uri userUri, FeedOptions options = null)

Parameters

userUri Uri: The URI of the parent user.
options FeedOptions: (Optional) The FeedOptions 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.

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.

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.

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 in the Azure Cosmos DB service.

Task<FeedResponse<StoredProcedure>> ReadStoredProcedureFeedAsync(Uri documentCollectionUri, FeedOptions options = null)

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
options FeedOptions: (Optional) The FeedOptions 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.

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.

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.

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 in the Azure Cosmos DB service.

Task<FeedResponse<Trigger>> ReadTriggerFeedAsync(Uri documentCollectionUri, FeedOptions options = null)

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
options FeedOptions: (Optional) The FeedOptions 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.

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.

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.

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.

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.

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 in the Azure Cosmos DB service.

Task<FeedResponse<UserDefinedFunction>> ReadUserDefinedFunctionFeedAsync(Uri documentCollectionUri, FeedOptions options = null)

Parameters

documentCollectionUri Uri: The URI of the parent document collection.
options FeedOptions: (Optional) The FeedOptions 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.

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 in the Azure Cosmos DB service.

Task<FeedResponse<User>> ReadUserFeedAsync(Uri databaseUri, FeedOptions options = null)

Parameters

databaseUri Uri: The URI of the parent database.
options FeedOptions: (Optional) The FeedOptions 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.

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.

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: (Optional) 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.

ReplaceDocumentAsync(Document, RequestOptions, CancellationToken)

Replaces a Document in the Azure Cosmos DB service as an asynchronous operation.

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.

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.

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: (Optional) 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<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.

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.

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: (Optional) The RequestOptions 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.

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.
429	TooManyRequests - The replace offer is throttled as the offer scale down operation is attempted within the idle timeout period of 4 hours. Consult the DocumentClientException.RetryAfter value to see how long you should wait before retrying this operation.

See Also: Offer

RequestOptions

ResourceResponse<TResource>

Task

ReplacePermissionAsync(Permission, RequestOptions)

Replaces a Permission in the Azure Cosmos DB service as an asynchronous operation.

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.

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: (Optional) The RequestOptions 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.

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.

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: (Optional) The RequestOptions 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.

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.

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: (Optional) The RequestOptions 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.

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.

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: (Optional) The RequestOptions 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.

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.

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: (Optional) The RequestOptions 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.

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.

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.

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.

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 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.

UpsertAttachmentAsync(Uri, object, RequestOptions, CancellationToken)

Upserts an attachment as an asychronous operation in the Azure Cosmos DB service.

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: (Optional) 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.

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

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

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

Parameters

collectionLink 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 collectionLink 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 asychronous operation in the Azure Cosmos DB service.

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: (Optional) The RequestOptions for the request.
disableAutomaticIdGeneration bool: A flag to disable the automatic id generation.
cancellationToken CancellationToken: (Optional) A CancellationToken that can be used by other objects or threads to receive notice of 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.

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 asychronous operation in the Azure Cosmos DB service.

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 Permission object.
options RequestOptions: (Optional) The RequestOptions 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.

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 asychronous operation in the Azure Cosmos DB service.

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 StoredProcedure object.
options RequestOptions: (Optional) The RequestOptions 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.

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 asychronous operation in the Azure Cosmos DB service.

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 Trigger object.
options RequestOptions: (Optional) The RequestOptions 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.

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 asychronous operation in the Azure Cosmos DB service.

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 User object.
options RequestOptions: (Optional) The RequestOptions 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.

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)