It's dangerous to code alone! Take this.

Updates

29 November 2021

Early Access #7 for 5th Edition is out today. I finished the edits for code maps, scope, and code structure, and also got the index updated.

There is only one thing left for 5th Edition: a final revision pass. A guess (but not a commitment) is that this will wrap up in two weeks.

22 November 2021

Early Access #6 for 5th Edition is out today. (And somehow, I missed the post for Early Access #5, but that was last Sunday.)

The major changes this time around are:

  • Updates to the cover. It isn’t wildly different from 4th Edition, but hopefully, it is enough to distinguish the two when sitting side-by-side.
  • There are several pitfalls I keep seeing readers stumble into early in the book: (1) not installing the right workload, (2) not picking the right template, and (3) not using the right version of .NET. All of those were called out in the book, but it was really easy to skip through those pages. I’ve now called those pitfalls out in bold and with a little (!) icon next to them to draw more attention to them. Hopefully, fewer people will fall into those pits now.
  • One concern I’ve had with 5th Edition (and to some degree, 4th Edition) is how well people will understand things like how code is organized hierarchically and how that relates to scope and things of that nature. To address this, I’ve put in more content and diagrams to try to explain it. If you search the new version for “code map,” you’ll find the places I’ve added new content to illustrate this. (The new diagram type I added I’m calling a code map because Visual Studio can create similar diagrams with the same name. In most places where I put one in, I used that “code map” phrase, so you should be able to use it to find the sites that changed.) I’m not entirely done revising those sections. But I still wanted to get what I’ve got into readers’ hands to get feedback.

The main remaining items are:

  • Finish editing the code map/structure/organization stuff.
  • A (final?) revision pass through the whole book to polish things off.

We’re getting close to the end of Early Access. Any feedback you’ve still got is greatly appreciated!

12 November 2021

A version of the Upgrade Companion (a document for 4th Edition readers who are excited to learn the new C# 10 features as you go) is available here: Upgrade Companion for 4th Edition

8 November 2021

Early Access #4 for 5th Edition went out today. This update finished the revision pass and cleaned out a rather long list of other things I needed to do. The content (but not cover) of the book is now essentially what it will be for the official release. (With any necessary fixes for things I find or readers find.)

The 5th Edition still has a small list of non-trivial things that need to be done before the official release:

  • Cover updates.
  • Solution udpates.
  • Website updates.
  • The 4th Edition Upgrade Companion.
  • Probably another revision pass to catch any remaining copyediting errors and make some minor tweaks to the index.

Also going out today is the 4th Edition update 4.0.8. This fixes a handful of very minor typos and similar issues.

31 October 2021

Happy Halloween!

5th Edition Early Access #3 is out today.

The major efforts this past week have been:

  1. Working on a revision pass through the book to update images, do copyediting, and ensuring consistency across the book. I got from the Introduction through Level 29 (Records). For these levels, I don’t expect any further substantial changes, and they are potentially “done” for 5th Edition.
  2. I added a mention to vscode.dev to the book, which lets you write C# code in VS Code online. (But currently doesn’t support actually running it.)
  3. I fixed several broken links in the book.

The focus for the next little while is:

  • Finish the revision pass.
  • Look into hardback and color options.
  • Cover updates.
  • Challenge solution updates.
  • Getting the website ready for 5th Edition.
  • A few other small things I’ve encountered while working through the book.

24 October 2021

5th Edition Early Access #2 is out today. The main changes in this update are:

  1. Quite a bit of rework on how the book talks about namespaces in Level 3 and a whole lot of rework and rewriting in Level 33 (“Managing Larger Programs”).
  2. A very substantial rework of Level 29 (“Records”) to talk about records as a compact way to create both classes and structs rather than as an entirely different entity from the other two. This reflects how records are evolving in C# 10, and I think this version makes them very easy to explain and understand.
  3. Some small tweaks to the samples the “Indexers” section of Level 41 to address some minor concerns I had about how it deals with the properties and immutability.
  4. A small change to the “Reflection” section in Level 47 to call out the System.Reflection namespace. This felt important to do, since using directives are not needed nearly as often as they were in C# 9 and earlier.
  5. I added a mention to int.Parse (and friends like double.Parse) in Level 6 when it brings up the Convert class. The two are largely interchangeable, and some people like int.Parse over Convert.ToInt32. This had the added benefit of fixing a consistency problem in the Structs level where int.Parse is thrown out as an example without having ever been discussed before, and was not formally introduced until Level 34.
  6. I fixed an issue where the bonus levels were all getting the number “0” instead of “A”, “B”, and “C”.

There’s still a fair bit of work to do. Here are the main items:

  • Another revision pass through the whole book to do the following:
    • Update screenshots.
    • Fix consistency issues.
    • Copyediting.
    • Identify any other large issues that need attention.
  • Changes to make the cover of the 5th Edition stand out from 4th Edition a bit better.
  • Adding solutions for 5th Edition. While the challenges have all remained the same, some of the language changes mean each of the challenges deserve some minor tweaks to correctly reflect the “right” way to do things.

That first item is the big one. I’ll have a much better idea on how much effort really remains when that is well underway or finished. And that’s the focus of this coming week.

17 October 2021 - Part 2

My apologies for a second update on a single day, but I just put up an article about “Modern C#” and how the language is evolving. It is a somewhat philosophical article, but I hope it sheds some light on the question of, “Didn’t we just get a 4th Edition? Why is there a 5th Edition before even a year has passed?” Here’s the article: Modern C#

17 October 2021

Early Access for 5th Edition is now officially underway on Gumroad. If you’ve bought the 4th Edition on Gumroad, you should have gotten an email detailing how to get into Early Access for free. If you’ve bought the 4th Edition in print form, reach out to me, and I can get you in.

If you’re about to buy the book and are now wondering if you should go with 4th Edition, get Early Access of the 5th Edition, or wait, here’s my suggestion.

We’re still at least a month away from the finished 5th Edition, which is waiting on the release of C# 10 on the 9th of November. 4th Edition is still the latest and greatest version of the book, and reflects the latest and greatest version of C#. If you want something stable, then get 4th Edition and reach out to me. I’ll also get you into the Early Access, and you can have both.

If you’re willing to live on the bleeding edge and wanted the digital edition anyway, then I’d recommend just diving into the 5th Edition in Early Access. The book is, honestly, 99% what it will be when it is all done. I need to update some screenshots, and I need to make a few revision passes. You’ll also need to deal with getting the Visual Studio 2022 release candidate instead of VS 2019. But if you’re buying 5th Edition in Early Access, there’s a bit of a discount over buying 4th Edition, to reflect the increased volatility.

If you want a print copy, you can either go with 4th Edition in print (reach out to me, and I’ll get you into the Early Access in digital form) or be patient for a bit longer and get 5th Edition when it arrives.

As I said in my 5th Edition announcement, I expect 4th and 5th Editions to be 98% the same, but the 2% that is different has a rather substantial impact on how modern C# code is written. The changes–while seemingly minor–make a huge difference. (Which is why I decided I need to do a 5th Edition, when 4th Edition hasn’t even been out a year yet.)

As always, if you have questions or comments on any of this, don’t hesitate to reach out to me on Discord or email. I love talking about this stuff with you guys, and the book is vastly better because of the many conversations I’ve had with readers.

13 October 2021

I’m making it official: the 5th Edition is in the works! C# 10, .NET 6, and Visual Studio 2022 are all coming out on the 9th of November, which is the driving force behind the new update. I’m shooting for mid or late November, but it will really just depend on how things go. For details, see this article: 5th Edition Announcement.

If you’ve recently bought 4th Edition or are thinking about buying it, please check out that article. I try hard to take care of readers, and I think you’ll be happy with my plans for getting updates to people who have already bought the 4th Edition.

Reach out on Discord or email if you have questions or concerns.

3 October 2021

Version 4.0.7 has arrived! This is another digital-only update, fixing a few small typos:

  1. Table of Contents: The text for the section called “The Adventure Begins” was accidentally labeled as “The Adventure Begin.”
  2. Page 30: In the code sample, there is a missing semicolon: Console.WriteLine("Hi " + username) should be Console.WriteLine("Hi " + username);.
  3. Page 33: When discussing variables, the book said, “You have a lot of control over what names you give to your variables, nut the language has a few rules.” This should say, “but the language has a few rules.”
  4. Page 84: In the code sample, there is a missing quotation mark: Console.WriteLine($"{a} * {b} = {a * b}); should be Console.WriteLine($"{a} * {b}");.

11 September 2021

Version 4.0.6 is going out today. This is another digital-only update, fixing a typo and a minor improvement to the sample code:

  1. Fixed a mis-numbering of the “Methods” knowledge check answers on page 269.
  2. Added in a readonly modifier to the _numberLock field in the sample on page 339, since it doesn’t need to change after creation.

Earlier, I had committed to monthly digital updates through the third quarter (July, August, September). 4.0.6 represents that last of that original commitment.

I have not yet made plans for the fourth quarter of the year, but at this point, I think it is a safe assumption to expect at least an update the first weekends of October and November.

The caveat to that plan would be that if there are no reported issues, then there won’t be an update. (Though I think I’d likely still post an update here, saying so.)

8 August 2021

Version 4.0.5 is going out today. This is another digital-only update, fixing minor typos and a few other tweaks. This is also the smallest update, in terms of total changes, so far, which is a trend I generally expect to continue going forward.

The changes include:

  1. Fixing the title in the headers of Level 53 (said Bonus Level A instead of Into Lands Uncharted as they were supposed to say). Thanks @odigity!
  2. A couple of corrections to the code sample on page 339 about using locks to enforce thread safety. Thanks @Powder!
  3. Added a missing $ to a string interpolation for the code at the very bottom of page 266. Thanks @Powder!
  4. A slight tweak to the Safer Number Crunching challenge on page 267 to indicate using the int.TryParse(string s, out int result) method (as shown earlier in that section) instead of the non-existent int.TryParse(out int value) method (missing the first string parameter). Thanks @Powder and @Kranberry!
  5. An updated version of the XP Tracker on the website to fix some outdated challenge entries. Thanks @AddAmazeing!

I also added two new articles on the website as a part of this update:

  1. Locks and Reading Data: Discusses locks in a bit more depth to cover some ground that the book doesn’t quite capture. Worth a read if you’re doing much with multi-threading and concurrency in C#. This is in response to the deeper analysis I did while fixing #2 above, so thanks again, @Powder!
  2. Lists and InvalidOperationExceptions. The book mentions that you can use foreach on a list, but that if you add, remove, or swap out items in a list while in the middle of a foreach, you’ll get an exception. It then mentions that there are two ways to get around the problem, and describes how you can just use a for loop. But it does not cover the second option. This article covers it. Thanks for asking about it, @JustPlay!

6 July 2021

Version 4.0.4 is going out today. This is another digital-only update, fixing minor typos and a few small other tweaks.

This includes:

  • On pages 199 and 200, The IsOnBoard method was incorrectly using Row instead of row, using the property instead of the parameter. This has now been fixed.
  • On page 243 and 244, there were a couple of sentences that called out arrays, when the topic was actually lists.
  • On page 372, the second bitshift example was wrong. It said “00010001 becomes 00000100,” but should have said “00010001 becomes 00000010.”
  • On page 379, I reordered the number++; and Console.WriteLine(number); lines in the example so the goto and for versions worked in the same way.
  • On page 380, the sample said Add(newShip()), but that should have read Add(new Ship()) (which changes it to correctly calling the Ship constructor instead of a mysterious newShip() method).
  • A couple of other minor typos.

On the website, I have also made a couple of minor tweaks as well:

  • Some tweaks to the CRC cards for Hangman on the website.
  • The solution for the challenge called The Color now uses static properties instead of static fields, as required by the challenge description.

This is the smallest update we’ve had, though it still contains about 12 typo corrections and minor improvements.

Back when the book was first released, I mentioned that for April, May, and June, you should expect an update the first weekend of the month. That has carried over into July now, and I think it is reasonable to expect that to continue for August and September as well.

I also want to say that I’ve been spending some time trying to get an epub and/or mobi version of the book available, since I know that format works better on smaller screens and ebook readers are optimized for flexible-layout formats. The tough part is not the epub or mobi side, it is ensuring the workflow still allows me to make both EPUB and PDF versions, while still retaining all of the features I’ve got in the PDF. I had hoped to start putting out some work-in-progress versions before the end of June, but that hasn’t happened yet, and still looks to be a ways out still. I currently expect that 5th Edition (whenever that is, but it doesn’t feel like C# 10 is immiment) will have EPUB or MOBI (or both) available.

6 June 2021

Version 4.0.3 is going out today. This is a digital-only update, fixing minor typos and adding clarity in a few small corner cases.

This was supposed to be the May 2021 update, but it kept getting pushed back until now, and so the May and June updates are combined in this update.

There are a handful of minor issues that have been reported to me in the last couple of days that didn’t make it into this update. They’ll make it into the next one, which I’m planning for the first weekend in July. (That’s a long weekend for me. I won’t consider the update late until the 6th of July.)

The errata page has gotten pretty crowded now, though you may notice that (a) the vast majority are minor typos and (b) most are late in the book. I don’t think the later part of the book had any less attention than earlier parts of the book, but I have a couple of readers with sharp eyes that happen to have been through most of the book already (in Early Access) before it was published.

4 April 2021

Version 4.0.2 is going out today. The first digital edition release was 4.0.0, and the first print edition was 4.0.1.

This will be a digital-only update, fixing some minor typos and adding a bit of clarity in a few small corner cases.

This isn’t a commitment, but I am tentatively planning on doing updates of this nature once a month, usually on the first weekend of the month, so the next one might be early May.

23 March 2021

The physical 4th Edition of The C# Player’s Guide is now available on Amazon! Here’s the link: https://amzn.to/2PlxQCW

It’s been a long journey, but I’m over-the-moon excited about this edition finally becoming available! The “Look Inside” feature doesn’t work yet (I’ll ask, but I think it usually takes a few days) but if you want a preview before buying, you can always look at the sample that is available from the home page.

21 March 2021

The ISBN-related issues have been resolved, and it is now just pending a review by Amazon before it will appear there! They’ve said to allow up to three days, though I think there are reasons to believe it may be somewhat less than that.

20 March 2021

The latest on the physical edition is that at this point, I’m waiting on processes outside of my control to happen. It will take up to five more days for the ISBN information to propagate through the system, and then up to another three days for the book to become available. My best guess is neither will take as long as the worst-case scenarios they state, but there’s no way to be sure right now. (And there’s always the possibility of some other unforeseen circumstance.)

I’ll try to keep this page updated as I learn more information.

14 March 2021

The 4th Edition has arrived in digital form!

This week’s changes involve small fixes for a high quantity of typo reports and suggestions scattered throughout the book.

Given that this is the first official release of the 4th Edition, you might also find this article useful to you, which describes all of the changes made for 4th Edition vs. 3rd Edition at a high level: https://csharpplayersguide.com/articles/whats-new-4th-edition.html.

This ends the Early Access program that has been running since late October. Going forward, the digital edition on Gumroad will continue to get periodic updates, though not at the same weekly cadence as before. My best guess is that this will be more like monthly, and only if there are things worth doing an update for.

The physical edition will be available soon, likely by the end of this week. It’s a longer process to get that approved, but now pushing it through that process is the only thing left.

It is a slow process with some consequences (usually some downtime in availability) but typo corrections can be done even in print. (Obviously, anybody whose book was already printed won’t get the corrections. Alas, we’ll have to just live with that.) So while it will be at a lower rate, there is still the possibility of limited corrections, even in print form.

Despite the slower update rate, please don’t hesitate to report any issues you find in the book, big or small.

The errata page on the website can be updated almost instantly, and any necessary change will find their way to the digital and print versions before too long.

While this isn’t a commitment, I fully expect that there will be a 5th Edition in due time. There will be new versions of C#, and I intend on keeping the book up-to-date with that. So even broad, sweeping suggestions can be addressed before too much time passes. (I currently have no clear insight into when this might be. We’ll probably know more at Microsoft’s Build conference in May.)

As Early Access winds down, I want to say again how nice it has been to have so many of you along on the journey with me. Thanks to your efforts, the book is far better than it ever would have been otherwise. (Again, no promises on exactly how things will unfold, but I hope to see many of you again for the next Early Access!)

13 March 2021

This week’s update is delayed by a day. I usually get the update out Friday or Saturday, but I’ve got a few final things to take care of before pushing this one out. Normally, I’d just let loose ends go until the next release, but this will be the first official release, and it may be a bit longer until the next update.

Stay tuned!

6 March 2021

Release Candidate #4 is now available!

This may be the final release candidate, as Visual Studio 16.9–the sole impediment to the release–is now out!

A few minor fixes readers reported have been fixed, and I also made a couple of small tweaks to the section on making new projects with the templates.

I’m waiting on one final print copy to review this week, but unless there is some big problem that comes out of that, the final release may be available in one week. (Treat that as a guess, not a promise.)

27 February 2021

Release Candidate #3 is now available!

The final revision pass is complete, as are all loose ends that I wanted to finish. At this point, there is nothing specific I want to accomplish with the book that isn’t already done.

It now becomes a waiting game. The book assumes that you are using the new (upcoming) template system instead of the old (current) template system. This is supposed to be the default in Visual Studio 16.9, though you can turn it on in 16.8 (the current release). The book has a page (now says STOP in big obvious letters so you don’t miss it) that describes how to switch over to this new system. But my intent was to wait for Visual Studio 16.9 to be released before publishing the final edition of the book. So that’s what we’re waiting on.

I may yet decide it isn’t worth waiting, rework the book to account for both template systems, and just go ahead with the release before 16.9 comes out.

In the meantime, any issues readers find will still be fixed; expect the weekly releases to continue for now.

20 February 2021

Release Candidate #2 is now available!

The primary accomplishment is working through the final revision pass. This is now 90% complete.

I spent some time working on video walkthroughs before deciding that it was a lot of work and not a lot of value, so I decided not to do it. If it’s something people would find valuable, we can still do it as a live stream through Discord and make the recordings available on the website.

All that’s left is this:

  1. Finish the revision pass.
  2. A few tiny loose ends.
  3. Fix problems submitted by readers.

If you haven’t joined the discord server, I’d love to see you over there! https://discord.gg/Wx8VMUbk68

12 February 2021

We’ve made it to our first Release Candidate, with Release Candidate #1 coming out today!

The big accomplishments of the past week are:

  1. Made a new Discord server specifically for this book. Come join the fun!
  2. Updated the XP Tracker at the beginning of the book.
  3. Updated the Map at the beginning of the book.
  4. Updated the title page at the beginning of the book.
  5. Added an illustration to the Final Battle challenge in Level 52.
  6. Turned four challenges into Boss Battles (the big ones, though several are multi-part).
    • Hunting the Manticore
    • Catacombs of the Class
    • Fountain of Objects
    • The Final Battle
  7. Changed the visual appearance of the CRC cards.

The plans for the coming week are:

  1. Yet another revision pass. (This should be much faster than the last. I spent a few hours and got through four chapters, so I don’t expect this one to drag on for weeks like the last round.)
  2. I am planning on (but not committing to) making some video walkthroughs of the Boss Battles to put online. I think these videos will show more nuance to the development process than a simple snapshot of the final result.

And of course, fix the things you guys report.

5 February 2021

Early Access #17 is out today.

The big updates are:

  1. The cover is now finished.
  2. The website is now finished.
  3. The back of the book is now basically finished, notably: a. The Operators table was moved to the website: /articles/operators-table. b. The Keywords table was eliminated. Nobody was using it, and it didn’t really seem to be providing much value. c. The Built-In Types diagram and table were totally redone and moved to the end of Level 6. (You should check it out!)

The final few items are these:

  1. Finish the front part of the book. In particular, the XP Tracker and map need some updates and tweaks.
  2. A few other items that have bene kicking around on the GitHub issue tracker, though some of those will also need to wait for 5th Edition, unfortunately. (Don’t hesitate to go there and get involved in the discussions there.)
  3. Additional changes as feedback continues coming in.

I think there’s an 80% chance all of that will get finished this week, so whether the book is done in one week or not is largely dependent on what else pops up that I decide to do.

Also keep in mind that I’m currently somewhat on the hook to wait for Visual Studio 16.9, which isn’t out yet, and still feels like it is at least two weeks out, if not more. If that truly becomes the only thing I’m waiting on, I might change course on it.

29 January 2021

Early Access #16 is out today.

The bulk of my time this last week was on getting the website up and running. There are three key elements that you should be aware of:

  1. There is a new home: csharpplayersguide.com
  2. The website takes much better advantage of reactive web design, so you should have a better experience on phones and tablets.
  3. The solutions are now available there (csharpplayersguide.com/solutions), and will therefore no longer be included as a download here, as there is no longer a need for it.

I also spent some time working with a graphic designer on the cover, and am planning on going with the blue sword+circle design, with a handful of tweaks and refinements.

I will be continuing to work on the website and the cover this coming week, and also finishing up the final revision pass on the Tables and Charts at the back of the book, as well as the map and XP tracker at the start. To that end, I’d love to get a better feel for if and how you use the Tables and Charts at the back of the book. If you could take just a minute or two and fill out this survey, it would give me a great deal of insight into where I should go with it: https://www.surveymonkey.com/r/XSPCSFC

In short, the coming week is:

  1. Finish the cover.
  2. Finish the website.
  3. Finish the front and back parts of the book.
  4. Fix issues you report.

There is a teeny tiny chance I’ll be finished with all of those for Early Access #17. (Probably less than 5%, but this is the first time there has been a chance.)

22 January 2021

Early Access #15 just went out today.

The final revision pass is now complete, and there are only two major efforts left:

  1. Update the cover.
  2. Update the website.

There are some other more minor things, and I’m expecting to still get more issues submitted from readers, but those are the big ones.

For me, this feels like the beginning of the end. There’s still plenty more to do (and I’m not expecting a release in January) but we’re getting to the end.

15 January 2021

This week, nearly all of the effort went into the final revision pass and made pretty good progress. I am about 58% of the way through the book, up through the level on Files, though the Introduction and Part 2 and Part 3 intro pages have also not been covered yet.

There were several other typos that people found, including a couple that my final revision pass missed. (Things that were not strictly wrong, but that were still awkward and deserved improvement.) So even though I’m going through this final revision pass, don’t hesitate to send me anything you notice so that we can make sure we get them all.

This revision pass is the main focus for the coming week.

I’m currently estimating about 50 hours to go on this final revision pass, which has a chance of being finished up for this next release. I might put off the release until Saturday evening if I think I can get it all finalized. So next week’s update might be on the late side.

8 January 2021

The 13th early access release of the C# Player’s Guide, 4th Edition is now available.

The bulk of the effort has gone in to making the final revision pass through the book. I completed Level 18 in that process, which puts me at about 25% of the way done, and an estimated 108 hours to go, which is probably three full weeks.

I also fixed a ton of small typos and grammar fixes that people reported–probably more than any other single week. Keep them coming!

I got some feedback from a couple of people on the potential cover designs over the week, and am still interested in hearing more. I haven’t done anything with them due to focusing on the final revision pass, but I appreciate the comments I have received so far.

1 January 2021

The 12th Early Access for The C# Player’s Guide, 4th Edition is now available.

The biggest accomplishment was finishing the challenges. The biggest change came with The Final Battle challenges, which was a complete do-over.

Aside from that, I got the process of designing a new cover underway. I have a couple of options:

Option #1: Just keep the current cover, more or less intact as it is now. Probably a tweak to the edition number color. That cyan that is currently in there was quick and dirty. Option #2: A second design I got with some color variations. These are in the downloads on Gumroad. There are four variations, different only by color (I believe). Option #3: Pay another graphic designer to come up with a completely different choice. (I work with several that do pretty good work.)

I know you’re not buying the book because of the cover, but I’m definitely interested in getting a broad set of opinions on it. If you prefer the cover as it currently stands to this new Option 2 that is in the downloads, I want to hear that. If you like this alternative, I want to know that too. If one of the four color variations stands out as a favorite (or one you especially dislike), I want to hear that.

I did get the final revision pass started, though it is really only just beginning, and I can already tell it is going to take more time than I had initially anticipated. That puts the release date in more like early to mid February, but the to-do list is starting to get pretty short, and I don’t expect huge delays beyond that, now that I’ve got my teeth in the last major effort.

There was also the usual assortment of small tweaks and typos that were fixed.

27 December 2020

Early Access #11 is now available. Here are the release notes:

The primary focus was on creating answers to the challenges. To that end, all of Part 3 now has solutions (they all got tweaked a little in the process to add more consistency). Part 5 also has answers to the challenges. Other than a few stragglers from earlier in the book, everything is done except the Final Battle–a whole set of challenges right at the end of the book.

The big problem I had this week is that I decided that Final Battle challenge was too hard. I stripped out some of the primary elements and made another challenge, but I decided yesterday that it, too, was too hard. At least this time, I felt it could be tweaked into something that works, rather than having to retool it from scratch. That is still a work in progress, but included in the challenge solution code, I have both the more complex version of the program up and running (‘Level 52 - The Final Battle/ TheFinalBattle’) as well as my beginning attempts to simplify it (‘Level 52 - The Final Battle/TheFinalBattleSimplified’). I’m not done simplifying yet, but you can see it where things stand. Also ‘Level 52 - The Final Battle/Description.txt’ contains an extremely rough description of the challenges–as I thought they might be before simplifying. I’ve included all of that in this update, though I expect it will be cleaned up by next week.

I also fixed a number of small issues that readers found. The typos and grammar fixes have all been addressed, though there are a few suggestions still hanging out that need attention in future releases. (A suggestion to include the Parts as bookmarks, a suggestion to include an EPUB format, and a suggestion to include something about StringBuilder, among other things.)

Overall, I made less progress on these challenge solutions than I had hoped. That delays the final release by a bit. I’m now confident it will not be December, so I am now targeting late January. I think there’s at least of month of work left. I do have all of this coming week off. If things go well, that might change for the better, but based on this past week, I can’t make promises.

18 December 2020

Early Access #10 is now available. Here are the release notes:

The primary focus this time has been on providing solutions to all of the challenges in the book. To that end, there are now solutions for nearly all challenges in Part 1 and Part 2. There were a few where the challenge itself needed some substantial changes, and those have not been included yet. The missing ones are “Casting and Order of Operations” and “Positive or Negative” from Part 1 and “Containers,” “Generic Containers,” and “Lists of Inventory” from Part 2.

Several challenges–especially the “Hunting the Manticore” and “Fountain of Objects” challenges–were changed rather significantly to make them easier. If you gave either of those an attempt and struggled before, try the updated version again. Those are meant to be tough challenges, but the bar was probably set just a little too high.

There were a small number of other small typos and similar fixes, though far fewer than in the past. But I was able to fix all reported issues of that nature.

I expect that creating solutions will be finished by the next update.

I am still interested in feedback about the fonts and visual style. I recieved just a couple of comments on that, and want to make sure I get it right.

And as always, I’m interested in any feedback–big or small–so please don’t hesitate to reach out if you see something suspicious or flat out wrong.

11 December 2020

Early Access #9 is available. Here are the release notes:

This is the 9th early access release of the C# Player’s Guide, 4th Edition.

There were three major efforts that were completed in this update, and it might be the most substantial update we’ve had.

First, the book now accounts for all C# 9 features. Most of the actual C# 9 feature changes were in advanced, dark, corner cases and didn’t require any big changes. But there were several that are worth pointing out:

  • Partial methods just got more powerful. The Partial Methods sub-section in Level 47 got revised.
  • “Native sized” integers (ints that match the target hardware, for situations where you are interoperating with low-level code) were added. A section for this was added to Level 46.
  • You can use static on a local method or lambda to prevent closures/capturing local variables. The Closures section in Level 38 changed to show this.
  • If a lambda expression does not need a variable, it can now use a discard for the variable (Level 38).
  • When you override a method, you can now specify a more specific return type (Level 26).
  • When the compiler can infer the type, you no longer need to list the class name when using new to call a constructor: Point p = new (x, y);. See the new subsection called “Leaving Off the Class Name” in Level 18.
  • Lots of new improvements to patterns, including the and, or, and not patterns, as well as the >, <, <=, and >= patterns. See Level 40.
  • init accessors for properties, in addition to get and set. These cannot be set whenever, but can be set in the constructor or in object-initializer syntax. See the revised section called “Object Initializer Syntax and Init Properties” in Level 20.
  • Records are a new special type of class that is data-centric, with extremely compact definitions. A whole new level exists for records: Level 29.
  • Top-level statements. More on that later.

Second, I made some rather significant changes to the internal visual design of the book, changing a number of fonts. I was able to increase the font size and reduce the page count (weird, right?), and every graphic designer I have talked to about it has suggested a serif font is better for long reading than a sans-serif font, which is what drove the change more than anything else. I suspect there are a few places here and there that didn’t get the appropriate font change. If something looks out of place to you visually, I’d love to hear about it. I’m using styles through and through, but there are a lot to manage, and it is easy to miss them here and there. I will still be going through everything with a fine-toothed comb at least one more time, but I could definitely use your eyes to help.

Third, I spent time getting an early version sent to the printer to make a physical copy. It takes time to get that going and to get a copy shipped, so I have yet to see the physical edition, but it should be available in the next few days. I’m generally expecting to get an updated physical copy every week starting now, to help track down those issues that only reveal themselves in print.

Now let’s talk about that top-level statement thing in more depth. C# 9 added a feature called top-level statements. It allows you to ditch the whole namespace blah, class Program, and public static void Main(string[] args) and just write something like System.Console.WriteLine("Hello World!"); as a complete program. The compiler generates a Program class and a Main method of sorts, so it is still technically doing the same thing. Just with less typing.

It is helpful for new programmers, because you don’t have to know what classes, namespaces, and methods are, nor static, void, and string[]. You can just start really basic. It is also helpful for everybody else too. I’m not sure I’ll ever write another public static void Main in my life. For large programs, this change has only the tiniest impact on your overall code. But for small programs, it greatly reduces the amount of ceremony and pomp around creating a basic program.

As you may know from my mid-week email asking for feedback on how to approach top-level statements, I was very conflicted on how to address this. I could just leave things more or less as they are and put a small blurb late in the book that said, “By the way, there’s this other syntax,” or I could change the entire beginning of the book to allow people to ease into C# better by using top-level statements to get going. It was a hard decision (and even now, I continue to wonder) but I decided that top-level statements are probably the way to go. It definitely eases the learning curve for new programmers, and while 99.99% of current C# code uses the traditional Main entry point, future code will likely slant towards top-level statements. So lots of the book was reworked to account for this.

There is now a note right at the beginning of the book that has you turn on a feature in Visual Studio (16.8) to make using top-level statements easy to begin with. Level 3 (Hello World) got a pretty substantial rewrite, including telling you to delete the contents generated from the template and replace it with a top-level statement. The Methods level got some pretty significant changes as well. So if you’re past that, you might want to skim it. And the Enumerations and Classes levels got some adjustments, mostly around where to place new type definitions. Finally, Level 33, which used to be about namespaces, is not about namespaces, splitting your code into multiple files, and the traditional Main entry points. Because methods created as a part of top-level statements are local functions, the section on local functions was also moved up one level.

There is one important drawback: as the book currently stands, it assumes that you will have Visual Studio 16.9 in your hands. That is not out yet, and I was told by somebody who knows that it will not likely be released in December. Until it is out, you will have to enable the preview feature described in the note at the beginning. My initial thought is to delay the release of the book until Visual Studio 16.9 (16.x is Visual Studio 2019, if that helps avoid confusion with their double-versioning scheme) is out, probably in January or maybe February. I do still have the option of putting into the book something to the effect of, “If you are using a version before 16.9, go turn this thing on. Otherwise, you don’t have to do anything.” That would allow me to not have to wait for the final 16.9 release.

My decision about top-level statements is made, but it is tentative. I got a lot of comments (split fairly evenly) on what approach to take, and for many people, feelings were pretty strong. I’d be interested in hearing from you again now that you have a version to review in your hands. (Whether it changed your mind or not.)

The next big efforts are creating solutions to the challenges, updating the cover, and beginning the final, fine-grained revision pass (copyediting, indexing, checking that the sample code all compiles, etc.). We’re getting to the end!

4 December 2020

Early Access #8 is available, and the entire book is now there! I was able to finish the last nine levels (chapters), as well as the glossary and the tables and charts.

There are several big efforts still remaining:

  • Update the book to C# 9.
  • Get the website ready, including a few articles that the book calls out that don’t exist yet.
  • Create solutions for all the challenges.
  • Update the cover.
  • Update the index.

The focus for next week will be on C# 9 features. I don’t know that it will be done by the end of Early Access #9, but whatever is ready will be included.

27 November 2020

Early Access #7 is available. This includes six new levels (chapters):

  • Level 32: Namespaces
  • Level 42: Threads
  • Level 43: Asynchronous Programming
  • Level 44: Dynamic Objects
  • Level 49: Unsafe Code
  • Level 50: Other Features in C#

That puts us at 46 of 55 total levels or 84%. It is 417 of 515 pages by page count (81%) though the revision pass that I am doing is cutting out pages in high numbers. The final page count will be under 500 pages.

20 November 2020

Early Access #6 is available. It is a nice feeling to have that done with most of the weekend still ahead of me to carry on with the book without pressure.

This includes 8 new levels (chapters):

  • Level 34: Exceptions
  • Level 35: Delegates
  • Level 36: Events
  • Level 37: Lambda Expressions
  • Level 38: Files
  • Level 39: Pattern Matching
  • Level 40: Operator Overloading
  • Level 41: Query Expressions

Level 33 (Namespaces) is still not ready, giving us 40 of 55 total levels or 72% of the full book by chapter count.

Of course, even when this revision pass is over, there will be plenty to do still, including updating the book for C# 9, creating solutions for all of the challenges, and updating the cover.

I think the guess of Late December seems quite reasonable still.

And since I have somehow turned these updates into updates about the kitten, too, you will be happy to know that he is doing great and growing up fast. (Still only gets to the litter box half the time, but he weighs twice as much as when we found him! He is now probably about five weeks old, and we have had him here for the last two.)

13 November 2020

Early Access #5 is now up. The earliest I have ever been, which is nice. But it comes at a cost: This is from only five days, all of which were workdays. So it is a small update.

This adds only a single level (chapter) to the book, though a second level was merged into it. So the book is two chapters closer to being done.

This also adds a partial solution for the Fountain of Objects challenges. I’m not done with all of them, but I am done with a few, so I’ve made those solutions available.

It also includes many small grammar and spelling fixes, many of which were reported by readers. Please keep the feedback coming, no matter how big or small!

Also, the cat seems to be doing good. He was not eating and not pooping, but he has been doing both, and after losing several ounces of weight, he has regained all of it and a bunch more. I think he’ll end up being fine! (Though I will also say he has taken up some time and sleep that might otherwise have gone into the book. But I don’t regret that for a moment.)

8 November 2020

I’m a day later than I’d like. We found an almost 3-week old abandoned kitten and have been trying to take care of it. That’s very time consuming, though I don’t regret it. Hopefully, he (we think) comes through okay. He seems lively and happy but isn’t eating as much as he should and hasn’t pooped in the 36 hours that we have had him, so we’re worried about that too. (Yes, we’re stimulating him.) We’ll take him to the vet tomorrow if he doesn’t start pooping and eating more.

Anyway… future releases can hopefully get back to Friday night or Saturday morning now.

Early Access Release 4 is now up on Gumroad and includes 7 new levels (chapters), along with the usual small fixes for typos and unclear sentences. This completes Part 2 and is also now 31 of 56 total levels. However, I will be going through the challenges in the level called The Fountain of Objects, which is the book’s most extensive program besides the final battle. I had wanted to do that for EA 4 but needed to abandon that plan. However, my initial attempt at a solution made me decide to restructure some of the challenges there. I did that to make them clearer and simpler. Putting together my own solution in the coming week may result in additional changes.

I have also revised my guess about when the book will be done to late December. I’m still hopeful it could be early to mid-December, but I keep pushing it out, and that makes me think I need to make a bigger adjustment. So I’m currently guessing late December, but Early Access releases will come every week until then, either way.

A final note: This week is the .NET Conf, and C# 9 and .NET 5 will be officially released. I was hoping to have the 4th Edition ready to go about right now, but I won’t be. You may find some of the sessions about C# 9 and .NET 5 interesting, and a preview of how The C# Player’s Guide will be modified to account for those in the coming weeks!

31 October 2020

Early Access Release 3 is now up on Gumroad, including two new levels (chapters) and some fixes for typos and unclear sentences. This includes a level solely focused on building some more significant programs, including Tic-Tac-Toe. (3rd Edition had a chapter called “Tic-Tac-Toe,” though this is substantially revised.) This release includes solutions to all of the challenges in that level since they are more substantial than others before it. (Eventually, they will all have answers.)

24 October 2020

Early Access Release 2 is now up on Gumroad, including eight new levels (chapters), some fixes to page numbering and XP, and other typos.

17 October 2020

Early Access Release 1 went up on Gumroad today: https://gum.co/oKNdk

I’ve set the cost at $9.95, but I expect that to go up as the book gets closer to completion. (The 3rd Edition’s digital version is $29.95, for reference.)

Keep these two points in mind:

  • This is only Part 1 of the book. The other chapters need more revision before being included.
  • This is digital-only. No physical book is included in this now or later. (A physical book will be available when the Early Access is complete. If you want a physical book, your best bet is to buy the 3rd Edition, which is already available, or wait a few more weeks for the 4th Edition.)

Anybody who joins the Early Access will get all other Early Access releases until the final release (as well as any patch releases I make after the official release). So this is an excellent chance to get it cheap if you’re okay dealing with a few rough edges here and there.

If you are willing to commit to putting some effort into reading it and doing the challenges, and providing thoughtful feedback, please email me. With a commitment to helping me make it better, I can get you a code for a discount on the book. An ally who will help me find the issues so I can fix them is worth more than the few bucks I’d get from Gumroad at this point.

Early Access Release 1 does not contain the entire book. It only has Part 1. That is the only part that has had a serious revision pass completed on it. More chapters will be added soon. But for somebody working through the book, they can get started on the first 100+ pages now and get the rest of the updates over the coming weeks.

I expect to put out a new Early Access Release with any changes, fixes, and improvements to existing content and add in the new chapters that have had a revision pass. This should happen roughly weekly on Friday or Saturday until the final release comes, probably in 4 to 8 weeks.

This is a big deal, and if you have any questions about what to expect with Early Access, feel free to contact me (rbwhitaker@outlook.com).

You can also track the progress of Early Access through this GitHub page: https://github.com/rbwhitaker/CSharpPlayersGuideEarlyAccess/.

With that, I’ll update my guess for publication to sometime between mid-November and early December.

4 September 2020

I’ve been making progress this week towards the first digital-only early access release of the book. I have at least another week of that, but it might be two or three weeks.

In my next update, I can post more numbers for percentage complete, as I have been cleaning up my backlog of items to do.

Here’s a high-level to-do list that I think is needed before Early Access:

  • A revision pass through every chapter. (So far, I have done about 5 of 55-ish.)
  • Reworking the quizzes throughout the book.
  • Marking some sections as Side Quests.
  • Deciding what to do about marking key points in the book as special (or deciding not to do this).
  • Changing the order of some of the late chapters in the book.
  • Some additions to the Try It Out challenges in the book.
  • Making the cover say 4th Edition, even if it isn’t the final version of the cover.

27 August 2020

I was going along with pretty frequent updates for a while there and then stopped. But rest assured, I’ve put lots of time into the book in the meantime.

It is time for another update, though: I expect the 4th Edition of the book to be available in November of 2020 when C# 9 and .NET 5 are released.

As I was doing revisions in January, I began to find more and more things I wanted to change about the book. I ended up in a situation where I decided to significantly revise almost every aspect of the book. In some ways, the 4th Edition is almost a complete rewrite. Not exactly, but close.

So here we are, nearly eight months later.

I feel reasonably confident that the November deadline will hold this time, and the book will be much better for the delay.

I’ve also been considering something I haven’t done before: making a digital-only version of the book available in an Early Access format. It could be a good way to get some extra eyes on the book early on while also allowing people who want an updated version before November to have it. I am not yet committed to doing that, but it’s a distinct possibility. It will probably be at least a couple more weeks before that happens if it does happen.

As far as my percent complete that I was reporting, I was thinking today that I maybe should file bankruptcy on it. My next step is to do a lot of cleanup of my to-do list, and I’m tempted to just toss it and start fresh. I’ll let you know what I do in the next update. (I’m hopeful that updates can come every few days from now until publication to keep you all informed of the current status.)

1 January 2020

Currently there are 164 issues involved in the project:

  • Done: 73 (44.5%)
  • In Progress: 0 (0%)
  • To Do: 91 (55.4%)

I’ve completed 26 tasks in the last couple of days, but I also added in 89 more tasks as well. (And that doesn’t include ones that got added to a later version of the book.)

But I hit a rather significant milestone today: all of the C# 8 content is now largely in place.

Roughly 60 of the new issues are in a “taking stock” category, which is stuff for me to go through the book and itemize what else still needs to be done before the official release. That’s my next step, and should knock out about 60 total items of the 91 left to do, but will also likely produce a number of other new items. Once that is done, the number of tasks being added to the project should flatten out quite a bit.

Estimated completion date is still late January 2020.

30 December 2019

Currently, there are 75 total issues involved in the project.

  • Done: 47 (62.6%)
  • In Progress: 1 (1.4%)
  • To Do: 27 (36%)

While I’ve completed a lot more (approaching 2/3 of the way) I’ve also added in a lot more tasks. Many of these are small-ish.

Again, my latest projection for the book release is January 2020, but probably on the late end, with a small chance of flowing into February. As we get late in the process, I start ordering physical copies to see what still needs to be tweaked, and that is a longer feedback loop.

More to come soon!

15 December 2019

The 4th Edition of the book is coming along. New tasks come up every day, but also every day, tasks get checked off.

Currently, there are 62 total issues involved in the project.

  • Done: 27 (43.5%)
  • In Progress: 19 (30.6%)
  • To Do: 16 (25.8%)

A big part of the “In Progress” ones are related to the rewrite an/or addition of five different chapters, and they’re (unfortunately) moving through the pipeline right now in sync with each other. When they go, they might all go together.

Outside of work, all of my focus and attention is currently going into this 4th Edition.

The earlier numbers are concrete; they are 100% accurate of the current situation. This next number is a wild guess. My best guess is that the 4th Edition will be sometime in January of 2020, so depending on your time table for learning C#, waiting until the 4th Edition arrives might be worth it.

If you have any questions about the state of the 4th Edition, don’t hesitate to contact me.

Also, if you have some experience with C# in the past (like if you bought the 3rd Edition and have been through it) I’d love to get some reader feedback on the new chapters in the works for the 4th Edition. The time frame is kind of tight. Probably over no more than the next 10 days or so. Let me know if you’re interested. (It won’t be the whole book, just the specific new chapters, so it won’t be self contained in terms of learning. That’s why I’d ideally like to get people who have already been through the 3rd Edition or have some familiarity with C#. But I’ll take whoever is interested right now.)

Unfortunately, I don’t have anything to offer, in the way of payment or reward for helping out in this way. (Other than you get access to a draft of the content before most people do, in exchange for some feedback from you about what’s working and what’s not.)

Expect more updates as we get closer to the publication date!