public void ConfigureServices(IServiceCollection services)
{
    services.AddTus2(options =>
    {
        // Shorthand for adding a scoped implementation of Tus2DiskStorage to the DI container
        options.AddDiskStorage(@"C:\path\to\save\files");
        // Adds MyTusHandler as transient
        options.AddHandler<MyTusHandler>();
    });
}
public void Configure(IApplicationBuilder app)
{
    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapTus2<MyTusHandler>("/files-tus-2");
    });
}

public class MyTusHandler : TusHandler
{
    private readonly ILogger _logger;
    private readonly Tus2StorageFacade _storage;
    public MyTusHandler(ILoggerFactory loggerFactory, Tus2StorageFacade storage)
        : base(storage)
    {
        _logger = loggerFactory.CreateLogger(nameof(MyTusHandler));
        _storage = storage;
    }
    public override bool AllowClientToDeleteFile => true;
    // Set to false to not report progress back to the client. This is needed as some clients (e.g. the one in golang) errors out after a fixed number of 104 responses.
    // Default value is true.
    public override bool EnableReportingOfProgress => true;
    // Limits that apply for this handler to handle files. Limits or any of its properties can be null. Note that these are note validated on the next request and are just kept as a hint for the client.
    // Default value is null (i.e. no limits).
    public override TusHandlerLimits? Limits => new()
    {
        Expiration = TimeSpan.FromHours(24),
        MaxSize = 1024 * 1024 * 1024,
        MaxAppendSize = 100 * 1024 * 1024,
        MinSize = 1024,
        MinAppendSize = 5 * 1024 * 1024
    };
    public override async Task<CreateFileProcedureResponse> CreateFile(CreateFileContext context)
    {
        _logger.LogInformation("Creating file {UploadToken}", context.Headers.UploadToken);
        var response = await _storage.CreateFile(context);
        _logger.LogInformation("File created? {Success}", response.Status == System.Net.HttpStatusCode.Created);
        return response;
    }
    public override async Task<UploadTransferProcedureResponse> WriteData(WriteDataContext context)
    {
        _logger.LogInformation("Receiving upload, starting at {UploadOffset}", context.Headers.UploadOffset);
        var response = await base.WriteData(context);
        _logger.LogInformation("Was success? {Success}", response.Status == System.Net.HttpStatusCode.Created);
        return response;
    }
    public override async Task<UploadRetrievingProcedureResponse> RetrieveOffset(RetrieveOffsetContext context)
    {
        _logger.LogInformation("Retrieving offset for {UploadToken}", context.Headers.UploadToken);
        var response = await base.RetrieveOffset(context);
        _logger.LogInformation("Offset is {UploadOffset}", response.UploadOffset);
        return response;
    }
    public override async Task<UploadCancellationProcedureResponse> Delete(DeleteContext context)
    {
        _logger.LogInformation("Deleting file {UploadToken}", context.Headers.UploadToken);
        var response = await base.Delete(context);
        _logger.LogInformation("File deleted? {Deleted}", response.Status == System.Net.HttpStatusCode.NoContent);
        return response;
    }
    public override Task FileComplete(FileCompleteContext context)
    {
        _logger.LogInformation("File {UploadToken} is complete", context.Headers.UploadToken);
        return base.FileComplete(context);
    }
}

services.AddTus2(options =>
{
    // SimpleTus2StorageFactory being a class implementing ITus2StorageFactory. 
    // Same as adding a scoped instance of <ITus2StorageFactory, SimpleTus2StorageFactory()>
    options.AddStorageFactory(new SimpleTus2StorageFactory());
    options.AddHandler<MyTusHandler>();
});
app.UseEndpoints(endpoints =>
{
    endpoints.MapTus2<MyTusHandler>("/files-tus-2");
});
// Handler constructor needs to be updated to use the storage factory and a possible name of the storage.
public class MyTusHandler : TusHandler
{
    public MyTusHandler(ITus2ConfigurationManager config)
        : base(config, "MyStorage") // "MyStorage" is optional and will provide the string "MyStorage" to the factory.
    {
    }
    ...
}

services.AddTus2(options =>
{
    // Add disk based ongoing upload manager as a scoped instance.
    options.AddDiskBasedUploadManager(@"C:\tusfiles");
    // The above is the same as calling:
    options.AddUploadManager(new OngoingUploadManagerDiskBased(new() { SharedDiskPath = @"C:\tusfiles" }));
    // OR use your own:
    // Add an instance as a scoped instance...
    options.AddUploadManager(new RedisOngoingUploadManager("connection string"));
    // ... or add ongoing upload manager factory as a scoped instance.
    builder.AddUploadManagerFactory(new RedisOngoingUploadManagerFactory());
});

services.AddTus2(options =>
{
    // Defaults
    options.AddDiskStorage(@"C:\tusfiles");
    options.AddUploadManager(new OngoingUploadManagerDiskBased(new() { SharedDiskPath = System.IO.Path.GetTempPath() }));
    // Storage factory
    options.AddStorageFactory(new SimpleTus2StorageFactory());
});
public class MyService
{
    private readonly ITus2ConfigurationManager _config;
    private readonly Tus2Storage _defaultStorage;
    private readonly Tus2StorageFacade _defaultStorageFacade;
    private readonly IOngoingUploadManager _defaultUploadManager;
    public MyService(
        ITus2ConfigurationManager config,
        IOngoingUploadManager defaultUploadManager,
        Tus2StorageFacade facade,
        TUs2Storage storage)
    {
        _config = config;
        _defaultUploadManager = defaultUploadManager;
        _defaultStorageFacade = facade;
        _defaultStorage = storage;
    }
    public async Task MyMethod()
    {
        var defaultStorage = await _config.GetDefaultStorage();
        var defaultStorage2 = await _config.GetDefaultStorage();
        // Calls SimpleTus2StorageFactory.CreateNamedStorage with name "MyProfile".
        var myProfileStorage = await _config.GetNamedStorage("MyProfile");
        var defaultUploadManager = await _config.GetDefaultUploadManager();
        // True, the storage factory is only called once per scope.
        Assert.AreEqual(defaultStorage, defaultStorage2);
        // True
        Assert.AreEqual(defaultUploadManager, _defaultUploadManager);
        // True, the facade is just a wrapper around the storage
        Assert.AreEqual(_defaultStorageFacade.Storage, _defaultStorage);
    }
}