PDF Download Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition)
In this instance, what should do after getting this web site is so straightforward? Discover the web link and also take it as your referral to go to the web link of the book soft file. So you could get it flawlessly. This publication provides an impressive system of just how guide will certainly affect the presence of the life framework. Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) is a manner that could reduce your lonely sensation when remaining in the lonesome leisure.
Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition)
PDF Download Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition)
Do you require brand-new recommendation to accompany your extra time when being at residence? Reviewing a publication can be a good selection. It could save your time usefully. Besides, by reading publication, you could enhance your expertise and experience. It is not just the science or social expertise; several things can be acquired after reading a publication.
When reading the title, you can see how the author is very reliable in using the words to create sentences. It will be also the ways how the author creates the diction to influence many people. But, it's not nonsense, it is something. Something that will lead you is thought to be better. Something that will make your feel so better. And something that will give you new things. This is it, the Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition)
As known, to finish this publication, you could not should get it at the same time in a day. Doing the tasks along the day could make you really feel so bored. If you aim to force reading, you might favor to do other amusing tasks. However, one of ideas we desire you to have this book is that it will certainly not make you really feel bored. Feeling burnt out when checking out will certainly be only unless you don't like guide. Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) really uses exactly what everybody wants.
Be the initial to download this e-book Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) as well as let read by surface. It is very simple to read this book Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) considering that you don't have to bring this printed Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) everywhere. Your soft documents book can be in our gizmo or computer so you could appreciate reading everywhere and also each time if required. This is why lots numbers of individuals additionally check out the books Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) in soft fie by downloading and install guide. So, be just one of them that take all advantages of checking out guide Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) by online or on your soft documents system.
From the Inside Flap
This book shows how to use the Win32 Application Programming Interface (API) and the emerging Win64 API, concentrating on the core system services, including the file system, process and thread management, interprocess communication, network programming, and synchronization. User interfaces, internals, and I/O drivers, although important and interesting topics, are beyond the scope of this book. The examples concentrate on scenarios that are likely to arise in practice, and in many cases the examples can be used as bases for real applications. The Win32 API is supported by Microsoft's family of 32-bit operating systems:Windows 2000, Windows NT, Windows 98, Windows 95, and Windows CE. Win64, tobe supported as a 64-bit interface on Windows 2000, is very similar, and migrationissues are discussed as required. There is no doubt that Win32, along with Win64,is an important factor for application developers, in many cases replacing UNIXas the preferred API for application programs targeted at desktop and serversystems. Many observers predict that Win32 will become the dominant programminginterface, although it appears that UNIX and Win32 will continue to coexistand that each will find its own niche.Regardless of the outcome of the operating system wars, many experienced programmerswill want to learn the Win32 API quickly, and this book is designed to helpthem do so. The first objectives are to explain what Win32 is, show how to use it in realisticsituations, and do so as quickly as possible without burdening the reader withunnecessary detail. This book is, therefore, not comprehensive, but it explainsthe central features of the most important functions and shows how to use themin realistic programming situations. Equipped with this knowledge, the readerwill be able to use the comprehensive Microsoft reference documentation to exploredetails, advanced options, and the more obscure functions as requirements orinterests dictate. I have found the Win32 API easy to learn using this approach,and I have greatly enjoyed developing Win32 programs, despite occasional frustration.This enthusiasm will show through at times, as it should. This does not meanthat I feel that Win32 is necessarily better than other operating system APIs,but it certainly has many attractive features. Many Win32 books assume that the user is familiar only with 16-bit Windows 3.1 programming. These books spend a great deal of time explaining how processes, virtual memory, interprocess communication, and preemptive scheduling work without showing how to use them in realistic situations. A programmer experienced in UNIX, VAX VMS, IBM MVS, or another high-end operating system--that is, nearly anything other than the long-obsolete Windows 3.1 Win16 API--will be familiar with these concepts and will be impatient to find out how they are implemented in Win32. Most Win32 books also spend a great deal of space on user interface programming. This book avoids the user interface, beyond discussing simple character-based console I/O, in the interest of concentrating on the important core features. This book takes the point of view that Win32 is just an operating system (OS)API, providing a well understood set of features. Many programmers, regardlessof experience level, need to learn Win32 and the Windows operating systems quickly,and an understanding of Win32 is invaluable in discussing subjects such as Microsoft'sComponent Object Model (COM). The Windows systems, when compared with othersystems, have good, bad, and average features and quality. The purpose of thisbook is to show how to use those features efficiently and in realistic situationsto develop useful, high-quality, and high-performance applications. AudienceAnyone who has experience programming in UNIX or another operating system, even Windows 3.1, and who wants to learn about Win32 quickly. Programmers and software engineers who must port existing applications, often in UNIX, to Win32 for operation under Windows 2000 or any of the other Windows platforms. This book contains many comparisons among Win32, UNIX, and standard C library functions and programming models. All common UNIX functionality, including process management, synchronization, file systems, and interprocess communication, is covered in Win32 terms. Programmers who are developing servers or other systems or components in which management of resources such as processes and threads is of primary importance and in which the user interface is of secondary importance. Programmers using COM or DCOM will find much of the information here helpful in understanding COM's DLL usage, thread models, interfaces, and synchronization. Readers starting new projects who are not constrained by the need to port existing code. Many aspects of program design and implementation are covered, and Win32 functions are used to create useful applications and to solve common programming problems. Computer science students at the upperclass undergraduate or beginning graduate level in courses covering systems programming or application development. This book will also be useful to those who are learning multithreaded programming or need to build networked applications. This book would be a useful complementary text to a book such as W. Richard Stevens' Advanced Programming in the UNIX Environment (see the Bibliography) so that students could compare Win32 and UNIX. Students in operating systems courses will find this book to be a useful supplement as it illustrates how a commercially important operating system provides essential OS functionality. The only other assumption, implicit in all the others, is a knowledge of Cprogramming. Organization Chapters are organized topically so that the features required in even a single-threadedapplication are covered first, followed by process and thread management features,and finally network programming in a multithreaded environment. This organizationallows the reader to advance logically from file systems to security, memorymanagement, and file mapping, and then to processes, threads, and synchronization,followed by interprocess and network communication. This organization also allowsthe examples to evolve in a natural way, much as a developer might create asimple prototype and then add additional capability. The advanced features,such as asynchronous I/O, appear last. Within each chapter, after introducing the functionality area, such as processmanagement or memory-mapped files, we discuss important Win32 functions andtheir relationships in detail. Illustrative examples follow. Within the text,only essential parts of programs are listed; complete programs and the requiredinclude files, utility functions, and the like are in an appendix or on thedisc provided with the book. Throughout, we identify those features supportedonly by Windows 2000 and NT, because Windows 98, 95, and CE do not implementmany advanced features. Each chapter suggests related additional reading andgives some exercises. Many exercises address interesting and important issuesthat did not fit within the normal text, and others allow the reader to exploreadvanced or specialized topics. Chapter 1 is a high-level introduction to the Windows OS family and Win32.A simple example program shows the basic elements of Win32 programming styleand lays the foundation for more advanced Win32 features. Win64 and migrationissues are introduced in Chapter 1, described extensively in Chapter 16, andincluded throughout the book as required.Chapters 2 and 3 deal with file systems, console I/O, file locking, and directorymanagement. Unicode, the extended character set used by Windows 2000/NT, isalso introduced in Chapter 2. Examples include sequential and direct file processingand a directory traversal program. Chapter 3 ends with a discussion of registrymanagement programming, which is similar in many ways to file and directorymanagement.Chapter 4 introduces Win32's Structured Exception Handling (SEH) capability,which will be used extensively throughout the book. Many books defer SEH tolater chapters, but by introducing it early we will be able to use SEH throughoutand thus simplify some programming tasks and improve quality. Chapter 5 explains Windows NT object security, showing, in an example, how to emulate UNIX-style file permissions. Security upgrades can then be applied to the examples as appropriate. Although security is used in the later chapters, feel free to skip this chapter if you are not interested in this topic. Chapter 6 treats Win32 memory management and shows how to use memory-mappedfiles both to simplify programming and for performance. This chapter also coversdynamic link libraries (DLLs). Chapter 7 introduces Win32 processes, process management, and simple processsynchronization. Chapter 8 then describes thread management in similar terms.Examples in each chapter show the many benefits, including program simplicityand performance, of threads and processes. Chapters 9 and 10 provide an extended, in-depth treatment of Win32 thread synchronization,one of Win32's strong features. Synchronization is a complex topic, and thesetwo chapters use extended examples and well understood models to help you obtainthe programming and performance benefits of threads while avoiding many of thepitfalls. Chapters 11 and 12 are concerned with interprocess and interthread communication and networking. Chapter 11 concentrates on the features that are properly part of Win32--namely, pipes, named pipes, and mailslots. Chapter 12 treats Windows Sockets, which allow interoperability with non-Windows systems using industry-standard protocols, primarily TCP/IP. Windows Sockets, while not strictly part of Win32, provide for network and Internet communication and interoperability, and the subject matter is consistent with the rest of the book. A multithreaded client/server system illustrates how to use interprocess communication along with threads. Chapter 13 describes how Windows 2000 and Windows NT provide "NT services"that allow you to manage background servers, such as the ones created in Chapters11 and 12. Some small programming changes will turn the servers into NT services.Chapter 14 shows how to use overlapped I/O with events and completion routines. For file systems, this feature applies only to Windows 2000 and NT, and you can achieve much the same thing with threads. The closely related I/O completion ports are, however, necessary for scalable multithreaded servers, so this feature is illustrated with the servers created in Chapters 11, 12, and 13. Waitable timers are described, because they require concepts first introduced in Chapter 14. Chapter 15 concludes with a survey of two specialized topics: Remote Procedure Calls (RPCs) and Microsoft's COM object model, which integrates many of the concepts in the book. Remote procedures and COM objects frequently use the features described throughout this book. Simple examples are included, and this chapter illustrates that readers now have the necessary information to learn other Win32 topics beyond the core system services. Chapter 16 describes the Win64 programming issues and how to plan for applicationmigration and portability. There are three appendices. Appendix A describes the programs on the disc andhow to use them. Appendix B contains several tables that compare Win32 functionswith their counterparts in UNIX and the Standard C library. Appendix C comparesthe performance of alternative implementations of some of the examples in thetext so that you can gauge the trade-offs between Win32 features, both basicand advanced, and the C library. Notes on the Second Edition The Second Edition includes extensive new material along with significant updatingand reorganization. Objectives of the Second Edition include: Cover Windows 2000 and Win64 migration. Provide increased coverage of threads and synchronization. Chapter 10 is new, as are the examples in Chapter 9. Add coverage of sockets and remote procedure calls (Chapters 12 and 15) and NT services (Chapter 13), thereby dealing with issues that are important when developing services and servers, particularly for Windows 2000. Describe the performance implications of threads and synchronization in more depth (Chapters 9 and 10). Incorporate reader and student feedback to fix defects, improve explanations, improve the organization, and address numerous small details. UNIX and C Library Notesand Tables Within the text at appropriate points, we contrast Win32 style and functionalitywith the comparable UNIX (and LINUX) and ANSI Standard C library features. Tableslisting the comparable functions are presented in Appendix B. This informationis included because many readers are familiar with UNIX and are interested inthe comparisons between the two systems. Readers without a UNIX background shouldfeel free to skip these paragraphs. Such discussions are indented, in a smallerfont. Examples The examples are designed to do the following: Illustrate common, representative, and useful applications of the Win32 functions. Correspond to real programming situations encountered in program development, consulting, and teaching. Some of my clients and course participants have used the code examples as the bases for their own systems. During my consulting activities, I frequently encounter code that is similar to that used in the examples, and on several occasions I have seen code taken directly from the First Edition. (Feel free to do so yourself, and an acknowledgment in your documentation would be greatly appreciated.) Frequently, this code occurs as part of COM or C++ objects. The examples are "real-world" examples and solve "real-world" problems. Emphasize how the functions actually behave and interact, which is not always as you might first expect after reading the documentation. Throughout this book, the text and the examples concentrate on interactions between functions rather than the functions themselves. Grow and expand, adding new capability to a previous solution in an easy and natural manner and exploring alternative implementation techniques.In the earlier chapters, many examples implement UNIX commands, such asls, touch, chmod, and sort, showing the Win32 functions in a familiar contextwhile creating a useful set of utilities. Different implementations of thesame command will also give us an easy way to compare performance benefitsavailable with advanced Win32 features. Appendix C contains the results ofthese performance tests. Examples in the early chapters are usually short, but the later chapters present longer examples when appropriate. Exercises at the end of each chapter suggest alternative designs, subjectsfor investigation, and additional functionality that is important but beyondthe scope of this book. Some exercises are easy, and a few are very challenging.Frequently, clearly labeled defective solutions are provided, because fixingthe bugs is an excellent way to sharpen skills. All examples have been debugged and tested under Windows 2000, Windows NT,and, where appropriate, Windows 98 and 95. For Windows NT testing we used Version4.0, and although the bulk of the development was performed on single-processor,Intel-based systems, many programs were also tested on multiprocessor systems.The client/server applications have been tested using multiple clients simultaneouslyinteracting with a server. Nonetheless, there is no guarantee or assurance ofprogram correctness, completeness, or fitness for any purpose. Undoubtedly,even the simplest examples contain defects or will fail under some conditions;such is the fate of nearly all software. I will, however, gratefully appreciateany messages regarding program defects--and, better still, fixes.The code will be updated as required whendefects are found and fixed and as reader input is received. If you encounterany difficulties with the programs or any material in the book, check this locationfirst, because there may already be a fix or explanation. If that does not answeryour question, feel free to send e-mail to jmhart@world.std.0201703106P04062001
Read more
From the Back Cover
"If you are new to the Win32 API, but have programmed for other high-end operating systems such as UNIX or VMS, then Win32 System Programming is the book for you. HIGHLY RECOMMENDED." --Christopher L.T. Brown, Windows 2000 Magazine A practical guide to the central features and functions of the Win32 API, Win32 System Programming, Second Edition, will get you up and running with Windows NT and Windows 2000. Unlike most Windows programming resources, this book focuses exclusively on the core system services--file system, memory, processes, communication, and security--rather than on the more commonly featured graphical user interface functions. Especially geared for those already familiar with UNIX or other high-end operating systems, Win32 System Programming, Second Edition, helps you to build on your knowledge base to learn Win32 features quickly and easily. This new edition has been updated and enhanced with new coverage of network programming, servers, NT services, thread performance, and synchronization. It also offers a preview of Win64, the new 64-bit API for Windows 2000. Beginning with an examination of the features required in a single-process application, the text gradually progresses to increasingly sophisticated functions relating to a multithreaded environment. You will find extensive coverage of such critical Win32 topics as: The Win32 file system Character I/O and Unicode The registry Structured exception handling Security services Memory management and DLLs Threads, process management, scheduling, and thread synchronization Interprocess communication, featuring pipes and mailslots Network programming with sockets NT services, including the service control handler, event logging, and debugging Asynchronous I/O Remote Procedure Calls Win64, covering architecture, programming models, data types, and legacy code migration Short, practical examples illustrate each topic, and are included on the accompanying CD-ROM and supporting Web site (http://world.std.com/~jmhart/w32.htm). The appendixes compare Win32, UNIX, and the C library; and provide performance measurements and results. Win32 System Programming, Second Edition, will give you a solid grounding in the core operating system functions of the Windows environment, an understanding of Win64 for Windows 2000, and the know-how you need to put them to work. 0201703106B04062001
Read more
See all Editorial Reviews
Product details
Hardcover: 544 pages
Publisher: Addison-Wesley Professional; 2 edition (October 9, 2000)
Language: English
ISBN-10: 0201703106
ISBN-13: 978-0201703108
Product Dimensions:
7.6 x 1.2 x 9.5 inches
Shipping Weight: 2.3 pounds (View shipping rates and policies)
Average Customer Review:
4.1 out of 5 stars
20 customer reviews
Amazon Best Sellers Rank:
#4,070,655 in Books (See Top 100 in Books)
I thought the book was well written and would be marginally useful as a basic reference book but I expected more content such at the WIN32 API and more than just a preview of WIN64 and a summary discussion of COM/DCOM and other more complex subjects.The appendix comparing Win32, Unix and the "C" Library, while making good book fodder, is relatively useless without substantive definitions and examples.All in all, not much bang for the book. I would not have purchased the book if I had reviewed a copy of the book before ordering it through Amazon.
This is an excellent book. It provides enough information to give the reader a sound understanding of the Win32 System Services; but, it doesn't overburden him with minutiae that can be acquired from MSDN later -- if needed. The author's frequent comparisons of the Win32 System Services with those of UNIX are very effective in enabling the UNIX developer to bridge the conceptual gulf to Windows.
The rating I give here is just based on a skim of the book. However, after visiting the author's website, I very quickly realized that there is a fourth edition of the text. Unless you specifically want a more historical perspective, I would recommend that you get the fourth edition.
This book is roughly the same as Steven's "Advanced Programing in the Unix Environment". It gets you in touch with the moving pieces of the Windows operating system.Bring with you a strong understanding of C/C++ and some experience administrating a Windows system and you can be up and running banging against the operating system's APIs. Open network sockets, play with "Thread Local Storage", create and register your very own service, interface with the security system, whack around the registry, and a dozen other ways to shoot yourself in the foot or get some actual work done.This book has almost nothing about making windows, graphics, sounds, or anything else that will help you get started making yet another accounting application. If that's what you are looking for look somewhere else.This book also comes threateningly close to being a good beginners guide to porting *nix applications to the Windows operating system. The author draws many parallels to various *nix utilities and how to write their equivalent using Windows' APIs.For those that like plenty of rope to hang themselves, this is the book for you. I enjoyed learning about the various facilities Windows provides the developer, and feel that this book helped me gain a better understanding of where to look first for doing fairly common relatively low-level tasks.
This book pretty much covers everything I needed to know about Win32 system programming. It has very good coverage of topics like threading, file handling, Memory Management, Interprocess communication, network programming, and asynchronous I/O with completion ports. Ever wonder how to share memory or access really, really huge files? Want to learn how to build more scalable servers? This book covers all that and more. I recently took a new job that uses all of this stuff and I was relieved to find a book that covered it all so well.He gives a very good generalized view of the windows programming philosophy and explains some common windows types and their uses, which helps in understanding the rest of the API. There are plenty of programming examples and he often compares Win32 programming techniques to UNIX programming techniques giving references to the Stevens book which will help put things in context for UNIX programmers.For client side programming you can get by with Petzold but for server side this book is a must. If you do system development on Win32 then this book is your weapon.
This book pretty much covers everything I needed to know about Win32 system programming. It has very good coverage of topics like threading, file handling, Memory Management, Interprocess communication, network programming, and asynchronous I/O with completion ports. Ever wonder how to share memory or access really, really huge files? Want to learn how to build more scalable servers? This book covers all that and more. I recently took a new job that uses all of this stuff and I was relieved to find a book that covered it all so well.He gives a very good generalized view of the windows programming philosophy and explains some common windows types and their uses, which helps in understanding the rest of the API. There are plenty of programming examples and he often compares Win32 programming techniques to UNIX programming techniques giving references to the Stevens book which will help put things in context for UNIX programmers.For client side programming you can get by with Petzold but for server side this book is a must. If you do system development on Win32 then this book is your weapon.
John Hart has done a fabulous job of expanding and updating his coverage of Win32 system programming. Unique in it's perspective of educating programmers familiar with UNIX or a similar OS, this book explains the landscape of Win32 operating systems, how they relate to each other and what features are present or missing from each of them.With almost 150 pages of new material, John digs way beneath the surface and covers new topics such as advanced thread synchronization, sockets, Windows 2000, Win64, and performance comparisons of multiple ways to solve a problem. Many existing topics are also updated and have new sample programs.The appendix cross reference of Win32, UNIX, and C runtime library APIs that was in the first edition has also been revisitied and expanded. A very valuable resource for anyone new to either OS or working with both.In short, if you are coming to Win32 from a UNIX background this is definitely the book for you. If you're already a crack Win32 programmer, you'll probably learn a lot as well.
Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) PDF
Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) EPub
Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) Doc
Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) iBooks
Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) rtf
Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) Mobipocket
Win32 System Programming: A Windows 2000 Application Developer's Guide (2nd Edition) Kindle
0 komentar:
Posting Komentar