All we really care about is that the task returned by
'SendAsync' or 'ReceiveAsync' does not blo...

The event is async so we should not rely on it executing before
the Announce task completes.

Standard CancellationToken semantics!

It's concern is purely to receive broadcast messages and then
pass the data to the ClientEngine ...

The TrackerManager just needs a way to generate the appropriate
AnnounceParameters or ScrapePara...

Use Stopwatch instead of DateTime.[Utc]Now. Fix up some comments
to make them a bit more accurat...

These should be proxied to the main loop.

Just covering a few more cases.

This also fixes two bugs :) Firstly, it is allowed to set
'Tracker' to null when all Trackers fa...

Allows me to remove the old BeginSend/Receive methods.

If we need to await a Task we should have a timeout in case it
never actually completes.

This is easier than having to iterate over every Tracker and
attaching to individual events. As ...

The async/await changes make this a little easier to represent
using normal/sequential logic.

Also swap to autoprops in some places.

The Async variants offer the same overloads as the synchronous
variants, and all the Async varia...

The simplifications we gained from async/await across the
codebase mean we no longer have confus...

We don't particularly want people mutating our objects
while we're using them, so hide the metho...

These are not supposed to be exposed to the public. They
are controlled exclusively by the engin...

This isn't for people to mess with. The engine manages this
value based on whether or not an enc...

They're not user-extendable/usable.

This way we can associate an eventargs with each buffer from
our BufferManager and re-use that e...

Now that we're null out the Socket object we need to be careful
to null check the socket to avoi...

If we never send or receive any messages, we do want our timeout
to be hit. That means we need t...

There are better ways :p

Rather than exporting a clone of the active request list and
then iterating it to see how many o...

We can instantiate the HaveMessage once and send it to many peers.

If either the DiskManager or SendMessageAsync methods throw
an exception we should still return ...

If we call 'Enqueue' we automatically kick off the messaging
sending logic to begin sending mess...

Since we've already instantiated a TaskCompletionSource we
should go ahead and populate it inste...

We can just cache and reuse them. Saves a few dozen MB of
allocations for a small torrent.

If we have a timer callback which executes every 1 minute, then
the objects referred to by that ...

When doing the initial population of pending requests we should
not add items for blocks which h...

If we're swapping from downloading -> seeding we dispose every
connection where we know the othe...

This prevents it from retaining requests forever.

Partial fix for https://github.com/mono/monot...

This is a little better memory-wise.

Small tweaks applied by Alan before commiting.

Always add/remove from these two lists at the same time to ensure
they are always in sync.

As p...

We can't guarantee that user subclasses of things like IConnection
won't throw exceptions, so le...

That way we can complete all our cleanup before disposing the
object.

Patch modified from chang...

If we want to time out a message early, we just set Engine.Timeout
to be Zero. We don't need to ...

We just care that we send 5 messages every loop. We don't need
additional checks to rate limit.

This class is quite simple to unit test as it no longer
relies on any timing. The DhtEngine is r...

Same reasoning as last time.

Also use stopwatch instead of DateTime for calculating
deltas. Stopwatch timestamps are much che...

If we call Seen then the FailedCount is set to zero, which is
the correct thing to do as this su...

Use a normal abstract method to implement this feature, and
remove the reference to the 'Query' ...

Make stuff readonly.
Remove unused 'using' statements.
Add some license headers.

Slims up some code and makes it easier to probe for values.

We can just increment an integer using the Interlocked class
and take the first two bytes of the...

They need to be compared in different ways at different places in
the codebase, so it's safer to...

Less memory overhead.

Dht updates

According to the spec a FindNodeResponse should contain a
'nodes' key, but some implementations ...

Technically this does not have to be a BEncodedString, so
let's accept any BEncodedValue from ot...

If the received dictionary doesn't have a message type identifier
then we should bail out immedi...

Because why not!

When we search for peers, we should keep track of the nodes
which responded to us. This way when...

This is a little simpler to deal with! It has the same semantics as
a HashSet - if a closer node...

This is now written in a similar style to InitialiseTask. It
sends as many messages concurrently...

We shouldn't wait for one message to time out before sending
the next announce message.

Use discard variables "_ =" to ignore returned Task objects
which we don't want to await.

The returned task used to wait for the full bootstrap to complete
(if one was needed). However t...

Now we can ensure all of the Dht engine interactions can be
performed in a non-blocking but thre...

Just reference the existing files instead of copying/pasting.

We'll never raise events, so if anyone attaches event handlers
just discard them.

We don't want/need to Register it, we can just set a non-null
value on the property.

When we receive an ErrorMessage we should treat it like a
ResponseMessage - we need to unregiste...

The tests will use this to ensure that pending requests are
removed from the list when the respo...

Timeouts are either zero, or the default value. If we rely on
a message being sent, and a respon...

This is useful for tests when we want to time messages out on
purpose.

Send at most 5 messages every 5 milliseconds. This avoids the
possibility of overloading bad rou...

The timeout is 15 minutes so there's no need to run the logic
once per second.

This test should send a PingResponse message as soon as a Ping
is sent so that the new nodes are...

Sometimes we'll want to respond with a Response message when a
Query is sent.

This is a slightly cleaner way of handling message timeouts.
It also ensures we always clean up ...

We don't actually count the active sends, nor should we! Once
a message is sent then we wait for...

If we receive a message we should immediately ensure we have both
a transaction id and a valid I...

When doing our loop we should iterate over all available
messages and process them in one go.