Microsoft.EntityFrameworkCore

A DbContext instance represents a session with the database and can be used to query and save instances of your entities. DbContext is a combination of the Unit Of Work and Repository patterns.

Typically you create a class that derives from DbContext and contains properties for each entity in the model. If the properties have a public setter, they are automatically initialized when the instance of the derived context is created. Override the method to configure the database (and other options) to be used for the context. Alternatively, if you would rather perform configuration externally instead of inline in your context, you can use (or ) to externally create an instance of (or ) and pass it to a base constructor of . The model is discovered by running a set of conventions over the entity classes found in the properties on the derived context. To further configure the model that is discovered by convention, you can override the method.

Initializes a new instance of the class. The method will be called to configure the database (and other options) to be used for this context.

Initializes a new instance of the class using the specified options. The method will still be called to allow further configuration of the options.

The options for this context.

Gets the scoped being used to resolve services. This property is intended for use by extension methods that need to make use of services not directly exposed in the public API surface.

Override this method to configure the database (and other options) to be used for this context. This method is called for each instance of the context that is created. In situations where an instance of may or may not have been passed to the constructor, you can use to determine if the options have already been set, and skip some or all of the logic in .

A builder used to create or modify options for this context. Databases (and other extensions) typically define extension methods on this object that allow you to configure the context.

Override this method to further configure the model that was discovered by convention from the entity types exposed in properties on your derived context. The resulting model may be cached and re-used for subsequent instances of your derived context.

If a model is explicitly set on the options for this context (via ) then this method will not be run. The builder being used to construct the model for this context. Databases (and other extensions) typically define extension methods on this object that allow you to configure aspects of the model that are specific to a given database.

Saves all changes made in this context to the database.

This method will automatically call to discover any changes to entity instances before saving to the underlying database. This can be disabled via . The number of state entries written to the database.

Saves all changes made in this context to the database.

Asynchronously saves all changes made in this context to the database.

This method will automatically call to discover any changes to entity instances before saving to the underlying database. This can be disabled via . Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A to observe while waiting for the task to complete. A task that represents the asynchronous save operation. The task result contains the number of state entries written to the database.

Asynchronously saves all changes made in this context to the database.

Indicates whether is called after the changes have been sent successfully to the database. This method will automatically call to discover any changes to entity instances before saving to the underlying database. This can be disabled via . Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A to observe while waiting for the task to complete. A task that represents the asynchronous save operation. The task result contains the number of state entries written to the database.

Releases the allocated resources for this context.

Gets an for the given entity. The entry provides access to change tracking information and operations for the entity.

The type of the entity. The entity to get the entry for. The entry for the given entity.

Gets an for the given entity. The entry provides access to change tracking information and operations for the entity. This method may be called on an entity that is not tracked. You can then set the property on the returned entry to have the context begin tracking the entity in the specified state.

The entity to get the entry for. The entry for the given entity.

Begins tracking the given entity, and any other reachable entities that are not already being tracked, in the state such that they will be inserted into the database when is called.

The type of the entity. The entity to add. The for the entity. The entry provides access to change tracking information and operations for the entity.

Begins tracking the given entity, and any other reachable entities that are not already being tracked, in the state such that they will be inserted into the database when is called. This method is async only to allow special value generators, such as the one used by 'Microsoft.EntityFrameworkCore.Metadata.SqlServerValueGenerationStrategy.SequenceHiLo', to access the database asynchronously. For all other cases the non async method should be used.

The type of the entity. The entity to add. A to observe while waiting for the task to complete. A task that represents the asynchronous Add operation. The task result contains the for the entity. The entry provides access to change tracking information and operations for the entity.

Begins tracking the given entity in the state such that no operation will be performed when is called. A recursive search of the navigation properties will be performed to find reachable entities that are not already being tracked by the context. These entities will also begin to be tracked by the context. If a reachable entity has its primary key value set then it will be tracked in the state. If the primary key value is not set then it will be tracked in the state. An entity is considered to have its primary key value set if the primary key property is set to anything other than the CLR default for the property type.

The type of the entity. The entity to attach. The for the entity. The entry provides access to change tracking information and operations for the entity.

Begins tracking the given entity in the state such that it will be updated in the database when is called. All properties of the entity will be marked as modified. To mark only some properties as modified, use to begin tracking the entity in the state and then use the returned to mark the desired properties as modified. A recursive search of the navigation properties will be performed to find reachable entities that are not already being tracked by the context. These entities will also begin to be tracked by the context. If a reachable entity has its primary key value set then it will be tracked in the state. If the primary key value is not set then it will be tracked in the state. An entity is considered to have its primary key value set if the primary key property is set to anything other than the CLR default for the property type.

The type of the entity. The entity to update. The for the entity. The entry provides access to change tracking information and operations for the entity.

Begins tracking the given entity in the state such that it will be removed from the database when is called.

If the entity is already tracked in the state then the context will stop tracking the entity (rather than marking it as ) since the entity was previously added to the context and does not exist in the database. Any other reachable entities that are not already being tracked will be tracked in the same way that they would be if was called before calling this method. This allows any cascading actions to be applied when is called. The type of the entity. The entity to remove. The for the entity. The entry provides access to change tracking information and operations for the entity.

Begins tracking the given entity, and any other reachable entities that are not already being tracked, in the state such that they will be inserted into the database when is called.

The entity to add. The for the entity. The entry provides access to change tracking information and operations for the entity.

The entity to add. A to observe while waiting for the task to complete. A task that represents the asynchronous Add operation. The task result contains the for the entity. The entry provides access to change tracking information and operations for the entity.

The entity to attach. The for the entity. The entry provides access to change tracking information and operations for the entity.

The entity to update. The for the entity. The entry provides access to change tracking information and operations for the entity.

Begins tracking the given entity in the state such that it will be removed from the database when is called.

If the entity is already tracked in the state then the context will stop tracking the entity (rather than marking it as ) since the entity was previously added to the context and does not exist in the database. Any other reachable entities that are not already being tracked will be tracked in the same way that they would be if was called before calling this method. This allows any cascading actions to be applied when is called. The entity to remove. The for the entity. The entry provides access to change tracking information and operations for the entity.

Begins tracking the given entities, and any other reachable entities that are not already being tracked, in the state such that they will be inserted into the database when is called.

The entities to add.

The entities to add. A task that represents the asynchronous operation.

Begins tracking the given entities in the state such that no operation will be performed when is called. A recursive search of the navigation properties will be performed to find reachable entities that are not already being tracked by the context. These entities will also begin to be tracked by the context. If a reachable entity has its primary key value set then it will be tracked in the state. If the primary key value is not set then it will be tracked in the state. An entity is considered to have its primary key value set if the primary key property is set to anything other than the CLR default for the property type.

The entities to attach.

Begins tracking the given entities in the state such that they will be updated in the database when is called. All properties of each entity will be marked as modified. To mark only some properties as modified, use to begin tracking each entity in the state and then use the returned to mark the desired properties as modified. A recursive search of the navigation properties will be performed to find reachable entities that are not already being tracked by the context. These entities will also begin to be tracked by the context. If a reachable entity has its primary key value set then it will be tracked in the state. If the primary key value is not set then it will be tracked in the state. An entity is considered to have its primary key value set if the primary key property is set to anything other than the CLR default for the property type.

The entities to update.

Begins tracking the given entity in the state such that it will be removed from the database when is called.

If any of the entities are already tracked in the state then the context will stop tracking those entities (rather than marking them as ) since those entities were previously added to the context and do not exist in the database. Any other reachable entities that are not already being tracked will be tracked in the same way that they would be if was called before calling this method. This allows any cascading actions to be applied when is called. The entities to remove.

Begins tracking the given entities, and any other reachable entities that are not already being tracked, in the state such that they will be inserted into the database when is called.

The entities to add.

The entities to add. A to observe while waiting for the task to complete. A task that represents the asynchronous operation.

The entities to attach.

The entities to update.

Begins tracking the given entity in the state such that it will be removed from the database when is called.

Provides access to database related information and operations for this context.

Provides access to information and operations for entity instances this context is tracking.

The metadata about the shape of entities, the relationships between them, and how they map to the database.

Creates a that can be used to query and save instances of .

The type of entity for which a set should be returned. A set for the given entity type.

Finds an entity with the given primary key values. If an entity with the given primary key values is being tracked by the context, then it is returned immediately without making a request to the database. Otherwise, a query is made to the database for an entity with the given primary key values and this entity, if found, is attached to the context and returned. If no entity is found, then null is returned.

The type of entity to find. The values of the primary key for the entity to be found. The entity found, or null.

The type of entity to find. The values of the primary key for the entity to be found. A to observe while waiting for the task to complete. The entity found, or null.

The type of entity to find. The values of the primary key for the entity to be found. The entity found, or null.

The type of entity to find. The values of the primary key for the entity to be found. A to observe while waiting for the task to complete. The entity found, or null.

The options to be used by a . You normally override or use a to create instances of this class and it is not designed to be directly constructed in your application code.

Initializes a new instance of the class. You normally override or use a to create instances of this class and it is not designed to be directly constructed in your application code.

The extensions that store the configured options.

Gets the extensions that store the configured options.

Gets the extension of the specified type. Returns null if no extension of the specified type is configured.

The type of the extension to get. The extension, or null if none was found.

Gets the extension of the specified type. Throws if no extension of the specified type is configured.

The type of the extension to get. The extension.

Adds the given extension to the options.

The type of extension to be added. The extension to be added. The same options instance so that multiple calls can be chained.

The type of context that these options are for. Will return if the options are not built for a specific derived context.

Provides a simple API surface for configuring . Databases (and other extensions) typically define extension methods on this object that allow you to configure the database connection (and other options) to be used for a context. You can use to configure a context by overriding or creating a externally and passing it to the context constructor.

Initializes a new instance of the class with no options set.

Initializes a new instance of the class to further configure a given .

The options to be configured.

Gets the options being configured.

Gets a value indicating whether any options have been configured. This can be useful when you have overridden to configure the context, but in some cases you also externally provide options via the context constructor. This property can be used to determine if the options have already been set, and skip some or all of the logic in .

Sets the model to be used for the context. If the model is set, then will not be run.

The model to be used. The same builder instance so that multiple calls can be chained.

Sets the that will be used to create instances for logging done by this context.

The logger factory to be used. The same builder instance so that multiple calls can be chained.

Sets the to be used for query caching by this context. EF will create and manage a memory cache if none is specified.

The memory cache to be used. The same builder instance so that multiple calls can be chained.

Sets the that the context should resolve all of its services from. EF will create and manage a service provider if none is specified. The service provider must contain all the services required by Entity Framework (and the database being used). The Entity Framework services can be registered using the method. Most databases also provide an extension method on to register the services required. For example, the Microsoft SQL Server provider includes an AddEntityFrameworkSqlServer() method to add the required services. If the has a or registered, then this will be used as the options for this context instance.

The service provider to be used. The same builder instance so that multiple calls can be chained.

Enables application data to be included in exception messages, logging, etc. This can include the values assigned to properties of your entity instances, parameter values for commands being sent to the database, and other such data. You should only enable this flag if you have the appropriate security measures in place based on the sensitivity of this data.

The same builder instance so that multiple calls can be chained.

Sets the tracking behavior for LINQ queries run against the context. Disabling change tracking is useful for read-only scenarios because it avoids the overhead of setting up change tracking for each entity instance. You should not disable change tracking if you want to manipulate entity instances and persist those changes to the database using . This method sets the default behavior for all contexts created with these options, but you can override this behavior for a context instance using or on individual queries using the and methods. The default value is . This means the change tracker will keep track of changes for all entities that are returned from a LINQ query.

Configures the runtime behavior of warnings generated by Entity Framework. You can set a default behavior and behaviors for each warning type.


                    optionsBuilder.ConfigureWarnings(warnings => 
                        warnings.Default(WarningBehavior.Ignore)
                                .Log(CoreEventId.IncludeIgnoredWarning, CoreEventId.ModelValidationWarning)
                                .Throw(RelationalEventId.QueryClientEvaluationWarning))

An action to configure the warning behavior. The same builder instance so that multiple calls can be chained.

Replaces the internal Entity Framework implementation of a service contract with a different implementation. This method can only be used when EF is building and managing its internal service provider. If the service provider is being built externally and passed to , then replacement services should be configured on that service provider before it is passed to EF. The replacement service gets the same scope as the EF service that it is replacing.

The type (usually an interface) that defines the contract of the service to replace. The new implementation type for the service. The same builder instance so that multiple calls can be chained.

Adds the given extension to the options. If an existing extension of the same type already exists, it will be replaced. This method is intended for use by extension methods to configure the context. It is not intended to be used in application code.

The type of extension to be added. The extension to be added.

The type of context to be configured.

Initializes a new instance of the class with no options set.

Initializes a new instance of the class to further configure a given .

The options to be configured.

Gets the options being configured.

Sets the model to be used for the context. If the model is set, then will not be run.

The model to be used. The same builder instance so that multiple calls can be chained.

Sets the used for logging information from the context.

The to be used. The same builder instance so that multiple calls can be chained.

Sets the used to cache information such as query translations. If none is specified, then Entity Framework will maintain its own internal .

The to be used. The same builder instance so that multiple calls can be chained.

Sets the that the context will resolve its internal services from. If none is specified, then Entity Framework will maintain its own internal . By default, we recommend allowing Entity Framework to create and maintain its own for internal services.

The to be used. The same builder instance so that multiple calls can be chained.

The same builder instance so that multiple calls can be chained.

Configures the runtime behavior of warnings generated by Entity Framework. You can set a default behavior and behaviors for each warning type.


                    optionsBuilder.ConfigureWarnings(warnings => 
                        warnings.Default(WarningBehavior.Ignore)
                                .Log(CoreEventId.IncludeIgnoredWarning, CoreEventId.ModelValidationWarning)
                                .Throw(RelationalEventId.QueryClientEvaluationWarning))

An action to configure the warning behavior. The same builder instance so that multiple calls can be chained.

The type (usually an interface) that defines the contract of the service to replace. The new implementation type for the service. The same builder instance so that multiple calls can be chained.

The options to be used by a . You normally override or use a to create instances of this class and it is not designed to be directly constructed in your application code.

The type of the context these options apply to.

Initializes a new instance of the class. You normally override or use a to create instances of this class and it is not designed to be directly constructed in your application code.

The extensions that store the configured options.

Adds the given extension to the options.

The type of extension to be added. The extension to be added. The same options instance so that multiple calls can be chained.

The type of context that these options are for ().

A can be used to query and save instances of . LINQ queries against a will be translated into queries against the database. The results of a LINQ query against a will contain the results returned from the database and may not reflect changes made in the context that have not been persisted to the database. For example, the results will not contain newly added entities and may still contain entities that are marked for deletion. Depending on the database being used, some parts of a LINQ query against a may be evaluated in memory rather than being translated into a database query. objects are usually obtained from a property on a derived or from the method.

The type of entity being operated on by this set.

Gets an that represents a local view of all Added, Unchanged, and Modified entities in this set. This local view will stay in sync as entities are added or removed from the context. Likewise, entities added to or removed from the local view will automatically be added to or removed from the context. This property can be used for data binding by populating the set with data, for example by using the extension method, and then binding to the local data through this property. For WPF bind to this property directly. For Windows Forms bind to the result of calling ToBindingList on this property.

The values of the primary key for the entity to be found. The entity found, or null.

The values of the primary key for the entity to be found. A to observe while waiting for the task to complete. The entity found, or null.

Begins tracking the given entity, and any other reachable entities that are not already being tracked, in the state such that they will be inserted into the database when is called.

The entity to add. The for the entity. The entry provides access to change tracking information and operations for the entity.

The entity to attach. The for the entity. The entry provides access to change tracking information and operations for the entity.

Begins tracking the given entity in the state such that it will be removed from the database when is called.

If the entity is already tracked in the state then the context will stop tracking the entity (rather than marking it as ) since the entity was previously added to the context and does not exist in the database. Any other reachable entities that are not already being tracked will be tracked in the same way that they would be if was called before calling this method. This allows any cascading actions to be applied when is called. The entity to remove. The for the entity. The entry provides access to change tracking information and operations for the entity.

The entity to update. The for the entity. The entry provides access to change tracking information and operations for the entity.

Begins tracking the given entities, and any other reachable entities that are not already being tracked, in the state such that they will be inserted into the database when is called.

The entities to add.

Begins tracking the given entities, and any other reachable entities that are not already being tracked, in the state such that they will be inserted into the database when is called. This method is async only to allow special value generators, such as the one used by 'Microsoft.EntityFrameworkCore.Metadata.SqlServerValueGenerationStrategy.SequenceHiLo', to access the database asynchronously. For all other cases the non async method should be used.

The entities to add. A task that represents the asynchronous operation.

The entities to attach.

Begins tracking the given entity in the state such that it will be removed from the database when is called.

The entities to update.

Begins tracking the given entities, and any other reachable entities that are not already being tracked, in the state such that they will be inserted into the database when is called.

The entities to add.

The entities to add. A to observe while waiting for the task to complete. A task that represents the asynchronous operation.

The entities to attach.

Begins tracking the given entity in the state such that it will be removed from the database when is called.

The entities to update.

Returns an which when enumerated will execute a query against the database to load all entities from the database.

The query results.

Returns an which when enumerated will execute a query against the database to load all entities from the database.

The query results.

Returns an which when enumerated will asynchronously execute the query against the database.

The query results.

Gets the IQueryable element type.

Gets the IQueryable LINQ Expression.

Gets the IQueryable provider.

Gets the scoped being used to resolve services. This property is intended for use by extension methods that need to make use of services not directly exposed in the public API surface.

This method is called by data binding frameworks when attempting to data bind directly to a . This implementation always throws an exception as binding directly to a will result in a query being sent to the database every time the data binding framework requests the contents of the collection. Instead materialize the results into a collection, by calling a method such as or , and bind to the collection.

Always thrown. Never returns, always throws an exception.

Gets a value indicating whether the collection is a collection of System.Collections.IList objects. Always returns false.

An exception that is thrown when a concurrency violation is encountered while saving to the database. A concurrency violation occurs when an unexpected number of rows are affected during save. This is usually because the data in the database has been modified since it was loaded into memory.

Initializes a new instance of the class.

The error message that explains the reason for the exception. The entries that were involved in the concurrency violation.

An exception that is thrown when an error is encountered while saving to the database.

Initializes a new instance of the class.

The error message that explains the reason for the exception. The exception that is the cause of the current exception.

Initializes a new instance of the class.

The error message that explains the reason for the exception. The entries that were involved in the error.

Initializes a new instance of the class.

The error message that explains the reason for the exception. The entries that were involved in the error. The exception that is the cause of the current exception.

Gets the entries that were involved in the error. Typically this is a single entry, but in some cases it may be zero or multiple entries.

Static methods that are useful in application code where there is not an EF type for the method to be accessed from. For example, referencing a shadow state property in a LINQ query.

Addresses a given property on an entity instance. This is useful when you want to reference a shadow state property in a LINQ query. Currently this method can only be used in LINQ queries and can not be used to access the value assigned to a property in other scenarios.

The following code performs a filter using the a LastUpdated shadow state property.


                    var blogs = context.Blogs
                        .Where(b => EF.Property<DateTime>(b, "LastUpdated") > DateTime.Now.AddDays(-5))

The type of the property being referenced. The entity to access the property on. The name of the property. The value assigned to the property.

Entity Framework LINQ related extension methods.

Asynchronously determines whether a sequence contains any elements.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to check for being empty. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains true if the source sequence contains any elements; otherwise, false.

Asynchronously determines whether any element of a sequence satisfies a condition.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An whose elements to test for a condition. A function to test each element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains true if any elements in the source sequence pass the test in the specified predicate; otherwise, false.

Asynchronously determines whether all the elements of a sequence satisfy a condition.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An whose elements to test for a condition. A function to test each element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains true if every element of the source sequence passes the test in the specified predicate; otherwise, false.

Asynchronously returns the number of elements in a sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An that contains the elements to be counted. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the number of elements in the input sequence.

Asynchronously returns the number of elements in a sequence that satisfy a condition.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An that contains the elements to be counted. A function to test each element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the number of elements in the sequence that satisfy the condition in the predicate function.

Asynchronously returns an that represents the total number of elements in a sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An that contains the elements to be counted. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the number of elements in the input sequence.

Asynchronously returns an that represents the number of elements in a sequence that satisfy a condition.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An that contains the elements to be counted. A function to test each element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the number of elements in the sequence that satisfy the condition in the predicate function.

Asynchronously returns the first element of a sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the first element of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the first element in .

Asynchronously returns the first element of a sequence that satisfies a specified condition.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the first element of. A function to test each element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the first element in that passes the test in .

Asynchronously returns the first element of a sequence, or a default value if the sequence contains no elements.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the first element of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains default ( ) if is empty; otherwise, the first element in .

Asynchronously returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the first element of. A function to test each element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains default ( ) if is empty or if no element passes the test specified by ; otherwise, the first element in that passes the test specified by .

Asynchronously returns the last element of a sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the last element of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the last element in .

Asynchronously returns the last element of a sequence that satisfies a specified condition.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the last element of. A function to test each element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the last element in that passes the test in .

Asynchronously returns the last element of a sequence, or a default value if the sequence contains no elements.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the last element of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains default ( ) if is empty; otherwise, the last element in .

Asynchronously returns the last element of a sequence that satisfies a specified condition or a default value if no such element is found.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the last element of. A function to test each element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains default ( ) if is empty or if no element passes the test specified by ; otherwise, the last element in that passes the test specified by .

Asynchronously returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the single element of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the single element of the input sequence.

Asynchronously returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the single element of. A function to test an element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the single element of the input sequence that satisfies the condition in .

Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the single element of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the single element of the input sequence, or default ( ) if the sequence contains no elements.

Asynchronously returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An to return the single element of. A function to test an element for a condition. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the single element of the input sequence that satisfies the condition in , or default ( ) if no such element is found.

Asynchronously returns the minimum value of a sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An that contains the elements to determine the minimum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the minimum value in the sequence.

Asynchronously invokes a projection function on each element of a sequence and returns the minimum resulting value.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . The type of the value returned by the function represented by . An that contains the elements to determine the minimum of. A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the minimum value in the sequence.

Asynchronously returns the maximum value of a sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . An that contains the elements to determine the maximum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the maximum value in the sequence.

Asynchronously invokes a projection function on each element of a sequence and returns the maximum resulting value.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . The type of the value returned by the function represented by . An that contains the elements to determine the maximum of. A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the maximum value in the sequence.

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the sum of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the values in the sequence.

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the sum of the sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the sum of the projected values..

Asynchronously computes the average of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the average of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the average of the sequence of values.

Asynchronously computes the average of a sequence of values.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. A sequence of values to calculate the average of. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the average of the sequence of values.

Asynchronously computes the average of a sequence of values that is obtained by invoking a projection function on each element of the input sequence.

Multiple active operations on the same context instance are not supported. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. The type of the elements of . A sequence of values of type . A projection function to apply to each element. A to observe while waiting for the task to complete. A task that represents the asynchronous operation. The task result contains the average of the projected values.