.Net and its companion languages like C# are unique as a developer platform and a runtime. I love the fact that .Net has a common runtime that supports several languages to be used to develop on top of it and the interoperability between those is absolutely flawless. The is made possible by the metadata that is included in the binaries that are compiled, which are called assemblies.
The other thing I love is the fact that the compiled binaries do not contain by default native code, but intermediate language code (which is binary, not text) that is just-in-time compiled to native on runtime. This is a very small performance penalty on application start-up (and the first time each method is used for the first time), but essentially makes applications multi-platform. In the end, native code is actually run, so performance is not an issue.
Yet another amazing aspect .Net has is the incredibly optimized garbage collector. This means that developers don't need to worry about managing object memory. There are no segmentation faults for trying to access already de-allocated memory. There are no memory leaks (strictly speaking that is - in practice, there still can be memory mismanagement by making bad use of static variables). As to the performance, while purists will stand by their highly optimized C and C++ code, for applications that have a lot of objects being created and disposed, the GC does represent an incredibly *better* performance than C and C++. I've already benchmarked this and the difference can be of something between 5x and 10x faster, where .Net solidly wins. Moreover, .Net manages very well the problem of memory fragmentation.
Finally, .Net supports some language features I absolutely became dependant on. Delegates are so much better than Java's anonymous interfaces. Properties are an incredibly better way to expose private state, that Getters and Setters. Generics are well implemented instead of being erasure generics.
Finally, there's the unique killer feature, LINQ - Language Integrated Query. Linq allows for expression trees to be written in the language of your choice (for instance C#) and have those expression trees be translated by database providers into optimized SQL queries to that database. This allows a whole new level of ORMs and a great example is Entity Framework. But this is just one of LINQ's many aspects. Depending on the context, the exact same LINQ, usually represented as a lambda expression, might be used as either an expression tree or an anonymous method. This means the same logic used to query a database can be used to query non-database things like lists of objects, XML, Json and so on. It is extremely versatile.
There are so many more things I absolutely love about .Net, but these are probably the main things.
The fact that in the past .Net was officially a Windows only proposition. In fact, .Net 4.5 is still only Windows. It kind of defeats one of its great characteristics, the fact that it is in theory multi-platform. However, there has been Mono, an alternative .Net implementation that wasn't supported by Microsoft and even better, .Net has been rebooted and a there is now .Net Core that is officially multi-platform. In practice, nowadays we can run .Net in a very broad range of devices ranging like macOS computers, Linux desktops and servers, iPhones and iPads, Android devices and Windows UWP, Even IOT devices, hologram and Xbox are supported now.
Do consider .Net Core. .Net Core is still not the complete framework, so it still misses some bits. If you need some more advanced features like AppDomains and more control over threads, you're out of luck with .Net Core and you will need the full framework like .Net 4.5. However, if you don't need those features, .Net Core is a supported multi-platform solution.