├── Images
    └── main.png
├── .github
    ├── renovate.json
    └── workflows
    │   ├── release.yml
    │   ├── ci-build.yml
    │   └── lock.yml
├── src
    ├── Directory.Build.targets
    ├── Fusillade.Tests
    │   ├── Http
    │   │   ├── fixtures
    │   │   │   └── ResponseWithETag
    │   │   ├── BaseHttpSchedulerSharedTests.cs
    │   │   ├── TestHttpMessageHandler.cs
    │   │   ├── HttpSchedulerCachingTests.cs
    │   │   └── HttpSchedulerSharedTests.cs
    │   ├── API
    │   │   ├── ApiApprovalTests.cs
    │   │   ├── ApiExtensions.cs
    │   │   ├── ApiApprovalTests.FusilladeTests.DotNet10_0.verified.txt
    │   │   ├── ApiApprovalTests.FusilladeTests.DotNet8_0.verified.txt
    │   │   └── ApiApprovalTests.FusilladeTests.DotNet9_0.verified.txt
    │   ├── Fusillade.Tests.csproj
    │   ├── NetCacheTests.cs
    │   └── IntegrationTestHelper.cs
    ├── Fusillade
    │   ├── Fusillade.csproj
    │   ├── ConcatenateMixin.cs
    │   ├── InflightRequest.cs
    │   ├── Priority.cs
    │   ├── Builder
    │   │   └── FusilladeSplatBuilderExtensions.cs
    │   ├── LimitingHttpMessageHandler.cs
    │   ├── OfflineHttpMessageHandler.cs
    │   ├── IRequestCache.cs
    │   ├── NetCache.cs
    │   └── RateLimitedHttpMessageHandler.cs
    ├── Directory.Packages.props
    ├── stylecop.json
    ├── Directory.Build.props
    └── Fusillade.sln
├── version.json
├── .gitattributes
├── LICENSE
├── CODE_OF_CONDUCT.md
├── .gitignore
├── CONTRIBUTING.md
├── README.md
└── .editorconfig


/Images/main.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/reactiveui/Fusillade/HEAD/Images/main.png


--------------------------------------------------------------------------------
/.github/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 |     "$schema": "https://docs.renovatebot.com/renovate-schema.json",
3 |     "extends": ["local>reactiveui/.github:renovate"]
4 | }


--------------------------------------------------------------------------------
/src/Directory.Build.targets:
--------------------------------------------------------------------------------
1 | <Project>
2 |   <PropertyGroup>  
3 |     <Product>$(AssemblyName) ($(TargetFramework))</Product>
4 |   </PropertyGroup>
5 | </Project>
6 | 


--------------------------------------------------------------------------------
/version.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": "4.0",
 3 |   "publicReleaseRefSpec": [
 4 |     "^refs/heads/main", // we release out of master
 5 |     "^refs/heads/rel/\\d+\\.\\d+\\.\\d+" // we also release branches starting with rel/N.N.N
 6 |   ],
 7 |   "nugetPackageVersion":{
 8 |     "semVer": 2
 9 |   },
10 |   "cloudBuild": {
11 |     "setVersionVariables": true,
12 |     "buildNumber": {
13 |       "enabled": false
14 |     }
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Fusillade.Tests/Http/fixtures/ResponseWithETag:
--------------------------------------------------------------------------------
 1 | HTTP/1.1 200 OK
 2 | Access-Control-Allow-Origin: *
 3 | Content-Type: text/plain; charset=UTF-8
 4 | Date: Tue, 24 Dec 2013 03:16:30 GMT
 5 | Etag: "12345"
 6 | Server: gunicorn/0.17.4
 7 | Content-Length: 118
 8 | Connection: keep-alive
 9 | 
10 | {
11 |   "ETag": "12345",
12 |   "Content-Type": "text/plain; charset=UTF-8",
13 |   "Content-Length": "118",
14 |   "Server": "httpbin"
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Fusillade/Fusillade.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 	<PropertyGroup>
 3 | 		<TargetFrameworks>netstandard2.0;net8.0;net9.0;net10.0</TargetFrameworks>
 4 | 		<PackageId>fusillade</PackageId>
 5 | 		<LangVersion>preview</LangVersion>
 6 | 		<Nullable>enable</Nullable>
 7 | 		<WarningsAsErrors>CS8625;CS8604;CS8600;CS8614;CS8603;CS8618;CS8619</WarningsAsErrors>
 8 | 	</PropertyGroup>
 9 | 
10 | 	<ItemGroup>
11 | 		<PackageReference Include="punchclock" />
12 | 		<PackageReference Include="Splat" />
13 | 	</ItemGroup>
14 | </Project>
15 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Release
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |     
 7 | jobs:
 8 |   release:
 9 |     uses: reactiveui/actions-common/.github/workflows/workflow-common-release.yml@main
10 |     with:
11 |       configuration: Release
12 |       productNamespacePrefix: "Fusillade"
13 |       installWorkflows: false
14 |     secrets:
15 |       SIGN_CLIENT_USER_ID: ${{ secrets.SIGN_CLIENT_USER_ID }}
16 |       SIGN_CLIENT_SECRET: ${{ secrets.SIGN_CLIENT_SECRET }}
17 |       SIGN_CLIENT_CONFIG: ${{ secrets.SIGN_CLIENT_CONFIG }}
18 |       NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}
19 | 


--------------------------------------------------------------------------------
/.github/workflows/ci-build.yml:
--------------------------------------------------------------------------------
 1 | name: Build
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - main          # ✅ run on main
 7 |   pull_request:        # (optional) run on PRs targeting any branch
 8 |   
 9 | # Needed so the reusable workflow can optionally delete the temp per-OS artifacts it creates.
10 | permissions:
11 |   contents: read
12 |   actions: write
13 | 
14 | jobs:
15 |   build:
16 |     uses: reactiveui/actions-common/.github/workflows/workflow-common-setup-and-build.yml@main
17 |     with:
18 |       configuration: Release
19 |       productNamespacePrefix: "Fusilade"
20 |     secrets:
21 |       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
22 | 


--------------------------------------------------------------------------------
/src/Fusillade/ConcatenateMixin.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
 2 | // Licensed to ReactiveUI and Contributors under one or more agreements.
 3 | // ReactiveUI and Contributors licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System;
 7 | using System.Collections.Generic;
 8 | using System.Linq;
 9 | using System.Reactive.Linq;
10 | using System.Text;
11 | 
12 | namespace Fusillade;
13 | 
14 | internal static class ConcatenateMixin
15 | {
16 |     public static string ConcatenateAll<T>(this IEnumerable<T> enumerables, Func<T, string> selector, char separator = '|') =>
17 |         enumerables.Aggregate(new StringBuilder(), (acc, x) =>
18 |         {
19 |             acc.Append(selector(x)).Append(separator);
20 |             return acc;
21 |         }).ToString();
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Fusillade.Tests/Http/BaseHttpSchedulerSharedTests.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
 2 | // Licensed to the .NET Foundation under one or more agreements.
 3 | // The .NET Foundation licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System.Net.Http;
 7 | using Punchclock;
 8 | 
 9 | namespace Fusillade.Tests
10 | {
11 |     /// <summary>
12 |     /// Checks to make sure the base http scheduler works.
13 |     /// </summary>
14 |     public class BaseHttpSchedulerSharedTests : HttpSchedulerSharedTests
15 |     {
16 |         /// <inheritdoc/>
17 |         protected override LimitingHttpMessageHandler CreateFixture(HttpMessageHandler? innerHandler) =>
18 |             new RateLimitedHttpMessageHandler(innerHandler, Priority.UserInitiated, opQueue: new OperationQueue(4));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/.github/workflows/lock.yml:
--------------------------------------------------------------------------------
 1 | name: 'Lock Threads'
 2 | 
 3 | on:
 4 |   schedule:
 5 |     - cron: '0 0 * * *'
 6 |   workflow_dispatch:
 7 | 
 8 | permissions:
 9 |   issues: write
10 |   pull-requests: write
11 | 
12 | concurrency:
13 |   group: lock
14 | 
15 | jobs:
16 |   action:
17 |     runs-on: ubuntu-latest
18 |     steps:
19 |       - uses: dessant/lock-threads@v5
20 |         with:
21 |           github-token: ${{ github.token }}
22 |           issue-inactive-days: '14'
23 |           pr-inactive-days: '14'
24 |           issue-comment: >
25 |             This issue has been automatically locked since there
26 |             has not been any recent activity after it was closed.
27 |             Please open a new issue for related bugs.
28 |           pr-comment: >
29 |             This pull request has been automatically locked since there
30 |             has not been any recent activity after it was closed.
31 |             Please open a new issue for related bugs.


--------------------------------------------------------------------------------
/src/Fusillade/InflightRequest.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
 2 | // Licensed to ReactiveUI and Contributors under one or more agreements.
 3 | // ReactiveUI and Contributors licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System;
 7 | using System.Net.Http;
 8 | using System.Reactive.Subjects;
 9 | using System.Threading;
10 | 
11 | namespace Fusillade;
12 | 
13 | internal class InflightRequest(Action onFullyCancelled)
14 | {
15 |     private int _refCount = 1;
16 | 
17 |     public AsyncSubject<HttpResponseMessage> Response { get; protected set; } = new AsyncSubject<HttpResponseMessage>();
18 | 
19 |     public void AddRef() => Interlocked.Increment(ref _refCount);
20 | 
21 |     public void Cancel()
22 |     {
23 |         if (Interlocked.Decrement(ref _refCount) <= 0)
24 |         {
25 |             onFullyCancelled();
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Catch all for anything we forgot. Add rules if you get CRLF to LF warnings.
 2 | * text=auto
 3 | 
 4 | # Text files that should be normalized to LF in odb.
 5 | *.cs     text eol=lf diff=csharp
 6 | *.xaml   text
 7 | *.config text
 8 | *.c      text
 9 | *.h      text
10 | *.cpp    text
11 | *.hpp    text
12 | 
13 | *.sln     text
14 | *.csproj  text
15 | *.vcxproj text
16 | 
17 | *.md       text
18 | *.tt       text
19 | *.sh       text
20 | *.ps1      text
21 | *.cmd      text
22 | *.bat      text
23 | *.markdown text
24 | *.msbuild  text
25 | 
26 | 
27 | # Binary files that should not be normalized or diffed
28 | *.png    binary
29 | *.jpg    binary
30 | *.gif    binary
31 | *.ico    binary
32 | *.rc     binary
33 | 
34 | *.pfx    binary
35 | *.snk    binary
36 | *.dll    binary
37 | *.exe    binary
38 | *.lib    binary
39 | *.exp    binary
40 | *.pdb    binary
41 | *.sdf    binary
42 | *.7z     binary
43 | 
44 | # Generated file should just use CRLF, it's fiiine
45 | SolutionInfo.cs text eol=crlf diff=csharp
46 | 


--------------------------------------------------------------------------------
/src/Fusillade.Tests/API/ApiApprovalTests.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
 2 | // Licensed to the .NET Foundation under one or more agreements.
 3 | // The .NET Foundation licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System.Diagnostics.CodeAnalysis;
 7 | using System.Threading.Tasks;
 8 | using NUnit.Framework;
 9 | 
10 | namespace Fusillade.APITests
11 | {
12 |     /// <summary>
13 |     /// Tests for handling API approval.
14 |     /// </summary>
15 |     [ExcludeFromCodeCoverage]
16 |     public class ApiApprovalTests
17 |     {
18 |         /// <summary>
19 |         /// Tests to make sure the akavache project is approved.
20 |         /// </summary>
21 |         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
22 |         [Test]
23 |         public Task FusilladeTests() => typeof(OfflineHttpMessageHandler).Assembly.CheckApproval(new[] { "Fusillade" });
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Fusillade/Priority.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
 2 | // Licensed to ReactiveUI and Contributors under one or more agreements.
 3 | // ReactiveUI and Contributors licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | namespace Fusillade;
 7 | 
 8 | /// <summary>
 9 | /// This enumeration defines the default base priorities associated with the
10 | /// different NetCache instances.
11 | /// </summary>
12 | public enum Priority
13 | {
14 |     /// <summary>
15 |     /// This is a explicit task.
16 |     /// </summary>
17 |     Explicit = 0,
18 | 
19 |     /// <summary>
20 |     /// A speculative priority where we aren't sure.
21 |     /// </summary>
22 |     Speculative = 10,
23 | 
24 |     /// <summary>
25 |     /// This is background based task.
26 |     /// </summary>
27 |     Background = 20,
28 | 
29 |     /// <summary>
30 |     /// This is a instance which is initiated by the user.
31 |     /// </summary>
32 |     UserInitiated = 100,
33 | }
34 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2016 Anaïs Betts
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | this software and associated documentation files (the "Software"), to deal in
 5 | the Software without restriction, including without limitation the rights to
 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | the Software, and to permit persons to whom the Software is furnished to do so,
 8 | subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 


--------------------------------------------------------------------------------
/src/Fusillade/Builder/FusilladeSplatBuilderExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
 2 | // Licensed to ReactiveUI and Contributors under one or more agreements.
 3 | // ReactiveUI and Contributors licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System;
 7 | using Fusillade;
 8 | 
 9 | namespace Splat.Builder;
10 | 
11 | /// <summary>
12 | /// Splat module for configuring Fusillade.
13 | /// </summary>
14 | public static class FusilladeSplatBuilderExtensions
15 | {
16 |     /// <summary>
17 |     /// Creates the fusillade net cache.
18 |     /// </summary>
19 |     /// <param name="builder">The builder.</param>
20 |     /// <returns>The App Instance for Chaining.</returns>
21 |     public static IAppInstance CreateFusilladeNetCache(this IAppInstance builder)
22 |     {
23 |         if (builder is null)
24 |         {
25 |             throw new ArgumentNullException(nameof(builder));
26 |         }
27 | 
28 |         NetCache.CreateDefaultInstances(builder.Current);
29 |         return builder;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Fusillade.Tests/Fusillade.Tests.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 	<PropertyGroup>
 3 | 		<TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
 4 | 		<NoWarn>$(NoWarn);1591;CA1707;SA1633</NoWarn>
 5 | 		<IsPackable>false</IsPackable>
 6 | 		<NoWarn>$(NoWarn);CA2000;CA1031;CA1307;CA1305</NoWarn>
 7 | 		<LangVersion>preview</LangVersion>
 8 | 		<Nullable>enable</Nullable>
 9 | 	</PropertyGroup>
10 | 
11 | 	<ItemGroup>
12 | 		<ProjectReference Include="../Fusillade/Fusillade.csproj" />
13 | 	</ItemGroup>
14 | 
15 | 	<ItemGroup>
16 | 		<PackageReference Include="Akavache.SystemTextJson" />
17 | 		<PackageReference Include="System.Reactive" />
18 | 		<PackageReference Include="Microsoft.Reactive.Testing" />
19 | 		<PackageReference Include="ReactiveUI" />
20 | 		<PackageReference Include="ReactiveUI.Testing" />
21 | 		<PackageReference Include="Microsoft.NET.Test.Sdk" />
22 | 		<PackageReference Include="NUnit" />
23 | 		<PackageReference Include="NUnit3TestAdapter" />
24 | 		<PackageReference Include="NUnit.Analyzers" PrivateAssets="All" />
25 | 		<PackageReference Include="Verify.NUnit" />
26 | 		<PackageReference Include="PublicApiGenerator" />
27 | 		<PackageReference Include="coverlet.msbuild" PrivateAssets="All" />
28 | 	</ItemGroup>
29 | </Project>


--------------------------------------------------------------------------------
/src/Fusillade.Tests/NetCacheTests.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
 2 | // Licensed to the .NET Foundation under one or more agreements.
 3 | // The .NET Foundation licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using NUnit.Framework; // switched from xUnit
 7 | 
 8 | namespace Fusillade.Tests
 9 | {
10 |     /// <summary>
11 |     /// Checks to make sure that the NetCache operates correctly.
12 |     /// </summary>
13 |     [TestFixture]
14 |     [NonParallelizable] // replaces CollectionDefinition DisableParallelization
15 |     public class NetCacheTests
16 |     {
17 |         /// <summary>
18 |         /// Verifies that we are registering the default handlers correctly.
19 |         /// </summary>
20 |         [Test]
21 |         public void DefaultValuesShouldBeRegistered()
22 |         {
23 |             using (Assert.EnterMultipleScope())
24 |             {
25 |                 Assert.That(NetCache.Speculative, Is.Not.Null);
26 |                 Assert.That(NetCache.UserInitiated, Is.Not.Null);
27 |                 Assert.That(NetCache.Background, Is.Not.Null);
28 |                 Assert.That(NetCache.Offline, Is.Not.Null);
29 |                 Assert.That(NetCache.OperationQueue, Is.Not.Null);
30 |                 Assert.That(NetCache.RequestCache, Is.Null);
31 |             }
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Fusillade.Tests/Http/TestHttpMessageHandler.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
 2 | // Licensed to the .NET Foundation under one or more agreements.
 3 | // The .NET Foundation licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System;
 7 | using System.Net.Http;
 8 | using System.Reactive.Linq;
 9 | using System.Reactive.Threading.Tasks;
10 | using System.Threading;
11 | using System.Threading.Tasks;
12 | 
13 | namespace Fusillade.Tests
14 | {
15 |     /// <summary>
16 |     /// Tests the main http scheduler.
17 |     /// </summary>
18 |     /// <remarks>
19 |     /// Initializes a new instance of the <see cref="TestHttpMessageHandler"/> class.
20 |     /// </remarks>
21 |     /// <param name="createResult">Creates a http response.</param>
22 |     public class TestHttpMessageHandler(Func<HttpRequestMessage, IObservable<HttpResponseMessage>> createResult) : HttpMessageHandler
23 |     {
24 |         /// <inheritdoc/>
25 |         protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
26 |         {
27 |             if (cancellationToken.IsCancellationRequested)
28 |             {
29 |                 return Observable.Throw<HttpResponseMessage>(new OperationCanceledException()).ToTask();
30 |             }
31 | 
32 |             return createResult(request).ToTask(cancellationToken);
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Directory.Packages.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project>
 3 |   <PropertyGroup>
 4 |     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
 5 |   </PropertyGroup>
 6 |   <ItemGroup>
 7 |     <!-- Central package versions -->
 8 |     <PackageVersion Include="punchclock" Version="5.0.1" />
 9 |     <PackageVersion Include="Splat" Version="17.1.1" />
10 |     <PackageVersion Include="Akavache.SystemTextJson" Version="11.5.1" />
11 |     <PackageVersion Include="ReactiveUI.Testing" Version="22.3.1" />
12 |     <PackageVersion Include="ReactiveUI" Version="22.3.1" />
13 |     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
14 |     <PackageVersion Include="NUnit" Version="4.4.0" />
15 | 	<PackageVersion Include="NUnit3TestAdapter" Version="6.0.0" />
16 | 	<PackageVersion Include="NUnit.Analyzers" Version="4.11.2" />
17 |     <PackageVersion Include="Verify.NUnit" Version="31.9.0" />
18 |     <PackageVersion Include="PublicApiGenerator" Version="11.5.4" />
19 |     <PackageVersion Include="coverlet.msbuild" Version="6.0.4" />
20 |     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
21 |     <PackageVersion Include="Nerdbank.GitVersioning" Version="3.9.50" />
22 |     <PackageVersion Include="stylecop.analyzers" Version="1.2.0-beta.556" />
23 |     <PackageVersion Include="Roslynator.Analyzers" Version="4.15.0" />
24 |     <PackageVersion Include="Microsoft.Reactive.Testing" Version="6.1.0" />
25 |     <PackageVersion Include="System.Reactive" Version="6.1.0" />
26 |   </ItemGroup>
27 | </Project>
28 | 


--------------------------------------------------------------------------------
/src/stylecop.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "$schema": "https://raw.githubusercontent.com/DotNetAnalyzers/StyleCopAnalyzers/master/StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json",
 3 |     "settings": {
 4 |         "indentation": {
 5 |             "useTabs": false,
 6 |             "indentationSize": 4
 7 |         },
 8 |       "documentationRules": {
 9 |         "documentExposedElements": true,
10 |         "documentInternalElements": false,
11 |         "documentPrivateElements": false,
12 |         "documentInterfaces": true,
13 |         "documentPrivateFields": false,
14 |         "documentationCulture": "en-US",
15 |         "companyName": "ReactiveUI and Contributors",
16 |         "copyrightText": "Copyright (c) 2025 {companyName}. All rights reserved.\nLicensed to ReactiveUI and Contributors under one or more agreements.\nReactiveUI and Contributors licenses this file to you under the {licenseName} license.\nSee the {licenseFile} file in the project root for full license information.",
17 |         "variables": {
18 |           "licenseName": "MIT",
19 |           "licenseFile": "LICENSE"
20 |         },
21 |         "xmlHeader": false
22 |       },
23 |         "layoutRules": {
24 |             "newlineAtEndOfFile": "allow",
25 |             "allowConsecutiveUsings": true
26 |         },
27 |         "maintainabilityRules": {
28 |             "topLevelTypes": [
29 |                 "class",
30 |                 "interface",
31 |                 "struct",
32 |                 "enum",
33 |                 "delegate"
34 |             ]
35 |         },
36 |         "orderingRules": {
37 |             "usingDirectivesPlacement": "outsideNamespace",
38 |             "systemUsingDirectivesFirst": true
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Fusillade/LimitingHttpMessageHandler.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
 2 | // Licensed to ReactiveUI and Contributors under one or more agreements.
 3 | // ReactiveUI and Contributors licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System.Net.Http;
 7 | 
 8 | namespace Fusillade;
 9 | 
10 | /// <summary>
11 | /// Limiting HTTP schedulers only allow a certain number of bytes to be
12 | /// read before cancelling all future requests. This is designed for
13 | /// reading data that may or may not be used by the user later, in order
14 | /// to improve response times should the user later request the data.
15 | /// </summary>
16 | public abstract class LimitingHttpMessageHandler : DelegatingHandler
17 | {
18 |     /// <summary>
19 |     /// Initializes a new instance of the <see cref="LimitingHttpMessageHandler"/> class.
20 |     /// </summary>
21 |     /// <param name="innerHandler">A inner handler we will call to get the data.</param>
22 |     protected LimitingHttpMessageHandler(HttpMessageHandler? innerHandler)
23 |         : base(innerHandler!)
24 |     {
25 |     }
26 | 
27 |     /// <summary>
28 |     /// Initializes a new instance of the <see cref="LimitingHttpMessageHandler"/> class.
29 |     /// </summary>
30 |     protected LimitingHttpMessageHandler()
31 |     {
32 |     }
33 | 
34 |     /// <summary>
35 |     /// Resets the total limit of bytes to read. This is usually called
36 |     /// when the app resumes from suspend, to indicate that we should
37 |     /// fetch another set of data.
38 |     /// </summary>
39 |     /// <param name="maxBytesToRead">The maximum number of bytes to read.</param>
40 |     public abstract void ResetLimit(long? maxBytesToRead = null);
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Fusillade/OfflineHttpMessageHandler.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
 2 | // Licensed to ReactiveUI and Contributors under one or more agreements.
 3 | // ReactiveUI and Contributors licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System;
 7 | using System.Net;
 8 | using System.Net.Http;
 9 | using System.Threading;
10 | using System.Threading.Tasks;
11 | 
12 | namespace Fusillade;
13 | 
14 | /// <summary>
15 | /// A http handler that will make a response even if the HttpClient is offline.
16 | /// </summary>
17 | /// <remarks>
18 | /// Initializes a new instance of the <see cref="OfflineHttpMessageHandler"/> class.
19 | /// </remarks>
20 | /// <param name="retrieveBodyFunc">A function that will retrieve a body.</param>
21 | public class OfflineHttpMessageHandler(Func<HttpRequestMessage, string, CancellationToken, Task<byte[]>>? retrieveBodyFunc) : HttpMessageHandler
22 | {
23 |     /// <inheritdoc />
24 |     protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
25 |     {
26 |         var retrieveBody = retrieveBodyFunc;
27 |         if (retrieveBody == null && NetCache.RequestCache != null)
28 |         {
29 |             retrieveBody = NetCache.RequestCache.Fetch;
30 |         }
31 | 
32 |         if (retrieveBody == null)
33 |         {
34 |             throw new Exception("Configure NetCache.RequestCache before calling this!");
35 |         }
36 | 
37 |         var body = await retrieveBody(request, RateLimitedHttpMessageHandler.UniqueKeyForRequest(request), cancellationToken).ConfigureAwait(false);
38 |         if (body == null)
39 |         {
40 |             return new HttpResponseMessage(HttpStatusCode.ServiceUnavailable);
41 |         }
42 | 
43 |         var byteContent = new ByteArrayContent(body);
44 |         return new HttpResponseMessage(HttpStatusCode.OK) { Content = byteContent };
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Fusillade/IRequestCache.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
 2 | // Licensed to ReactiveUI and Contributors under one or more agreements.
 3 | // ReactiveUI and Contributors licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System.Net.Http;
 7 | using System.Threading;
 8 | using System.Threading.Tasks;
 9 | 
10 | namespace Fusillade;
11 | 
12 | /// <summary>
13 | /// This Interface is a simple cache for HTTP requests - it is intentionally
14 | /// *not* designed to conform to HTTP caching rules since you most likely want
15 | /// to override those rules in a client app anyways.
16 | /// </summary>
17 | public interface IRequestCache
18 | {
19 |     /// <summary>
20 |     /// Implement this method by saving the Body of the response. The
21 |     /// response is already downloaded as a ByteArrayContent so you don't
22 |     /// have to worry about consuming the stream.
23 |     /// </summary>
24 |     /// <param name="request">The originating request.</param>
25 |     /// <param name="response">The response whose body you should save.</param>
26 |     /// <param name="key">A unique key used to identify the request details.</param>
27 |     /// <param name="ct">Cancellation token.</param>
28 |     /// <returns>Completion.</returns>
29 |     Task Save(HttpRequestMessage request, HttpResponseMessage response, string key, CancellationToken ct);
30 | 
31 |     /// <summary>
32 |     /// Implement this by loading the Body of the given request / key.
33 |     /// </summary>
34 |     /// <param name="request">The originating request.</param>
35 |     /// <param name="key">A unique key used to identify the request details,
36 |     /// that was given in Save().</param>
37 |     /// <param name="ct">Cancellation token.</param>
38 |     /// <returns>The Body of the given request, or null if the search
39 |     /// completed successfully but the response was not found.</returns>
40 |     Task<byte[]> Fetch(HttpRequestMessage request, string key, CancellationToken ct);
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Fusillade.Tests/API/ApiExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
 2 | // Licensed to the .NET Foundation under one or more agreements.
 3 | // The .NET Foundation licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System;
 7 | using System.Diagnostics.CodeAnalysis;
 8 | using System.Reflection;
 9 | using System.Runtime.CompilerServices;
10 | using System.Threading.Tasks;
11 | using NUnit.Framework; // add for NUnit attributes if needed later
12 | using PublicApiGenerator;
13 | using VerifyNUnit; // changed from VerifyXunit
14 | 
15 | namespace Fusillade.APITests;
16 | 
17 | /// <summary>
18 | /// A helper for doing API approvals.
19 | /// </summary>
20 | public static class ApiExtensions
21 | {
22 |     /// <summary>
23 |     /// Checks to make sure the API is approved.
24 |     /// </summary>
25 |     /// <param name="assembly">The assembly that is being checked.</param>
26 |     /// <param name="namespaces">The namespaces.</param>
27 |     /// <param name="filePath">The caller file path.</param>
28 |     /// <returns>
29 |     /// A Task.
30 |     /// </returns>
31 |     public static async Task CheckApproval(this Assembly assembly, string[] namespaces, [CallerFilePath] string filePath = "")
32 |     {
33 |         var generatorOptions = new ApiGeneratorOptions { AllowNamespacePrefixes = namespaces };
34 |         var apiText = assembly.GeneratePublicApi(generatorOptions);
35 |         var result = await Verifier.Verify(apiText, null, filePath)
36 |             .UniqueForRuntimeAndVersion()
37 |             .ScrubEmptyLines()
38 |             .ScrubLines(l =>
39 |                 l.StartsWith("[assembly: AssemblyVersion(", StringComparison.InvariantCulture) ||
40 |                 l.StartsWith("[assembly: AssemblyFileVersion(", StringComparison.InvariantCulture) ||
41 |                 l.StartsWith("[assembly: AssemblyInformationalVersion(", StringComparison.InvariantCulture) ||
42 |                 l.StartsWith("[assembly: System.Reflection.AssemblyMetadata(", StringComparison.InvariantCulture));
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Directory.Build.props:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project>
 3 | 	<PropertyGroup>
 4 | 		<Copyright>Copyright (c) ReactiveUI and Contributors</Copyright>
 5 | 		<Authors>ReactiveUI and Contributors</Authors>
 6 | 		<PackageProjectUrl>https://github.com/reactiveui/fusillade/</PackageProjectUrl>
 7 | 		<PackageReleaseNotes>https://github.com/reactiveui/fusillade/releases</PackageReleaseNotes>
 8 | 		<RepositoryUrl>https://github.com/reactiveui/fusillade</RepositoryUrl>
 9 | 		
10 | 		<NoWarn>$(NoWarn);VSX1000</NoWarn>
11 | 		<Platform>AnyCPU</Platform>
12 | 		<IsTestProject>$(MSBuildProjectName.Contains('Tests'))</IsTestProject>
13 | 		<RepositoryType>git</RepositoryType>
14 | 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
15 | 		<CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)analyzers.ruleset</CodeAnalysisRuleSet>
16 | 		<DebugType>Embedded</DebugType>
17 | 		<PackageIcon>main.png</PackageIcon>
18 | 		<PackageReadmeFile>README.md</PackageReadmeFile>
19 | 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
20 | 		<PublishRepositoryUrl>true</PublishRepositoryUrl>
21 | 		<EmbedUntrackedSources>true</EmbedUntrackedSources>
22 | 		<AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
23 | 		<EnableNETAnalyzers>True</EnableNETAnalyzers>
24 | 		<AnalysisLevel>latest</AnalysisLevel>
25 | 		<WarningsAsErrors>$(WarningsAsErrors);nullable</WarningsAsErrors>
26 | 	</PropertyGroup>
27 | 
28 | 	<ItemGroup Condition="'$(IsTestProject)' != 'true'">
29 | 		<PackageReference Include="Microsoft.SourceLink.GitHub" PrivateAssets="All" />
30 | 	</ItemGroup>
31 | 
32 | 	<ItemGroup>
33 | 		<None Include="$(MSBuildThisFileDirectory)../images/main.png" Pack="true" PackagePath="/"/>
34 | 		<None Include="$(MSBuildThisFileDirectory)../LICENSE" Pack="true" PackagePath="LICENSE" />
35 | 		<None Include="$(MSBuildThisFileDirectory)../README.md" Pack="true" PackagePath="/" />
36 | 	</ItemGroup>
37 | 
38 | 	<ItemGroup>
39 | 		<PackageReference Include="Nerdbank.GitVersioning" PrivateAssets="all" />
40 | 		<PackageReference Include="stylecop.analyzers" PrivateAssets="all" />
41 | 		<PackageReference Include="Roslynator.Analyzers" PrivateAssets="All" />
42 | 	</ItemGroup>
43 | 
44 | 	<ItemGroup>
45 | 		<AdditionalFiles Include="$(MSBuildThisFileDirectory)stylecop.json" Link="stylecop.json" />
46 | 	</ItemGroup>
47 | </Project>
48 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Contributor Code of Conduct
 2 | 
 3 | As contributors and maintainers of this project, and in the interest of
 4 | fostering an open and welcoming community, we pledge to respect all people who
 5 | contribute through reporting issues, posting feature requests, updating
 6 | documentation, submitting pull requests or patches, and other activities.
 7 | 
 8 | We are committed to making participation in this project a harassment-free
 9 | experience for everyone, regardless of level of experience, gender, gender
10 | identity and expression, sexual orientation, disability, personal appearance,
11 | body size, race, ethnicity, age, religion, or nationality.
12 | 
13 | Examples of unacceptable behavior by participants include:
14 | 
15 | * The use of sexualized language or imagery
16 | * Personal attacks
17 | * Trolling or insulting/derogatory comments
18 | * Public or private harassment
19 | * Publishing other's private information, such as physical or electronic
20 |   addresses, without explicit permission
21 | * Other unethical or unprofessional conduct
22 | 
23 | Project maintainers have the right and responsibility to remove, edit, or
24 | reject comments, commits, code, wiki edits, issues, and other contributions
25 | that are not aligned to this Code of Conduct, or to ban temporarily or
26 | permanently any contributor for other behaviors that they deem inappropriate,
27 | threatening, offensive, or harmful.
28 | 
29 | By adopting this Code of Conduct, project maintainers commit themselves to
30 | fairly and consistently applying these principles to every aspect of managing
31 | this project. Project maintainers who do not follow or enforce the Code of
32 | Conduct may be permanently removed from the project team.
33 | 
34 | This Code of Conduct applies both within project spaces and in public spaces
35 | when an individual is representing the project or its community.
36 | 
37 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
38 | reported by contacting a project maintainer at anais@anaisbetts.org. All
39 | complaints will be reviewed and investigated and will result in a response that
40 | is deemed necessary and appropriate to the circumstances. Maintainers are
41 | obligated to maintain confidentiality with regard to the reporter of an
42 | incident.
43 | 
44 | 
45 | This Code of Conduct is adapted from the [Contributor Covenant][homepage],
46 | version 1.3.0, available at
47 | [http://contributor-covenant.org/version/1/3/0/][version]
48 | 
49 | [homepage]: http://contributor-covenant.org
50 | [version]: http://contributor-covenant.org/version/1/3/0/
51 | 


--------------------------------------------------------------------------------
/src/Fusillade.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 18
 4 | VisualStudioVersion = 18.0.11205.157 d18.0
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Fusillade", "Fusillade\Fusillade.csproj", "{26493C47-6A4A-4F2A-9F92-046AA8CD95CC}"
 7 | EndProject
 8 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Fusillade.Tests", "Fusillade.Tests\Fusillade.Tests.csproj", "{BA0745E4-4566-4655-B83C-B4398F67DC39}"
 9 | EndProject
10 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{6B92A58B-DD1B-4AFF-A3CA-D51CBEB7B43D}"
11 | 	ProjectSection(SolutionItems) = preProject
12 | 		..\.gitattributes = ..\.gitattributes
13 | 		..\.gitignore = ..\.gitignore
14 | 		analyzers.ruleset = analyzers.ruleset
15 | 		..\.github\workflows\ci-build.yml = ..\.github\workflows\ci-build.yml
16 | 		..\CODE_OF_CONDUCT.md = ..\CODE_OF_CONDUCT.md
17 | 		..\CONTRIBUTING.md = ..\CONTRIBUTING.md
18 | 		Directory.build.props = Directory.build.props
19 | 		Directory.build.targets = Directory.build.targets
20 | 		Directory.Packages.props = Directory.Packages.props
21 | 		..\LICENSE = ..\LICENSE
22 | 		..\README.md = ..\README.md
23 | 		..\.github\workflows\release.yml = ..\.github\workflows\release.yml
24 | 		stylecop.json = stylecop.json
25 | 		..\version.json = ..\version.json
26 | 	EndProjectSection
27 | EndProject
28 | Global
29 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
30 | 		Debug|Any CPU = Debug|Any CPU
31 | 		Release|Any CPU = Release|Any CPU
32 | 	EndGlobalSection
33 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
34 | 		{26493C47-6A4A-4F2A-9F92-046AA8CD95CC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
35 | 		{26493C47-6A4A-4F2A-9F92-046AA8CD95CC}.Debug|Any CPU.Build.0 = Debug|Any CPU
36 | 		{26493C47-6A4A-4F2A-9F92-046AA8CD95CC}.Release|Any CPU.ActiveCfg = Release|Any CPU
37 | 		{26493C47-6A4A-4F2A-9F92-046AA8CD95CC}.Release|Any CPU.Build.0 = Release|Any CPU
38 | 		{BA0745E4-4566-4655-B83C-B4398F67DC39}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
39 | 		{BA0745E4-4566-4655-B83C-B4398F67DC39}.Debug|Any CPU.Build.0 = Debug|Any CPU
40 | 		{BA0745E4-4566-4655-B83C-B4398F67DC39}.Release|Any CPU.ActiveCfg = Release|Any CPU
41 | 		{BA0745E4-4566-4655-B83C-B4398F67DC39}.Release|Any CPU.Build.0 = Release|Any CPU
42 | 	EndGlobalSection
43 | 	GlobalSection(SolutionProperties) = preSolution
44 | 		HideSolutionNode = FALSE
45 | 	EndGlobalSection
46 | 	GlobalSection(ExtensibilityGlobals) = postSolution
47 | 		SolutionGuid = {96AB3D31-3E93-4E65-90D6-571A60C269E0}
48 | 	EndGlobalSection
49 | EndGlobal
50 | 


--------------------------------------------------------------------------------
/src/Fusillade.Tests/API/ApiApprovalTests.FusilladeTests.DotNet10_0.verified.txt:
--------------------------------------------------------------------------------
 1 | [assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v10.0", FrameworkDisplayName=".NET 10.0")]
 2 | namespace Fusillade
 3 | {
 4 |     public interface IRequestCache
 5 |     {
 6 |         System.Threading.Tasks.Task<byte[]> Fetch(System.Net.Http.HttpRequestMessage request, string key, System.Threading.CancellationToken ct);
 7 |         System.Threading.Tasks.Task Save(System.Net.Http.HttpRequestMessage request, System.Net.Http.HttpResponseMessage response, string key, System.Threading.CancellationToken ct);
 8 |     }
 9 |     public abstract class LimitingHttpMessageHandler : System.Net.Http.DelegatingHandler
10 |     {
11 |         protected LimitingHttpMessageHandler() { }
12 |         protected LimitingHttpMessageHandler(System.Net.Http.HttpMessageHandler? innerHandler) { }
13 |         public abstract void ResetLimit(long? maxBytesToRead = default);
14 |     }
15 |     public static class NetCache
16 |     {
17 |         public static System.Net.Http.HttpMessageHandler Background { get; set; }
18 |         public static System.Net.Http.HttpMessageHandler Offline { get; set; }
19 |         public static Punchclock.OperationQueue OperationQueue { get; set; }
20 |         public static Fusillade.IRequestCache? RequestCache { get; set; }
21 |         public static Fusillade.LimitingHttpMessageHandler Speculative { get; set; }
22 |         public static System.Net.Http.HttpMessageHandler UserInitiated { get; set; }
23 |     }
24 |     public class OfflineHttpMessageHandler : System.Net.Http.HttpMessageHandler
25 |     {
26 |         public OfflineHttpMessageHandler(System.Func<System.Net.Http.HttpRequestMessage, string, System.Threading.CancellationToken, System.Threading.Tasks.Task<byte[]>>? retrieveBodyFunc) { }
27 |         protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { }
28 |     }
29 |     public enum Priority
30 |     {
31 |         Explicit = 0,
32 |         Speculative = 10,
33 |         Background = 20,
34 |         UserInitiated = 100,
35 |     }
36 |     public class RateLimitedHttpMessageHandler : Fusillade.LimitingHttpMessageHandler
37 |     {
38 |         public RateLimitedHttpMessageHandler(System.Net.Http.HttpMessageHandler? handler, Fusillade.Priority basePriority, int priority = 0, long? maxBytesToRead = default, Punchclock.OperationQueue? opQueue = null, System.Func<System.Net.Http.HttpRequestMessage, System.Net.Http.HttpResponseMessage, string, System.Threading.CancellationToken, System.Threading.Tasks.Task>? cacheResultFunc = null) { }
39 |         public override void ResetLimit(long? maxBytesToRead = default) { }
40 |         protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { }
41 |         public static string UniqueKeyForRequest(System.Net.Http.HttpRequestMessage request) { }
42 |     }
43 | }
44 | namespace Splat.Builder
45 | {
46 |     public static class FusilladeSplatBuilderExtensions
47 |     {
48 |         public static Splat.Builder.IAppInstance CreateFusilladeNetCache(this Splat.Builder.IAppInstance builder) { }
49 |     }
50 | }


--------------------------------------------------------------------------------
/src/Fusillade.Tests/API/ApiApprovalTests.FusilladeTests.DotNet8_0.verified.txt:
--------------------------------------------------------------------------------
 1 | [assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName=".NET 8.0")]
 2 | namespace Fusillade
 3 | {
 4 |     public interface IRequestCache
 5 |     {
 6 |         System.Threading.Tasks.Task<byte[]> Fetch(System.Net.Http.HttpRequestMessage request, string key, System.Threading.CancellationToken ct);
 7 |         System.Threading.Tasks.Task Save(System.Net.Http.HttpRequestMessage request, System.Net.Http.HttpResponseMessage response, string key, System.Threading.CancellationToken ct);
 8 |     }
 9 |     public abstract class LimitingHttpMessageHandler : System.Net.Http.DelegatingHandler
10 |     {
11 |         protected LimitingHttpMessageHandler() { }
12 |         protected LimitingHttpMessageHandler(System.Net.Http.HttpMessageHandler? innerHandler) { }
13 |         public abstract void ResetLimit(long? maxBytesToRead = default);
14 |     }
15 |     public static class NetCache
16 |     {
17 |         public static System.Net.Http.HttpMessageHandler Background { get; set; }
18 |         public static System.Net.Http.HttpMessageHandler Offline { get; set; }
19 |         public static Punchclock.OperationQueue OperationQueue { get; set; }
20 |         public static Fusillade.IRequestCache? RequestCache { get; set; }
21 |         public static Fusillade.LimitingHttpMessageHandler Speculative { get; set; }
22 |         public static System.Net.Http.HttpMessageHandler UserInitiated { get; set; }
23 |     }
24 |     public class OfflineHttpMessageHandler : System.Net.Http.HttpMessageHandler
25 |     {
26 |         public OfflineHttpMessageHandler(System.Func<System.Net.Http.HttpRequestMessage, string, System.Threading.CancellationToken, System.Threading.Tasks.Task<byte[]>>? retrieveBodyFunc) { }
27 |         protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { }
28 |     }
29 |     public enum Priority
30 |     {
31 |         Explicit = 0,
32 |         Speculative = 10,
33 |         Background = 20,
34 |         UserInitiated = 100,
35 |     }
36 |     public class RateLimitedHttpMessageHandler : Fusillade.LimitingHttpMessageHandler
37 |     {
38 |         public RateLimitedHttpMessageHandler(System.Net.Http.HttpMessageHandler? handler, Fusillade.Priority basePriority, int priority = 0, long? maxBytesToRead = default, Punchclock.OperationQueue? opQueue = null, System.Func<System.Net.Http.HttpRequestMessage, System.Net.Http.HttpResponseMessage, string, System.Threading.CancellationToken, System.Threading.Tasks.Task>? cacheResultFunc = null) { }
39 |         public override void ResetLimit(long? maxBytesToRead = default) { }
40 |         protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { }
41 |         public static string UniqueKeyForRequest(System.Net.Http.HttpRequestMessage request) { }
42 |     }
43 | }
44 | namespace Splat.Builder
45 | {
46 |     public static class FusilladeSplatBuilderExtensions
47 |     {
48 |         public static Splat.Builder.IAppInstance CreateFusilladeNetCache(this Splat.Builder.IAppInstance builder) { }
49 |     }
50 | }


--------------------------------------------------------------------------------
/src/Fusillade.Tests/API/ApiApprovalTests.FusilladeTests.DotNet9_0.verified.txt:
--------------------------------------------------------------------------------
 1 | [assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v9.0", FrameworkDisplayName=".NET 9.0")]
 2 | namespace Fusillade
 3 | {
 4 |     public interface IRequestCache
 5 |     {
 6 |         System.Threading.Tasks.Task<byte[]> Fetch(System.Net.Http.HttpRequestMessage request, string key, System.Threading.CancellationToken ct);
 7 |         System.Threading.Tasks.Task Save(System.Net.Http.HttpRequestMessage request, System.Net.Http.HttpResponseMessage response, string key, System.Threading.CancellationToken ct);
 8 |     }
 9 |     public abstract class LimitingHttpMessageHandler : System.Net.Http.DelegatingHandler
10 |     {
11 |         protected LimitingHttpMessageHandler() { }
12 |         protected LimitingHttpMessageHandler(System.Net.Http.HttpMessageHandler? innerHandler) { }
13 |         public abstract void ResetLimit(long? maxBytesToRead = default);
14 |     }
15 |     public static class NetCache
16 |     {
17 |         public static System.Net.Http.HttpMessageHandler Background { get; set; }
18 |         public static System.Net.Http.HttpMessageHandler Offline { get; set; }
19 |         public static Punchclock.OperationQueue OperationQueue { get; set; }
20 |         public static Fusillade.IRequestCache? RequestCache { get; set; }
21 |         public static Fusillade.LimitingHttpMessageHandler Speculative { get; set; }
22 |         public static System.Net.Http.HttpMessageHandler UserInitiated { get; set; }
23 |     }
24 |     public class OfflineHttpMessageHandler : System.Net.Http.HttpMessageHandler
25 |     {
26 |         public OfflineHttpMessageHandler(System.Func<System.Net.Http.HttpRequestMessage, string, System.Threading.CancellationToken, System.Threading.Tasks.Task<byte[]>>? retrieveBodyFunc) { }
27 |         protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { }
28 |     }
29 |     public enum Priority
30 |     {
31 |         Explicit = 0,
32 |         Speculative = 10,
33 |         Background = 20,
34 |         UserInitiated = 100,
35 |     }
36 |     public class RateLimitedHttpMessageHandler : Fusillade.LimitingHttpMessageHandler
37 |     {
38 |         public RateLimitedHttpMessageHandler(System.Net.Http.HttpMessageHandler? handler, Fusillade.Priority basePriority, int priority = 0, long? maxBytesToRead = default, Punchclock.OperationQueue? opQueue = null, System.Func<System.Net.Http.HttpRequestMessage, System.Net.Http.HttpResponseMessage, string, System.Threading.CancellationToken, System.Threading.Tasks.Task>? cacheResultFunc = null) { }
39 |         public override void ResetLimit(long? maxBytesToRead = default) { }
40 |         protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { }
41 |         public static string UniqueKeyForRequest(System.Net.Http.HttpRequestMessage request) { }
42 |     }
43 | }
44 | namespace Splat.Builder
45 | {
46 |     public static class FusilladeSplatBuilderExtensions
47 |     {
48 |         public static Splat.Builder.IAppInstance CreateFusilladeNetCache(this Splat.Builder.IAppInstance builder) { }
49 |     }
50 | }


--------------------------------------------------------------------------------
/src/Fusillade.Tests/IntegrationTestHelper.cs:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
 2 | // Licensed to the .NET Foundation under one or more agreements.
 3 | // The .NET Foundation licenses this file to you under the MIT license.
 4 | // See the LICENSE file in the project root for full license information.
 5 | 
 6 | using System;
 7 | using System.IO;
 8 | using System.Linq;
 9 | using System.Net;
10 | using System.Net.Http;
11 | using System.Reactive.Linq;
12 | using System.Text;
13 | 
14 | namespace Fusillade.Tests
15 | {
16 |     /// <summary>
17 |     /// A helper for performing integration tests.
18 |     /// </summary>
19 |     public static class IntegrationTestHelper
20 |     {
21 |         /// <summary>
22 |         /// Combines together paths together and then gets a full path.
23 |         /// </summary>
24 |         /// <param name="paths">The paths to combine.</param>
25 |         /// <returns>The string path.</returns>
26 |         public static string GetPath(params string[] paths)
27 |         {
28 |             var ret = GetIntegrationTestRootDirectory();
29 |             return new FileInfo(paths.Aggregate(ret, Path.Combine)).FullName;
30 |         }
31 | 
32 |         /// <summary>
33 |         /// Gets the root directory for the integration test.
34 |         /// </summary>
35 |         /// <returns>The path.</returns>
36 |         public static string GetIntegrationTestRootDirectory()
37 |         {
38 |             // XXX: This is an evil hack, but it's okay for a unit test
39 |             // We can't use Assembly.Location because unit test runners love
40 |             // to move stuff to temp directories
41 |             return Directory.GetParent(Directory.GetCurrentDirectory())!.Parent!.FullName;
42 |         }
43 | 
44 |         /// <summary>
45 |         /// Creates a response from a sample file with the data.
46 |         /// </summary>
47 |         /// <param name="paths">The path to the file.</param>
48 |         /// <returns>The generated response.</returns>
49 |         public static HttpResponseMessage GetResponse(params string[] paths)
50 |         {
51 |             var bytes = File.ReadAllBytes(GetPath(paths));
52 | 
53 |             // Find the body
54 |             var bodyIndex = -1;
55 |             for (bodyIndex = 0; bodyIndex < bytes.Length - 3; bodyIndex++)
56 |             {
57 |                 if (bytes[bodyIndex] != 0x0D || bytes[bodyIndex + 1] != 0x0A ||
58 |                     bytes[bodyIndex + 2] != 0x0D || bytes[bodyIndex + 3] != 0x0A)
59 |                 {
60 |                     continue;
61 |                 }
62 | 
63 |                 goto foundIt;
64 |             }
65 | 
66 |             throw new Exception("Couldn't find response body");
67 | 
68 |         foundIt:
69 | 
70 |             var headerText = Encoding.UTF8.GetString(bytes, 0, bodyIndex);
71 |             var lines = headerText.Split('\n');
72 |             var statusCode = (HttpStatusCode)int.Parse(lines[0].Split(' ')[1]);
73 |             var ret = new HttpResponseMessage(statusCode);
74 | 
75 |             ret.Content = new ByteArrayContent(bytes, bodyIndex + 2, bytes.Length - bodyIndex - 2);
76 | 
77 |             foreach (var line in lines.Skip(1))
78 |             {
79 |                 var separatorIndex = line.IndexOf(':');
80 |                 var key = line.Substring(0, separatorIndex);
81 |                 var val = line.Substring(separatorIndex + 2).TrimEnd();
82 | 
83 |                 if (string.IsNullOrWhiteSpace(line))
84 |                 {
85 |                     continue;
86 |                 }
87 | 
88 |                 ret.Headers.TryAddWithoutValidation(key, val);
89 |                 ret.Content.Headers.TryAddWithoutValidation(key, val);
90 |             }
91 | 
92 |             return ret;
93 |         }
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | 
  4 | # User-specific files
  5 | *.suo
  6 | *.user
  7 | *.userosscache
  8 | *.sln.docstates
  9 | 
 10 | # User-specific files (MonoDevelop/Xamarin Studio)
 11 | *.userprefs
 12 | 
 13 | # Build results
 14 | [Dd]ebug/
 15 | [Dd]ebugPublic/
 16 | [Rr]elease/
 17 | [Rr]eleases/
 18 | x64/
 19 | x86/
 20 | build/
 21 | bld/
 22 | [Bb]in/
 23 | [Oo]bj/
 24 | 
 25 | # Visual Studio 2015 cache/options directory
 26 | .vs/
 27 | # Uncomment if you have tasks that create the project's static files in wwwroot
 28 | #wwwroot/
 29 | 
 30 | # MSTest test Results
 31 | [Tt]est[Rr]esult*/
 32 | [Bb]uild[Ll]og.*
 33 | 
 34 | # NUNIT
 35 | *.VisualState.xml
 36 | TestResult.xml
 37 | 
 38 | # Build Results of an ATL Project
 39 | [Dd]ebugPS/
 40 | [Rr]eleasePS/
 41 | dlldata.c
 42 | 
 43 | # DNX
 44 | *.lock.json
 45 | artifacts/
 46 | *.nuget.props
 47 | *.nuget.targets
 48 | 
 49 | *_i.c
 50 | *_p.c
 51 | *_i.h
 52 | *.ilk
 53 | *.meta
 54 | *.obj
 55 | *.pch
 56 | *.pdb
 57 | *.pgc
 58 | *.pgd
 59 | *.rsp
 60 | *.sbr
 61 | *.tlb
 62 | *.tli
 63 | *.tlh
 64 | *.tmp
 65 | *.tmp_proj
 66 | *.log
 67 | *.vspscc
 68 | *.vssscc
 69 | .builds
 70 | *.pidb
 71 | *.svclog
 72 | *.scc
 73 | 
 74 | # Chutzpah Test files
 75 | _Chutzpah*
 76 | 
 77 | # Visual C++ cache files
 78 | ipch/
 79 | *.aps
 80 | *.ncb
 81 | *.opendb
 82 | *.opensdf
 83 | *.sdf
 84 | *.cachefile
 85 | 
 86 | # Visual Studio profiler
 87 | *.psess
 88 | *.vsp
 89 | *.vspx
 90 | *.sap
 91 | 
 92 | # TFS 2012 Local Workspace
 93 | $tf/
 94 | 
 95 | # Guidance Automation Toolkit
 96 | *.gpState
 97 | 
 98 | # ReSharper is a .NET coding add-in
 99 | _ReSharper*/
100 | *.[Rr]e[Ss]harper
101 | *.DotSettings.user
102 | 
103 | # JustCode is a .NET coding add-in
104 | .JustCode
105 | 
106 | # TeamCity is a build add-in
107 | _TeamCity*
108 | 
109 | # DotCover is a Code Coverage Tool
110 | *.dotCover
111 | 
112 | # NCrunch
113 | _NCrunch_*
114 | .*crunch*.local.xml
115 | nCrunchTemp_*
116 | 
117 | # MightyMoose
118 | *.mm.*
119 | AutoTest.Net/
120 | 
121 | # Web workbench (sass)
122 | .sass-cache/
123 | 
124 | # Installshield output folder
125 | [Ee]xpress/
126 | 
127 | # DocProject is a documentation generator add-in
128 | DocProject/buildhelp/
129 | DocProject/Help/*.HxT
130 | DocProject/Help/*.HxC
131 | DocProject/Help/*.hhc
132 | DocProject/Help/*.hhk
133 | DocProject/Help/*.hhp
134 | DocProject/Help/Html2
135 | DocProject/Help/html
136 | 
137 | # Click-Once directory
138 | publish/
139 | 
140 | # Publish Web Output
141 | *.[Pp]ublish.xml
142 | *.azurePubxml
143 | # TODO: Comment the next line if you want to checkin your web deploy settings
144 | # but database connection strings (with potential passwords) will be unencrypted
145 | *.pubxml
146 | *.publishproj
147 | 
148 | # NuGet Packages
149 | *.nupkg
150 | # The packages folder can be ignored because of Package Restore
151 | **/packages/*
152 | # except build/, which is used as an MSBuild target.
153 | !**/packages/build/
154 | # Uncomment if necessary however generally it will be regenerated when needed
155 | #!**/packages/repositories.config
156 | 
157 | # Windows Azure Build Output
158 | csx/
159 | *.build.csdef
160 | 
161 | # Windows Azure Emulator
162 | ecf/
163 | rcf/
164 | 
165 | # Windows Store app package directory
166 | AppPackages/
167 | BundleArtifacts/
168 | 
169 | # Visual Studio cache files
170 | # files ending in .cache can be ignored
171 | *.[Cc]ache
172 | # but keep track of directories ending in .cache
173 | !*.[Cc]ache/
174 | 
175 | # Others
176 | ClientBin/
177 | ~$*
178 | *~
179 | *.dbmdl
180 | *.dbproj.schemaview
181 | *.pfx
182 | *.publishsettings
183 | node_modules/
184 | orleans.codegen.cs
185 | 
186 | # RIA/Silverlight projects
187 | Generated_Code/
188 | 
189 | # Backup & report files from converting an old project file
190 | # to a newer Visual Studio version. Backup files are not needed,
191 | # because we have git ;-)
192 | _UpgradeReport_Files/
193 | Backup*/
194 | UpgradeLog*.XML
195 | UpgradeLog*.htm
196 | 
197 | # SQL Server files
198 | *.mdf
199 | *.ldf
200 | 
201 | # Business Intelligence projects
202 | *.rdl.data
203 | *.bim.layout
204 | *.bim_*.settings
205 | 
206 | # Microsoft Fakes
207 | FakesAssemblies/
208 | 
209 | # GhostDoc plugin setting file
210 | *.GhostDoc.xml
211 | 
212 | # Node.js Tools for Visual Studio
213 | .ntvs_analysis.dat
214 | 
215 | # Visual Studio 6 build log
216 | *.plg
217 | 
218 | # Visual Studio 6 workspace options file
219 | *.opt
220 | 
221 | # Visual Studio LightSwitch build output
222 | **/*.HTMLClient/GeneratedArtifacts
223 | **/*.DesktopClient/GeneratedArtifacts
224 | **/*.DesktopClient/ModelManifest.xml
225 | **/*.Server/GeneratedArtifacts
226 | **/*.Server/ModelManifest.xml
227 | _Pvt_Extensions
228 | 
229 | # Paket dependency manager
230 | .paket/paket.exe
231 | 
232 | # FAKE - F# Make
233 | .fake/
234 | 
235 | # Tools
236 | tools/
237 | 
238 | # ReactiveUI
239 | artifacts/
240 | src/CommonAssemblyInfo.cs
241 | src/ReactiveUI.Events/Events_*.cs
242 | src/Fusillade.Tests/API/ApiApprovalTests.*.received.txt
243 | 


--------------------------------------------------------------------------------
/src/Fusillade/NetCache.cs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
  2 | // Licensed to ReactiveUI and Contributors under one or more agreements.
  3 | // ReactiveUI and Contributors licenses this file to you under the MIT license.
  4 | // See the LICENSE file in the project root for full license information.
  5 | 
  6 | using System;
  7 | using System.Net.Http;
  8 | using Punchclock;
  9 | using Splat;
 10 | 
 11 | namespace Fusillade;
 12 | 
 13 | /// <summary>
 14 | /// Handles caching for our Http requests.
 15 | /// </summary>
 16 | public static class NetCache
 17 | {
 18 |     private static LimitingHttpMessageHandler speculative;
 19 |     [ThreadStatic]
 20 |     private static LimitingHttpMessageHandler? unitTestSpeculative;
 21 |     private static HttpMessageHandler userInitiated;
 22 |     [ThreadStatic]
 23 |     private static HttpMessageHandler? unitTestUserInitiated;
 24 |     private static HttpMessageHandler background;
 25 |     [ThreadStatic]
 26 |     private static HttpMessageHandler? unitTestBackground;
 27 |     private static HttpMessageHandler offline;
 28 |     [ThreadStatic]
 29 |     private static HttpMessageHandler? unitTestOffline;
 30 |     private static OperationQueue operationQueue = new(4);
 31 |     [ThreadStatic]
 32 |     private static OperationQueue? unitTestOperationQueue;
 33 |     private static IRequestCache? requestCache;
 34 |     [ThreadStatic]
 35 |     private static IRequestCache? unitTestRequestCache;
 36 |     private static IReadonlyDependencyResolver? Current;
 37 | 
 38 |     /// <summary>
 39 |     /// Initializes static members of the <see cref="NetCache"/> class.
 40 |     /// </summary>
 41 |     static NetCache()
 42 |     {
 43 |         var innerHandler = GetCurrent().GetService<HttpMessageHandler>() ?? new HttpClientHandler();
 44 | 
 45 |         // NB: In vNext this value will be adjusted based on the user's
 46 |         // network connection, but that requires us to go fully platformy
 47 |         // like Splat.
 48 |         speculative = new RateLimitedHttpMessageHandler(innerHandler, Priority.Speculative, 0, 1048576 * 5);
 49 |         userInitiated = new RateLimitedHttpMessageHandler(innerHandler, Priority.UserInitiated, 0);
 50 |         background = new RateLimitedHttpMessageHandler(innerHandler, Priority.Background, 0);
 51 |         offline = new OfflineHttpMessageHandler(null);
 52 |     }
 53 | 
 54 |     /// <summary>
 55 |     /// Gets or sets a handler of that allow a certain number of bytes to be
 56 |     /// read before cancelling all future requests. This is designed for
 57 |     /// reading data that may or may not be used by the user later, in order
 58 |     /// to improve response times should the user later request the data.
 59 |     /// </summary>
 60 |     public static LimitingHttpMessageHandler Speculative
 61 |     {
 62 |         get => unitTestSpeculative ?? GetCurrent().GetService<LimitingHttpMessageHandler>("Speculative") ?? speculative;
 63 |         set
 64 |         {
 65 |             if (ModeDetector.InUnitTestRunner())
 66 |             {
 67 |                 unitTestSpeculative = value;
 68 |                 speculative ??= value;
 69 |             }
 70 |             else
 71 |             {
 72 |                 speculative = value;
 73 |             }
 74 |         }
 75 |     }
 76 | 
 77 |     /// <summary>
 78 |     /// Gets or sets a scheduler that should be used for requests initiated by a user
 79 |     /// action such as clicking an item, they have the highest priority.
 80 |     /// </summary>
 81 |     public static HttpMessageHandler UserInitiated
 82 |     {
 83 |         get => unitTestUserInitiated ?? GetCurrent().GetService<HttpMessageHandler>("UserInitiated") ?? userInitiated;
 84 |         set
 85 |         {
 86 |             if (ModeDetector.InUnitTestRunner())
 87 |             {
 88 |                 unitTestUserInitiated = value;
 89 |                 userInitiated ??= value;
 90 |             }
 91 |             else
 92 |             {
 93 |                 userInitiated = value;
 94 |             }
 95 |         }
 96 |     }
 97 | 
 98 |     /// <summary>
 99 |     /// Gets or sets a scheduler that should be used for requests initiated in the
100 |     /// background, and are scheduled at a lower priority.
101 |     /// </summary>
102 |     public static HttpMessageHandler Background
103 |     {
104 |         get => unitTestBackground ?? GetCurrent().GetService<HttpMessageHandler>("Background") ?? background;
105 |         set
106 |         {
107 |             if (ModeDetector.InUnitTestRunner())
108 |             {
109 |                 unitTestBackground = value;
110 |                 background ??= value;
111 |             }
112 |             else
113 |             {
114 |                 background = value;
115 |             }
116 |         }
117 |     }
118 | 
119 |     /// <summary>
120 |     /// Gets or sets a scheduler that fetches results solely from the cache specified in
121 |     /// RequestCache.
122 |     /// </summary>
123 |     public static HttpMessageHandler Offline
124 |     {
125 |         get => unitTestOffline ?? GetCurrent().GetService<HttpMessageHandler>("Offline") ?? offline;
126 |         set
127 |         {
128 |             if (ModeDetector.InUnitTestRunner())
129 |             {
130 |                 unitTestOffline = value;
131 |                 offline ??= value;
132 |             }
133 |             else
134 |             {
135 |                 offline = value;
136 |             }
137 |         }
138 |     }
139 | 
140 |     /// <summary>
141 |     /// Gets or sets a scheduler that should be used for requests initiated in the
142 |     /// operationQueue, and are scheduled at a lower priority. You don't
143 |     /// need to mess with this.
144 |     /// </summary>
145 |     public static OperationQueue OperationQueue
146 |     {
147 |         get => unitTestOperationQueue ?? GetCurrent().GetService<OperationQueue>("OperationQueue") ?? operationQueue;
148 |         set
149 |         {
150 |             if (ModeDetector.InUnitTestRunner())
151 |             {
152 |                 unitTestOperationQueue = value;
153 |                 operationQueue ??= value;
154 |             }
155 |             else
156 |             {
157 |                 operationQueue = value;
158 |             }
159 |         }
160 |     }
161 | 
162 |     /// <summary>
163 |     /// Gets or sets a request cache that if set  indicates that HTTP handlers should save and load
164 |     /// requests from a cached source.
165 |     /// </summary>
166 |     public static IRequestCache? RequestCache
167 |     {
168 |         get => unitTestRequestCache ?? requestCache;
169 |         set
170 |         {
171 |             if (ModeDetector.InUnitTestRunner())
172 |             {
173 |                 unitTestRequestCache = value;
174 |                 requestCache ??= value;
175 |             }
176 |             else
177 |             {
178 |                 requestCache = value;
179 |             }
180 |         }
181 |     }
182 | 
183 |     internal static void CreateDefaultInstances(IReadonlyDependencyResolver? current)
184 |     {
185 |         // This method is just here to force the static constructor to run
186 |         Current = current;
187 |     }
188 | 
189 |     private static IReadonlyDependencyResolver GetCurrent()
190 |     {
191 |         return Current ??= AppLocator.Current;
192 |     }
193 | }
194 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
  1 | # Contributing to Fusillade
  2 | 
  3 | We'd love for you to contribute to our source code and to make Fusillade even better than it is
  4 | today! Here are the guidelines we'd like you to follow:
  5 | 
  6 |  - [Code of Conduct](#coc)
  7 |  - [Question or Problem?](#question)
  8 |  - [Issues and Bugs](#issue)
  9 |  - [Feature Requests](#feature)
 10 |  - [Submission Guidelines](#submit)
 11 |  - [Coding Rules](#rules)
 12 |  - [Commit Message Guidelines](#commit)
 13 | 
 14 | ## <a name="coc"></a> Code of Conduct
 15 | 
 16 | Help us keep the project open and inclusive. Please read and follow our [Code of Conduct](CODE_OF_CONDUCT.md).
 17 | 
 18 | ## <a name="question"></a> Got a Question or Problem?
 19 | 
 20 | 
 21 | ## <a name="issue"></a> Found an Issue?
 22 | 
 23 | If you find a bug in the source code or a mistake in the documentation, you can help us by
 24 | submitting an issue to our [GitHub Repository](https://github.com/reactiveui/Fusillade). Even better you can submit a Pull Request
 25 | with a fix.
 26 | 
 27 | **Please see the [Submission Guidelines](#submit) below.**
 28 | 
 29 | ## <a name="feature"></a> Want a Feature?
 30 | 
 31 | You can request a new feature by submitting an issue to our [GitHub Repository](https://github.com/paulcbetts/Fusillade).  If you
 32 | would like to implement a new feature then consider what kind of change it is:
 33 | 
 34 |   prevent duplication of work, and help you to craft the change so that it is successfully accepted
 35 |   into the project.
 36 | * **Small Changes** can be crafted and submitted to the [GitHub Repository](https://github.com/reactiveui/Fusillade) as a Pull
 37 |   Request.
 38 | 
 39 | ## <a name="submit"></a> Submission Guidelines
 40 | 
 41 | ### Submitting an Issue
 42 | 
 43 | If your issue appears to be a bug, and hasn't been reported, open a new issue. Help us to maximize
 44 | the effort we can spend fixing issues and adding new features, by not reporting duplicate issues.
 45 | 
 46 | Providing the following information will increase the chances of your issue being dealt with
 47 | quickly:
 48 | 
 49 | * **Overview of the Issue** - if an error is being thrown a stack trace helps
 50 | * **Motivation for or Use Case** - explain why this is a bug for you
 51 | * **Fusillade Version(s)** - is it a regression?
 52 | * **Operating System** - is this a problem with all browsers or only specific ones?
 53 | * **Reproduce the Error** - provide a example or an unambiguous set of steps.
 54 | * **Related Issues** - has a similar issue been reported before?
 55 | * **Suggest a Fix** - if you can't fix the bug yourself, perhaps you can point to what might be
 56 |   causing the problem (line of code or commit)
 57 | 
 58 | **If you get help, help others. Good karma rulez!**
 59 | 
 60 | ### Submitting a Pull Request
 61 | Before you submit your pull request consider the following guidelines:
 62 | 
 63 | * Search [GitHub](https://github.com/reactiveui/Fusillade/pulls) for an open or closed Pull Request
 64 |   that relates to your submission. You don't want to duplicate effort.
 65 | * Make your changes in a new git branch:
 66 | 
 67 |     ```shell
 68 |     git checkout -b my-fix-branch master
 69 |     ```
 70 | 
 71 | * Create your patch, **including appropriate test cases**.
 72 | * Follow our [Coding Rules](#rules).
 73 | * Run the test suite, as described below.
 74 | * Commit your changes using a descriptive commit message that follows our
 75 |   [commit message conventions](#commit).
 76 | 
 77 |     ```shell
 78 |     git commit -a
 79 |     ```
 80 |   Note: the optional commit `-a` command line option will automatically "add" and "rm" edited files.
 81 | 
 82 | * Build your changes locally to ensure all the tests pass:
 83 | 
 84 |     ```shell
 85 |     build.cmd
 86 |     ```
 87 | 
 88 | * Push your branch to GitHub:
 89 | 
 90 |     ```shell
 91 |     git push origin my-fix-branch
 92 |     ```
 93 | 
 94 | In GitHub, send a pull request to `Fusillade:master`.
 95 | 
 96 | If we suggest changes, then:
 97 | 
 98 | * Make the required updates.
 99 | * Re-run the test suite to ensure tests are still passing.
100 | * Commit your changes to your branch (e.g. `my-fix-branch`).
101 | * Push the changes to your GitHub repository (this will update your Pull Request).
102 | 
103 | If the PR gets too outdated we may ask you to rebase and force push to update the PR:
104 | 
105 | ```shell
106 | git rebase master -i
107 | git push origin my-fix-branch -f
108 | ```
109 | 
110 | _WARNING: Squashing or reverting commits and force-pushing thereafter may remove GitHub comments
111 | on code that were previously made by you or others in your commits. Avoid any form of rebasing
112 | unless necessary._
113 | 
114 | That's it! Thank you for your contribution!
115 | 
116 | #### After your pull request is merged
117 | 
118 | After your pull request is merged, you can safely delete your branch and pull the changes
119 | from the main (upstream) repository:
120 | 
121 | * Delete the remote branch on GitHub either through the GitHub web UI or your local shell as follows:
122 | 
123 |     ```shell
124 |     git push origin --delete my-fix-branch
125 |     ```
126 | 
127 | * Check out the master branch:
128 | 
129 |     ```shell
130 |     git checkout master -f
131 |     ```
132 | 
133 | * Delete the local branch:
134 | 
135 |     ```shell
136 |     git branch -D my-fix-branch
137 |     ```
138 | 
139 | * Update your master with the latest upstream version:
140 | 
141 |     ```shell
142 |     git pull --ff upstream master
143 |     ```
144 | 
145 | ## <a name="rules"></a> Coding Rules
146 | 
147 | To ensure consistency throughout the source code, keep these rules in mind as you are working:
148 | 
149 | * All features or bug fixes **must be tested** by one or more unit tests.
150 | * All public API methods **must be documented** with XML documentation.
151 | 
152 | ## <a name="commit"></a> Git Commit Guidelines
153 | 
154 | Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special
155 | format that includes a **type**  and a **subject**:
156 | 
157 | ```
158 | <type>: <subject>
159 | <body>
160 | <BLANK LINE>
161 | <footer>
162 | ```
163 | 
164 | ### Revert
165 | 
166 | If the commit reverts a previous commit, it should begin with `revert: `, followed by the header of the reverted commit. In the body it should say: `This reverts commit <hash>.`, where the hash is the SHA of the commit being reverted.
167 | 
168 | ### Type
169 | 
170 | Must be one of the following:
171 | 
172 | * **feat**: A new feature
173 | * **fix**: A bug fix
174 | * **docs**: Documentation only changes
175 | * **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
176 |   semi-colons, etc)
177 | * **refactor**: A code change that neither fixes a bug nor adds a feature
178 | * **perf**: A code change that improves performance
179 | * **test**: Adding missing tests
180 | * **chore**: Changes to the build process or auxiliary tools and libraries such as documentation
181 |   generation
182 | 
183 | ### Subject
184 | The subject contains succinct description of the change:
185 | 
186 | * use the imperative, present tense: "change" not "changed" nor "changes"
187 | * don't capitalize first letter
188 | * no dot (.) at the end
189 | 
190 | ### Body
191 | Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes".
192 | The body should include the motivation for the change and contrast this with previous behavior.
193 | 
194 | ### Footer
195 | The footer should contain any information about **Breaking Changes** and is also the place to
196 | reference GitHub issues that this commit **Closes**.
197 | 
198 | **Breaking Changes** should start with the word `BREAKING CHANGE:` with a space or two newlines. The rest of the commit message is then used for this.
199 | 


--------------------------------------------------------------------------------
/src/Fusillade.Tests/Http/HttpSchedulerCachingTests.cs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
  2 | // Licensed to the .NET Foundation under one or more agreements.
  3 | // The .NET Foundation licenses this file to you under the MIT license.
  4 | // See the LICENSE file in the project root for full license information.
  5 | 
  6 | using System;
  7 | using System.Collections.Generic;
  8 | using System.Linq;
  9 | using System.Net;
 10 | using System.Net.Http;
 11 | using System.Net.Http.Headers;
 12 | using System.Reactive.Linq;
 13 | using System.Text;
 14 | using System.Threading.Tasks;
 15 | using Akavache;
 16 | using Akavache.SystemTextJson;
 17 | using NUnit.Framework; // switched from xunit
 18 | 
 19 | namespace Fusillade.Tests.Http
 20 | {
 21 |     /// <summary>
 22 |     /// Checks to make sure that the http scheduler caches correctly.
 23 |     /// </summary>
 24 |     [TestFixture]
 25 |     public class HttpSchedulerCachingTests
 26 |     {
 27 |         /// <summary>
 28 |         /// Checks to make sure that the caching functiosn are only called with content.
 29 |         /// </summary>
 30 |         /// <returns>A task to monitor the progress.</returns>
 31 |         [Test]
 32 |         public async Task CachingFunctionShouldBeCalledWithContent()
 33 |         {
 34 |             var innerHandler = new TestHttpMessageHandler(_ =>
 35 |             {
 36 |                 var ret = new HttpResponseMessage()
 37 |                 {
 38 |                     Content = new StringContent("foo", Encoding.UTF8),
 39 |                     StatusCode = HttpStatusCode.OK,
 40 |                 };
 41 | 
 42 |                 ret.Headers.ETag = new EntityTagHeaderValue("\"worifjw\"");
 43 |                 return Observable.Return(ret);
 44 |             });
 45 | 
 46 |             var contentResponses = new List<byte[]>();
 47 | 
 48 | #if NET472
 49 |             var fixture = new RateLimitedHttpMessageHandler(innerHandler, Priority.UserInitiated, cacheResultFunc: async (rq, re, key, ct) => contentResponses.Add(await re.Content.ReadAsByteArrayAsync()));
 50 | #else
 51 |             var fixture = new RateLimitedHttpMessageHandler(innerHandler, Priority.UserInitiated, cacheResultFunc: async (rq, re, key, ct) => contentResponses.Add(await re.Content.ReadAsByteArrayAsync(ct)));
 52 | #endif
 53 | 
 54 |             var client = new HttpClient(fixture);
 55 |             var str = await client.GetStringAsync(new Uri("http://lol/bar"));
 56 | 
 57 |             using (Assert.EnterMultipleScope())
 58 |             {
 59 |                 Assert.That(str, Is.EqualTo("foo"));
 60 |                 Assert.That(contentResponses, Has.Count.EqualTo(1));
 61 |             }
 62 | 
 63 |             Assert.That(contentResponses[0], Has.Length.EqualTo(3));
 64 |         }
 65 | 
 66 |         /// <summary>
 67 |         /// Checks to make sure that the cache preserves the http headers.
 68 |         /// </summary>
 69 |         /// <returns>A task to monitor the progress.</returns>
 70 |         [Test]
 71 |         public async Task CachingFunctionShouldPreserveHeaders()
 72 |         {
 73 |             var innerHandler = new TestHttpMessageHandler(_ =>
 74 |             {
 75 |                 var ret = new HttpResponseMessage()
 76 |                 {
 77 |                     Content = new StringContent("foo", Encoding.UTF8),
 78 |                     StatusCode = HttpStatusCode.OK,
 79 |                 };
 80 | 
 81 |                 ret.Headers.ETag = new("\"worifjw\"");
 82 |                 return Observable.Return(ret);
 83 |             });
 84 | 
 85 |             var etagResponses = new List<string>();
 86 |             var fixture = new RateLimitedHttpMessageHandler(innerHandler, Priority.UserInitiated, cacheResultFunc: (rq, re, key, ct) =>
 87 |             {
 88 |                 etagResponses.Add(re.Headers.ETag!.Tag);
 89 |                 return Task.FromResult(true);
 90 |             });
 91 | 
 92 |             var client = new HttpClient(fixture);
 93 |             var resp = await client.GetAsync(new Uri("http://lol/bar"));
 94 |             Assert.That(etagResponses[0], Is.EqualTo("\"worifjw\""));
 95 |         }
 96 | 
 97 |         /// <summary>
 98 |         /// Does a round trip integration test.
 99 |         /// </summary>
100 |         /// <returns>A task to monitor the progress.</returns>
101 |         [Test]
102 |         public async Task RoundTripIntegrationTest()
103 |         {
104 |             var aka = CacheDatabase.CreateBuilder().WithSerializerSystemTextJson().Build();
105 |             var cache = new InMemoryBlobCache(aka.Serializer!);
106 | 
107 |             var cachingHandler = new RateLimitedHttpMessageHandler(new HttpClientHandler(), Priority.UserInitiated, cacheResultFunc: async (rq, resp, key, ct) =>
108 |             {
109 | #if NET472
110 |                 var data = await resp.Content.ReadAsByteArrayAsync();
111 | #else
112 |                 var data = await resp.Content.ReadAsByteArrayAsync(ct);
113 | #endif
114 |                 await cache.Insert(key, data);
115 |             });
116 | 
117 |             var client = new HttpClient(cachingHandler);
118 |             var origData = await client.GetStringAsync(new Uri("http://httpbin.org/get"));
119 | 
120 |             Assert.That(origData, Does.Contain("origin"));
121 | 
122 |             var singleKey = await cache.GetAllKeys();
123 |             using (Assert.EnterMultipleScope())
124 |             {
125 |                 Assert.That(string.IsNullOrEmpty(singleKey), Is.False);
126 |                 Assert.That(singleKey.StartsWith("HttpSchedulerCache_", StringComparison.Ordinal), Is.True);
127 |             }
128 | 
129 |             var offlineHandler = new OfflineHttpMessageHandler(async (rq, key, ct) => await cache.Get(key));
130 | 
131 |             client = new HttpClient(offlineHandler);
132 |             var newData = await client.GetStringAsync(new Uri("http://httpbin.org/get"));
133 | 
134 |             Assert.That(origData, Is.EqualTo(newData));
135 | 
136 |             var shouldDie = true;
137 |             try
138 |             {
139 |                 await client.GetStringAsync(new Uri("http://httpbin.org/gzip"));
140 |             }
141 |             catch (Exception ex)
142 |             {
143 |                 shouldDie = false;
144 |                 Console.WriteLine(ex);
145 |             }
146 | 
147 |             Assert.That(shouldDie, Is.False);
148 |         }
149 | 
150 |         /// <summary>
151 |         /// Checks that only relevant http methods are cached.
152 |         /// </summary>
153 |         /// <param name="method">The name of the method.</param>
154 |         /// <param name="shouldCache">If it should be cached or not.</param>
155 |         /// <returns>A task to monitor the progress.</returns>
156 |         [TestCase("GET", true)]
157 |         [TestCase("HEAD", true)]
158 |         [TestCase("OPTIONS", true)]
159 |         [TestCase("POST", false)]
160 |         [TestCase("DELETE", false)]
161 |         [TestCase("PUT", false)]
162 |         [TestCase("WHATEVER", false)]
163 |         public async Task OnlyCacheRelevantMethods(string method, bool shouldCache)
164 |         {
165 |             var innerHandler = new TestHttpMessageHandler(_ =>
166 |             {
167 |                 var ret = new HttpResponseMessage()
168 |                 {
169 |                     Content = new StringContent("foo", Encoding.UTF8),
170 |                     StatusCode = HttpStatusCode.OK,
171 |                 };
172 | 
173 |                 return Observable.Return(ret);
174 |             });
175 | 
176 |             var cached = false;
177 |             var fixture = new RateLimitedHttpMessageHandler(innerHandler, Priority.UserInitiated, cacheResultFunc: (rq, re, key, ct) =>
178 |             {
179 |                 cached = true;
180 |                 return Task.FromResult(true);
181 |             });
182 | 
183 |             var client = new HttpClient(fixture);
184 |             var request = new HttpRequestMessage(new(method), "http://lol/bar");
185 |             await client.SendAsync(request);
186 | 
187 |             Assert.That(cached, Is.EqualTo(shouldCache));
188 |         }
189 |     }
190 | }
191 | 


--------------------------------------------------------------------------------
/src/Fusillade/RateLimitedHttpMessageHandler.cs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
  2 | // Licensed to ReactiveUI and Contributors under one or more agreements.
  3 | // ReactiveUI and Contributors licenses this file to you under the MIT license.
  4 | // See the LICENSE file in the project root for full license information.
  5 | 
  6 | using System;
  7 | using System.Collections.Generic;
  8 | using System.Globalization;
  9 | using System.IO;
 10 | using System.Linq;
 11 | using System.Net.Http;
 12 | using System.Reactive.Linq;
 13 | using System.Reactive.Threading.Tasks;
 14 | using System.Text;
 15 | using System.Threading;
 16 | using System.Threading.Tasks;
 17 | using Punchclock;
 18 | 
 19 | namespace Fusillade;
 20 | 
 21 | /// <summary>
 22 | /// A http handler which will limit the rate at which we can read.
 23 | /// </summary>
 24 | /// <remarks>
 25 | /// Initializes a new instance of the <see cref="RateLimitedHttpMessageHandler"/> class.
 26 | /// </remarks>
 27 | /// <param name="handler">The handler we are wrapping.</param>
 28 | /// <param name="basePriority">The base priority of the request.</param>
 29 | /// <param name="priority">The priority of the request.</param>
 30 | /// <param name="maxBytesToRead">The maximum number of bytes we can read.</param>
 31 | /// <param name="opQueue">The operation queue on which to run the operation.</param>
 32 | /// <param name="cacheResultFunc">A method that is called if we need to get cached results.</param>
 33 | public class RateLimitedHttpMessageHandler(HttpMessageHandler? handler, Priority basePriority, int priority = 0, long? maxBytesToRead = null, OperationQueue? opQueue = null, Func<HttpRequestMessage, HttpResponseMessage, string, CancellationToken, Task>? cacheResultFunc = null) : LimitingHttpMessageHandler(handler)
 34 | {
 35 |     private readonly int _priority = (int)basePriority + priority;
 36 |     private readonly Dictionary<string, InflightRequest> _inflightResponses = new();
 37 |     private long? _maxBytesToRead = maxBytesToRead;
 38 | 
 39 |     /// <summary>
 40 |     /// Generates a unique key for a <see cref="HttpRequestMessage"/>.
 41 |     /// This assists with the caching.
 42 |     /// </summary>
 43 |     /// <param name="request">The request to generate a unique key for.</param>
 44 |     /// <returns>The unique key.</returns>
 45 |     public static string UniqueKeyForRequest(HttpRequestMessage request)
 46 |     {
 47 |         if (request is null)
 48 |         {
 49 |             throw new ArgumentNullException(nameof(request));
 50 |         }
 51 | 
 52 |         var ret = new[]
 53 |         {
 54 |             request.RequestUri!.ToString(),
 55 |             request.Method.Method,
 56 |             request.Headers.Accept.ConcatenateAll(x => x.CharSet + x.MediaType),
 57 |             request.Headers.AcceptEncoding.ConcatenateAll(x => x.Value),
 58 |             (request.Headers.Referrer ?? new Uri("http://example")).AbsoluteUri,
 59 |             request.Headers.UserAgent.ConcatenateAll(x => x.Product != null ? x.Product.ToString() : x.Comment!),
 60 |         }.Aggregate(
 61 |             new StringBuilder(),
 62 |             (acc, x) =>
 63 |             {
 64 |                 acc.AppendLine(x);
 65 |                 return acc;
 66 |             });
 67 | 
 68 |         if (request.Headers.Authorization != null)
 69 |         {
 70 |             ret.Append(request.Headers.Authorization.Parameter).AppendLine(request.Headers.Authorization.Scheme);
 71 |         }
 72 | 
 73 |         return "HttpSchedulerCache_" + ret.ToString().GetHashCode().ToString("x", CultureInfo.InvariantCulture);
 74 |     }
 75 | 
 76 |     /// <inheritdoc />
 77 |     public override void ResetLimit(long? maxBytesToRead = null) => _maxBytesToRead = maxBytesToRead;
 78 | 
 79 |     /// <inheritdoc />
 80 |     protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
 81 |     {
 82 |         if (request is null)
 83 |         {
 84 |             throw new ArgumentNullException(nameof(request));
 85 |         }
 86 | 
 87 |         var method = request.Method;
 88 |         if (method != HttpMethod.Get && method != HttpMethod.Head && method != HttpMethod.Options)
 89 |         {
 90 |             return base.SendAsync(request, cancellationToken);
 91 |         }
 92 | 
 93 |         var cacheResult = cacheResultFunc;
 94 |         if (cacheResult == null && NetCache.RequestCache != null)
 95 |         {
 96 |             cacheResult = NetCache.RequestCache.Save;
 97 |         }
 98 | 
 99 |         if (_maxBytesToRead < 0)
100 |         {
101 |             var tcs = new TaskCompletionSource<HttpResponseMessage>();
102 | #if NETSTANDARD2_0
103 |             tcs.SetCanceled();
104 | #else
105 |             tcs.SetCanceled(cancellationToken);
106 | #endif
107 |             return tcs.Task;
108 |         }
109 | 
110 |         var key = UniqueKeyForRequest(request);
111 |         var realToken = new CancellationTokenSource();
112 |         var ret = new InflightRequest(() =>
113 |         {
114 |             lock (_inflightResponses)
115 |             {
116 |                 _inflightResponses.Remove(key);
117 |             }
118 | 
119 |             realToken.Cancel();
120 |         });
121 | 
122 |         lock (_inflightResponses)
123 |         {
124 |             if (_inflightResponses.ContainsKey(key))
125 |             {
126 |                 var val = _inflightResponses[key];
127 |                 val.AddRef();
128 |                 cancellationToken.Register(val.Cancel);
129 | 
130 |                 return val.Response.ToTask(cancellationToken);
131 |             }
132 | 
133 |             _inflightResponses[key] = ret;
134 |         }
135 | 
136 |         cancellationToken.Register(ret.Cancel);
137 | 
138 |         var queue = opQueue ?? NetCache.OperationQueue;
139 | 
140 |         queue.Enqueue(
141 |             _priority,
142 |             null!,
143 |             async () =>
144 |             {
145 |                 try
146 |                 {
147 |                     var resp = await base.SendAsync(request, realToken.Token).ConfigureAwait(false);
148 | 
149 |                     if (_maxBytesToRead != null && resp.Content?.Headers.ContentLength != null)
150 |                     {
151 |                         _maxBytesToRead -= resp.Content.Headers.ContentLength;
152 |                     }
153 | 
154 |                     if (cacheResult != null && resp.Content != null)
155 |                     {
156 |                         var ms = new MemoryStream();
157 | #if NET5_0_OR_GREATER
158 |                         var stream = await resp.Content.ReadAsStreamAsync(realToken.Token).ConfigureAwait(false);
159 | #else
160 |                         var stream = await resp.Content.ReadAsStreamAsync().ConfigureAwait(false);
161 | #endif
162 |                         await stream.CopyToAsync(ms, 32 * 1024, realToken.Token).ConfigureAwait(false);
163 | 
164 |                         realToken.Token.ThrowIfCancellationRequested();
165 | 
166 |                         var newResp = new HttpResponseMessage();
167 |                         foreach (var kvp in resp.Headers)
168 |                         {
169 |                             newResp.Headers.TryAddWithoutValidation(kvp.Key, kvp.Value);
170 |                         }
171 | 
172 |                         var newContent = new ByteArrayContent(ms.ToArray());
173 |                         foreach (var kvp in resp.Content.Headers)
174 |                         {
175 |                             newContent.Headers.TryAddWithoutValidation(kvp.Key, kvp.Value);
176 |                         }
177 | 
178 |                         newResp.Content = newContent;
179 | 
180 |                         resp = newResp;
181 |                         await cacheResult(request, resp, key, realToken.Token).ConfigureAwait(false);
182 |                     }
183 | 
184 |                     return resp;
185 |                 }
186 |                 finally
187 |                 {
188 |                     lock (_inflightResponses)
189 |                     {
190 |                         _inflightResponses.Remove(key);
191 |                     }
192 |                 }
193 |             },
194 |             realToken.Token).ToObservable().Subscribe(ret.Response);
195 | 
196 |         return ret.Response.ToTask(cancellationToken);
197 |     }
198 | }
199 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![NuGet Stats](https://img.shields.io/nuget/v/fusillade.svg)](https://www.nuget.org/packages/fusillade) ![Build](https://github.com/reactiveui/Fusillade/workflows/Build/badge.svg) [![Code Coverage](https://codecov.io/gh/reactiveui/fusillade/branch/main/graph/badge.svg)](https://codecov.io/gh/reactiveui/fusillade)
  2 | 
  3 | <br />
  4 | <a href="https://github.com/reactiveui/fusillade">
  5 |   <img width="120" heigth="120" src="https://raw.githubusercontent.com/reactiveui/styleguide/master/logo_fusillade/main.png">
  6 | </a>
  7 | 
  8 | ## Fusillade: An opinionated HTTP library for .NET apps
  9 | 
 10 | Fusillade helps you write efficient, resilient networked apps by composing HttpMessageHandlers for HttpClient. It focuses on:
 11 | 
 12 | - Request de-duplication for relevant HTTP methods
 13 | - Concurrency limiting via a priority-aware operation queue
 14 | - Request prioritization for predictable UX
 15 | - Speculative background fetching with byte-budget limits
 16 | - Optional caching of responses and an offline replay handler
 17 | 
 18 | Design inspirations include Android's Volley and Picasso.
 19 | 
 20 | Supported targets: library is built for .NET Standard 2.0 and is used from modern .NET (e.g., .NET 8/9), Xamarin/Mono, and .NET for iOS/Android/Mac Catalyst apps.
 21 | 
 22 | 
 23 | ## Install
 24 | 
 25 | - Package Manager: Install-Package fusillade
 26 | - .NET CLI: dotnet add package fusillade
 27 | 
 28 | Optional (examples below): Akavache for caching.
 29 | 
 30 | - .NET CLI: dotnet add package Akavache.SystemTextJson
 31 | 
 32 | 
 33 | ## Quick start
 34 | 
 35 | Create HttpClient instances by picking the right handler from NetCache:
 36 | 
 37 | ```csharp
 38 | using Fusillade;
 39 | using System.Net.Http;
 40 | 
 41 | // Highest priority: the user is waiting now
 42 | var client = new HttpClient(NetCache.UserInitiated);
 43 | var json = await client.GetStringAsync("https://httpbin.org/get");
 44 | ```
 45 | 
 46 | Available built-ins:
 47 | 
 48 | - NetCache.UserInitiated: foreground work the user is waiting for
 49 | - NetCache.Background: background work that should not block UI work
 50 | - NetCache.Speculative: background prefetching with a byte budget
 51 | - NetCache.Offline: fetch from cache only (no network)
 52 | 
 53 | By default, requests are processed four at a time via an operation queue.
 54 | 
 55 | 
 56 | ## Core ideas
 57 | 
 58 | ### 1) Request de-duplication
 59 | 
 60 | Fusillade de-duplicates concurrent requests for the same resource when the method is GET, HEAD, or OPTIONS. If multiple callers request the same URL concurrently, only one on-the-wire request is made; the others join the same in-flight response.
 61 | 
 62 | This happens transparently in RateLimitedHttpMessageHandler.
 63 | 
 64 | ### 2) Concurrency limiting and prioritization
 65 | 
 66 | All work is scheduled through an OperationQueue (default parallelism is 4). Each handler has an effective priority:
 67 | 
 68 | - Priority.UserInitiated (100)
 69 | - Priority.Background (20)
 70 | - Priority.Speculative (10)
 71 | - Priority.Explicit (custom base with offset)
 72 | 
 73 | Higher numbers run before lower ones. You can set a custom base (Explicit) and an offset to fit your scenario.
 74 | 
 75 | ```csharp
 76 | using Fusillade;
 77 | using Punchclock;
 78 | using System.Net.Http;
 79 | 
 80 | // Custom queue with 2 concurrent slots
 81 | var queue = new OperationQueue(2);
 82 | 
 83 | var handler = new RateLimitedHttpMessageHandler(
 84 |     new HttpClientHandler(),
 85 |     basePriority: Priority.Explicit,
 86 |     priority: 500,           // higher runs earlier
 87 |     opQueue: queue);
 88 | 
 89 | var client = new HttpClient(handler);
 90 | ```
 91 | 
 92 | ### 3) Speculative background fetching with byte budgets
 93 | 
 94 | Use NetCache.Speculative for prefetching scenarios. Limit the total number of bytes fetched; once the limit is reached, further speculative requests are canceled.
 95 | 
 96 | ```csharp
 97 | // Reset byte budget to 5 MB (e.g., on app resume)
 98 | NetCache.Speculative.ResetLimit(5 * 1024 * 1024);
 99 | 
100 | var prefetch = new HttpClient(NetCache.Speculative);
101 | _ = prefetch.GetStringAsync("https://example.com/expensive-data");
102 | ```
103 | 
104 | To stop speculative fetching immediately:
105 | 
106 | ```csharp
107 | NetCache.Speculative.ResetLimit(-1); // any further requests will be canceled
108 | ```
109 | 
110 | 
111 | ## Caching and offline
112 | 
113 | Fusillade can optionally cache responses (body bytes + headers) and replay them when offline.
114 | 
115 | There are two ways to wire caching:
116 | 
117 | 1) Provide a cacheResultFunc to RateLimitedHttpMessageHandler, which gets called with the response and a unique request key when a response is received.
118 | 
119 | 2) Set NetCache.RequestCache with an implementation of IRequestCache. Fusillade will invoke Save and Fetch automatically.
120 | 
121 | ### IRequestCache
122 | 
123 | ```csharp
124 | public interface IRequestCache
125 | {
126 |     Task Save(HttpRequestMessage request, HttpResponseMessage response, string key, CancellationToken ct);
127 |     Task<byte[]> Fetch(HttpRequestMessage request, string key, CancellationToken ct);
128 | }
129 | ```
130 | 
131 | - Save is called once the handler has fully buffered the body (as ByteArrayContent) and cloned headers.
132 | - Fetch should return the previously saved body bytes for the key (or null if not found).
133 | 
134 | Keys are generated by RateLimitedHttpMessageHandler.UniqueKeyForRequest(request). Treat the key as an implementation detail; persist what you receive and return it during Fetch.
135 | 
136 | ### Simple Akavache-based cache
137 | 
138 | ```csharp
139 | using Akavache;
140 | using Akavache.SystemTextJson;
141 | using Fusillade;
142 | using System.Net.Http;
143 | 
144 | // Initialize a simple in-memory Akavache cache
145 | var database = CacheDatabase.CreateBuilder().WithSerializerSystemTextJson().Build();
146 | var blobCache = new InMemoryBlobCache(database.Serializer);
147 | 
148 | // Option A: Provide a cacheResultFunc directly
149 | var cachingHandler = new RateLimitedHttpMessageHandler(
150 |     new HttpClientHandler(),
151 |     Priority.UserInitiated,
152 |     cacheResultFunc: async (rq, resp, key, ct) =>
153 |     {
154 |         var data = await resp.Content.ReadAsByteArrayAsync(ct);
155 |         await blobCache.Insert(key, data);
156 |     });
157 | 
158 | var client = new HttpClient(cachingHandler);
159 | var fresh = await client.GetStringAsync("https://httpbin.org/get");
160 | 
161 | // Option B: Implement IRequestCache and set NetCache.RequestCache
162 | NetCache.RequestCache = new MyRequestCache(blobCache);
163 | ```
164 | 
165 | ```csharp
166 | // Example IRequestCache wrapper over Akavache
167 | class MyRequestCache : IRequestCache
168 | {
169 |     private readonly IBlobCache _cache;
170 |     public MyRequestCache(IBlobCache cache) => _cache = cache;
171 | 
172 |     public async Task Save(HttpRequestMessage request, HttpResponseMessage response, string key, CancellationToken ct)
173 |     {
174 |         var bytes = await response.Content.ReadAsByteArrayAsync(ct);
175 |         await _cache.Insert(key, bytes);
176 |     }
177 | 
178 |     public Task<byte[]> Fetch(HttpRequestMessage request, string key, CancellationToken ct)
179 |         => _cache.Get(key);
180 | }
181 | ```
182 | 
183 | ### Offline replay
184 | 
185 | Use OfflineHttpMessageHandler to serve cached data only (no network). This handler asks IRequestCache (or your custom retrieveBodyFunc) for the cached body and returns:
186 | 
187 | - 200 OK with the cached body, or
188 | - 503 Service Unavailable if not found
189 | 
190 | ```csharp
191 | // Use NetCache.Offline after setting NetCache.RequestCache
192 | var offline = new HttpClient(NetCache.Offline);
193 | var data = await offline.GetStringAsync("https://httpbin.org/get");
194 | 
195 | // Or construct explicitly
196 | var offlineExplicit = new HttpClient(new OfflineHttpMessageHandler(
197 |     async (rq, key, ct) => await blobCache.Get(key)));
198 | ```
199 | 
200 | 
201 | ## Dependency injection and Splat integration
202 | 
203 | If you use Splat, you can initialize NetCache to use your container’s services via the provided extension:
204 | 
205 | ```csharp
206 | using Splat.Builder;
207 | 
208 | var app = AppBuilder.CreateSplatBuilder().Build();
209 | app.CreateFusilladeNetCache();
210 | ```
211 | 
212 | You can also register a platform-specific HttpMessageHandler (e.g., NSUrlSessionHandler on iOS, AndroidMessageHandler on Android) in your container beforehand; NetCache will pick it up as the inner HTTP handler.
213 | 
214 | 
215 | ## Advanced configuration
216 | 
217 | - Custom OperationQueue: override NetCache.OperationQueue with your own queue to control concurrency for the entire app.
218 | 
219 | ```csharp
220 | using Punchclock;
221 | NetCache.OperationQueue = new OperationQueue(maxConcurrency: 6);
222 | ```
223 | 
224 | - Custom priorities: compose RateLimitedHttpMessageHandler with Priority.Explicit and an offset to place certain pipelines ahead or behind the defaults.
225 | 
226 | ```csharp
227 | var urgent = new RateLimitedHttpMessageHandler(new HttpClientHandler(), Priority.Explicit, priority: 1_000);
228 | var slow   = new RateLimitedHttpMessageHandler(new HttpClientHandler(), Priority.Explicit, priority: -50);
229 | ```
230 | 
231 | - Deduplication scope: deduplication is per-HttpMessageHandler instance via an in-memory in-flight map. Multiple handlers mean multiple scopes.
232 | 
233 | 
234 | ## Usage recipes
235 | 
236 | - Image gallery / avatars
237 |   - Use RateLimitedHttpMessageHandler for GETs
238 |   - De-dup prevents duplicate downloads for the same URL
239 |   - Use Background for preloading next images; switch to UserInitiated for visible images
240 | 
241 | - Boot-time warmup
242 |   - On app start/resume, set NetCache.Speculative.ResetLimit to a sensible budget
243 |   - Queue speculative GETs for likely-next screens to reduce perceived latency
244 | 
245 | - Offline-first data views
246 |   - Populate cache during online sessions using cacheResultFunc or IRequestCache
247 |   - When network is unavailable, point HttpClient to NetCache.Offline
248 | 
249 | 
250 | ## FAQ
251 | 
252 | - How many requests run at once?
253 |   - Default is 4 (OperationQueue with concurrency 4). Override via NetCache.OperationQueue or pass a custom queue to a handler.
254 | 
255 | - Which methods are de-duplicated?
256 |   - GET, HEAD, and OPTIONS.
257 | 
258 | - How are cache keys generated?
259 |   - Via RateLimitedHttpMessageHandler.UniqueKeyForRequest(request). Treat this as an implementation detail; persist and reuse as given.
260 | 
261 | - Can I cancel a request?
262 |   - Use CancellationToken in HttpClient APIs; dedup ensures the underlying request cancels only when all dependents cancel.
263 | 
264 | 
265 | ## Contribute
266 | 
267 | Fusillade is developed under an OSI-approved open source license, making it freely usable and distributable, even for commercial use. We ❤ our contributors and welcome new contributors of all experience levels.
268 | 
269 | - Answer questions on StackOverflow: https://stackoverflow.com/questions/tagged/fusillade
270 | - Share knowledge and mentor the next generation of developers
271 | - Donations: https://reactiveui.net/donate and Corporate Sponsorships: https://reactiveui.net/sponsorship
272 | - Ask your employer to support open-source: https://github.com/github/balanced-employee-ip-agreement
273 | - Improve documentation and examples
274 | - Contribute features and bugfixes via PRs
275 | 
276 | 
277 | ## What’s with the name?
278 | 
279 | “Fusillade” is a synonym for Volley 🙂
280 | 


--------------------------------------------------------------------------------
/src/Fusillade.Tests/Http/HttpSchedulerSharedTests.cs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
  2 | // Licensed to the .NET Foundation under one or more agreements.
  3 | // The .NET Foundation licenses this file to you under the MIT license.
  4 | // See the LICENSE file in the project root for full license information.
  5 | 
  6 | using System;
  7 | using System.Collections.Concurrent;
  8 | using System.Linq;
  9 | using System.Net;
 10 | using System.Net.Http;
 11 | using System.Net.Http.Headers;
 12 | using System.Reactive;
 13 | using System.Reactive.Linq;
 14 | using System.Reactive.Subjects;
 15 | using System.Reactive.Threading.Tasks;
 16 | using System.Text;
 17 | using System.Threading;
 18 | using System.Threading.Tasks;
 19 | using Microsoft.Reactive.Testing;
 20 | using NUnit.Framework; // switched from xUnit
 21 | using ReactiveUI;
 22 | using ReactiveUI.Testing;
 23 | 
 24 | namespace Fusillade.Tests
 25 | {
 26 |     /// <summary>
 27 |     /// Base class full of common requests.
 28 |     /// </summary>
 29 |     public abstract class HttpSchedulerSharedTests
 30 |     {
 31 |         /// <summary>
 32 |         /// Checks to make sure a dummy request is completed.
 33 |         /// </summary>
 34 |         /// <returns>A task to monitor the progress.</returns>
 35 |         [Test]
 36 |         public async Task HttpSchedulerShouldCompleteADummyRequest()
 37 |         {
 38 |             var fixture = CreateFixture(new TestHttpMessageHandler(_ =>
 39 |             {
 40 |                 var ret = new HttpResponseMessage()
 41 |                 {
 42 |                     Content = new StringContent("foo", Encoding.UTF8),
 43 |                     StatusCode = HttpStatusCode.OK,
 44 |                 };
 45 | 
 46 |                 ret.Headers.ETag = new EntityTagHeaderValue("\"worifjw\"");
 47 |                 return Observable.Return(ret);
 48 |             }));
 49 | 
 50 |             var client = new HttpClient(fixture)
 51 |             {
 52 |                 BaseAddress = new Uri("http://example"),
 53 |             };
 54 | 
 55 |             var rq = new HttpRequestMessage(HttpMethod.Get, "/");
 56 | 
 57 |             var result = await client.SendAsync(rq).ToObservable()
 58 |                 .Timeout(TimeSpan.FromSeconds(2.0), RxApp.TaskpoolScheduler);
 59 | 
 60 |             var bytes = await result.Content.ReadAsByteArrayAsync();
 61 | 
 62 |             using (Assert.EnterMultipleScope())
 63 |             {
 64 |                 Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
 65 |                 Assert.That(bytes, Has.Length.EqualTo(3));
 66 |             }
 67 |         }
 68 | 
 69 |         /// <summary>
 70 |         /// Checks to make sure that the http scheduler doesn't do too much scheduling all at once.
 71 |         /// </summary>
 72 |         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
 73 |         [Test]
 74 |         public async Task HttpSchedulerShouldntScheduleLotsOfStuffAtOnce()
 75 |         {
 76 |             var blockedRqs = new ConcurrentDictionary<HttpRequestMessage, Subject<Unit>>();
 77 |             var scheduledCount = 0;
 78 |             var completedCount = 0;
 79 | 
 80 |             var scheduled5Tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
 81 |             var completed5Tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
 82 | 
 83 |             await new TestScheduler().WithAsync(async _ =>
 84 |             {
 85 |                 var fixture = CreateFixture(new TestHttpMessageHandler(rq =>
 86 |                 {
 87 |                     var current = Interlocked.Increment(ref scheduledCount);
 88 |                     if (current == 5)
 89 |                     {
 90 |                         scheduled5Tcs.TrySetResult();
 91 |                     }
 92 | 
 93 |                     var ret = new HttpResponseMessage()
 94 |                     {
 95 |                         Content = new StringContent("foo", Encoding.UTF8),
 96 |                         StatusCode = HttpStatusCode.OK,
 97 |                     };
 98 | 
 99 |                     ret.Headers.ETag = new EntityTagHeaderValue("\"worifjw\"");
100 | 
101 |                     var subj = new Subject<Unit>();
102 |                     blockedRqs[rq] = subj;
103 | 
104 |                     return subj
105 |                         .Select(_ => ret)
106 |                         .Finally(() =>
107 |                         {
108 |                             var c = Interlocked.Increment(ref completedCount);
109 |                             if (c == 5)
110 |                             {
111 |                                 completed5Tcs.TrySetResult();
112 |                             }
113 |                         });
114 |                 }));
115 | 
116 |                 var client = new HttpClient(fixture)
117 |                 {
118 |                     BaseAddress = new Uri("http://example")
119 |                 };
120 | 
121 |                 var rqs =
122 |                     Enumerable
123 |                         .Range(0, 5)
124 |                         .Select(x => new HttpRequestMessage(HttpMethod.Get, "/" + x))
125 |                         .ToArray();
126 | 
127 |                 using var subscription =
128 |                     rqs.ToObservable()
129 |                        .Select(rq => client.SendAsync(rq))
130 |                        .Merge()
131 |                        .Subscribe();
132 | 
133 |                 using (Assert.EnterMultipleScope())
134 |                 {
135 |                     Assert.That(SpinWait.SpinUntil(() => Volatile.Read(ref scheduledCount) == 4 && blockedRqs.Count == 4, TimeSpan.FromSeconds(2)), Is.True);
136 |                     Assert.That(scheduledCount, Is.EqualTo(4));
137 |                     Assert.That(completedCount, Is.Zero);
138 |                 }
139 | 
140 |                 // Complete one request to free a slot and allow the 5th to be scheduled.
141 |                 var firstSubj = blockedRqs.First().Value;
142 |                 firstSubj.OnNext(Unit.Default);
143 |                 firstSubj.OnCompleted();
144 | 
145 |                 // Wait for the 5th to be scheduled deterministically.
146 |                 await scheduled5Tcs.Task.WaitAsync(TimeSpan.FromSeconds(2));
147 | 
148 |                 using (Assert.EnterMultipleScope())
149 |                 {
150 |                     // Ensure the completedCount advanced for the one we just finished.
151 |                     Assert.That(SpinWait.SpinUntil(() => Volatile.Read(ref completedCount) >= 1, TimeSpan.FromSeconds(2)), Is.True);
152 |                     Assert.That(scheduledCount, Is.EqualTo(5));
153 |                     Assert.That(completedCount, Is.EqualTo(1));
154 |                 }
155 | 
156 |                 // Complete all remaining requests (snapshot to avoid concurrent mutation during enumeration).
157 |                 var subjects = blockedRqs.Values.ToArray();
158 |                 foreach (var v in subjects)
159 |                 {
160 |                     v.OnNext(Unit.Default);
161 |                     v.OnCompleted();
162 |                 }
163 | 
164 |                 // Wait until all completed.
165 |                 await completed5Tcs.Task.WaitAsync(TimeSpan.FromSeconds(2));
166 | 
167 |                 using (Assert.EnterMultipleScope())
168 |                 {
169 |                     Assert.That(scheduledCount, Is.EqualTo(5));
170 |                     Assert.That(completedCount, Is.EqualTo(5));
171 |                 }
172 | 
173 |                 return Task.CompletedTask;
174 |             });
175 |         }
176 | 
177 |         /// <summary>
178 |         /// Checks to make sure that the rate limited scheduler stops after content limit has been reached.
179 |         /// </summary>
180 |         /// <returns>A task to monitor the progress.</returns>
181 |         [Test]
182 |         public async Task RateLimitedSchedulerShouldStopAfterContentLimitReached()
183 |         {
184 |             var fixture = CreateFixture(new TestHttpMessageHandler(_ =>
185 |             {
186 |                 var ret = new HttpResponseMessage()
187 |                 {
188 |                     Content = new StringContent("foo", Encoding.UTF8),
189 |                     StatusCode = HttpStatusCode.OK,
190 |                 };
191 | 
192 |                 ret.Headers.ETag = new EntityTagHeaderValue("\"worifjw\"");
193 |                 return Observable.Return(ret);
194 |             }));
195 | 
196 |             var client = new HttpClient(fixture)
197 |             {
198 |                 BaseAddress = new Uri("http://example"),
199 |             };
200 | 
201 |             fixture.ResetLimit(5);
202 | 
203 |             // Under the limit => succeed
204 |             var rq = new HttpRequestMessage(HttpMethod.Get, "/");
205 |             var resp = await client.SendAsync(rq);
206 |             Assert.That(resp.StatusCode, Is.EqualTo(HttpStatusCode.OK));
207 | 
208 |             // Crossing the limit => succeed
209 |             rq = new HttpRequestMessage(HttpMethod.Get, "/");
210 |             resp = await client.SendAsync(rq);
211 |             Assert.That(resp.StatusCode, Is.EqualTo(HttpStatusCode.OK));
212 | 
213 |             // Over the limit => cancelled
214 |             rq = new HttpRequestMessage(HttpMethod.Get, "/");
215 |             Assert.ThrowsAsync<TaskCanceledException>(async () => await client.SendAsync(rq));
216 |         }
217 | 
218 |         /// <summary>
219 |         /// Tests to make sure that concurrent requests aren't debounced.
220 |         /// </summary>
221 |         /// <returns>A task to monitor the progress.</returns>
222 |         [Test]
223 |         public async Task ConcurrentRequestsToTheSameResourceAreDebounced()
224 |         {
225 |             var messageCount = 0;
226 |             Subject<Unit> gate = new();
227 | 
228 |             var fixture = CreateFixture(new TestHttpMessageHandler(_ =>
229 |             {
230 |                 var ret = new HttpResponseMessage()
231 |                 {
232 |                     Content = new StringContent("foo", Encoding.UTF8),
233 |                     StatusCode = HttpStatusCode.OK,
234 |                 };
235 | 
236 |                 ret.Headers.ETag = new EntityTagHeaderValue("\"worifjw\"");
237 |                 messageCount++;
238 | 
239 |                 return gate.Take(1).Select(__ => ret);
240 |             }));
241 | 
242 |             var client = new HttpClient(fixture)
243 |             {
244 |                 BaseAddress = new Uri("http://example"),
245 |             };
246 | 
247 |             var rq1 = new HttpRequestMessage(HttpMethod.Get, "/");
248 |             var rq2 = new HttpRequestMessage(HttpMethod.Get, "/");
249 | 
250 |             Assert.That(messageCount, Is.Zero);
251 | 
252 |             var resp1Task = client.SendAsync(rq1);
253 |             var resp2Task = client.SendAsync(rq2);
254 |             Assert.That(messageCount, Is.EqualTo(1));
255 | 
256 |             gate.OnNext(Unit.Default);
257 |             gate.OnNext(Unit.Default);
258 | 
259 |             var resp1 = await resp1Task;
260 |             var resp2 = await resp2Task;
261 | 
262 |             using (Assert.EnterMultipleScope())
263 |             {
264 |                 Assert.That(resp1.StatusCode, Is.EqualTo(HttpStatusCode.OK));
265 |                 Assert.That(resp2.StatusCode, Is.EqualTo(HttpStatusCode.OK));
266 |                 Assert.That(messageCount, Is.EqualTo(1));
267 |             }
268 |         }
269 | 
270 |         /// <summary>
271 |         /// Checks to make sure that requests don't get unfairly cancelled.
272 |         /// </summary>
273 |         /// <returns>A task to monitor the progress.</returns>
274 |         [Test]
275 |         public async Task DebouncedRequestsDontGetUnfairlyCancelled()
276 |         {
277 |             var messageCount = 0;
278 |             Subject<Unit> gate = new();
279 | 
280 |             var fixture = CreateFixture(new TestHttpMessageHandler(_ =>
281 |             {
282 |                 var ret = new HttpResponseMessage()
283 |                 {
284 |                     Content = new StringContent("foo", Encoding.UTF8),
285 |                     StatusCode = HttpStatusCode.OK,
286 |                 };
287 | 
288 |                 ret.Headers.ETag = new EntityTagHeaderValue("\"worifjw\"");
289 |                 messageCount++;
290 | 
291 |                 return gate.Take(1).Select(__ => ret);
292 |             }));
293 | 
294 |             var client = new HttpClient(fixture)
295 |             {
296 |                 BaseAddress = new Uri("http://example"),
297 |             };
298 | 
299 |             var rq1 = new HttpRequestMessage(HttpMethod.Get, "/");
300 |             var rq2 = new HttpRequestMessage(HttpMethod.Get, "/");
301 | 
302 |             Assert.That(messageCount, Is.Zero);
303 | 
304 |             var cts = new CancellationTokenSource();
305 | 
306 |             var resp1Task = client.SendAsync(rq1, cts.Token);
307 |             var resp2Task = client.SendAsync(rq2);
308 |             Assert.That(messageCount, Is.EqualTo(1));
309 | 
310 |             cts.Cancel();
311 | 
312 |             gate.OnNext(Unit.Default);
313 |             gate.OnNext(Unit.Default);
314 | 
315 |             Assert.ThrowsAsync<TaskCanceledException>(async () => await resp1Task);
316 |             var resp2 = await resp2Task;
317 | 
318 |             using (Assert.EnterMultipleScope())
319 |             {
320 |                 Assert.That(resp2.StatusCode, Is.EqualTo(HttpStatusCode.OK));
321 |                 Assert.That(messageCount, Is.EqualTo(1));
322 |             }
323 |         }
324 | 
325 |         /// <summary>
326 |         /// Checks to make sure that different paths aren't debounced.
327 |         /// </summary>
328 |         /// <returns>A task to monitor the progress.</returns>
329 |         [Test]
330 |         public async Task RequestsToDifferentPathsArentDebounced()
331 |         {
332 |             var messageCount = 0;
333 |             Subject<Unit> gate = new();
334 | 
335 |             var fixture = CreateFixture(new TestHttpMessageHandler(_ =>
336 |             {
337 |                 var ret = new HttpResponseMessage()
338 |                 {
339 |                     Content = new StringContent("foo", Encoding.UTF8),
340 |                     StatusCode = HttpStatusCode.OK,
341 |                 };
342 | 
343 |                 ret.Headers.ETag = new EntityTagHeaderValue("\"worifjw\"");
344 |                 messageCount++;
345 | 
346 |                 return gate.Take(1).Select(__ => ret);
347 |             }));
348 | 
349 |             var client = new HttpClient(fixture)
350 |             {
351 |                 BaseAddress = new Uri("http://example"),
352 |             };
353 | 
354 |             var rq1 = new HttpRequestMessage(HttpMethod.Get, "/foo");
355 |             var rq2 = new HttpRequestMessage(HttpMethod.Get, "/bar");
356 | 
357 |             Assert.That(messageCount, Is.Zero);
358 | 
359 |             var resp1Task = client.SendAsync(rq1);
360 |             var resp2Task = client.SendAsync(rq2);
361 |             Assert.That(messageCount, Is.EqualTo(2));
362 | 
363 |             gate.OnNext(Unit.Default);
364 |             gate.OnNext(Unit.Default);
365 | 
366 |             var resp1 = await resp1Task;
367 |             var resp2 = await resp2Task;
368 | 
369 |             using (Assert.EnterMultipleScope())
370 |             {
371 |                 Assert.That(resp1.StatusCode, Is.EqualTo(HttpStatusCode.OK));
372 |                 Assert.That(resp2.StatusCode, Is.EqualTo(HttpStatusCode.OK));
373 |                 Assert.That(messageCount, Is.EqualTo(2));
374 |             }
375 |         }
376 | 
377 |         /// <summary>
378 |         /// Tests if a debounce is fully cancelling requests.
379 |         /// </summary>
380 |         /// <returns>A task to monitor the progress.</returns>
381 |         [Test]
382 |         public async Task FullyCancelledDebouncedRequestsGetForRealCancelled()
383 |         {
384 |             var messageCount = 0;
385 |             var finalMessageCount = 0;
386 |             Subject<Unit> gate = new();
387 | 
388 |             var fixture = CreateFixture(new TestHttpMessageHandler(_ =>
389 |             {
390 |                 var ret = new HttpResponseMessage()
391 |                 {
392 |                     Content = new StringContent("foo", Encoding.UTF8),
393 |                     StatusCode = HttpStatusCode.OK,
394 |                 };
395 | 
396 |                 ret.Headers.ETag = new("\"worifjw\"");
397 |                 messageCount++;
398 | 
399 |                 return gate.Take(1)
400 |                     .Do(__ => finalMessageCount++)
401 |                     .Select(__ => ret);
402 |             }));
403 | 
404 |             var client = new HttpClient(fixture)
405 |             {
406 |                 BaseAddress = new Uri("http://example"),
407 |             };
408 | 
409 |             var rq1 = new HttpRequestMessage(HttpMethod.Get, "/");
410 |             var rq2 = new HttpRequestMessage(HttpMethod.Get, "/");
411 | 
412 |             Assert.That(messageCount, Is.Zero);
413 | 
414 |             var cts = new CancellationTokenSource();
415 | 
416 |             var resp1Task = client.SendAsync(rq1, cts.Token);
417 |             var resp2Task = client.SendAsync(rq2, cts.Token);
418 |             using (Assert.EnterMultipleScope())
419 |             {
420 |                 Assert.That(messageCount, Is.EqualTo(1));
421 |                 Assert.That(finalMessageCount, Is.Zero);
422 |             }
423 | 
424 |             cts.Cancel();
425 | 
426 |             gate.OnNext(Unit.Default);
427 |             gate.OnNext(Unit.Default);
428 | 
429 |             Assert.ThrowsAsync<TaskCanceledException>(async () => await resp1Task);
430 |             Assert.ThrowsAsync<TaskCanceledException>(async () => await resp2Task);
431 | 
432 |             using (Assert.EnterMultipleScope())
433 |             {
434 |                 Assert.That(messageCount, Is.EqualTo(1));
435 |                 Assert.That(finalMessageCount, Is.Zero);
436 |             }
437 |         }
438 | 
439 |         /// <summary>
440 |         /// Attempts to download a release from github to test the filters.
441 |         /// </summary>
442 |         /// <returns>A task to monitor the progress.</returns>
443 |         [Test]
444 |         [Category("Slow")]
445 |         public async Task DownloadARelease()
446 |         {
447 |             const string input = "https://github.com/akavache/Akavache/releases/download/3.2.0/Akavache.3.2.0.zip";
448 |             var fixture = CreateFixture(new HttpClientHandler()
449 |             {
450 |                 AllowAutoRedirect = true,
451 |                 MaxRequestContentBufferSize = 1048576 * 64,
452 |             });
453 | 
454 |             var client = new HttpClient(fixture);
455 |             var result = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, new Uri(input)));
456 |             var bytes = await result.Content.ReadAsByteArrayAsync();
457 | 
458 |             using (Assert.EnterMultipleScope())
459 |             {
460 |                 Assert.That(result.IsSuccessStatusCode, Is.True);
461 |                 Assert.That(bytes, Has.Length.EqualTo(8089690));
462 |             }
463 |         }
464 | 
465 |         /// <summary>
466 |         /// Creates the test fixtures.
467 |         /// </summary>
468 |         /// <param name="innerHandler">The inner handler.</param>
469 |         /// <returns>The limiting handler.</returns>
470 |         protected abstract LimitingHttpMessageHandler CreateFixture(HttpMessageHandler? innerHandler = null);
471 |     }
472 | }
473 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
  1 | # editorconfig.org
  2 | 
  3 | # top-most EditorConfig file
  4 | root = true
  5 | 
  6 | # Default settings:
  7 | # A newline ending every file
  8 | # Use 4 spaces as indentation
  9 | [*]
 10 | insert_final_newline = true
 11 | indent_style = space
 12 | indent_size = 4
 13 | dotnet_diagnostic.CA1027.severity=error
 14 | dotnet_diagnostic.CA1062.severity=error
 15 | dotnet_diagnostic.CA1064.severity=error
 16 | dotnet_diagnostic.CA1066.severity=error
 17 | dotnet_diagnostic.CA1067.severity=error
 18 | dotnet_diagnostic.CA1068.severity=error
 19 | dotnet_diagnostic.CA1069.severity=warning
 20 | dotnet_diagnostic.CA2013.severity=error
 21 | dotnet_diagnostic.CA1802.severity=error
 22 | dotnet_diagnostic.CA1813.severity=error
 23 | dotnet_diagnostic.CA1814.severity=error
 24 | dotnet_diagnostic.CA1815.severity=error
 25 | dotnet_diagnostic.CA1822.severity=error
 26 | dotnet_diagnostic.CA1827.severity=error
 27 | dotnet_diagnostic.CA1828.severity=error
 28 | dotnet_diagnostic.CA1826.severity=error
 29 | dotnet_diagnostic.CA1829.severity=error
 30 | dotnet_diagnostic.CA1830.severity=error
 31 | dotnet_diagnostic.CA1831.severity=error
 32 | dotnet_diagnostic.CA1832.severity=error
 33 | dotnet_diagnostic.CA1833.severity=error
 34 | dotnet_diagnostic.CA1834.severity=error
 35 | dotnet_diagnostic.CA1835.severity=error
 36 | dotnet_diagnostic.CA1836.severity=error
 37 | dotnet_diagnostic.CA1837.severity=error
 38 | dotnet_diagnostic.CA1838.severity=error
 39 | dotnet_diagnostic.CA2015.severity=error
 40 | dotnet_diagnostic.CA2012.severity=error
 41 | dotnet_diagnostic.CA2011.severity=error
 42 | dotnet_diagnostic.CA2009.severity=error
 43 | dotnet_diagnostic.CA2008.severity=error
 44 | dotnet_diagnostic.CA2007.severity=warning
 45 | dotnet_diagnostic.CA2000.severity=suggestion
 46 | 
 47 | [project.json]
 48 | indent_size = 2
 49 | 
 50 | # C# files
 51 | [*.cs]
 52 | # New line preferences
 53 | csharp_new_line_before_open_brace = all
 54 | csharp_new_line_before_else = true
 55 | csharp_new_line_before_catch = true
 56 | csharp_new_line_before_finally = true
 57 | csharp_new_line_before_members_in_object_initializers = true
 58 | csharp_new_line_before_members_in_anonymous_types = true
 59 | csharp_new_line_between_query_expression_clauses = true
 60 | 
 61 | # Indentation preferences
 62 | csharp_indent_block_contents = true
 63 | csharp_indent_braces = false
 64 | csharp_indent_case_contents = true
 65 | csharp_indent_case_contents_when_block = true
 66 | csharp_indent_switch_labels = true
 67 | csharp_indent_labels = one_less_than_current
 68 | 
 69 | # Modifier preferences
 70 | csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:suggestion
 71 | 
 72 | # avoid this. unless absolutely necessary
 73 | dotnet_style_qualification_for_field = false:suggestion
 74 | dotnet_style_qualification_for_property = false:suggestion
 75 | dotnet_style_qualification_for_method = false:suggestion
 76 | dotnet_style_qualification_for_event = false:suggestion
 77 | 
 78 | # only use var when it's obvious what the variable type is
 79 | csharp_style_var_for_built_in_types = true:suggestion
 80 | csharp_style_var_when_type_is_apparent = true:suggestion
 81 | csharp_style_var_elsewhere = true:suggestion
 82 | 
 83 | # prefer C# premade types.
 84 | dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
 85 | dotnet_style_predefined_type_for_member_access = true:suggestion
 86 | 
 87 | # name all constant fields using PascalCase
 88 | dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion
 89 | dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols  = constant_fields
 90 | dotnet_naming_rule.constant_fields_should_be_pascal_case.style    = pascal_case_style
 91 | dotnet_naming_symbols.constant_fields.applicable_kinds   = field
 92 | dotnet_naming_symbols.constant_fields.required_modifiers = const
 93 | dotnet_naming_style.pascal_case_style.capitalization = pascal_case
 94 | 
 95 | # static fields should have s_ prefix
 96 | dotnet_naming_rule.static_fields_should_have_prefix.severity = suggestion
 97 | dotnet_naming_rule.static_fields_should_have_prefix.symbols  = static_fields
 98 | dotnet_naming_rule.static_fields_should_have_prefix.style    = static_prefix_style
 99 | dotnet_naming_symbols.static_fields.applicable_kinds   = field
100 | dotnet_naming_symbols.static_fields.required_modifiers = static
101 | dotnet_naming_symbols.static_fields.applicable_accessibilities = private, internal, private_protected
102 | dotnet_naming_style.static_prefix_style.required_prefix = s_
103 | dotnet_naming_style.static_prefix_style.capitalization = camel_case
104 | 
105 | # internal and private fields should be _camelCase
106 | dotnet_naming_rule.camel_case_for_private_internal_fields.severity = suggestion
107 | dotnet_naming_rule.camel_case_for_private_internal_fields.symbols  = private_internal_fields
108 | dotnet_naming_rule.camel_case_for_private_internal_fields.style    = camel_case_underscore_style
109 | dotnet_naming_symbols.private_internal_fields.applicable_kinds = field
110 | dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal
111 | dotnet_naming_style.camel_case_underscore_style.required_prefix = _
112 | dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case
113 | 
114 | # Code style defaults
115 | csharp_using_directive_placement = outside_namespace:suggestion
116 | dotnet_sort_system_directives_first = true
117 | csharp_prefer_braces = true:silent
118 | csharp_preserve_single_line_blocks = true:none
119 | csharp_preserve_single_line_statements = false:none
120 | csharp_prefer_static_local_function = true:suggestion
121 | csharp_prefer_simple_using_statement = false:none
122 | csharp_style_prefer_switch_expression = true:suggestion
123 | 
124 | # Code quality
125 | dotnet_style_readonly_field = true:suggestion
126 | dotnet_code_quality_unused_parameters = non_public:suggestion
127 | 
128 | # Expression-level preferences
129 | dotnet_style_object_initializer = true:suggestion
130 | dotnet_style_collection_initializer = true:suggestion
131 | dotnet_style_explicit_tuple_names = true:suggestion
132 | dotnet_style_coalesce_expression = true:suggestion
133 | dotnet_style_null_propagation = true:suggestion
134 | dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
135 | dotnet_style_prefer_inferred_tuple_names = true:suggestion
136 | dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
137 | dotnet_style_prefer_auto_properties = true:suggestion
138 | dotnet_style_prefer_conditional_expression_over_assignment = true:silent
139 | dotnet_style_prefer_conditional_expression_over_return = true:silent
140 | csharp_prefer_simple_default_expression = true:suggestion
141 | 
142 | # Expression-bodied members
143 | csharp_style_expression_bodied_methods = true:suggestion
144 | csharp_style_expression_bodied_constructors = true:suggestion
145 | csharp_style_expression_bodied_operators = true:suggestion
146 | csharp_style_expression_bodied_properties = true:suggestion
147 | csharp_style_expression_bodied_indexers = true:suggestion
148 | csharp_style_expression_bodied_accessors = true:suggestion
149 | csharp_style_expression_bodied_lambdas = true:suggestion
150 | csharp_style_expression_bodied_local_functions = true:suggestion
151 | 
152 | # Pattern matching
153 | csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
154 | csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
155 | csharp_style_inlined_variable_declaration = true:suggestion
156 | 
157 | # Null checking preferences
158 | csharp_style_throw_expression = true:suggestion
159 | csharp_style_conditional_delegate_call = true:suggestion
160 | 
161 | # Other features
162 | csharp_style_prefer_index_operator = false:none
163 | csharp_style_prefer_range_operator = false:none
164 | csharp_style_pattern_local_over_anonymous_function = false:none
165 | 
166 | # Space preferences
167 | csharp_space_after_cast = false
168 | csharp_space_after_colon_in_inheritance_clause = true
169 | csharp_space_after_comma = true
170 | csharp_space_after_dot = false
171 | csharp_space_after_keywords_in_control_flow_statements = true
172 | csharp_space_after_semicolon_in_for_statement = true
173 | csharp_space_around_binary_operators = before_and_after
174 | csharp_space_around_declaration_statements = do_not_ignore
175 | csharp_space_before_colon_in_inheritance_clause = true
176 | csharp_space_before_comma = false
177 | csharp_space_before_dot = false
178 | csharp_space_before_open_square_brackets = false
179 | csharp_space_before_semicolon_in_for_statement = false
180 | csharp_space_between_empty_square_brackets = false
181 | csharp_space_between_method_call_empty_parameter_list_parentheses = false
182 | csharp_space_between_method_call_name_and_opening_parenthesis = false
183 | csharp_space_between_method_call_parameter_list_parentheses = false
184 | csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
185 | csharp_space_between_method_declaration_name_and_open_parenthesis = false
186 | csharp_space_between_method_declaration_parameter_list_parentheses = false
187 | csharp_space_between_parentheses = false
188 | csharp_space_between_square_brackets = false
189 | 
190 | # analyzers
191 | dotnet_diagnostic.AvoidAsyncVoid.severity = suggestion
192 | 
193 | dotnet_diagnostic.CA1000.severity = none
194 | dotnet_diagnostic.CA1001.severity = error
195 | dotnet_diagnostic.CA1009.severity = error
196 | dotnet_diagnostic.CA1016.severity = error
197 | dotnet_diagnostic.CA1030.severity = none
198 | dotnet_diagnostic.CA1031.severity = none
199 | dotnet_diagnostic.CA1033.severity = none
200 | dotnet_diagnostic.CA1036.severity = none
201 | dotnet_diagnostic.CA1049.severity = error
202 | dotnet_diagnostic.CA1056.severity = suggestion
203 | dotnet_diagnostic.CA1060.severity = error
204 | dotnet_diagnostic.CA1061.severity = error
205 | dotnet_diagnostic.CA1063.severity = error
206 | dotnet_diagnostic.CA1065.severity = error
207 | dotnet_diagnostic.CA1301.severity = error
208 | dotnet_diagnostic.CA1303.severity = none
209 | dotnet_diagnostic.CA1308.severity = none
210 | dotnet_diagnostic.CA1400.severity = error
211 | dotnet_diagnostic.CA1401.severity = error
212 | dotnet_diagnostic.CA1403.severity = error
213 | dotnet_diagnostic.CA1404.severity = error
214 | dotnet_diagnostic.CA1405.severity = error
215 | dotnet_diagnostic.CA1410.severity = error
216 | dotnet_diagnostic.CA1415.severity = error
217 | dotnet_diagnostic.CA1507.severity = error
218 | dotnet_diagnostic.CA1710.severity = suggestion
219 | dotnet_diagnostic.CA1724.severity = none
220 | dotnet_diagnostic.CA1810.severity = none
221 | dotnet_diagnostic.CA1821.severity = error
222 | dotnet_diagnostic.CA1900.severity = error
223 | dotnet_diagnostic.CA1901.severity = error
224 | dotnet_diagnostic.CA2000.severity = none
225 | dotnet_diagnostic.CA2002.severity = error
226 | dotnet_diagnostic.CA2007.severity = none
227 | dotnet_diagnostic.CA2100.severity = error
228 | dotnet_diagnostic.CA2101.severity = error
229 | dotnet_diagnostic.CA2108.severity = error
230 | dotnet_diagnostic.CA2111.severity = error
231 | dotnet_diagnostic.CA2112.severity = error
232 | dotnet_diagnostic.CA2114.severity = error
233 | dotnet_diagnostic.CA2116.severity = error
234 | dotnet_diagnostic.CA2117.severity = error
235 | dotnet_diagnostic.CA2122.severity = error
236 | dotnet_diagnostic.CA2123.severity = error
237 | dotnet_diagnostic.CA2124.severity = error
238 | dotnet_diagnostic.CA2126.severity = error
239 | dotnet_diagnostic.CA2131.severity = error
240 | dotnet_diagnostic.CA2132.severity = error
241 | dotnet_diagnostic.CA2133.severity = error
242 | dotnet_diagnostic.CA2134.severity = error
243 | dotnet_diagnostic.CA2137.severity = error
244 | dotnet_diagnostic.CA2138.severity = error
245 | dotnet_diagnostic.CA2140.severity = error
246 | dotnet_diagnostic.CA2141.severity = error
247 | dotnet_diagnostic.CA2146.severity = error
248 | dotnet_diagnostic.CA2147.severity = error
249 | dotnet_diagnostic.CA2149.severity = error
250 | dotnet_diagnostic.CA2200.severity = error
251 | dotnet_diagnostic.CA2202.severity = error
252 | dotnet_diagnostic.CA2207.severity = error
253 | dotnet_diagnostic.CA2212.severity = error
254 | dotnet_diagnostic.CA2213.severity = error
255 | dotnet_diagnostic.CA2214.severity = error
256 | dotnet_diagnostic.CA2216.severity = error
257 | dotnet_diagnostic.CA2220.severity = error
258 | dotnet_diagnostic.CA2229.severity = error
259 | dotnet_diagnostic.CA2231.severity = error
260 | dotnet_diagnostic.CA2232.severity = error
261 | dotnet_diagnostic.CA2235.severity = error
262 | dotnet_diagnostic.CA2236.severity = error
263 | dotnet_diagnostic.CA2237.severity = error
264 | dotnet_diagnostic.CA2238.severity = error
265 | dotnet_diagnostic.CA2240.severity = error
266 | dotnet_diagnostic.CA2241.severity = error
267 | dotnet_diagnostic.CA2242.severity = error
268 | 
269 | dotnet_diagnostic.RCS1001.severity = error
270 | dotnet_diagnostic.RCS1018.severity = error
271 | dotnet_diagnostic.RCS1037.severity = error
272 | dotnet_diagnostic.RCS1055.severity = error
273 | dotnet_diagnostic.RCS1062.severity = error
274 | dotnet_diagnostic.RCS1066.severity = error
275 | dotnet_diagnostic.RCS1069.severity = error
276 | dotnet_diagnostic.RCS1071.severity = error
277 | dotnet_diagnostic.RCS1074.severity = error
278 | dotnet_diagnostic.RCS1090.severity = error
279 | dotnet_diagnostic.RCS1138.severity = error
280 | dotnet_diagnostic.RCS1139.severity = error
281 | dotnet_diagnostic.RCS1163.severity = suggestion
282 | dotnet_diagnostic.RCS1168.severity = suggestion
283 | dotnet_diagnostic.RCS1188.severity = error
284 | dotnet_diagnostic.RCS1201.severity = error
285 | dotnet_diagnostic.RCS1207.severity = error
286 | dotnet_diagnostic.RCS1211.severity = error
287 | dotnet_diagnostic.RCS1507.severity = error
288 | 
289 | dotnet_diagnostic.SA1000.severity = error
290 | dotnet_diagnostic.SA1001.severity = error
291 | dotnet_diagnostic.SA1002.severity = error
292 | dotnet_diagnostic.SA1003.severity = error
293 | dotnet_diagnostic.SA1004.severity = error
294 | dotnet_diagnostic.SA1005.severity = error
295 | dotnet_diagnostic.SA1006.severity = error
296 | dotnet_diagnostic.SA1007.severity = error
297 | dotnet_diagnostic.SA1008.severity = error
298 | dotnet_diagnostic.SA1009.severity = error
299 | dotnet_diagnostic.SA1010.severity = none
300 | dotnet_diagnostic.SA1011.severity = error
301 | dotnet_diagnostic.SA1012.severity = error
302 | dotnet_diagnostic.SA1013.severity = error
303 | dotnet_diagnostic.SA1014.severity = error
304 | dotnet_diagnostic.SA1015.severity = error
305 | dotnet_diagnostic.SA1016.severity = error
306 | dotnet_diagnostic.SA1017.severity = error
307 | dotnet_diagnostic.SA1018.severity = error
308 | dotnet_diagnostic.SA1019.severity = error
309 | dotnet_diagnostic.SA1020.severity = error
310 | dotnet_diagnostic.SA1021.severity = error
311 | dotnet_diagnostic.SA1022.severity = error
312 | dotnet_diagnostic.SA1023.severity = error
313 | dotnet_diagnostic.SA1024.severity = error
314 | dotnet_diagnostic.SA1025.severity = error
315 | dotnet_diagnostic.SA1026.severity = error
316 | dotnet_diagnostic.SA1027.severity = error
317 | dotnet_diagnostic.SA1028.severity = error
318 | dotnet_diagnostic.SA1100.severity = error
319 | dotnet_diagnostic.SA1101.severity = none
320 | dotnet_diagnostic.SA1102.severity = error
321 | dotnet_diagnostic.SA1103.severity = error
322 | dotnet_diagnostic.SA1104.severity = error
323 | dotnet_diagnostic.SA1105.severity = error
324 | dotnet_diagnostic.SA1106.severity = error
325 | dotnet_diagnostic.SA1107.severity = error
326 | dotnet_diagnostic.SA1108.severity = error
327 | dotnet_diagnostic.SA1110.severity = error
328 | dotnet_diagnostic.SA1111.severity = error
329 | dotnet_diagnostic.SA1112.severity = error
330 | dotnet_diagnostic.SA1113.severity = error
331 | dotnet_diagnostic.SA1114.severity = error
332 | dotnet_diagnostic.SA1115.severity = error
333 | dotnet_diagnostic.SA1116.severity = error
334 | dotnet_diagnostic.SA1117.severity = error
335 | dotnet_diagnostic.SA1118.severity = error
336 | dotnet_diagnostic.SA1119.severity = error
337 | dotnet_diagnostic.SA1120.severity = error
338 | dotnet_diagnostic.SA1121.severity = error
339 | dotnet_diagnostic.SA1122.severity = error
340 | dotnet_diagnostic.SA1123.severity = error
341 | dotnet_diagnostic.SA1124.severity = error
342 | dotnet_diagnostic.SA1125.severity = error
343 | dotnet_diagnostic.SA1127.severity = error
344 | dotnet_diagnostic.SA1128.severity = error
345 | dotnet_diagnostic.SA1129.severity = error
346 | dotnet_diagnostic.SA1130.severity = error
347 | dotnet_diagnostic.SA1131.severity = error
348 | dotnet_diagnostic.SA1132.severity = error
349 | dotnet_diagnostic.SA1133.severity = error
350 | dotnet_diagnostic.SA1134.severity = error
351 | dotnet_diagnostic.SA1135.severity = error
352 | dotnet_diagnostic.SA1136.severity = error
353 | dotnet_diagnostic.SA1137.severity = error
354 | dotnet_diagnostic.SA1139.severity = error
355 | dotnet_diagnostic.SA1200.severity = none
356 | dotnet_diagnostic.SA1201.severity = error
357 | dotnet_diagnostic.SA1202.severity = error
358 | dotnet_diagnostic.SA1203.severity = error
359 | dotnet_diagnostic.SA1204.severity = error
360 | dotnet_diagnostic.SA1205.severity = error
361 | dotnet_diagnostic.SA1206.severity = error
362 | dotnet_diagnostic.SA1207.severity = error
363 | dotnet_diagnostic.SA1208.severity = error
364 | dotnet_diagnostic.SA1209.severity = error
365 | dotnet_diagnostic.SA1210.severity = error
366 | dotnet_diagnostic.SA1211.severity = error
367 | dotnet_diagnostic.SA1212.severity = error
368 | dotnet_diagnostic.SA1213.severity = error
369 | dotnet_diagnostic.SA1214.severity = error
370 | dotnet_diagnostic.SA1216.severity = error
371 | dotnet_diagnostic.SA1217.severity = error
372 | dotnet_diagnostic.SA1300.severity = error
373 | dotnet_diagnostic.SA1302.severity = error
374 | dotnet_diagnostic.SA1303.severity = error
375 | dotnet_diagnostic.SA1304.severity = error
376 | dotnet_diagnostic.SA1306.severity = none
377 | dotnet_diagnostic.SA1307.severity = error
378 | dotnet_diagnostic.SA1308.severity = error
379 | dotnet_diagnostic.SA1309.severity = none
380 | dotnet_diagnostic.SA1310.severity = error
381 | dotnet_diagnostic.SA1311.severity = none
382 | dotnet_diagnostic.SA1312.severity = error
383 | dotnet_diagnostic.SA1313.severity = error
384 | dotnet_diagnostic.SA1314.severity = error
385 | dotnet_diagnostic.SA1316.severity = none
386 | dotnet_diagnostic.SA1400.severity = error
387 | dotnet_diagnostic.SA1401.severity = error
388 | dotnet_diagnostic.SA1402.severity = error
389 | dotnet_diagnostic.SA1403.severity = error
390 | dotnet_diagnostic.SA1404.severity = error
391 | dotnet_diagnostic.SA1405.severity = error
392 | dotnet_diagnostic.SA1406.severity = error
393 | dotnet_diagnostic.SA1407.severity = error
394 | dotnet_diagnostic.SA1408.severity = error
395 | dotnet_diagnostic.SA1410.severity = error
396 | dotnet_diagnostic.SA1411.severity = error
397 | dotnet_diagnostic.SA1413.severity = none
398 | dotnet_diagnostic.SA1500.severity = error
399 | dotnet_diagnostic.SA1501.severity = error
400 | dotnet_diagnostic.SA1502.severity = error
401 | dotnet_diagnostic.SA1503.severity = error
402 | dotnet_diagnostic.SA1504.severity = error
403 | dotnet_diagnostic.SA1505.severity = none
404 | dotnet_diagnostic.SA1506.severity = error
405 | dotnet_diagnostic.SA1507.severity = error
406 | dotnet_diagnostic.SA1508.severity = error
407 | dotnet_diagnostic.SA1509.severity = error
408 | dotnet_diagnostic.SA1510.severity = error
409 | dotnet_diagnostic.SA1511.severity = error
410 | dotnet_diagnostic.SA1512.severity = error
411 | dotnet_diagnostic.SA1513.severity = error
412 | dotnet_diagnostic.SA1514.severity = none
413 | dotnet_diagnostic.SA1515.severity = error
414 | dotnet_diagnostic.SA1516.severity = error
415 | dotnet_diagnostic.SA1517.severity = error
416 | dotnet_diagnostic.SA1518.severity = error
417 | dotnet_diagnostic.SA1519.severity = error
418 | dotnet_diagnostic.SA1520.severity = error
419 | dotnet_diagnostic.SA1600.severity = error
420 | dotnet_diagnostic.SA1601.severity = error
421 | dotnet_diagnostic.SA1602.severity = error
422 | dotnet_diagnostic.SA1604.severity = error
423 | dotnet_diagnostic.SA1605.severity = error
424 | dotnet_diagnostic.SA1606.severity = error
425 | dotnet_diagnostic.SA1607.severity = error
426 | dotnet_diagnostic.SA1608.severity = error
427 | dotnet_diagnostic.SA1610.severity = error
428 | dotnet_diagnostic.SA1611.severity = error
429 | dotnet_diagnostic.SA1612.severity = error
430 | dotnet_diagnostic.SA1613.severity = error
431 | dotnet_diagnostic.SA1614.severity = error
432 | dotnet_diagnostic.SA1615.severity = error
433 | dotnet_diagnostic.SA1616.severity = error
434 | dotnet_diagnostic.SA1617.severity = error
435 | dotnet_diagnostic.SA1618.severity = error
436 | dotnet_diagnostic.SA1619.severity = error
437 | dotnet_diagnostic.SA1620.severity = error
438 | dotnet_diagnostic.SA1621.severity = error
439 | dotnet_diagnostic.SA1622.severity = error
440 | dotnet_diagnostic.SA1623.severity = error
441 | dotnet_diagnostic.SA1624.severity = error
442 | dotnet_diagnostic.SA1625.severity = error
443 | dotnet_diagnostic.SA1626.severity = error
444 | dotnet_diagnostic.SA1627.severity = error
445 | dotnet_diagnostic.SA1629.severity = error
446 | dotnet_diagnostic.SA1633.severity = error
447 | dotnet_diagnostic.SA1634.severity = error
448 | dotnet_diagnostic.SA1635.severity = error
449 | dotnet_diagnostic.SA1636.severity = error
450 | dotnet_diagnostic.SA1637.severity = none
451 | dotnet_diagnostic.SA1638.severity = none
452 | dotnet_diagnostic.SA1640.severity = error
453 | dotnet_diagnostic.SA1641.severity = error
454 | dotnet_diagnostic.SA1642.severity = error
455 | dotnet_diagnostic.SA1643.severity = error
456 | dotnet_diagnostic.SA1649.severity = error
457 | dotnet_diagnostic.SA1651.severity = error
458 | 
459 | dotnet_diagnostic.SX1101.severity = error
460 | dotnet_diagnostic.SX1309.severity = error
461 | dotnet_diagnostic.SX1623.severity = none
462 | dotnet_diagnostic.RCS1102.severity=error
463 | dotnet_diagnostic.RCS1166.severity=error
464 | dotnet_diagnostic.RCS1078i.severity=error
465 | dotnet_diagnostic.RCS1248.severity=error
466 | dotnet_diagnostic.RCS1080.severity=error
467 | dotnet_diagnostic.RCS1077.severity=error
468 | dotnet_diagnostic.CA1825.severity=error
469 | dotnet_diagnostic.CA1812.severity=error
470 | dotnet_diagnostic.CA1805.severity=error
471 | dotnet_diagnostic.RCS1197.severity=error
472 | dotnet_diagnostic.RCS1198.severity=none
473 | dotnet_diagnostic.RCS1231.severity=suggestion
474 | dotnet_diagnostic.RCS1235.severity=error
475 | dotnet_diagnostic.RCS1242.severity=error
476 | dotnet_diagnostic.RCS1256.severity=none
477 | dotnet_diagnostic.CA2016.severity=warning
478 | dotnet_diagnostic.CA2014.severity=error
479 | dotnet_diagnostic.RCS1010.severity=error
480 | dotnet_diagnostic.RCS1006.severity=error
481 | dotnet_diagnostic.RCS1005.severity=error
482 | dotnet_diagnostic.RCS1020.severity=error
483 | dotnet_diagnostic.RCS1049.severity=warning
484 | dotnet_diagnostic.RCS1058.severity=warning
485 | dotnet_diagnostic.RCS1068.severity=warning
486 | dotnet_diagnostic.RCS1073.severity=warning
487 | dotnet_diagnostic.RCS1084.severity=error
488 | dotnet_diagnostic.RCS1085.severity=error
489 | dotnet_diagnostic.RCS1105.severity=error
490 | dotnet_diagnostic.RCS1112.severity=error
491 | dotnet_diagnostic.RCS1128.severity=error
492 | dotnet_diagnostic.RCS1143.severity=error
493 | dotnet_diagnostic.RCS1158.severity=none
494 | dotnet_diagnostic.RCS1163.severity=none
495 | dotnet_diagnostic.RCS1171.severity=error
496 | dotnet_diagnostic.RCS1173.severity=error
497 | dotnet_diagnostic.RCS1176.severity=error
498 | dotnet_diagnostic.RCS1177.severity=error
499 | dotnet_diagnostic.RCS1179.severity=error
500 | dotnet_diagnostic.RCS1180.severity=warning
501 | dotnet_diagnostic.RCS1190.severity=error
502 | dotnet_diagnostic.RCS1195.severity=error
503 | dotnet_diagnostic.RCS1214.severity=error
504 | 
505 | [*.{cs,vb}]
506 | #############################################
507 | # NUnit Analyzers — enable all as errors
508 | #############################################
509 | 
510 | # Structure Rules (NUnit1001 - )
511 | dotnet_diagnostic.NUnit1001.severity = error # TestCase args must match parameter types
512 | dotnet_diagnostic.NUnit1002.severity = error # TestCaseSource should use nameof
513 | dotnet_diagnostic.NUnit1003.severity = error # TestCase provided too few arguments
514 | dotnet_diagnostic.NUnit1004.severity = error # TestCase provided too many arguments
515 | dotnet_diagnostic.NUnit1005.severity = error # ExpectedResult type must match return type
516 | dotnet_diagnostic.NUnit1006.severity = error # ExpectedResult must not be used on void methods
517 | dotnet_diagnostic.NUnit1007.severity = error # Non-void method but no ExpectedResult provided
518 | dotnet_diagnostic.NUnit1008.severity = error # ParallelScope.Self at assembly level has no effect
519 | dotnet_diagnostic.NUnit1009.severity = error # ParallelScope.Children on non-parameterized test
520 | dotnet_diagnostic.NUnit1010.severity = error # ParallelScope.Fixtures on a test method
521 | dotnet_diagnostic.NUnit1011.severity = error # TestCaseSource member does not exist
522 | dotnet_diagnostic.NUnit1012.severity = error # async test method must have non-void return type
523 | dotnet_diagnostic.NUnit1013.severity = error # async method must use non-generic Task when no result
524 | dotnet_diagnostic.NUnit1014.severity = error # async method must use Task<T> when result expected
525 | dotnet_diagnostic.NUnit1015.severity = error # Source type does not implement I(Async)Enumerable
526 | dotnet_diagnostic.NUnit1016.severity = error # Source type lacks default constructor
527 | dotnet_diagnostic.NUnit1017.severity = error # Specified source is not static
528 | dotnet_diagnostic.NUnit1018.severity = error # TestCaseSource param count mismatch (target method)
529 | dotnet_diagnostic.NUnit1019.severity = error # Source does not return I(Async)Enumerable
530 | dotnet_diagnostic.NUnit1020.severity = error # Parameters provided to field/property source
531 | dotnet_diagnostic.NUnit1021.severity = error # ValueSource should use nameof
532 | dotnet_diagnostic.NUnit1022.severity = error # Specified ValueSource is not static
533 | dotnet_diagnostic.NUnit1023.severity = error # ValueSource cannot supply required parameters
534 | dotnet_diagnostic.NUnit1024.severity = error # ValueSource does not return I(Async)Enumerable
535 | dotnet_diagnostic.NUnit1025.severity = error # ValueSource member does not exist
536 | dotnet_diagnostic.NUnit1026.severity = error # Test or setup/teardown method is not public
537 | dotnet_diagnostic.NUnit1027.severity = error # Test method has parameters but no arguments supplied
538 | dotnet_diagnostic.NUnit1028.severity = error # Non-test method is public
539 | dotnet_diagnostic.NUnit1029.severity = error # TestCaseSource param count mismatch (Test method)
540 | dotnet_diagnostic.NUnit1030.severity = error # TestCaseSource parameter type mismatch (Test method)
541 | dotnet_diagnostic.NUnit1031.severity = error # ValuesAttribute args must match parameter types
542 | dotnet_diagnostic.NUnit1032.severity = error # IDisposable field/property should be disposed in TearDown
543 | dotnet_diagnostic.NUnit1033.severity = error # TestContext.Write methods will be obsolete
544 | dotnet_diagnostic.NUnit1034.severity = error # Base TestFixtures should be abstract
545 | dotnet_diagnostic.NUnit1035.severity = error # Range 'step' parameter cannot be zero
546 | dotnet_diagnostic.NUnit1036.severity = error # Range: from < to when step is positive
547 | dotnet_diagnostic.NUnit1037.severity = error # Range: from > to when step is negative
548 | dotnet_diagnostic.NUnit1038.severity = error # Attribute values' types must match parameter type
549 | 
550 | # Assertion Rules (NUnit2001 - )
551 | dotnet_diagnostic.NUnit2001.severity = error # Prefer Assert.That(..., Is.False) over ClassicAssert.False
552 | dotnet_diagnostic.NUnit2002.severity = error # Prefer Assert.That(..., Is.False) over ClassicAssert.IsFalse
553 | dotnet_diagnostic.NUnit2003.severity = error # Prefer Assert.That(..., Is.True) over ClassicAssert.IsTrue
554 | dotnet_diagnostic.NUnit2004.severity = error # Prefer Assert.That(..., Is.True) over ClassicAssert.True
555 | dotnet_diagnostic.NUnit2005.severity = error # Prefer Is.EqualTo over AreEqual
556 | dotnet_diagnostic.NUnit2006.severity = error # Prefer Is.Not.EqualTo over AreNotEqual
557 | dotnet_diagnostic.NUnit2007.severity = error # Actual value should not be a constant
558 | dotnet_diagnostic.NUnit2008.severity = error # Incorrect IgnoreCase usage
559 | dotnet_diagnostic.NUnit2009.severity = error # Same value used for actual and expected
560 | dotnet_diagnostic.NUnit2010.severity = error # Use EqualConstraint for better messages
561 | dotnet_diagnostic.NUnit2011.severity = error # Use ContainsConstraint for better messages
562 | dotnet_diagnostic.NUnit2012.severity = error # Use StartsWithConstraint for better messages
563 | dotnet_diagnostic.NUnit2013.severity = error # Use EndsWithConstraint for better messages
564 | dotnet_diagnostic.NUnit2014.severity = error # Use SomeItemsConstraint for better messages
565 | dotnet_diagnostic.NUnit2015.severity = error # Prefer Is.SameAs over AreSame
566 | dotnet_diagnostic.NUnit2016.severity = error # Prefer Is.Null over ClassicAssert.Null
567 | dotnet_diagnostic.NUnit2017.severity = error # Prefer Is.Null over ClassicAssert.IsNull
568 | dotnet_diagnostic.NUnit2018.severity = error # Prefer Is.Not.Null over ClassicAssert.NotNull
569 | dotnet_diagnostic.NUnit2019.severity = error # Prefer Is.Not.Null over ClassicAssert.IsNotNull
570 | dotnet_diagnostic.NUnit2020.severity = error # Incompatible types for SameAs constraint
571 | dotnet_diagnostic.NUnit2021.severity = error # Incompatible types for EqualTo constraint
572 | dotnet_diagnostic.NUnit2022.severity = error # Missing property required for constraint
573 | dotnet_diagnostic.NUnit2023.severity = error # Invalid NullConstraint usage
574 | dotnet_diagnostic.NUnit2024.severity = error # Wrong actual type with String constraint
575 | dotnet_diagnostic.NUnit2025.severity = error # Wrong actual type with ContainsConstraint
576 | dotnet_diagnostic.NUnit2026.severity = error # Wrong actual type with SomeItems+EqualConstraint
577 | dotnet_diagnostic.NUnit2027.severity = error # Prefer Is.GreaterThan over ClassicAssert.Greater
578 | dotnet_diagnostic.NUnit2028.severity = error # Prefer Is.GreaterThanOrEqualTo over GreaterOrEqual
579 | dotnet_diagnostic.NUnit2029.severity = error # Prefer Is.LessThan over ClassicAssert.Less
580 | dotnet_diagnostic.NUnit2030.severity = error # Prefer Is.LessThanOrEqualTo over LessOrEqual
581 | dotnet_diagnostic.NUnit2031.severity = error # Prefer Is.Not.SameAs over AreNotSame
582 | dotnet_diagnostic.NUnit2032.severity = error # Prefer Is.Zero over ClassicAssert.Zero
583 | dotnet_diagnostic.NUnit2033.severity = error # Prefer Is.Not.Zero over ClassicAssert.NotZero
584 | dotnet_diagnostic.NUnit2034.severity = error # Prefer Is.NaN over ClassicAssert.IsNaN
585 | dotnet_diagnostic.NUnit2035.severity = error # Prefer Is.Empty over ClassicAssert.IsEmpty
586 | dotnet_diagnostic.NUnit2036.severity = error # Prefer Is.Not.Empty over ClassicAssert.IsNotEmpty
587 | dotnet_diagnostic.NUnit2037.severity = error # Prefer Does.Contain over ClassicAssert.Contains
588 | dotnet_diagnostic.NUnit2038.severity = error # Prefer Is.InstanceOf over ClassicAssert.IsInstanceOf
589 | dotnet_diagnostic.NUnit2039.severity = error # Prefer Is.Not.InstanceOf over ClassicAssert.IsNotInstanceOf
590 | dotnet_diagnostic.NUnit2040.severity = error # Non-reference types for SameAs constraint
591 | dotnet_diagnostic.NUnit2041.severity = error # Incompatible types for comparison constraint
592 | dotnet_diagnostic.NUnit2042.severity = error # Comparison constraint on object
593 | dotnet_diagnostic.NUnit2043.severity = error # Use ComparisonConstraint for better messages
594 | dotnet_diagnostic.NUnit2044.severity = error # Non-delegate actual parameter
595 | dotnet_diagnostic.NUnit2045.severity = error # Use Assert.EnterMultipleScope or Assert.Multiple
596 | dotnet_diagnostic.NUnit2046.severity = error # Use CollectionConstraint for better messages
597 | dotnet_diagnostic.NUnit2047.severity = error # Incompatible types for Within constraint
598 | dotnet_diagnostic.NUnit2048.severity = error # Prefer Assert.That over StringAssert
599 | dotnet_diagnostic.NUnit2049.severity = error # Prefer Assert.That over CollectionAssert
600 | dotnet_diagnostic.NUnit2050.severity = error # NUnit 4 no longer supports string.Format spec
601 | dotnet_diagnostic.NUnit2051.severity = error # Prefer Is.Positive over ClassicAssert.Positive
602 | dotnet_diagnostic.NUnit2052.severity = error # Prefer Is.Negative over ClassicAssert.Negative
603 | dotnet_diagnostic.NUnit2053.severity = error # Prefer Is.AssignableFrom over ClassicAssert.IsAssignableFrom
604 | dotnet_diagnostic.NUnit2054.severity = error # Prefer Is.Not.AssignableFrom over ClassicAssert.IsNotAssignableFrom
605 | dotnet_diagnostic.NUnit2055.severity = error # Prefer Is.InstanceOf<T> over 'is T' expression
606 | dotnet_diagnostic.NUnit2056.severity = error # Prefer Assert.EnterMultipleScope statement over Multiple
607 | 
608 | # Suppressor Rules (NUnit3001 - )
609 | dotnet_diagnostic.NUnit3001.severity = error # Expression checked in NotNull/IsNotNull/Assert.That
610 | dotnet_diagnostic.NUnit3002.severity = error # Field/Property initialized in SetUp/OneTimeSetUp
611 | dotnet_diagnostic.NUnit3003.severity = error # TestFixture instantiated via reflection
612 | dotnet_diagnostic.NUnit3004.severity = error # Field should be disposed in TearDown/OneTimeTearDown
613 | 
614 | # Style Rules (NUnit4001 - )
615 | dotnet_diagnostic.NUnit4001.severity = error # Simplify the Values attribute
616 | dotnet_diagnostic.NUnit4002.severity = error # Use Specific constraint
617 | 
618 | # C++ Files
619 | [*.{cpp,h,in}]
620 | curly_bracket_next_line = true
621 | indent_brace_style = Allman
622 | 
623 | # Xml project files
624 | [*.{csproj,vcxproj,vcxproj.filters,proj,nativeproj,locproj}]
625 | indent_size = 2
626 | 
627 | # Xml build files
628 | [*.builds]
629 | indent_size = 2
630 | 
631 | # Xml files
632 | [*.{xml,stylecop,resx,ruleset}]
633 | indent_size = 2
634 | 
635 | # Xml config files
636 | [*.{props,targets,config,nuspec}]
637 | indent_size = 2
638 | 
639 | # Shell scripts
640 | [*.sh]
641 | end_of_line = lf
642 | [*.{cmd, bat}]
643 | end_of_line = crlf
644 | 
645 | vsspell_dictionary_languages = en-US


--------------------------------------------------------------------------------