What are /r/dotnet's favorite Products & Services?

From 3.5 billion Reddit comments

You can check the Speeding up ReSharper article for some tipps to fix slow downs. Especially disabling anti virus programs for the ReSharper cache improves performance a lot.

Besides that, you can also check out Rider, which has ReSharper as back end and IntelliJ as front end.

Ignore .NET Framework. .NET Framework just means old.

.NET 6 is just the next version of .NET Core. It doesn't "replace" .NET Core since it is .NET Core. They just dropped the "Core" suffix since there's going to be one .NET going forward.

MAUI is basically the next iteration of Xamarin.Forms and you can migrate Xamarin.Forms apps to MAUI (https://docs.microsoft.com/en-us/dotnet/maui/get-started/migrate). While you might need to make some changes to upgrade from Xamarin.Forms to MAUI, it's likely to be less painful than many communities make upgrading to new versions.

Basically, you use .NET 6. Xamarin.Forms is the stable library that's available, but there is a preview of MAUI that you can use or you can upgrade a Xamarin.Forms app to MAUI later. Xamarin.Forms and MAUI are both just libraries and there are other libraries as well like Uno (https://platform.uno).

In other ecosystems, this exists too. With iOS, there's SwiftUI and InterfaceBuilder. For desktop development, there's Gtk+, Qt, Electron, etc.

.NET 6 is where all the current/future of .NET is.

MAUI is a cross-platform system for building UIs, but there are others in .NET or in other languages (like Dart/Flutter or Kotlin/Jetpack). MAUI is a re-branding of Xamarin.Forms as well as a major upgrade.

Read Clean Code and The Clean Coder to produce higher quality code and be a better software professional.

Learn about design patterns and architectural patterns to produce software that is easier to maintain and extend.

Learn about proper testing; practice TDD and BDD, so your software has fewer defects and actually aligns with what your customers need.

Learn a couple of new languages; given that you know C#, I’d recommend F# and something like Python.

Improve your soft skills, so you can collaborate more effectively and communicate better with people outside the dev organization.

Learn about best practices in non-functional requirements, such as security, monitoring and performance.

Learn about different paradigms, such as event-driven architecture, or the actor model.

Never stop learning new things, even if you don’t intend on immediately using them. Awareness goes a long way.

These are just some suggestions.

“A long descriptive name is better than a short enigmatic name. A long descriptive name is better than a long descriptive comment.” ― Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship

Naming convention should be preferred over comments. A class with clear naming is more readable then a class full of comments.

I'd also like to add, if a method requires comments it could be a code smell in that the method may be doing too much.

Good read. The part where they await long calls inside a foreach loop is a common mistake. For everyone here I recommend reading this 100 page book:

https://www.amazon.com/Async-5-0-Unleash-Power/dp/1449337163

It gives you a better idea on what async/await does, and how to use it effectively without having to read Stephen Clearly’s huge book.

Hey OP - I know this is the worst kind of advice because you didn't ask for it, but I think you're going down a dangerous path here. It looks like you're implementing your own cookie based authentication system and storing sensitive information in plain text in the cookie. This is dangerous because it's trivial for a user to manipulate the cookie and do nasty things like potentially escalate their privileges in the application.

I'd recommend you take a look at ASP.NET Identity or [Forms Authentication](https://msdn.microsoft.com/en-us/library/ff398049(v=vs.100\).aspx) if you're looking to implement authentication. Security is worth doing right the first time.

edit: fix URL

Non AMP link:

https://auth0.com/blog/implementing-nanoservices-in-aspnet-core/

I don't know, you can scale microservices in cloud just as easily as these nanoservices. Not sure I see the point in them

> How to handle Authentication?

Do yourself a favor and pick something pluggable that can evolve with you, supporting both API consumption and web applications/apps. Do you already have a user database with passwords? If so I’d look at https://github.com/IdentityServer/IdentityServer4

If not let someone else handle the heavy lifting like https://auth0.com

This isn't the size of the package. It's the number of times it has been downloaded.

The package is only 141.65 KB. See https://www.nuget.org/packages/Microsoft.Extensions.Primitives/6.0.0-preview.7.21377.19

But the required .NET Core 2.0 is not. :P

https://www.microsoft.com/net/download/core

edit:

To elaborate, because some people (caugh*anonveggy*caugh) don't know/get it.

In order to use the ASP.NET Core 2.0 framework you need to have a runtime that implements .NET Standard 2.0 (an API specification). This is because this framework targets only .NET Standard 2.0. Currently the only runtimes that support this standard are .NET Core 2.0 (which is not yet released), or .NET 4.6.1 with a new tooling set (which is not released either).

So while ASP.NET Core 2.0 is released, there's no way to use it yet (unless using preview software). That's likely the reason why Microsoft made no announcement about this yet.

Setting up your own NuGet server would be perfect for this and allows for versioning. Bung your business logic, etc in to packages. Then you'd simply reference your packages across your solutions.

Check out this article: http://www.codeproject.com/Articles/872230/Create-Your-Own-Private-NuGet-Server-in-Windows-Az, ignore the deploying to Azure bit.

Do you have the .Net Core 2.0 SDK installed? If you have VS 2017, it should already be installed along with it, but if not, you can download it here.

You'll also need nodejs (but only for NPM.)

Once you've got all of those, you can instantly bootstrap a complete ASP.net MVC SPA with Angular2+ by running dotnet new angular at a command line.

Seriously. It's magic.

The big difference between .NET and PHP is the forced OOP. That might be the thing that might annoy you at first, but you should really just try to accept it and use it to your advantage. It can be quite overwhelming getting into ASP.NET at first, but once you get under its skin, you will question why you even bothered with PHP in the first place. The performance of ASP.NET is excellent, and the database support, level of abstraction and tooling is vastly superior. The added bonus of doing ASP.NET is that you're using a language that isn't strictly web-only; once you've learned C# you can apply that language to basically anything you want (even for performance-critical tasks and games).

ASP.NET MVC is pretty straight forward to get into; just start up a new Web Project and let the wizard create a starting template for you (it will contain basic html, controls and models which you can explore). There are tons of videos, tutorials and introductory documents on http://www.asp.net/.

> So I have been thinking about the Microsoft stack in general. Now, every place I have worked at has been a LAMP environment and there has been this stigma attached to Microsoft development that I have a hard time shaking. They always referred to Microsoft environments as high class corporate suit environments.

One thing that rarely gets disclosed is how much easier it is to work with the Microsoft stack in general. Things are actually designed to work together, they're not hacked together with superglue and duct-tape which is more often the case in Linux environments (shell scripts taking output from a shell command, running it through a regex parser and then sends that information in as parameters to another program.. Just the thought of that type of pipeline makes me feel nervous)

Why would we use his coding standard when there’s already a book of coding standard from the people behind .net ?

https://www.amazon.com/Framework-Design-Guidelines-Conventions-Libraries/dp/0321545613

https://player.fm/series/the-net-core-podcast/corewf-with-dustin-metzgar

​

Fast forward to 20:40

​

This information has been leaking out in podcast interviews for a while now. I am trying to find a secondary source in a .NET Rocks podcast from a few months ago.

​

I kinda figured that this would happen when it was announced that WPF and Winforms were coming across. The use case for Framework really was diminished by that decision.

I use LinqPad for that. You can suck in your DbContext and write queries to your hearts content. Add in the Query Plan Visualizer and its a nice little workflow for not only testing to ensure the SQL generated isn't 100% hot garbage, but seeing if the SQL generated plays nicely with existing indexes and the such

In case you haven't seen it, Bootstrap has a migration guide on their site https://getbootstrap.com/docs/4.0/migration/. Does not explicitly mention jQuery or Popper versioning though.

If you're running in windows, you can use Task Manager. If you add the Command Line column to the Details tab, it will show you which app that dotnet.exe is running.
Show Command Line in Windows 10 Task Manager

I'll agree with the other comments and say Core. As someone who did this earlier this year, the advantages, at least for me, where far too much to not do it.

Firstly for Razor Views the ability to have ASP HTML Tags allows for much greater code generation and readability, which in my opinion is a huge step over writing @Html.ActionLink and instead being able to write "<a asp-for=..." is just much, much more beginner friendly.

Also the cleaner IActionResult response codes in API calls is much easier to read and write, and follows the "Clean Code" conventions of really simple, sentence like code, and in my eyes is much cleaner than writing a manual return code. As far as I know this functionality did not exist in MVC 5.

Although, if you are going to be writing code for environments that use AD for authentication/authorization I would recommend staying back until the DirectoryService library is ported over in 2.0 (or so they claim it will be). If you need references as to why, I can provide you with it, but I don't want to throw too much at you for beginning this.

On top of all of this, assuming you will use EntityFramework Core, it is much faster than EF6, but lacks Lazy Loading (which I hated in the beginning but grew to love).

I go back and forth between Java and C# all the time. You are probably going to get absolutely zero out of Java training. Do a few code reviews with a seasoned Java developer on your team, and you'll get the idiomatic differences pretty quickly.

The largest nuisance coming from a C# perspective is the lack of properties and checked exceptions. There are some other interesting differences, for example plumbing with streams in Java is fun, but XML is a major hassle.

The cognitive dissonances between the two languages build character, promote plasticity of mind, and will give you better insights into both languages.

Also, check out Joshua Bloch's "Effective Java" book.

I think we need to watch this issue https://github.com/dotnet/aspnetcore/issues/26489 closely. As Identityserver 4 is in officially supported templates of Microsoft and used in the ApiAuthorization nuget package of Aspnetcore https://www.nuget.org/packages/Microsoft.AspNetCore.ApiAuthorization.IdentityServer

I am going to expect that the Aspnetcore team is going to build their own. As they already had plans to do this for long but went for a community package because it was used a lot. Well that's not the case anymore atm.

> Webforms creates a strongly typed object model representation of your view.

This is actually easier to do in MVC in my experience.

> Why are people using relatively complex server-side algorithms in the cshtml files (e.g. foreach)

I'm not sure I would classify 'foreach' as 'relatively complex' or inherently server-side. Obviously don't put business logic in you views, that goes for web forms as well as MVC.

> it lacks proper support for reusable components

This is just straight up FUD. Writing HTML helpers and utilizing Javascript libraries is far easier and leaner than writing monolithic aspx controls. There are dozens of light-weight, off the shelf, feature rich third party libraries that do an awesome job as well: like Kendo UI, and they are highly and easily customizable unlike aspx controls.

> The ASP .Net responds to user actions through Events. The MVC architecture uses the CRUD interface

MVC architecture does not inherently mean 'CRUD,' that is a common use but has nothing to do with the pattern itself.

> I strongly dislike the CRUD interface for thin client development

You prefer the anti-pattern in Web Forms that attempts to give state to HTTP instead of a RESTful style architecture for a thin client ?

> Push all the business logic and data formatting out to the Model and/or to a layer in between

This should not be some kind of revelation regardless of what framework you're using.

> CRUD is retarded

Compelling argument there, but CRUD != MVC

If you register for a Visual Studio account you get a monthly Azure credit (VM, hosting, db, whatever).

https://visualstudio.microsoft.com/free-developer-offers/

&#x200B;

It's all I've ever needed for POC and "interview / learning" projects.

> Read Clean Code and The Clean Coder to produce higher quality code and be a better software professional.

And then read Agile Principles, Patterns, and Practices in C# by Robert Martin

And then buy & watch Bob Martin's Clean Coders videos

And then send cash or money order directly to Uncle Bob

Praise Be to Bob.

If the templates are similar enough, you could attempt a Git rebase. First create a new branch pointing to your original commit with just the template code. Then delete everything, create the new template, and commit. Next, do git rebase branch_to_rebase. You may need to fix merge errors during the process. See the get rebase documentation for more information.

VisualSVN Server is a free windows-friendly subversion server.

VisualSVN is a visual studio extension that integrates with svn (not just VisualSVN Server) and makes the general experience enjoyable. Free if computer not part of a domain.

Which flavour of caching do you need? What you're looking for might be here.

This is now in the System.Runtime.Caching namespace and package, as caching is useful outside of web.

TinyMCE is extremely powerful and used by many of the larger CMS systems (WordPress for instance). It is available as a Nuget package, works with jQuery very well. The only configuration change outside of turning on/off the features I wanted was to tell TinyMCE to XML encode the contents of the textarea in order to avoid the YSOD with 'Request Validation Errors' due to the HTML markup coming back from TinyMCE.

first you are going off a blog post from over a year ago to base pricing on. I wouldn't say he's wrong, it's just changed.

That being said, it has changed. Pricing for the entry level website is free - http://azure.microsoft.com/en-us/pricing/details/app-service/

Start here: http://www.asp.net/aspnet/samples/aspnet-mvc

Between the samples you find and the links to forums and MSDN based sources you should find plenty to get you started. You would also do well to read up on the MVC pattern in general

I'd say yes, but not directly. A lot of people are turning to a kickass library lead by Damien Edwards called SignalR

SignalR uses Web Sockets, and falls back to other compatible techniques for older clients.

It's awesome, use it. :)

"Controls" aren't really a thing in MVC; that's a WebForms artifact. While WebGrid does exist, it's not something Microsoft really cares about (last commit around April 2012), which makes sense as it isn't "the MVC way".

If you need a grid, you build it using plain old Javascript and HTML. If you want a ton of features out of the box, you just use a library. The best one I've found is datatables. It has an absolutely huge amount of functionality out of the box, and writing plugins is pretty straightforward too. There are a bunch of others out there too.

Redis can be set to do the following when you run out of memory and try to make a write that requires more:

• Return an error stating as much
• Delete the least-recently used key(s) to make room
• Delete the keys you designated to expire next, to make room
• Delete random keys to make room.

There are additional options atop those basic ones that give you a little more control. This page has a lot more detail.

We use redis extensively as our primary data store for our dotnet application so I've become a sort of defacto expert.

Thats not the source. That is an opinion article, with several crossed out statements probably from the assertion that .net is no longer supported. This could not be further from the truth, as "there is no end in sight for support."

This is the real source (for the author's article and my quote, both from the dustin metzgar): https://player.fm/series/the-net-core-podcast/corewf-with-dustin-metzgar

I have enjoyed using PetaPoco. It's simple and does its job and doesn't get in the way. This documentation for an earlier version gives a good overview of what it can do.

If I was going to build something today, I'd build on OWIN (katana). http://www.asp.net/aspnet/overview/owin-and-katana. Provides a nice abstraction that should allow minimum rework when vNext is released.

ASP.NET MVC uses routing which means that the address is really just pointing to a controller (maybe named HomeController?). Check the global.asax file in the root of the project. Edit: Meant global.asax, not .ascx

You might find Zurb's interchange javascript library interesting for what you are trying to accomplish. Done client side instead of server side, but it solves the problem you are looking at http://foundation.zurb.com/docs/components/interchange.html

I generally found, once past very basics, Googling C# equivalent to Java <class/etc.>

ReSharper taught me a fair amount of more advanced areas as it often suggests alternative pattens e.q. LINQ to replace for loops

Working Effectively with Legacy Code by Michael Feathers has been incredibly helpful for me in similar situations supporting legacy ASP.NET apps. It's not specific to ASP.NET, but it should be very useful to you in general.

Definitely get up to speed with basic ASP.NET and understand page life cycle. It's drastically different than how MVC works.

>For example, I was looking for a diff library in .NET like Python's difflib but couldn't find it.

Just how did you look!? DiffPlex is one amongst thousands on nuget. I reckon, you looked extremely poorly for some reason.

As for the documentation being abysmal - could be, but I reckon,

• you exaggerate with "abysmal"

• it is more your expectations of where things should be than anything else. Basic reference is in the XML doc comments, libraries usually do have it. Readmes and basic examples are commonly on the github site of the package.

They usually record them and then make them available for future viewing.

Here are videos from 2014: http://channel9.msdn.com/Events/dotnetConf/2014

Here are videos from 2013: https://www.youtube.com/playlist?list=PL5i79H1f8hbezk9uLlorTmI7TypY56WF0

~~PdfSharp should get you there.~~

edit: The project I worked on that we did this I misremembered. We used Ghostscript.NET to open and rasterize the pdf.

Are you looking for something like hammock or RestSharp?

Edit - Don't feel dumb for asking questions. And don't ever let someone make you feel dumb with their answers or lack thereof.

Yes, I certainly believe that ASP.NET Core is slowly becoming more and more popular in startups. Below I'm attaching some links to prove the point:

1.) https://raygun.com/blog/dotnet-vs-nodejs/ 2.) https://www.ageofascent.com/2016/02/18/asp-net-core-exeeds-1-15-million-requests-12-6-gbps/

The first one is an Application performance monitoring software named raygun that moved from nodejs to asp.net core and the second one is a multiplayer online game named age of ascent that moved their whole backend server code to asp.net core. Plus Blazor is also maturing with time and it may become an alternative for writing single page applications in the near future.

There's this.

A couple of other alternatives are:

1. Integrated security - no need to store passwords in the connection string
2. Injecting the connection string as part of your build pipeline

Nearest MS equivalent is Web Api 2 for creating a web service only project. Create an empty web project and check off the include web api core option and you get a very stripped down project.

http://www.asp.net/web-api/overview/getting-started-with-aspnet-web-api/tutorial-your-first-web-api

YES. OH GOD YES. ASP.NET MVC is the accepted best route for new web application projects over webforms.

The article linked has absolutely zero logic implemented, its all prebaked, with little detail into how things work. He doesn't even show you how to add a controller method. Not to bash this blog, but a more comprehensive resource of tutorials would be http://www.asp.net/mvc/tutorials/mvc-5. Granted, the linked article is simply the first part and is theory heavy, so it might pick up in the next part.

MVC can get incredibly deep. You can add new web actions (called controller actions) that can do whatever you want, return any page, its a full fledged web application framework. This article does absolutely zero justice to the system, aside from how easy it is to start a new project (which you only do once in a while).

I use ASP.NET MVC with a C# backend, and add an extra MVVM, BLL and DAL layer to keep concerns seperate. I even customized how the user session is handled so I can have it hold extra data (by default only the user name is held). But i'll have to revisit my custom implementation with Identity claim based authorization is implemented into my project (a newer, more comprehensive security system).

It is worth just looking up some tutorials on Asp.net MVC, there are plenty.

But the basics are it is broken down into a couple of sections usually, models/controllers/views which are normally directories in a mvc project when you make anew one.

So a request comes in, tries to match the URL to a route which are normally set up in the global.ascx which will figure out what controller it wants then usually action is next in the URL, the action then will decide what view it will use, by default it tries to match a view to the name of the action, so /views/Home/index.aspx will be used, and the controller would be in controllers/HomeController.cs and in there is a method called index. Sounds like they have an controller/action of Home/index mapped to Home.aspx.

But then again the tutorials out there can explain it better then I can in a wall of text, try your start here http://www.asp.net/mvc/tutorials

Hey there, this is an intermediate topic and good luck with your voyage. I use Auth0 and it is really making things simple. It helps you to keep your code base clean BUT (this is a big “but” because it is important) you need to get your hands dirty first to understand stuff. Instead of a 3rd party, I would suggest you to create your own authentication to begin with. You can just use Basic authentication if you only keep it in your portfolio. Or you can go for an OAuth 2.0 flow if you really want to use it on production. I suggest JWT format and this is the best document I found for you in a similar scenario; https://jasonwatmore.com/post/2020/04/22/react-email-sign-up-with-verification-authentication-forgot-password#running-aspnet-core When you have this successfully, you will know what you want and need, then you can compare 3rd parties and go for an https://auth0.com/docs/flows/authorization-code-flow-with-proof-key-for-code-exchange-pkce

We run GitLab CE on Ubuntu 14.04 in a Hyper-V environment. Has a lot of features and installation and updates are a breeze. That is if you are open to a non windows solution.

https://about.gitlab.com/

Read "JavaScript: The Good Parts". That's the first thing I did and it helps knowing just how bad of a language JavaScript is, and of course the things that you can do to make it better. All the TypeScript suggestions are great too, or maybe Flow which is becoming more popular.

Using git aliases may take some of the tedium away if you’re working in command line.

Some tools will set up git aliases for you; such as oh-my-zsh’s git plugin.

What works for me is a DigitalOcean droplet preconfigured with Dokku (https://www.digitalocean.com/products/one-click-apps/dokku/).

Then you can push your .net core app, containing a Dockerfile, to the git repo on your droplet. Then Dokku handles all the build stuff. It works really well and it's el cheapo.

All in all, this is a cheap solution with a nice deployment flow.

https://www.nuget.org/packages/Microsoft.CodeAnalysis.FxCopAnalyzers

Set the rules that are important to your organization to "Error". Then you don't have to worry about manually checking for violations every time someone commits a feature.

That seems like a whole lot of unnecessary effort when you can just replace the session state memory provider with the redis provider.

https://www.nuget.org/packages/Microsoft.Web.RedisSessionStateProvider

What /u/grudolf said is correct. I would like to add that there is a nuget package called FrameLog https://www.nuget.org/packages/FrameLog/ that will accomplish exactly what you want to do and is EF friendly.

I have not used it but I read up on it and it seems fairly easy to incorporate into a project.

You can find a more extensive summary of some of this week's planned announcements regarding Microsoft and their movement towards a cross-platform and open-source world here.

Additionally, they are live-streaming the entire Connect() event here on Channel 9 if you are interested in following along.

Uno enables you to build native Android/iOS or WebAssembly apps using the UWP framework. Well, Xamarin also has a XAML-based UI framework (Xamarin.Forms) but that is another dialect of XAML. If you're already familiar with UWP, Uno can be a more natural choice. (As a matter of fact, if you target either of the native mobile platforms, Uno does rely on Xamarin. Xamarin makes available the platform functionality, over which Uno provides a UWP-compatible UI layer as shown in the diagram here.)

What I like the most about Uno is that it makes possible to develop my app as a regular Windows UWP app which can then run on the targeted platform with no or minimal modifications. The debug/test cycles are much faster this way as no emulator or real device is needed.

Yes - it is slightly different to VB in that you can create a list of objects read from database and tell Combo box which field to display - e.g. link

The powershell tools for AD are very strong. At the very least it can create easily consumable XML for the app to do stuff with.

I mean, yeah you can probably query AD directly, but the last time I looked at that, it was a comparative spaghetti mess. e.g. http://www.codeproject.com/KB/system/getuserfrmactdircsharp.aspx

I work for Premier Support in Microsoft, teaching workshops on Azure and MVC. This is the tutorial series on which most of my labs are based.

(Disclaimer, I do not officially represent Microsoft on Reddit.)

The ASP.NET vNext platform is going to be awesome. I'm already running some MVC5 applications on Linux via mod_mono, and running them without relying on apache/nginx will be even better.

I think you're grossly misinformed and you're a bit heavy handed on reprimanding "the DotNet Community" because of your ignorance.

MSDN has a ton of free content.

http://www.asp.net/mvc/tutorials/mvc-5/introduction/getting-started

Microsoft even has free video training.

http://www.microsoftvirtualacademy.com/training-courses/developing-asp-net-mvc-4-web-applications-jump-start

There is a ton of great content (free) out there...you just have to know where to look! (Or Google). Instead of coming out and demanding free content (and doing it in a condescending way), why not ask the community for links to free references. You'll catch more flies with honey, than you will with vinegar.

Auth0 has great documentation.

https://auth0.com/docs/quickstart/backend/aspnet-core-webapi/01-authorization

You'll also want to review their pricing page. If it's for a personal project you should fall into the free tier. If it's for work then I suggest reaching out to their sales team.

1. Use localStorage
2. (Usually) there are two tokens. One is the actual auth token, the other is a refresh token used to re-authenticate in case the actual auth token expires.
3. None? Use HTTPS and don't save it elsewhere is pretty much all.

Just install the .Net core SDK for your distro(downloads page has instructions for a few distributions). After that you can use visual studio code(free) or jetbrains rider(paid) for development.

​

You can follow the standard ASP.Net Core tutorials using the dotnet CLI to get yourself going.

That's really all there is to it believe it or not...

Strengths of .NET Framework for SaaS (Compared to .NET Core):

• Better support for Window's legacy components, libraries and languages (e.g. COM, and VB.NET)
• Preinstalled on Windows Servers
• Uses standard Window's administration tools to install and configure
• Better support for most Enterprise and third party Window's based systems and tooling (today, anyways)

Strengths of .NET Core for SaaS (Compared to .NET Framework):

• Better performance and scalability
• Side by side installs
• Self contained installs
• Cross platform
• Gets new features first (e.g. Span)
• Source code and issue support is available on GitHub
• Most new blogs, articles, documentation and books are being written for .NET Core

In general, for a new project you should be using .NET Core unless you are using technologies vital to your project that are only available when using .NET Framework. Its faster, it was designed for the modern web with features specifically for microservice and dense server hosting that the .NET Framework doesn't have.

The question of cloud based or web based deployment and hosting is kind of asinine to ask about before you have even decided what the goal of your software is. Its something that should be informed by system architectural choices. Trying to choose it up front is much more likely to get you to arrive at the wrong system composition.

If you are asking when to use each architectural style, you could try reading some documentation on the approaches. Microsoft publishes architectural guidelines and books that are a decent introduction.

Yes.

@ OP: Don't be scared of new languages and techs because they are new. Try them out, develop a quick spike, and decide based on experience, not fear of the unknown.

Have you considered going with the monthly option?

For the base version, it's only $12.90/month for the first year&mdash;which works out to $154.80/yr, so it's a bit more expensive than the yearly option&mdash;but the upside is that you can cancel it if you later decide you aren't using it enough to make it worthwhile. Paying $13/month might seem a little more tenable than the full $130 up front.

There are also discounts for uninterrupted years of subscription (20% after 1st year (~$123.84/year), 40% after 2nd year (~$92.88/year), which is still slightly more than the yearly purchase) and, if you stay subscribed for a full year you still get the perpetual fallback license.

I have been asking these kinds of questions recently, having been in the F# ecosystem commercially for 12 years now. The answer is complicated.

F# is going through some turbulence but the worst is (I think) now over. VS2017 was a disaster for F# and introduced a huge number of show-stopping bugs into the core tooling. Updates have fixed many but it is still quite buggy (I was playing with F# in VS2019 today and quickly found another bug).

The F# event scene has become fragmented across more events but the recent F# Exchange in London was apparently the largest ever with ~200 delegates.

Microsoft are investing in F#. For example, VSCode is obviously hugely popular right now but the F# tooling (Ionide) is lacklustre so Microsoft are paying the guy who wrote it to sure it up. I think that is a very good sign.

Finally, I'd note that we have a mobile app written in F# using Xamarin and it has worked very well for us. Our CTO is very happy with the tooling. I'm keen to do things with it that would be very hard to do in other languages.

On the other hand, I think F# is so tied to .NET that F# for client-side web is much harder than necessary so I'm working on a minimal ML dialect that is designed to run in the browser. Although it is a hobby project I may well end up porting it to native code on Linux using LLVM but that's a long way off...

Depending on your methodology you might be exactly where you need to be. If you are in a scrum or agile methodology if you can pull a task off the board and get it done. On my team our people who know all the systems have been here 13 years+ Most of them are not aware of the newer technologies.

It is simply not possible to master all of the technologies. I would recommend the book Code Complete which is language agnostic. If you have a pluralsight license give up a couple nights to follow shawn wildermuths classes on mvc/angular/bootstrap websites where he really shows how it all fits together. Pluralsight isn't free but in a month I will watch 40+ hours of training. I go a little crazy on it.

If you only do your coding during your 40 hours at work. You will never get to where you want to be. Meetings and other interruptions never actually give you 8 hours a day. 4 hours during work is a good day for me. If you do 2 hours a night of training/learning you will noticeably exceed your peers in knowledge. Not many people want to put in that work.

I don't think you should feel shame. The worst developers I have worked with have been those not yet crushed by the wave of the Dunning-Kruger effect.

Regarding learning material I have found that I end up helping others at work not with MVC or LINQ but with more primitive concepts such as basics of C#, how the CLR works, and WHEN to use things like LINQ. While I think learning some of the baseline buzzwords such as MVC are important for resumes and interviews I think things like Code Complete (maybe) and the CLR via C# (even with it's age) can have a larger impact on overall software quality.

The core package is out of preview / 1.0.0 as of Dec 1st - https://www.nuget.org/packages/Amazon.Lambda.Core/

Here's the release annoucement - https://aws.amazon.com/blogs/compute/announcing-c-sharp-support-for-aws-lambda/

To install, just do: Install-Package Amazon.Lambda.AspNetCoreServer -Pre

Power users won't want to use the GUI, it's just too limited in comparison to what you can do with <code>git</code>. But the GUI is still great for those who are not interested in using a shell and more power to them.

If you're looking for free VM software Oracle VirtualBox works great. I have only used it from a windows host though so your mileage may vary. I had a windows 7 VM and used it for years for development without any issues.

This helped me a ton. It breaks it down really well.

http://www.codeproject.com/Articles/1014588/A-Barebones-Implementation-of-the-MVVM-Pattern

Edit: to add to this. mvvm is really awesome, as well, if you want portable code. Like if you wanted to port your code from wpf to WinRT (universal apps) or even to mono c# as a Linux application. I try to keep these things in mind when I'm coding, to avoid as much UI code behind as possible and try to do as much UI logic in xaml as I can.

(Also makes unit testing way easier)

Why not use a Behavior ?

For .NET Framework 4.5, .NET Core 3.0, .NET Core 3.1 and later: https://www.nuget.org/packages/Microsoft.Xaml.Behaviors.Wpf/

For .NET Framework 4.0 : System.Windows.Interactivity namespace

Your Behavior is written in C#, attaches to an UI element, and acts on it. You then add it in your XAML. I'd use it on the TabControl.

If you need to use Data Binding, use Dependency Properties in your behavior.

It seems the Nuget package is still available to use.

As for the read-only state of the repo, the most likely explanation is that the repo owner is not able to do maintenance on the library anymore, so they made it read-only. It is not ideal, but at least now people know not to expect updates.

If this is a crucial piece of software to you, and you're willing to put in the time to maintain it, perhaps you can approach the owner of the repo and see whether you can take over ownership? I see their email address is on their alternate GH profile.

Elementary OS (your URL is wrong) isn't "built around" it. It's just a programming language, not a framework. Yes, most of their tools are written using it, but the underlying tech is GLib, GTK, and Gnome.

I've written some Vala, and it's okay, but it's only syntatically similar to C#. It's built on top of the GLib object system and uses its class library, compiles to native executables via an intermediate translation to C, and (at the time I used it, at least) doesn't support things like automatic boxing and unboxing. Ultimately, it's only useful for writing software in the GLib/GTK ecosystem.

Holy crap this page is doing stuff to my eyes.

http://azure.microsoft.com/en-us/services/documentdb/

Just try to read the text in the green area with the checkboxes next to it. Does the blue button seem to jump around under it as your eyes move?

Personally I use Durandal for SPA development; it's built on top of jQuery and Knockout, two libraries I'm very familiar with. Knockout can take some getting used to though if you've never used it.

Uno platform on webassembly has AOT for over a year already and their learnings apply to blazor. Xamarin.ios and xamarin.android also have aot since forever (not in wasm but the bundle size effect still applies) The end goal with AOT is not to do a full AOT because that increases the package too much, you generate a profile that finds what what is needed to aot and what is not needed, so you get the best of both world. uno platform aot

If we look at xamarin for example, they call profile guided AOT ‘startup tracing’ and they get 50% startup time gain with only 10% increase in package size. Experience may vary depending on your code but still gives a good idea.

it is very much needed to make c# on webassembly viable.

Yep - ASP.Net MVC. IMHO, the only way that you should be doing new development (if you're sticking strictly within the MS stack).

Oh, and make sure you're actually targetting Dot Net 4.5.2 or 4.6, as support for v4.0 ends in January.

I'd try finding some stuff on PluralSight and Microsoft's Channel 9. I just started working with EF and ASP.NET this week and it took me a while to get the hang of it, but I feel comfortable now.

The course is free on ASP.NET:

http://www.asp.net/mvc/pluralsight

http://www.asp.net/mvc

Started with the C# webstack myself. Very happy with my capabilities. I can confidently say there is nothing I can not build with it. More recently, I have applied my C# knowledge to making games (Unity3d). Its nice being able to apply the same logic client side and server side.

Why do you think Web Forms are going away? Microsoft indicates on their ASP.NET 5 overview page that Web Forms will continue to be supported.

http://www.asp.net/vnext/overview/aspnet-vnext/aspnet-5-overview#webforms

I just browsed over to http://www.asp.net/vnext and the ultimate guide and setting everything up from scratch guides were pretty good.

Its a fairly broad topic, is there a aspect you want to focus on or are you interested in every aspect of the stack?

Things like OWIN, NuGet, Dependency Injection, Front side compilation, portable class libraries, testability, etc. form the core and understanding these concepts will help when you look at the vNext stack and its motivations and design.

Here's a link for a decent C# Resource from the ground up, good for the fundamentals of the language and has interactive examples which compile and run without an IDE. so you can play with the code in the browser, and see the results. https://www.microsoft.com/net/tutorials/csharp/getting-started

It depends on what medium you get the most out of. I personally think physical books is just blah for retaining information. If you enjoy videos and get a lot from them, I would highly recommend one of the online video subscriptions. If you are really wanting to learn the front end side of things, an egghead.io or front end masters subscription are very much worth the money. Egghead is super short, straight to the point videos. FEM is more workshop-ish, and usually dives into the why/how/theoretical side of things. Pluralsight is also great.

There's also lots of free content out there too :). Don't think you have to spend money in order to get 'continued learning'

http://www.linqpad.net/

Linqpad will give you the resulting SQL query generated by your Linq query. It's a free tool, and $45 will give you Intellisense. Worth every penny, in my opinion.

Every product team makes its own choice about whether to offer a community edition, taking into consideration the market, the product position, the community, and tooling situation. At the moment, we aren’t considering a community version for Rider similar to IntelliJ IDEA or PyCharm. There are, however, some free and discounted complementary options available for Rider.

It depends on what you want exactly.

If you want a mobile browser friendly version of your web site you could use a css library/framework like Bootstrap, which could help you speed up the process of converting to a mobile friendly web site.

If you want a mobile app using PhoneGap/Cordova, you can still leverage your html and css. Look at a framework like Ionic. Doing an app this way would probably require you to change your backend to more of an API unless that's the way it is already.

It sounds more like what you want is a mobile friendly version of your site. As others have stated, that is just reworking your front end to be responsive or have a subdomain like m.yoursite.com. I prefer a responsive design over a separate site.

Good luck

Sign up for [Visual Studio Dev Essentials](https://visualstudio.microsoft.com/dev-essentials/). It's free and comes with 3 free months of Pluralsight. You'll find plenty of good videos on there if that's how you prefer to learn

git seems to be what most folks are using these days so you'd do well to learn it. The book should get you started - you probably only need the first chapter or two as the rest gets into crazy situations you probably won't be faced with (at least now.) I haven't used TFVC but if it's anything like earlier versions of MS source control, git will be much more pleasant once you get the hang of it. If you do decide to go with git, learn to use it from the command line. GUI tools are ok for merge conflicts, but really you should just do everything else from the CLI.

(I could be totally off base since I actually haven't looked at this one with any depth, or focus. So please do forgive me if I am really off the reservation with this.)

I think that that is the goal of https://code.visualstudio.com , isn't it?

The logic that they're using is fairly awful. For instance the number of jobs that they mention for C# has a couple of flaws:

1) They used a website that was talking about the UK only. Local job data does not always translate to global job data.

2) Every type of language specific position has gone down since 2013. I mean just compare C# to Java. Oh and I added F# for the heck of it. Nice to see it down there at 0%.

3) Big data is tiny on the job listing spectrum. Incredibly minute. We're talking less than 0.1%. Kafka at best comes in at 0.06%.

Then you go to the whole big data is the future theme and I've only run into a couple companies who have used that much information with any success. One was Jet and one was a cancer research company. Most people collect a ton of info and then have no idea what to do with it. Now the stuff that he says about .Net Core putting the OSS community into a holding pattern is correct. The rest is meh.

> Is it a way to do it once, then copy the schematic over to different installs?

You write a script. ALTER TABLE foo ADD FOREIGN KEY (…).

FYI

New Azure SDK libraries (those with namespaces starting with "Azure.") use System.Text.Json by default, and allow users to opt into custom serializers, like Newtonsoft. See https://www.nuget.org/packages/Azure.Messaging.ServiceBus.

Trying to popularize a library I've built and used on almost all my .NET projects in the past few years.

The article I wrote about it on codeproject (easier. Net settings) was well received (4.9 with 95 votes), but there was no public repo when I wrote it. Would love for people to review it, and contribute to it now.

It's basically a library for managing application state (e.g. window locations&sizes, last entered username... basically any data that's not domain data).

This library has made me love this requirement, and since I like it so much, I figured might as well present it to other devs and a) get oppionions and b) get myself some reputation points:)

I'd really appreciate people taking a look and commenting.

Thanks!