In the previous post in this series we mentioned the concept of superposition briefly. Let's use this second part to dive deeper into the mathematics of it, meet the cat of Schrödinger and try to find some simple quantum computing use cases for it.
While it's still early days, we would want that OmniSharp users can work with .NET 5 as soon as possible, so we have just added support for .NET 5 in OmniSharp.
Let me quickly walk you through what you need to do to take advantage of that.
Quantum mechanics is one of the fundamental theories of physics, and has been tremendously successful at describing the behavior of subatomic particles. However, its counter-intuitive probabilistic nature, bizarre rules and confusing epistemology have troubled some of the greatest physicists of the 20th century, even prompting Albert Einstein to remark “Old Man (often translated as 'God') doesn't play dice”.
Today, we are at the dawn of the quantum computing age, a multidisciplinary field that sits at the intersection of quantum physics, computer science, mathematics and chemistry and may revolutionize the world of computing and software engineering.
In this post I am starting a new series that will, through the lens of a .NET developer, introduce the basics of quantum computing – using examples in Q#.
There are several ways of bootstrapping your MVC applications on top of ASP.NET Core 3.x. One thing that you need to do, in order to use the framework, is to initialize it into the state where it can actually discover your controllers, views, pages and expose them as HTTP endpoints.
I've recently had some conversations with folks about that, and it occurred to me that this is not necessarily all that obvious to everyone. That's because there are a few ways of doing that, so let's quickly run through them.
OmniSharp powers intellisense and language services in C# plugins and extensions for numerous editors, including VS Code. When we build things into OmniSharp, we typically try to keep things lightweight (of course if the term “lightweight” applies to anything related to MSBuild…) and non-invasive. This means that many features/tweaks are actually opt-in by default, and wouldn't normally show up on their own.
In this post I wanted to show you a few of such less known features.
EditorConfig is an excellent way to enforce stylistic rules on your C# projects. However, the rules and their corresponding IDExxxx diagnostics are only enforced in the editor, such as Visual Studio or VS Code with OmniSharp, but not at build time.
While there are various categories of EditorConfig conventions that you can use, in this post, I will show you how to enforce the formatting conventions (IDE0055) at build time.
When you compile your C#, F# or VB.NET code, which are all high-level managed languages, the relevant compiler doesn’t compile it to native code, but instead it compiles it into the Common Intermedia Language.
The IL code is then just-in-time (not always, but let’s keep things simple) compiled by the CLR/CoreCLR to machine code that can be run on the CPU. What I wanted to show you today, is that with the new Microsoft.NET.Sdk.IL project SDK, it is actually quite easy to create and build projects in pure IL.
Let’s have a look.
One of the little known and rarely used hidden features of .NET Core is the ability to seed AppContext data dictionary directly from the csproj project file. This provides an interesting mechanism for exposing low-level tweaks/knobs/settings for your application code.
Let's have a look.
One of the awesome features introduced in .NET Core 3.0 and C# 8.0 are async streams. The feature consists of two parts – async disposable, for async clean up, as well as async enumerable, for async iteration.
Normally, the C# language features are backwards compatible and can be used regardless of the runtime framework being targeted. In this particular case, however, the newly introduced types that are needed for async streams feature to work, such as for example IAsyncDisposable or IAsyncEnumerator<T>, were only added in .NET Core 3.0, restricting the usage of the features to that runtime, and later.
Let's have a look at how you can still benefit from async disposable and async enumerable on older frameworks.
In this blog post we will look at how you could create an instance of an object in C# without calling its constructor – which sounds a bit crazy, but is actually something that has been supported by both CLR and Core CLR for a long time now.
More after the jump.