Earlier this week I passed the Microsoft “Programming in C#” exam.
I’ve been studying for it over the last few months, and have been compiling the blog post in the process in case the info useful to someone else.
This is main starting point for the exam: http://www.microsoft.com/learning/en/us/exam.aspx?id=70-483.
The main syllabus is as follows:
- Implement multithreading and asynchronous processing
- Use the Task Parallel library (ParallelFor, Plinq, Tasks); create continuation tasks; spawn threads by using ThreadPool; unblock the UI; use async and await keywords; manage data by using concurrent collections
- Manage multithreading
- Synchronize resources; implement locking; cancel a long-running task; implement thread-safe methods to handle race conditions
- Implement program flow
- Iterate across collection and array items; program decisions by using switch statements, if/then, and operators; evaluate expressions
- Create and implement events and callbacks
- Create event handlers; subscribe to and unsubscribe from events; use built-in delegate types to create events; create delegates; lambda expressions; anonymous methods
- Implement exception handling
- Handle exception types (SQL exceptions, network exceptions, communication exceptions, network timeout exceptions); catch typed vs. base exceptions; implement try-catch-finally blocks; throw exceptions; determine when to rethrow vs. throw; create custom exceptions
- Create types
- Create value types (structs, enum), reference types, generic types, constructors, static variables, methods, classes, extension methods, optional and named parameters, and indexed properties; create overloaded and overriden methods
- Consume types
- Box or unbox to convert between value types; cast types; convert types; handle dynamic types; ensure interoperability with unmanaged code, for example, dynamic keyword
- Enforce encapsulation
- Enforce encapsulation by using properties, by using accessors (public, private, protected), and by using explicit interface implementation
- Create and implement a class hierarchy
- Design and implement an interface; inherit from a base class; create and implement classes based on the IComparable, IEnumerable, IDisposable, and IUnknown interfaces
- Find, execute, and create types at runtime by using reflection
- Create and apply attributes; read attributes; generate code at runtime by using CodeDom and lambda expressions; use types from the System.Reflection namespace (Assembly, PropertyInfo, MethodInfo, Type)
- Manage the object life cycle
- Manage unmanaged resources; implement IDisposable, including interaction with finalization; manage IDisposable by using the Using statement; manage finalization and garbage collection
- Manipulate strings
- Manipulate strings by using the StringBuilder, StringWriter, and StringReader classes; search strings; enumerate string methods; format strings
- Validate application input
- Validate JSON data; data collection types; manage data integrity; evaluate a regular expression to validate the input format; use built-in functions to validate data type and content out of scope: writing regular expressions
- Perform symmetric and asymmetric encryption
- Choose an appropriate encryption algorithm; manage and create certificates; implement key management; implement the System.Security namespace; hashing data; encrypt streams
- Manage assemblies
- Version assemblies; sign assemblies using strong names; implement side-by-side hosting; put an assembly in the global assembly cache; create a WinMD assembly
- Debug an application
- Create and manage compiler directives; choose an appropriate build type; manage programming database files and symbols
- Implement diagnostics in an application
- Implement logging and tracing; profiling applications; create and monitor performance counters; write to the event log
- Perform I/O operations
- Read and write files and streams; read and write from the network by using classes in the System.Net namespace; implement asynchronous I/O operations
- Consume data
- Retrieve data from a database; update data in a database; consume JSON and XML data; retrieve data by using web services
- Query and manipulate data and objects by using LINQ
- Query data by using operators (projection, join, group, take, skip, aggregate); create method-based LINQ queries; query data by using query comprehension syntax; select data by using anonymous types; force execution of a query; read, filter, create, and modify data structures by using LINQ to XML
- Serialize and deserialize data
- Serialize and deserialize data by using binary serialization, custom serialization, XML Serializer, JSON Serializer, and Data Contract Serializer
- Store data in and retrieve data from collections
- Store and retrieve data by using dictionaries, arrays, lists, sets, and queues; choose a collection type; initialize a collection; add and remove items from a collection; use typed vs. non-typed collections; implement custom collections; implement collection interfaces
Firstly, the most useful book of the lot:
Pro C# and the .NET 4.5 Framework 6th Edition (Professional Apress)
This gives a good in-depth treatment of most of the exam topics. It’s comfortably the best book out there for content and coverage, and come recommended by the community in general. I would choose this above the study guides any day.
Next, the official study-guides:
EXAM REF 70-483: PROGRAMMING IN C#
This is Microsoft’s official offering. It took some time in coming out (a full 10 months after the exam was commissioned), however this is probably not a bad thing. I owned the 70-515 study guide exam which had 189 Confirmed and 70 Unconfirmed errata, many of them serious technical faults. At the time I wrote a review on Amazon opining that Microsoft should have been ashamed, and I stand by that. This book is a vast improvement on previous standards by Microsoft.
The book (slightly bizarrely in my opinion) treats the subject matter in syllabus order. This means that, right at the very start, we are thrust into the world of multi-threaded and the Task Parallel library when maybe you want a more gentle introduction.
MCSD CERTIFICATION TOOLKIT (EXAM 70-483): PROGRAMMING IN C# (Wrox Programmer To Programmer)
This was my favourite of the two “offical” study guides dedicated exclusively for the exam. It treated the topics in a sensible order and gave handy tips and hints throughout. The best thing about this, book, however is the numerous example questions and the cheat sheets – Which can be downloaded for free online!
CLR Via C# 4th Edition (Developer Reference)
An outstanding book, that delves deep into the fundamentals.
Part 1 “CLR Basics” was tough reading, although there was some useful stuff on assembly signing towards the end.
Part 2 “Designing Types” goes into the details of the fundamental basics of the core type-system constructs, and I would say is essential reading.
Part 3 “Essential Types” gives information on the core types. Again, essential reading.
Part 4 “Core Facilities” – Very detailed treatment of CLR core facilities. I found the stuff on Garbage Collection useful and readable.
Part 5 “Threading” – Very detailed treatment of multi-threading.
C# in Depth
Suffice to say, this is an absolute classic that should grace the bookshelf of every C# developer. The 3rd edition was due publication at the time of writing,
C# 5.0 Pocket Reference: Instant Help for C# 5.0 Programmers
Less than a tenner, and really useful for jogging your memory on stuff. It gives the absolute minimum it needs to on each topic so can be treated as a good starting point.
LINQ Pocket Reference (Pocket Reference)
This gave the best concise overview on the whole of LINQ than anything else I encountered.
Programming In C# Jump Start
This is a useful course split into eight modules across fairly sensible boundaries. You could watch the whole course or pick what’s relevant to you.
4. Articles on This Site
I made lots of notes in electronic form, and saved them as private blog articles. Most of it was taken from the official study guides, and was in note formal not suitable for publishing, however there were a few that flourished into full-blown articles.
At the time of writing, MSDN lists 100 Reserved and Contextual keywords. Given their list, could you describe each, including those with overloaded uses? I’ve detailed them here in the article The Hundred Keywords of C#.
10 Kinds of Things
In his book CLR via C#, Jeffrey Richter details the 10 different kinds of things that can go in a type. Learning and understanding these gives a useful coverage of some topics. I’ve written about it here: Delegates, Events and The 10 Type Members of C#.
None of the books covered this topic very well in my opinion, and the relevant information on MSDN was strewn across a number of different pages. In the end I pulled what I felt most relevant into the following: Notes on C# Performance Counters.
5. Practice Tests
As already noted above, both the study books have practice questions within. The Wrox sample questions can be downloaded for free online.
You may well be tempted to download some of the “brain-dumps” available online, however bear in mind that this is against Microsoft’s Exam Policy, and that they naturally treat this very seriously. Use of brain dumps devalues the qualification and could result in disqualification or decertification. Check out this article: Why Brain Dumps Are Bad if you are unconvinced.
You can also find some solutions here: 70-483 Solutions
6. On the Day
Much has been written in other articles about the sort of material you should use for study, but nothing I’ve seen really helps you on the day.
Firstly, you should make sure you know the requirements for the day at the test centre. Check out the details with regard to attendance, transport, parking and identification.
So, what’s it like? What do you have to do? How should you approach the day? Well, everyone’s different, so you’ll know what suits you. This is how it went for me:
I booked my exam for the afternoon to give me the morning to relax and chill out. I read through my notes, and got some facts straight in my head. I also followed the following advice: What to Eat Before An Exam.
I arrived at the test centre early and was asked for two forms of ID, one official government issued (I presented my driving licence). I was given my locker key and told to put everything inside the locker except my driving licence. I was then scanned with a metal detector to ensure I was carrying nothing untoward into the test centre.
I was given a laminated sheet of paper, and a marker for notes which had to be returned – again, this is to help prevent having exam content leave the room. I was then shown to a terminal in the test room. These were in high-partitioned cubicles which had a set of noise-cancelling headphones.
The test administrator then logged me into the terminal, setup the software and left the room. There were two options, to take the practice test, or to start ahead with the real one. I opted for the practice test which was a set of ten questions on a completely unrelated subject. This is to get you used to the software and the means by which you answer the questions. Once completed I then proceeded onto the real test.
The real test started by telling you the number of questions, the time you have to do this, and the pass mark (700 for me, which I guess is out of 1000). The test has not started yet, so plan out how long you have for each. I split it up into 10-minute blocks, and measured my progress against that.
Finally, I took the plunge and started. The required pace was quicker than I anticipated, and I had fallen behind by the half-way stage. In the end I completed the exam with three seconds to spare.
You are able to mark questions for review, which I did, however I didn’t have any time to review them. As it was, I didn’t need to. Once the exam finished, my score popped up on the page (863) with a congratulatory message. I expected ticker-tape to fall from the ceiling, or something, but in reality it was a little anti-climactic.
The test centre gave me a printed output of the score, and that was that.
7. Other Articles
I’m not the only one to have blogged about this. Here are some other articles, all with useful advice:
- Dermot Boyle – Exam 70-483: Programming in C# 5.0
- Shane Brewer – Passed the MCSD Exam 70-483 Programming in C#!!!
- Deepak Puri – Exam 70-483: Programming in C# 5.0
- Claudio Bernascon – Microsoft 70-483 exam preparation guide