I am researching about .Net core and when i saw that "It's easy to use async/await with .net Core" as a plus point.Still I could not find any reason whats different between .Net and .Net Core async methods,Can someone explain it here please
There is nothing in .NET Core that would make it easier than full Framework to use async/await, because that is a language feature, not a framework feature.
I cannot comment on the random article you may have read. Maybe it was mistaken, maybe it compared .NET Core to non-.NET, or maybe it compared it to older versions or maybe it talked about ASP.NET Core which is not (necessarily) .NET Core, but rather the new version of ASP.NET.
Related
.Net Core version (2.0+)
.Net Framework version 4.5+
, Visual studio 2019
Currently i have an issue where the UI is made in .Net framework but the back end code is currently in .net Core.
I looked at standard and it looks like .Net core can reference standard but not the other way around.
Aside from converting the UI to Core or the backend to .Net framework. Is there a way around this issue?
Currently the two (.net framework and core) do not communicate with each other.
What i have is a .Net framework legacy monolith application, which has been revamped in core (but no UI). In the future we'll go web/ cross platform but temporary we'd like the new core code to connect with Desktop Ui as the UI is going to take some time to complete.
Regards
Unfortunately this will not play out exactly as you hope for.
First of all, make sure your projects are targeting .net Standard.
Second, check out this blog here. Theres a matrix of support and compatibility.
Good luck on your endeavor!
We are going to create new application using Web Forms and we want to know when Web Forms (ASPX pages) Technology going to be obsolete or not be supported from Microsoft.
https://dotnet.microsoft.com/platform/support/policy/aspnet
So WebForms is part of .Net Framework.
https://learn.microsoft.com/en-us/dotnet/framework/migration-guide/versions-and-dependencies
“.NET Framework 4.8 is the last version of .NET Framework. .NET Framework is serviced monthly with security and reliability bug fixes. .NET Framework will continue to be included with Windows, with no plans to remove it. You don't need to migrate your .NET Framework apps, but for new development, use .NET 5 or later.”
So it's baked into Windows at this point if you want to use it. Everyone will discourage you from using it, as you are essentially mastering out-of-vogue and increasingly obsolete technology, and maybe not doing your career any favors. But if, like me, you have some huge WebForms app for which there is no time nor money to rewrite, then you can at least rest assured that it will continue to run on Windows.
Microsoft will be continuing to support ASP.Net WebForms for some time to come since much of it's functionality is based into the core .Net Framework. There are several locations to get information on which ASP.Net features/technologies such as ASP.Net MVC 4 will be going out of support soon. https://www.asp.net/support lists many of the technologies. For ASP.Net Webforms, it's tied to the Framework versions as best as I understand. https://support.microsoft.com/en-us/lifecycle/search?alpha=.net%20framework
Support policy for ASP.NET is documented here: https://dotnet.microsoft.com/platform/support/policy/aspnet
I am reading an ebook about Docker and Microservices. It referred the .net core was lightweight compared with traditional .net standard.
I don't quite get the story behind it. Can someone give some explanation about this?
This is because .Net Core is optimized for microservices and dockers.
In short, .Net Core doesn't offer as many things as another classic implementation of .Net Standard, reducing its size which even allows for an app to be packaged with all dependencies (and so not needing any installation of .Net on the running machine). This is why I think it could be called lightweight.
See :
https://msdn.microsoft.com/en-us/magazine/mt842506.aspx
https://learn.microsoft.com/en-us/dotnet/standard/choosing-core-framework-server
About light weight of .net core app
I am reading an ebook about Docker and Microservices. It referred the
.net core was lightweight compared with traditional .net standard.
I think here you are referring to .net core is lightweight than .net frameworks as .net standard are just API specifications for implementing base class libraries by different frameworks.
Please refer to below link for more information:
https://www.infoq.com/news/2017/10/dotnet-core-standard-difference/
https://medium.com/wolox-driving-innovation/net-core-vs-net-framework-a694f1fbdb26
Now coming back to why .net core framework is lightweight .net 4.5 or other frameworks as it's modular. When you create or run an application you don't need to install all dependencies which you do not need unlike .net 4.5 or other frameworks where everything is installed.
Basically, .Net framework has been split into individual pieces implemented using CoreFX for .net core framework which makes .Net core lightweight.
Link for details - https://www.tutorialspoint.com/dotnet_core/dotnet_core_managed_extensibility_framework.htm
I was looking for possibilities for porting some web projects from Windows .NET framework to Ubuntu linux using open source .NET core
After a lot of struggle with Mono, which I have almost gave up. I was looking at .NET core as a new hope. Have anyone of us ported from .NET to .NET core?
If yes, can the possible problems like the ones I faced with Mono be shared?
Moving from .NET to .NET Core is a huge move, especially if you're going to take advantage of Core. There is not currently a one click port, and I doubt you'll ever get a one-click migration like migrating from a VS 2013 project to a VS 2015 project. The entire startup flow is different, and to automate switching to that would be incredibly difficult. For now, the way I am looking at it is that moving to .NET Core is essentially a rewrite. As to whether that is worth it to you for your project - well that's really hard to say and also probably not well suited to that site.
That said, if you do rewrite you can probably bring along a lot of your business logic. You just will need to redo a lot of the other structure.
There's no easy way to move a project from .NET Framework to .NET Core. Possibly you'll need to rewrite or start from scratch.
There are some major differences between two
Format of configuration files (web.config vs appsettings.json)
Used libraries
Startup files (Global.asax vs Startup.cs)
Lack of static objects in .Net Core. Like Session and Application
objects - which is a good thing btw.
Many of the .Net Framework libraries are dependant on
app.config/web.config files
I Was just reading this post: http://blogs.msdn.com/b/dotnet/archive/2014/12/04/introducing-net-core.aspx
It left me a bit confused since the first picture in the article seems to imply that .NET desktop apps and ASP.NET don't share the same framework implementation. I was always under the impression that it was. Any ideas?
They use the same .NET framework.
But they don't have to. And this is the way the .NET ecosystem is evolving right now - ways to avoid using the full (ever growing) .NET framework for everything.
As a bonus, the new .NET Framework Core is open-sourced. This is not entirely posssible with the whole .NET framework, since it includes a whole lot of licenses and proprietary technologies.
Given all that, it's now possible to deploy very light-weight web applications using ASP.NET, not even having to use IIS (thanks to OWIN). You only have to include the packages you need - instead of having a single monolithic runtime and BCL, there's hundreds of NuGet packages you choose to use (or not).
You will have to better define "the same framework implementation", as they (full .NET Framework and .NET Core) are built from the same code base with different configuration, and also host your web applications in a slightly different way.
The most important getaway of that article should be "ASP.NET 5 can run on both .NET Framework 4.6 and .NET Core 5". You get different benefits from each runtimes,
.NET 4.6 gives you best compatibility against previous .NET runtimes.
.NET Core 5 gives you flexibility on running multiple customized DNX side by side, and portability to Linux and OS X.
Unfortunately Microsoft decides to limit desktop apps to .NET 4.6, but Mono guys have demonstrated possibility to run some (such as WinForms apps) on .NET Core,
https://github.com/akoeplinger/mono-winforms-netcore