Windows (All Versions): MSDN Magazine Articles
MSDN Magazine: Windows (All Versions) rss

All MSDN Magazine Topics
  • Event Tracing for Windows: Core Instrumentation Events in Windows 7
    Alex Bendetov, Insung Park - September 2009 2009
    In the first article of a two-part series, the authors present a high-level overview of the ETW technology and core OS instrumentation.

  • Inside Windows 7: MultiTouch Capabilities in Windows 7
    Yochay Kiriaty - August 2009
    This is Part 3 of a multipart article series on Windows 7. Part 3 covers the Windows 7 multitouch capabilities.

  • Inside Windows 7: Introducing The Taskbar APIs
    Yochay Kiriaty & Sasha Goldshtein - July 2009
    This is Part 2 of a multipart article series on Windows 7. The focus of Part 2 is the Windows 7 taskbar.

  • Inside Windows 7: Introducing Libraries
    Yochay Kiriaty - June 2009
    This is Part 1 of a multipart article series on Windows 7. This article is about the new user profile storage concept in Windows 7, called Libraries.

  • Editor's Note: More than Pretty Pictures
    Howard Dierking - August 2008
    Complete freedom in creating the user experience can be a double-edged sword, but a little bit of artistry can transform an application's usability.

  • Windows with C++: Asynchronous WinHTTP.
    Kenny Kerr - August 2008
    This month's column explains how to use Windows HTTP Services, or WinHTTP, the new, powerful API for implementing HTTP clients.

  • Data and WPF: Customize Data Display with Data Binding and WPF
    Josh Smith - July 2008
    Here we present techniques for programmatic and declarative data binding and display with Windows Presentation Foundation.

  • CLR Inside Out: Extend Windows Forms Apps Using System.AddIn
    Mueez Siddiqui - July 2008
    See how Windows Forms applications can be adapted to use the new .NET Add-in framework (System.AddIn) this month.

  • { End Bracket }: Customize Windows Home Server
    Chris Gray - July 2008
    Chris Gray discusses custom applications he’s developed for Windows Home Server and explores applications for energy savings.

  • Windows with C++: Windows Imaging Component Basics
    Kenny Kerr - April 2008
    Windows Imaging Component (WIC) is an extensible framework for encoding, decoding, and manipulating images. See how to use WIC to encode and decode different image formats.

  • Foundations: Vector Graphics and the WPF Shape Class
    Charles Petzold - March 2008
    The System.Windows.Shapes namespace is Charles Petzold's namespace of choice for rendering two-dimensional vector graphics in WPF. Here he explains why.

  • WinUnit: Simplified Unit Testing for Native C++ Applications
    Maria Blees - February 2008
    Maria Blees introduces WinUnit, a handy new unit testing tool for native C++ projects.

  • Foundations: Templates for Uncommon Controls
    Charles Petzold - January 2008
    Charles Petzold demonstrates how Windows Presentation Foundation (WPF) templates let you turn common controls into uncommon visual objects.

  • Test Run: UI Automation with Windows PowerShell
    Dr. James McCaffrey - December 2007
    This installment of Test Run is a guide to using Windows PowerShell to perform ultra lightweight UI automation.

  • Windows with C++: Windows Template Library 8.0
    Kenny Kerr - December 2007
    Kenny Kerr takes a look at Windows Template Library (WTL) support for new Windows Vista control enhancements, including task dialogs, Aero wizards, and open file dialogs.

  • Crash Course: Analyze Crashes to Find Security Vulnerabilities in Your Apps
    A. Abouchaev, D. Hasse, S. Lambert, and G. Wroblewski - November 2007
    Here the authors analyze program crashes to help you understand if you have the potential for read or write violations in your applications, and how they can lead to security vulnerabilities.

  • { End Bracket }: WPF is for developers, too
    Kevin Moore - November 2007
    There's still a role for developers in creating applications with WPF and XAML. In fact there are three: plumber, widget author, and ground breaker.

  • WPF Threads: Build More Responsive Apps With The Dispatcher
    Shawn Wildermuth - October 2007
    Understanding the Windows Presentation Foundation threading model helps when creating user interfaces that are both compelling and responsive.

  • Mobile Apps: Adjust Your Ring Volume For Ambient Noise
    Chris Mitchell - October 2007
    Here's an overview of designing and installing a Windows Mobile app that monitors the noise level in the surrounding environment and adjusts the ring volume of a Pocket PC accordingly.

  • Test Run: Test automation with Windows XP Embedded
    Dr. James McCaffrey and Mike Hall - October 2007
    This month's column explores how to create lightweight but powerful UI test automation for software systems that run on Windows XP Embedded.

  • Windows with C++: Task Scheduler 2.0
    Kenny Kerr - October 2007
    The new Task Scheduler in Windows Vista can do so much more than previous versions. We introduce some basic concepts and building blocks you can put to use in your own scheduled task projects.

  • Windows with C++: Windows Vista Control Enhancements
    Kenny Kerr - August 2007
    With the release of Windows Vista, C++ developers will be happy to know there's plenty of magic left to perform. This new column will provide the necessary insight.

  • NTFS: Enhance Your Apps With File System Transactions
    Jason Olson - July 2007
    Presented here is an overview of Transactional NTFS and how it revolutionizes transactions.

  • Security: Applying Cryptography Using The CNG API In Windows Vista
    Kenny Kerr - July 2007
    Cryptography Next Generation (CNG) is meant to be a long-term replacement for the CryptoAPI, providing replacements for all of the cryptographic primitives it offered.

  • Speak Up: Support Dictation With Text Services Framework
    Eric Brown - July 2007
    Learn how to make your apps speech-aware by supporting Windows Speech Recognition and the Text Services Framework.

  • CONCURRENCY: Synchronization Primitives New To Windows Vista
    Robert Saccone and Alexander Taskov - June 2007
    Windows Vista has lots of goodies for native C++ developers including condition variables, slim reader/writer locks, and one-time initialization.

  • Concurrent Affairs: Asynchronous Device Operations
    Jeffrey Richter - June 2007
    Jeff Richter uses the AsyncResult<TResult> class to implement the CLR’s Asynchronous Programming Model to perform hardware device operations asynchronously.

  • Security Briefs: Events in Windows Vista
    Keith Brown - May 2007


  • XmlLite: A Small And Fast XML Parser For Native C++
    Kenny Kerr - April 2007
    XmlLite provides a high-performance, low-overhead XML reader and writer geared for applications written in native C++. Learn more here.

  • Event Tracing: Improve Debugging And Performance Tuning With ETW
    Dr. Insung Park and Ricky Buch - April 2007
    Event Tracing for Windows (ETW) provides general-purpose, high-speed tracing of events raised by both user-mode applications and kernel-mode device drivers. Learn how ETW can improve your development and debugging work.

  • Security Briefs: Improve Manageability through Event Logging
    Keith Brown - April 2007
    When something goes wrong, a manageable application will tell the administrator how to fix the problem. The Windows Event Log can provide the necessary information.

  • .NET Matters: Restart Manager and Generic Method Compilation
    Stephen Toub - April 2007
    This month Stephen Toub answers questions pertaining to the Windows Vista Restart Manager API and generic method compilation.

  • IIS 7.0: Explore The Web Server For Windows Vista And Beyond
    Mike Volodarsky - March 2007


  • .NET Security: Support Certificates In Your Applications With The .NET Framework 2.0
    Dominick Baier - March 2007


  • WiX Tricks: Automate Releases With MSBuild And Windows Installer XML
    Sayed Ibrahim Hashimi - March 2007


  • Foundations: Tracking Services in Windows Workflow Foundation
    Matt Milner - March 2007


  • Least Privilege: Teach Your Apps To Play Nicely With Windows Vista User Account Control
    Chris Corio - January 2007
    User Account Control in Windows Vista keeps the OS safe from intentional and accidental configuration changes.

  • Vista and Office: View Data Your Way With Our Managed Preview Handler Framework
    Stephen Toub - January 2007
    Stephen Toub shows you how to write your own Preview handlers for Windows Vista and Outlook 2007.

  • SideShow Gadgets: Get Started Writing Gadgets For Windows SideShow Devices
    Jeffrey Richter - January 2007
    SideShow Gadgets for Windows Vista are cool. Writing your own is even better. Find out how it's done.

  • Desktop Security: Create Custom Login Experiences With Credential Providers For Windows Vista
    Dan Griffin - January 2007
    Why is a change to the Windows logon plug-in interface so exciting? Because with credential providers you can customize the logon experience for your users.

  • Worldly Windows: Extend The Global Reach Of Your Applications With Unicode 5.0
    Julie D. Allen, Michael S. Kaplan, Cathy Wissink - January 2007
    When using global applications, people want to communicate with others on their terms, in their own languages. Unicode 5.0 brings that ideal closer to reality.

  • Editor's Note: A New Year—A New Vista
    Joshua Trupin - January 2007
    Josh Trupin revs the engine to get us all ready for Windows Vista.

  • Mobilize: Explore The New Features In Windows Embedded CE 6.0
    Paul Yao - December 2006
    Paul Yao presents an overview of Windows Embedded CE 6.0.

  • Locale Hero: Enable Global Apps With Locale Builder And Windows Vista
    Kieran Snyder and Shawn Steele - December 2006
    Everything you need to know about locales in Windows Vista.

  • Single Sign-On: A Developer's Introduction To Active Directory Federation Services
    Keith Brown - November 2006
    Use Active Directory Federation Services to allow other organizations to use your Web applications without the need for you to grant access explicitly.

  • Smart Storage: Protect Your Data Via Managed Code And The Windows Vista Smart Card APIs
    Dan Griffin - November 2006
    Smart cards are a compelling alternative to the reliance on passwords, which are the weakest link in authentication systems. Get the Windows smart card programming basics here.

  • CLR Inside Out: Investigating Memory Issues
    Claudio Caldato and Maoni Stephens - November 2006
    Memory issues can manifest in a wide variety of ways. This column shows you how to collect the data you need to determine what types of mem¬ory issues you are experiencing.

  • Cutting Edge: A Tour of Windows Workflow Activities
    Dino Esposito - November 2006
    Windows Workflow Foundation supports virtually any scenario where human opera¬tors are involved. Learn how to use it to tame your workflows.

  • Peer To Peer: Harness The Power Of P2P Communication In Windows Vista And WCF
    Justin Smith - October 2006
    P2P applications face a number of barriers preventing their wide adoption as a productivity solution. Fortunately Windows Vista improves the situation, as you’ll learn here.

  • Web Service Workflows: Deploy Distributed Business Processes With Windows Workflow And Web Services
    Israel Hilerio - October 2006
    Due to the distributed nature of a business process it makes sense for a workflow to be deployed as a distributed application. See how Windows Workflow and Web Services hold the key.

  • Security Briefs: CardSpace, SqlMembershipProvider, and More
    Keith Brown - October 2006
    This month Keith Brown fields some reader questions on InfoCard turned CardSpace and passwords for SqlMembershipProvider.

  • Security Briefs: Security in Windows Communication Foundation
    Keith Brown - August 2006
    Windows Communication Foundation provides three major protections— confidentiality, integrity, and authentication. This month Keith Brown explains what they can do for you.

  • Beyond WinFX: Transactions, Aero Wizards, And Task Dialogs In Windows Vista
    Kenny Kerr - July 2006


  • CLR Inside Out: Windows Vista Globalization Features
    Shawn Steele - June 2006
    Windows XP and the Microsoft .NET Framework both have APIs that support globalization. Windows Vista™ will further extend globalization support by introducing several new features.

  • { End Bracket }: Singularity
    James Larus, Galen Hunt, and David Tarditi - June 2006
    When the C and C++ programming languages were invented, computers were slow, memory was limited, and compilers were simple and memory challenged, so a practical language could be little more than a veneer for assembly language.

  • Built For Speed: Develop Turbocharged Apps For Windows Compute Cluster Server
    Rich Ciapala - April 2006
    This article explores the services provided by Compute Cluster Server 2003 and the tools provided by Visual Studio 2005 that will help you develop High-Perfomance Computing applications.

  • Talking Windows: Exploring New Speech Recognition And Synthesis APIs In Windows Vista
    Robert Brown - January 2006
    Windows Vista includes a built-in speech recognition engine exposed through a number of new APIs that will let your users interact with your app using speech rather than a keyboard or mouse. Here Robert Brown explains speech recognition and introduces you to the APIs to use in your upcoming Windows Vista applications.

  • Got Directory Services?: New Ways to Manage Active Directory using the .NET Framework 2.0
    Ethan Wilansky - December 2005
    System.DirectoryServices is a managed code layer on top of Active Directory Service Interfaces, and you can employ it to better manage Active Directory from your code. Here Ethan Wilansky helps you get started.

  • What Gives You the Right?: Combine the Powers of AzMan and WSE 3.0 to Protect Your Web Services
    Niels Flensted-Jensen - November 2005
    In this article, Niels Flensted-Jensen demonstrates how you can combine new and existing Microsoft technologies with minimal new code to provide flexible authorization for individual Web service methods. Windows 2003 Authorization Manager, Web Service Enhancements 3.0, and Enterprise Library all play a part.

  • Stay Alert: Use Managed Code To Generate A Secure Audit Trail
    Mark Novak - October 2005
    In today's security-conscious environments, a reliable audit trail is a valuable forensic tool The Windows Server 2003 operating system provides features that let you enable a wide range of applications to make use of auditing functionality. This article looks at auditing from the operating system perspective and describes a sample managed code implementation that will allow you to add auditing to your own server applications.

  • Winsock: Get Closer to the Wire with High-Performance Sockets in .NET
    Daryn Kiely - August 2005
    The Win32 Windows Sockets library (Winsock) provides mechanisms to improve the performance of programs that use sockets, and the Microsoft .NET Framework provides a layer over Winsock so that managed applications can communicate over sockets. To use all these layers to write a truly high-performance socket-based application requires a little background information, as Daryn Kiely explains here.

  • Security Briefs: Customizing GINA, Part 2
    Keith Brown - June 2005
    GINA, the Graphical Identification and Authentication component, is a part of WinLogon that you can customize or replace. Last month I introduced GINA customization; this month, I'm going to drill down to implement each of the GINA entry points.

  • { End Bracket }: It's Not Just Fonts
    Bill Hill - June 2005
    Creating a typeface that's truly readable on a screen is much more complex than people realize. The average core font in Windows®, for instance, has about 25,000 lines of executable code as well as the outline and other data.

  • Security Briefs: Customizing GINA, Part 1
    Keith Brown - May 2005
    Over the years I've had many people ask me to write about GINA, the Graphical Identification and Authentication component that serves as the gateway for interactive logons. This month I'll begin my coverage of this topic to help you get started if you're tasked to build such a beast.

  • Escape DLL Hell: Simplify App Deployment with ClickOnce and Registration-Free COM
    Dave Templin - April 2005
    DLL Hell that results from versioning conflicts is generally not a problem in .NET because components do not require registration, and are either totally isolated to an application or are managed in a well-defined side-by-side way with the help of the Global Assembly Cache. But if you're still using COM, wouldn't it be great if you could deploy your existing COM components using a model similar to the .NET Framework? In Windows XP, you can, and this article explains how.

  • Security: Manipulate Privileges in Managed Code Reliably, Securely, and Efficiently
    Mark Novak - March 2005
    When the author was faced with implementing support for changing a security descriptor on an object, he noticed there was not support for that operation in .NET. So he devised two solutions to the problem: the first, simpler one, is tailored to the .NET Framework 1.1 and can be used today. The second solution incorporates several advanced features available only in the .NET Framework 2.0. Both are presented here.

  • Go Global: Make the .NET World a Friendlier Place with the Many Faces of the CultureInfo Class
    Michael Kaplan - March 2005
    CultureInfo is a complex .NET class whose objects are used for resource loading, formatting, parsing, casing, sorting, and other conventions that change as the language, location, or writing system is changed. It can be tricky to use correctly in every situation. Here Michael Kaplan explains some common scenarios in which you will use CultureInfo and provides information about the behavior, best practices, and consequences of a wrong decision.

  • Security Briefs: Access Control List Editing in .NET
    Keith Brown - March 2005
    Access control lists (ACLs) can be complex beasts, and user interfaces for editing them are incredibly tricky to implement properly. That's why I was really excited when Windows® 2000 shipped with a programmable ACL editor, shown in Figure 1.

  • Safety in Windows: Manage Access to Windows Objects with ACLs and the .NET Framework
    Mark Novak - November 2004
    Until now, Microsoft did not provide explicit support in the .NET Framework for manipulating security settings. With the .NET Framework 1.x, access can only be granted to users via a series of cumbersome P/Invoke calls. By introducing the concepts of security objects and rules, the .NET Framework 2.0 allows developers to manipulate security settings of objects in a few easy steps using managed code. Want to know more? Read on.

  • Web Q&A: ANSI Chars in XML, E-commerce Architecture, and More
    Edited by Nancy Michell - February 2004


  • Code Name Longhorn: A First Look at Writing and Deploying Apps in the Next Generation of Windows
    Dino Esposito - January 2004
    The next version of the Microsoft Windows operating system, code-named "Longhorn," marks a significant change not only in terms of how the operating system works, but also in the way in which applications are built. The Longhorn version of Windows includes a new storage system, natural search technology, and an increased emphasis on security and trustworthy computing. Here the author provides an overview of Longhorn, focusing on the build-once, deploy n-times application model. In addition, he discusses the new language, code-named "XAML," that's used to create UI elements, then presents some working samples.

  • Code Name WinFS: Revolutionary File Storage System Lets Users Search and Manage Files Based on Content
    Richard Grimes - January 2004
    One of the monumental problems organizations face today is aggregating information that's stored in disparate formats. Knowledge workers have long wanted to be able to search for content independent of format. The next version of the Windows operating system, code-named "Longhorn," boasts a new storage subsystem that makes that task easier. That subsystem, code-named "WinFS," allows the user to perform searches based on the metadata of the stored item, regardless of what type of file it is or which application created it. This article covers the basic architecture of WinFS and explains how to use the WinFS managed API.

  • Windows Shell: Create Namespace Extensions for Windows Explorer with the .NET Framework
    Dave Rensin - January 2004
    Extending the Windows shell with namespace extensions allows you to create some custom functionality for Windows Explorer. One common use is to enable Explorer to present a list of items that do not exist in one real folder, but actually reside in a number of places. The view on the folder makes it look like these items are in one place, so managing them becomes easier. This article illustrates the process of creating custom shell namespace extensions using C# and the .NET Framework. The author dispels some myths about the difficulty of writing such extensions, and shows that it is easier than it was before .NET. Along the way he outlines undocumented interfaces and describes advanced techniques for consuming them in .NET.

  • Threading: Break Free of Code Deadlocks in Critical Sections Under Windows
    Matt Pietrek and Russ Osterlund - December 2003
    Critical sections, a mechanism that prohibits more than one thread at a time from executing a particular section of code, is a topic that has not received much attention and thus tends not to be well understood. A solid understanding of critical sections in Windows can really come in handy when you need to track down multithreading performance issues in your code. This articles delves under the hood of critical sections to reveal information useful in finding deadlocks and in pinpointing performance problems. It also includes a handy utility program that shows all of your critical sections and their current states.

  • Authorize It: Use Role-Based Security in Your Middle Tier .NET Apps with Authorization Manager
    Keith Brown - November 2003
    Authorization Manager in Windows Server 2003 represents a significant improvement in the administration of role-based security, making it more scalable, flexible, and easier to implement. Using Authorization Manager, you can define roles and the tasks those roles can perform. You can nest roles to inherit characteristics from other roles, and you can define application groups. In addition, Authorization Manager lets you use scripts to modify permissions dynamically, and it allows you to wrap your security logic in a security policy that can be stored in Active Directory. Authorization Manager also includes an easy-to-use API for running access checks. The author discusses all of these topics and demonstrates them with a working sample.

  • Windows Server 2003: Discover Improved System Info, New Kernel, Debugging, Security, and UI APIs
    Matt Pietrek - June 2003
    There's a lot to say about Windows Server 2003. First of all, it's the first operating system with built-in .NET Framework support, and it's the first 64-bit OS from Microsoft. But wait, there's more! There are lots of new features and APIs in this version as well. For instance, Windows Server 2003 features Hot Add Memory and a number of other arcane new tidbits. There are new APIs for handling threads, directories, and files, and new features like the low fragmentation heap for managing memory and system information. There's vectored exception handling and new UI APIs as well.OS internals expert Matt Pietrek takes a look at the additions he finds most interesting and useful so you'll have a good place to start when you dive into Windows Server 2003.

  • Security Briefs: Exploring S4U Kerberos Extensions in Windows Server 2003
    Keith Brown - April 2003
    Building Web sites that provide services external to the corporate firewall is tricky. Usually it's not desirable to grant corporate domain accounts to external clients, and from a purely practical standpoint Kerberos does not work well over the Internet due to the typical configuration of client-side firewalls.

  • Talking To…: Michael Howard Discusses the Secure Windows Initiative
    - March 2003
    The growth of interconnected computers in recent years has pushed security concerns to the forefront of development and application design. The Microsoft effort, dubbed the Secure Windows Initiative (SWI), focuses on securing new and legacy code.

  • Cutting Edge: Windows Hooks in the .NET Framework
    Dino Esposito - October 2002
    If you wanted to, you could distinguish two general categories of classes in the Microsoft® . NET Framework—classes that introduce new functionality such as XML readers and ADO. NET providers, and collections and classes that wrap underlying Win32® system functions.

  • C++ Q&A: Typename, Disabling Keys in Windows XP with TrapKeys
    Paul DiLascia - September 2002


  • Resource File: Skills Development
    - September 2002
    Two Microsoft Web sites have been created to assist developers in writing secure code using the latest technology.

  • Windows XP: Escape from DLL Hell with Custom Debugging and Instrumentation Tools and Utilities, Part 2
    Christophe Nasarre - August 2002
    Building on his article published in the June issue, which demonstrated several ways to get process and DLL-related information from APIs such as PSAPI, NTDLL, and TOOLHELP32, the author presents some unusual ways to get system-oriented info that you can easily integrate in your own toolkit. There are three tools included as samples: LoadLibrarySpy, which monitors an application and detects which DLLs are really loaded; WindowDump, which retrieves the content and a detailed description of any window; and FileUsage, which redirects console-mode applications to tell you which process is using any opened file.

  • Windows CE.NET: New Version Offers Revamped Platform Builder, Improved Tools, Enhanced API, and Source Code
    Paul Yao - July 2002
    Windows CE .NET, the newest member of the .NET family, includes a number of improvements over previous versions of Windows CE. For example, there are quite a few new APIs and enhancements to security and connectivity, the user interface, the kernel, and the emulator. In addition, DirectX support has been added and C++ in Windows CE .NET now supports C++ exceptions, STL, and runtime type information. In this article the author takes a tour of Windows CE .NET, starting with the New Platform Wizard that allows you to code for your choice of devices. A sample application is included that locates features on portable devices so the reader knows what's available before writing code.

  • DirectShow: Core Media Technology in Windows XP Empowers You to Create Custom Audio/Video Processing Components
    Michael Blome and Mike Wasson - July 2002
    DirectShow is an API that enables Windows applications to control a wide variety of audio/video input devices including (but not limited to) DV camcorders, Web cams, DVD drives, and TV tuner cards. It provides out-of-the-box support for a variety of formats, from WAV and AVI to Windows Media. DirectShow is also extensible, enabling third parties to support their own specialized devices, formats, or processing components. This article introduces the basic concepts behind DirectShow and gives a step-by-step tutorial showing how to create your own video effect filter.

  • .NET Zero Deployment: Security and Versioning Models in the Windows Forms Engine Help You Create and Deploy Smart Clients
    Chris Sells - July 2002
    Windows Forms applications solve many of the problems inherent in building Web applications the old fashioned way?with HTML. To demonstrate the use of Windows Forms over the Web, the author takes his existing app, Wahoo!, and ports it to Windows Forms. In doing so, he discusses versioning, linked files, security, storage isolation, the deployment model, and everything else you need to get started building your own Windows Forms apps for the Web.

  • Windows XP: Escape from DLL Hell with Custom Debugging and Instrumentation Tools and Utilities
    Christophe Nasarre - June 2002
    DLL conflict problems can be tough to solve, but a large number of tools are available to help. There are also many Windows APIs that you can use to build custom debugging tools. Three such tools are discussed here and provided as samples. DllSpy lists all the DLLs loaded in the system and the processes that are using them. ProcessSpy enumerates the running processes and exposes the DLLs they are using, and ProcessXP displays the list of concurrent running sessions for Windows XP.

  • Web Q&A: XML Security Questions
    Edited by Nancy Michell - June 2002


  • Security: Unify the Role-Based Security Models for Enterprise and Application Domains with .NET
    Juval Lowy - May 2002
    Role-based security allows administrators to assign access permissions to users based on the roles they play rather than on their individual identities. These privileges can be used to control access to objects and methods, and are easier to identify and maintain than user-based security. The .NET Framework provides two role-based security models, which are exposed as two namespaces: System.Enterprise-Services and System.Security.Permissions. Presented here is a comparison of the two options and a discussion of when each is the right choice. The author also demonstrates the process involved in setting up access security and discusses role memberships.

  • COM+ 1.5: Discover Powerful Low-Level Programming in Windows XP with New COM+ APIs
    Craig Andera and Tim Ewald - April 2002
    The new version of COM+ that ships as part of Windows XP includes APIs for low-level context programming. These functions allow you to create contexts that use COM+ runtime services, independent of objects and without registering anything in the COM+ Catalog. Designed for advanced COM+ developers who understand the COM+ context model, these APIs make it easy to integrate runtime services with code in nonstandard ways. This article explains how these low-level context APIs work, discusses when you'd want to use them, and provides a .NET-based wrapper to make it simpler to use the APIs from C#.

  • Windows CE: Develop Handheld Apps for the .NET Compact Framework with Visual Studio .NET
    Larry Roof - March 2002
    Smart Device Extensions (SDE) for Visual Studio .NET allow programmers to develop applications for the .NET Compact Framework, a new platform that maintains many of the features of the .NET Framework in a version optimized for handheld devices. This article shows how SDE provides access through Visual Studio .NET to a variety of .NET classes for devices running Windows CE, including classes for creating user interfaces. Data access classes and Web Services for the .NET Compact Framework are also explained. Following that overview, a sample Web Service called XMLList is built. Then the UI-the XMLList client-side application-is created.

  • Windows 2000 Loader: What Goes On Inside Windows 2000: Solving the Mysteries of the Loader
    Russ Osterlund - March 2002
    DLLs are a cornerstone of the Windows operating system. Every day they quietly perform their magic, while programmers take them for granted. But for anyone who's ever stopped to think about how the DLLs on their system are loaded by the operating system, the whole process can seem like a great mystery. This article explores DLL loading and exposes what really goes on inside the Windows 2000 loader. Knowing how DLLs are loaded and where, and how the loader keeps track of them really comes in handy when debugging your applications. Here that process is explained in detail.

  • Inside Windows: An In-Depth Look into the Win32 Portable Executable File Format, Part 2
    Matt Pietrek - March 2002
    The Win32 Portable Executable File Format (PE) was designed to be a standard executable format for use on all versions of the operating systems on all supported processors. Since its introduction, the PE format has undergone incremental changes, and the introduction of 64-bit Windows has required a few more. Part 1 of this series presented an overview and covered RVAs, the data directory, and the headers. This month in Part 2 the various sections of the executable are explored. The discussion includes the exports section, export forwarding, binding, and delayloading. The debug directory, thread local storage, and the resources sections are also covered.

  • Inside Windows: An In-Depth Look into the Win32 Portable Executable File Format
    Matt Pietrek - February 2002
    A good understanding of the Portable Executable (PE) file format leads to a good understanding of the operating system. If you know what's in your DLLs and EXEs, you'll be a more knowledgeable programmer. This article, the first of a two-part series, looks at the changes to the PE format that have occurred over the last few years, along with an overview of the format itself. After this update, the author discusses how the PE format fits into applications written for .NET, PE file sections, RVAs, the DataDirectory, and the importing of functions. An appendix includes lists of the relevant image header structures and their descriptions.

  • Windows XP: Kernel Improvements Create a More Robust, Powerful, and Scalable OS
    Mark Russinovich and David Solomon - December 2001
    The Windows XP kernel includes a number of improvements over Windows 2000 that promote better scalability and overall performance. This article covers these changes and explains how they improve startup time, increase registry size limits, and promote more efficient disk partitioning. Windows XP provides support for 64-bit processors, which is covered here along with a discussion of how side-by-side assemblies end DLL Hell. Also new in the Windows XP kernel is a facility that will roll back driver installations to the Last Known Good state of the registry, making driver installation safer. Other topics include the new volume shadow copy facility, which provides for more accurate backups and improvements in remote debugging.

  • Windows Services: New Base Classes in .NET Make Writing a Windows Service Easy
    Ken Getz - December 2001
    Windows services are applications that run outside of any particular user context in Windows NT, Windows 2000, or Windows XP. The creation of services used to require expert coding skills and generally required C or C++. Visual Studio .NET now makes it easy for you to create a Windows service, whether you're writing code in C++, C#, or Visual Basic. You can also write a Windows service in any other language that targets the common language runtime. This article walks you through the creation of a useful Windows service, then demonstrates how to install, test, and debug the service.

  • Pocket PC: MSMQ for Windows CE Brings Advanced Windows Messaging to Embedded Devices
    Bob Hartman - December 2001
    Handheld devices are becoming increasingly important nodes on wireless networks, allowing their users to connect to data stores and other central server applications over the network. But wireless network connections can be unreliable, requiring the use of store-and-forward messaging that does not need to maintain a continuous connection. Microsoft Message Queue (MSMQ) has supplied these features to desktop machines, and there is now a version for handheld devices. MSMQ for Windows CE allows users of embedded devices to perform tasks such as remote order processing and inventory update without worrying about the state of their connection. The benefits of MSMQ for Windows CE and how to install and run the service is covered here.

  • Editor's Note: Windows XP is Here, Again!
    - December 2001


  • Windows XP Overview: Take Advantage of New Windows XP Features in Your Apps Today
    Douglas Boling - November 2001
    Windows XP includes both improvements to the operating system and several new features that enhance the user experience. The most noticeable change in Windows XP is the user interface, which includes a revised Start menu and updated Task Bar. The new look is possible because Windows XP can be skinned, which lets the interface be changed dramatically with a new facility called themes. Windows XP also introduces fast user switching, which allows multiple users to be logged onto their own sessions at the same time on the same machine and, as the name implies, they can switch back and forth quickly. Another new feature, ClearType, is discussed here as well.

  • New Graphical Interface: Enhance Your Programs with New Windows XP Shell Features
    Dino Esposito - November 2001
    The Windows XP shell introduces many new features that both users and developers are sure to welcome. The interface supports a number of styles that will be new to users, and it also supports customization of those styles through a new concept called themes. There are more shell registry settings available to the user and developer, a facility for customizing infotips, and infotip shell extensions. In addition, folder views can be customized. This article covers these shell changes and includes a discussion of a number of other Windows XP additions. These include fast user switching, which lets users log on and off quickly, and AutoPlay support for a variety of devices and file types not previously supported.

  • Beyond Windows XP: Get Ready Now for the Upcoming 64-Bit Version of Windows
    Stan Murawski - November 2001
    In this article the author modifies an industry standard middle-tier application server benchmark called Nile. The goal was to get it to build and run correctly on the 64-bit edition of the Microsoft .NET Advanced Server running on computers with Intel Itanium processors and still build as a 32-bit version to run on Pentium class x86 processors. While modifying Nile, the author discovered some of the tips he presents here. As the article explains, when modifying code for 64-bit Windows, data types are the key to success. The article discusses which types to use and when, along with new data types and the importance of memory alignment.

  • Autoplay in Windows XP: Automatically Detect and React to New Devices on a System
    Stephane St-Michel and Brian Aust - November 2001
    The last few years have seen dramatic growth in digital multimedia content and an increasing number of devices generating such content. Accordingly, the Autoplay feature of Microsoft Windows has been enhanced to handle these scenarios. This article presents samples that use the new features and provides advice on how to take advantage of these additions. The topics covered include Autoplay support for audio CDs and for DVD movies, the Autoplay registration process, event handlers, and how your software can cancel Autoplay when you don't want certain files interrupted. The download includes tools for diagnosing problems and to help the reader understand the shell hardware detection service processing of hardware events.

  • MSLU: Develop Unicode Applications for Windows 9x Platforms with the Microsoft Layer for Unicode
    Michael Kaplan and Cathy Wissink - October 2001
    The Microsoft Layer for Unicode (MSLU) provides Unicode support on Windows platforms that don't provide their own support, including Windows 98, Windows 95, and Windows Me. With MSLU you can write Unicode applications easily for these platforms. MSLU is simple to install, small (even though it wraps more than 400 APIs), and easy on system resources. This article explains the design criteria behind MSLU and how to put the layer to work for you.

  • Win32 Resources: Using C++ to Programmatically Retrieve a Global Cursor's Shape and ID
    Dmitri Klementiev - October 2001
    Getting global cursor information is useful when developing software that drives or gathers information about other UI-based applications, including information about a remote machine. This article describes a way to programmatically identify the current cursor's ID and bitmap at any point in time. The first technique described is based on polling for information and shows how to get the handle of the current global cursor. This handle will then allow you to get information about the cursor. You can also monitor WinEvents for changes to the global cursor.

  • Fax Services: Send Any Printable File From Your Program in Windows 2000
    Marcin Kaluza - August 2001
    All versions of Windows 2000 have fax services built in, so sending faxes manually is as easy as setting fax options from the control panel. Faxes can also be sent programmatically in Windows 2000 using either COM Automation or the standard C API. The example in this article uses COM Automation with Visual Basic and MFC to programmatically manage faxing. The objects used for fax transmission, such as the FaxServer and FaxDoc objects, as well as their properties and methods, are explained. Because faxing of files you can't print can be problematic, this process is explained. Finally, this article implements a fax routing extension-a plug-in that exports standard functions and implements routing methods for processing received faxes.

  • Multiprocessor Optimizations: Fine-Tuning Concurrent Access to Large Data Collections
    Ian Emmons - August 2001
    Application performance involves more than just speed. In a Web server environment, top performance also means ensuring that the maximum numbers of users can be served concurrently. This can be accomplished through efficient use of multiprocessor machines and thread management. This article presents techniques that can solve a number of concurrency problems. One approach, using thread management, controls access to a database on a per-thread basis, which protects the integrity of the data. In the article, reusable thread classes are built and presented. The classes are then tested and their performance in a live environment is examined.

  • Windows UI: Our WinMgr Sample Makes Custom Window Sizing Simple
    Paul DiLascia - July 2001
    Programmers using Visual Basic have always had an advantage over C++ programmers when it comes to component and window sizing. There are many third-party Visual Basic-based solutions to this age-old problem, but unfortunately, there are few elegant alternatives for the C++ crowd, short of using a full-fledged windowing toolkit. This article explains how to circumvent the tedious task of hardcoded pixel arithmetic. It starts by introducing a window sizing rules system, and then moves on to show how CWinMgr, a data-driven class, can intelligently manage an MFC application's window sizing.

  • C++ Q&A: Initializing Class Objects, The TestAD App and Active Desktop, #include Problems
    Paul DiLascia - May 2001


  • C++ Attributes: Make COM Programming a Breeze with New Feature in Visual Studio .NET
    Richard Grimes - April 2001
    C++ attributes in Visual Studio .NET are used to generate C++ code through attribute providers. Attribute providers generate code for COM classes, and the code is injected by the C++ compiler at compile time. This has the effect of reducing the amount of code that you need to write. In addition, with C++ attributes you no longer need to maintain separate IDL and RGS files, which makes project management simpler. This article explains C++ attributes, the process used by the attribute provider to generate code, and the code that is automatically generated. It also covers how attributes affect the registration process, how attributes can be used to generate code module entry points, and how connection points can be implemented using C++ attributes. Also explained is how these features contribute to the Unified Event Model for the .NET platform.

  • Winsock 2: QoS API Fine-Tunes Networked App Throughput and Reliability
    Wei Hua - April 2001
    The Generic Quality of Service (GQoS) API is a subset of the Winsock 2 API that allows a Winsock application to inform the network of its traffic requirements, enabling entitled applications to receive preferential treatment for their traffic. Existing Winsock applications can be GQoS-enabled by adding or modifying Winsock calls at appropriate places. An application's sending and receiving traffic needs can also be defined by specifying parameters within the QualityOfService (QOS) structure. This article discusses how traffic information is conveyed throughout the network, what kind of QOS structure should be used in your app, and how to set up network configurations for testing GQoS applications.

  • Windows Script Host: New Code-Signing Features Protect Against Malicious Scripts
    Eric Lippert - April 2001
    Downloading scripts from the Web or e-mail leaves users vulnerable to security risks because scripts can't be signed. But now developers can use Windows Script Host (WSH) to hash scripts so users can verify their source and safety. With WSH, scripts can be signed or verified using all the same tools ordinarily used to sign EXE, CAB, DLL, and OCX files. This article discusses public-key cryptosystems, the process of signing and verifying scripts in WSH, and several warnings about attacks that could potentially be made against cryptographically secured scripts and ways in which to avoid them.

  • Security Briefs: The Security Support Provider Interface Revisited
    Keith Brown - April 2001


  • C++ Q&A: Why = Returns a Reference, Accessing the Recycle Bin, When to Use STL
    Paul DiLascia - April 2001


  • Whistler: Build More Flexible Console Snap-ins with the MMC 2.0 Object Model
    Vivek Jhaveri - March 2001
    Microsoft Management Console (MMC) 2.0 provides a host of exciting new features for MMC users and snap-in developers. The new MMC 2.0 automation object model allows much of the user interface of MMC 2.0 to be accessed through script, and exposes events so that many tasks can now easily be automated. The new view extension model uses HTML to enable extensions to seamlessly integrate new user interfaces with those of existing snap-ins. MMC 2.0 also includes a specific view extension snap-in, the Extended View snap-in, which provides an interface similar to Web folders. Drag and drop support has been expanded, and console files now use the XML file format. Enhancements to console taskpads make it easier to accomplish tasks.

  • Resource Leaks: Detecting, Locating, and Repairing Your Leaky GDI Code
    Christophe Nasarre - March 2001
    Leaks are possible, even in robust Windows-based applications. As bugs go, leaks are some of the most difficult to find, especially when they occur in graphics device interface (GDI) objects and menus. While free and third-party tools exist to detect such leaks, it is usually difficult to make the connection between the numeric handle value returned by the tool, and a bitmap or menu in your program. This can limit the usefulness of these tools. Custom tools can be built that detect, track down, and eradicate GDI and menu leaks. Here, three such tools are built using well-known and documented APIs.

  • Windows CE: eMbedded Visual Tools 3.0 Provide a Flexible and Robust Development Environment
    Paul Yao - January 2001
    This article provides an overview of writing applications for Windows CE 3.0. Unicode support in Windows CE, the kernel, memory management, the object store, and COM and DCOM are discussed. The article also covers the user interface, graphics, the Internet, and how Windows CE compares to the desktop in each of these areas. eMbedded Visual Tools 3.0 is discussed in depth. To help the reader decide which tools to use, development with Visual Basic, Win32, MFC, and ATL are explained. Text editor samples with this article have been developed with Visual Basic and Win32 so their implementations can be compared.

  • C++ Q&A: Browser Detection in the Registry, Changing Cursors in Windows, Avoiding Resource ID Collision
    Paul DiLascia - January 2001


  • COM+ and Windows 2000: Ten Tips and Tricks for Maximizing COM+ Performance
    David S. Platt - December 2000
    There are many tricks to getting the most out of COM+, and this article offers the author's top 10. The tips cover the importance of transaction processing, the use of the COM+ catalog, and the design of three-tier distributed systems. Writing components using the correct threading model, knowing when to use compensating transactions, and the importance of stress testing early in the process also make the list. Other indespensible suggestions emphasize the importance of recognizing where an object's state is located, choosing appropriate authentication levels for COM+ applications, using Queued Components correctly, and implementing object pooling.

  • C++ Q&A: Sending Messages in Windows, Adding Hot Keys to your Application
    Paul DiLascia - December 2000


  • Windows 2000 Registry: Latest Features and APIs Provide the Power to Customize and Extend Your Apps
    Dino Esposito - November 2000
    The Windows registry as it is recognized today first appeared in Windows 95. Its introduction simplified the storage of initialization information and made that data more secure. This article covers the history of the registry, the form it took in the early days, and its current incarnation in Windows 2000. Practical tips for managing data in the registry are outlined, along with descriptions of special keys, functions, and file types. Manipulation of the registry to customize both application behavior and certain features in Windows is discussed. Also covered are future directions of the registry, including the use of XML to store registry information in a hierarchical fashion.

  • Avoiding DLL Hell: Introducing Application Metadata in the Microsoft .NET Framework
    Matt Pietrek - October 2000
    The Microsoft .NET platform uses metadata and assemblies to store information about components, enabling cross-language programming and resolving the infamous DLL Hell problem. This article describes the use of metadata for easy linking and loading of assemblies, the relationship between metadata and concepts such as IDL and type libraries, and the metadata hierarchy. The process of reading metadata from assemblies for easy versioning is also described. Although Microsoft provides the MSIL disassembler, IDLASM, and MetaInfo.exe for accessing metadata, the author provides two sample programs that read metadata using the unmanaged metadata interfaces and the Reflection API.

  • Windows Sockets 2.0: Write Scalable Winsock Apps Using Completion Ports
    Anthony Jones and Amol Deshpande - October 2000
    Writing a network-aware application isn't difficult, but writing one that is scalable can be challenging. Overlapped I/O using completion ports provides true scalability on Windows NT and Windows 2000. Completion ports and Windows Sockets 2.0 can be used to design applications that will scale to thousands of connections. The article begins with a discussion of the implementation of a scalable server, discusses handling low-resource, high-demand conditions, and addresses the most common problems with scalability.

  • Marshalling Your Data: Efficient Data Transfer Techniques Using COM and Windows 2000
    Richard Grimes - September 2000
    The way you choose to transfer data is vitally important in a distributed application. Windows 2000 provides several new features that allow you to transfer data more efficiently. Lightweight handlers allow you to write smart proxies that can cache results and perform buffered reads and writes, minimizing the number of network calls. Windows 2000 also allows you to use pipe interfaces to transfer large amounts of data efficiently through a read-ahead facility. This article illustrates several ways to improve data transfer in Windows 2000 using these new features. It also reports the results of transfer time tests and provides recommendations for transferred buffer sizes.

  • Shelley Powers: Migrating Your ASP Apps from Windows NT 4.0 to Windows 2000
    Shelley Powers - August 2000
    In order to take advantage of new features in Windows 2000 and IIS 5.0, you must first migrate your Windows NT 4.0-based ASP applications to Windows 2000. This article provides a multi-step migration plan. It discusses how to install and configure IIS 5.0, set up security, migrate MTS packages to COM+ applications, and handle differences in the ASP object models. Also included are guidelines for setting up Visual Basic and Visual C++ for development in Windows 2000 and information on what to expect when moving ASP components to the new OS.

  • Security Briefs: Explore the Security Support Provider Interface Using the SSPI Workbench Utility
    Keith Brown - August 2000


  • Wicked Code: Implementing Handler Marshaling Under Windows 2000: DeviceClient Sample App
    Jeff Prosise - August 2000


  • More Windows 2000 UI Goodies: Extending Explorer Views by Customizing Hypertext Template Files
    Dino Esposito - June 2000
    The Web-style interface is the default Explorer folder view for the Desktop Update in Windows 2000. The Desktop Update uses HTML-based hypertext templates to create the Web view, and you can customize these templates to include your own views and commands. This article shows you how the Explorer Web view works and how to build your own custom templates for it. You'll see how to add a command prompt and task buttons to a new folder view using HTML, script, and ActiveX controls. The shell object model and thumbnail shell extensions are also examined, then used to build a simple icon viewer for Explorer.

  • Windows CE Web Server: Using Web Tools to Monitor and Manage Embedded Devices
    Leonid Braginski and Matthew Powell - May 2000
    When it ships, Windows CE 3.0 is expected to include Web services via the Windows CE Web Server. This new component of the Windows CE operating system will allow developers to share data or monitor and manage devices that are running Windows CE-whether they are handheld PCs or embedded in devices such as gas pumps or refrigerators. This article explains how the Windows CE Web Server component can be included in the operating system for a given device. We'll also show you how the Web server features you're familiar with from Microsoft Internet Information Services are implemented in the Windows CE Web Server.

  • Windows Management Instrumentation: Administering Windows and Applications across Your Enterprise
    Jeffrey Cooperstein - May 2000
    This article provides an overview of Windows Management Instrumentation, a technology that exposes a wide variety of system and device information through a standard API. With WMI, management information is exposed by following the object oriented structure outlined in the Common Information Model (CIM), which relies on inheritance for reuse and standardization of object classes that represent system devices. This article briefly describes querying WMI for information using a query language much like SQL called Windows Management Instrumentation Query Language (WQL), existing system classes, handling system events, and security in WMI.

  • Security Briefs: Understanding Kerberos Credential Delegation in Windows 2000 Using the TktView Utillity
    Keith Brown - May 2000


  • Windows 2000: Asynchronous Method Calls Eliminate the Wait for COM Clients and Servers
    Jeff Prosise - April 2000
    Windows 2000 is the first version of COM to support asynchronous method calls, which permit clients to make nonblocking calls to COM objects and objects to process incoming calls without blocking the calling threads. COM clients benefit from asynchronous method calls because they can continue working while waiting for outbound calls to return. Objects benefit because they can queue incoming calls and service them from a thread pool. Our SieveClient and SieveServer sample apps demonstrate how to create and use asynchronous clients and servers in COM-based distributed applications.

  • Scripting Windows: Windows Management Instrumentation Provides a Powerful Tool for Managing Windows with Script
    Alan Boshier - April 2000
    The new Windows Management Instrumentation (WMI) technology for Windows 2000, Windows NT 4.0, and Windows 98 provides powerful scripting technology that can be used to administrate Windows-based systems. With WMI, you can create scripts to simplify management of devices, user accounts, services, networking, and other aspects of your system. This piece will introduce you to WMI and the WMI Scripting Object Model, taking a look at the available objects, methods, and properties. Along the way, you'll see how these elements can be used to create system management scripts.

  • Bugslayer: Windows 2000 and LDR Messages, A COM Symbol Engine, Finding Bloated Functions, and More
    John Robbins - April 2000


  • Windows 2000 UI Innovations: Enhance Your User's Experience with New Infotip and Icon Overlay Shell
    Dino Esposito - March 2000
    Windows 2000 includes some helpful new UI features you can customize and implement in your own applications. In this article you'll see how to provide infotips for files, after making the appropriate registry entries. Then create a custom column handler extension, resulting in a new column for the Explorer's Details view. In order to further extend the shell, additional UI goodies will also be examined and implemented including: search handlers, cleanup handlers, folder customizations using property sheet handlers and icon overlays, and context menu shell extensions. All the code samples are rolled up into a handy package which we've named, by tradition, ShellToys.

  • House of COM: Performance Trade-offs of the Windows 2000 Component Execution Environment
    Don Box - March 2000


  • Security Briefs: Exploring Handle Security in Windows
    Keith Brown - March 2000


Page view tracker