MCTS Self-Paced Training Kit (Exam 70-536): Microsoft .NET Framework 2.0 Application Development Foundation

• #2 in Best csharp Programming Books

78 Reviews

Sort by: Most Helpful ▲ Date Rating

The following are my pointers about the book and exam. I hope they'll help calm someone's nerves, because I was a nervous wreck before my exam yesterday.

First, about me:

> I studied in earnest for three weeks, using only the book and accompanying practice exams until the last three days
> I used Transcender during the last three days, and never scored above 60% on the full practice exam
> I am relatively new to .NET (four months exp. writing production-level apps), but not new to software development (working with Java for over four years)
> I passed the exam yesterday, on the first attempt, with a score of 859

With that said...

1. To anyone sadistic enough to take a Java cert exam (like my moronic self), the MCTS is a cakewalk. Unlike the ferocious Java exams which try to bait you into picking the wrong answers, 70-536 seems to do the exact opposite. I'll elaborate on this in point 2.

2. Remember taking the SATs and being given the advice to first eliminate clearly wrong answers before analyzing the ones that might be right? Do that on this exam, and you'll immediately cut your answer choices in half on nearly every question. For the vast majority of the questions, Microsoft practically GIVES you the answer - almost like they're trying to sell you on how intuitive their framework is. These questions are multiple choice, with one answer choice being cartoonishly incorrect, another answer being kind-of-correct but clearly too convoluted, then two or more other answers that are extremely similar, except for some minor detail.

3. You do not need to go into the MSDN and know every object mentioned in the book like Adam knew his wife. You should, however, be very familiar with the methods and signatures of Stream objects, Serializer objects (XMLSerializer, especially), AppDomain, and Culture/Region Info. As for the rest, just pay close attention to the methods and objects used in the book's examples.

4. The Transcender exam is WAAAAAAAAAAAY HARDER than the actual 70-536.

5. The MeasureUp exam that comes with the book is slightly easier than the actual 70-536.

6. On my particular exam, there were no questions whose material hadn't been covered by the book. Be careful, though, because from the Transcender exams it seems the book's authors left out at whole lot about interoperability.

Seriously folks, this exam isn't that bad if you're a seasoned software pro and familiar with OOP. Get a solid grasp of the stuff in the book (the labs really help), use Transcender for some details that the book misses, take the exam, and pass that sucker.

Good luck!

Simply unbelievable. For those of you who have not heard, the "first edition" of this book had a ridiculous number of errors in it. In fact, I originally had a copy of it from my work, and I had to print off the errata (list of corrections and fixes) and it was OVER 60 PAGES. Yeah, it was really fun trying to read the book on one side of my desk, and having a 60+ page document on the other side trying to find all the errors and bad code examples.....so anyway, I bought the "second edition" from Amazon. While it looks like the 60+ pages of errors that were found in the "first edition" were all corrected, there ARE STILL MORE OBVIOUS ERRORS IN THE BOOK. I cannot express in words how amazing this is to me. Did ANYONE with a technical background actually proof-read this book the first time? If not, shouldn't someone have done it before printing a second edition that was made because ONLY because there were 60+ PAGES OF ERRORS in the first edition? This to me is inexcusable. And how Microsoft could put their stamp on this book is baffling.

Anyway, other than the errors, the book is fine.....it just makes it hard to read this book for an exam, because can you really trust the content 100%? I say no. And, to top it all off, this (to my knowledge) is the only book out there for the 70-536 Exam. Good luck.

I used this book as my primary resource for the exam, backed up with a transcender for additional practice tests. I passed the exam on the first attempt. Based on that, I'll rate it as 4 stars (more like 3.5).

Yes there are errors - so make sure to get the errata. Do the practice tests on the CD (several times!). I can't imagine not using this book, given that it's the only one at present. If you look at the exam topics on the MS web-site, you could spend weeks or months on MSDN chasing down the relevant information. This book brings it together in one place, and avoids you spending loads of time on irrelevant topics. I think the book covers just enough to get you through the exam - provided you know the content very well. This is not an easy exam.

As for a general .NET book, the various chapters provide a useful introduction to each topic, but don't go into that much depth - just enough for the exam. Part of the issue is the exam covers a very wide range of topics, so it's difficult to go into much more depth without making the book 2,000 pages long.

At the end of the day, it got me through the exam, which is ultimately what matters.

Despite the harsh reviews, including one from one of my co-workers, I went with this book for 70-536 preparation simply because there isn't anything else out there. I was waiting on Amit Kalani to come out with his highly anticipated book, but I'm starting to wonder if that will ever see the light of day.

In any case, it seems that this book has had corrections made to it since the earlier reviews. I've noticed that more recent printings have a slightly darker cover and that the errata listed at Microsoft's website has been corrected in the book. I could find no mention of a 2nd printing on the inside cover or anything else to suggest a reprint. This doesn't make up for the missing content but does at least make me feel a little better in that I don't have to constantly reference the 33 printed pages of errata while reading.

This book skims over several subjects because it's trying to cover too much material. Chapter 6 and 7 on Graphics and Threading (respectively) both suffer from this. Large fonts and long lists of methods and properties leave little room for actual knowledge sharing. The order in which they cover the subjects leaves a lot to be desired as well. Just look at the fact that chapter 6 is Graphics and chapter 7 is Threading.

Anyway, the content tries to cover all that is required and probably prepares you for the test as well as possible (I haven't taken an exam yet). So, i was thinking 3 stars.

But then I arrived at chapter 9 - Installing and Configuring Applications. My guess is that Mr.s Northrup and Wildermuth had around 13 or 14 chapters done and were coming down to the wire when they asked Bill Ryan if he wouldn't mind contributing a chapter or two. Then he turned in what he had and they ran spell checker on it. That must be it, because there are errors on every page! Paragraphs copied from other chapters, review questions that have nothing to do with the section just read, and a lab in section two that has nothing to do with the Installer class discussed in section 2. If you look at a code example on page 489, you'll see what I mean. Not only does the code not work, but it's faulty in it's design. He mentions that the class implements IEnumerable, and then tries to use a counter to move through the list (but fails to increment the counter). That's retarded. Since I'm still in the beginner stages of all of this, these mistakes can set me back a while when I stare and try to figure out what he's doing.

Anyway, one star. The editors should go back to school somewhere. Rosemary Caperton and Sandi Resnick are pointed out specifically as proof-readers, and Jim Fuchs and David Robinson as technical editors. If I was any of them I'd ask for my name to be removed in subsequent editions.

The book looks like it was written in a hurry. Did anybody proof read it? For example, a test question at the end of one lesson is about topic covered in the following lesson. I just hope it will get me through the exam, somehow.

It seems this book was written by a team of beginners and I'm not talking about the numerous typos, but something like "class" instead of "object", "include" instead of "using" (many, many times) etc. It deserved 2 stars only for the exam voucher and for being usable after a look at http://support.microsoft.com/kb/923018/en-us for a long list of errata.

If you have read the reviews, this book is controversial to say the least. Issue #1: there are errors. True, however in my opinion, given the scope of the book and the number of contributors, errors were inevitable. Also note Microsoft has most of the errata documented on their support web site.

Assuming you're ok with fixing up a book with the published errata sheet, the next thing you may have a problem with: this book alone will not prepare you for the 70-536 exam. Sorry.

That is more of an indication of the difficulty of the exam than the quality of the book. The simple fact is no other book will prepare you for the 70-536. This is the only one, and does a commendable job, all things considered.

I put up four stars because I like this book. It is logically structured, and easy to follow. I liked the step-by-step examples and the labs. I actually learned a few things about .NET cryptography, code access security, and serialization. Even if you're not interested in the exam, this is a good book to learn the framework.

I bought this book in preperation for my first MC exam. It does a good job of getting across what material will be covered on the exam, but that's about it.

Much of the material lacks context and is poorly written. I spent more time on the internet looking up material that was in the book in order to get an understanding of it adequate to answer the sample questions than I did in the book itself.

This book, like many I've bought from Microsoft Press, has many editing errors, but I found many of the exercises, labs, and sample questions contained errors, making study for the exam very frustrating.

The practice tests and lesson review application that shipped with the book is also disappointing. You can't choose, for example, which lessons or Chapters you want to practice, instead you have to choose groupings of topics that include topics scattered throughout the book and that aren't necessarily related. The menu and interface layout is difficult to use, I mention this only because I find it ironic that such a poorly thoughout app is shipped with a book essentially about application design...

This book seems like it does a decent job of covering what is supposed to be on the exam, but it contains an embarrassing amount of errors. I'm only five chapters in, and so far nearly every lesson contains at least one instance of C# code getting mixed in with VB code examples, cut and paste errors (text from previous sections appearing in later unrelated ones), or incorrect answers to sample problems. This book should have never hit the shelves in this condition.

I am already MCP and had read many training kits, but this would be with no doubt the worst, i will list my impression about this book in terms of the many negatives and rare positives i found.

NEGATIVES:
*chapters are mixed up with lessons, and both are VERY poorly organized,with ambiguos titles for chapters(like instrumentation , interoperation)you will be very lucky if you could guess the contents based on the titles!
*Very poor editing , you find many copy and paste errors in code, duplicated figures and questions to chapters in wrong place.
*finally and MOST IMPORTANT, providing MISLEADING and WRONG information(confirmed after contacting authors).
*does NOT cover even 50% of exam, i had to go to MSDN and other resources.

POSITIVES
*you get 15% discount voucher for the exam.
*authors are aware of their mistakes and are striving to make a better edition.

I would suggest that you dont buy this book unless you are in a hurry for the exam and /or this book is your only choice(another TK is on its way out).

The book is too long, with irelevent information for the reader. The book covers all samples in both Visual Basic and C Sharp, making the volume twice the size (and probably price). However, the exam lets you pick one language. Why spend time covering the differences between VB and C#?

The authors completely ignore C++. This is a valid language choice for exam 70-536. (Look at the microsoft website, under 70-536). So if you are a C++ developer, you need to reintepret the C# samples. However the authors have no problem giving every example in both VB and C# to make their book bigger.

I gave this book two stars instead of one. This is only because of the 90 day 2005 Professional edition, and the Exam discount.
The discount runs all the way to 2010.

After reading their book I am considering writing my own. I can give examples in all three languages. That way I can charge one third more money!!!

OK, this book is a little dated, but I got a really good chuckle from an anecdote relayed by one of the authors that is still funny. Early in the book, on page 68, Mr. Wildermuth attempts to assert his expertise to the reader by declaring that he has "written hundreds, if not thousands, of lines of code". I have shown this little blurb around to many of my colleagues and clients. It has turned into somewhat of a euphemism for a n00b. For instance:

Dev1: "How did the interview go with Ted?"
Dev2: "Not great. He's got a good personality, but his skill set is a little weak."
Dev1: "What kind of stuff has he worked on?"
Dev2: "I would say that he has probably written hundreds, if not thousands, of lines of code."
Both: "ROFL!"

or

Dev1: "Holy cow! Come over here and look at this mudball of code that I have to support now."
Dev2: "Wow! You're not kidding. Who wrote this?"
Dev1: "Who do you think? Joe."
Dev2: "Oh man, he's written hundreds ..."
Dev1: "If not thousands!"
Dev2: "... of lines of code."

All that said, this book does the job. It helped me pass the test. I have taken quite a few Microsoft exams and I have usually turned to the Microsoft Press Self-Paced Training Kit books as a first resource. This book lives up to the good name the series has earned for itself.

I see from many of the reviews here that readers are disappointed if the book doesn't spoon feed them all the way through the exam. I would say that, for myself, preparing for an exam includes a multi-pronged approach. It starts with these books and continues to MSDN and Transcender. But most importantly, I think you have to definitely open up Visual Studio and practice. Write some code! Maybe even hundreds, if not thousands, of lines. ;)

So many errors that it has to be done in 2 parts

http://support.microsoft.com/kb/923018/en-us
http://support.microsoft.com/kb/935218/en-us

It looks like I still have ver 1 I'm still seeing the errors listed on the Microsoft website and I just purchased the book 01DEC07. This is really, really bad. This is something I don't need trying to study for this exam.

Places where this book is "weak" is where YOU as a reader need to learn how to use MSDN and look it up yourself. The point of the book is to quickly run you through what is going to be covered on the test... NOT to give you a hand holding through the numerous topics covered in a short amount of pages. Yes theres chapters that could use elaboration for me personally... but this book's job is not to go indepth, that is the point of the MANY other books referred to by the microsoft learning site. Each test has requisite books and then a training kit book. If you didn't read the whole C# or VB language book before you read this, then you can't complain when it doesn't hold your hand.

edit: having now passed the 70-536 on my first try, even though i put this book down for several months and picked it back up again is a testament to how good it does it's job. So long as YOU, the reader, do all of the examples, lookup each object on msdn and thoroughly research them, and run through the practice tests and study tests multiple times.

Avoid this book unless you are prepared to spend 10 times more time on certain chapters than is warranted. It's not the case that the book would be OK if the known errata were corrected; certain chapters have many more errors and faults, and need complete rewriting by someone other than the original author.

The publisher needs to issue a 2nd edition of this book with the following chapters completely rewritten: 9, 10, 11, 13, and probably 16. If these chapters aren't rewritten, when another publisher with proper quality control provides an alternative, that should be used instead of this book.

For example, code listings are presented to demonstrate COM interop, but there are no paragraphs explaining the code, and there are no comments in those code listings. It takes an inordinately long time to make sense of these chapters, due to the dense errors and lack of actual explanation.

I'm afraid I have to go against the positive reviews and give this book one star.

The first and biggest problem I had with this book is that it does not attempt to teach you very much about the topics on the 70-536 exam. Or, perhaps it *does* make this attempt but it fails pathetically. Instead, it scratches the surface of the topics and "points you in the right direction". I'd hoped the book would take a more rigorous pedagogical approach to discussing the exam topics. Microsoft's MSDN is better at explaining the topics than this book, in my own opinion, and this is how I will study for the exam going forward.

The book is divided into chapters and each chapter has several lessons. At the end of each lesson is a set of review questions.

Here are some examples of the problems I had with the first two chapters of this book (before I decided to give up on it):

Chapter 2, Lesson 1 does *not* discuss the System.IO.File class nor does it mention System.IO.Directory, yet the very first question in that lesson's review is in regards to these two classes.

On page 56 the authors mention overriding the Parse() method to provide a conversion from Strings. Override it? Override it from what class? It's not defined in System.Object. Probably the authors mean *provide* a Parse() method.

On page 948, one of the answers to a question reads, "...when an abstract method inherited from System.Object is called." What? System.Object does not define *any* abstract methods.

There are other problems as well. Chapter 2 lists many methods on the DirectoryInfo and FileInfo classes. Sometimes the authors tell you what return types the methods have and sometimes they don't, and sometimes they are just wrong (p.92, the OpenWrite() method).

I admit I only read the first two chapters of this book but I believe it's a total waste of money. I don't understand how this book can have any positive reviews. Before you buy this book you really should spend some time looking it over at a bookstore. I wish I had.

I've seen comments good and bad. I passed with room to spare using this book as my main guide. That's what its purpose is, and it does that well.

I'll state it plain and simple : this book got me my 070-536 exam.

It is an invaluable tool, simply by the fact that it lists all the topics that come at the exam in one convenient place. Learning from the MSDN documentation alone is impossible. You need a plan that delimits what is to learn for the exam and not.

There are a few typos and such, but it is never 'blocking'. One must always read "actively"; having to keep a sharp eye helps memorizing the content! ;)

CONS :
- There are not a lot of questions at the end of the chapters to test oneself. But it is sometimes sufficient to notice that some chapters have not been understood correctly. There are more questions on the CD though.
- A few topics are poorly explained. More schemas and diagrams and explanations required (the part on evidences in the application domain chapter). But at least the book lists what is to learn. What is not clear enough can be found on msdn or with google, until you find an explanation that "clicks" with you.

PROS :
- In one book, all the topics that you need to cover for the exam
- 15% voucher
- Some chapters are above the others in terms of pedagogy (Configuration Management)
- CD with self-test program (+explanations), very useful.

This book follows a preview, view, review, and re-review approach to teaching the .NET Framework. I think that's probably appropriate for someone who's just starting out, but most programmers will be bored to tears. Couple that with the bi-lingual approach (both VB and C# are covered) and you've got about 300 pages of actual content. That's too bad because there's a lot more value in covering the material quickly (just the facts), but if you like review and need to program in both languages, this book is for you!

Yes, this book does help with studying for the material, but we just took the exam from a training boot camp......if I'd only used this book plus the study questions that come with it....no way. I read the book for 8 months previous to coming at least 4-5 nights a week.....went through all the practice exam and review questions, but the exam was really a bit different. The camp I'm at was the only reason I passed....no way with the book alone can you pass...in my opinion. There were questions on the test that weren't even in the book. I just took the exam an hour ago! There's too much errata in this book. Someone printed the errata and passed it out to class, and there's about 10 pages (front and back) with misspelling and incorrect code. In addition, we found more errata as we went along.

I'll use this in day to day for reference, but man...talk about trying to push something out while not even having a strong review.....all people in the class agree this book needs a new revision!!!!!!!!!!

I read this book twice. And I used the MS Press Training Kit Exam Prep application. I studied all 304 questions. I passed the test. So the study guide works. And this was the hardest exam I've taken (I've taken six).

I didn't rate it 5 stars, because many of the examples were obvious, and the book had a few errors and typos. A handful of the exam questions were wrong, or had duplicate answers both of which were correct (pick one of the duplicates; no it's the other duplicate with the same answer). But generally, it provided enough information to pass the test.

This test is hard. Don't underestimate it.

Do not expect to pass test 70-536 using this book as the only resource. You will not do it. Do not think this book is for beginner's, it's not. You must have a firm grasp of object oriented programming to understand .NET. Also, don't trust the Practice Exam CD that comes with the book. I've found more than a few questions that have incorrect answers (according to MSDN). Even with all this said, I'm 100% positive I would NOT have passed this test the first take if I did not use this book in my studying.

This book formed a great foundation for .NET 2.0. There is a lot of content in the book and I think they put it in a format that is easy to understand. Some of the content such as Code Access Security, WMI, and COM Interopability are a bit thin, but you can make that difference up with MSDN.

My recommendation is to buy this book. Read it from cover to cover. DO ALL THE QUESTIONS, EXAMPLES, LABS, AND PRACTICE TESTING!!! Once you're done with all of this, if you have money to spend, perform the Microsoft learning online content. If you can't afford that, go to online practice test sites, such as MeasureUp and do those. Once this is all done, you should have a grasp of your weak spots. Hit those again and then take the test.

I used this book as my initial source of preparation for the 70-536 and would recommend it not only for the content, but also for the perks the book contains which include a MeasureUp practice test, a 15% off voucher for any Microsoft Certification exam (expires 2010), and a 90-day trial of Visual Studio 2005 for the few readers who would need it.

The book itself does a good job of introducing though not comprehensively explaining each subject area covered by the test. I felt that some of the content was more instructional filler than study guide (e.g. sections such as "What Is Inheritance?" or the verbose "Case Scenarios" which I just skipped over) but all in all I'd say the book is a pretty handy resource.

After having taken the test, I can't recall a question pertaining to a class or concept that this text didn't at least introduce you to.

That said, I wouldn't rely on the book alone in preparing for the test. As mentioned, the book is a good introduction, but I'd highly recommend using the included practice tests and even supplimentary tests (like those from Transcender) to identify any weak areas requiring deeper study.

I personally used the book, its test, and the Transcender tests and Google as preparation material. On the day of the test, it took an hour of answering questions and some pretty fervent prayer, but I was able to pass the exam quite comfortably on my first attempt.

I am really not sure if anybody could make this book better or easier to read. It is fairly easy to follow; the problem is that there is just a lot of material to go through here. Many of which is probably not appliciable to most programmers BUT apparently is all applicable to the exam, which is why you bought the book, right?

The MCTS Self-Paced Training Kit covers a wide range of topics, everything needed for the exam. The lesson reviews provide a good way to test your knowledge. Each chapter offers a mix of conceptual material, facts, examples in both VB and C#, and suggestions. Contrary to what another reviewer stated, I found the chapters by all authors very helpful, including those by Bill Ryan. The "rambling" style of his chapters and other chapters in the book actually provide a conversational tone, presenting otherwise dry material in an interesting manner. Overall, the book succeeds in what it was intended to do--provide a thorough, comprehensive review of topics for the exam.

I purchased this kit (book and sample tests) primarily as a study guide to prepare for the 70-536 exam. Due in large part to this kit, I was able to pass the exam on my first attempt. Beyond being a great tool for exam preparation, the book provided a great deal of information and "how to" details for key .NET topics. I do agree with a few other reviewers that there are some topics covered in the actual exam that are not addressed in the kit. I recommend this product to anyone preparing for the 70-536 exam.

Es una ayuda imprescindible para el examen. Obviamente, tambien pesa la experiencia, pero la verdad es que el libro me guió muy bien.

Muy recomendable para quien desea dar el examen 70-536 o profundizar acerca de todos los aspectos del framework 2.0

Using this book, some extra material to handle weakness in the book, and Transcender I passed the exam. Without the book, preparation for the exam would have been much more difficult. I also found that the book provided an excellent source for information about the Framework, useful even without considering the exam.

There are numerous errors as others have specified. There are also some extremely weak sections that are of minimal help when taking the exam. This includes threading and interoperation chapters. Look for additional help on these subjects. I also thought that the instrumentation needed work.

Another issue is the presentation of information on capabilities. The book includes tables containing the more important methods, but the signatures for these methods are not included; it would have been extremely informative since this information indicates best how a method is used. Also there is no way to tell static methods from instance methods. Another weakness is that the signature of the constructors is missing.

The book is very good;it's very interesting and open the world of .net programming. Very important for developers.

ofcourse this book is not for newbie level it is for people whom they want to pass the exam, i read manybook before this book and cover in depth the .NET foundation but the topics are not organized in a way to be memorized for the exam, this book is simple to memorize the questions for the exam

The practice exams are a great help. I also like the fact that it includes a searchable pdf version of the book.

Some of the reviews for this book are far too harsh. I do agree that the first version of the book had numerous errors, but the second version corrected most of them. I used this book as my primary study guide for the 70-536 exam and I passed the exam easily. I considered using an alternative practice exam solution, but the software that came with the book was adequate, and in some instances, more difficult than the actual exam.

With that being said, I too agree that this book alone will (most likely) not enable you to pass the exam. This book is a *study guide*, not a *cheat sheet*. The goal of the book is to introduce you to exam topics and prepare you to solve exam problems using the .NET Framework App Foundation. This book is intended for candidates that have experience with previous or current versions of the Framework, who wish to condition that knowledge to pass an exam. The authors inform you of what level of skills you should have at the beginning of every chapter.

As with any technical book, it can use a little work. Chapter 9 'Installing Applications' should be considered for revision to flow better for the reader. But even with it's choppy flow, the information in chapter 9 is quite useful.

In summary; I read it, I passed, I'd recommend it.


-Grant

I am a Java programmer with no background in .Net, so I thought I would try to get certified as a way to learn the subject matter in a comprehensive manner. This book is not a good introduction to creating applications for Windows for a couple of reasons. First, much of the information in this book is badly out of context. For example, the first lab in Chapter 9 gives complete, detailed instructions on how to create a project in Microsoft Visual Studio. This lab would have been more useful as the first lab in the first chapter (obviously). In addition, many security related items are brought up in early chapters, but discussion of them is deferred to Chapter 11. Second, the book assumes familiarity with Windows concepts or products without explanation (which, in a "Foundation" book, I believe it shouldn't do). A discussion on remote components assumes a familiarity with IIS. I have finished chapters on Application Domains and Services and Installing and Configuring Applications and I still don't have a good idea of what a .dll file is, or how to actually create a componentized application.

That said, the book is not a total loss, it just requires considerable effort on the part of a novice to understand the information.

Some of chapters (specially at the beginning of the book), are quite good and I found interesting information in them. But the rest are very poor, and can do more harm, than good to one who reads them.
Some code snippets, even if they work, are very good examples how you SHOULD NOT WRITE programs.
I wouldn't recommend this book to anyone, who doesn't have some experience in .NET programming and expects to learn from it. But it is quite good reference for the exam. I don't think, you will be able to pass exam using this book alone (unless you know .NET so well, you don't need any book to pass it :-)).

Any book that intends to give an overview of something as large and varied as the [...] framework is going to gloss over some areas. This was no exception. It did provide a fairly detailed overview of security (over 150 pages in total).

Since I used this book to study for the exam I (extensively) used the practice cd that comes with the book to test myself as I read (and re-read) chapters.
As others have mentioned there are several typos in the book and exams. There are several questions which are frustratingly ambiguous and there are (at least) two answers which are absolutely incorrect. The editor needs a performance review...
I thought that these questions would appear in the final exam and if I could memorize them then I would pass the exam. Wrong. NONE of the questions in the practice exam were in my final exam. In fact, there were questions in the final exam that weren't even covered in the book (yes, I went back and checked...). I passed the exam only because I had familiarity with the subject from my hands on experience as a developer and from (lots of) extra research on google i did away from the book.
The moral: You can't use this book alone to pass the test - you must supplement everything you learn in this book with your own investigation and hands on practice. You have to know your stuff to pass the exam. And if you're serious about being a developer this should be a problem...

Good luck!

This book seems to cover all the necessary topics for the 70-536 exam, but the errors/typos are totally unacceptable. This is probably the most poorly edited book I've ever read. Repeated paragraphs, copy-and-paste errors, code that doesn't compile....you lose confidence in the book and when something doesn't make sense, I find myself wondering if I don't understand the concept or if it's just another error.

Again, if you can get past the errors, the book does cover all of the necessary topics.

This book is better than nothing but there is a lot of room for improvement regarding quality. It went a long way towards helping me pass the 70-536 exam. This book has an alarming number of typos in it, tends to gloss over some important items, and is missing some key exam items. I bought this because I didn't want to wait months and months for other resources to become available. If you can wait I suggest you do.

In my humble opinion this is very good book. I didn't take the exam yet so I don't know if it works but after reading over the 50% of this book I can surely say that the way this book is written is the one of the best (for me of course :) ) there are some typos but I can surely recomend it to all who wants to learn new MS technology and of course who wats to take the 70-536 exam :)

Good book. Gives us a good overview of various topics covered in the exam. Has a few errors. But, we could figure it out. It comes with 300 exam practice questions, answers and links to MSDN. If you cover all the topics in the book, and go through the MSDN links provided in the CD, it will help us give a good shot at the exam. I used this book and transcender practice test. I passed the exam in my first attempt. The MCTS exam is tough. That makes it covetable.
RJ

Well I just took the exam today and passed (I didn't do exceptionally well but I have the certificate!). My only source was this book. By me passing I guess you can say it did the job for the task at hand. About 11 out of 16 of the chapters in the book are very easy to understand and very helpful and straightforward (minus the typos). However, some of the others, particularly those dealing with diagnostic and management configuration could use some work. My biggest issue with the book is not with how it is written, but the content. There were about 5 questions which I had no clue about and do not remember their content being directly mentioned (if at all) in the book. I am not pointing fingers at anyone, but there is a problem there with either the book's content or the access the authors had of what would be covered on the exam. All in all, I give it a 3 out 5 since I did pass. Although, I did study this book everyday, heavily, for three straight weeks. As for the practice questions, I thought they were ok as well. They helped me learn some things not covered in the book (oddly enough) and were useful to point out important points on specific topics. This isn't the greatest book in the world, but if you know it really well and do al of the examples and labs, you will probably pass.

TOO MANY ERRORS
After reading 200 pages of this book the numerous errors was a distraction. After visting Microsoft's web site and seeing the list of corrections I felt that this book should be recall and the people who purchase this first edition should be entitle to a refund or free replacement of the copy they purchase.

DO NOT PURCHASE THIS BOOK UNTIL CORRECTION ARE MADE
WAIT FOR THE SECOND EDITION

The book covers key areas effeciently, especially new technologies in 2.0. I have not found content to be out of line with the same tests that I have seen. This is a good starting point for those that want to move on their MCTS and eventually their MCPD certifications.

No book can really cover the entire material but the no. of typos, mistakes and incorrect code samples is really exasperating ... however if you are willing to supplement study by yourself, the practise questions and exams are sufficently indicative of the real exam.

After having purchased book and used it to study for the 70-536 exam. I can summarized my experience in the following:

The book will not be sufficient to pass the exam, and makes for a really bad and frustrating study guide.

The authors of the book that have an incomplete understanding of the material.

The authors and editors of the book have horrible writing skills.



First of all the book is missing much of content from the actual exam, probably about 40 percent. Don't let the books objectives insert fool you, there are huge gaps in the book, and you will not pass by using the study guide as your only resource. While the study guide is missing a lot of content, it also goes too far into detail for some content that is actually included in the book. For example, for the exam you will only need a broad understanding of reflection, you will not need to be able to write an entire section of code on "creating code in runtime", you will also not need to memorize the exact steps of using the .Net configuration tools.

Often it seemed then when the authors didn't understand an item, instead of researching it themselves and then thoroughly explaining it, they just cut and pasted random information / code examples from MSDN with no after thought, or they simply skiped the difficult item all together. It's understandable that the authors would have such bad knowledge of coding, since as they personally state that they have only written "hundreds if not thousands of lines of code" (pg 68).

Some examples of their poor understanding include:

The StrongNameIdentityPermission in the book (pg 661), is generically described as "defines the identity permission for strong names" , pasted verbatim from MSDN. A more complete and meaningful explanation would have been "Restricts the assembles that can call this method, based on a specific public key from the calling assembly."

On page 603, instead of actually explaining how to use the PerformanceCounterClass, the author instead find it necessary to show us how to append PerformaceCounter properties to a StringBuilder class.

On page 819, the authors the describe how to perform "Exception Handling in Managed Code". They quickly list how you shouldn't do it, and that "you need to do something else". Of course instead of actually saying what it is, and even mentioning the solution, they list a 2 page cryptic code example.

As of the second edition, there are still many code and grammatical mistakes. The authors often try to get cutesy with inappropriate personal anecdotes that feel completely out of place, or use bad worded filler material like "These two classes have an intuitive synergy that becomes evident when you use them." (pg 482).

Reading the book I got a feeling that the authors got paid per page written, so they felt compelled to stretch things out as much as they can with extra tables for class parameters and methods and unnecessary code examples. Mind you, instead of actually adding all of this filler material, they could have just been more thorough with the exam material.

Bottom line is that there is no excuse for incorrect code samples, grammatical mistakes, very poor writing, and missing content. Especially since this is already the second edition.

Some other reviewers of this book have stated such ridiculous explanations as: "i'm glad there's errors and that you have to research to figure them out." or "Places where this book is "weak" is where YOU as a reader need to learn how to use MSDN and look it up yourself." , those are NOT valid excuses for such as horrible book.

For a good example of a study guide see: Kathy Sierra's study guide for SCJD, even though that exam is much harder, the book is concise and straight to the point. Teaching you only what you need to be taught.



As for the actual exam:

It was easier then expected, especially when compared to the Sun Certified Java Programmer course (mind you I did purchase extra exam practice questions, and study from them).

Whereas in the SCJP exam, there are many tricks questions, and you needed a thorough understanding / memorization of writing specific code, and knowing when code wouldn't compile, run, etc. For this exam, having a broad general understanding of all topics will be sufficient, the most obvious answers are typically the correct ones, and you really don't need to memorize/ be able to write entire sections of code .

For study preparation I recommend reading through the book, without trying to memorize code sections. Skipping the labs. Purchasing extra exam questions like Transcender, and working through them, and looking up any missing items on MSDN.

It took me about 100 hours to prepare for the exam, but this is having already a solid understanding of Object Oriented Programming, having passed some Sun Java Courses, and having used .Net at work. I probably could have studied for less time, if I was warned about this book.

Also make sure to place special emphasis on studying streams, including all related streams types, crypto , compression, text, etc, and their corresponding method signatures.

I'm giving this book 2 stars, instead of 1, solely on the fact that that this is really the only 70-536 study guide in print, and using it will save you time over trying to figure things out using Microsoft's atrocious MSDN, which is just as poorly written and confusing.

The content in this book is definitely not enough for exam preparation. After reading the entire book word to work I would say It only prepared me 60%. Rest of the information I need to get it from other sources mainly from MSDN help. The good part I found is it outlines exam objectives very well so that you can do you additional readings from other source but that you can also get from exam prep guide in microsoft website. I still recommend this book becuase I don't see any better option.

After reading this book cover to cover and taking the practice test many, many times I was able to pass the test on my first try.

What really pissed me off (along with my co-workers) is the amount of errors both in the book and the practice test. The book has so many typo's and errors the there is 2 (yea TWO) knowledge base articles for the errata. About 15% of the practice test questions (out of 300+) were just WRONG. Either the answers were not correct, or there were no correct answers.

Ok, enough of the rant. Like I said, this book did help me to pass the test, so for that I give it 3 stars. Had i failed the test it would have been more like 1 star.

Take that for what it is. Since this is the ONLY book for the test, you are kinda stuck... Just be ready for errors and frustration.

This book is really a good one, for people who are not familiar with programming computer applications.
It's starting from the beginning and is explaining very well all the examples of code used in the book.
Sometimes there is too much theory used in the book, but the reader of the book, gets also a lot of practical exercises to test your knowledge.

I've been so frustrated with this book that I finally decided to write my first review. It's incredibly hard to read due to the ambiguities and laughable inaccuracies; and this is the "revised" copy. I went to the errata link and found that even the most obvious problems were not addressed. For example, there is 3 line code snippet on page 46 dealing with event handlers that was "corrected" and the revision on the first statement invalidated the third. The review questions often cover topics out of order or ask questions that are simply not covered anywhere in the book. You don't have to be an expert to see the problems here, but you'll have to become one to make sense out of this book.

The book is my first contact with another IT world. I mean the dot NET. It guides you through all the important parts of dot NET technology. I especially appreciate a lot of working examples and way of explanation. It leads you to self-motivated learning. I mean you become courious how all the described functionality in reality really works and if IT really works :-) Thanks to the book I have found out a lot of useful functionality. It is really a good book for certification exam too. When you read it for second time you realize how well the book is organised.

This book explains about the most used classes on .net framework, and explains the most common methods, properties, members and enumerations. You can't use this book alone to pass the test - you must supplement with another book.

[...]

While this book did help me to study for the exam, I've never read any computer book with so many errors.

For example:
- pieces of text copied & pasted from other chapters, then forgetting to change the text
- Wrong headings, e.g. Chapter 9 Table 9-1 and Table 9-2 are both "ConfigurationManager Properties and Methods"
- Bad sample code (e.g. variable declared but not used)
- Bad information, e.g. Chapter 5 (Serialization), section "How to Control SOAP Serialization" is wrong: The SOAP serialization attributes (Table 5-1) applies to the XmlSerializer, not the SoapFormatter being discussed.
- Wrong usage in samples, e.g. chapter 10, lesson 1: EventLog.CreateEventSource overload used in sample deprecated, lesson 2: author claims you need a DefaultTraceListener for Debugger.Log, and lots of other cases.
- Unnecessary "cute" personal stories, e.g: "Practically every application I have ever developed has used collections extensively. For example, I have used collections to store lists of e-mail messages that I am ready to process in an e-mail system I wrote some years ago". Some years ago? No recent development? "The generic LinkedList class is a type of collection that is new to .NET, though the concept is well worn and tested. In fact, I remember writing a LinkedList in college". Not necessary to tell the readers you've never written a linked list in the real world.

I found Chapter 9 (Installing and Configuring Applications) particularly bad in terms of the usefulness of the content. The topic isn't that difficult, but the samples just don't demonstrate the ideas very well.

The typos etc are acceptable, but when it appears that the authors know less about programming than the reader, then it creates a really bad impression for Microsoft Press.

I'm sorry I didn't rather wait for Amit Kalani's book instead.

I'm not quite sure just how to rate this book. When it's the only book of its kind on the market it has to be easily the best book on the subject. And people report that by using this book they have successfully passed the 70-536 exam. That's what the book is all about, so it meets its basic goals.

On the down size, there are a lot of typos. I found, like some other reviewers, that when I saw a typo I could see what it was supposed to be. And having to think about what the typo really meant forced me to concentrate more on that sentence. How's that for looking on the bright side.

Realistically, let's hope that a second edition comes out fairly soon that basically contains the same information but is better edited.

Conclusion: here is everything you need to know in one book. With it you get a discount on the cost of the test. With the CD you get a fully functional Visual Studio 2005 Professional Edition that is good for 90 days. That's long enough to prepare for the exam.

This books structure makes it very easy to get a chapter a night done and prepare you for the exam. The labs are good and the accompanying DVD contains both practice exams and a trial version of Visual Studio 2005, so you have everything you need in one book.

This exam is only half of an MCTS qualification, so you'll need either the Web Development or Windows Development to go with it if you want an actual qualification.

I only had issue with one or two of the answers given to questions, but I found it quite encouraging that I was able to think 'hey, that's not the best way to achieve that'.

Comming from the 1.0 and 1.1 framework, this book really helped me get up to speed with 2.0. It covers many new capabilies and enhancements of the new framework (isolated storage, generics, etc...). This is my "MAIN" reference book now... its almost like my programming bible. :)

I read this book in preparation for the 70-536 exam. As the other reviews say, the latter chapters start to show a breakdown in editorial skill and in-depth description. The bottom-line is that if you have over a year of good concentrated (not college classes) programming AND you read every chapter of this book to familiarize yourself with the fundamentals covered in the test, you will probably pass. The practice tests that are included leave a little to be desired as well, while they do get you familiar with the concepts of the questions that will be asked on the actual exam, the practice test questions will not contain any of the actual questions on the test (you'll need some supplemental brain-dumps for that).

For a purpose built training kit, the MCTS serves it's purpose as a reference book quite well, not only giving examples of What and How to perform tasks, The MCTS Training Kit has exam based questions show you can see where many common mistakes can be made. The lack of "Real World" examples can be forgiven, given that most developers are after a code snippet, rather than how to re-design the wheel.
A good all-rounder, a must for anyone wishing to further their skills.

I give the book three stars because I just passed the test and couldn't have done it without this book. However, I agree with most of criticisms that have been posted. Particularly galling to me were the very poor index and the mistakes in the examples and questions

I have almost finished reading the book for the first time. I am going to reread it again and throughly work through the examples.

Here is my opinion about the book. It is pretty good. It covers a lot of topics and has more than 1000 pages. Because of the sheer breadth of the covered material some topics are not described in the detail they deserve. Despite of that, it is a great study guide. My rating - 85%.

Now, the testing software that comes with this book is unbelievingly lame. I cannot stress enough how lame and unusable that stupid software is. It is designed for screens with resolution 800 * 600. It looks like it was written in VB6, thus it does not scale well on high resolution monitors. I just cannot believe that this software was actually released. What a shame... I hope that other books in the series will have better software.

Please note that the second edition of the 70-536 Training Kit is available. Fully updated and revised, the second edition replaces this first edition, and is the one to buy to prepare for the 70-536 exam.

I have just started studying for my certification for the .NET Framework and this book is real helpful. It provides me with answers that I was not able to get through school. I have learned some new things that make developing a bit easier now that I have learned about some different approaches with this book.

The majority of reviews of this book are quite right in that it is a good preparation guide, but the plethora of errors can cause some confusion. Microsoft has posted the corrections for the book, but the best way to overcome the errors is to go through the practice tests and look up questions you feel you are right about. Additional reading is a must and missed questions are the best prompt to guide you to additional resources.

While definitely a thick book, the content is extremely detailed. Though keep in mind that there are many ways to reach any given end or effect - the various authors programming / example styles expose the reader to a few ways to expressing the same result, which is quite beneficial.

In terms of organization, this book is very good, especially considering that multiple authors were involved. The only chapter that merits additional scrutiny is the security chapter, which helps throughout the book, as security considerations are sprinkled throughout.

In summary, with a moderate amount of experience with .NET (2.0+), this book is an excellent primer for the test and provides the requisite understanding of the framework to prepare one for the exam. The only caveat I found was that for people with .NET 3.0 or 3.5+ experience, some of the methods may be a slight bit different due to minor changes between 2.0 and 3.5.

Dieses Buch gibt einen allumfassenden Überblick über das .Net Framework. Es hat Referenzen der wichtigsten Framework-Klassen der einzelnen Themen. Man hat am Ende ein fundiertes Wissen über die vielen Bereiche die das Framework abdeckt.
In jedem Kapitel ein "Realworld Scenario" und Übungsaufgaben. Zudem noch Frage und Antwort nach jeder Lektion.
Der Glossar am Ende des Buches scheint mir etwas klein, deckt aber die wichtigen Begriffe des Buches ausreichend ab.

The pluses:
- It covers the items in the exam and gets you basically familiar with them.
- It has the practice tests CD which is very helpful.

The minuses:
- It doesn't cover the items in the exam enough to pass the exam.
- It has many errors.
- It is poorly written so that you don't always understand fully what can or can't be done with the item you are studying.
- Most of the time you will need to look at MSDN or the Framework help to get the full concept of the item you are studying.
- Some of the lesson test questions are out of order so you get asked about something that isn't covered until the next chapter or lesson.

Overall:
I'm glad I got it. It is going to help me get through the exam, but it could be a much better product if more care had been taken in its production.

First, I appeared for MCTS 70-529 (Distributed Applications) and I was able to clear in the very first attempt with 856 score -- not an easy one as it covers complex topics. Then I attempted MCTS 70-536 thinking that it is easier than 70-529. But definitely not an easy one either and I got a score of 771. It is voluminous and a beast as it covers lots of topics, right from types to code access security, collections, threading, interoperability, serialization, instrumentation, internationalization and more.

As you can imagine, a single book is not enough. You need to consult MSDN documentation heavily and frequently as most methods are overloaded with so many variations. And plus I suggest some other question bank (such as transcender, measure up, etc) in addition to the ones provided with the book. Question bank provided with book is good but not enough to cover all the tricks.

You can skip other question banks only if you are extremely .NET savvy. Which I suppose many people will not have exposure to so many topics in their careers does not matter with how many years of IT experience.

This exam is definitely not a breeze. So please prepare seriously if you intend to gain knowledge and pass this exam.

Very good book to start your preparation.
But still lot of details are not covered up that
are important for the exam, making MSDN a must along with this book.

I brought this book in order to learn how to program. I wanted to take the exam. I had to get a dictionary to make it trough the text. The author seemed to take a very complicated issue, and make it even more complicated by the use of the types of words like antithesis, and obfuscate. While I know what these words mean, it would have been a much easier read if he would have used plain english. I have a bachelors in CIS, and 2 masters degrees. An MBA, and a masters in project management, and I still had a hard time making it through this text. As the other reviews have suggested, I had to purchase 2 other texts to learn the language. I have since been designing web pages for a year, and I have never, ever, opened this book again. It was a waste of the $49 bucks I paid for it.

Achei realmente um excelente guia de estudos, com muito exercícios e um ótimo simulador de provas, customizável.

O livro é bem organizado e segue a risca o conteúdo da prova. Estou gostando muito. Eu recomendo.

The book has quite a few mistakes (not just the usual typo). Entire chapters are, lets say more or less either copied from the help with no additional insight or otherwise lack additional value. The included tests are faulty. The coverage of test questions is only "garanteed" by the provided practice tests, NOT the book itself.

I still think it is a good starting point to get an impression of what the actual test might require. OTOH just following the test related table of contents (70-536), reading the help and trying everything yourself + purchase of practice tests would most likely be better (something you'll have to do in any case since the book does have quite a few white holes AND you can't rely on the answers provided by the practice tests).

I have been reading this book in the past one week.

The first 5 chapters, namely, "Framework Fundamentals", "Input/Output", "Searching, Modifying and Encoding Text", "Collections and Generics" and "Serialization" are very easy to understand.

However, the chapters like "Threading", "Application Domains and Services", "Installing and Configuring Applications" are really hard to understand, I have no idea with what the author is talking about most times. As a foundation book, instead of giving a very general description about the topic and just list the members of the realted classes, I really think that the author should spend more time explaining what is it exactly, what the developer can benefit from using it and good examples are essential.

Most examples given in this book are very short and doesn't make any sense some times. We can always find the information about how to use a class, method from MSDN or other sources, but I suppose what a reader really needs are good exmaples that involve the related comcepts, classes, etc.

Anyway, I will continue to read this book as it is the only book written for the exam.

I also have the newer (corrected) version of the book (check the copyright page in the beginning of the book, mine lists version: 5 6 7 8 9 QWT 1 0 9 8 7). Despite the numerous corrections, I still find some errors, even those that are unlisted in the errata list. When looking at the four KB articles on the Microsoft site, the errata list shows a gap between part 3 and 4. So I think there is something missing in the errata.

For example: an error I discovered today, on page 712, the second bullet reads:

"One or more PrincipalPermission properties. Use Authenticated to restrict access to authenticated users, Role to restrict access by group memberships, and User to restrict access to a specific user name."

This is incorrect, there is no 'User' PrincipalPermission property. Replace 'User' with 'Name'.It should read instead:

"One or more PrincipalPermission properties. Use Authenticated to restrict access to authenticated users, Role to restrict access by group memberships, and Name to restrict access to a specific user name."

This is in particular a strange error, because on the previous page the authors says:

"Memorize these three properties (Authenticated, Name, Role). Remember, PrincipalPermission doesn't expose any other properties--not a user's full name, phone number, password, or any other attribute."

For the rest of the book, I found the topics are not very well explained. Except for the chapter dealing with Code Access Security, which I found was very clear. In general, I did not like the fact that there are so few images in the book that could clarify the text. Sometimes the text alone is a litte bit boring to read. But then again, it's part of the job, no?

As there is no alternative for this book yet, I hope I will pass my exam by using this book and some internet resources... We'll see.

Good luck to all exam takers!

This book is a good start, but you won't pass the test by just reading it. Experience and practice test will go a long way to help.

With an exam as broad as this exam is, it's probably next to impossible to find one author with the depth of knowledge in each topic to write a manual and develop the labs that are found in this piece. However, the employment of an editor and overall UX specialist would work wonders to making the material presented in this book more streamlined, user friendly and less disjointed.

You can tell that different chapters were written by different authors. This goes from writing style in the text itself all the way down to sample code and labs found on the accompanying CD. C'mon, for the amount of effort put into this type of manual, and the perceived 'stakes' involved in passing these tests, give us some materials that are consistent so that as learners, we aren't distracted by the inconsistencies.

The exam simulation software sucks. The user experience there is dismal - dismal on the order of Windows 95 user experience dismal. You would be better off biting the bullet and picking up the Self Test Software exam prep package for this particular exam.

Overall, the material covered in this guide, paired with significant on-the-job experience and supplemental exam prep (like the STS packages mentioned above) should be more than sufficient to pass the exam covered. But don't use this book as your sole preparation tool.

Again, at 1050+ pages, I would like to see electronic only versions of these types of books. Especially considering the extremely short life span that technology books have. If you can find a way to get an electronic-only version and avoid buying the hardback, then go that route instead.

It's a gr8 product, the only setback was that Microsoft has just one book for VB as well as C# coders, so half of the book is useless for me

Actually I am editing my oppinion after reading this book almost three times now ... The silly typos and mistakes over the book are a fact, however I'd like to say that I really learnt a lot with the book, and overall found it very useful.

I missunderstood the focus of the book, and expected more of a "how to do" book, when really it is a logical and structured list (withouth to going into too much depht) of the .NET Frameworks features. After reading simpler books, and with a bit more experience developing in .NET, I actually went back to read it again and found it very very useful.

In my oppinion a lof of people commit the same mistake as I did, and expect more of a learning book, than a proper study guide.

I took the exam today....and....passed. Phew! This is one VERY tough exam to study for. I spent about 200 hours preparing for this exam. The exam is very broad and very deep. I bought this book and used the Transcender.

The book was poorly edited and had mistakes that which stated certain "facts" that turned out to be outright wrong. The book itself barely gets you going for the material you'll need to know. I admit that the 302 test questions were helpful, though. When you start taking some of those sample tests, you'll realize how quickly the book material was lacking. The Transcender really helped cover a lot of other ground that this book didn't. Oddly enough, the test still pulled some punches on material that was covered in neither, unless you plan to go very deep on every topic which is next to impossible.

This book might be the only reasonable paper resource out there, especially with the test questions, so just be forewarned....be careful...and you'll have to study deeper than you might expect in various areas.

I am a computer programmer; I have 3 years working with .net 1.0 and .net 1.1. This book is exactly what I need to for the 70-536 exam. The books focus only in .Net 2.0. Therefore you must know .net 1.1 to actually understand. Advice: use TestKing, MSDN and this book to pass the exam.

I used this book to pass the exam. The topics covered on this exam are varied and obscure. This had to be a difficult book to write. However, that doesn't excuse the tremendous and glaring amount of errata. If you look carefully at each chapter, that chapter's author is revealed by the Real World boxes and the writing style. Tony Northrup writes well and covers the material with minimal errors--he gets 5 stars. Shawn Wildermuth writes decently, has more errors and doesn't cover material in great depth--3 stars. Bill Ryan's chapters, well, imagine a smart but poorly organized college student who attempts to write a term paper that was assigned two months ago in one night. It's kind of like that--1 star.