5 comments about Mastering C# Database Programming.

1. I found this book to be very helpful to me in connecting and using the Microsoft Access database with some Visual Studio C# programming I was struggling with. It is the only book I have found that at all addresses Access and it adequately covers the needed information to make the connection and manipulate data using SQL. Whether you are using Access of SQL2000 and especially if you are struggling I highly recommend this book to you.



2. This book is probably the best book in the market if you want to take your novice c# asp.net skills to intermediate/expert level. It provides plenty of good examples and practically all the knowledge you need to become a fully competent c# asp.net developer.
   
   I especially found the chapter on SQL and T-SQL particulary awesome. As a Senior DBA who has worked on SQL for 7 years, I thought the author had superb knowledge of SQL transactions which I rarely see even amongst the SQL books. I highly suggest every c# developer to delve deelply into the SQL chapters of this book as it will increase your T-SQL transaction knowledge exponentially.



3. This book is a good introductionto SQL server 2000 programming with C#. The author introduces the basics of SQL server in the first part and focuses on the ADO.NET in the second part. I like the format well. Overall a very good book.



4. very good book helps the programmer to get what he needs in the shortest time, well organized, very clear and has useful examples.
   it covers many topics in one book (SQL server, ADO.NET and C# database programming) in a way that makes it easy to do your code without opening too many books.
   the only limitation is that it covers only SQL server database programming, I wished if it covers alos Oracle and MySql.
   thanks to Jason price



5. I picked up this book to translate what I know about database programming from Unix to Windows. Although this book is a bit outdated since it was published in 2003, 99% of it was useful for me today. This book easily helped me transition my Unix coding into the Windows world and I will be keeping it close on my bookshelf for my day to day needs.

5 comments about Microsoft Visual C# 2005 Express Edition: Build a Program Now! W/ CD (Pro-Developer).

1. I thought this book was easy to read, colorful, and practical. The learn-by-doing approach really works well and the fact that they included a copy of C# Express saves you a long download. Well worth the price.



2. Negatively the sidebar examples can at times clutter the
   page and the type in them is too small for comfortable
   reading.
   On the other hand nice abundant use of color and the main text is alright. Unlike previous books on C# does not require an
   install of the pricey Visual Studio because has an express edition of its software.



3. I interrupted my online C# education to study and work with this book. It was well worth it, since it turned out to satisfyingly detailed, yet covered each function in a move-along fashion.
   
   The only negative is that some of the print was thinner/smaller font than it should be for my old eyes, but that enabled the above-mentioned detail. This is more than make up for by the colorful presentation, and clearly written text, and, most of all, the solid examples and exercises. I LEARNED A LOT!
   
   You can't go wrong with this book. After completing it, I went to the bookstore and reviewed other thicker books. Boy, was I happy I started with this. Ah, well, now back to my online tutorials from Microsoft.



4. As a beginner, I thought that the author's approach was both respectful and thoughtful. The examples are easy to follow and understand and the book is well organized. Although this book can't be considered to be a reference book, it certainly is an excellent way to learn the basics of the C# language. It's a fun and useful book, and I highly recommend it.



5. I got this for my Nephew who is 16 and wanted to try programming. This book was really good for him since he has had very little exposure to the "behind the scenes" of computers and software. He was able to write his first program right away which got him pretty excited about it.

2 comments about Professional Windows PowerShell Programming: Snapins, Cmdlets, Hosts and Providers (Wrox Professional Guides).

1. I've been developing PowerShell cmdlets for the past year and half for the PowerShell Community Extensions project. I really wish I had this book when I started. It would have saved me a ton of time. Having everything documented in one place alone would have been a huge timesaver. The examples in the book are really good and should give any would-be developer of PowerShell cmdlets or providers a huge jumpstart. One minor quibble is that the formatting on some of the sample code output wraps making it harder to interpret the results. Other than that it is a fantastic compendium of the knowledge necessary to start knocking off some heavy duty cmdlets and providers.



2. This very well may be the only decent book regarding PowerShell programming beyond the ordinary PS scripts. If you want to create your own CmdLets, Providers, etc this is the only book I've found that gets you there.
   
   With that said, despite the authors' efforts the book feels more like a reference than a tutorial. The authors' expertise is so deep sometimes they forget to explain all the "obvious" things.
   
   For example, when the PSObject class gets presented to the reader the details are outstanding, as always, but there's very little effort devoted to explaining why this class is needed at all. I've seen other books do better in that matter.
   
   A different example: If you've created your own CmdLets, you already know you can derive from CmdLet or PSCmdLet, the latter being a subclass of the former with additional features but additional requirements. The book totally avoids this discussion (did I miss it?) and PSCmdLet gets used exclusively all over the chapter without telling the reader why.
   
   Don't get me wrong, this is a wonderful book and honestly, I may come back in a few weeks to update this review and give the book an additional star. But I'm the kind of guy that always needs the "Why" before the "How".

5 comments about Microsoft Visual C# .NET Step by Step--Version 2003 (Step By Step (Microsoft)).

1. Coming from a VB background I chose two books to step up to C#. The first was Charles Petzolds excellent book, programming in the key of C#. My second book was this one. While this fills in many holes left out of Petzolds book, (mainly to do with the .NET framework & the .NET IDE, since Petzold deals purely with the C# language) it does so at the expense of clarity & in depth explanations as to `why' we do certain things. Often this book uses explanations dealing with as yet explained methods or objects, hence its flow is not contiguous, & the information supplied shallow. Had I not first worked through the `Key of C#' book, I would have been left scratching my head with this one. As in one example, it uses the conditional ternary operator statement having not yet explained this simple yet enigmatic little piece of code. (Fortunately I'd learnt this in the previous book). At other times, it gives examples that don't result in anything of value as code methodology. In another example the authors declare a property as 'money' without any prior indication of creating a money class, which led me to search MSDN online documentation for a non existent money data type that i may have overlooked. Not good. They have a skill of muddying simple concepts with overly complex examples. I came away thinking this book would be more for the experienced C++ developer, however, it doesn't really supply any ground breaking information on C# or its framework; it only skims over what could be discovered by yourself with a bit of exploration.
   As I said originally, it does serve to fill in some gaps left out by other books, but I would steer away from this book if you are a beginner or even new to OOP. Another thing that in fact annoyed me about this book was its false claim that the .NET guidelines recommend against ANY use of Hungarian Notation at all. In fact the guidelines only recommend against using hn for exposed members. Private variables are still up to the team to decide upon. This was personal point of view & not related to true recommendations.
   
   This book may better well serve as a reference but definitely not as a step by step beginner's book. It will leave you with more questions than answers. I would go for a book more dedicated to a particular facet of .NET, rather than this `all in one' step by step. For that reason, I'd probably choose Petzolds if you're looking to learn the C# `language', (It is also an excellent start in learning about OOP, though it doesn't touch upon Interfaces). There are also other excellent books on OOP, ADO & the .NET framework.
   
   The style of this book leads me to believe it was written with the C++/Java developer in mind who want a quick jump to C#, rather than the VB developer who needs to adapt to the new framework. I'd only buy it if what you're looking for is a brief overview of the lot.



2. One of the best book I have seen on the subject for people new to C# .Net, but know some other language.



3. It starts out in the first ten chapters explaining the concepts pretty well, and then it turns into an example-fest without any consideration for its namesake ("step by step"). All the examples are incomplete using "..." to signify previously exampled code. Its like a freaking jigsaw puzzle (especially CH 15) unless you have a laptop and are following the source from the cd), but why must you use both? The book itself should be self-contained.
   I read some other reviews and felt the same criticisms reading it in the book for the first time (especially on the "ternary operator statement" from the review by ANT).
   THE BOOK IS NOT FOR BEGINNERS.
   I still don't fully understand what struts or interfaces are. In places, it uses allegories instead of definitions. The book is just bad. I think Im writing this review mostly for venting frustration about the amount of time I spent reading it.



4. this is pretty good book for a beginner who has some programming experience and wish to learn C#. i have read some of the comments such as "Definitely Not For Beginners". i would like to say, probably the reader doesn't know how to program at all. the example is easy to follow. i have to admit that i didn't test on all the sample code from CD, but with the thorough elaboration learned from the book, it's enough for me to write my own testing code. For example, there is some topic about ArrayList and the book provide a sample for playing card, instead of using the sample provided, i rather write my own to test it out.
   
   this book is not for those who want to learn windows programming in c# or web development. if you already know c# but want to know more about windows / asp.net programming. this is not the book for you.



5. This book does, indeed, take you through C# step by step. It does a farly good job of introducing concepts and showing them in action. Usually by opening a file and entering the code. My biggest complaint about this book and the vast majority of other programming books that I've encountered is the lack of exercises. It's all well and good to demonstrate a while statement and the data types but just saying, "Type in the following lines", doesn't teach you to write a program.

1 comments about Programming ASP.NET AJAX: Build rich, Web 2.0-style UI with ASP.NET AJAX.

1. A great read.
   A must read for AJAX developers!
   ASP.NET AJAX is a free framework for quickly creating efficient and interactive Web applications that work across all popular browsers.
   This book will teach you:
   1) Create next-generation interfaces with reusable AJAX components.
   Enhance existing pages using powerful AJAX controls with support for all modern browsers.
   2) Access remote services and data from the browser without tons of complicated script.
   3) Take advantage of the improved efficiency and ease of use in Visual Studio 2008, with its built-in support for ASP.NET AJAX, improved JavaScript support, and a new Web page designer interface.
   It starts you off with a intro into asp.net AJAX library and moves into a light introduction with JavaScript. Then moves into the core of the AJAX functionality with using several examples of xmlhttprequest object and transferring data using both JSON and xml.
   It then leads you to the next logical step of the calling web services and makes great use of the inherit asp.net members and profiling functionality ALL THROUGH JAVA SCRIPT. Amazing really no more calls backs to the server to find out if they are a member.
   It then leads you into the Next big step of the asp.net AJAX functionality which is the control toolkit. This is a absolutely free web controls that just work and christen does a great job at showing you how to do this in easy steps.
   It wraps with showing the the asp.net futures section that is iffy at best. It uses an xml based approach to forming JavaScript and although very cool I don't believe will reach the production release.
   Overall this book rocks and should be read by all interface designers

No comments about Team Foundation Server 2008 in Action.

5 comments about Developing Application Frameworks in .NET.

1. Developing Application Frameworks in .NET is a valuable resource for mid to senior level developers or architects. It presents fundamental concepts when designing and building frameworks for the middle tier for an IT based enterprise solution. Not only does it solidify the reader with strong concepts, it also introduces and explains fundamental Microsoft C#.NET technologies needed for implementation.



2. As one would say that mere coders think in terms of ad-hoc one time solutions while developers and software engineers think how to incorporate these best practices in the form of an application framework. Xin Chen has done a good job explaining big picture thinking i.e. how a set of libraries or classes that are used to implement the standard structure of an application are made to collaborate in the form of a reusable framework.
   
   I'm personally a big fan of application frameworks which provide extensibility along with good foundation support for example Rocky Lhotka's CSLA (Component-based Scalable Logical Architecture). Xin Chen does the similar job building one chapter at a time. He is walking the reader through step by step building of the framework and keeping the big picture in sight. The book is divided into 15 chapters in which Xin elaborates on application frameworks, dissect them, discusses class factories, caching, configuration, windows services, message queuing, authorization, authentication, cryptography, transaction, document layer and work flow services. The author has high degree of familiarity with GOF design patterns so reader will see the degree of reusability and patterns & practices in action. Application event logging and exception handling is an inherent part of any application framework however I was disappointed to see not much discussion about it in the book. Also, during the discussion of real world business problems, author did not discuss rules engines or provide guidance about integrating dynamic logic into your framework which I strongly feel should be an integral part of an enterprise level architecture. The current business models as we know them thrive on change and we cannot isolate development designs from user's needs.
   
   Having said that, if you are looking to build a large amount of reusable code into a framework to save development time for yourself and fellow colleagues / developers, this book will provide you enough good pointers for this purpose. Author recognizes that the frameworks cannot be built in the air and hence provided us with concrete examples. I'll also recommend reading "GOF Design Patterns", Rocky Lhotka's "CSLA.NET 2.0 (Expert C# Business Objects)" and "Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries" along with this if you are serious about developing application frameworks for your enterprise.



3. I have been developing application frameworks for several years. This book is a good read about them. It covers many of the issues related to application frameworks including class factories, configuration and security. Each chapter contains information about the 'theory' related to these topics and information about the .Net implementation. I learned about .Net classes I was not aware of.
   Although I recommend reading the book, I want to warn potential readers about two issues:
   - The book ignores some aspects of application frameworks. Missing for example is logging, which is very important in practice. Users of your framework will want to monitor it and logging will be an issue you have to deal with.
   - Sometimes the author is more concerned with showing a clever implementation than a practical one. I find the hierarchical cache interesting but in practice there are bigger issues: how efficient is the cache (creating the xml document seems a performance killer), how are cached elements evicted (this brings issues about timing and locking that are ignored in the book), etc. Similarly, I have rarely seen the need for all the configuration-based customization that the author shows. I would have appreciated if each chapter discussed the goals of the implementation (e.g., performance vs. ease of use) and its trade-offs.
   I recommend the book but think twice about your goals before copying the implementation.



4. The problem with this book is that SAF, the sample framework, is a toy just for demonstration purpose. The book gives insight on why and how to construct a framework, very good in this aspect, but it doesn't give you a real framework you can adapt or use.
   What's is the point of writing your own framework from the base, if frameworks are supposed to be so generic that can be used in disparate applications, a framework written by a real expert would be good for you too, or at least an excellent starting point.
   I think a really useful thing would be a open source project, community supporting and a book.
   Lhotka does something like that, but his framework is focused in implement a configurable dataset, very good, but frameworks have lots more aspects.
   This book teach the basic well, .net technologies, gof patterns with examples. A must read for beginners, not very useful for more advanced people.



5. This is not only helpfull for architects, but for programmers responsible for planning and scoping projects in general. The writing is to the point, and provides very solid foundations for writing high level framework strategies. The only thing lacking would be that I think it is geared toward 1.1 framework, would be great to see how 2.0 could enhance this. The frameworks in the book are great starting points which can be enhanced based on your own business requirements.

No comments about Visual C# How to Program (3rd Edition).

4 comments about GDI+ Custom Controls with Visual C# 2005.

1. The caption on the front of the book states that GDI+ Custom Controls is a "fast-paced example-driven tutorial," which it is just that. This book covers the main essentials for GDI+ that all control developers want to know, including topics on painting, mouse movements, printing, drag/drop, and other topics.
   
   The authors of the book like to use the examples to drive home most of the points about GDI+. Though it starts out by discussing each subject, it quickly moves to an illustration of the subject through an example, explaining the concepts in a follow-up response. Throughout the book are little tidbits of knowledge that are really good concepts to understand. Already knowing quite a bit about GDI+, there was some information for me still to learn on the subject.
   
   The overall writing style of the book makes it an easy read. Plus, this book has more code sections than the average book to look at, as well as screen shots, which makes it more practical. Generally after each code section, there is a review to explain what the code does, not leaving you to guess what all of the purpose of the code is. In addition, I've included a review on the content of the chapters below.
   
   This book starts out with a discussion on the fundamentals of controls: the different parts they are composed of and the objects and concepts for drawing them to the screen. It moves on towards drawing complex objects using the GraphicsPath object, which allows you to draw lines, curves, polygons, and other shapes in a continuous motion, as well as Transformations. These chapters focus mostly on the drawing of objects, with a minor amount of coverage on the handling of text. The example for the complex object section is the drawing and painting of the Visual Studio logo, which is an excellent example to illustrate a complex drawing example.
   
   Drawing control parts, borders, and adornments is the next subject, which is exposed to custom controls through the ControlPaint class. The book discusses each of the available control parts and includes a screenshot of their appearance in each of their states (such as a button in Checked, Flat, Inactive, Normal, or Pushed state). Next is the ability to render various border styles for a control, as well as various adornments (such as the resizing handle, the size grip used to resize windows, various glyphs, and other objects) on the screen. It is amazing all of the options available, and the book discusses some of the uses in the examples in the chapter.
   
   It covers more of the major functionality in controls in the next several chapters, such as how to display and alter images, print a control's text output to the printer, and handle mouse clicking and moving events within the control, each with their own example. The book also talks about the two kinds of dragging; dragging a control around the screen, and dragging/dropping an object.
   
   The chapter on custom collections discusses both non-generic and generic versions of each type of collection. It discusses how each collection works, which is important to know. I personally didn't realize all of the different options that were available. However, the book doesn't cover creating your own custom collections, which you see implemented in most controls.
   
   The book continues with a short discussion on double-buffering and how you can improve performance by storing the painting of a control in memory. To do this, the example it uses is scrolling text across the screen, which can be an intensive process. As you may know, scrolling is an intensive process because it has to repaint constantly. If you've had the Task Manager open when scrolling a Microsoft Word document, you may know what I'm talking about. The one example I wish they would have included in this is the use of scrollbars in a control, as they talk about it before moving on to a scrolling text example.
   
   Controls have a design-time environment, which the next chapter talks about. You can add additional features, such as using custom windows forms to provide property editing support, using attributes to interact with the property grid, or using a type editor to limit the amount of acceptable values. For instance, the Color control has a limited set of values based on the enumeration, which the built-in type converter handles that limitation, by providing a drop down box with the selection of colors. This chapter talks about all the various aspects of design-time components, but I wish it would have gone more in-depth in regards to the examples. It touched upon the Color type converter, but only implemented a custom modal property editor, leaving out some of the other topics like designers themselves, which can be complex. It also didn't mention about Action lists, a new feature in the design-time environment.
   
   The book comes to an end with a design theory chapter, stating concepts you should think about when designing your custom control. Taking these concepts of "appearance", "intuitiveness", and "stability", we come to the last chapter which uses them to create a custom PieChart control, a more advanced control tying in the various topics discussed throughout the whole book. The control renders a pie chart, and if it can, the text for the item in the pie chart directly in the control, with a legend on the side.
   
   In reading this book, I found it to be a great guide to get you started. It doesn't cover each subject in great detail; if it would, it would have to be a reference book, and would be way too many pages to cover in one book, not to mention the monumental price. After all, windows development is a complex topic with so many different aspects to it. But this book, for someone who doesn't understand the concepts or who has a basic knowledge of GDI+, and only has a minor understanding of custom controls, will find this book beneficial as a starting place to get a framework for developing custom controls in the windows environment.



2. While the book looks like a good book from what we've read (we do pretty much no application programming though), don't make the mistake of getting it in hopes for Custom Controls for C# on the web.
   
   We should have read more into it (the Visual C# Express Edition comment should have been a hint), but it was the only book on Custom Controls out at the time, so we hoped on it hoping to find some neat control examples.
   
   We were disappointed when we found it only dealt with Application Custom Controls and there is very little thus far we could adapt for the web.
   
   I really wish they would have put somewhere in the description to spell it out that there are no C# web items in the book, though.



3. It is a good book about understanding how GUI widgets are drawn on screen , however I think it could have gone further in depth , taking into account more traditional Widgets.



4. This book worked out very well for me. It's very readable and at about 250 pages, it covers a lot of ground very fast. I hadn't worked with custom controls before this and now I am quite comfortable with them.
   
   One of the things I liked about it was that it was example driven. You build custom controls starting on chapter 1. Then they go over GDI+, then more advanced image manipulation, event handling, double buffering, design time support, deployment and in the last chapter you put it all together in a pie chart example.
   
   Two caveats. You might want something more comprehensive for reference. For that reason I also have Pro .NET 2.0 Windows Forms and Custom Controls in C#. Also, I think some of the UI stuff could have been a tad more stylish.

5 comments about Simply C#: An Application-Driven(TM) Tutorial Approach (Simply).

1. For the authors of Simply C#. A note from a guy who programs for the challenge and fun of it. I am in chapter 32 of Simply C#. Bravo for a wonderful learning experience! I have seen (and bought) lots of Programming Books (Basic, C, C++) over the years, yours in number ONE on my list..Wow..it is a joy to work with..Thanks..Thomas J. McGrail. Longs, SC



2. If you are new to C# and has no experience with other C based languages (C, C++, Java), then this book should be the first book you should read. All the rudimentry concepts are explained in detail. The practice problems are marvelous. The author, unlike most programming authors, clearly understands the paramount importance of writing practice programs to learn a new computer language.

   If you want to have a heavy duty understanding of ADO, ASP, and OOP, then this book will come up short. But there are other books in the market that will fill that niche.




3. If you are like me and need to have 'hands-on' practice to learn new things, then this is the book for you. Lots of code with concise and detailed explanation of all the concepts being presented. A step by step tutorial with each exercise building on the previous one. You become 'immersed' in the code with the end result that you actually learn something.



4. I would say that this book would be the step after Deitel's C# How to Program. The concepts in this book are more mathmatic then what is in How to Program.
   
   In essance I found explanations of most of the concepts vague.
   
   If you are just beginning to program, then i would say do the How to Program first and Simply C# after. You should be able to write some decent programs and head into an ADO or ASP .net book from there.



5. This book is very good on teaching the basics of C#, and makes you think a bit. The tutorial driven approach enables you actually get experience in every chapter ( at the end of every chapter are good exercises). The problem is that you do not have the answers to the excercises available unless you have the Teacher edition ( this is a classroom book ) , and Deitel will not help you out in this area ( say if you are stuck on an excercise ).There are also 'Programming Challenges' at the end of every chapter that have you use command and concepts that you have yet to learn ( not in all but some ). Other than that, this tutorial is very good, just bad customer service from the authors.