(Part 2) Top products from r/dotnet

You sound exactly like me 10 months ago. I also took the plunge, moving from PHP/MySQL to C#/.NET. Keep in mind that I am not a .NET veteran, but I have gone from knowing nothing to developing all of my sites in it in just under 10 months.

• Object Oriented is a big part of it. If you know this from Java, great. If not, start there. I recommend Head First Object-Oriented Analysis & Design
  
  
• MVC - if you have used a PHP MVC framework you are going to have a much easier time of it. I did not, so I had to learn MVC, OOP, C#, and .NET all at once.
  
  
• Wrox ASP.NET MVC3 has been invaluable. My copy is covered in sticky notes and highlighter after reading, and I refer to it heavily.
  
  
• I just bought Pro ASP.NET MVC 3 Framework, and it also seems good, however, I like the Wrox book better.
  
  
• Pluralsight.com - A little pricey at $30 / mo, but they have a plethora of extremely high quality videos. If you have enough free time to make use of the monthly subscription, I do recommend it.
  
  
• When you come to databases, I highly recommend going the Entity Framework route. Most other things seem like garbage by comparison in my limited experience.

I think you partially need to decide what area you want to focus on. Generally if you're going to delve into more advanced materials they should also be geared towards the in depth aspects of a specific technology, methodology, or problem.

I'll add a +1 for the design patterns suggestion. The Head First book is an option, but here is the book that I've got that is quite good. There's always the gang of 4 book, and although it is the "design patterns bible" its also a bit dry.

I'm also going to suggest Mark Seemann's Dependency Injection book. Although it is about DI and inversion of control containers, he also really focuses on SOLID design that makes DI more effective.

If you don't know what SOLID design principles are, then I'd brush up on that.

Turning specifically to C#, there's Jon Skeet's C# in Depth and also Jeremy Richter's CLR via C#. Both are great books are focused on roughly the same thing, understanding some of the inner workings of of the C# language, but they each approach it in a slightly different way. Although the CLR book came out before, C# in Depth seems to be a bit more highly regarded. I'd take a look at the TOC of each and see which one interests you more.

Outside of that, I'd say make sure that you really understand concepts like generics, reflection, and maybe even dive into understanding some MSIL.

Given your understanding of the problem with Js/React, I'd dive right in to C#/.NetCore. You're aware of potential pitfalls and confusion of language vs framework, but there's probably not a lot of avoiding it anyway. C# is fairly straight forward for the most part. .NetCore is fairly dominant now so starting with it makes sense.

You could start with this book if you wanted:

https://www.amazon.com/Programming-Language-Covering-Microsoft-Development/dp/0321741765

Its starting to show some age, but it is where I started. It does do a good job covering stuff like value vs reference types, nulls, basic operators, special types like string, structured exception handling, etc. that could be valuable, but you can probably infer most of it if you have learned any sort of OO before. There's some stuff in there that's simply out of date, and glaringly no coverage of async/await. There are a bunch of newer language features such as string interpolation that may be better or more accepted ways to handle things these days.

edit: this is also popular, but still only up to date on C# 5.0:
https://www.amazon.com/C-Depth-3rd-Jon-Skeet/dp/161729134X

I own all of Robert C. Martin's books, except for UML for Java, as well as Martin Fowler's Refactoring (the white one), PEAA, DSL and Analysis Patterns. I also have Refactoring to Patterns, Code Complete and Design Patterns (aka go4) and a few others.

I would suggest Refactoring to Patterns is the one you are looking for, but that expects you have a working knowledge of what the patterns are already (likely with your experience though you may not know them by name). I don't think that is strictly necessary but it will help you understand why you might want do do things the way being suggested in the book. The examples are in Java, but they apply to C# just as much. His site is here: https://industriallogic.com/xp/refactoring/ and he has the code up behind an online course / paywall (I have not looked into this).

In a greenfield environment, tdding up an application from a blank project Uncle Bob or Fowler's pattern books are probably better, but from the perspective of an existing codebase I think Kerievsky's Refactoring to Patterns and Fowler's Refactoring are best.

Hahahaha. Indeed I am. :)

I still have my original Pro ASP.NET MVC 1 book on my bookshelf: https://www.amazon.com/Pro-ASP-NET-Framework-Steven-Sanderson/dp/1430210079

What was remarkable about this book was it covered:

• MVC
  
• Dependency Injection (IoC containers)
  
• Unit Testing and TDD
  
• n-tier Architecture
  
• ORMs
  
  All in 1 book in a current and relevant topic. It's one of the best books in software engineering that I've ever read. And the irony is that it wasn't trying to be a software engineering book, but the author did a really great job of covering all the bases well.

As a personal choice I'd recommend Essential C# 6.0. I purchased this a month or so ago and since then I've found it to be an excellent resource. The examples are clearly explained and references are also made to previous iterations of C# where applicable. I've certainly found it to be a great learning tool.

https://www.amazon.co.uk/Essential-6-0-Addison-Wesley-Microsoft-Technology/dp/0134141040

For learning, I use plural-sight courses and/or use specific books.

This seems like a good course Outside-In Test-Driven Development. You can sing up for 10 days trial and see if you can learn something from it.

This is also good book Growing Object-Oriented Software, Guided by Tests Paperback– Oct 12 2009

by Steve Freeman (Author), Nat Pryce (Author). But it's bit outdated with the project and technology. The key concepts is there which is get a walking skeleton done and than use TDD to add features and refactor along as you go.

Also don't get bogged down with details in the beginning; otherwise it will be never end journey. Before you try anything you should ask your self how is going to help me be a better developer.

I am not sure what your experience level is so can't say much.

​

While reading this book I've found the website from the authors of this book which has some tips on how to make a good resume, and they also offer a resume review service, but I personally haven't used that so far, so no comments on that one. I also find these tips from ex-googler and ex-microsofter pretty useful. But I'd also like to hear some experiences from anyone who used those resume writing services, my experience is getting close to 10 years and I'm starting finding it a bit troubled to highlight everything important in one-two pages.

If you are open to it, here are a few good reads to help you on your way. The legacy code book may pay dividends quicker given your situation.

Clean Code: https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_apa_ruhyybGGV0C34

Refactoring: Improving the Design of Existing Code https://www.amazon.com/dp/0201485672/ref=cm_sw_r_cp_apa_gwhyyb1VRNSKK

Working Effectively with Legacy Code https://www.amazon.com/dp/0131177052/ref=cm_sw_r_cp_apa_0whyyb3Y604NJ

Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler)) https://www.amazon.com/dp/0321601912/ref=cm_sw_r_cp_apa_JxhyybA08ZQF8

There is book "Reactive Messaging Patterns with the Actor Model", also

just to share nice general talk by Vaughn Vernon about Actor model.

And follow up to OP question:

"Can anyone recommend some simple library to implement DDD events?"

AKKA .net or Orleans are very powerful but seem like overkill for this purpose...

This site is ok: http://wpftutorial.net/Home.html
WPF by Adam Nathan is the best book out there: http://www.amazon.com/WPF-4-5-Unleashed-Adam-Nathan/dp/0672336979/ref=sr_1_1?ie=UTF8&qid=1450973915&sr=8-1&keywords=wpf

I know you probably want something free. Unfortunately, I didn't find anything very useful. As a git user myself, I just purchased this: http://www.amazon.com/Professional-Team-Foundation-Server-Programmer/dp/1118836340

Robert C. Martin, a.k.a. Uncle Bob, initially wrote a book for Java (2002) before the C# (2006) book was written. The only version he seems to maintain, or at least I can find links for on GitHub, is Java.

The book has helped me understand concepts, and most consider Uncle Bob one of the essential authors of computer programming. The C# book has code throughout, especially Section 4, but I cannot find a downloadable source. You'd have to input by hand, page-by-page if you wanted the complete system.

This one helped me a LOT: Inside the Microsoft Build Engine: Using MSBuild and Team Foundation Build

I used it last year when I was in the process of putting together a build-time rebranding and configuration system for a project I worked on, and it was extremely helpful, especially the sections on batching.

And then read Javascript: The Good Parts which will tell you the subset of js that is actually sane.

WebForms and MVC are pretty different.

If you want to get a low level view of how the webforms framework works (instead of just rote memorizing stuff) I highly suggest picking up a book like this:
http://www.amazon.com/Developing-Microsoft-Controls-Components-Pro-Developer/dp/0735615829/ref=sr_1_2?ie=UTF8&qid=1376688466&sr=8-2&keywords=custom+server+controls

There are a few. Any of them should work. Once you understand how custom server controls are made, the lifecycle of controls, how the controls make it out to the output stream and the lifecycle of the page; everything else (in webforms) makes sense much more quickly.

It's uncommon to start with custom server controls early, but it will be a massive help when you're debugging problems that don't make sense.

http://www.amazon.com/Functional-Programming-Techniques-Projects-Programmer/dp/0470744588

A few more resources that I own;

https://www.amazon.ca/ASP-NET-Core-Razor-Pages-Beginners-ebook/dp/B0772SL5VJ

https://www.amazon.com/ASP-NET-Core-High-Performance-applications/dp/1788399765

www.pluralsight.com

https://productivedev.com/

> You might adopt new things, but you're not adopting new ideas.

Bad ideas? No.

> Even Visual Studio doesn't work that way anymore and it's moving to more processes,

Yes, that's why the VS 2015 performance is much better than VS 2017 on the same hardware.

> For a dozen reasons, including security, performance

Can you elaborate how the split to multiple processes improves the performance? To create a new process is very expensive operation, compared to a new thread. The same with sharing data across processes versus threads. There is no benefit.

Process isolation can "resolve" poor code quality when a buggy code is more isolated. Again, it isn't any improvement, just a poor fix of having more incompetent developers on the board :-/

> When you're using synchronisation primitives you're doing message passing via shared state, and every time you hit one your code becomes synchronous.

No, you don't understand basic things. Recommended reading Concurrent Programming on Windows