I have finally finished reading C# 4.0 in a Nutshell!

I did it. I read a thousand page (well, 995 pages with a six page Preface) reference manual on C# 4.0! Since I've been reading it everyone has started using C# 4.5 and I've had four different jobs. I was obsessed with reading this book in 2012 and managed to read 700 of the pages before 2012 ended, but this year I've really been burnt out and have been reading at a rate of a page a day. The last quarter of the book is on threading and various patterns for safely locking objects that multiple threads will use. I was pretty checked out in reading that stuff. There is surprisingly another quarter of the book which is on XML stuff. (transforming XML, serializing types to XML, etc.) The other half of the book which was the not the quarter on threading nor the quarter on XMLing was really, really good however. Now I can really said I've read something, though I think one of the lessons from this is not to read a thousand page tomb again. I am much stronger for it. Congratulations to Joseph and Ben Albahari for writing the informative: C# 4.0 in a Nutshell! They are smart men to say the least. Here is what I've learned:

1. Encapsulation in contrast to the Open/closed Principal
2. M magic for decimal creation
3. default values for value types in an array
4. bottleneck through parent
5. virtual and override
6. casting a child class to a parent interface
7. delegate example
8. Func example
9. use Action instead of Func when you wish for a Func to return nothing
10. multicast delegate example
11. closures
12. = () =>
13. events
14. Math.Pow
15. Put methods in a class that require casting to an interface to use!
16. how getsetters reflect
17. user interface technologies
18. DateTimeOffset
19. using IFormatProvider and ICustomFormatter
20. using string.Format with flags enums
21. set the culture of the current thread
22. Tuples
23. Process
24. predicates
25. Array.ConvertAll shows off the power of delegates
26. type-changing across .Select
27. lazy execution of IEnumerable
28. expression trees
29. query from one IEnumerable type collection to another
30. .AsEnumerable()
31. .AsQueryable()
32. Upcast to an Interface!
33. Cross Join Queries and Non-equi Join Queries
34. expressions in C#
35. Skip and Take
36. Join/Distinct/Union/Structs/lookups
37. Intersect/Union/Except
38. SelectMany
39. let
40. LINQ to XML
41. XML, XPath, and XSD
42. XSLT
43. IDisposable
44. using
45. Code Contracts
46. Contravariance
47. where T : Whatever
48. File I/O
49. Networking Cheat Sheet
50. remoting
51. the GAC has priority over the bin
52. instance method
53. the parameterless constructor on a base class is always called
54. attributes
55. use dynamic to add nonspecific types in C# 4.0
56. use dynamic to cherry pick more specific types
57. visitor pattern
58. dynamic method calls
59. static state
60. unmanaged code and the C# extern keyword
61. #if(!DEBUG)
62. encrypt and decrypt
63. signature versus public key handshake
64. finalizers
65. threading
66. write your own equality comparisons
67. spinning
68. why use PLINQ?
69. why not use PLINQ?
70. asynchronous methods
71. MarshalByRefObject
72. unsafe
73. fixed
74. handing in delegates to APIs
75. COM
76. regular expressions
77. conclusion

 
 

Addendum 1/25/2014: Please see this as it turns out the post you are looking at is not the last post on C# 4.0 in a Nutshell.

 
 

Addendum 3/14/2014: My reference to C# 4.5 should really be a reference to the ASP.NET 4.5 Framework which uses C# 5.0.

 
 

Addendum 6/2/2014: This is yet another blog entry after I thought I was done blogging of C# 4.0 in a Nutshell.

 
 

Addendum 6/24/2014: This is still yet another blog entry.

 
 

Addendum 3/1/2015: Yet again!