NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
NuGet, #1077 most downloaded on NuGet
Azure WebJobs SDK Extension for the Durable Task Framework
Latest stable
3.19.0
Last release 10 days ago
10 Nov 2026
Ships fairly regularly
a new release about every 3 weeks
Nearly every release is documented
notes for 54 of the last 60 stable releases
4 versions withdrawn
withdrawn after publishing
127 years old
117 releases · first in 1900
Drag across the ruler to compare, or tap a release to open it.
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.6
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.6
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.5
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.5
Your coding agent can read these notes before it upgrades. Set up the MCP server →
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.4
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.4
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.3
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.3
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.2
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.2
Upgrade Microsoft.AspNetCore.Mvc.WebApiCompatShim from 2.1.0 to 2.2.0 (https://github.com/Azure/azure-functions-durable-extension/pull/2385)
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.1
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.1
Mitigated CVE-2022-1941 by updating transitive Google.ProtoBuf dependency
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.9.0
Note that to enable the display of activity function inputs when querying orchestration history, you must set the following configuration in your host.json file:
{
"extensions": {
"durableTask": {
"storeInputsInOrchestrationHistory": true
}
}
}
This setting tells the Durable Task Framework to save activity inputs in the history table (which it doesn't do by default).
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.8.1
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.8.1
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.8.0
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.8.0
DurableTask.Core --> v2.11.* DurableTask.AzureStorage --> v1.13.*
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.7.2
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.7.2
NuGet Gallery | Microsoft.Azure.WebJobs.Extensions.DurableTask 2.7.1
NuGet Gallery | Microsoft.Azure.WebJobs.Extensions.DurableTask 2.7.1
IConnectionStringResolver has been deprecated in favor of IConnectionInfoResolver
NuGet Gallery | Microsoft.Azure.WebJobs.Extensions.DurableTask 2.7.0
IConnectionStringResolver has been deprecated in favor of IConnectionInfoResolverStandardConnectionStringProvider and WebJobsConnectionStringProvider have been deprecated in favor of StandardConnectionInfoProvider and WebJobsConnectionInfoProviderThe remaining bug fixes are coming in transitively via our DTFx dependency updates:
See the release notes further below for more details.
See dependency updates below, which can be breaking if there are hard dependency conflicts (like .NET Framework 4.6.1)
Full Changelog: https://github.com/Azure/azure-functions-durable-extension/compare/v2.6.1...v2.7.0
Support specification of max entity operation batch size
IncludeDeleted to EntityQuery which controls whether to return deleted entities. (#1421)IDurableEntityClient.ListEntitiesAsync no longer returns deleted entities. (#1421)Microsoft.Azure.DurableTask.AzureStorage 1.9.4 -> 1.10.1 Microsoft.Azure.WebJobs.Extensions.DurableTask.Analyzers 0.4.1 -> 0.4.2
New HttpRetryOptions class for passing retry options to CallHttpAsync() invocations to add & customize retry behavior
HttpRetryOptions class for passing retry options to CallHttpAsync() invocations to add & customize retry behaviorHttpRetryOptions to DurableHttpRequest - set this property to use retry logic when you use the CallHttpAsync() overload that takes the full objectIDurableOrchestrationContext's CallHttpAsync(HttpMethod, Uri, string) overload now has a HttpRetryOptions parameterIDurableActivityContext now has a Name property.Microsoft.Azure.DurableTask.AzureStorage --> 1.9.4 Microsoft.Azure.DurableTask.Core 2.5.6 --> 2.6.0 Microsoft.Azure.WebJobs.Extensions.DurableTask.Analyzers 0.4.0 --> 0.4.1
Release Notes (v1.9.2) Release Notes (v1.9.1)
Added the ability to provide custom connection string names when creating a DurableClient in an ASP.NET Core app (external app)
DurableTask.AzureStorage --> 1.9.0 DurableTask.Core --> 2.5.6
Update dependencies to address CVE-2019-0548 and CVE-2021-26701 vulnerabilities
IDurableClient.MakeCurrentAppPrimaryAsync and the new HTTP API /makeprimary. This allows customers using the app lease feature to programmatically restore the primary app after a region failover without restarting their applications. (#1769 and DurableTask #529)ITypedDurableOrchestrationContext and ITypedDurableClient. The source generator looks at your source code for existing orchestrations and activities and creates new methods on these interfaces that have the correct method name, parameters and return type. See here for more details, and download the preview package on nuget.org.APPINSIGHTS_INSTRUMENTATIONKEY isn't set (#1787),https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.4.3
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.4.3
…target endpoint doesn't exist (#1718). This is a breaking change if you were handling HttpRequestExceptions by catching FunctionFailedExceptions.
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.4.2
type field under durableTask/storageProvider in host.json. If this field isn't set, then the storage backend will default to using Azure Storage. (#1702)HttpRequestExceptions by catching FunctionFailedExceptions.https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.4.1
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.4.1
If the value is true, then the response status code will be 500. This is a breaking change if you are using a unit test framework like Moq (recommende…
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.4.0
One of the long running requests we have received from customers is a way to improve the observability of their orchestration execution. The new distributed tracing functionality correlates all of the operations performed by an orchestration so that a single query can give a clear representation of the work that an orchestration instance has accomplished.
This feature was previously released as a separate alpha package, but now it can be used in our mainline package simply by adding a few settings to your host.json.
This feature is still a work in progress as we add support for all operation, but we encourage developers to try out this new tracing model to get better visibility into their orchestrations. The new samples should provide guidance for how to set up your application to use Distributed Tracing, as well as adding your own custom telemetry.
Before this release, the only way to perform management operations on orchestrations and entities was to use Azure Functions bindings to access an IDurableClient or to use the built-in management HTTP APIs. Thanks to a contribution by @davidrevoledo, instances of IDurableClient can be created in external ASP.NET Core, console, and Azure Functions applications via dependency injection!
Check out our new sample project for examples of how you can create these client instances in your own applications.
This release introduces a new API to restart orchestrations that may have failed or have terminated due to transient conditions. The restarted orchestration will use the same input as the original orchestration, and can reuse the instance id or use a new one.
This new API can be called with the C# method IDurableOrchestrationClient.RestartAsync(string instanceId, bool restartWithNewInstanceId) as well as the HTTP API /instances/<instance-id>/restart. Support for these APIs for Durable Functions apps running on Node and Python will be added in the near future with releases to each language's SDK.
BatchSize and BatchPosition properties to IDurableEntityContext(#1511)Timeout Property for DurableHttpRequest (#1547): This property defines the timeout for each HTTP request. This timeout applies to each asynchronous polling request too.IDurableEntityContext.DispatchAsync() directly to IDurableEntityContext interface to allow the method to be mockable using a unit test framework like Moq (recommended) (#1581)bool returnInternalServerErrorOnFailure parameter to WaitForCompletionOrCreateCheckStatusResponseAsync (#1572): This optional parameter is added to handle the HttpResponse that is returned. The default value is false, which means it will return a 200 status code. If the value is true, then the response status code will be 500. This is a breaking change if you are using a unit test framework like Moq (recommended) that mocks the WaitForCompletionOrCreateCheckStatusResponseAsync method. All that should be required is to account for the new parameter in your .Setup() method.https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.3.1
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.3.1
extensions.durableTask.storageProvider.useLegacyPartitionManagement to true in the host.json.IDurableEntityClient.CleanEntityStorageAsync() is a new API that will remove empty entities from storage and clean up orphaned locks.true (#1502)…to make them easier to unit test. This is a breaking change if you have custom implementations of these interfaces in your unit test code. If you are…
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.3.0
DurableTask.Core) and the Azure Storage provider logs (DurableTask.AzureStorage). See here for more information.IDurableOrchestrationContext, IDurableOrchestrationClient, IDurableEntityContext, and IDurableEntityClient to make them easier to unit test. This is a breaking change if you have custom implementations of these interfaces in your unit test code. If you are using a unit test framework like Moq (recommended) that can automatically implement interfaces, then this is a non-breaking change.https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.2.2
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.2.2
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.2.1
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.2.1
OrchestrationClientAttribute and binding type "orchestrationClient" for durable client bindings to make it easier to transition from Durable 1.x to Durable 2.x. (#1295)IDurableClient to make cross-app calls to Functions that do not exist on its own app (#1306)IErrorSerializerSettingsFactory in Activity/SubOrchestration contexts (#2194)For more information on the Durable Functions Analyzer, see these release notes: https://github.com/Azure/azure-functions-durable-extension/releases/tag/Analyzer-v0.2.0
We occasionally make small breaking changes in minor releases if we think the change is sufficiently warranted and the impact sufficiently small. The…
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.2.0
We are now including the Durable Task Roslyn Analyzer by default in all Durable Functions releases. This analyzer helps find common bugs that violate the rules of Durable Functions through live code analysis. See here for more details.
x-functions-key header from async polling request in CallHttpAsync() (#1217)IMessageSerializerSettingsFactory in orchestration and entity contexts (#1260)This extension release includes improvements that are specific to non-.NET releases of Durable Functions, including our JavaScript and soon our Python SDKs.
SignalEntityAsync() (#1271)We occasionally make small breaking changes in minor releases if we think the change is sufficiently warranted and the impact sufficiently small. The following minor breaking changes were made in this release:
IDurableOrchestrationContext.WaitForExternalEvent(). This should only break tests that either directly implement IDurableOrchestrationContext or that use Moq on IDurableOrchestrationContext.WaitForExternalEvent.Fix for direct implementation of IDurableOrchestrationContext:
Task<T> IDurableOrchestrationContext.WaitForExternalEvent<T>(string name, TimeSpan timeout) to Task<T> IDurableOrchestrationContext.WaitForExternalEvent<T>(string name, TimeSpan timeout, CancellationToken token)Task<T> IDurableOrchestrationContext.WaitForExternalEvent<T>(string name, TimeSpan timeout, T defaultValue) to Task<T> IDurableOrchestrationContext.WaitForExternalEvent<T>(string name, TimeSpan timeout, T defaultValue, CancellationToken token)Fix for using Moq on IDurableOrchestrationContext.WaitForExternalEvent():
It.IsAny<CancellationToken>() to IDurableOrchestrationContext.WaitForExternalEvent() in your .Setup() method.This is a patch release to the Durable Functions extension that contains several important bug fixes.
This is a patch release to the Durable Functions extension that contains several important bug fixes.
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.1.1
If you are using JavaScript or C# script (.csx), use the following command to install this version of the extension:
func extensions install -p Microsoft.Azure.WebJobs.Extensions.DurableTask -v 2.1.1
Note that this release is not yet available in extension bundles.
This is a minor update release to the Durable Functions extension that contains new features and bug fixes.
This is a minor update release to the Durable Functions extension that contains new features and bug fixes.
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.1.0
If you are using JavaScript or C# script (.csx), use the following command to install this version of the extension:
func extensions install -p Microsoft.Azure.WebJobs.Extensions.DurableTask -v 2.1.0
Note that this release is not yet available in extension bundles.
AllowSynchronousIO = false (#1085)[Obsolete] warning messages for abstract base classes (#1027)This release adds new methods in the following interfaces:
IDurableEntityClientIDurableEntityContextIDurableOrchestrationContextThese changes are not expected to break any application code. However, custom implementations of these interfaces in unit test code may be impacted. To avoid any impact to these kinds of interface updates, we recommend using test frameworks like Moq as described in our Unit Testing documentation and NOT creating your own implementations of these interfaces.
It is an incremental update from v2.0.0-beta3 and contains various small breaking changes.
This is the GA (Generally Available) release for Durable Functions 2.0. It is an incremental update from v2.0.0-beta3 and contains various small breaking changes.
This is an officially supported release. Subsequent 2.x releases will be non-breaking upgrades. We recommend that all new Durable Function apps use 2.x builds.
The nuget package for this extension can be found here: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.0.0
Instructions for how to update a 1.x Durable Function app to work with 2.x can be found here: https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-preview
NOTE: Most of the official documentation has been updated with 2.x content. However, there are still a few articles with older 1.x content. Those articles will be gradually updated over the next few days to reflect the new 2.x code samples and behaviors.
The following improvements were contributed directly to Microsoft.Azure.WebJobs.Extensions.DurableTask:
The following improvements were contributed to Microsoft.Azure.DurableTask.AzureStorage, which is a core dependency for both Durable 1.x and 2.x:
The following are breaking changes between v2.0.0-beta3 and v2.0.0 (this was our last opportunity to make breaking changes for a while).
v1 branch (#989)It also includes some additional breaking changes. See below for details on what has changed in this release.
Durable Functions v2.0.0-beta3 is an incremental update from the previous beta2 release. This is the last planned pre-release for Durable Functions 2.0 and adds some new features and important bug fixes. It also includes some additional breaking changes. See below for details on what has changed in this release.
You can download the beta3 build of the Durable Functions v2 extension from nuget here: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.0.0-beta3
There are three main features that we've added in this release:
We've developed a Roslyn C# analyzer that inspects your Durable Functions code for various code constraint violations and warns you if it finds any. It's based on the original Durable Functions analyzer developed by @stimms, who agreed to let us build on his code to create an "official" analyzer package. The goal is to make you both more productive and more confident in the Durable Functions code that you write.
You can download this new analyzer here: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask.Analyzers/
The analyzer provides a variety of warnings and code-fixes across client functions, orchestrator functions, and entity functions:
A few important things to note:
It's our very first attempt at building an analyzer, so there are going to be some bugs. Let us know if you encounter any by opening an issue.
For the best experience, you'll want to enable full solution analysis in your Visual Studio settings. This can be done in Tools -> Options -> Text Editor -> C# -> Advanced --> "Enable full solution analysis":
[Deterministic] attribute so that the analyzer knows to check them for correctness.The following example demonstrates how the [Deterministic] attribute is used:
[FunctionName("MyOrchestrator")]
public static async Task MyOrchestrator([OrchestrationTrigger] IDurableOrchestrationContext context)
{
object input = context.GetInput<object>();
object result1 = DirectCall(context, input);
object result2 = await DirectAsyncCall(context, result1);
object result3 = await context.CallActivityAsync<object>("MyActivity", result2);
// ...
}
[Deterministic]
private static object DirectCall(IDurableOrchestrationContext context, object input)
{
return IndirectCall(); // call another method, which must also be analyzed
}
[Deterministic]
private static object IndirectCall()
{
// ... some inline code goes here
}
[Deterministic]
private static async Task<object> DirectAsyncCall(IDurableOrchestrationContext context, object result1)
{
// ... this could be some wrapper around an activity function call, a durable timer, external event, etc.
}
[FunctionName("MyActivity")]
public static object MyActivity([ActivityTrigger] IDurableActivityContext context)
{
// ... a normal activity function. This is not required to have the [Deterministic] attribute.
}
Note that only methods which have an orchestrator function in the callstack are required to have the [Deterministic] attribute. Activity functions and client functions have no such requirement.
As part of this release, we have also added support for Durable Entities written in JavaScript. This new support exists starting in the v1.3.0 release on npm.org. Here is an example "Counter" entity written in JavaScript:
const df = require("durable-functions");
module.exports = df.entity(function(context) {
let currentValue = context.df.getState(() => 0);
switch (context.df.operationName) {
case "add":
const amount = context.df.getInput();
currentValue += amount;
break;
case "reset":
currentValue = 0;
break;
case "get":
context.df.return(currentValue);
break;
}
context.df.setState(currentValue);
});
Similarly, orchestrator functions written in JavaScript can invoke durable entities:
const df = require("durable-functions");
module.exports = df.orchestrator(function*(context){
const entityId = new df.EntityId("CounterEntity", "myCounter");
currentValue = yield context.df.callEntity(entityId, "get");
if (currentValue < 10) {
yield context.df.callEntity(entityId, "add", 1);
}
});
Also included in this release is support for Durable HTTP in JavaScript. Durable HTTP was first introduced as a new feature in beta2 for .NET and now we've made it available in JavaScript, including built-in support for leveraging Azure Managed Identities. Here is a sample JavaScript function which calls the Azure Resource Manager REST API to get a list of Azure Subscriptions available to the current user.
const df = require("durable-functions");
module.exports = df.orchestrator(function*(context) {
// get a list of the Azure subscriptions that I have access to
var res = yield context.df.callHttp(
"GET",
"https://management.azure.com/subscriptions?api-version=2019-06-01",
undefined, // no request content
undefined, // no request headers (besides auth which is handled by the token source)
df.ManagedIdentityTokenSource("https://management.core.windows.net"));
return res;
});
There were a couple breaking changes to Durable Entities introduced in this release.
IDurableEntityContext.IsNewlyConstructed has been renamed to HasState.IDurableEntityContext.DestructOnExit() has been renamed to DeleteState().[Deterministic] attribute for use with the Roslyn analyzer (#950)StartNewOrchestration from within orchestrations and entities (#917)As always, if you run into problems or have questions, please open an issue at https://github.com/Azure/azure-functions-durable-extension/issues/new/choose. Note that we have a separate repo that is specific to our JavaScript support, which you can find here: https://github.com/Azure/azure-functions-durable-js.
Updates to our official documentation are coming soon.
Durable Functions v2.0.0-beta2 is a breaking-change update from the previous beta1 release that adds some notable new features to Durable Functions 2.
Durable Functions v2.0.0-beta2 is a breaking-change update from the previous beta1 release that adds some notable new features to Durable Functions 2.0. See below for details on what has changed in this release.
Special thanks to @shibayan and @gled4er who voluntarily contributed to this release!
You can download the beta2 build of the Durable Functions v2 extension from nuget here: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.0.0-beta2
[OrchestrationClient] binding to [DurableClient] (#900)We have renamed the [OrchestrationClient] binding to [DurableClient]. This is because we wanted a binding name that worked for both orchestrations and entities. Supported argument types are IDurableOrchestrationClient (same as before), IDurableEntityClient (new), and IDurableClient, which combines both of the previous interface definitions.
We've introduced a new Durable HTTP feature that allows you to:
A very simple example of an orchestrator function making an HTTP call:
[FunctionName("CheckBing")]
public static async Task RunOrchestrator(
[OrchestrationTrigger] IDurableOrchestrationContext context)
{
DurableHttpResponse res = await context.CallHttpAsync(HttpMethod.Get, new Uri("https://bing.com"));
if (res.StatusCode != HttpStatusCode.OK)
{
throw new ArgumentException($"Bing.com is down! {res.StatusCode}: {res.Content}");
}
}
A more complex example of an orchestrator function making an ARM call to restart a VM:
[FunctionName("RestartVm")]
public static async Task RunOrchestrator(
[OrchestrationTrigger] IDurableOrchestrationContext context)
{
string subscriptionId = "mySubId";
string resourceGroup = "myRG";
string vmName = "myVM";
// Automatically fetches an Azure AD token for resource = https://management.core.windows.net
// and attaches it to the outgoing Azure Resource Manager API call.
var restartRequest = new DurableHttpRequest(
HttpMethod.Post,
new Uri($"https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart?api-version={apiVersion}"),
tokenSource: new ManagedIdentityTokenSource("https://management.core.windows.net"));
DurableHttpResponse restartResponse = await context.CallHttpAsync(restartRequest);
if (restartResponse.StatusCode != HttpStatusCode.OK)
{
throw new ArgumentException($"Failed to restart VM: {restartResponse.StatusCode}: {restartResponse.Content}");
}
}
A more complete example can be found in the precompiled C# "RestartVMs" samples.
Entity classes support the .NET dependency injection provided by the Azure Functions runtime. The following example demonstrates how to register an IHttpClientFactory service into a class-based entity.
[assembly: FunctionsStartup(typeof(MyNamespace.Startup))]
namespace MyNamespace
{
public class Startup : FunctionsStartup
{
public override void Configure(IFunctionsHostBuilder builder)
{
builder.Services.AddHttpClient();
}
}
}
The following snippet demonstrates how to incorporate the injected service into your entity class.
public class HttpEntity
{
private readonly HttpClient client;
public class HttpEntity(IHttpClientFactory factory)
{
this.client = factory.CreateClient();
}
public Task<int> GetAsync(string url)
{
using (var response = await this.client.GetAsync(url))
{
return (int)response.StatusCode;
}
}
// The function entry point must be declared static
[FunctionName(nameof(HttpEntity))]
public static Task Run([EntityTrigger] IDurableEntityContext ctx)
=> ctx.DispatchAsync<HttpEntity>();
}
For more information on dependency injection in Azure Functions, see the Azure Functions Dependency Injection documentation.
NOTE: Unlike when using constructor injection in regular .NET Azure Functions, the functions entry point method for class-based entities must be declared static. Declaring a non-static function entry point may cause conflicts between the normal Azure Functions object initializer and the Durable Entities object initializer.
Unlike regular functions, entity class methods do not have direct access to input and output bindings. Instead, binding data must be captured in the entry-point function declaration and then passed to the DispatchAsync<T> method. Any objects passed to DispatchAsync<T> will be automatically passed into the entity class constructor as an argument.
The following example shows how a CloudBlobContainer reference from the blob input binding can be made available to a class-based entity.
public class BlobBackedEntity
{
private readonly CloudBlobContainer container;
public BlobBackedEntity(CloudBlobContainer container)
{
this.container = container;
}
// ... entity methods can use this.container in their implementations ...
[FunctionName(nameof(BlobBackedEntity))]
public static Task Run(
[EntityTrigger] IDurableEntityContext context,
[Blob("my-container", FileAccess.Read)] CloudBlobContainer container)
{
// passing the binding object as a parameter makes it available to the
// entity class constructor
return context.DispatchAsync<BlobBackedEntity>(container);
}
}
For more information on bindings in Azure Functions, see the Azure Functions Triggers and Bindings documentation.
Note that it is possible to have a mix of both DispatchAsync and dependency injected objects as constructor arguments. Note, however, that the order of the constructor arguments must match the order of the DispatchEntity arguments.
Official documentation has not yet been updated to reflect these changes, but this should happen over the next week or so.
This will reduce the number of breaking changes that must be fixed, although using the old abstract base classes will result in "obsolete" warnings.
Durable Functions v2.0.0-beta1 is an update to the previous alpha release that contains some notable updates to Durable Functions 2.0.
For more comprehensive documentation of all the Durable Functions 2.0 features, please see our official documentation page: https://docs.microsoft.com/azure/azure-functions/durable/durable-functions-preview
In the previous release, we introduced "entity functions" which was a functional way of defining "durable entities" (actor-like stateful objects). The following is a C# entity function using the original programming model:
[FunctionName("Counter")]
public static void Counter([EntityTrigger] IDurableEntityContext ctx)
{
int currentValue = ctx.GetState<int>();
switch (ctx.OperationName.ToLowerInvariant())
{
case "add":
int amount = ctx.GetInput<int>();
currentValue += operand;
break;
case "reset":
currentValue = 0;
break;
case "get":
ctx.Return(currentValue);
break;
}
ctx.SetState(currentValue);
}
It's still possible to use this functional-style programming model for Durable Entities, but starting in the beta1 release, there is now an additional programming model that uses .NET classes. The following is the same Counter example as before, but using classes and properties instead of a single function:
public class Counter
{
[JsonProperty("value")]
public int CurrentValue { get; set; }
public void Add(int amount) => this.CurrentValue += amount;
public void Reset() => this.CurrentValue = 0;
public int Get() => this.CurrentValue;
[FunctionName(nameof(Counter))]
public static Task Run([EntityTrigger] IDurableEntityContext ctx)
=> ctx.DispatchAsync<Counter>();
}
In addition, new client APIs have been introduced which allow invoking durable entities using type-safe proxies (thanks to @shibayan for contributing this feature)!
Also, the precompiled C# samples have been updated to use this new programming model.
For more information on the updated programming model for Durable Entities, please refer to this documentation: https://docs.microsoft.com/azure/azure-functions/durable/durable-functions-preview#entity-functions
In the alpha release, we announced that we were dropping support for Azure Functions 1.0. After some careful consideration, we decided to walk back that decision and re-introduce support for Azure Functions 1.0. This effectively means that applications that depend on .NET Framework can also use Durable Functions 2.0.
More updates to host.json (BREAKING) (#641): We've continued to refactor the host.json configuration for Durable Functions to make it more organized. Find the latest schema definition here: host.json.
Support for HttpRequest/IActionResult in HTTP-specific APIs (#318): The Durable Functions HTTP APIs previously only supported HttpRequestMessage and HttpResponseMessage. Starting in this release, they now support the .NET Core-specific HttpRequest, HttpResponse, and IActionResult APIs which were introduced in Azure Functions 2.0.
Fixes related to duplicated entity signals (#762): This is a bug fix where it was possible for entity signals to be duplicated, resulting in unreliable behavior. In this release, sorting and de-duplication logic has been added to address this problem.
Add legacy compatibility for abstract base classes (#766): To make it easier to migrate from Durable Functions 1.0 to Durable Functions 2.0, we've re-introduced the abstract base "context" classes. This will reduce the number of breaking changes that must be fixed, although using the old abstract base classes will result in "obsolete" warnings.
Documentation for invoking Durable Entities over HTTP: Since the alpha release, Durable Entities could be invoked over built-in HTTP APIs. However, this was neither mentioned nor documented! As part of this release, we've updated the HTTP API documentation to include the APIs for signaling and querying durable entities. Also, a Counter sample has been added with instructions for invoking the entity using curl commands.
All fixes from the previous v1.x releases: Several bug fixes of gone into Durable Functions 1.0 since the last 2.0 release. This v2.0.0-beta1 release includes all bug fixes up to and including the v1.8.3 release.
Azure Pipelines and digital signing of assemblies: Starting with this release, all v2.0 are using Azure Pipelines for the build and release processes. As part of this migration, we are now Authenticode signing all DLLs shipped in our nuget package (previously we were only digitally signing the nuget package). Thanks to our newest team member @amdeel for making this happen!
You can download the beta1 build of the Durable Functions v2 extension from nuget here: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.0.0-beta1
Durable Functions 2.0.0-alpha is a breaking change release that contains the first iteration of some notable new features. It is consider an alpha qua…
Durable Functions 2.0.0-alpha is a breaking change release that contains the first iteration of some notable new features. It is consider an alpha quality preview release, and is intended for collecting early feedback from users. This release is not suitable for any production workloads, and subsequent releases may contain additional breaking changes.
Official documentation on this release can be found here: https://docs.microsoft.com/azure/azure-functions/durable/durable-functions-preview
LockAsync method in the orchestration context that allows taking locks on one or more durable entities. More information on this new functionality can be found here.durableTask has changed. This was done to support alternate storage providers. Please see this documentation for the latest.v2 branch until a later date. Durable Functions 1.x will continue to be developed in the dev and master branches.You can download the alpha build of the Durable Functions v2 extension from nuget here: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/2.0.0-alpha
Nothing published for this version
Dynamically generate ports for local RPC endpoints
This is a patch release to the Durable Functions extension that contains several important bug fixes.
This is a patch release to the Durable Functions extension that contains several important bug fixes.
https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/1.8.5
If you are using JavaScript or C# script (.csx), use the following command to install this version of the extension:
func extensions install -p Microsoft.Azure.WebJobs.Extensions.DurableTask -v 1.8.5
Note that this release is not yet available in extension bundles.
ControlQueueBufferThreshold configurable, and increases default from 64 to 256 (#1077)ObjectDisposedException when function host shuts down (#472)StartNewAsync() behavior of overwriting currently running orchestration instances when existing instance ids are used to instead throw an exception with the host.json setting overridableExistingInstanceStates:"NonRunningStates" (#1204)Also includes the following bug fixes/improvements from v1.8.4:
WaitForExternalEvent with CancellationToken overloads (#820)Nothing published for this version
The v1.8.3 release is a bug fix release with several fixes/improvements over v1.8.2.
The v1.8.3 release is a bug fix release with several fixes/improvements over v1.8.2.
DurableTask.AzureStorage nuget dependency to v1.6.3This release can be downloaded from nuget.org: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/1.8.3
For more information on Durable Functions, see our official documentation: https://docs.microsoft.com/azure/azure-functions/durable/durable-functions-overview
Previously large orchestration inputs and outputs would result in orchestration instance status query results that returned a blob storage URL instead of the actual input or output content. This meant that custom code needed to be written to handle the case where either the output was a blob storage URL or the JSON-encoded input or output of the orchestration. This non-deterministic behavior was problematic enough that we decided change the behavior to always download the full orchestration inputs and outputs (the blob URL behavior is actually a recent change, which we're effectively reverting).
If you depended on the previous behavior of returning blob storage URLs for large inputs or outputs, you disable the "always fetch" behavior in host.json as shown below:
{
"durableTask": {
"fetchLargeMessagesAutomatically": false
}
}
The v1.8.2 release is a bug fix release with several fixes/improvements over v1.8.1.
The v1.8.2 release is a bug fix release with several fixes/improvements over v1.8.1.
This release can be downloaded from nuget.org: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/1.8.2
For more information on Durable Functions, see our official documentation: https://docs.microsoft.com/azure/azure-functions/durable/durable-functions-overview
The v1.8.1 release is a bug fix release with several fixes/improvements over v1.8.0.
The v1.8.1 release is a bug fix release with several fixes/improvements over v1.8.0.
This release can be downloaded from nuget.org: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/1.8.1
For more information on Durable Functions, see our official documentation: https://docs.microsoft.com/azure/azure-functions/durable/durable-functions-overview
The v1.8.0 release contains several features and bug fixes. Most of the bug fixes are related to reliability and error handling. All new features in t
The v1.8.0 release contains several features and bug fixes. Most of the bug fixes are related to reliability and error handling. All new features in this release were developed by external contributors, who are called out below (some of whom are first time contributors).
Thanks for all those who helped make this release possible with great contributions and/or bug reports!
The latest nuget package can be downloaded here: Microsoft.Azure.WebJobs.Extensions.DurableTask. The package is digitally signed by Microsoft to ensure its integrity and authenticity.
This is a bug fix release that addresses the following issues:
This is a bug fix release that addresses the following issues:
RaiseEventAsync and ContinueAsNew (#572)This release can be downloaded from nuget.org: https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask/1.7.1
For more information on Durable Functions, see our official documentation: https://docs.microsoft.com/azure/azure-functions/durable/durable-functions-overview
The v1.7.0 release is a minor update for Durable Functions. While it is "minor" according to the semver definition, it is a _significant_ release in t
The v1.7.0 release is a minor update for Durable Functions. While it is "minor" according to the semver definition, it is a significant release in terms of the actual payload. There are many new features, improvements, important bug fixes, and is fully compatible with both Functions 1.0 and Functions 2.0. It also includes support for command-line management of orchestrations via the Azure Functions Core Tools.
Thanks to everyone who contributed, either via code, asking good questions, or by filing issues! Special thanks goes to @gled4er, @TsuyoshiUshio, @cmkerner20 (one of our Summer interns), @k-miyake (first-time contributor), @mlankamp (first-time contributor) and @brandonh-msft for their community contributions, including code and documentation!
New features are primarily oriented around orchestration instance and data management.
DurableOrchestrationContext.NewGuid() API, it's now possible to create randomly generated GUID/UUID values in a way that is safe for replays (docs). Contributed by @gled4er.showInput parameter has been added which allows the caller to remove the inputs from the response (docs).DurableActivityContextBase class that can be used for mocking activity functions (docs). Contributed by @gled4er.There are some very significant bug fixes in this release, making it a highly-recommended upgrade.
Worth calling out separately, this release also includes support for a new Durable Functions-specific commands in the next release (>= 2.3.131) of the Azure Functions Core Tools for Azure Functions 2.0. These commands are intended to enable users to manage their orchestrations without the need for calling REST APIs.
The GitHub Pull Request for these updates can be found here: https://github.com/Azure/azure-functions-core-tools/pull/838).
Supported commands include:
func durable start-new ... to start a new instance of an orchestrator functionfunc durable get-runtime-status ... to query the status of a running orchestrationfunc durable get-instances ... to query for orchestrations based on their status, creation time, and/or completion timefunc durable terminate ... to terminate orchestration instancesfunc durable raise-event ... to send event notifications to running orchestrationsfunc durable rewind ... to resurrect failed orchestration instances (rewind functionality is currently in preview)func durable purge-history ... to purge history data from Azure Storage based on a particular time rangefunc durable delete-task-hub ... to permanently delete all Azure Storage data associated with your durable function app (queues, tables, and blobs).These commands work by making calls directly to Azure Storage, so they do not require the durable function app to be actually running. They also work with both real Azure Storage accounts and the Azure Storage Emulator on Windows devices. More details can be found in the Instance Management documentation topic. Originally contributed by @cmkerner20.
Previously the Durable Functions documentation was mixed in with the regular Azure Functions documentation in a way that made it fairly difficult to navigate. As part of this release, we have also revamped the organization of the docs into their own sub-section. The new home for the Durable docs can be found here: https://docs.microsoft.com/azure/azure-functions/durable. It has the following sections:
Be sure to check out the new documentation layout. If there's anything you think is missing or needs fixing up, feel free to leave us feedback or open a docs PR using the links on the page!
Note that some of the old links might return 404 currently. We're working on fixing those so that they redirect to the new locations.
The latest nuget package can be downloaded here: Microsoft.Azure.WebJobs.Extensions.DurableTask. The package is digitally signed by Microsoft to ensure its integrity and authenticity.
The v1.6.2 release is a patch update for Durable Functions. Here are the important details:
The v1.6.2 release is a patch update for Durable Functions. Here are the important details:
All samples (with the exception of WebJobs) have also been updated to target Azure Functions 2.0 using this release.
For more information about Durable Functions and how to get started, please see our official documentation on docs.microsoft.com: https://docs.microsoft.com/azure/azure-functions/durable-functions-overview
Nothing published for this version
Azure Functions v2.0 (preview) breaking change compatibility
The v1.6.0 release is a minor update for Durable Functions. It contains new features, various improvements, and bug fixes. The two biggest areas of focus are:
Regarding <span>#</span>2, all Azure Functions v2 users will need to upgrade to this release. Previous versions of Durable Functions are no longer expected to work with Azure Functions v2 as of the most recently announced v2 update. Please see the Functions v2 Breaking Changes section below for additional notes and instructions.
Thanks to everyone who contributed, either via code, asking good questions, or by filing issues! Special thanks goes to @TsuyoshiUshio, @markheath, @yuka1984 for their community contributions (including code and documentation)! And extra special thanks goes to @cmkerner20, one of our summer interns, who contributed a new "orchestration rewind" feature!
timeout parameter has been added to this API, greatly simplifying this common pattern. Thanks to @markheath for this community contribution!taskHub parameter has been added to the RaiseEventAsync API which allows a function in one function app to easily raise events to an orchestration running in another function app. Thanks to @yuka1984 for this community contribution!The names of the dependent Durable Task Framework nuget packages have changed.
It was recently announced that major Azure Functions v2 breaking changes were coming (please subscribe to the announcements repo if you were not aware of this!). This release is intended to be compatible with the announced breaking changes. The sections below will go into further detail.
These compatibility constraints apply to both the Azure Functions runtime running in Azure as well as the Azure Functions CLI tools.
All host.json settings for Durable Functions must now be placed inside an "extensions" section (other non-durable trigger-specific settings have also moved here). For example:
{
"version":"2.0",
"extensions": {
"durableTask": {
"hubName": "MyTaskHubV2",
"azureStorageConnectionStringName": "storagewestus12345"
}
}
}
If you do not make these changes, then the default settings will be used and there are no warnings or errors to notify you about this.
The Azure Functions runtime controls the URL prefixes for all built-in extension endpoints. With the v2 release, the /DurableTaskExtension/ segment of each URL has been changed to /durabletask/. For example, when querying for the status of an orchestration instance:
GET /runtime/webhooks/DurableTaskExtension/instances/{instanceId}?code=XYZ
...now becomes...
GET /runtime/webhooks/durabletask/instances/{instanceId}?code=XYZ
Additional notes related to this breaking change on how this may impact you:
These updates will be reflected in the HTTP API documentation in the near future.
The latest nuget package can be downloaded here: Microsoft.Azure.WebJobs.Extensions.DurableTask
Please see our installation documentation for instructions for all supported platforms.
The v1.5.0 release is a minor update for Durable Functions. It contains new features, various improvements, and bug fixes. The biggest focus was on im
The v1.5.0 release is a minor update for Durable Functions. It contains new features, various improvements, and bug fixes. The biggest focus was on improving on some key pain points since the GA release, as well as enabling support for the latest Azure Functions v2 runtime.
Thanks to everyone who contributed, either via code, asking good questions, or by filing issues! Special thanks goes to @gled4er, @TsuyoshiUshio, and @yuka1984 for their community contributions (including code and documentation)! The specific contributions are called out below.
CreateHttpManagementPayload API to get status/terminate/raise-event URLs (#155): Previously only HTTP-triggered functions could discover management endpoint URLs. With this API, any function trigger can now discover this information via DurableOrchestrationClient. See the Instance management documentation for more details. Thanks @gled4er for this community contribution!Also note that due to an internal policy change on nuget.org, the dependent DurableTask.AzureStorage and DurableTask.Core nuget packages have been temporarily renamed to DurableTask.AzureStorage.Private and DurableTask.Core.Private.
The latest nuget package can be downloaded here: Microsoft.Azure.WebJobs.Extensions.DurableTask
Please see our installation documentation for instructions for all supported platforms (be sure to always select the latest version of the extension).
Note that the Azure Functions portal, the Azure Functions CLI, and the Visual Studio tools for Azure Functions and Azure WebJobs may run into issues when using the latest version of the Durable Functions extension at the time of writing. Updates for these tools are in the works.
Nothing published for this version
It contains new features, various fixes, and a few small compile-time breaking changes (last-minute public surface area cleanup). The biggest focus wa…
This is the very first GA release for Durable Functions. It contains new features, various fixes, and a few small compile-time breaking changes (last-minute public surface area cleanup). The biggest focus was on improving performance and scale.
This is an officially supported release. Subsequent 1.x releases will be non-breaking upgrades.
Thanks to everyone who contributed, either via code, asking good questions, or by filing issues! Special thanks goes to @gled4er, @TsuyoshiUshio, @mikhailshilkov, @CarlosSardo, and @MS-Santi for their community contributions (including code, samples, and documentation)!
GetInputAsJson and GetRawInput internal [Breaking change!]Please see our installation documentation for instructions for all supported platforms.
Nothing published for this version
Nothing published for this version
Nothing published for this version
As with most pre-releases, it contains several important fixes, new features, and breaking changes. Thanks to everyone who contributed, either via cod…
This is the RC (Release Candidate) release of the Durable Functions extension to Azure Functions, and contains a significant number of updates. As with most pre-releases, it contains several important fixes, new features, and breaking changes. Thanks to everyone who contributed, either via code, asking good questions, or by filing issues!
Special thanks goes to @gled4er, @TsuyoshiUshio, @yuka1984, @kingkino, @rukasakurai, and @hamamotsu for their community contributions!
SetCustomStatus API has been introduced which allows an orchestrator function to expose "progress" state to external callers. The state can be a simple string or a complex JSON object.DurableOrchestrationClient (https://github.com/Azure/azure-functions-durable-extension/issues/224)DurableOrchestrationContext.ParentInstanceId) (https://github.com/Azure/azure-functions-durable-extension/pull/257)Anyone can start using the v1.3.1-rc release by referencing the latest Microsoft.Azure.WebJobs.Extensions.DurableTask NuGet package in their projects.
Update your .csproj file with the following package reference:
<PackageReference Include="Microsoft.Azure.WebJobs.Extensions.DurableTask" Version="1.3.1-rc" />
Use the following command to install the updated extension into your project:
func extensions install -p Microsoft.Azure.WebJobs.Extensions.DurableTask -v 1.3.1-rc
The Azure Portal Durable Functions templates for projects targeting Functions 2.0 (preview) will automatically install this version of the extension at a later date.
There are runtime breaking changes in this release, so it is highly recommended to use this new package version with new function apps.
If you have an existing function app that you would like to migrate to this version, please see the versioning and migration strategies documentations for best practices.
Documentation has not been published yet for these new features, but expect the docs to trickle in over the next few weeks. In the meantime, here are some quick notes for how to get started with some of the new features.
This is a feature which allows users to set a custom status value from their orchestrator function, and have it exposed via the HTTP GetStatus API or the DurableOrchestrationClient.GetStatusAsync API.
Here is a simple example of how it works, starting with the orchestrator function code:
public static async Task SetStatusTest([OrchestrationTrigger] DurableOrchestrationContext ctx)
{
// ...do work...
// update the status of the orchestration with some arbitrary data
var customStatus = new { nextActions = new [] {"A", "B", "C"}, foo = 2, };
ctx.SetCustomStatus(customStatus);
// ...do more work...
}
While the orchestration is running, external clients can fetch this custom status. For example:
GET /admin/extensions/DurableTaskExtension/instances/instance123
...yields the following JSON status payload...
{
"runtimeStatus": "Running",
"input": null,
"customStatus": { "nextActions": ["A", "B", "C"], "foo": 2 },
"output": null,
"createdTime": "2017-10-06T18:30:24Z",
"lastUpdatedTime": "2017-10-06T19:40:30Z"
}
The custom status payload is limited to 16 KB of UTF-16 JSON text. If larger custom status payloads are required, the recommendation is to store them outside the orchestration state in a store like Azure Storage or Cosmos DB.
Azure Event Grid orchestration lifecycle publishing can be enabled by specifying the eventGridTopEndpoint and eventGridKeyName fields in the durableTask section of host.json:
{
"durableTask": {
"eventGridTopicEndpoint": "YOUR_EVENT_GRID_TOPIC_ENDPOINT_SAS_URL",
"eventGridKeySettingName": "YOUR_EVENT_GRID_TOPIC_KEY_APP_SETTING"
}
}
Note that the eventGridKeySettingName field should be the name of an Application Setting or environment variable which contains the actual secret key value. You should never put your Event Grid key directly in host.json.
The eventType for these events is orchestratorEvent and the subject is durable/orchestrator/{orchestrationRuntimeStatus}, where {orchestrationRuntimeStatus} can be Running, Completed, Failed, or Terminated.
This is a minor update to the third beta release which contains a small number of important fixes and improvements over the original beta 3 release.
This is a minor update to the third beta release which contains a small number of important fixes and improvements over the original beta 3 release.
For anyone impacted by the StartNewAsync timeout issue, you can add the following JSON configuration to your host.json file to work around the issue.
{
"durableTask": {
"disableStartInstancePolling": true
}
}
The behavior you will observe is that DurableOrchestrationClient.StartNewAsync will return quickly, but the started instance may not be visible for several seconds. An improved fix is scheduled for the next release and the above configuration will no longer have any effect.
Anyone can start using the v1.2.2-beta3 release by referencing the latest Microsoft.Azure.WebJobs.Extensions.DurableTask NuGet package in their projects.
Update your .csproj file with the following package reference:
<PackageReference Include="Microsoft.Azure.WebJobs.Extensions.DurableTask" Version="1.2.2-beta3" />
Use the following command to install the updated extension into your project:
func extensions install -p Microsoft.Azure.WebJobs.Extensions.DurableTask -v 1.2.2-beta3
The Azure Portal Durable Functions templates for projects targeting Functions 2.0 will automatically install this version of the extension into the function app starting April 2.
Nothing published for this version
This is the third beta release and contains several important fixes, new features, and breaking changes. Thanks to everyone who contributed, either vi…
This is the third beta release and contains several important fixes, new features, and breaking changes. Thanks to everyone who contributed, either via code, asking good questions, or by filing issues!
Special thanks goes to @gled4er and @brandonh-msft for their community contributions!
Many new features were included in this release:
statusEndpointGetUrl by including the showHistory=true query string parameter.Proper documentation is still being written for these new features, so stay tuned for that.
Anyone can start using the v1.2.0-beta3 release by referencing the latest Microsoft.Azure.WebJobs.Extensions.DurableTask NuGet package in their projects.
Update your .csproj file with the following package reference:
<PackageReference Include="Microsoft.Azure.WebJobs.Extensions.DurableTask" Version="1.2.0-beta3" />
Use the following command to install the updated extension into your project:
func extensions install -p Microsoft.Azure.WebJobs.Extensions.DurableTask -v 1.2.0-beta3
The Azure Portal templates do not currently support installing or updating to v1.2.0-beta3. :( Please consider using the Azure Functions CLI experience instead, and deploying your local changes to Azure.
There are runtime breaking changes in this release, so it is highly recommended to use this new package version with new function apps.
If you have an existing function app that you would like to migrate to this version, please see the versioning and migration strategies documentations for best practices.
This is the second beta release and contains several important fixes, new features, and breaking changes. Thanks to everyone who contributed, either v…
This is the second beta release and contains several important fixes, new features, and breaking changes. Thanks to everyone who contributed, either via code, asking good questions, or by filing issues!
Retry-After response headers to the create and HTTP status query APIs for improved integration with Logic Apps (#99)Anyone can start using the v1.1.0-beta2 release by referencing the latest Microsoft.Azure.WebJobs.Extensions.DurableTask NuGet package in their projects.
Update your .csproj file with the following package reference:
<PackageReference Include="Microsoft.Azure.WebJobs.Extensions.DurableTask" Version="1.1.0-beta2" />
Use the following command to install the updated extension into your project:
func extensions install -p Microsoft.Azure.WebJobs.Extensions.DurableTask -v 1.1.0-beta2
The Azure Portal templates do not currently support installing or updating to v1.1.0-beta2. :( Please consider using the Azure Functions CLI experience instead, and deploying your local changes to Azure.
There are both compile time and runtime breaking changes in this release, so it is highly recommended to use this new package version with new function apps.
If you have an existing function app that you would like to migrate to this version, please see the versioning and migration strategies documentations for best practices.
Nothing published for this version
One column per quarter.