CodeBlog | 博客查看、收藏与分享； 博文高亮显示代码； CSDN博客搜索； 分享博文或应用到QQ好友； 机器人陪聊； 文章推送；

Only the people at Microsoft who implemented that method can tell you for sure why it was implemented the way it was. However…

It's important to note that your proposed alternative doesn't work in very many interesting scenarios. It's very limited in when it would work, as compared to the scenarios where OfType() might be called.

Indeed, it only works in the scenarios where the caller shouldn't be calling OfType() in the first place. After all, if the object is actually already the type IEnumerable, it's pointless to filter the source by type. Callers should already know enough about the source's actual type to know whether such filtering is really needed or not. And they certainly shouldn't be calling OfType() for its side-effect of removing null values.

So, why introduce an "optimization" that only optimizes code that should never have been written in the first place? That'd be pretty much contrary to the usual guidelines for optimization. One of the first rules is to focus on the common case. Optimizing the uncommon case is often a waste of code, particularly in a library, and that's especially true when the particular uncommon case in question involves bad code.

Is this true? Am I missing something?

I believe your reading of the source code is correct. But you shouldn't rely on this behavior unless it's documented. My guess is that the documentation simply hasn't kept up with the implementation, but you can open an issue here to get the docs updated.

.NET Core has lots of little enhancements like this that you might hesitate to make to .NET Framework for backwards-compatibility reasons.

It seems that the VB compiler treats LINQ query syntax different than the C# compiler.

In C# the expression

I had similar issue. Try installing a correct version of LLDB. SOS plugin from specific dotnet version is linked to a specific version of LLDB. For example dotnet 2.0.5 is linked with LLDB 3.6, v.2.1.5 is linked with LLDB 3.9. Also this document might be helpful: Debugging CoreCLR

Note not all versions of LLDB are available for some OS. For example LLDB 3.6 is unavailable on Debian but available on Ubuntu.

The memory usage is way down and into a respectable range for .NET Core 2.1 (netcoreapp2.1).

That article is describing an outdated mode of operation for 'Swarm'. What's described is 'Classic Swarm' that needed an external kv store (like consul) but now Docker primarily uses 'Swarm mode' (which is an orchestration capability built in to the engine itself). To answer what I think your questions are:

1. I think you're asking, if we can expose a port for a service on a host, why do we need an overlay network? If so, what happens if the host goes down and the container gets re-scheduled to another node? The overlay network takes care of that by keeping track of where containers are and routing traffic appropriately.

2. Not sure what you mean by this.

3. If consul was a key piece of discovery infra then yes, it would be a single point of failure so you'd want to run it HA. This is one of the reasons that the dependency on an external kv was removed with 'Swarm Mode'.

4. Not sure what you mean by this, but maybe about rebalancing? If so then yes, if a host (with containers) goes down, those containers will be re-scheduled on another node.

As Hans Passant suggested, there is an extra field added at the end of string object which is 4 bytes (in x64, it might require another 4 bytes extra, for padding).

So in the end we have :

However, in my pursuit of parallelizing the work I believe I found a more straightforward method than what I could find.

It's more straightforward, but wrong.

The other methods are somewhat dated.

What on earth does this even mean?

Am I missing something that will make my method susceptible to any of the myriad of multithreading problems?

The most basic rule of thread safety is: you can't use a not-threadsafe object on multiple threads without a lock. Random is not threadsafe, but you use the same one on every thread to calculate the seed.

Note that Jon and Stephen's "dated" methods correctly lock around the seeding random.

Clearly I don't know as much as Stephen or Jon so I'm concerned I missed something.

First, you should thoroughly internalize the basic rules of thread safety before writing any more multithreaded code.

Second, your attitude was your error. The correct attitude is: Jon and Stephen are both experts and their solutions contain no unnecessary parts. If you think that you've found a solution that lacks a part that their solutions have, then you need to explain why your solution does not need the part that their solution has.

Yeah, this is probably caused by proc notation. The desugaring is very low-level, introducing a lot of (needless) arrs and not taking advantage of &&& or *** at all.

For example, last I checked, this: