C# From the Ground Up

This will be a basic introduction to the C# language and its runtime. We will cover the entirety of the language, up to C# 4.0, and at least some of the base class libraries in the .Net framework. Basic familiarity with these classes is essential in gaining proficiency in the language.

    no lectures added

Everyone taking this course should have taken at least one programming course in the past, preferably in a C-like language (think: curly braces). Though you you may be able to get by if you have a background in something else (say Ruby or Python, for instance), there are some things that have no direct parallel in other languages that come under the heading "C-like" (namely, things like static typing). Additionally, if you have no idea what Object Oriented programming entails, you may have difficulty coming up to speed on some of the advanced topics.


There is no formal syllabus, per se. I may submit links or add documentation that I think might be illuminating. My guess is that the vast majority of learners would benefit most from the video tutorials that would accompany the lessons. I have yet to decide where the videos will be posted (if someone in on the subreddit has any idea, I'm open), but everything that I do will be referenced via the subreddit.

I need to do some research into how to do video with an audio mic, so I probably won't start until the first or second week in July. Full details will, again, be posted in the /r/CSharpFromTheGroundUp subreddit.

Note: I actually no longer own a copy of Visual Studio (I prefer eating), so all of the lessons will be given using the MonoDevelop IDE. Shouldn't be to much of a stretch for anyone to follow along, as we will be focusing on the C# language and not on any of the advanced features of Visual Studio. I dont' have enough hours in the day to cover how to get either Mono or Visual Studio installed, so please use google to have that done before we start the first class.

In general, the outline will be as follows:

1) Basic looping constructs and control flow statements: Though everyone taking the course should have at least some basic programming background, we will cover some of the subtleties that C# has in its control flow constructs. Since these constructs are involved in 90% of the code you will ever write, it's best to make sure that they are thoroughly covered.

2) Types and Objects: We will do a gradual introduction to the concept of what a type is and why you must conform to the .Net runtime type system. We will, of course, cover the Object Oriented type system that .Net provides, as well as some how the C# types map to the underlying .Net infrastructure. We will gain just enough information to figure out when we can use subclasses and when we can't (i.e. when using structs). At this point, we will also briefly cover what an Assembly is and what they contain.

3) Method Signatures and Polymorphism: After we begin creating simple objects, we will cover how to construct methods, how to override methods in the inheritance hierarchy, and how polymorphism relates to method signatures. Additionally, we will cover properties, and their underlying implementation. We will also cover some constructs that are unique to the .Net runtime, like "out" parameters and give a preview of delegates.

4) Interfaces and Inheritance: Having covered the basic "hows" of object inheritance, including overriding and polymorphism, we will cover how to leverage .Net's Interfaces to construct more flexible systems. We will also cover when to create more complicated inheritance hierarchies -- and why you often shouldn't. We'll talk a little about type discovery and conversion (using "is" and "as"), since everybody, no matter how careful, has to do it every once in a while.

5) Static, Readonly, Public, Private, and other Straight Jackets: There are a multiplicity of ways you can expose your objects to the outside world. There is even more than one way reference objects in the system -- not just using "new". We'll cover the relationship between these conventions and their relation to the underlying implementation.

6) .Net, Types, and Resources: There are no free lunches. At some point, you have to clean up after yourself. We'll talk a little about how to think about the .Net runtime (for instance, its reliance upon Garbage Collection) and how we can use the language to pick up after us (with the "using" statement), since laziness is a virtue. We'll also cover, at a high level, what the .Net runtime is as well as the how your code runs on the platform. We may also cover what null really is and what use nullable types can be (though we may need to move this into the section on LINQ for it to make any sense).

7) .Net Runtime and Generics: Now that we've covered quite a bit of the basic semantics of C#, we should spend some time familiarizing ourselves with the base class library. The BCL, as it's more commonly referred to, does the vast majority of your heavy lifting while you're coding. We will introduce ourselves to the steadfast DateTime, String, and other System.Collections.Generic classes. During this process, we will cover what generic types are, why they're useful, and how you can use them in your own programs.

8) LINQ and IEnumerable<>: This is one of the neatest areas in .Net. We're going to cover how to leverage the LINQ syntax to perform complicated transformations and querying of data. We will see how intimately tied to .Net's implementation of IEnumerable<> this system is, and how you can leverage it to do interesting things like query a database with LINQ to SQL.

9) Anonymous Types and Delegates: Continuing on our perusal of the LINQ landscape, will will cover these two attendant ideas, which are often quiet helpful in constructing more readable programs. Anonymous types allow us to create new kinds of statically typed objects that we didn't have to define before, and delegates (also often called lambda expressions, though they're essentially the same thing) help us to add additional coding logic in places where we would otherwise obfuscate our code with a method call. We'll learn how these two things allow us to do things with LINQ that we might not have envisioned doing without them.

10) Assemblies and Reflection: In order to really understand what it is that you're building when you compile your C# code, we need to look at what an Assembly is and how we can access running assemblies internals to do strange and wonderful things. This will also lead into a discussion of the new keyword "dynamic" and how the .Net runtime now seems to care less about what type you're dealing with (though, that's really just a carefully constructed illusion).

11) Annotations, Extension Methods, and Partial Classes: Here, we really begin to see how the tools of Reflection and the .Net type system allow us, in C# 4.0 to use new and interesting means of extending existing types and adding information to classes that we control.

12) Feature Grab Bag: Anything I didn't cover up till now is up for grabs. Pick a subject that you'd like to learn more about, and let me know. We can cover anything you like.

Throughout the course, the focus will be on programs that may be relevant to you. In fact, I can assure you that the only way you really learn to do something is if you're actually interested in doing it. Thus, when you subscribe to this class on Reddit, please add some information about your background any particular genre of programming you would like to cover. I can't promise that I can craft a homework schedule that cope with everything you may be interested in, but I can promise that I can at least lean towards technologies and techniques that you may find useful in that domain.

In general, the homework will expound upon some feature just covered in the lesson. I have never taught a course before, and I have a sense that I may be a real hard-ass about giving out tough homework problems. If I go over your heads, I need you to let me know, so that I can balance the course with your needs. There's no point in trying to learn how to swim when you're already drowning.

Now, all that being said, I will try, in a non-trivial way, to make you think hard about a serious problem. Success is not guaranteed, but you will be generously rewarded by thinking long and hard about the problem. Solutions may be posted at some point, but what would probably be better is simply posting your code to your github account after the assignment is over, so that I and others can review your solutions.

Additional information

There's a big long list of C# features you can find here:


There is no possible way that I can cover them all, but if you're interested in something I don't seem to cover, please let me know, and I'll find a way to insert it into the course. This is course that must be lead by you, the student, since I already know the language and have no way of telling what features you may want to use in your own programs.

I may occasionally slip into "design pattern/object speak", so if anything doesn't make sense to you, please post it to the subreddit so that I can cover it in a later lecture.

Teacher qualifications

I've been a software developer for 6 years or so, much of that time spent programming on top of .Net. I don't know everything about the platform, but I know enough to help somebody pick up the basics and run with them.

I currently program mostly in Ruby now, but I still remember where the '{' key is.

Latest Update


1. mknull
2. ParaIdioma
3. Cigue
4. Malpercio
5. Jasdev
6. gravespr
7. oluap
8. SpookyFish
9. AgentZac
10. stuntaneous
11. druid_king9884
12. blastdan
13. ilogik
14. ptj
15. doptimusdx
16. Zamarok
17. Booray
18. immadeofpoison
19. poorasian
20. ckentlea
21. d3vin
22. almkrist
23. scapegoat57
24. lyris
25. flyer456654
26. Freakazo
27. anastas
28. BlueMoon
29. xOnic
30. sm_36688
31. autotom
32. lazylenz
33. genron1111
34. memphislynx
35. MrWeb20
36. Cheesybean
37. monkeyfacebag
38. Prodarkangel
39. blueyoshi
40. Arthree
41. Jarth
42. GoGoGodzilla
43. frefyx
44. thisismygame
45. AllHailWestTexas
46. blahblah984
47. dwhiteazn
48. kru89
49. propolandante
50. laur
51. PlastixMonkey
52. PlastixMonkey
53. varswap
54. wafflebook
55. elexhobby
56. PimpNinjaMan
57. Mason
58. karlgnarx
59. Mr_Moe
60. karlgnarx
61. LowlySpartan
62. thegreatandpowerfulOZ
63. Hackenslacker
64. SmoothCorn
65. shriek
66. HansJuan
67. pinion_
68. kousinkar
69. djr_
70. sniuff
71. salvager
72. Caedo
73. vexleir
74. mangostache
75. saetekm
76. Marshall.Hallenbeck
77. Leftmer
78. skippai
79. fashion4
80. mukan
81. Jamie
82. ghsteo
83. hungoverbunny
84. DeveloperSpike
85. tpo_ca
86. RedVee
87. firen22
88. gangarajusk
89. shawn524
90. ArmchairPhysicist
91. xerohour
92. walking_distance
93. ivers17872
94. kaixi
95. chirwan
96. partlycloudy
97. Rubuler
98. schizocat
99. Duckball
100. Cpierswim
101. eideas
102. lambeosaurus
103. unclemeow
104. poolstiksamurai
105. technitrox
106. joli
107. tekiran
108. T_T
109. jhyde
110. hutch34
111. amxn
112. ZeppelinJ0
113. claff319
114. heckler0077
115. Revolution
116. fivetanley
117. Jensr
118. exchan
119. tirian
120. Elarania
121. trcm
122. dvoraklol
123. thingdeux
124. dranomaly
125. kace714
126. fakshh
127. bokonon9
128. Myself
129. ehamilton
130. coderseal
131. Mclarenf1905
132. arrnas
133. dare599z
134. phiberoptik957
135. morethanvulgar
136. JollyBard
137. ebzero89
138. aaron
139. invisibleman
140. Danimalion
141. will_eat_for_food
142. jrstoltz
143. eggoeater
144. naturefreak827
145. aDFP
146. johnsonnc
147. DrPiD
148. jtt02
149. LakatosI
150. warlockkaal
151. darkfalz
152. Hooded_eskimo
153. Obligator
154. noiplah
155. MWadman
156. Capochetta
157. gyrosash
158. donnywiththegun
159. andersonxe
160. ivantse
161. rdasilva
162. emptyvoices
163. ben9105
164. jhoiz
165. twoje
166. Zelchan
167. jfs
168. digigopher
169. path411
170. Acrazia
171. Protagoras
172. Psyballa
173. Wettam
174. tylerofathenry
175. michaelburns
176. Tethylis
177. zelladolphia
178. zelladolphia
179. Bozzard
180. Viagraine
181. nina107c
182. totocus
183. Lumen
184. xkaiserxremx
185. rleese
186. Lkz
187. I_prefer_11_and_7
188. dman_in_a_can
189. veasse
190. maj21
191. serialnommer
192. xrox122
193. Johnny-Stu
194. ohgasm
195. nmulcahey
196. nmulcahey
197. alyssa_w
198. stayclassytally
199. c_d_u
200. revrigel
201. krystalxjohnson
202. giftedrage
203. megadrive
204. tulle
205. massivelemon
206. assassingriff
207. GhostHat
208. SkittishLodger
209. JOELturnthetvdown
210. killerabbit37
211. CompPhysicist
212. m0rph3r
213. ineedclass
214. shagnasty
215. touchme12
216. jonxed
217. jatoskep
218. vks24
219. clownwig
220. Vashy
221. Rilthy
222. toogad
223. av607
224. av607
225. valenluis
226. Anqueetus
227. Drewley
228. berjdo
229. phi
230. wwmorbodo
231. mitsuharu
232. faykour
233. Karlito
234. toefuta
235. 4dspacewhale
236. 4dspacewhale
237. 4dspacewhale
238. twisterrust
239. polnisch_vodka
240. ladeedaaaa
241. algor
242. cocushio
243. abcdefghijklmno
244. EvilNorwegian
245. youremywifenow
246. JumpinJimmy728
247. merqiwaters
248. ranveer5289
249. 00speeddemon00
250. airwolf
251. grizw0ld
252. drhydralisk
253. wadall
254. Chalky
255. sistermoo
256. zafarmukeri
257. Frietjes_met_toscaanse_saus
258. longlivetoni
259. NetGhost03
260. layzeegrimm
261. spamNham
262. maximx
263. connell
264. bxia
265. AHoodedEskimo
266. eitauisunity
267. gotime11
268. kevnoto
270. leunamme
271. PlotCitizen
272. tufyhead
273. chu_ogu
274. Plastilinovaya
275. stevepm1
276. spiffai
277. dios496
278. largemargin-
279. akrz
280. WonderPlus
281. TauntingFrenchGuard
282. suprit
283. thesourabh
284. dourk
285. BogdanSin
286. 38snub
287. awbauer
288. mspaintcreeper
289. mryasir
290. timmahh
291. Captain-Lightning
292. Kimgirl50
293. CheeseNips
294. enamy
295. mzuowei
296. best_username
297. voldyman
298. aponyforeveryamerican
299. kayakguy429
300. swim2muchmk
301. swelldom
302. ipeeonhoes
303. Beginner
304. Brain21
305. MyKeyLV
306. AideE
307. kyrodck
308. wonderwander
309. p00dle
310. savagepm
311. BadNeon
312. Tavvat
313. icyhail