Customer Reviews

Professional NT Services

5 star:		(15)
4 star:		(3)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

It's hard to find someone these days who works with NT and is entirely unaware of NT services. There have been books treating the topic, there's some info and samples on MSDN, mag articles, and so on. Nevertheless, there have been two problems with all of it. First, all sources were treating services very narrowly, within a limited API-programming scope, and second--it was all over the place. This book imo successfully addresses both of these problems. It is most of what anyone would ever need on the topic, collected all in one place. Better yet, the author extends the coverage into lateral areas, from both the business and technological viewpoints. There's quite a bit on security, event-logging, COM and NT services interaction, MS message queue programming, ATL, debugging, profiling, and more. Quite a bit of that is useful even in its own right--services or not. You end up learning some, picking some suggestions, stealing code snippets from here and there... The book increases one's comfort not only with "hows" but also with "whys" of NT service programming. This may be the best book of the kind I've read lately.

Which is not to say that it's perfect. Some passages, especially at the beginning, are somewhat unreadable. For some reason, "role" is repeatedly spelled with the French accent... There's been a few rather touching cases of split infinitives-evasion that resulted in what J.K. Galbraith once called "fine examples of fiduciary prose" that "the conoisseurs will want to read backward as well as forward." But not much of it! Not much at all... While on a few occasions the author did start to slide into OO crypto-shamanism--there's a few "patterns" and "semantics" here and there--he clearly managed to regain control of himself--the patterns theme is used reasonably, and not in an altogether inappropriate context. What else? In a few places "persist" was used as a transitive verb, which is annoying. Anyway, that's nit-picking. Let's concentrate on positives: there wasn't a single "refactoring" in all of the book! Not a single "cool" either. The words "remote" and "migrate" weren't used as transitive verbs--a feat unheard of in the realm of MS stuff-related tech writing. In fact, "remote" wasn't even used as a verb at all. I repeat, this book is the cleanest of the ones I've seen lately. A word about Wrox: While many formerly-trustworthy publishers, like AW, have obviously given in to the temptation and engaged in large-scale consumer fraud by throwing oodles of nonsense, pseudo-scientific OO-puffery at the reader, Wrox seems to be quietly establishing itself on the level with O'Reilly. Good for them. Thanks to the author and the publisher.

No other source compares to the quality and convenience of Professional NT Services, either in book form or on the Internet. The only other way to get this information is to read sample code on MSDN, which is a less-than-optimal way to learn the subject.

Professional NT Services describes the issues involved in writing services, such as security and threading, and provides sample code every step of the way. The book also details how to build a service with ATL and even tells you how to improve ATL's implementation. It even talks a bit about Microsoft Transaction Server (now part of COM+).

Here are three bits of information that I discovered elsewhere that I wish were more evident in the book -

1. If you create an ATL service, the default registation code registers the EXE as a COM server instead of a service -- run "myservice.exe -Service" to register the service.

2. The easiest way for multiple clients to be able to use a single COM instance that's housed in the service is to implement the COM class using DECLARE_CLASSFACTORY_SINGLETON. This is your typical "server" pattern.

3. Clients that want to connect to COM objects housed in the ervice should use CLSCTX_SERVER in CoCreateInstance

Perhaps this information is buried in the book somewhere, but I didn't find it. At any rate, without this book, I wouldn't have known where to start.

Finally, for all its great qualities, the book needs to be revised for Windows 2000. It mentions some new features of "NT5" but I wonder how accurate this information really is.

The book is comprehensive, clear, and easy to read. The source code works and it is easy to follow (the code is available on-line.) The discussion on ATL COM servers is truly enlightening and by itself worth the price of the book. If you are writing an ATL COM server this book is a must, especially if it will be a multi-threaded server.

From the beginning the author has the attitude that NT services are easy to understand and his "prophecy" becomes self-fulfilling throughout the book. The book is well organized and it pays special attention to service design and usage patterns.

Also notice that the book does not cover hardware drivers. By the way, do read the previous review titled "One of a kind" as it gives very useful tips on installing ATL services (using "myservice.exe -Service") and housing COM objects in a service; I have not found that information in the book.

This book addresses all the issues related to such complex problems as NT Services. The author explains them in very great details, and makes you understand how all this works. The sample code works and you can use the classes from the book to start coding NT Services very fast. The author is very talented in explaining difficult concepts. Funny enough, this book has the best explanation on MSMQ, as well as apartments. As an alternative to the classes provided in this book, I recommend the CodeGuru NT Service C++ wizard written by Joerg Koenig. But even with a wizard, it is good to know how all this works.

This is the kind of book you don't want to put down until you've read it cover to cover. And then you start writing your own services using some of the best example code (starter code, really) and base classes I've ever seen in a book. It's a complete 'how to' and 'why' reference manual, targeted at developers who know C++ and Windows but not Services.

The only book on the subject and its an excellent read and technically advanced.

Knowledgeable and complete explanation of importance and use of NT services. Every "How" has concise and understandable "Why". Chapter about NT security, general tips for multithreaded design, MSMQ, ..., a lot of extra staff. Elegant C++ classes for every aspect of NT service development - immediately reusable. Worth every penny you'll pay for this book.

This book is a excellent explanation of the important technologies involved in writing services for NT. The writing is clear, and understandable. The treatment is complete, and, surprisingly, not overly verbose or redundant (as is often the case with books of this type). This is an wonderful book for beginning service writers as well as experts. Beginners will appreciate the clear writing and logical pace. Experts will apperciate the complete coverage and apt organization. Reading just the chapters you are interested in is quite easy. Later chapters do not make unnecessary assumptions to previous examples or specific material earlier in the book, making this a useful reference.

After years of administering Windows NT Services the time finally came that I needed to write a service; this book taught me everything I needed to know about how NT Services work: not just with function prototypes, but with plenty of well-written examples, class wrappers for common tasks, and practical advice.

Reading this book made me realize how much information was missing from all of the NT Service administration books that I had read (such as the NT Server Resource Kit). This book inadvertantly contains the best information on NT Service security, setup, registry settings, dependencies, startup, error logging, and other administration topics.

Pratical advice abounds; after a section on the three ways to control service start order, Miller waxes, "...I can reveal that what you need to do in real life is almost never extremely complex. Most of the Win32 services you will write won't have convoluted interactions with other services. If the service will use RPC, for instance, you just need to make sure to specify RPCSS as a service dependency." That advice is very helpful to the beginning NT Services programmer that might be thinking about Load-ordering Groups or Tag Order for controlling service startup ( the most common route is Dependencies ). He continues, "The best advice I can give you is to keep it as simple as possible - use specific service dependencies rather than complex combinations of load-ordering groups and tag values whenever possible."

Hope this helps.

After spending weeks in the MSDN labyrinth, trying to tie together the disjoint topics described, I found this book. It would have saved me much aggrevation and frustration had I found it earlier. The author ties together all the neccessities of an NT Service, installation, configuration, Event Logging, Security, LocalSystem, user accounts etc. in a clear, concise manner. The author does NOT dismiss related topics with the wave of a hand with the infamous "beyond the scope of this book" statement, but rather gives you a well founded background in them. i.e NT security and issues to beware of when working with services, an analysis of MSMQ and how to work with services, working with COM objects... I could go on, but you get the picture. If you are going to be working with NT Services, BUY THIS BOOK.