
Announcing .NET Core 2.0 - benaadams
https://blogs.msdn.microsoft.com/dotnet/2017/08/14/announcing-net-core-2-0/
======
SiVal
I wish I had a better sense of where cross-platform desktop app platforms
stood these days: Electron, Java, .NET, QT. All I hear are "Eww, Electron is
ridiculous, slow, heavy Web junk for desktop", "Eww Java is blub, insecure,
and half-abandoned by Oracle", "Eww, .NET is Microsoft and unreliable for
anything serious on non-MS OSes", "Eww, by the time you pay the license, learn
QT, learn the odd variant of C++, and manually deal with different bugs on
every platform, you discover you would have been better off using the OS
makers' preferred tech on each," and so on.

It's hard to tell how much of this emotional reaction is due to current
reality, how much is leftover from old experiences that are no longer
relevant, how much is just language preference (not platform quality), etc.

I could just try them all, but my experience years ago was that the cross-
platform tech, when it worked, made things easy at first, but that final 5% of
your code was always trying to find hacks to do what no one had ever tried
before--very time consuming and risky (no guarantee of success). So "trying
them all" won't really give me a true sense of where the technologies are in
reality.

There's no rush in my case, but I do wish I had a more realistic sense of what
the various desktop dev technologies were like these days in case I ever go
back to it.

~~~
gwbas1c
I work on a cross-platform desktop application written in C#. We use .Net on
Windows and Mono on Mac.

The thing with desktop applications is that an "industrial-strength" one needs
to look native; thus it's in our best interest to use the native language of
choice. This means that our Mac UI is Objective C, and we're very good at
integrating Objective C and C#.

The other thing with desktop applications is that if you're doing something
interesting, you probably need to call native APIs for OS concepts that are
unique to each platform. A cross-platform environment can't do this very well;
and we drop into C++ APIs on Windows and Objective C on Mac to do this.

The sweet spot for cross-platform development is your business logic, and
networking calls. That shouldn't change as you move among platforms, and that
should be the area that cross-platform development gets right. If you're
willing to do this in C or C++, everything will be straightforward, but you
have to deal with the warts of C and C++. If you need a higher-level language,
it better integrate well with the languages you need to do your UI and low-
level logic in.

~~~
Rusky
> The thing with desktop applications is that an "industrial-strength" one
> needs to look native

I don't think this is the case for every application. It's definitely true for
mobile apps, and it's probably true for desktop apps that are relatively small
and/or use mainly standard OS GUI functionality.

But for things like Photoshop, or Office, or Unity/Unreal, too much of the UI
is application-specific for it to really matter, and I think they benefit from
a consistent cross-platform codebase and appearance.

------
jefe_
I have been absolutely loving .NET Core since I started using it this spring.
Currently running two applications in production, one on a Windows Server with
IIS and another on a Centos 6 server with Docker. Docker was surprisingly
easier than configuring Web Deploy to IIS. There have been a few things that
are oddly documented, but generally documentation has improved over these
months as user base has grown. They have some great videos on Microsoft
Virtual Academy. Early on it felt like many packages weren't compatible
(particularly PDF & Image tools), but as time has progressed many old packages
have been converted to .Net Core. One project I converted was in PHP before,
so I can't accurately speak to performance (obviously feels fast), but
development speeds have increased greatly with IntelliSense vs a text-editor.
Another project, I had a C++ console application that sort of needed to become
a web application but wasn't worth the effort of rewriting. In relatively
short order, I had a .Net Core web application using interop services to call
the dll. I was later chided by some C# purists that it could have been
rewritten in C#, but it was still cool to see how easy it was.

Ten years ago when I was starting out, Microsoft wasn't even a consideration
when looking at toolsets, it was stodgy, expensive, and didn't run on a
MacBook. Now, not only have they completely redesigned, and sold me on their
development toolsets, but they've implemented an interesting alternative to
AWS, and they've shifted my go-to machine from a Mac to a Windows machine. The
turnaround is pretty remarkable (obviously they have remarkable resources, but
still). I sort of want Michael Lewis, or someone, to write a book about the
last decade at Microsoft.

~~~
strayamaaate
Couldn’t agree more. I’ve been using .Net Core 1.1 daily for the last couple
of months building out a reasonably large Web API for a game.

The platform, tools and C# as a language are a pleasure to work with on both
my Mac and Windows machines (small caveat on VS for Mac, it’s still a bit
lumpy)

I’ve been using Unity for about 8 years and I’m finally confident building a
backend using .Net and basking in the joy of interfacing it with Unity.

When I first started using Unity many years ago, we used to say it made making
games fun again. I can say .Net Core feels the same for Web/API development.

Kudos to all those who put effort into bringing 2.0 out.

~~~
justboxing
> building out a reasonably large Web API for a game.

How are you hosting this? Can you share any experience? I built a Web API
using .Net 4.6.1 and when it came time to host it, Azure DB, Azure Web App
became quickly super expensive.

I'd be curious to know if you've find a cost-effective hosting solution for
hosting .Net Core APIs in a Production-like environment for a SaaS website
(which is what I'm building on the side)

~~~
Huppie
I'm not OP but maybe I can chime in. My employer runs a fairly large
application platform on Azure and I've used Azure for personal projects a few
times.

Let me start off that you can host (ASP).NET Core projects just about
anywhere, so using AWS is definitely a possibility. I myself use basic Azure
functionality though. Here's what I do when costs are the limiting factor:

For storage, Azure used to provide a small (20MB) db instance for free in
their 'free tier', but that doesn't seem to be available anymore.

As an alternative you should consider using Azure Table Storage instead of
Azure DB.

While Azure DB offers a fully-functional SQL server instance, it will cost at
least $5 per month to use on a basic plan. Using Table Storage (Azure's
'NoSQL' solution), on the other hand, is way cheaper. For a fairly small
application with less than a hundred users my average monthly bill is $0.00.
Even if it scales to a hundred thousands users (while it isn't really built
for that) the costs for using Table Storage would probably still be less than
a dollar per month.

Alternatively, you could use SQL Server Compact. This should be possible on
Azure but I would not recommend going this route though.

As for hosting, my personal apps almost exclusively make use of the Free tier
for App Services. For what my apps are doing this turns out to be efficient
enough. If that's not enough, a simple Shared hosting environment is also
pretty cheap at less than $10 per month.

It only gets expensive if you really need dedicated VMs running for you but
even then $50 per month for a dedicated machine shouldn't break the bank if
your SaaS business is actually going somewhere, plus scaling it up or out is
dead simple. On average I spend more time per month babysitting the single VM
I have with RackSpace where I run old (non-azure) webapps than our entire team
spends managing our azure environments (DTAP) with hundreds of apps and
databases.

~~~
justboxing
Thanks. Very useful info.

------
banashark
I'm enjoying reaping the rewards of all the dotnet core work in my F#
projects.

One critique:

Why break semver?

[https://github.com/dotnet/standard/blob/master/docs/faq.md#w...](https://github.com/dotnet/standard/blob/master/docs/faq.md#what-
about-the-breaking-change-between-net-standard-1x-and-20)

Like I get that it _feels_ like a big change (and it is), but you've gone and
confused a huge population of library writers and users with the major version
bump.

[https://github.com/search?q=netstandard2.0&type=Issues&utf8=...](https://github.com/search?q=netstandard2.0&type=Issues&utf8=%E2%9C%93)

How many of those are irrelevant or invalid? That's just github. I already see
the noise being created in slack and gitter channels as well.

Other than that I think dotnet core is an amazing engineering effort and I've
been happy using F# on OSX with it.

~~~
bsaul
do you still need to install mono in addition to core to get autocomplete on
vscode ?

~~~
banashark
Yes

[https://github.com/ionide/ionide-vscode-
fsharp#mono](https://github.com/ionide/ionide-vscode-fsharp#mono)

------
snomad
Looks like VS 15.3 is official too

[https://blogs.msdn.microsoft.com/visualstudio/2017/08/14/vis...](https://blogs.msdn.microsoft.com/visualstudio/2017/08/14/visual-
studio-2017-version-15-3-released/)

~~~
Todd
Here's the associated submission:

[https://news.ycombinator.com/item?id=15009929](https://news.ycombinator.com/item?id=15009929)

------
pantalaimon
Does .NET Core also include a cross platform GUI toolkit? (Windows.Forms and
WPF come to mind)

If not, what toolkit would be recommended these days for this purpose?

~~~
asp_net
Not specificly .NET Core, but Xamarin is already available for macOS and is,
afaik, actively working on Xamarin.Forms coming to desktop, including Linux.

~~~
alykhalid
Blog post announcing this feature [https://blog.xamarin.com/glimpse-future-
xamarin-forms-3-0/](https://blog.xamarin.com/glimpse-future-xamarin-
forms-3-0/)

------
manigandham
Good video overview of everything:
[https://www.youtube.com/watch?v=Q2mMbjw6cLA](https://www.youtube.com/watch?v=Q2mMbjw6cLA)

------
LyalinDotCom
For those of you who are using VSTS: CI/CD or VSTS: Build please note that
we're still updating our hosted build image but that should be done in the
next few days.

We'll also be sure to update the docs here with the list of what is supported:
[https://www.visualstudio.com/en-
us/docs/build/concepts/agent...](https://www.visualstudio.com/en-
us/docs/build/concepts/agents/hosted#software)

~~~
styfle
I just realized that Hosted VS2017 is still using Visual Studio 2017 (15.1
Update). That's two versions behind now. When is it going to get the 15.3
update?

------
sandGorgon
Why are there so few new languages built on the .NET platform ? This is a
genuine question - is there something about the JVM that gives rise to such
vibrant ecosystems.

Clojure, Scala, Kotlin, Groovy, JRuby : Most importantly, every one of them is
in production use - not just as toy/experimental languages. And we havent even
opened the Pandora's box that is Java 9+Truffle.

There's a lot of broscience that .NET is superior to the JVM - is that on
sheer performance only ?

~~~
mike_hearn
The .NET runtime is not superior to the JVM and probably never has been.
Certainly not in performance. The JVM stomps .NET CLR in performance.

C# has been superior to Java, as a language, for quite a long time (IMHO) and
likely always will be. The libraries, well, I don't know. Pretty similar I
guess.

The thing to consider about programming languages is there's no way to make
money from them anymore. That means they're either loss leaders for some other
product (Swift : iOS, C# : Windows), the result of academic research (Scala,
Haskell, etc), one man's personal quest to redefine coding (Clojure, Groovy,
Ruby), or the result of a company attempting to optimise its own processes or
products (Go, JavaScript, Kotlin). Oh yes. And then there's C++ which defies
categorisation :-)

So now you look at the categories above and what do you observe? That a lot of
the developers will be essentially hobbyist in nature, or working on products
that are often used on UNIX. These people will want to build on a cross
platform runtime. Until recently .NET was not cross platform.

JVM bytecode is also a bit simpler than .NET bytecode and has better support
for dynamic languages. Many languages are dynamic.

~~~
pjmlp
.NET always had AOT compilation from day 1, and now has .NET Native, which is
the same backend as Visual C++.

It had forks being used to write Singularity and Midori, and official support
for unsafe code if performance required it to, including ways to manually
manage memory.

The CLR has native APIs for IL rewriting engines, via the profiler native API.

Supports value types, SIMD, and the roadmap to C# 8.0 will be adding more
features bringing C# low level capabilities closer to C++.

Java will be getting some of these goodies as per Java Language Summit 2017,
but they are all targeting Java 10 or later, while .NET is delivering them on
2017.

------
hacker_9
_" You can now refer to .NET Core/.NET Standard libraries from .NET Framework
projects and vice versa. No need to manually add interop NuGet packages –
Visual Studio does this for you automatically."_

Excellent. Hopefully developers moves over to .Net Core en masse now, and I
won't have to wait long for all my third party projects to switch over.

------
disease
Am I misunderstanding something, or does Entity Framework Core, even at
version 2.0, not support translating LINQ code into GROUP BY in the generated
SQL? That seems so unbelievable that I figure I have to be wrong here.

------
WhitneyLand
Perfect example of a strong technology that has really been hurt by strategic
errors.

Whatever success .NET did have, it was still largely pigeonholed as just
something for Microsoft stack devotees.

There was no technical reason the essence of the new core version couldn't
have been a priority 20 years ago. Not only cross platform and open source,
but acting earlier and more aggressively to dispel patent trap mistrust. It
cost precious momentum.

No doubt hindsight makes it easy to say all this now, but there was still an
issue of entrenched thinking about the way things had always been before,
combined with a circle the wagons mentality.

One part of it I think was easy to see, was that free high quality development
tools should have been widely available day one. How does it make any sense
for a company to try and make $5000 off of a copy of visual studio, at the
expense of platform momentum that is driving $200 billion a year in revenue?

~~~
pjmlp
20 years ago there was Rotor (aka Shared Source CLI), but it was another
management in place.

[https://msdn.microsoft.com/en-
us/library/cc749640.aspx](https://msdn.microsoft.com/en-
us/library/cc749640.aspx)

------
raziel2p
Trying to get it working on Linux, I had to manually fix some permission
errors, and now am stuck on this helpful error message: No executable found
matching command "dotnet-net"

Not a great experience, especially since I was able to get 1.1 working quite
easily.

------
junto
With "Live Unit Testing Support" it seems that NCrunch is about to become
redundant.

[https://docs.microsoft.com/en-us/visualstudio/test/live-
unit...](https://docs.microsoft.com/en-us/visualstudio/test/live-unit-testing)

[http://www.ncrunch.net/](http://www.ncrunch.net/)

------
locusm
Whats support like for non MSSQL databases these days like? Can MySQL &
Postgres be easily hooked up and used??

~~~
mosen
I'ved used [http://www.npgsql.org/](http://www.npgsql.org/) to great effect.

------
systems
Beside C#, what other languages are considered to have first class support

I know VB .Net might be implicit here, but I am not so sure as I dont hear
much about it anymore and I think it is no longer adding new features

And I know that there is some F# support

So aside from those two (VB .Net and F#) ... any other languages have serious
support for .net core?

~~~
bsaul
i tried f# and it really feels like a second classe citizen ( at least on
macos). Very few educational resources. You still need to spend a lot of time
on c sharp to learn the frameworks, and then maybe move to f#.

~~~
jackfoxy
The problem is F# does not use the Roslyn compiler (but does use other
components of the Roslyn tool stack in Visual Studio) and it uses things in
the IL (primarily tail calls) the other .NET languages do not -- and the rest
of the Microsoft teams understandably want to move fast on all the initiatives
surrounding .NET Core.

This results in the Microsoft F# team and the F# community contributors
playing catch-up. Eventually F# will catch-up, but it is going to take time.

~~~
TensorMetric
Microsoft's own .NET Native runtime is simply not .NET compliant
[https://news.ycombinator.com/item?id=15007166](https://news.ycombinator.com/item?id=15007166)

This is unacceptable and should be fixed ASAP. F# is a mature language
existing for more than a decade, there is simply no excuse to let this slide.

~~~
jackfoxy
Microsoft had to fix the C# compiler. The result was Roslyn. It's actually
amazing that Roslyn was a successful project. Probably most software projects
that ambitious fail. The project would have failed if they tried to make it F#
compliant at the same time.

Speaking as someone who makes his living writing F# code, I'm as frustrated as
anyone about this, but there will be a successful resolution. I just don't
know how soon. Before today's announcements my personal thinking was that it
would be this autumn. That's still possible. In the meantime I can still
function in the F# world, as before. It just remains frustrating to branch out
into some of the areas I would like to.

~~~
TensorMetric
If it's going to be fixed this year, then why isn't it even on the official
road map?
[https://github.com/Microsoft/visualfsharp/issues/2400](https://github.com/Microsoft/visualfsharp/issues/2400)

~~~
jackfoxy
You're absolutely correct about .NET native not being .NET
compliant...sigh...there are just higher priorities for such a big company. As
quoted in the comments " [F# native support] depends on the Core CLR team
improving support for a couple of big items. dotnet native is and AOT
compilation are absolutely a goal for us ... they just are longer term than
this roadmap anticipates."

It's actually eye-opening how few the number of people at MS who actually
write code is. I suppose if there were more coders they would be stepping all
over each other and never get anything done.

~~~
pjmlp
Politics more likely.

------
dvfjsdhgfv
Does someone has some experience running .NET Core on Linux? Any
problems/experiences you could share?

~~~
manigandham
We've been running high-traffic production services for months, everything's
been great. Leaner faster apps running on smaller, cheaper Linux VMs and
containers. No problems encountered.

For running typical webapps and services, the existing .NET APIs were already
good enough and now we have pretty much everything else available.

------
adrianlmm
I find weird that Asp.NET Core 2.0 was announced before .NET Core 2.0

~~~
terrajobst
All within hours. Basically, they all shipped at the same time. Blog posts
were manually published. There is no order implied.

------
pi-rat
\- CI/CD support for containers

Anyone know what that's about?

