Order this in terms of likelihood

This disables most things so it's pretty easy to
use.

We can't rely on any given port being available. Try a few!

We add 1 extra block request (16kB) for every 10 kB/sec of
transfer rate from the remote peer. T...

The normal scenario is that no files are marked as 'do not download',
so optimise this method to...

If SetAll(true) is invoked and all bits are already set to true,
fast-path and do nothing. Simil...

These classes should not have been public

COR Policies added to HttpStream

param name for old parameter removed.

Slight progress. CORS policy declined message goes away. Just a lot of Net.Sockets Exceptions be...

Access-Control-Allow-Origin fixed the issue. Video is not yet playing as hoped. Will look more i...

the ServerUri points to another domain that should allow HttpListener to be CORS friendly with t...

If you create two DhtEngines then message ids should not be
shared. This wouldn't have been a pr...

The cache is on by default, so disable it here so the tests keep
excercising the correct code.

If the dht engine is stopped, clear out the send and
receive queues.

If the settings have chosen port 0, then the listener will
bind to an arbitrary available port. ...

This is integrated with ClientEngine.Start/Stop now

Use a random port... because we can!

Also make the status printing a little more concise.

I want it to be ambiguous. Sometimes i want to refer to a method
and i really don't care which o...

The rough edges should be resolved and the disk cache
should be safe to enable by default again....

The engine (currently) only needs two additional methods when streaming
files. Wrap these in ISt...

These are caches, not 'save' directories. The torrent itself
is saved somewhere, but metadata/fa...

Don't manually save/restore fast resume data or the
dht cache. This is handled implicitly by the...

If the DhtEngine is implicitly managed by the engine then
it will now also implicitly manage sav...

At least make it a directory called 'cache'. This
will make things a little better.

* [core] Add support for automatically saving/loading FastResume

The engine will now automati...

This phase is usually short lived too, so this is one
step closer to allowing 'streaming' for fi...

This might make it easier to debug performance

They're super useful in things like custom piece pickers,
or piece writers, as it makes it trivi...

Some simplifications to the API.

Rather than manually creating a torrent manager, then regist...

This will allow the engine to implicitly manage fastresume data,
dht cache data, and also provid...

Move this to ClientEngine.AddStreamingAsync. When this overload
is invoked we'll now populate th...

EngineSettings contains the path where torrent metadata
files are cached when torrents are downl...

If it's supposed to be a directory, append 'Directory' to
the property name.

This replaces usag...

This should make them deterministically green. We should really
be awaiting the returned tasks t...

If we're reading data from the in-memory cache, we should not
block on the flush-to-disk aspect....

The memory cache enables us to support some level of out-of-order
incremental hashing.

If a blo...

There used to be the potential for a data race. The issue
is that there'd be a gap where a parti...

Added CreateSubFolder property to TorrentSetting

I unintentionally removed support for piece sizes which
were not multiples of 16kB. It came as ...

It's probably best, long term, to be consistent. Make this
method async and ensure it proxies to...

This is cached because we know the version passed into
the method is not guaranteed to be non-nu...

Incremental hashing now fully guarantees the invariant
that a block which is incrementally hashe...

Simplify the logic to create Piece objects with the correct
number of blocks, and also ensure th...

All public/internal entry points to this class
should proxy themselves to the IO loop so threadi...

The tests should ensure they don't request data which
does not exist. i.e. do not request block ...

These will help reduce the amount of math littered around
the library.

This guarantees we cannot accidentally mix up blocks if there
are two or more active torrents.

We can simplify this and wrap the increment/decrement
in a try/finally in the same method. The c...

Rather than multiplying out the piece/block math in
multiple places, reduce it to some helpers m...

Now we can handle multiple consecutive zero length files while
retaining the new logic to binary...

Rather than integrating a memory cache as an IPieceWriter, we can
instead integrate it as it's o...

* [core] Allow bypassing the disk cache

The cache is used primarily to ensure that data is he...

Remove tests which serve no purpose anymore. The tests in
PieceManagerTests are actually attempt...

I'm pretty confident that we can safely keep MemoryWriter available
for people who wish to sligh...

This should rarely, if ever, change during runtime. In the
event it does change it's probably be...

If the very first block we send is the last block in the torrent,
and then we try to send anothe...

If two blocks from the same piece are received at the same time
and are processed in sequential ...

This reverts commit 5e0afecec3ea354898a1369134f36178c19d8ccb.

There are issues which appear to stem from the memory cache:
https://github.com/alanmcgovern/mon...

This isn't ideal, but it's good enough for now. It's pretty
much mandatory to update the version...

Reported by AN3Orik on github

We should be clamping the end piece index to within
the bounds of the file we're downloading.

If the MemoryWriter capacity is smaller than the size of
the block being written, it should shor...

If there's a peer we *should* be requesting pieces from but
are currently not requesting any, tr...

This will allow implementations of IPieceRequester to perform
operations on a regular cadence.

Move the specialised streaming piece picker logic into the new StreamingPieceRequester.

This ...

* using the modern pattern match syntax

* 1、bug fixed--spelling mistake，check whether Picker ...

If we forbid the piece picker from being changed at runtime then
we never have to Initialize an ...

Next round of refactorings. I'm a bit happier with this approach.

IPiecePicker - implement th...

Some libraries/apps like to seek backwards in the stream
even though they've already read the da...

We can now rely on the IPiecePicker to appropriately
handle how duplicate requests are assigned ...

If we have all the highest, high and medium priority pieces, then
we should enqueue at most 2 re...

If the seek was a no-op we can avoid the overhead of
reassessing which pieces need to be requested.

Don't request the same piece twice from one peer. The
purpose is to make it more likely we'll be...

Issue 3 requests for each block in the first piece, then
3 requests for each block in the secon...

If every piece has been requested 3 times this would cause
us to leave endgame mode.

It would h...

The StandardPicker logic has now been enhanced to
fully support the 'maxDuplicates' parameter in...

This is static data, so only create it once.

The tests were slightly non-deterministic in how they
ran due to the interaction between the tes...

Ensure the tests do not deliberately trigger errors by invalidly
writing the same data twice con...

Refactoring picking

It's a bit more accurate in how it's used :)

Also expose a way to enqueue piece request and
piece cancellation messages with peers. This allo...

IPiecePicker.ContinueAnyExistingRequest now allows duplicate
requests to be made. This allows th...