Yesterday, while randomly googling for "hot reload" I got aware of the drama which went down around two weeks ago, when Microsoft decided to remove this feature from the release, even after including it in the previews.
Here is a good summary https://www.youtube.com/watch?v=L9_pzDjw9HQ
Looks like they have walked this back, and Hot Reload for CLI (and thus, tools outside full the Visual Studio IDE) is here to stay. For now.
https://devblogs.microsoft.com/dotnet/net-hot-reload-support...
From what I read, it doesn't yet support stuff like async/await, LINQ, lambdas (and few other things). And those are used a lot in modern .NET apps.
Still a great improvement in the right direction.
This is a great! Now I can publish statically linked executables and run it everywhere. I don't have to tolerate Golang and its quirks just to have cross-compilation and static binaries, even though they will be larger in size.
$ dotnet new console -n HelloWorld
$ dotnet publish --project HelloWorld -r osx-arm64 --self-contained -o out -p:PublishTrimmed=true
$ du -sh out
10Mhttps://www.joelonsoftware.com/2004/01/28/please-sir-may-i-h...
.NET 7 will work on NativeAOT for instantaneous startup of especially smaller apps, but I think they’ve already optimized JIT warmups or something — I was pleasantly surprised when I just wrote a .NET 6 console app that read JSON from a server.
One thing though, is that native .dlls are still outside (DetoursServices.dll for example in BuildXL). But still pretty impressive what it can done. That, and the new embedded .pdb (for .NET only, e.g. not native).
I wish "publish" was used more by the place I work for (most of the folks would simply Release (F5) and store what's there in p4). I've only recently discovered about "publish" and that is after haven't worked with .NET for so long...
I might be ignorant here but if you're not specifically pointing out what version DLL's you want, aren't you in fact publishing a dynamically linked executable instead of a statically linked one?
Doesn't these single-file apps rely on the GAC?
> .NET Core and .NET 5 and later versions eliminate the concept of the global assembly cache (GAC)
I'm a novice at Golang, and I dislike much of the language, except that it's fast and can produce small binaries.
But it's funny how the infographic in the post mentions MAUI for desktop development, but the "desktop" keyword in the text is referring to the WinForms github repository. I can't think of a more concise statement about the state of GUI development on .NET. I would really wish for less fragmentation and churn in that space.
AS a longtime original VB/Winforms developer - MS lost their mind on desktop development and didn't look back.
They chased EVERY fad that could be chased. Silverlight, UPF, XAML, WPF, Islands, MAUI. This is one of those things - imagine if they'd focused on building an amazing and cross platform (ultimately) toolkit with just a basic drag and drop designer? Who cares about "styling" your app and all the rest of the garbage.
How many lost years and peoplehours?
I've got to the point where I don't trust them on any of this stuff. I target WinForms and if they ever decide to kill that then I'll abandon the platform completely.
>Who cares about "styling" your app and all the rest of the garbage.
One of the problems with WPF is the lack of styling of the standard controls. It takes a lot of work to ensure your app doesn't look like a turd.
Kinda joking, kinda serious, but all the Microsoft UI changes in the last 10-15 years have definitely helped enterprise IT adopt internal web applications. :)
Get rid of it.
Being a wise man I spared myself from this madness long time ago;) When I need Windows Desktop App I use Delphi or lately Lazarus that can do both Windows and Linux GUI from a single source and produce native standalone executables.
I will never bet on any new MS desktop development framework anymore . It’s either WPF or preferably web (even Electron) for me.
There's Uno, Avalonia, Xamarin Forms, and MAUI, all cross-platform. I think it's a mess no matter what.
Even if you want to use the latest and greatest UI, your customers need to keep up too. Completely unworkable.
There are very few applications that simply cannot work in a web browser in 2021. Even accounting for all the inconsistent bullshit between browser vendors, you can still arrive at something that works as far back as IE6 if you are conservative with your footprint.
Do you really need flexbox, webgl2 and GPS navigation for that warehouse inventory management application? Does everything have to live the various app stores? Will your users revolt if there isn't some ceremonial download & install phase of using your product?
I would go so far as to argue for deployment of a self-contained webservice to the end users that could be accessed via any arbitrary localhost browser before succumbing to the Microsoft Desktop GUI framework du jour.
Might as well use Unity game engine and write your app inside one.
It looks mature enough now, and has a better chance of being still useful in 5 years from now than WinUI or MAUI or whatever is the latest GUI tech MS wants us to use.
I am basically stuck on .net 4.8 because of that.
This is the first thing I look for in these announcements. .NET 6 is the successor to .NET Core 3.1.
Which is not far from say Ubuntu LTS at five years. (Python and Ruby have more confusing security fix policies than LTS/stable designations, but both are relatively close to the 3-5 year mark for security fixes.)
Definitely not "long" from the perspective of classic Enterprise development (or Windows "LTS" lengths), but from modern viewpoints it is "long". Interesting how such things shift culturally.
I'm excited by having these built in. I always found it awkward to need to do: `.GroupBy(item => item.Property).Select(group => group.First())`.
https://devblogs.microsoft.com/dotnet/announcing-net-6/#syst...
So without already being in an existing Windows-based Microsoft shop, is there any reason I should be interested in .NET today?
* Great performance - https://www.techempower.com/benchmarks/#section=data-r20&hw=...
* Open source - Microsoft has made a lot of missteps but they have came a very long way. The bright side is both how far they've came & the outcomes of the recent missteps.
* Very productive toolset imo. I focus mostly on web based tech though. I really like the syntax & type system.
* Swiss Army Knife in that you can use .NET to do just about any type of project - Web (front & back end), mobile, games, IoT, desktop, machine learning, etc.
* You can use C# & F# syntax, both very popular (though let's all be honest, F# is a 2nd class citizen in .NET but it's got a great fan base)
It seems to be keeping up with the broader .NET ecosystem pretty well I think - (https://devblogs.microsoft.com/dotnet/whats-new-in-fsharp-6/). In some ways it is ahead of C# as well so I wouldn't say it is behind at all.
For internal admin tools I can throw together a windows form app in C# much quicker than any other system I've worked with. I'm pretty new to the eco system so to it's amazing how fast you can get up to speed.
Microsoft has done an amazing amount of work writing and rewriting code to make cross platform open source .NET a real thing. All open licensed and developed in the open.
It's fitting you mention all the work Microsoft has done rewriting code. You're talking about .NET itself but I'm talking about the ecosystem, where Microsoft often does take others' projects and release their own version (the Windows package manager comes to mind), training the community to only trust things that come from them. Of course there was the recent famous example of Microsoft deleting public code so they could feature it in Visual Studio, but this tweet is typical of the attitude I've seen from the community: https://twitter.com/GeoffreyHuntley/status/14540569884432179...
Toplevel programs should make it easier to experiment with C# if you're interested. We also have first-class support for C# commands in https://ab.bot if you just want to play around with the language and make a fun Slack bot or something, although it might take us a week or so to get move up to .NET 6.
Shudders at memories of coworkers writing giant, ridiculously inefficient LINQ queries without understanding how it's actually using the database and what it's doing server-side
> Toplevel programs should make it easier to experiment with C# if you're interested.
Definitely interested in that small feature :) If I had extra time I'd like to see what it takes to brew install dotnet and write a simple CLI program. Can .NET deploy a static binary nowadays?
There is no killer feature for .NET I think. That's why it's a hard sell. I think its sales pitch is more or less parallel to Java (though I prefer C# to Java and VS to IntelliJ).
Do you want a statically typed, extremely fast, cross-platform language with a comprehensive standard library and huge ecosystem of 3rd party packages with almost unrivalled devX (Rider on non-Windows OSes) and streamlined packaging and deployment that allows you to scale from single person PoC to large team development within the same codebase with no additional overhead?
I'd note that it's a bit of a jack-of-all-trades when it comes to desktop and ML. The ML.NET package keeps getting better but for those areas where there's an obvious standard, e.g. Python for ML, you may as well use the standard for that thing. The desktop story continues to disappoint and I'd advise people to steer clear of desktop unless they want a nasty surprise. But for web applications I'd not want to use anything else.
And that's why developers and companies like it. It is a good, easy to use, well supported, well documented, sane jack-of-all-trades.
The .NET Core ecosystem was a lot sparser back then but picking up the language was actually the most pleasant "learn a new language and be productive in it" experience I've ever had, and I don't think I'd ever turn away from it now. YMMV, of course, depending on how much you like whatever you're writing in now.
I can tell you why the company I work for uses C# to develop microservice based products:
-cross platform
-tons of libraries
-integration with most of the things we need
-great speed
-good productivity
-great tools
We can iterate fast, have performance. Also, C#/.NET is good for other purposes such as mobile apps, frontend, writing glue code, and even desktop if the need arises.
Could you expand a bit on that?
I used .Net 1.1 and 2.0 for awhile, and coming back to it now while deciding the future path for our application.
I've heard the more recent releases of .NET have been pretty good, but I don't see any real reason to be interested in it. There are already plenty of good options out there.
Outside of a few areas related to DDD, event sourcing, and some distributed-system frameworks (NServiceBus and MassTransit) there's really no killer app for .NET, in my opinion.
The big selling point for .NET now is that it runs on Linux...which is not really a selling point in the grand scheme of things.
Blazor is an excellent C# on the browser stack.
And MAUI will target React Native (native controls) and Cordova (Blazor on Maui) at the same time ... which is extremely powerful. But that is half a year out.
.NET has a lot to offer if you take individual app models of it. If you want to stick in one language, it is even a top contender.
Linux selling point is already gone. That is standard already for 5 years now.
I've been on .net since 1.1 and .net Core since 1.0 and this statement makes me so confused.
Core lives _inside_ of .net 6? Is there a non-core ASP.NET that also lives inside that framework?
I thought .net 5 was where the legacy 4.x branch and core 3.1 was married in holy matrimony, minus the worst of the legacy garbage.
Yep!
> I thought .net 5 was where the legacy 4.x branch and core 3.1 was married in holy matrimony, minus the worst of the legacy garbage.
.NET 5 was the next evolution of .NET Core. There was no great merging of legacy .NET Framework into the .NET Core branch or something like that. It saw a bunch of foundational stuff land in so that .NET could support modern client apps from Xamarin and further support the modern versions of WinForms and WPF.
If that sounds confusing, it kind of is. But it's a clear branding effort - .NET is not a choice between the "slim .NET Core" and the "big .NET Framework. It is either .NET or the legacy stuff (still called The .NET Framework).
There was a brief period of time after I recognized that .NET really works on all platforms without proprietary stuff and before the `dotnet watch` desaster in which I was at least curious about .NET. But even then I never fully figured out how .NET, .NET Core, ASP.NET, .NET Framework, .NET MAUI and the kitchen sink relate to each other.
If the purpose of branding is to make something recognizable, Microsoft consistently fails across the board with me.
No, the "non-Core" ASP.Net framework is not ported to the .Net Core platform (i.e. .net 5+). Only ASP.Net Core runs on .Net Core.
This is unfortunate, because it means older web sites based on the classic ASP.Net does not have clear migration path to .net 5+.
Only remaining confusing part left in ecosystem is "ASP.NET Core", because even though .NET got rid of Core, latest version ASP.NET didn't
Perfectly clear and reasonable.
There is .Net Core, which was a rewrite of the .Net runtime to make it platform independent.
Then there is ASP.Net Core is which is a rewrite of the ASP.Net web stack. Despite the name, this was not initially dependent on .Net Core platform, it could run on both .Net Framework and .Net Core.
ASP.Net Core is the only web framework running on .Net Core though, the old ASP.Net framework is not ported to .Net Core. So to answer your question, no, there is not a non-core asp.net running on the .Net Core platform.
Then there is EF Core which was a rewrite of Entity Framework. Again, this was not initially dependent on .Net Core, although later versions is.
Basically "Core" just means "new backwards-incompatible rewrite".
The open source multi platform rewrite, originally named core, now named "", is going to be the active platform going forward. There are several core rewrites of the popular modules that will be the ones that are actively developed going forward.
We can either stay on 4.8 forever, or migrate to the "" which is where all the new and exciting things are being developed. MS has promised they will support 4.8 for the foreseeable future, for what it's worth.
Here's a video explainer: https://youtu.be/4olO9UjRiww
At this point I've given up hope at grokking the various names within/peripheral to dotnet.
It requires a PhD to understand versioning at this point.
Perhaps this is indicative of the larger Microsoft ecosystem, but it feels like my peers at university and in the industry tend to stay far away from .NET for personal projects, etc.
Why is this?
Both .NET/C# and Java are the core of Dark Matter Development [0]. They're what a huge chunk of developers and enterprise actually use but they're not cool and they don't get blogged about.
Obviously the history of EEE and Windows only legacy means there's a lot of hostility to anything .NET specifically amongst a subpopulation of developers. However I don't think it sufficiently explains the lack of noise about both Java and C#.
It's a bit of a shame because it would be nice to have more startup opportunities in .NET (or Java/Kotlin - rather than slow, dynamically typed, error-prone scripting language du-jour), there are some but they're a tiny minority.
It's hard not to get caught up in worrying about the future of one's favorite language/ecosystem but then I think over time the obvious benefits of the ecosystem will win people over, I hope.
[0]: https://www.hanselman.com/blog/dark-matter-developers-the-un...
Sometimes you see articles on the Internet where someone basically says something along the lines of "All developers use the Linux bash command-line workflow", and I just look at statements like that and wonder what on earth are they talking about!?
I have never seen a developer familiar with the command line. I have never seen a developer willingly use a Linux desktop. I have never seen anyone do anything but boring, "dark matter" .NET and Java development using IDEs on Windows.
I'm not talking about a couple of guys here. I mean that I have met or interacted with hundreds of developers across dozens of organisations!
Literally not one has ever said: "I wish I had bash", or any similar statement.
I tell a lie. I just remember that the one startup that I worked for had: Linux, bash scripting, allergies to Microsoft, hip-new-technologies, etc, etc...
In .NET there is usually one way to do things, the MS way. You don't have options. Whatever MS prescribes is practiced by most enterprise shops. I remember arguing for something closer to MVC (several open source solutions) when ASP.NET forms was the way to do things. It wasn't until ASP.NET MVC came out that enterprise shops came on board.
I still see a lot of documentation that shows Visual Studio screenshots. How am I supposed to do that on Linux? .NET still feels like a Windows first solution. You will not find official docs for Python, Node or Go using OS-specific IDE or editor screenshots.
Even if you ignore the history of companies like MS and Oracle what it comes down to is vendor lockin. If there's a chance a vendor will pop up in 3 years time with a huge bill, why take the risk when there are plenty of free alternatives.
From your linked article: "Where are the dark matter developers? Probably getting work done. Maybe using ASP.NET 1.1 at a local municipality or small office. Maybe working at a bottling plant in Mexico in VB6. Perhaps they are writing PHP calendar applications at a large chip manufacturer"
i.e. in Cost Centers not Revenue Centers, which is to say in jobs that do not pay well, and their management is trying to figure out how to spend less money, not make more money.
It's leftover industry bias because of Microsoft's long history of a proprietary tech stack that costs money to use. Today's Microsoft of promoting open source VSCode doesn't really undo the mindshare they lost in the 1990s and 2000s when the internet got big. I wrote previous comment about this: https://news.ycombinator.com/item?id=20256825
C#/.NET (including WinForms and ASP.NET) was instantly popular with corporate enterprises but Microsoft never captured emerging startups with their tech stack. E.g. 1990s startups like Ebay, Amazon, Google, etc all used Java+MySQL+Linux instead of C#+MSSQLServer+MSWinNT. And new high-profile open-source projects like Hadoop, Cassandra, Elasticsearch, etc chose Java instead of C#. I currently can't think of a famous project where the canonical source is C#. I use iText C# library but that was ported from Java. That's how it usually evolves. A lot of C# libraries were actually Java projects at first.
In Microsoft Land, the SQL Server team considers this an Enterprise feature, which basically translates to: "We added a couple of zeros to the price".
THIS, I feel, more than anything, meant that the Microsoft stack was just a dead end for many startups. The licensing cost for the database alone exceeded their revenue.
This was already crazy back then, but since then Microsoft has doubled down and increased SQL Server licensing. It is eyewateringly expensive now, and even their Enterprise customers are slowly starting to switch away from it.
They're slowly but surely turning SQL Server into Oracle.
But if your personal projects are a stepping stone to a programming job, then .NET has a monstrous legacy problem. In 2002-2007 a lot of code was written using .NET in enterprises: it was the best way to write a rich desktop application for Windows and ASP.NET WebForms, while terrible, were an okay stack for intranet websites, certainly not worse than PHP5 without Yii or Laravel. And if you were a Microsoft shop, you got the best integration with MS SQL Server and (oh Lord) BizTalk if you used .Net.
But then Rails and Google Chrome came out and completely upended the webapp industry. Microsoft has been playing catch-up ever since.
A modern startup could certainly use .NET 6 instead of the framework of the month to write their world-shattering program, but they won't, because .NET isn't cool. A lot of .NET jobs are in stuffy enterprises where you likely won't be paid to write a backend to a Svelte SPA in .NET 6, you will be paid to maintain an ASP.NET WebForms 2.0 monster that uses WCF to talk to some SOAP/XML webservices.
Of course, the same applies to JavaEE, but Java has a second leg to stand on: people wrote FOSS in Java back when it was a dirty word at Microsoft, so not everything in Java shops is a terrible Spring/JavaEE mutant that has to be configured using vendor-specific XML.
Microsoft does not play catchup in the web space. It is in the pack for some years already. The stuff they do with Blazor is at the upper end of the pack.
.NET, like Java, is not cool. It does not need to. It gets the job done without any experiments in a very modern platform. Doing a startup with boring tech is a thing.
So in summary: .NET is a very good choice for a beginner or converts. It is fresh, you can do solid stuff, do the full stack in one platform (web, desktop, apps, games, iot, ML, ...) and there are plenty of jobs (greenfield or brownfield).
Every enterprise targeting technology has the same issue.
In fact, that legacy is an opportunity to move into modern stacks.
And where is Rails now? .NET is still thriving.
>A modern startup could certainly use .NET 6 instead of the framework of the month to write their world-shattering program, but they won't, because .NET isn't cool. A lot of .NET jobs are in stuffy enterprises where you likely won't be paid to write a backend to a Svelte SPA in .NET 6, you will be paid to maintain an ASP.NET WebForms 2.0 monster that uses WCF to talk to some SOAP/XML webservices.
I get paid to write a modern microservice based application using .NET, Kubernetes, Docker, Consul, Redis, Postgres. I can't say it's boring. But it is true, the app is for an enterprise, not a startup. The payment is relatively good and the app is making money for the company, so we aren't a cost center.
I'm working on migrating an ASP.NET 4.0 application right now, and it's basically stuck in the past.
Physically, yes, it could be updated by the developers to work on .NET 6.0, but no manager will ever fund this. They don't understand the benefits, and no amount of explanation will justify this effort in their minds.
So Microsoft basically stranded their customers on an iceberg floating away from the shore that is very slowly, almost imperceptibly melting...
TLDR: Microsoft wanted .NET developers to only use tech from Microsoft, used various tactics to achieve that, and people got the message. If you wanted to use modern tech or develop innovative stuff, .NET was not a comfortable place to be.
Microsoft have tried to move past that, but never really have. .NET has never had a healthy Open Source eco-system.
Another aspect is that M$ tools are used by millions, it's just that there's a selection bias for tried-and-true tool users to just quietly make things work. "Blue collar programmer" comes to mind. All the leading-edge churn, noise, and fatigue is the corner of the industry that generates tons of blog posts and HN links.
Most/all of their offerings seemed like legacy software/tools once IntelliJ, big JS projects, and SPAs became such a popular solution for software development on macOS and Ubuntu.
Now with VS Code, TypeScript, heavy dev in GitHub platform, cross-plat .NET, vcpkg, etc... and generally very powerful dev tooling, they actually have excellent offerings.
All that said, M$ clearly has a long road ahead of earning back good will in "high" tech corner of the industry and Academia.
So, I'm a *nix guy. You know, running Sway WM, using Doom Emacs as my daily driver, that sort of a thing. Learned vim to write my thesis at night on an armchair where using the mouse was not comfortable.
Not long ago I accidentally got involved with a kind of a .NET consulting gig. Rather, I got involved as a domain expert to help out some SaaS startup dealing with that domain, and it just so happened that they were writing their thing in C#. Before that I hadn't used C# at all, mainly dealing with Python and C++. I liked the language, I thought the tooling on Linux was pretty decent. The ecosystem was a bit lacking for the domain in question, but it had other nice things going for it.
But there was definitely a bit of a culture clash with the .NET guys. As an example, I did my domain thing in a pretty much self-contained library. While writing it I needed something that would be 'just data' without any additional 'functionality' attached to it, so I naturally reached for `struct`, given that it exists in the language. The .NET guys asked why it was not a `class` instead. See, somewhere deep inside they felt that not wrapping everything in a `class` is wrong on some fundamental level. Later, I had to touch the rest of the codebase a bit. At one point there was something I felt was a 'one-line change', that took 12 files to edit. Mostly routing calls through different auxiliary classes because 'architecture'. And you know, I'm really not trying to diss those guys. They were nice, capable, smart, productive, good people. It's just that I was very evidently from a different 'tribe'.
So, I personally like the direction that .NET is taking. I think that this release has very nice things in it. Such as the statically linked binaries, and compilation to webassembly. I also believe that modern .NET has a nice value proposition in being able to use your code across the board in many contexts and settings. On top of that, both C# and F# are nice languages.
But I won't be looking for .NET jobs, or putting that .NET stint on my resume, lest some recruiter gets the wrong ideas!
And there can certainly be a culture clash, there is a bit of a tendency towards more complex patterns in the .NET world. But you don't have to do that, and MS is quite explicitly adding versions with less boilerplate in this release, if you prefer that.
The difference between a class and a struct in C# is not the same as between a class and a struct in C++. In C#, structs can definitely be useful, but also have some gotchas, so they're mostly used only in performance-critical parts of the code.
If you visit a foreign tribe, I think you should listen to the locals, unless you are really certain your way of doing things is better in the local context.
Have heard this sentiment in more than one comment in places like HN. "The {tech} is great, but the culture was ... so I'm not putting {tech} on my resume". And So it becomes a self-fulfilling prophecy :). Yet some tech seem immune to this. They don't say "X is great but the culture was crap, so I'm abandoning X", they say "X is great but the culture was crap so I'm changing jobs".
It really drives home that culture is critical, and even the worst tech can be tolerable if it is thought of as cool. Though of course the thought of abandoning ship to learn the latest and greatest solely to avoid legacy C++98/Spring/WebForms/whatever is naturally appealing.
I won't blame .NET for this. Needlessly complicated architectures are because OOP everywhere minded guys, Uncle Bob and GoF patterns. If you worked with a Java shop you cold have been hit by the same scenario.
1) Region (for example, my data point is from Boston)
2) Framework language choice (https://insights.stackoverflow.com/survey/2021)
3) Ecosystem (i.e. Microsoft vs. Unix)
4) Experience level (probably)
If anyone has any SF data points I am extremely curious.
And it's an especially hard sell given that it doesn't have a good GUI situation. Support for Windows GUIs is back since .NET 5, but the cross platform options are weak. It's very possible when the MAUI library finally releases that we'll see more people deciding to use .NET.
Avalonia is great and recommended by most people that used it. Or do we now only count Microsoft-made solutions and then whine that .NET is not open to OSS?
Rider is the perfect replacement, though. Comes with all the features of ReSharper (this is a big deal for many .NET workflows, VS may have integrated many of its features, but not all of them) and extensions and themes you can actually use (IME with VS of the 50% that promise to do what I want 90% are broken).
JetBrains just know what they’re doing. They’re clearly prioritizing quality (something the VS team seems to be actively working against).
Oh, and it’s damn near 100% compatible with VS projects (one thing I missed about 2 years ago were live updates of WPF XAML, everything else just worked).
.NET/C#/F#/VB are old. 20 years for C# and VB. And they weren't friendly on non-Windows platforms until recently (last five years or so).
Microsoft procured the open source version of .NET (Mono) and decided to push the platform to a unified, cross-platform deployment. That started with .NET Core and has evolved to .NET 6.
So you're coming to .NET awareness exactly when it's at its most effective cross-platform capabilities.
And AWS and Azure both let you build C# functions/lambdas for serverless API's, so it has market appeal.
I'm building my startup, Mach9Poker, in C# and the debugging/unit testing are top notch. The language C# is easy enough. It's the libraries you have to really learn and there is a "way" to Microsoft things that's different. But there are also massive helpers in IO, list management (Linq is one of the greatest technologies ever created), generics, lambdas, and more.
I started with C# with 1.0, back when structs inside structs didn't serialize properly. I've written iOS apps with Xamarin. I am a C# fan. I haven't used it professionally in a decade and my last personal project was years ago.
When is C# the right idea? The only time is when the project is entirely captured by the Microsoft ecosystem. There are plenty of places where this is the case. Windows desktop applications. Small business contract work who are still using Windows. Big business IT who still use Windows. Opportunities to migrate to Azure.
Where is C# the wrong idea? Everywhere else.
Writing for the best monetized mobile market? Swift.
Writing for cross-platform mobile market? Javascript.
Writing for cross-platform desktop market? Javascript. Maybe Java if you have a history of it.
Writing for the cloud? Something linux first. Javascript, Python. If you want a big GC language, why would you pick C# over Java?
AAA games? C++
Not AAA games? Maybe C# with Unity?
In every category where C# is used (outside Microsoft captured environments), there is a dominant solution which is not C#.
And that sucks. Because C# is awesome.
From a management perspective, this is not bad. You get movable team members. In my company we have moved people from WinForms app, to cloud deployed micro-portals and then to a Apple/Android App (all different solutions .. not a migration). C# play a big role in that.
I think this is again a dark-matter-developer / line-of-business situation.
>Why is this?
It's a reminiscence from the times .NET was Windows only and MS was considered evil by the Linux guys.
Some older people haven't learned that times have changed.
And for young people is missing the coolness factor, it isn't promoted and made fashionable like the shiny new framework X for Javascript.
In any case, the performance results were really outstanding (particularly vs Mono) especially given we use C++ for many performance sensitive areas already. Looking forward to upgrading to .NET 6 in the coming months.
Great work! Congrats to the .NET team!
Interesting. Do you have measurement results? According to my measurements the difference is not that big, see https://www.quora.com/Is-the-Mono-CLR-really-slower-than-Cor..., especially the section Update September 15th.
I am wondering about jumping from relatively large codebase in .NET Core 3.1 to 6.
Even those of us who are actively migrating applications are stuck with web forms, netfx and dotnet core 2/3 and will be for years, so it would be nice that we felt some love rather than being left behind.
MS are starting to feel like Apple where you only have value if you can keep up.
Well, the job market is pretty hot right now so I hear.
https://www.joelonsoftware.com/2002/01/06/fire-and-motion/
Think of the history of data access strategies to come out of Microsoft. ODBC, RDO, DAO, ADO, OLEDB, now ADO.NET – All New! [...] the end result is just cover fire. The competition has no choice but to spend all their time porting and keeping up
Maybe Microsoft got out-fire-and-motioned by Node.js for a while but they're working extra hard cranking out new stuff.
There are many reasons why one might be unable to upgrade to the latest version of any given thing. For an example close to my heart of why one might be unable to upgrade to .NET 6 (or indeed to later versions of the .NET 5 SDK), there's the showstopping https://github.com/NuGet/Home/issues/10389.
That's incredibly weird take in my opinion.
Whenever I use VS Code, then I feel huge gap between this and real VS with Roslynator extension.
Edit: Though I saw something this morning when I tried to load an f# project I made in VS refused to load even though the new ones generated with Rider are fine...
Rider feels so much faster than VS, and is rock solid - these were my 2 main reasons for switching from VS.
Rider is not perfect, but in many ways miles above Visual Studio.
As Rider doesn't have any Forms editor build-in (AFAIK), I am slowly switching most of my views to fully code, so I don't need to rely on Visual Studio's visual layout editors anymore.
https://www.jetbrains.com/help/rider/Working_with_Windows_Fo...
I noticed for a time that some projects created in rider had a different project type than those created in VS which caused some issues at my company. Was a simple change to the proj file though.
Do you mean Visual Studio? They don't share anything AFAIK
I just wished more startup are using it more as their tech stack to improve the ecosystem to be on par with Java. Almost every big tech companies are always using java now it's just hard to use .net when you won't get a job that doesn't suck
There's also a 40 page e-book ".NET for Java developers" here: https://aka.ms/dotnet-forjavadevs
I can, however, recommend you use Rider as your IDE. It includes JetBrains' excellent ReSharper code analysis tool, which actually corrects a lot of your generic OO code and will automatically rewrite it for you to be more idiomatic (avoiding memory and performance issues, for example). Rider knows the sharp edges so you can mostly forget about them.
Otherwise it should be very easy for you to pick up. .NET has some annoying code organization conventions (lots of subprojects, too many folders, etc.) but you can just structure your project however makes sense for you and avoid all of that.
If you feel like you really need a book, this one is good: https://www.packtpub.com/product/c-10-and-net-6-modern-cross...
https://docs.microsoft.com/en-us/aspnet/core/?view=aspnetcor...
I like JS as a language and the enormous progress thats been made in the JS ecosystem from the wild west days back then. But I have to say my most productive and enjoyable dev experience was with VS, C#, ReSharper etc.
Magical intellisense and real refactoring across millions of LOCs and multiple assemblies, all kinds of tools, visual designers, powerful 3rd party toolkits (anyone remember Infragistics), amazing docs. And of course now it'd be much better I'm sure.
Finally! :)
I was a bit disappointed that MS didn’t want to support macOS arm64 natively with .NET 5.
At the same time Microsoft invested a lot of effort in porting Java to arm64. Almost a year ago I could download Java builds for macOS arm64 from Azul (java 8-latest).
I wonder when, that could mean 2022
https://devblogs.microsoft.com/dotnet/update-on-dotnet-maui/
for instance, the F# example from https://fsharpforfunandprofit.com/posts/designing-for-correc...
can be done in C# like https://gist.github.com/keithn/ceeeed5f7eb567e1b2333747065d1...
almost similar amount of code, however, no exhaustive checking. Not that I find that to be much of a problem, but it would be nice
But honestly, with file scoped namespaces and global usings ... there is enough to see.
(We have a lot of .NET Framework libraries, shared between different applications, and a complex dependency graph between them. So I'm wondering if it is possible to migrate away from .NET Framework by starting with the executables and working our way down the dependency graph.)
[0]: https://docs.microsoft.com/en-us/dotnet/core/porting/third-p... [1]: https://docs.microsoft.com/en-us/dotnet/core/porting/#net-fr...
You have to be careful though because you could get runtime crashes if they try to access stuff that is not supported in .NET 6 (mostly Windows-specific libraries).
I'd recommend running this guy on the code base, it'll give you a good idea of how much a pain it will be: https://docs.microsoft.com/en-us/dotnet/standard/analyzers/p...
Those use a common API subset, and are a stopgap to make migration easier.
The only thing we miss is system programming due to not being able to opt out of using the garbage colector.
I built a couple of side-projects and startups - all on .net.
First one was on Xamarin even before it was bought by MS - the progress from that times is amazing, the last one - built fully on Blazor.
I believe more startups should try to adopt .net stack - it's fast, fun and efficient and becomes better every day.
Congrats .net teams on launch
For instance, in WPF applications: https://docs.microsoft.com/en-us/microsoft-edge/webview2/get...
https://devblogs.microsoft.com/dotnet/announcing-net-maui-pr...
Unless it gets rebranded again before it's usable.
https://github.com/chromelyapps/Chromely https://github.com/webview2/EdgeSharp
Good to finally have an official version!