Reddit mentions of C# 7.0 in a Nutshell: The Definitive Reference

Here below is my copy pasta of C#/Unity stuff which I post pretty often here.

Free C# ebook

• http://www.csharpcourse.com/ <- The download link is under 'here' at the end of the first paragraph.

If you want youtube tutorials:

• https://www.youtube.com/playlist?list=PLGLfVvz_LVvRX6xK1oi0reKci6ignjdSa <- apart from C# this dude has also A LOT OF other tutorials on many other languages.

• https://www.youtube.com/watch?v=pSiIHe2uZ2w <- has also pretty good Unity tutorials.

• https://scottlilly.com/build-a-cwpf-rpg/ <- learn WPF (desktop application with GUI) by making simple RPG game.

Book reference guide:

• https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650/ref=sr_1_1?ie=UTF8&qid=1547990420&sr=8-1&keywords=C%23+in+a+nutshell <- But treat is as a language reference guide, not a programming learning guide.

Text-based tutorials

• https://www.tutorialspoint.com/csharp/index.htm <- C#

• https://www.tutorialspoint.com//wpf/index.htm <- WPF (GUI programming)

Udemy - wait for $10 sale which occurs at least once in a month:

• https://www.udemy.com/csharp-tutorial-for-beginners/ <- for C#, dude has also more advanced tutorials to choose from.

• https://www.udemy.com/user/bentristem/ <- for Unity

Do not move to Unity or WPF before you get good grasp on C# syntax and OOP concepts.

C# in Depth - Jon Skeet

C# 7.0 https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

Coming from a C++ background I find [C# in a Nutshell] (https://www.amazon.ca/dp/1491987650) to be great. Concise, to the point, but nothing is (or seems to be) left out.

Fungus Cave

Github repository, screenshot.

I'd like to share two things this week. First, I want to expand my C# toolkit, so I searched and purchased two books:

• C# 7.0 in a Nutshell
  
• Programming WPF
  
  I haven't read WPF yet. As for Nutshell, both the price and content is amazing.
  
  Second, I designed and implemented a field of view algorithm. It has following features:
  
  
• It is not so complicated as recursive shadow casting.
  
• Walls do not block LOS, but they make grids which are farther away from the observer darker.
  
• You can easily add more obstacles in addition to walls and light sources.
  
  FOV is processed by three classes:
  
  
• FieldOfView creates a 2D array. Each grid in the array can be of one of three status: Unknown, Visited and InSight. When drawing FOV, the first step is turning all InSight grids to Visited.
  
• RenderSprite is the last step in drawing FOV. Every sprite checks its position in the observer's FOV status array and changes color accordingly: white for InSight, grey for Visited, and black for Unknown.
  
• FOVRhombus reads observer's position as input and changes the FOV status array.
  
  distanceBoard:
  
  > 3 3 3 3 | 3 4 4 4
  
  > 2 2 2 3 | 2 2 # 4
  
  > 1 1 2 3 | 1 1 2 4
  
  > x 1 2 3 | x 1 2 3
  
  FOVRhombus creates another 2D array called distanceBoard. The algorithm changes FOV status in three steps:
  
  
• Starting from observer's position, traverse the whole distanceBoard array and calculate the distance between observer and each grid. If the grid is a wall, push the position into a wallStack.
  
• For each wall in the wallStack, check surrounding grids in a rhombus shape. If distance(grid, observer) is greater than distance(wall, observer), increases the grid's distance by 1 (or any positive number you like.)
  
• For each grid in the distanceBoard, if the value is less than or equals to observer's max sight range, change the corresponding grid in FOV status array to InSight.
  
  Multiple walls cannot make the same grid even darker. If there are multiple obstacles that cast shadow, only the darkest shadow takes effect. If there are light sources, just reduce the distance.
  

I would recommend:
https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

Fantastic book for pros.

I've also been learning C# for work, and I don't do well in classes: I learn better from books. So if books are your thing, here's a couple recommendations (all of these are on Safari Books Online, see if your work will shell out for a subscription)

• Essential C# 6.0 for a starter book
  
  
• C# In A Nutshell is a great reference book
  
  
• C# In Depth is the book for understanding C# at an intermediate level

What helped me, way back in the day was the O'Reilly book.


https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650/ref=sr_1_4?ie=UTF8&qid=1539150580&sr=8-4

​

Had to learn C# for work so of course I took tutorials, downloaded some stuff and tinkered around, but I had no idea what I was doing. Started reading the O'Reilly book on my lunch breaks and making up exercise for myself. Took me months, but I learned a ton. Within those few months I already figured out tons of way to save myself time and frustration.


Another good idea is taking the C# Role Track at Pluralsight.


https://www.pluralsight.com/paths/csharp


I'm about halfway through it now, and I've learned quite a bit. I've been a C# dev for years. Really gets into all the nook and crannies of the language.


​

I'd suggest checking out Brackeys/Sebastion Lague/Sykoo On youtube as well as this website for tons of more in-depth written tutorials, for getting started, there's a ton of resources amongst those references. As far as generic C# stuff, for me the only way to tackle a new language is a good OReilly (or similar) book, I have this book which I believe covers a much newer version of C# than unity uses, but still is incredibly helpful.

Also, this is definitely not such a complex language that anyone should be suggesting taking another path first, yes here are are complex parts to C#, a lot of which I myself have yet to master. But you can do a lot of really cool stuff with simple concepts. I just finished building a physics simulator for my procedural engine and that was using only basic C# skills and built in Unity commands, nothing fancy at all. Don't let complexity scare you away, pick what you want to do, learn how to do that specifically to your satisfaction, rinse wash repeat. Do that for 6 months to a year and you'll be amazed by how much you've learned.

Good luck!

O'Reilly always does a solid job. Any of the recently published Microsoft books on C# / .NET / .NET Core are going to be good too. Though they may be dry, you'll be impressed with what you know how to build once you're through it. Also, going through the online tutorials Microsoft maintains is a good way to start. It'll help you hone in on what you want to focus on learning.

“Why is C# better than Python” is a tough question to answer, but the short answer is that all the features of C# were put there for a reason. And there are MANY features; C# has evolved over the years to support virtually all of the programming paradigms you can imagine, from procedural code to object-oriented to functional to low-level memory/hardware interaction to whatever. It’s dauntingly complex to dig into all of it, but you really only need a relatively shallow subset of those features to be productive, and you’ll only get better as you absorb more of the profile. What you find as you watch other languages like Python evolve is that they’re really playing catch-up, trying to patch in features that C# has had from its inception. Of course, trying to stick static type safety in after the fact is extremely difficult, but you’re seeing a lot of that in both Python and JavaScript. The lifecycle typically goes something like this: new developers get a whiff of the complexity of C# and are put off, then are pleasantly surprised by how easy and “flexible” JavaScript seems, spend years working with it, and then after hitting a wall with the limitations of those languages, they start down the rabbit hole of trying to monkey around with them to try to fix them up to be more like C#.

Just from the outset, static typing is a huge necessity for large software projects. You can’t afford to exist in an environment where every change of a property throws the stability of your codebase into question, with a host of problems that you can’t identify until runtime. Code clarity is, I would argue, the DEFINING feature of a stable, healthy project, and what you find with dynamically-typed languages is that people get to be afraid to refactor for clarity, because the code is brittle and can’t be changed with any reasonable
level of confidence.

Som people try to make assertions like “a good linter is just as powerful as a strongly-typed language”, but that just strikes me as nonsense. It’s only true if you can commit to using the language in a very basic, highly-conventional way, and once you’ve done that, what you’ve REALLY done is abandoned the flexibility that was the hallmark of the loosely-typed language in the first place, AND what you end up with is a very limited subset of the features a true statically-typed language gives you. It’s really tantamount to believing that most static-typing support is superfluous, which it is most definitely is not.

The thing about JavaScript in particular is that it received an enormous boost by being the only game in town. It’s still a pretty crappy language, but it used to be considerably worse; people tolerated it because it was the only game in town. Even then, it had its cadre of language evangelists who assured everybody that the overwhelmingly primitive nature of the language was really a great feature, and maybe in some abstract sense they were correct insofar as it was sufficient to become a building block for better transpiled iterations of it. But largely, as new features were introduced, developers embraced them wholeheartedly, which likely wouldn’t have been the case if there really was a ton of value in the extremely raw nature of early JavaScript.

These are a couple of really excellent resources for C#, which really dig into the design motivations of the language:

https://www.amazon.com/C-Depth-3rd-Jon-Skeet/dp/161729134X
https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

It’s worth noting that they’re both enormous books, and ironically the “Nutshell” book is over a thousand pages! That’s the kind of scope that you’re dealing with to really get into what C# has to offer. But once you do, it can feel awkward to switch between that and less-powerful languages. For that reason, I think every developer in any language could stand to learn about C#, since it’s just a great case study in language design.

All of that said, I always think it’s important to remember that programming in most dynamically-typed languages is pretty much like writing every C# program using Dictionary(string, object) as your only data type.

This one

The latest edition of this book will be released on August 25, 2017.
https://www.amazon.com/dp/1491987650/_encoding=UTF8?coliid=IFRETBPWLFYRO&colid=11QVEMNY6RZ6

https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

Came here to suggest the Albahari as a desk reference, I go back to mine constantly.

Protip: the writer of linqpad, also has some nice articles.

I would suggest C# In A Nutshell. I consider it the definitive reference for people who already know a bit of programming.

https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

Haven't read it, however you could probably look at this https://www.amazon.co.uk/C-7-0-Nutshell-Joseph-Albahari/dp/1491987650/ref=sr_1_5?keywords=C%23&qid=1563967181&s=gateway&sr=8-5 however if you just want to learn the basics you could just watch youtube tutorials and go from there