(Part 2) Top products from r/csharp

They seem a like reasonable starting point I think. Repetition is the mother of mastery, the more books the better (in addition to applying what is learned).

Since Mosh is calling out learning fundamentals as important to becoming a good C# developers, I would personally also recommend some general (non C# specific books) too for who are starting out in software development:

1. Design Patterns (Amazon) - also known as the "Gang of Four" Design Patterns, it was originally published in 1994 and is still relevant today. When people talk about design patterns, they're referring to the book more often then not.
   
   
2. Soft Skills (Amazon) - Not a book on programming actually... it's a software developers life manual. The reason I like this book is it covers the other parts of the life of a developer that I haven't seen covered anywhere else. Everything from learning strategies, time management, career advice, and even some health and fitness. It was an enjoyable read and I think other developers would enjoy it too.
   
   
3. The Passionate Programmer (Amazon) It's been a while since I've read this one, but I remember it giving decent advice for building a career in software development. Not to be confused with The Pragmatic Programmer (Amazon) which should be read at some point too.
   
   There's a ton more, but those are a few that stood out to me. Essentially the more the merrier in my opinion - books, courses, videos, tutorials, and so on. The books I'm recommending here focus on adopting the developer mindset and being successful at it. That's part of the puzzle.
   
   The other part is understanding the technical details including the programming language and frameworks you intend to use.
   
   And finally, for learning about C#, I do highly recommend Mosh's videos/courses (some are free on YouTube, others available on Udemy). He's got a unique ability to explain things clearly and simply in a way that beginners can pick up quickly.
   
   What I'd do is check out his free content first, and if you agree his style is ideal for learning, an investment in one of his courses is well worth it since he'll cover a lot more breadth and depth on each of the topics and they're organized into a super consumable package rather than scouring the internet for various topics.
   

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

> if I said anything that doesn't make sense it probably doesn't, so don't hurt me.

Haha. No worries. You're good.

I think I'm following you now. Like, I said previously, I was more up on C# years ago. These days, I do most of my development in Python, but still follow along in C# forums just to try to stay current on the language (because I like it as a language.)

If you're interested in a "deep dive" of the C# language, I highly recommend "C# in Depth" by Jon Skeet.

It's definitely not a book from which to learn the language. It's more a book about how and why the language is built the way it is.

Regarding the topic at hand: Tuples -- Jon covers it in Chapter 11 of the 4th (and most recent) edition of his book. There's about 30 pages dedicated to the topic and he covers:

• using tuples to compose data
  
• tuple syntax: literals and types
  
• converting tuples
  
• how tuples are represented in the .NET common language runtime (CLR)
  
• alternatives to tuples
  
  Hope this helps.

I read "Professional ASP.NET MVC 3" about 3 years ago but it seems liek there is a MVC 5 version out now.

To your question about why is asp.net webforms becoming outdata. While there are many reasons I think the biggest is that MVC as a design pattern works really well web appplication development. Webforms is a great technology but it tries to enforce a stateful design pattern on web development which can make development harder. Stateful design patterns are better for desktop applications where as stateless applications are better for web applications. Lastly with MVC works better with a lot of the javascript frameworks out there that webforms really struggled to ingrate well with but a lot has been improved to fix this.

I really enjoyed the C# Player's Guide. There's a newer version now but this is what I got.

Edit: I'm glad you guys liked this book as much as I did. To OP, I would offer two more suggestions.

1. Clean Code This book is NOT specific to C#. However, it gives you a holistic understanding of how to write code that is readable and effective. This is how I was able to transition from writing code that simply functioned (primarily for school) to code that my coworkers could pick up and run with. The book is the bible of software style where I work.
   
   
2. C# and the .NET Framework This is a very optional book in my opinion. It is also a little pricy, very long, more intermediate than beginner and you can gather much of its information from MSDN. However, I prefer looking things up and reading them in a book where possible. I also like having all this information in one location. When I have free time at work, I find myself more likely to flip to an unread section and skim over it than I would with the same information online.

I purchased TCP/IP sockets in C a while back, and at the time was working a job doing Linux network development. So, seeing the low-level APIs and diving straight into the work is what I recommend, but I know it's not the most accessible route. Unfortunately, I don't have any other book references as the majority of my understanding is documentation, blogs, and code. Honestly, my knowledge of sockets in Windows is far from complete.

There is a regular poster to /r/csharp who writes a series of articles and code about networking in C#. I believe he started from simply opening a socket, then continued onto TCP, UDP, and eventually creating a networked game. Surprisingly, I came across this when I was trying to find his posts. You might have better luck searching reddit (I only searched Google).

As for async, I purchased Stephen Cleary's book Concurrency in C# Cookbook and Alex Davies' book Async in C# 5.0, but I have barely cracked open either. :( Stephen Cleary's blog has a significant wealth of information on how async/await works, and things to do and avoid. Once you get over a few humps, MSDN's documentation is pretty thorough and readable as well.

Edit:
Found the networking series I mentioned above - https://16bpp.net/tutorials/csharp-networking/, written by /u/def-pri-pub.

There are couple books that really stood out for C#. These don't touch on .NET core but the same techniques apply.

Functional Programming in C#. http://amzn.to/2Ct3q5B if you come from a functional lang, this one is a must. Great LINQ concepts as well.


Adaptive Code via C@ http://amzn.to/2CsglEP is an updated version of the original. Dependencies and layering really helped me understand the core concepts of .NET. It's a M$ Press book. Easy read and a great reference.

Once you're comfortable with the basics and you want to learn a bit about program design I can really recommend Adaptive Code: Agile coding with design patterns and SOLID principles. After my teacher told me he was happy with my code but thought I should focus more on the SOLID principles to get it to the next level, I read this book. The first couple of chapters cover Agile and Kanban which was interesting, but I certainly got the most out of the next chapters covering the SOLID principles. Thorough explanations on each one of them.

I recommend starting by teaching some version control basics. Focus on git and quickly cover others like TFS and subversion. You can read Pro Git for free.

If you teach a hardware/software course, CODE is an excellent book.

I also recommend C# in Depth. I would also think it'd be cool to offer points for contributing to StackOverflow or the new open source .NET projects on GitHub.

If you teach design/analysis or other classes focused on architecture, Adaptive Code via C# is pretty good. I'm only a few chapters in, but it discusses Scrum methodology, layering and tiers, as well as how to follow practices for writing great code.

I would also suggest a course on JavaScript. I have had to train too many Junior and Senior developers on how to write JavaScript. It's scary that many web developers don't even understand fundamentals.

You're not going to want to read things that make you wish you had a computer with you, trust me. You have no idea how many times I have tried to force myself to read stuff like that when traveling or on vacation. Never works. So here's some stuff geared more towards the philosophy of development and programming that will be fun to read and will probably make you want to slow down, relax, and think about the concepts.

• The Mythical Man-Month: Essays on Software Engineering by Fred Brooks
  
  
• The Pragmatic Programmer: From Journeyman to Master by Andrew Hunt
  
  And for fun:
  
  
• The Cuckoo's Egg: Tracking a Spy Through the Maze of Computer Espionage by Cliff Stoll

Check out this, this, and this.

There's tons of books on C#. I personally like Introducing Visual C# 2010 from Apress and C# 4.0 in a Nutshell from O'Reilly. The former does a nice job covering both the C# language and the most important parts of the .NET framework, then gives a brief intro on the different UI options available. The latter skips the UI stuff, but covers some advanced topics a bit more in-depth. A lot of people seem to like Apress's Pro C#, but I didn't care for it. Also, check out the tutorials on BlackWasp.

After covering all of that stuff, figure out what you want to do and go from there. For Windows development, learn Win Forms and WPF. For web development, look into Web Forms, MVC, and Silverlight. For web services, learn WCF. Then take on a project or two, read articles, etc.

Some of these comments, honestly.

Ignore the trolls.

I'd recommend you buy a book or download one about C#.

Start with tutorials, simple stuff and build on it. There's plenty of examples online and YouTube is also a good source of knowledge.

If you can afford to pay, try pluralsight website. It's really good for content and I'm currently going through their Angular course.

Once you feel comfortable, try building a simple project like a command line app. It doesn't matter what, but keep practicing your skills and using the knowledge you learned.

More importantly, stick to one language at the time ;)

https://www.amazon.com/Ultimate-Beginners-Guide-Learn-Programming-ebook/dp/B07PFW5T7Z/ref=zg_bs_697342_3?_encoding=UTF8&psc=1&refRID=P5ZRY4WT4362QYPFFV79


https://www.amazon.com/C-Depth-Jon-Skeet/dp/1617294535/ref=zg_bs_697342_5?_encoding=UTF8&psc=1&refRID=P5ZRY4WT4362QYPFFV79

Yeah reading about design patterns is going to be a great help in moving forward. They will carry throughout most programming languages too, not just c#.

I just got a book that was recommended to me and I am really excited to read it, after I finish my current book. Check it out:
https://www.amazon.com/gp/aw/d/1509302581?psc=1&ref=ppx_pop_mob_b_asin_title

For UI on Windows, XAML is the tech to use. A great book that I have always had it’s multiple incarnations is:

WPF 4.5 Unleashed
https://www.amazon.co.uk/dp/0672336979/ref=cm_sw_r_cp_api_odbEAbVJ4WV5T

Unfortunately it will not teach you MVVM which is the supporting pattern that separates your visual from your underlying data. There are plenty of tutorials for that out there.

As mentioned in the other responses, async/await is the way to do async in .NET now. This book was great for that.

Async in C# 5.0
https://www.amazon.co.uk/dp/1449337163/ref=cm_sw_r_cp_api_-fbEAb2F57DYJ

Clear, concise, cheap and short. It does the job.

Any questions send me a DM.

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 would strongly recommend reading this book

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

It should be mandatory reading in all CS and SE degrees IMO.

It will not answer your specific question, but it will provide you with the tools and knowledge to understand how best to approach the problem and ensure your architect and design is well though through and draws on the learnings of those who have come before us.

VS2015 and VS2017 are practically identical (at least from a learner's perspective). But there's no reason to not upgrade or to have both installed.

I'd recommend getting a book to read and also following along with a video course (Microsoft Virtual Academy is a great place for videos). You can watch videos and work alongside when able, and read the book to flesh out things you're not sure of (or just revise when you can't access a computer).

I recommend this book: https://www.amazon.com/Microsoft-Visual-2013-Step-Developer/dp/073568183X/ref=sr_1_1?ie=UTF8&qid=1492133728&sr=8-1&keywords=c%23+visual+2013

I found the writing style explained things to me better than most other material, and I could grasp concepts that I felt many resources glossed over or didn't explain as well (the Yellow Book is also good at this).

Also, mixing resources helps a lot. You could read one author's take on a concept over and over again and never understand it, only to read a different explanation and it just clicks. When you get stuck on something just find another source.

Pro C# 7: With .NET and .NET Core https://www.amazon.co.uk/dp/1484230175/ref=cm_sw_r_cp_api_i_suTDCbEGBZC36

Really very good. Teaches the modern fundamentals of OOP in a clear way, as well as comprehensive covering of C# and .NET features.

I feel like the book Adaptive Code via C# was a great resource for me to advance to the next level as a developer. It covers all the topics you mentioned and helped me understand how to write more maintainable, well architected code.

Adaptive Code via C#

This is what you are looking for

It introduces you to all concepts you need to learn under your first year(s) of programming with C#. It has great, easy-to-grasp instructions and every chapter ends with exercises that it walks you through. I went from a novice to comfortable with the language in ~3 months.

After this, you have to get your hands dirty. Google for "programming exercises" or something like that. The point is that you will learn 100 times more when you take on a task that you have to solve by using your brain.

There are two good texts that I'd recommend, each have their own bright spots. Pro MVC 5 and Professional Asp.net MVC 5.

https://www.amazon.com/gp/aw/d/1509302581/ref=dp_ob_neva_mobile

Best of the best

Edit: by mistake I pasted a link to the first edition. Now updated.

Clean Architecture, for sure.

Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series) https://www.amazon.com/dp/0134494164/ref=cm_sw_r_cp_apa_i_yJ83Db51V9ZZS

There are some good C# project examples implementing clean architecture in ASP.NET Core (although the architecture itself could be applied to WPF and other kind of apps).

Have a look at this talk: https://www.youtube.com/watch?v=_lwCVE_XgqI

GitHub repository from the talk here: https://github.com/JasonGT/NorthwindTraders (I'd prefer this one)

​

Another example: https://github.com/ardalis/CleanArchitecture

​

Additionally, if you really want to understand the subject this is an obligatory read: https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

John Sharp's Microsoft Visual C# Step by Step is a great book. It teaches beginner, intermediate, and advanced concepts.

You're looking for step by step: Microsoft Visual C# 2013. I keep it on my desk at work. It's intermediate level, which means it assumes you know what programming is and you know what an IDE is, etc., and he does a fantastic job of holding your hand through the basic syntax before launching you off on the more difficult things. Highly recommended.

> is there a good book/course for developing desktops apps? I can only find books/courses on developing backend, REST services and the sort, never about desktop apps.

I just purchased two books this week. They might be helpful to you:

• C# 7.0 in a Nutshell
  
• Programming WPF
  

There's tutorials and getting started links on the side bar. Start there. Then check out pluralsight. The following books are good. Consider getting Microsoft Certified at some point if you really want to.

http://smile.amazon.com/C-6-0-Nutshell-Definitive-Reference/dp/1491927062/ref=sr_1_2?ie=UTF8&qid=1451614908&sr=8-2&keywords=C%23

http://smile.amazon.com/Pro-NET-Framework-Experts-Voice/dp/1430242337/ref=sr_1_1?ie=UTF8&qid=1451614991&sr=8-1&keywords=pro+C%23

http://smile.amazon.com/Pro-ASP-NET-Experts-Voice-ASP-Net/dp/1430265299/ref=sr_1_4?ie=UTF8&qid=1451614991&sr=8-4&keywords=pro+C%23

http://smile.amazon.com/C-6-0-NET-4-6-Framework/dp/1484213335/ref=sr_1_1?ie=UTF8&qid=1451615074&sr=8-1&keywords=pro+C%23+6

Originally MS published a great beginner series called "Learn {thing} Visually" and there was a book for each subject. Instead of teaching boring fundamentals of coding, it started by making simple Windows forms which were drag and drop and slowly taught the programming. I use to buy a stack of these books (they were like $13 on Amazon) and anytime somebody had a series interest I would get one from my trunk and give them the book.

Apparently this series was replaced with the "step by step" series:
https://www.amazon.com/dp/1509301046/

I think these books are good, anyway they are in my Amazon history

http://www.amazon.co.uk/gp/product/1449337163?psc=1&redirect=true&ref_=oh_aui_search_detailpage

http://www.amazon.co.uk/gp/product/1449320104?psc=1&redirect=true&ref_=oh_aui_search_detailpage
I think there is a c# 6 version now though

http://www.amazon.co.uk/gp/product/161729134X?psc=1&redirect=true&ref_=oh_aui_search_detailpage

:D

https://www.amazon.com/Professional-ASP-NET-MVC-Jon-Galloway/dp/1118794753

is the book I recommend. I learned how to do ASP MVC from it years ago.

One thing is what do you wanna do - ASP MVC 5 which is pretty established or ASP MVC 6, which has lots of features I'd say overwhelm a new beginner

In the past couple of weeks, I've been reading Design Patterns: Elements of Reusable Object-Oriented Software. If you understand MVC and design patterns in general, it is a good reference. The bulk of the book consists of the design patterns catalog, but there's also a chapter that lays out the reasons for using patterns in broad strokes, as well as a case study involving reasons for applying multiple design patterns in a project.

More than just describing the patterns themselves, some of the book focuses on the interrelationships among different design patterns. As a caveat, it references C++ and Smalltalk in its code samples, but the concepts of structuring objects and their dependencies transcend languages.

Not sure if you are still looking for a book, but I own this one and I really like it.


https://www.google.com/url?sa=t&source=web&rct=j&ei=pemtVPjGN4jboASy54H4Bw&url=http://www.amazon.com/Programming-WPF-Chris-Sells/dp/0596510373&ved=0CBwQFjAA&usg=AFQjCNEUS564892pYODydH4c00lTQt2HNg&sig2=IupvV8EHhAQcaKUpWB1Crg

Thank you for the response. I guess I have the same question for you so I will just copy and paste what I wrote to AberrantCheese.

Right now I am debating whether to get

Windows Presentation Foundations Unleashed

or

Programming WPF

I guess I just want the one that is less complex since I am a beginner.

On a side note, do I need to understand WPF and XAML before I proceed to MVVM?

At 1625 pages, [C# 6.0 and the .NET 4.6 Framework][book] is the most comprehensive book about C# I know about. Open its table of contents on Amazon and there's your checklist!

Another idea is to read the [C# language specification][spec] - that way you can be absolutely sure you haven't missed anything :)

(As far as I can see, the C# 6 specification has not yet been released but there is a draft on GitHub.)

[book]: https://www.amazon.com/C-6-0-NET-4-6-Framework/dp/1484213335/ref=sr_1_1?ie=UTF8&qid=1484208486&sr=8-1&keywords=andrew+troelsen
[spec]: https://www.microsoft.com/en-us/download/confirmation.aspx?id=7029

There are several books, blogs and videos that you can use.

These books are good choices:

C# 5.0 in a Nutshell and
Pro C# 5.0 and the .NET 4.5 Framework

I also wrote a blog post about it.

Resources to become a Ninja: C#

I can also throw in a recommendation for https://www.amazon.co.uk/Adaptive-Code-via-patterns-principles/dp/0735683204/ref=sr_1_2?keywords=C%23+SOLID&qid=1564580206&s=gateway&sr=8-2 - I have a copy and it's a good read

I thought Pro C# 2010 and the .NET 4 Framework was really good.

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.

I found Visual Studio C# Step by step to be a good book for people who are just starting or are even on intermediate level.

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).

There is this book which basically talks about everything in C# 7, a good and deetailed book. https://www.amazon.com/Pro-NET-Core-Andrew-Troelsen/dp/1484230175

I used "Pro C# 5.0 and the .NET 4.5 Framework 6th Ed" to teach myself C#.

​

I'm pretty sure there are newer editions now, but the content will be mostly the same, specially at beginner levels.

http://www.amazon.com/gp/aw/d/1430242337/ref=mp_s_a_1_1?qid=1415400001&sr=8-1&pi=SY200_QL40 I would recommend this book

The book is still in its first edition. From the Editorial Review on the Amazon page:

> The CD-ROM works with any Java-enabled browser (Internet Explorer 4.0 and Netscape Communicator 4.0.) It includes the full text of the printed book along with the richness of hypertext links to get the most out of patterns quickly. (Two versions of the text, one for 640 x 480 resolution and one for higher resolutions, are provided.)

It's friggin' old.

Everything else changes continuously in software. It's hard to believe that there aren't a bunch of design patterns that the GoF missed or have been invented since the GoF book was written.

Exactly the books many people suggested !
Further they recommended me this

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

"Pro C# 2010 And The .NET 4.0 Platform" by Troelsen.
£27.23 on amazon.
http://www.amazon.co.uk/Pro-2010-NET-4-0-Platform/dp/1430225491

Very thorough, in-depth, aimed at experienced programmers.
Covers C# and .NET, including CLI, CLR, and an overview of .NET libraries.

I have actually been using this book to learn C# and it has been helping immensely. It even tells you where in the book to begin based on your programming experience. Big book, but it really breaks everything down and lets you know how everything works.

Those who want more detailed info on these should check the Design Patterns book by GOF

Link:
https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8

Essential reading:

http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&ie=UTF8&qid=1426600164&sr=1-1&keywords=clean+code

http://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073/ref=sr_1_2?s=books&ie=UTF8&qid=1426600164&sr=1-2&keywords=clean+code

http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_4?s=books&ie=UTF8&qid=1426600164&sr=1-4&keywords=clean+code

http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_5?s=books&ie=UTF8&qid=1426600164&sr=1-5&keywords=clean+code

This is the third book suggested that was written by Uncle Bob.

Can you maybe explain the Difference between:

Clean Code , Clean Architecture and Clean Coder. All books by Uncle Bob

>Is there any decent books on the GoF stuff?

The GoF book: Design Patterns: Elements of Reusable Object-Oriented Software by "The Gang of Four" (Gamma, Vlissides, Johnson, and Helm)

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

Adaptive Code

https://www.amazon.com/Adaptive-Code-via-principles-Developer/dp/0735683204

For less messy amazon links you can extract the part after "/dp/" in

https://www.amazon.com/C-6-0-NET-4-6-Framework/dp/1484213335/ref=sr_1_1?ie=UTF8&qid=1484208486&sr=8-1&keywords=andrew+troelsen

and make it:

https://amzn.com/1484213335

BEEP BOP

Plz send any recommendations via PM

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.

Three things:

• Get an IDE that doesn't give you help. SharpDevelop is good for this.
  
  
• Get the book "Pro C# and the .NET framework" from Troelsen: http://www.amazon.com/2010-NET-Platform-Andrew-Troelsen/dp/1430225491
  
  
• Learn from production code and someone else's failures.
  
  I learned most of what I know today by writing VB apps and having the IDE convert them to C# (I stared with SharpDevelop)
  
  

if you need a comment for every function then either you are not spending enough time naming your functions or you are not respecting the single responsibility principle.

Comments should be few and far between and only say why something is needed not what it does (with the exceptions of very complicated regex or some unreadable math.)

https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073

I think you may be putting too much weight on one single negative video review. There are tons of other reviews out there in other media that are really quite favourable, see these from Amazon for example.

Unfortunately I didn't have a chance to watch that video, but I'll give my spiel anyways:

The book is not meant to be an introduction for beginners, and it's not meant to be a systematic exposition of C#'s features. I think of it more as taking us on a journey through the history of C#, to foster a deep conceptual understanding of why C# was designed the way it was.