(Part 3) Top products from r/csharp

This is just my 2 cents, but the first thing you should be asking when learning any language is what problem are you trying to solve with the language?

C# as a language doesn't amount to anything, but it's real potential comes from the frameworks it is associated with.

​

If you're wanting to:

web develop then you would need to look into .NET Core + WebApi + MVC or a front-end framework (Angular, React, Vue).

This is a great course to get you started with. It'll create a basic web application you can modify and play around with from the database to the front-end:

https://www.pluralsight.com/courses/aspdotnetcore-efcore-bootstrap-angular-web-app

​

desktop development then look at Wpf (window presentation forms) or use electron and c#

mobile development then take a look at xamarin

​

from your use of Unity though, it seems as if you are more into game development which I would advise then to go a bit lower and really learn algorithms and good implementations. For this, there are some greats books you can use to help you get started:

Cracking the Coding Interview: 189 Programming Questions and Solutions by Gayle Laakman - Even though this is an interview book it's a great intermediate book to algorithms. The book does assume you have a basic understanding of elementary data structures.

The Algorithm Design Manual by Steven Skiena - This is definitely more advanced and heavy but it's a great book to really dig down into the nitty gritty

A great website for practicing writing algorithms in c# is leetcode.com. It's a site that basically lists a bunch of small questions you can solve with an in browser compiler that includes c#. This way you wouldn't need to download visual studio to practice coding.

if you're up for the challenege, then you can download a framework like SFML.Net and try to develop a game from the ground-up without using an engine like unity. But this is obviously a lot of work ;)

​

Overall it's hard to give really specific advice without knowing where you're trying to head. But it's a good time to get into c# and in general microsoft's development stack. In the past people were shoe horned into using microsoft's technology stack from top to bottom but recently microsoft has made a lot of stride in making there tech more open which is making a lot of people turn heads.


If you are also looking for a more lite-weight ide then I recommend visual studio code or vscodium which is the same but without the trackers :)

You didn't go into too many details, so I just wanted to make sure you weren't missing the things that make for a a foundation.

I think Domain Driven Design is a good path for you, mainly because it doesn't necessarily over prescribe a technology stack (those are in constant flux) and focuses on the fundamentals of designing for a domain and understanding how to deal with the complexities that come with it.

Eric Evan's book is a great place to start. Personally I have two other books that are incredibly helpful for DDD. The first is Implementing DDD by Vaughn Vernon, and the second is Patterns, Principles, and Practices of DDD. I think the second is a little more along the lines of what you're looking for, but doesn't go into as much of ideas and structures of DDD. What it does do is go into more of the patterns that you're far more likely to see in an enterprise application.

Two patterns that you should pay attention to are Command Query Response Segregation (CQRS) and Event Sourcing. CQRS can be used in a number of ways and incarnations. Event Sourcing may or may not be applicable in your application, but its useful to think of an application's state and interactions as an immutible ledger of events.

If you go down the road of microservices, then I strongly suggest you also explore message queues as well. Although they certainly are useful, microservices are seen as somewhat of a fad or buzzword. Message queues, and the patterns that go with them, are quite useful in this context and also applicable in more "traditional" service oriented architectures as well. A great book for diving into those messaging patterns is Enterprise Integration Patterns.

NoSQL and Big Data solutions will likely come up along the way, and although they are worth exploring in their own right, I think its important that they are implemented for the right reasons. I'll leave this here for now, if this is something that you want to explore further, I'd suggest reading through Fowler's Polygot Persistence as a good jumping off point

I bought something like 4 WPF books in 2008 or so because I worked for a WinForms controls vendor and they wanted to evaluate creating a suite of WPF controls. It's hard to say any one of them was "better" than the other, I often found myself reading at least two of them when I got stuck. Here's what I remember about how they compare:

• Petzold's 'Applications = Code + Markup' is what you would expect from Charles Petzold. It's a very nuts-and-bolts discussion that will give you deep knowledge. There are no screenshots, that turns a lot of people off. It was the first I read, I read it cover-to-cover, and I think it's exceptional.
  
• 'Unleashed' is the only one with color pictures, and it uses a lot of them. It doesn't dive into many things as deep as Petzold, but it was my go-to when I felt like I needed a refresher. It's a much quicker read, but definitely a good value.
  
• 'Programming WPF' covered a handful of topics that I didn't feel were covered in 'Unleashed' or Petzold's book. Its technical content lies somewhere between those two: it is deeper than 'Unleashed' but not so deep as Petzold's. That makes it an easier read than Petzold's. It was a good value.
  
• Several months after those, I bought Pro WPF 1st edition (now it's on its 4th edition.) This book covered a few topics none of the other three touched, but I don't remember anything remarkable about it in comparison.
  
  I can't really say any one of them is 'best', I think it's smart to get two of them. The more different they are, the better, because having multiple explanations helps.
  
  One sad thing is WPF hasn't been widely adopted, so you can't supplement these books by joining some random forum and watching people answer dozens of WPF questions. That's how I learned WinForms: I had about 6 books that taught me squat, and spent 2 hours+ per day on a .NET forum absorbing the answers to every question. I learned the most when I started trying to answer questions. Maybe StackOverflow's got active WPF questions, one 'downside' to it is duplicate questions get buried. Having a steady stream of newbie questions to answer is great practice, it's almost like a kata.
  
  Expect slow going at first, and expect to be a little frustrated. I still find it easier to start a new WinForms application. Somewhere in the middle of a largish project, I find WPF becomes more of a joy to use.

Here are my two recommendations based on what you're starting with:

https://amzn.com/1430249358 - Beginning C# Object Oriented Programming by Dan Clark

It's circa 2013, but that shouldn't matter too much. The point of this book is to get you understanding the fundamentals which haven't changed a bit in a while. I can't speak to the effectiveness of this book, personally (I came from C++, so for me it was more about learning how inheritance patterns in C# differed and this book wouldn't have worked for me), but I've recommended it to other people looking to get a start in programming and it has been well received. The goal with this book is to get to the point where you can read a serious book on C# and this provides that pretty well.

After that, head right over to:

https://amzn.com/1491927062 C# 6.0 in a Nutshell - by Joseph Albahari and Ben Albahari (O'Reilly Press).

I own every edition of the C# in a Nutshell series and have read each (speed reader - lots of skimming/scanning since each edition has a lot of repeat content). I'm a huge fan of the "in a Nutshell" books - the "signal to noise" ratio of these books is very high - they're excellent books for people who prefer/are best at learning via books - think of it as an "AP Course". It'll take you a while to get through (the last guy who successfully completed both took 9 months front to back at about 20 hours a week using a strategy that involved reading the book about 4 times [topic for another post] -- it was for a job, so he had no choice but to learn). When you're done, though, you'll understand a large percentage of C# code and be able to write many different kinds of applications.

From there, it's time to head toward the particular discipline you'll be developing most frequently with (ASP.Net MVC, etc) or target certain areas (multithreading/thread safety is usually a good place to go next if you have no particular target).

> What should I do now?

Here's what you should do: keep learning C# for now. C++ and C# are both form the C-family programming languages so when it's time to switch to C++ lots of things will feel familiar. When you are starting to feel comfortable with the language, install Unity and start learning about programming games while using your C# skills. C#/Unity will provide you with an awesome safe sandbox where you can experiment. Try creating small minigames like Snake or Tetris in the beginning and then try more complicated things. Also, at this point may be read Game Engine Architecture or a similar book. Learn about Scenes, game objects, entities, components, 3D math, meshes, shaders, animations, particle systems, etc. It will help you a lot to be familiar with all these concepts when you start working with Source.

When you are starting to feel comfortable with C# and Unity then start learning C++. The main difference compared to C# is that you will have to learn to be a bit more disciplined and manage the memory yourself instead of relying on a GC. Modern C++ (i.e. smart pointers) helps a lot with that but you should familiarise yourself with new and malloc also since Source is pretty old and I don't think it takes advantage of all the [not so] new [anymore] goodies in the standard. When you are starting to feel comfortable with c++, install Source and start working on that awesome Half-Life mod you have in mind! Looking forward to playing it! 😁

As others have mentioned, writing code is the best way to get exposure. But if you're a book guy like me then there are a lot of option out there that'll accelerate the process. You'd be insane to read all the following--these are just starting points that can accommodate different interests/tastes.

Having said that, I'll start with the one book that I think every C# developer should own:

Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries

... it's a good read, and it includes a lot of direct input from the designers of the C# and the .NET Framework. Microsoft has been really good about sticking to those guidelines, so you'll immediately get a leg up on the Framework libraries if you work through this book. (Also, you'll win a lot of arguments with your coworkers about how APIs should be designed.)

General knowledge books (tons to pick from, but here are some winners):

• Cookbook-style factoids: C# 6.0 Cookbook, 4th Edition
  
• But since you're coming from a lower level language, you might appreciate more details: C# in Depth by Jon Skeet (the Chuck Norris of C#)
  
• Scott Meyers-style content with good discussions of idiomatic C#: Effective C#: 50 Specific Ways to Improve Your C#
  
• CLR via C# goes deep into the guts of the language.
  
  Deep dives into specific features that'll serve you well:
  
  
• Concurrency in C# Cookbook is a good starting point to get productive with the TPL quickly, but I actually learned a lot more from the more prosaic Pro Asynchronous Programming with .NET.
  
• C# generics aren't as powerful as C++ templates, but Metaprogramming in .NET may provide some decent (though clumsy) workarounds.
  
  Note: I've never found a good LINQ book that supported how I actually use the feature. Coming from C++, you can probably just start off by thinking of the extension methods on Enumerable as a C# version of std <algorithm>... a good way to avoid writing raw loops. But if you're a performance-obsessed game dev then you'll probably want to use LINQ sparingly--it does have some overhead.
  

To add to the great answers you've already got:

*At its core Clean Architecture is about decoupling via very strict boundaries so that each component can be deployed separately. That's it, everything else is detail. Before you can fully internalize this, you have to become very comfortable with Dependency Injection. The best way to do it is the book https://www.amazon.com/Dependency-Injection-Principles-Practices-Patterns/dp/161729473X - it IS the last word on the subject.

*The most common violation of CA is referencing the ORM directly from the application layer. This is a simple dependency issue: your application is now no longer deployable independent of the ORM in return for being able to use all of its features. Abstracting the more "advanced" features of the ORM is a fool's errand, so this is a very clear tradeoff. There are applications where taking this dependency would be a huge mistake, and applications where it would be very beneficial.

*The "correct" way to design repositories is an orthogonal matter, but it does depend on whether you are taking that depency on the ORM. There are quite a few issues around that - lifetime of the session/context object (and how to manage it to deal with transactional integrity), using specification objects as opposed to method explosion on repositories, enforcing DDD aggregates by using repositories etc. There is good material out there - my only input would be ignore any discussion that revolves around generic repositories - I find that to be a useless abstraction and not what the repository pattern is about.

*Jimmy Bogard's vertical slice architecture would probably work best overall if you pushed all business logic into a separate domain layer leaving the command objects fairly thin. He heavily uses his MediatR library, which could be confusing because it's not really an implementation of the mediator pattern, but kinda sorta follows the same concept. It's basically a means of locating a command handler (from the Command pattern) for a command without explicitly injecting the command handler. For a one to one scenario it gets you nothing but it helps when you have more than one command handler running around for your business case

*As far as interfacing between the components, you want to make sure you are very clear about the terminology. The ports and adapters in all these architectures refer to two distinct concepts: primary and secondary. The primary port is the API of the component, and primary adapters are its clients - tests would be primary adapters, for example. The secondary ports are the interfaces the component exposes for the purposes of dependency inversion, and the secondary adapters are the implementations of those interfaces by the components you don't want to take a dependency on from the higher level components.

Clean Architecture formalizes this a bit more to this by prescribing the usage of Presenters, Controllers and Interactors. Interactors are in the higher level component encapsulating your use cases, while Presenters and Controllers are secondary adapters that handle output and input, respectively.

I'm not a C# expert but Illustrated C# is my required text for my C# class and I like it a lot. I am more of a Java Developer, but I also really enjoy C# and have found the way the book breaks everything down is really great. https://www.amazon.com/Illustrated-2012-Experts-Voice-NET/dp/1430242787

Now, all that said, there are various synchronization primitives that can be used, and there also some generic rules that you should always try to follow:

1. When using thread-affine locking primitives (such as a Mutex or a CLR lock), all operations inside of the lock should occur quickly.
   
2. In general, locks should be read-only - they should not change between accesses, or they may break synchronization
   
3. Many readers can safely access a data structure at the same time without risk, provided that those readers do not modify the data structure itself in any way (our hypothetical queue did not support this, because Dequeue did modify the data structure).
   
4. Others. You can spend years and years researching this.
   
   Primitives:
   
   
5. CLR locks (see the C# lock keyword)
   
6. Mutexes (thread-affine)
   
7. Semaphores (generally not thread-affine)
   
8. Reader/Writer locks (thread-affine, uses per-thread state)
   
9. Manual/Auto Reset Events (not thread-affine)
   
10. The CountdownEvent class (on .NET, can't recall if this is thread-affine or not)
    
    Anyway, this is probably the most detailed response I've ever typed to anything on the internet, so... I'll leave you with some recommendations.
    
    I think Jared Parsons summarizes the problems pretty well here and here.
    
    You can also have a look at Joe Duffy's blog. I'd also highly recommend his book Concurrent Programming on Windows. He discusses general operating systems concepts, some of which are specific to Windows, concurrent programming in C# and C++, and various other details... Really great read.

I thought Expression Blend 4 Unleashed was good.

If you're looking for WPF, and not Blend specifically, WPF Tutorial is a good place to start. I also found this book really useful.

I recommend this one. Great for all levels. Well written IMO.

Thanks, but this is one 7.5 hour course and does not seem anywhere near a complete path to being job ready.

I have a Udemy account and would buy Mosh's courses on Udemy if I thought that they would form a concise package when put together. I would supplement this learning with books if necessary - specifically the following:

https://www.amazon.co.uk/dp/0735619670/?coliid=I3G8SYORH393ZR&colid=1IRAIWB2MBRLH&psc=0&ref_=lv_ov_lig_dp_it

https://www.amazon.co.uk/dp/0132350882/?coliid=I1ZCBXMO9SV7S2&colid=1IRAIWB2MBRLH&psc=0&ref_=lv_ov_lig_dp_it

https://www.amazon.co.uk/dp/0984782850/?coliid=I1OZDYM4OMN8N7&colid=1IRAIWB2MBRLH&psc=0&ref_=lv_ov_lig_dp_it

But a course where everything fits together (such as a bootcamp I can't afford) is really what I'm looking for.

Ah sorry PEAA Is Patterns of Enterprise Application Architecture. I can't even spell four letter acronyms right :)

EIP deals mostly with gluing stuff together while PEAA is more within the boundary of the application (vaguely) :)

If you have never programmed before I would recommend you read this book first. it will make OOP easier to digest when learning c#

http://www.amazon.com/Object-Oriented-Thought-Process-Matt-Weisfeld/dp/0672318539

To answer my own oldass question, it isn't as deep as I would have liked but Metaprogramming in .NET by Jason Bock and Kevin Hazzard has some discussion of them and some other cool stuff. It's got more breadth than depth on most of the topics it covers though.

Albiet it's a bit dated:
https://www.amazon.com/Data-Structures-Algorithms-Java-2nd/dp/0672324539
But I really enjoyed the book.

I would suggest using the officially recommended 70-483 programming reference book and mostly a whole lot of Microsoft Docs (MSDN).

The book itself is definitely not enough for passing the exam though, you really have to practise and you will need to follow each and every 'link' in the book with more information on the internet.

These ones are good - and much newer:

https://www.amazon.com/Pro-ASP-NET-Core-MVC-2/dp/148423149X/ref=sr_1_6?ie=UTF8&qid=1550791644&sr=8-6&keywords=asp.net

https://www.amazon.com/ASP-NET-Core-Action-Andrew-Lock/dp/1617294616/ref=sr_1_7?ie=UTF8&qid=1550791644&sr=8-7&keywords=asp.net

You might want to take a step back and consider how this gets handled from a business perspective.

I assume payroll is currently being calculated - how are they doing it? The software you end up writing should be an implementation of the business domain, therefore the business domain should guide you.

I highly recommend Domain-Driven Design for learning how to have the business, domain, and technical requirements guide your design.

Also Essential C# by Eric Lippert and Mark Michaelis, incredibly smart people. Jon Skeet (C# in Depth) and Eric Lippert both have blogs you should follow and read everything they write. http://smile.amazon.com/Essential-Edition-Addison-Wesley-Microsoft-Technology/dp/0134141040?sa-no-redirect=1

For a good algorithms and data structures textbook take a look at: Algorithms 4th Ed. by Sedgewick and Wayne (https://www.amazon.ca/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=pd_lpo_sbs_14_img_2?_encoding=UTF8&psc=1&refRID=Y10M1BMYGCSJCJJN2GJT) or Introduction to Algorithms 3rd Ed. by Cormen, Leiserson, Rivest, and Stein (https://www.amazon.ca/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844).

I believe the edition you were seeing was the upcoming 2nd edition. The original edition is available here:

Exam Ref 70-483 Programming in C# (MCSD) https://www.amazon.com/dp/0735676828/ref=cm_sw_r_cp_api_i_LH6.Ab13WAKMY

If you want to learn it the right way, read this book. I warn you, it is deeply technical. But there is no better source.

https://www.amazon.com/Concurrent-Programming-Windows-Joe-Duffy/dp/032143482X

That or DDD Distilled https://www.amazon.com/dp/0134434420/ref=cm_sw_r_cp_apa_DogwzbS6XRA70

These are my recommendations:

• Microsoft Docs
  
• Pro ASP.NET Core
  
• ASP.NET Core In Action
  
• EF Core In Action
  
• Programming ASP.NET Core (good if you're coming from a WebForm background)
  
• NDC Conferences

http://www.amazon.com/Illustrated-2012-Experts-Voice-NET/dp/1430242787

Just to confirm, this is the one?

I found this book helpful when trying to learn how to move from writing procedural code to OOP code: http://www.amazon.com/The-Object-Oriented-Thought-Process-Edition/dp/0672330164

https://www.amazon.com/dp/032157351X/
https://www.amazon.com/dp/0262033844/

C# is not a popular language with academics who tend to write cryptic Java and C/C++ for a living, so good luck finding a reference written by someone credible.