MSDN Magazine: C# rss

All MSDN Magazine Topics
  • CLR Inside Out: Code Contracts
    Melitta Andersen - August 2009
    This article will share some of the best practices that the Base Class Libraries (BCL) team devised as they added the code contract libraries and started to take advantage of them in their own code.

  • CLR Inside Out: Building Tuple
    Matt Ellis - July 2009
    In this column, the author lays out some guiding principles that you should follow when working with the ASP.NET MVC framework.

  • CLR Inside Out: Memory Usage Auditing For .NET Applications
    Subramanian Ramaswamy and Vance Morrison - June 2009
    Memory usage can have a direct impact on how fast an application executes and thus is important to optimize. In this article we discuss the basics of memory optimization for .NET programs.

  • Concurrent Affairs: More AsyncEnumerator Features
    Jeffrey Richter - August 2008
    Jeffrey Richter shows you some additional cool features of his AsyncEnumerator class.

  • .NET Matters: Asynchronous I/O with WebClient
    Stephen Toub - July 2008
    In this month’s installment of .NET Matters, columnist Stephen Toub answers reader questions concerning asynchronous I/O .

  • Robotics: Simulating the World with Microsoft Robotics Studio
    Sara Morgan - June 2008
    Microsoft Robotics Studio is not just for playing with robots. It also allows you to build service-based applications for a wide range of hardware devices.

  • Patterns in Practice: The Open Closed Principle
    Jeremy Miller - June 2008
    Extending an existing codebase can be as productive and frustration-free as writing all new code when you employ the Open Closed Principle. We'll show you how.

  • Service Station: Building a WCF Router, Part 2.
    Michele Leroux Bustamante - June 2008
    Here we present a deep look into the workings of Windows Communication Foundation routers, exploring the details of pass-through router implementations.

  • Foundations: Bitmaps and Pixel Bits
    Charles Petzold - June 2008
    Charles Petzold takes an inside look at the flexible bitmap pixel formats offered by the retained-mode graphics features of Windows Presentation Foundation.

  • Concurrent Affairs: Simplified APM with the AsyncEnumerator
    Jeffrey Richter - June 2008
    Here Jeffrey Richter introduces his AsyncEnumerator class, which drives an iterator so that different thread pool threads can execute the same code at different times.

  • Alphabet Soup: A Survey of .NET Languages And Paradigms
    Joel Pobar - May 2008
    Here we present a rundown of the various language paradigms of CLR-based languages via short language introductions and code samples.

  • Office Space: From VBA Macro to Word Add-in
    Robert Bogue - May 2008
    See how to use Word to capture a VBA macro and use Visual Studio Tools for Office to wrap it up into a deployable Word add-in.

  • Toolbox: Logging Web App Errors, Learning LINQ, and More
    Scott Mitchell - April 2008
    See how to log Web application errors for better health monitoring, what to read if you’re thinking about LINQ, and which blog Scott recommends reading this month.

  • CLR Inside Out: Measure Early and Often for Performance, Part 1
    Vance Morrison - April 2008
    In this month’s column, get the inside scoop on how to build performance into your apps from the start, rather than dealing with the fallout after you deploy them.

  • Service Station: Building a WCF Router, Part 1
    Michele Leroux Bustamante - April 2008
    Here we take a look at WCF clients and services, and explain how to tweak the addressing and message filtering behaviors so you can route services between them.

  • Going Places: Provisioning Mobile Devices
    Mike Calligaro - April 2008
    Learn how you can set up every mobile device in your company with a few lines of code and some XML--thanks to the provisioning APIs in the Windows Mobile SDK.

  • ASP.NET MVC: Building Web Apps without Web Forms
    Chris Tavares - March 2008
    Chris Tavares explains how the ASP.NET MVC Framework's Model View Controller pattern helps you build flexible, easily tested Web applications.

  • Loosen Up: Tame Your Software Dependencies for More Flexible Apps
    James Kovacs - March 2008
    James Kovacs explains the dark side of tightly coupled architectures, why they're hard to test and how they limit adaptation. He then proposes a number of solutions.

  • CLR Inside Out: Improving Application Startup Performance
    Claudio Caldato - March 2008
    Application startup performance matters to users, and there's plenty you can do to improve it. Here's a look at where to begin.

  • Data Points: Standard Query Operators with LINQ
    John Papa - March 2008
    LINQ to Objects and LINQ to Entities have an arsenal of Standard Query Operators that operate on sequences to perform a wide variety of operations.

  • 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.

  • .NET Matters: Asynchronous Stream Processing
    Stephen Toub - March 2008
    This month Stephen Toub discusses asynchronous stream processing.

  • Roll Your Own: Create a Language Compiler for the .NET Framework
    Joel Pobar - February 2008
    Joel Pobar presents an introduction to how compilers work and how you can write your own compiler to target the .NET Framework.

  • Silverlight: Create a Custom Expression Encoder Publishing Plug-In
    Laurence Moroney - February 2008
    Laurence Moroney demonstrates how to employ the Expression Encoder plug-in APIs by building and debugging a simple FTP upload plug-in.

  • PIAB And WCF: Integrating the Policy Injection Application Block with WCF Services
    Hugh Ang and David San Filippo - February 2008
    Using the PIAB you can enhance WCF services with policies such as validation, performance monitoring, authorization and caching without having to change a line of code.

  • WF How-To: Building State Machines with Windows Workflow Foundation
    Keith Pijanowski - February 2008
    State Machine workflows represent a different way of visualizing program logic. Rather than flowing from activity to activity like sequential workflows, State Machines transition from state to state. Learn about uses for State machines and see how to design and build a State Machine workflow with Windows Workflow Foundation.

  • Toolbox: Powerful Text Editing, Web Testing in .NET, Extended Unit Testing, and More
    James Avery - February 2008
    Powerful Text Editing, Web Testing in .NET, Extended Unit Testing, and More

  • CLR Inside Out: Dynamic Languages and Silverlight
    Jimmy Schementi - February 2008
    DLRConsole gives you an interactive environment for playing with dynamic languages in Silverlight.

  • Data Points: Designing an Entity Data Model
    John Papa - February 2008
    With the Entity Framework, developers are given more flexibility by being able to design around a conceptual model rather than a relational data model. To get started, you need to know how to design an Entity Data Model. John Papa walks you through that process.

  • Cutting Edge: Customize Controls with AJAX Extenders, Part 2
    Dino Esposito - February 2008
    This month Dino looks at AJAX control extenders again, adding more advanced features including masked editing and autocompletion.

  • Office Space: Security Programming in SharePoint 2007
    Ted Pattison - February 2008
    This month Ted Pattison presents an overview of programming security and permissions for Windows SharePoint Services 3.0.

  • Test Run: The Microsoft UI Automation Library
    Dr. James McCaffrey - February 2008
    James McCaffrey shows you how to get started with UI test automation using the new Microsoft UI Automation library.

  • Foundations: What's New for WCF in Visual Studio 2008
    Juval Lowy - February 2008
    Visual Studio 2008 and the .NET Framework 3.5 provide new tools and support that extends Windows Communication Foundation (WCF). Visual Studio 2008 also automates a number of manual WCF tasks for the developer as well.

  • .NET Matters: Stream Pipeline
    Stephen Toub - February 2008
    This month Stephen Toub explains how to make the most of dual processors when running encryption and compression tasks.

  • IIS 7.0: Enhance Your Apps with the Integrated ASP.NET Pipeline
    Mike Volodarsky - January 2008
    Mike Volodarsky demonstrates how IIS 7.0 lets you add performance and security upgrades to PHP apps without touching a line of PHP code.

  • WCF Syndication: HTTP Programming with WCF and the .NET Framework 3.5
    Justin Smith - January 2008
    Introducing Web-centric features of Windows Communication Foundation in the .NET Framework 3.5, including the HTTP programming model and the new syndication API.

  • Look it Up: Managing Directory Security Principals in the .NET Framework 3.5
    Joe Kaplan and Ethan Wilansky - January 2008
    Here's an overview of the new System.DirectoryServices.AccountManagement class in the .NET Framework 3.5 and how it simplifies working with directory services.

  • Toolbox: Advanced Unit Testing, Object Mocking, Profiling Your Apps and More
    James Avery - January 2008
    This month we look at advanced unit testing, object mocking, profiling, and lots more.

  • CLR Inside Out: Marshaling between Managed and Unmanaged Code
    Yi Zhang and Xiaoying Guo - January 2008
    Marshaling is an important part of .NET interop. It allows you to call into unmanaged code from managed code. This column will help you get started.

  • Data Points: Accessing Data from a Mobile Application
    John Papa - January 2008
    This month John Papa takes a look at developing a mobile application that can access data on your application server.

  • Extreme ASP.NET: Encapsulate Silverlight with ASP.NET Controls
    Fritz Onion - January 2008
    To implement Silverlight in ASP.NET pages, you can encapsulate your Silverlight elements in ASP.NET controls. Here's how.

  • Toolbox: Live Chat, Code Conversion, Multiple Monitors, and More
    Scott Mitchell - December 2007
    This month, more of the tools you need to get your job done.

  • Concurrent Affairs: Simplified APM with C#
    Jeffrey Richter - November 2007
    Jeffrey Richter introduces his AsyncEnumerator class and explains how it harnesses some recent additions to the C# programming language that make working with the asynchronous programming model significantly easier.

  • WPF: Flexible Content Display With Flow Documents
    Markus Egger - August 2007
    Markus Egger discusses all the flexibility and power of flow documents in Windows Presentation Foundation

  • OPC: A New Standard For Packaging Your Data
    Jack Davis and Andrey Shur - August 2007
    Open Packaging Conventions (OPC) defines a structured means for storing application data together with related resources. Learn about the benefits here.

  • Excel Services: Develop A Calculation Engine For Your Apps
    Vishwas Lele and Pyush Kumar - August 2007
    The Excel Services architecture lets users design their own algorithms and share workbooks on a server.

  • CLR Inside Out: Collections Best Practices
    Inbar Gazit - August 2007
    This month Inbar Gazit shows readers how to get the most out of the System.Collections namespace.

  • Cutting Edge: Canceling Server Tasks with ASP.NET AJAX
    Dino Esposito - August 2007
    This month Dino explains how to remotely cancel tasks running on the server using ASP.NET AJAX.

  • Extreme ASP.NET: Web Client Software Factory
    Fritz Onion - August 2007
    The Web Service Software Factory is designed to provide guidance and enhanced tools for building Web services using ASMX or WCF.

  • Foundations: Declarative WCF Security
    Juval Lowy - August 2007
    Juval Lowy designs easily configured security settings for applications built on Windows Communication Foundation.

  • Mobility: Make Your WPF Apps Power-Aware
    Andre Michaud - July 2007
    Here Andre Michaud shows you how to use power notifications to make your applications power aware.

  • Share Code: Write Code Once For Both Mobile And Desktop Apps
    Daniel Moth - July 2007
    If you're building .NET client apps already, target them to Windows Mobile using the same skills and toolsets.

  • 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.

  • CLR Inside Out: Digging into IDisposable
    Shawn Farkas - July 2007
    This month: cleaning up resources that are not garbage collected by the CLR garbage collector.

  • Data Points: ADO.NET Entity Framework Overview
    John Papa - July 2007
    The new Entity Framework in ADO.NET will let you manipulate data using an object model. John Papa explains.

  • Cutting Edge: Context-Sensitive Feedback with AJAX
    Dino Esposito - July 2007
    Beyond progress bars: talking to server-side apps with ASP.NET AJAX.

  • Service Station: WCF Bindings In Depth
    Aaron Skonnard - July 2007
    The WCF programming model makes it easy to configure services with a variety of wire formats and message protocols, thanks to binding.

  • Bugslayer: Wait Chain Traversal
    John Robbins - July 2007
    Windows Vista has a new API called Wait Chain Traversal (WCT), which allows you to determine when and why a process is deadlocked. Read on.

  • Security Briefs: Active Directory Cache Dependencies
    Keith Brown - July 2007
    If you're not taking advantage of Active Directory, you should be. Learn the benefits from Keith Brown.

  • Foundations: Extending the WPF Animation Classes
    Charles Petzold - July 2007
    Learn what the WPF Animation Classes can do, what they can't, and how to extend them.

  • C# 3.0: The Evolution Of LINQ And Its Impact On The Design Of C#
    Anson Horton - June 2007
    LINQ gives allows developers to take advantage of the power of queries. Find out how it came to be.

  • OFFICE UI: New VSTO Features Help You Customize Word And Outlook
    Steve Fox and Paul Stubbs - June 2007
    See how to use Microsoft Visual Studio Tools for the Microsoft Office System to build powerful custom applications against the 2007 Microsoft Office system.

  • CLR Inside Out: Reflections on Reflection
    Mike Repass - June 2007
    This month's installment of CLR Inside Out takes on reflection and the System.Reflection namespace.

  • Data Points: SQL Server Management Objects
    John Papa - June 2007
    SQL Server Management Objects offer developers a robust toolset for backing up and restoring databases, and issuing DDL commands, as John Papa explains.

  • Cutting Edge: Transactional Workflows
    Dino Esposito - June 2007
    When modeling business logic, workflows inevitably represent transactional tasks, so you need to know how to code transactional semantics in the Windows Workflow Foundation.

  • Service Station: WCF Addressing In Depth
    Aaron Skonnard - June 2007
    This month Aaron Skonnard looks at addressing details surrounding endpoint communication, many of which enable more advanced messaging scenarios.

  • Wicked Code: UpdatePanel Tips and Tricks
    Jeff Prosise - June 2007
    Jeff Prosise explains when it's better to use UpdatePanel and when it's better to use asynchronous calls to WebMethods or page methods instead.

  • Foundations: ActivityExecutionContext in Workflows
    Matt Milner - June 2007
    This month Matt Milner explains a critical component in the execution, persistence, and compensation of workflows.

  • 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.

  • .NET Matters: Handling Messages in Console Apps
    Stephen Toub - June 2007
    Many developers who use the Microsoft .NET Framework think that application type is tied to the libraries that can be used in that application. Stephen Toub clarifies.

  • Got Game?: Unleash Your Imagination With XNA Game Studio Express
    Charles Cox and Michael Klucher - May 2007

  • WPF: Customizing Controls For Windows Presentation Foundation
    Shawn Wildermuth - May 2007

  • Migration: Convert A Java Web Application To ASP.NET Using JLCA
    Brian Jimerson - May 2007

  • Collaborate: Help Teams Work Together With Web Services And Groove 2007
    John C. Hancock - May 2007

  • CLR Inside Out: 9 Reusable Parallel Data Structures and Algorithms
    Joe Duffy - May 2007

  • Test Run: Lightweight Testing with Windows PowerShell
    Dr. James McCaffrey - May 2007

  • Foundations: WCF Transaction Propagation
    Juval Lowy - May 2007

  • Identity: Secure Your ASP.NET Apps And WCF Services With Windows CardSpace
    Michèle Leroux Bustamante - April 2007
    Windows CardSpace replaces traditional authentication with a more consistent and streamlined login process and improves trust between end-users, applications and services. Michèle Leroux Bustamante explains.

  • Aero Glass: Create Special Effects With The Desktop Window Manager
    Ron Fosner - April 2007
    In this article we introduce the Desktop Window Manager, the new interface that manages how windows are rendered on the Windows Vista desktop.

  • 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.

  • CLR Inside Out: New Library Classes in "Orcas"
    Mike Downen, Inbar Gazit, and Justin Van Patten - April 2007
    The next version of Visual Studio currently code-named “Orcas”supports advanced encryption algorithms, Elliptic curve cryptography, big integers, and other security enhancements. The CLR team explains.

  • 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.

  • Extreme ASP.NET: Web Deployment Projects
    Fritz Onion - April 2007
    ASP.NET 2.0 development is the easiest ASP development yet. Fritz Onion reveals why.

  • .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

  • Digital Media: Add Video To Controls And 3D Surfaces With WPF
    Lee Brimelow - March 2007

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

  • ASP.NET 2.0: Manage Web Users With Custom Profile Providers
    Jason N. Gaylord - March 2007

  • CLR Inside Out: .NET Application Extensibility, Part 2
    Jack Gudenkauf and Jesse Kaplan - March 2007

  • Test Run: Testing Custom Transform Streams
    Dr. James McCaffrey - March 2007

  • Wicked Code: Scalable Apps with Asynchronous Programming in ASP.NET
    Jeff Prosise - March 2007

  • Bugslayer: GUI Control to Major Tom
    John Robbins - March 2007

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

  • Concurrent Affairs: Implementing the CLR Asynchronous Programming Model
    Jeffrey Richter - March 2007

  • SQL Server 2005: Regular Expressions Make Pattern Matching And Data Extraction Easier
    David Banister - February 2007
    Now you can perform efficient, sophisticated text analysis using regular expressions in SQL Server 2005.

  • CLR Inside Out: .NET Application Extensibility
    Jack Gudenkauf and Jesse Kaplan - February 2007
    This month the CLR team introduces the new System.AddIn namespace in the Base Class Library, which will be available in the next release of Visual Studio.

  • Data Points: Data Bound Applications with ADO.NET and Custom Objects
    John Papa - February 2007
    In this column see how to bind a custom list of business entities using the binding tools in the .NET Framework 2.0.

  • Service Station: The Service Factory for WCF
    Aaron Skonnard - February 2007
    This month Aaron Skonnard continues his exploration of software factories with a look at the Web Service Software Factory for Windows Communication Foundation.

  • 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.

  • Debug Leaky Apps: Identify And Prevent Memory Leaks In Managed Code
    James Kovacs - January 2007
    When is the .NET Garbage Collector unable to reclaim memory? The answer might surprise you. Stay tuned.

  • CLR Inside Out: Introduction to COM Interop
    Thottam R. Sriram - January 2007
    The CLR allows seamless interactions between Microsoft .NET applications and COM. But how, exactly? The CLR team knows.

  • Data Points: Column Expressions, DataRelations, and Computations
    John Papa - January 2007
    This month John Papa fields some of his favorite questions regarding data manipulation with ADO.NET.

  • Security Briefs: Using Protocol Transition—Tips from the Trenches
    Keith Brown - January 2007
    Now that Windows Server 2003 is widely deployed, Keith Brown addresses questions from readers who are trying to use protocol transition to build secure gateways into their intranets.

  • Graphics To Go: Make A Mobile Imaging App With The .NET Compact Framework 2.0
    Rob Pierry - December 2006
    This article focuses on developing for Pocket PCs, a skill which can then be transferred to Smartphone application development.

  • Windows Workflow: Build Custom Activities To Extend The Reach Of Your Workflows
    Matt Milner - December 2006
    This article covers the core components required for building custom activities in Windows Workflow Foundation.

  • Extend ASP.NET: Simplify Data Binding In ASP.NET 2.0 With Our Custom Control
    Rick Strahl - December 2006
    The wwDataBinder control addresses simple control data binding--binding simple form controls like textboxes, checkboxes, and the selected values of list controls to individual data or object values.

  • BizTalk Adapters: Integrate E-Mail Processing Into Your Business Solutions
    Alex Starykh - December 2006
    Use BizTalk Server to monitor e-mail for new messages, trigger confirmations, and persist e-mail and attachments to a custom database.

  • Data Points: RSS Feeds on a Smartphone
    John Papa - December 2006
    John Papa builds a Windows Mobile 5.0 application that reads RSS feeds and loads them into an ADO.NET DataSet.

  • Cutting Edge: The Client Side of ASP.NET Pages
    Dino Esposito - December 2006
    This month Dino Esposito dissects the client-side source code generated by ASP.NET pages.

  • Test Run: String Permutations
    Dr. James McCaffrey - December 2006
    The ability to programmatically create and use string permutations is essential in software testing, as James McCaffrey explains.

  • .NET Matters: Deserialization Progress, and More
    Stephen Toub - December 2006
    Build a standard progress bar that indicates how much deserialization has completed and how much still remains. Plus, System.Collection.Generics performance.

  • 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.

  • Test Run: Using Excel For Test Data
    Dr. James McCaffrey - November 2006
    This month see how to use Excel for test automation storage, whether you’re just starting out with NET, or you’re an advanced programmer.

  • Data Points: Revisiting System.Transactions
    John Papa - November 2006
    The System.Transactions namespace of the Microsoft .NET Framework makes handling transactions much simpler than previous techniques. Read all about it this month.

  • Security Briefs: Limited User Problems and Split Knowledge
    Keith Brown - November 2006

  • Concurrent Affairs: The ReaderWriterGate Lock
    Jeffrey Richter - November 2006

  • .NET Matters: Event Accessors
    Stephen Toub - November 2006
    Creating events on classes by adding the event keyword to a delegate member variable declaration.

  • WCF Essentials: What You Need To Know About One-Way Calls, Callbacks, And Events
    Juval Lowy - October 2006
    Object and component-oriented programming have only one way for clients to call a method, but Windows® Communication Foundation introduces two more. In this article Juval Lowy explains how they work.

  • 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.

  • App Fundamentals: Build A Great User Experience With Windows Presentation Foundation
    Michael Weinhardt - October 2006
    The Windows Presentation Foundation application model distinguishes between standalone and browser applications and between menu driven and hyperlink driven navigation, resulting in a more satisfying experience for your users.

  • 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.

  • SQL Server 2005: Jazz Up Your Data Using Custom Report Items In SQL Server Reporting Services
    Teo Lachev - October 2006
    Custom report items in SQL Server 2005 Reporting Services address your needs for custom reports without the pain of doing it from scratch.

  • Inside MSDN: Consuming MSDN Web Services
    Craig Andera - October 2006
    Get the inside track on how the MSDN team uses Web Services to power MSDN2.

  • Extreme ASP.NET: Control Adapters
    Fritz Onion - October 2006
    Control adapters let you provide alternate renderings of controls for mobile devices. But they can also be used to completely change the rendering of a con¬trol based on browser type, which can be useful in a number of situations.

  • Wicked Code: Running ASMX Web Services on STA Threads
    Jeff Prosise - October 2006
    Jeff Prosise describes performance problems in an ASMX Web service that relied on legacy COM and Visual Basic 6.0 to perform key processing tasks and the approach he took to find a fix.

  • Smart Clients: New Guidance And Tools For Building Integrated Desktop Applications
    Christian Thilmany and Jim Keane - September 2006
    Integrated Desktop is a loosely coupled hosting architecture and composite UI that runs on the desktop and is supported by a loosely coupled architecture on the back end. It collapses the number of applications a user must deal with when making decisions.

  • Enterprise Library: Take Exception To Critical Errors With Custom Application Blocks
    Jay Hilyard - September 2006
    Enterprise Library is a collection of application functionality blocks that you can re-use in your application for common functionality you'd otherwise have to write again and again. Here Jay Hilyard explains how to use them.

  • Test Run: Randomness in Testing
    Dr. James McCaffrey - September 2006
    In this installment of Test Run, James McCaffrey discusses how you can generate random test case data.

  • CLR Inside Out: Using concurrency for scalability
    Joe Duffy - September 2006
    Because of the popularity of multiprocessor machines, many concurrency articles focus on how to make concurrency safe in your code. However, they don't deal with how to get concurrency into your code in the first place.

  • Service Station: What's new in System.Xml 2.0?
    Aaron Skonnard - September 2006
    In this installment of Service Station, Aaron Skonnard takes a long hard look at System.Xml 2.0.

  • Concurrent Affairs: Concurrency and Coordination Runtime
    Jeffrey Richter - September 2006
    What can a robot-programming toolkit do for you? Read on and find out.

  • .NET Matters: Scope<T> and More
    Stephen Toub - September 2006
    This month Stephen Toub explains how you can get some of the functionality found in the TransactionScope class in your own classes.

  • Gathering MOSS: New Dev-Centric Features In Office SharePoint Server Keep Your Apps Rolling
    Ted Pattison - August 2006
    Microsoft Office SharePoint Server (MOSS) 2007 provides great portal and search features and much more, and Ted Pattison puts them to good use here.

  • Add-In Power: Let Users Customize Your Apps With Visual Studio Tools For Applications
    Paul Stubbs - August 2006
    If you're looking to increase the usefulness of your applications by making them customizable, you'll want to read about these three technologies available from Microsoft.

  • Design Patterns: Model View Presenter
    Jean-Paul Boodhoo - August 2006
    The MVP pattern helps you separate your logic and keep your UI layer free of clutter. This month learn how.

  • Service Station: Serialization in Windows Communication Foundation
    Aaron Skonnard - August 2006
    Windows Communication Foundation supports several serialization mechanisms and provides a simple, interoperable foundation for future service-oriented applications. Here Aaron Skonnard explains it all.

  • 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.

  • Code & Seek: Bring Windows Desktop Search Into Visual Studio With Our Cool Add-In
    Sergey Mishkovskiy - July 2006

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

  • Patterns & Practices: Speed Development With Custom Application Blocks For Enterprise Library
    Mark Seemann - July 2006

  • CLR Inside Out: Using Strong Name Signatures
    Mike Downen - July 2006
    Strong name signatures (and signing in general) are a key facet of Microsoft® . NET Framework security. But regardless of how well designed . NET signatures may be, they won’t offer the maximum benefit if you don’t know how to use them properly.

  • Inside MSBuild: Compile Apps Your Way With Custom Tasks For The Microsoft Build Engine
    Sayed Ibrahim Hashimi - June 2006
    Learn how you can use MSBuild to customize your builds. Since it ships as a part of the .NET Framework, you don't even need to have Visual Studio installed on your machine.

  • WCF Essentials: Discover Mighty Instance Management Techniques For Developing WCF Apps
    Juval Lowy - June 2006
    Instance management refers to a set of techniques used by Windows Communication Foundation to bind a set of messages to a service instance. This article introduces the concept and shows you why you need instance management.

  • Class To Contract: Enrich Your XML Serialization With Schema Providers In The .NET Framework
    Keith Pijanowski - June 2006
    The Microsoft .NET Framework 1.x provided minimal options for mapping classes to schemas and serializing objects to XML documents, making this sort of mapping quite a challenge. The .NET Framework 2.0 changes all this with Schema providers and the IXmlSerializable interface.

  • Test Run: Five Ways to Emit Test Results as XML
    Dr. James McCaffrey - June 2006
    The use of XML files in software testing has steadily increased over the past few years. Test case data, test harness configuration information, and test result data are now stored as XML. Recently I was writing some .

  • Wicked Code: Three Cures for Common Site Map Ailments
    Jeff Prosise - June 2006
    Data-driven site navigation is among the niftiest and most useful features in ASP. NET 2. 0. To get it working, all you do is create an XML site map file (or a SQL site map if you're using the MSDN®Magazine SqlSiteMapProvider), add a SiteMapDataSource, and bind a TreeView or Menu to the SiteMapDataSource.

  • Concurrent Affairs: Reader/Writer Locks and the ResourceLock Library
    Jeffrey Richter - June 2006
    If multiple threads concurrently execute code that writes to or modifies a resource, then obviously the resource must be protected with a thread synchronization lock to ensure that the resource doesn't get corrupted.

  • .NET Matters: Parameterized ThreadStart, EventWaitHandle, and More
    Stephen Toub - June 2006
    This month Stephen Toub answers readers questions that include: How do I pass data to a new thread? Why can't I convert from "ref string" to "ref object"? And what's the difference between EventWaitHandle, AutoResetEvent and ManualResetEvent?

  • Bug Bash: Let The CLR Find Bugs For You With Managed Debugging Assistants
    Stephen Toub - May 2006
    Managed Debugging Assistants are new to the .NET Framework 2.0 and help you to discover serious bugs quickly. Learn how to harness their power.

  • Analyze This: Find New Meaning In Your Ink With Tablet PC APIs In Windows Vista
    Markus Egger - May 2006

  • Test Run: Stress Testing.
    Dr. James McCaffrey - May 2006
    Stress testing is a fundamental quality assurance activity that should be part of every significant software testing effort. The key idea behind stress testing is simple: instead of running manual or automated tests under normal conditions, you run your tests under conditions of reduced machine or system resources.

  • Security Briefs: Step-by-Step Guide to InfoCard
    Keith Brown - May 2006
    In my April 2006 column I began a discussion of InfoCard, the upcoming identity metasystem, which is being prepared for release in the Windows Vista™ timeframe. If you haven’t read that column, you should definitely start there because I’m going to assume you’re familiar with the basics I covered.

  • Managed Spy: Deliver The Power Of Spy++ To Windows Forms With Our New Tool
    Benjamin Wulfe - April 2006
    Spy++ displays Win32 information such as window classes, styles, and messages. Now you can get that same functionality for managed code using our ManagedSpy. Get it here.

  • No More Hangs: Advanced Techniques To Avoid And Detect Deadlocks In .NET Apps
    Joe Duffy - April 2006
    You can combat deadlock using a combination of disciplined locking practices which Joe Duffy aptly explains in this article.

  • Mutant Power: Create A Simple Mutation Testing System With The .NET Framework
    James McCaffrey - April 2006
    With mutation testing, the system under test is changed to create a faulty version called a mutant. Here James McCaffrey explains how to do this in .NET.

  • CLR Inside Out: Extending System.Diagnostics
    Krzysztof Cwalina - April 2006
    The System. Diagnostics namespace in the Microsoft® . NET Framework contains powerful tracing capabilities. This includes the main tracing API: TraceSource. As you will see, the tracing APIs in System.

  • Cutting Edge: Windows Workflow Foundation, Part 2
    Dino Esposito - April 2006
    In last month's column, I presented a helpdesk workflow sample that focused on Windows® Forms client applications. This month I'll discuss ASP. NET workflow applications and the ability to expose a workflow as a Web service and invoke a Web service from a workflow.

  • Extreme ASP.NET: A New Solution to an Old State Storage Problem
    Fritz Onion - April 2006
    State management in Web applications is a contentious issue. Should you store user data per session or should you persist it across sessions? You can easily store information temporarily while someone navigates your site by using session state.

  • Service Station: Migrating to WSE 3.0
    Aaron Skonnard - April 2006
    You've probably heard that the new version of Web Services Enhancements (WSE) for the Microsoft® . NET Framework simplifies the process of building secure Web services. What you may not know is that most of these improvements derive from some core architectural changes made in WSE 3.

  • Winning Forms: Practical Tips For Boosting The Performance Of Windows Forms Apps
    Milena Salman - March 2006
    This article discusses techniques you can use to ensure that Windows Forms-based apps provide optimal performance to match the rich UI responsiveness they're known to provide.

  • Text Rendering: Build World-Ready Apps Using Complex Scripts In Windows Forms Controls
    Miguel A. Lacouture - March 2006
    The System.Windows.Forms.TextRenderer class provides support for complex scripts in Windows Forms controls so you can render text the way you want and support international locales.

  • The Perfect Host: Create And Host Custom Designers With The .NET Framework 2.0
    Dinesh Chandnani - March 2006
    The .NET Framework 2.0 introduces a set of classes that can be used to host designers right out of the box. With the understanding of designers you'll glean from this article, you'll be ready to host them in your own apps.

  • Cutting Edge: Windows Workflow Foundation
    Dino Esposito - March 2006
    In the January 2006 issue, Don Box and Dharma Shukla introduced Windows® Workflow Foundation and discussed the overall architecture of the framework and its constituent components (see WinFX Workflow: Simplify Development With The Declarative Model Of Windows Workflow Foundation).

  • Test Run: Determining .NET Assembly and Method References
    James McCaffrey - March 2006
    Before you can test any software system effectively, you must understand the system under test. If the system includes the Microsoft® . NET Framework, understanding the system under test includes understanding its assembly and method dependencies.

  • Concurrent Affairs: Build a Richer Thread Synchronization Lock
    Jeffrey Richter - March 2006
    In my last column, I showed the various thread synchronization mechanisms employed by the Microsoft® . NET Framework (see Concurrent Affairs: Performance-Conscious Thread Synchronization). I then examined the performance characteristics of all these mechanisms and determined that the Interlocked methods performed the best because the calling thread never has to transition to kernel mode.

  • .NET Matters: Abortable Thread Pool
    Stephen Toub - March 2006

  • Distributed .NET: Learn The ABCs Of Programming Windows Communication Foundation
    Aaron Skonnard - February 2006
    Windows Communication Foundation unifies the existing suite of .NET distributed technologies into a single programming model to improve the developer experience. This article introduces WCF so you'll be prepared to take advantage of all the new capabilities.

  • UDP Delivers: Take Total Control Of Your Networking With .NET And UDP
    Yaniv Pessach - February 2006
    UDP, the lesser-known sibling of TCP, is used for DNS resolution, SNMP network status, Kerberos security, digital media streaming, VoIP, and lots more. Learn how to put UDP to work for you.

  • Wandering Code: Write Mobile Agents In .NET To Roam And Interact On Your Network
    Matt Neely - February 2006
    In artificial intelligence, an agent is a logical entity that has some level of autonomy within its environment or host. A mobile agent has the added capability that it can move between hosts. In this article Matt Neely brings mobile agents from the halls of academia to a dev shop near you.

  • WSE Security: Protect Your Web Services Through The Extensible Policy Framework In WSE 3.0
    Tomasz Janczuk - February 2006
    This article describes the WSE policy framework, which allows you to describe constraints and requirements a Web service must enforce. Discussions include security scenarios in WSE 3.0 and extending the framework with custom constraints and requirements.

  • Smart Clients: Build A Windows Forms Control To Consume And Render WSRP Portlets
    Carl Nolan - February 2006
    Smart client apps use local resources, provide a rich client experience, and support intelligent install mechanisms. Web services offer powerful interoperability and integration features. Find out how to combine them to develop integrated apps that incorporate data from disconnected sources.

  • Paste As Visual Basic: A Visual Studio Add-In That Converts C# Code To Visual Basic
    Scott Swigart - February 2006
    Build a Visual Basic add-in that lets you copy C# code and paste it into Visual Studio as Visual Basic using the code converter of your choice. Scott Swigart shows you how.

  • Wicked Code: The SQL Site Map Provider You've Been Waiting For
    Jeff Prosise - February 2006
    Now that ASP.NET 2.0 is a shipping product, it seems appropriate to revisit an issue that tops the new features wish lists of many developers: a SQL Server™ site map provider.

  • WinFX Workflow: Simplify Development With The Declarative Model Of Windows Workflow Foundation
    Don Box and Dharma Shukla - January 2006
    Windows Workflow Foundation allows you to write workflow-based programs in terms of domain-specific activities that are implemented in CLR-based programming languages such as C# and Visual Basic. Here Don Box and Dharma Shukla get you started.

  • Dazzling Graphics: Top Ten UI Development Breakthroughs In Windows Presentation Foundation
    Ian Griffiths and Chris Sells - January 2006
    The Windows Presentation Foundation provides new techniques for UI-based developing applications and makes better use of current hardware and technologies. In this article, Ian Griffiths and Chris Sells explain 10 of the most significant advances that make WPF superior to its Win32 predecessors.

  • 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.

  • XPS Documents: A First Look at APIs For Creating XML Paper Specification Documents
    Bob Watson - January 2006
    Windows Vista includes improved document technology called the XML Paper Specification that is designed to provide users with a consistent document appearance regardless of where and how the document is viewed, solving the age-old problem of document portability and display consistency. Here Bob Watson explains.

  • Dev Q&A: DataGridView
    Edited by Nancy Michell - January 2006
    After receiving a late-breaking news bulletin at magazine headquarters early this month stating that the Web is just a fad that will never amount to anything, we have reluctantly decided to retire our venerable Web Q&A column and replace it with one we like to call Dev Q&A.

  • CLR Inside Out: Base Class Library Performance Tips and Tricks
    Kit George - January 2006
    The common language runtime (CLR) sits at the very heart of managed code. Indeed, it is the heart of managed code, so to understand managed code you need to understand the CLR.

  • Data Points: SqlConnectionStringBuilder, DataView, and More
    John Papa - January 2006
    Several significant enhancements have been made to ADO. NET 2. 0 in the areas of improved performance, increased flexibility, and added features. In my last column (Data Points: DataSet and DataTable in ADO.

  • Service Station: All About ASMX 2.0, WSE 3.0, and WCF
    Aaron Skonnard - January 2006
    The release of the Microsoft® . NET Framework 2. 0 reshapes the Web services landscape in several interesting, and perhaps confusing, ways. So this month I'm going to field some of the most common questions related to ASP.

  • Extreme ASP.NET: Codebehind and Compilation in ASP.NET 2.0
    Fritz Onion - January 2006
    As I write this column, the release candidates of the Microsoft® .NET Framework 2.0 and Visual Studio® 2005 have just come out, and by the time you read this, they will both already be on the shelves. It feels like it's been a long time coming.

  • Security Briefs: Encrypting Without Secrets
    Keith Brown - January 2006
    Do you have a Web site or other system that deals in secrets of any sort? It seems like every time I give a security talk, people ask how to deal with the sticky problem of storing secrets. Connection strings with passwords are an obvious problem.

  • .NET Matters: Iterating NTFS Streams
    Stephen Toub - January 2006

  • C#: Create Elegant Code With Anonymous Methods, Iterators, And Partial Classes
    Juval Lowy - Visual Studio 2005 Guided Tour 2006
    In this article Juval Lowy describes how exciting new features in Visual Studio 2005, that will improve your overall productivity compared to the first version of C#, so you can write cleaner code faster.

  • .NET Column: Introducing Generics in the CLR
    Jason Clark - Visual Studio 2005 Guided Tour 2006
    Generics are an extension of the CLR type system that allow developers to define types for which certain details are left unspecified. These details are specified when the code is referenced by consumer code, making for enhanced flexibility. Jason Clark explains how.

  • Smart Clients: Craft A Rich UI For Your .NET App With Enhanced Windows Forms Support
    Chris Sells and Michael Weinhardt - Visual Studio 2005 Guided Tour 2006
    The System.Windows.Forms namespace has increased by approximately 134 percent over the .NET Framework 1.1. There are 446 new public types; 113 existing types have been updated with new members and values; 218 types have been carried over from the original namespace. Read about it here.

  • Security Briefs: Security Enhancements in the .NET Framework 2.0
    Keith Brown - Visual Studio 2005 Guided Tour 2006
    The.NET Framework 2.0 got quite a few security enhancements. This month Keith takes you on a whirlwind tour of the goodies you'll find there.

  • Power to the Pen: The Pen is Mightier with GDI+ and the Tablet PC Real-Time Stylus
    Charles Petzold - December 2005

  • Can't Commit?: Volatile Resource Managers in .NET Bring Transactions to the Common Type
    Juval Lowy - December 2005
    Here Juval Lowy discusses the benefits you'll get when you implement transactions in your non-database applications, with a little help from volatile resource managers in the .NET Framework 2.0.

  • UI on the Fly: Use the .NET Framework to Generate and Execute Custom Controls at Run Time
    Morgan Skinner - December 2005
    Creating UI controls on the fly can be accomplished via run-time code generation. And there are lots of reasons to do so. Generating these controls once and then reusing them as needed is more efficient than generating the controls each time. Read on.

  • 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.

  • .NET Matters: BigInteger, GetFiles, and More
    Stephen Toub - December 2005

  • Are You in the Know?: Find Out What's New with Code Access Security in the .NET Framework 2.0
    Mike Downen - November 2005
    Unlike role-based security measures, code access security is not based on user identity. Instead, it is based on the identity of the code that is running, including information such as where the code came from. Here Mike Downen discusses the role of code access security (CAS) in .NET and outlines some key new features and changes in CAS for the .NET Framework 2.0.

  • Do You Trust It?: Discover Techniques for Safely Hosting Untrusted Add-Ins with the .NET Framework 2.0
    Shawn Farkas - November 2005
    When you allow your application to run arbitrary code through an add-in, you may expose users to unknown code, running the risk that malicious code will use your application as an entry point into the user's data. There are several techniques you can use to reduce the attack surface of your application, which Shawn Farkas discusses here.

  • Are You Protected?: Design and Deploy Secure Web Apps with ASP.NET 2.0 and IIS 6.0
    Mike Volodarsky - November 2005
    Ensuring the security of a Web application is critical and requires careful planning throughout the design, development, deployment, and operation phases. It is not something that can be slapped onto an existing application. In this article, Mike Volodarsky outlines best practices that allow you to take advantage of the security features of ASP.NET 2.0 and IIS 6.0 to build and deploy more secure Web applications.

  • 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.

  • Data Points: DataSet and DataTable in ADO.NET 2.0
    John Papa - November 2005
    ADO. NET 2. 0 sports some exciting enhancements to the core classes found in ADO. NET 1. x and introduces a variety of new classes, all of which promise to improve performance, flexibility, and efficiency.

  • Security Briefs: Security Features in WSE 3.0
    Keith Brown - November 2005
    I've been spending a lot of time lately building secure Web services with the Microsoft® . NET Framework 2. 0, and Web Services Enhancements (WSE) 3. 0 has been a lifesaver for me, so I thought it would be appropriate to dedicate a column to security features in this new product.

  • Memory Models: Understand the Impact of Low-Lock Techniques in Multithreaded Apps
    Vance Morrison - October 2005
    Because the use of low-lock techniques in your application significantly increases the likelihood of introducing hard-to-find bugs, it is best to use them only when absolutely necessary. Here Vance Morrison demonstrates the limitations and subtleties low-lock techniques so that if you are forced to use them you have a better chance of using them correctly.

  • High Availability: Keep Your Code Running with the Reliability Features of the .NET Framework
    Stephen Toub - October 2005
    Reliability requires the capacity to execute a sequence of operations in a deterministic way, even under exceptional conditions. This allows you to ensure that resources are not leaked and that you can maintain state consistency without relying on application domain unloading (or worse, process restarts) to fix any corrupted state. Unfortunately, in the.NET Framework, not all exceptions are deterministic and synchronous, which makes it difficult to write code that is always deterministic in its ability to execute a predetermined sequence of operations. In this article Stephen Toub will show you why, and explore features of the .NET Framework 2.0 that help you to mitigate these situations and write more reliable code.

  • Custom Cultures: Extend Your Code's Global Reach With New Features In The .NET Framework 2.0
    Michael Kaplan and Cathy Wissink - October 2005
    The upcoming Microsoft .NET Framework 2.0 adds a number of globalization features that address the important issues of extensibility, standards support, and migration. Here authors Michael Kaplan and Cathy Wissink explain what these features mean to your globalization effort.

  • 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.

  • Data Points: The Enterprise Library Data Access Application Block, Part 3
    John Papa - October 2005
    E nterprise applications can have a wide variety of data update requirements. Sometimes you need to save multiple rows of changes at once within a single transaction. Other times, the user must be allowed to enter multiple rows of data, send them to the database in a batch; and if a row or two fails, only the rows that succeeded should be committed and remain committed.

  • Test Run: Low-Level Web App UI Test Automation
    James McCaffrey - October 2005
    As Web applications have become more complex, testing them has become more important. There are many testing techniques available to you. For example, in the April 2005 issue of MSDN®Magazine, I describe a simple JScript®-based system that can test a Web app through its UI by using the Internet Explorer Document Object Model.

  • Wicked Code: Asynchronous Pages in ASP.NET 2.0
    Jeff Prosise - October 2005
    ASP.NET 2.0 is replete with new features ranging from declarative data binding and Master Pages to membership and role management services. But my vote for the coolest new feature goes to asynchronous pages, and here's why.

  • Concurrent Affairs: Performance-Conscious Thread Synchronization
    Jeffrey Richter - October 2005
    In my career, I have architected and implemented many thread synchronization techniques. This has provided me with a lot of experience that has shaped the way I now think about thread synchronization problems.

  • .NET Matters: NamedGZipStream, Covariance and Contravariance
    Stephen Toub - October 2005

  • Best Practices: Fast, Scalable, and Secure Session State Management for Your Web Applications
    Mike Volodarsky - September 2005
    ASP.NET provides a number of ways to maintain user state, the most powerful of which is session state. This article takes an in-depth look at designing and deploying high-performance, scalable, secure session solutions, and presents best practices for both existing and new ASP.NET session state features straight from the ASP.NET feature team.

  • ASP.NET 2.0: Personalize Your Portal with User Controls and Custom Web Parts
    Ted Pattison and Fritz Onion - September 2005
    ASP.NET 2.0 introduces a Web Part control that is designed to deal with the serialization, storage, and retrieval of customization and personalization data behind the scenes. In this article, the authors explain how you can put the WebPart control to work in your ASP.NET 2.0 applications.

  • Call MOM: Instrument and Monitor Your ASP.NET Apps Using WMI and MOM 2005
    Michael Jurek - September 2005
    The current version of Windows Management Instrumentation (WMI) satisfies many current and future manageability requirements. In this article Michael Jurek demonstrates how WMI provides important system management capabilities and develops a WMI-aware monitoring solution you can use to instrument your ASP.NET applications. He then introduces the capabilities of MOM 2005 that allow you to monitor these instrumented applications.

  • Cutting Edge: ASP.NET Forms
    Dino Esposito - September 2005
    Forms are an essential piece of ASP. NET—the ASP. NET Web programming model itself wouldn't be possible without forms. The use of forms is not constrained in pure HTML, but it is subject to some restrictions in ASP.

  • Design Patterns: Dependency Injection
    Griffin Caprio - September 2005
    Today there is a greater focus than ever on reusing existing components and wiring together disparate components to form a cohesive architecture. But this wiring can quickly become a daunting task because as application size and complexity increase, so do dependencies.

  • .NET Matters: Stream Decorator, Single-Instance Apps
    Stephen Toub - September 2005

  • Concurrency: What Every Dev Must Know About Multithreaded Apps
    Vance Morrison - August 2005
    Multithreading offers lots of benefits, but it's not a technique you can employ willy nilly without first learning about all the potential pitfalls. To get you started, Vance Morrison covers multithreading and the shared memory threading model, race conditions and how concurrent access can break invariants. He also discusses how to use locks so you can understand the costs involved.

  • Proxy Detection: Take the Burden Off Users with Automatic Configuration in .NET
    Durgaprasad Gorti - August 2005
    Proxy settings can be a real pain in the neck and very frustrating for users to configure properly. In this article, Durgaprasad Gorti discusses how you can use automatic proxy configuration via script and how it works in the Microsoft .NET Framework 1.1 and 2.0.

  • 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.

  • Easy UI Testing: Isolate Your UI Code Before It Invades Your Business Layer
    Mark Seemann - August 2005
    The User Interface Process Application Block (UIP) from the Microsoft Patterns & Practices team can help you isolate your UI, write unit tests for your UI logic, and write a UI that really is the thin layer it was always meant to be. Mark Seemann shows you how it's done in this article.

  • Data Points: The Enterprise Library Data Access Application Block, Part 2
    John Papa - August 2005
    Last month I explored the foundation of the Enterprise Library Data Access Application Block (DAAB) including how it all fits into an architecture (see Data Points: The Enterprise Library Data Access Application Block, Part 1).

  • Cutting Edge: DataSets vs. Collections
    Dino Esposito - August 2005
    In software, five years is like a geological era. Five years ago, the Microsoft® . NET Framework had just been announced. Since then, the DataSet has emerged as the key object for performing a variety of data-related tasks in .

  • Test Run: Test Harness Design Patterns
    James McCaffrey and James Newkirk - August 2005
    The Microsoft® . NET Framework provides you with many ways to write software test automation. But in conversations with my colleagues I discovered that most engineers tend to use only one or two of the many fundamental test harness design patterns available to them.

  • Smart Tags: Simplify UI Development with Custom Designer Actions in Visual Studio
    Michael Weinhardt - July 2005
    Windows Forms 2.0 components expose smart tags by utilizing Designer Actions. By taking advantage of this feature, you can add smart tags to your own custom components to make setting their properties and other actions much easier and developer-friendly.

  • Reflection: Dodge Common Performance Pitfalls to Craft Speedy Applications
    Joel Pobar - July 2005
    With reflection in .NET, you can load types, understand their members, make decisions about them, and execute, all within the safety of the managed runtime. But to use this power wisely, it's important to understand the associated costs and pitfalls to keep performance impact at a minimum. This article explains how.

  • Behind the Scenes: Discover the Design Patterns You're Already Using in the .NET Framework
    Rob Pierry - July 2005
    In this article, the author presents a basic overview of several common design patterns and how they are used in the .NET Base Class Library and other areas of the .NET Framework. You'll discover some of the motivation for why the Framework is designed the way it is, and come away with a better understanding of the abstract concepts of the patterns themselves.

  • Cutting Edge: DHTML-Enabled ASP.NET Controls
    Dino Esposito - July 2005
    In the past, I've covered some core aspects of the interaction between DHTML behaviors, the browser, and ASP. NET runtime (see Cutting Edge: Extend the ASP. NET DataGrid with Client-side Behaviors and Cutting Edge: Moving DataGrid Rows Up and Down).

  • Data Points: The Enterprise Library Data Access Application Block, Part 1
    John Papa - July 2005
    A solid data access later (DAL) can benefit an application by hiding redundant tasks, helping handle exceptions more gracefully, helping clean up resources more efficiently, and providing a layer of abstraction from the database.

  • .NET Matters: StringStream, Methods with Timeouts
    Stephen Toub - July 2005

  • Know Thy Code: Simplify Data Layer Unit Testing using Enterprise Services
    Roy Osherove - June 2005
    If you want to employ unit testing and test-driven development techniques in your database application development process, you'll have different factors to consider than you do when you're not involving a database. For example, you have to maintain a consistent state within the database and be able to roll back transactions when necessary. This article shows you how to get the best of unit testing for your database apps in a safe, usable manner.

  • Make It Snappy: Juice Up Your App with the Power of Hyper-Threading
    Yaniv Pessach - June 2005
    In this article, the author explores the hyper-threading technology found on newer Intel Pentium 4 processors and demonstrates how adding parallelism to your code can improve performance on hyper-threaded machines. He covers advanced optimizations for hyper-threading and shows a number of useful patterns. Code samples are in C#, but you can apply the same principles in other languages as they apply to both managed and unmanaged applications.

  • Cutting Edge: Data Repeater Controls in ASP.NET
    Dino Esposito - June 2005
    The ASP. NET Repeater is a basic container control that allows you to create custom lists from any data available to the page. It's a handy control, especially since most ASP. NET pages that display data need to repeat the same kinds of data over and over.

  • Data Points: XML Features in SQL Server 2000
    John Papa - June 2005
    SQL Server™ 2000 includes several XML features that let you transform relational rowsets into hierarchical XML documents, read XML documents, and bulk load data via XML. For example, you can pass an XML document to a stored procedure, join the XML to some tables and return a rowset, or even modify data in the database.

  • Service Station: Techniques for Contract-First Development
    Aaron Skonnard - June 2005
    In my May 2005 column, I discussed contract-first development and appropriate times to use it (see Service Station: Contract-First Service Development). In this second part, I'm going to focus on some techniques for contract-first development within the ASMX framework.

  • Wicked Code: Power Programming Tips for ASP.NET 2.0
    Jeff Prosise - June 2005
    In the February 2005 issue, I introduced five lesser-known features of ASP. NET 2. 0 that have the potential to make a significant impact on the security, performance, and robustness of your code (see Wicked Code: Five Undiscovered Features on ASP.

  • JIT and Run: Drill Into .NET Framework Internals to See How the CLR Creates Runtime Objects
    Hanu Kommalapati and Tom Christian - May 2005
    There's lots to explore in the .NET Framework 2.0, and plenty of digging to be done. If you want to get your hands dirty and learn some of the internals that will carry you through the next few years, you've come to the right place. This article explores CLR internals, including object instance layout, method table layout, method dispatching, interface-based dispatching, and various data structures.

  • Around the Horn: Engineer a Distributed System Using .NET Remoting for Process Intensive Analysis
    Nate D'Anna - May 2005
    Before the Microsoft .NET Framework, creating a distributed cluster of computers to perform scientific analysis was expensive in terms of hardware, programming and debugging time, and maintenance. You had to purchase expensive servers, spend time debugging network communication, design a distributed system completely different from a system deployed locally, and maintain a melting pot of error handling, data acquisition, networking, and analysis code. In this article, the author shows you how he was able to engineer a distributed computing system in C# to perform analysis of real-world data continuously acquired at high sampling rates, thanks to the .NET Framework.

  • Draft a Rich UI: Ground Rules for Building Enhanced Windows Forms Support into Your .NET App
    Michael Weinhardt and Chris Sells - May 2005
    In this article, the winning Windows Forms duo of Chris Sells and Michael Weinhardt team up again to explore lots of new features and additions to Windows Forms 2.0 that will let you build more flexible, feature-rich controls, get better resource management, more powerful data-binding abilities, and make your development life a whole lot more fun.

  • Web Q&A: ASP.NET Performance, Notification, Keeping Sort Order, and More
    Edited by Nancy Michell - May 2005

  • Cutting Edge: Collections and Data Binding
    Dino Esposito - May 2005
    When it's time to design the Data Access Layer (DAL) of your distributed Microsoft® . NET Framework-based app, one of the key decisions you'll make is how you'll pass data to and from methods of DAL classes.

  • Data Points: Data Access Strategies Using ADO.NET and SQL
    John Papa - May 2005
    When your goal is a scalable and efficient enterprise solution, you need to develop an efficient data-access strategy. You can't just do some testing on your production machines and rely on the results.

  • Service Station: Contract-First Service Development
    Aaron Skonnard - May 2005
    In one of my previous columns on Service Orientation (SO), I introduced the concept of "contract-first" service development (see Service Station: SOA: More Integration, Less Renovation). Over the next two installments of this column, I'm going to cover the topic in depth.

  • Extreme ASP.NET: A Little Bit of Control for Your Controls
    Rob Howard - May 2005
    Having worked for so many years designing and developing ASP. NET while at Microsoft, it's exciting now to have a venue in which to talk about it. In this new column, Extreme ASP. NET, I'll discuss and demonstrate time-tested techniques and approaches to implementing high-performance, reliable, secure, and user-friendly Web applications with ASP.

  • .NET Matters: ICustomTypeDescriptor, Part 2
    Stephen Toub - May 2005
    In last month's . NET Matters column, I answered a question concerning the PropertyGrid control, specifically about using it with classes that expose fields instead of properties. I demonstrated how the ICustomTypeDescriptor interface in the Microsoft® .

  • Security: Unify Windows Forms and ASP.NET Providers for Credentials Management
    Juval Lowy - April 2005
    The .NET Framework 2.0 provides custom credentials management to ASP.NET apps out of the box. Using it, you can easily authenticate users without using Windows accounts. In this article the author presents a set of helper classes that let a Windows Forms application use the ASP.NET credentials management infrastructure as easily as if it were an ASP.NET application.

  • Service Station: Developing .NET Web Services with Beta 2
    Aaron Skonnard - April 2005
    Version 2. 0 of the Microsoft® . NET Framework makes numerous improvements at various levels in the Web services protocol stack. In addition, better tool support and an increased focus on interoperability make your life easier.

  • .NET Matters: ICustomTypeDescriptor, Part 1
    Stephen Toub - April 2005

  • { End Bracket }: Creating a Custom Metrics Tool
    Stephen Toub - April 2005
    Metrics play an important role in our lives. Even if we don't realize it or characterize it as such, many daily activities have the potential to be quantified to some degree. So it's not surprising that metrics play an even greater role in the workplace, where there are goals and a bottom line and where much of a day's activity can be summarized in numbers.

  • Web Services: Increase Your App's Reach Using WSDL to Combine Multiple Web Services
    Gerrard Lindsay - March 2005
    The very tools that have helped drive the growing adoption of Web services, and the enabling abstractions that they provide, can often prevent developers from peeking behind the curtains at the XML standards that make up the Web services stack. This article will offer a solution that enables type sharing between proxies created for complementary Web services, while at the same time providing an opportunity to examine the Web Services Description Language (WSDL) and its interaction with the Web services tools you know and love.

  • ASP.NET: Combine Web and Windows Services to Run Your ASP.NET Code at Scheduled Intervals
    Andrew Needleman - March 2005
    If you want to schedule ASP.NET tasks, one solution is to use a Web service to provide an interface to your ASP.NET application and build a Windows service that calls to it at scheduled intervals. Thus the ASP.NET application doesn't have to own the scheduling logic. Here the author shows how to schedule your ASP.NET tasks using a Windows service to initiate the Web service call because Windows services can start themselves when Windows boots up.

  • 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.

  • Cutting Edge: Moving DataGrid Rows Up and Down
    Dino Esposito - March 2005
    Imagine opening your Inbox one morning and finding a message that reads "Dear Mr. DataGrid, I urgently need an ASP.NET DataGrid that lets my users move rows on the client. You're my last hope. Will you please help me?"

  • Test Run: Automate Your ASP.NET Web Services Testing
    James McCaffrey - March 2005
    It's no exaggeration to say that Web services are revolutionizing application-to-application communication. Web services are already being used extensively in corporate intranet environments and are making their way into commercial use, too.

  • Inside MSDN: Using InfoPath as a Reporting Solution
    Larry W. Jordan Jr. - March 2005
    I love the part of my job that lets me write code and develop software. In addition to those responsibilities, however, I manage a development organization that's working on a number of large strategic projects.

  • 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.

  • SharePoint: Add a Recycle Bin to Windows SharePoint Services for Easy Document Recovery
    Maxim V. Karpov and Eric Schoonover - February 2005
    Windows SharePoint Services helps improve collaboration and workflow while protecting documents and intellectual property. But one feature is conspicuously missing - an easy way to back up and restore deleted files from document libraries. In this article, the authors take advantage of the extensibility of WSS and its server-side and client-side object models to build a restore feature that works like the Recycle Bin in Windows Explorer.

  • Smart Tags: Realize the Potential of Office 2003 by Creating Smart Tags in Managed Code
    Ben Waldron - February 2005
    While you may well be excited about the prospect of building managed smart tags, there is little information available to help you create them using .NET. In this article the author fills in the blanks. Along the way he discusses the Microsoft Office Smart Tag List XML schema, advanced managed smart tags for Office 2003 and Office XP, and deploying these features in an organization.

  • SQL Server: Display Your Data Your Way with Custom Renderers for Reporting Services
    James Yip - February 2005
    SQL Server 2005 Reporting Servicesis a great tool that offers a centralized approach to storing and rendering reports. It also lets users view and download reports without installing additional software. Plus, reports can be saved in any number of different formats using custom report renderers. In this article, the author will develop one such report renderer that outputs HTML reports, but the skills you'll learn can easily be used to create a renderer for Microsoft Word documents or any other format of your choosing.

  • Testing: Get Your Customers Involved in the Testing Process with Functional Tests in Excel
    Will Stott - February 2005
    For specification documents to be truly valuable, they need to give an accurate picture of all the requirements of a project. This article describes how the communication value of specification documents can be improved by permitting users to test the code under construction using the Framework for Integrated Test (FIT), an open-source tool. It also explains how you can build a Windows Forms application in C# (WinFITRunnerLite) that converts functional tests, as written by your customers using Excel, into a form that allows you to run them with FIT against the code you're developing.

  • Inside MSDN: Designing URLs for MSDN2
    Tim Ewald - February 2005
    This is the first installment of a new column about MSDN® projects: what we're doing, how we're doing it, and what we're learning along the way. It will be written by MSDN staff with the goal of sharing the team's experiences in solving the real-world business problems MSDN faces.

  • Data Points: ADO.NET and System.Transactions
    John Papa - February 2005
    The Microsoft® . NET Framework versions 1. 0 and 1. 1 represented major changes in software development. However, one important thing that did not change much was support for distributed transactions.

  • Cutting Edge: Adding a Context Menu to ASP.NET Controls
    Dino Esposito - February 2005
    Although the context menu is a common element of most desktop applications, it is still fairly uncommon in Web application names because it doesn't map well to a server-based technology like ASP. NET.

  • Wicked Code: Five Undiscovered Features on ASP.NET 2.0
    Jeff Prosise - February 2005
    By now, developers everywhere have had the opportunity to download the first beta of the Microsoft® . NET Framework 2. 0. ASP. NET developers who have played with it are no doubt salivating at all the cool new features.

  • .NET Matters: File Copy Progress, Custom Thread Pools
    Stephen Toub - February 2005

  • { End Bracket }: C# and VBA: Like Oil and Water
    Ken Getz - February 2005
    Some things just don't mix as well as you would like. Take C# and Microsoft® Excel 2003 or Word 2003, for example. Not only are these applications huge productivity tools, but they both also provide access to large object models that you can program against from your own applications.

  • Memory Lane: Rediscover the Lost Art of Memory Optimization in Your Managed Code
    Erik Brown - January 2005
    Managed applications rely on the garbage collector in the .NET Framework to allocate and clean up memory. The little CPU time spent performing garbage collection (GC) is usually a fair trade-off for not having to worry about memory management. But for applications in which CPU time and memory are precious resources, minimizing the time spent garbage collecting can greatly improve application performance and robustness. Find out how to manage memory all over again.

  • Interop: Get Seamless .NET Exception Logging From COM Clients Without Modifying Your Code
    Matt Adamson - January 2005
    Using .NET objects from ASP can help you gain experience with the .NET Framework before migrating to ASP.NET. Your ASP pages will make use of the new .NET components through COM-callable wrappers (CCW). But how will you handle exceptions? This article fills you in.

  • All About Statics: Get a Charge From Statics with Seven Essential Programming Tips
    K. Scott Allen - January 2005
    This article examines seven characteristics of statics that will help you in your development. The discussion will touch on static constructors and how the C# and Visual Basic compilers work together with the runtime to implement additional safety behind the scenes. By the end of the article, you will come away with best practices for the use of static members and static classes in your apps.

  • Data Points: Data Source Controls in ASP.NET 2.0
    John Papa - January 2005
    ASP. NET 2. 0 introduces a series of new tools that improve data access including several data source and data bound controls. The new assortment of data source controls can eliminate a ton of repetitive code that was required in ASP.

  • Cutting Edge: Custom Script Callbacks in ASP.NET
    Dino Esposito - January 2005
    ASP. NET client callbacks represent a neat and elegant way to execute server-side code without posting and refreshing the current page. I discussed ASP. NET callbacks in the August and December 2004 installments of Cutting Edge, considering them from the perspective of rendered pages making background callbacks to the server, sending input data to the relevant page, and receiving a response.

  • Test Run: Lightweight UI Test Automation with .NET
    James McCaffrey - January 2005
    Manual user interface testing is one of the most fundamental types of software testing and it's the kind of testing that most software engineers first experience. Paradoxically, automated user interface tests are probably the most technically challenging kind of test to write.

  • The ASP Column: Determining Browser Capabilities in ASP.NET
    George Shepherd - January 2005
    Web applications are different from applications that run in homogenous environments because they send their output to all kinds of platforms and Web browsers. Some browsers support client-side scripting, some support XHTML, and still others have limited screen real estate.

  • Security Briefs: Security Enhancements in the .NET Framework 2.0
    Keith Brown - January 2005
    As I write this column, version 2. 0 of the Microsoft® . NET Framework is at Beta 1. When I got my bits, I hacked together a little program to dump all of the public members of all public types in the entire Framework and ran it on version 1.

  • .NET Matters: Sepia Tone, StringLogicalComparer, and More
    Stephen Toub - January 2005

  • Tablet PC: Add Support for Digital Ink to Your Windows Applications
    Paul Yao - December 2004
    Check out the cool new features in Windows XP Tablet PC Edition, including a number of Ink types, and ink that's stored as ink. Here Paul Yao takes you on a tour of everything you need to know to get started.

  • Mobility: Optimize Your Pocket PC Development with the .NET Compact Framework
    Dave Edson and John Socha-Leialoha - December 2004
    The .NET Compact Framework can be used to write great code and great applications. As long as you take a few things into consideration and are willing to bend a rule or two, you can have your performance cake and eat it too. In this article the authors present some neat tricks to make life as a programmer easier when using the .NET Compact Framework. Later they discuss techniques to increase performance, and decrease both load time and memory footprints. Sample code is provided.

  • Vrooooom: How .NET and C# Drove an Entry in the DARPA Grand Challenge
    John Hind - December 2004
    Find out how the .NET Framework, a team of programmers, and a bunch of people from Carnegie Mellon University built an automated car to compete in the DARPA Grand Challenge. Along the way you get some inside tips on building an extensible real-time control architecture based on a whiteboard metaphor and implementing an accurate GPS-synchronized timer component for .NET.

  • .NET Internals: Tailor Your Application by Building a Custom Forms Designer with .NET
    Sayed Y. Hashimi - December 2004
    The design-time architecture of Windows Forms in the .NET Framework has made development much more flexible than it had been with MFC. With Windows Forms, you can drag one of your custom controls from the toolbox and drop it onto the Visual Studio design surface and even though Windows Forms knows nothing about the control, it's able to host it and let you manipulate its properties—not possible in MFC. In this article, the author discusses what's going on under the covers as you design your forms and then walks through the creation of a bare-bones forms designer.

  • .NET Code Tuning: Make Your Apps Fly with the New Enterprise Performance Tool
    John Robbins - December 2004
    Because the common language runtime (CLR) is a black box, it's pretty hard to divine what's going on when you want to track down performance problems. Microsoft will be delivering a brand new profiler, the Enterprise Performance Tool (EPT), as part of Visual Studio 2005 Team Developer Edition that's ideal for use on a production system because it offers some very lightweight means of collecting performance data. Here John Robbins takes you on a tour.

  • Data Points: Efficient Coding With Strongly Typed DataSets
    John Papa - December 2004
    Someone once said to me that the hallmark of a good developer is the desire to spend time efficiently. Developers are continually pursuing ways to make coding easier and faster, and to reduce the number of errors.

  • Service Station: Run ASMX Without IIS
    Aaron Skonnard - December 2004
    When the Microsoft® . NET Framework first shipped, it introduced a breakthrough Web services framework known as ASMX. The motivation behind the ASMX design was to simplify the process of developing Web services as much as possible so that even if you're not an XML expert, you can get a Web service up and running.

  • .NET Matters: Asynchronous HttpWebRequests, Interface Implementation, and More
    Stephen Toub - December 2004

  • App Lockdown: Defend Your Apps and Critical User Info with Defensive Coding Techniques
    Kenny Kerr - November 2004
    Whether you're storing database connection strings, user credentials, or logon info, you'll need to practice good defensive programming techniques to avoid those surprise situations in which your data is exposed. In this article, author Kenny Kerry shows you how.

  • Cryptography: Employ Strong Encryption in Your Apps with Our CryptoUtility Component
    Michael Stuart and J Sawyer - November 2004
    When storing sensitive data, you need to be able to identify threats, determine how these threats interact with each other, and how issues can combine to constitute a vulnerability that will leave your data exposed. With a good understanding of the various cryptographic algorithms, salt, hashes, ACLs, and other available techniques, you'll be in a better position to protect your critical data.

  • Trustworthy Code: Exchange Data More Securely with XML Signatures and Encryption
    Mike Downen and Shawn Farkas - November 2004
    You can sign any kind of data using XML Signature, including part of an XML document, other XML documents, or other data of any format. However, in practice, XML signatures are most frequently used to sign other data represented in XML. In this article, the authors discuss the new standard and how you can benefit from it in your apps.

  • 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.

  • Intrusion Prevention: Build Security Into Your Web Services with WSE 2.0 and ISA Server 2004
    Dino Esposito - November 2004
    Once you've addressed security in your code, it's time to look at the environment it runs in. Firewalls stop unauthorized traffic from getting into your network, and smart Web service-specific firewalls, like the one that comes with Internet Security and Acceleration (ISA) Server 2004, bring XML intrusion prevention to your system for that added layer of safety.

  • Cutting Edge: The ASP.NET 2.0 Wizard Control
    Dino Esposito - November 2004
    ASP.NET has a lot to offer to both the low-level programmer willing to control every little step of the code and the busiest of developers who needs to point-and-click his way through Web app development using just a few existing components.

  • Service Station: Improving Web Service Interoperability
    Aaron Skonnard - November 2004
    If interoperability is the main promise of Web services, why is it that so many developers and organizations have a difficult time achieving it in practice? With all due respect to our hard-working standards bodies, the primary culprits are the imperfect specifications guiding today's implementations.

  • .NET Matters: ThreadPoolPriority, and MethodImplAttribute
    Stephen Toub - November 2004

  • .NET Internals: Examine Running Processes Using Both Managed and Unmanaged Code
    Christophe Nasarre - October 2004
    There are plenty of times when you need to get information on running processes, not the least of which is during performance tuning. Using the techniques in this article and special .NET classes you'll see how to get a process' ID, name, priority, number of threads, kernel handle, and memory consumption, as well as its user-mode, kernel-mode, and total elapsed running time and put them to use in a custom app called AssemblyBrowser.

  • ASP.NET 2.0: Speed Up Your Site with the Improved View State in ASP.NET 2.0
    Fritz Onion - October 2004
    View state is a wonderful thing. It allows the ASP.NET developer to maintain state for server-side controls that are not form elements.Used judiciously, it can improve the user experience. But in the wrong hands, it can cause your pages to grind to a halt. The release of ASP.NET 2.0 will include a variety of improvements to view state that will make it easier to use and less likely to slow performance.

  • Advanced Serialization: Format Your Way to Success with the .NET Framework Versions 1.1 and 2.0
    Juval Lowy - October 2004
    While .NET offers adequate support for the simple serialization cases, issues arise when you're attempting to support delegates and subscribers, versioning, and class hierarchies. . In addition, the introduction of generics in The .NET Framework breaks new ground in the complexity of the serialization task and the power of serialization tools. This article discusses these issues and related pitfalls, suggests techniques and workarounds that address them, and recommends when and how to best use the new serialization abilities.

  • Unit Testing: Mock Objects to the Rescue! Test Your .NET Code with NMock
    Mark Seemann - October 2004
    The problem: unit testing libraries, especially data access components, that have a complex set of dependencies. The solution: providing a dynamic mock implementation of your data access classes. Here the author explains just how to make testing easier and more reliable using NMock.

  • Data Points: Handling Data Concurrency Using ADO.NET, Part 2
    John Papa - October 2004
    Enterprise development has been moving towards a discon-nected model in recent years and ADO. NET development is no exception. While the disconnected model of the ADO. NET DataSet offers great flexibility, that adaptability also means looser control over data updates than you get with a connected data access model.

  • .NET Column: P/Invoke Revisited
    Jason Clark - October 2004
    In the July 2003 installment of the . NET column I covered the basics of Win32® interoperation with the Microsoft® . NET Framework (P/Invoke). Based on reader feedback, this topic is worthy of further coverage, so I have decided to revisit P/Invoke in this column.

  • Cutting Edge: Binary Serialization of DataSets
    Dino Esposito - October 2004
    The ADO. NET DataSet object plays an essential role in most of today's distributed, multitiered applications. Instances of the DataSet class are used to move data across the tiers and to exchange data with external services.

  • Service Station: Securing Web Services with WSE 2.0
    Aaron Skonnard - October 2004
    Beginning this month, The XML Files will run under the name Service Station. We have made this change so that the column can discuss broader topics such as Web services, service-oriented architecture, and the like.

  • Security Briefs: Password Minder Internals
    Keith Brown - October 2004
    In my last column I introduced Password Minder, the tool I use to manage all of my passwords. It generates a long, random password for each site I visit, and makes it possible for me to use the most complex passwords possible, without ever having to see the actual password material or type it in manually.

  • .NET Matters: ThreadPoolWait and HandleLeakTracker
    Stephen Toub - October 2004

  • Design Patterns: Simplify Distributed System Design Using the Command Pattern, MSMQ, and .NET
    Brad King - September 2004
    Service-oriented architecture is a great framework when you need to perform distributed computing tasks over the Internet. But when you want to perform processing inside your local network, a different solution may provide a better fit. That solution, based on the Command pattern, uses Windows services and Microsoft Message Queuing to implement a queued system that meets your needs better than a service-oriented solution. This article explains how to build it.

  • Data Points: Handling Data Concurrency Using ADO.NET
    John Papa - September 2004
    One of the key features of the ADO. NET DataSet is that it can be a self-contained and disconnected data store. It can contain the schema and data from several rowsets in DataTable objects as well as information about how to relate the DataTable objects—all in memory.

  • Test Run: Automate Testing of Your Stored Procs
    James McCaffrey - September 2004
    Many Windows®-based applications have a SQL Server™ back-end component that contains stored procedures. Although techniques to automatically test functions in the front-end code are well known, the techniques to write test automation for stored procedures are not.

  • Cutting Edge: Design Smarter Tracing for ASP.NET Pages
    Dino Esposito - September 2004
    Tracing is important to the success of your ASP. NET applications. When tracing is enabled for an ASP. NET page, a large chunk of runtime information is appended to the page's output for your perusal.

  • The ASP Column: What's in ASP.NET Config Files?
    George Shepherd - September 2004
    Even though you've been using ASP. NET for a while, how much do you really know about ASP. NET configuration files? While you've probably touched the Web. config file from time to time, there are some nuances involved in configuring ASP.

  • Bugslayer: Three Vital FXCop Rules
    John Robbins - September 2004
    In the June 2004 installment of the Bugslayer column, I introduced the amazing FxCop, which analyzes your . NET assemblies for errors and problems based on code that violates the . NET Design Guidelines.

  • GridView: Move Over DataGrid, There's a New Grid in Town!
    Dino Esposito - August 2004
    When incorporating the ASP.NET DataGrid control into your Web apps, common operations such as paging, sorting, editing, and deleting data require more effort than you might like to expend. But all that is about to change. The GridView control--the successor to the DataGrid-- extends the DataGrid's functionality it in a number of ways. First, it fully supports data source components and can automatically handle data operations, such as paging, sorting, and editing, as long as its bound data source object supports these capabilities. In addition, the GridView control offers some functional improvements over the DataGrid. Here DataGrid expert Dino Esposito introduces the GridView and explains all its long-awaited features.

  • Genetic Algorithms: Survival of the Fittest: Natural Selection with Windows Forms
    Brian Connolly - August 2004
    Genetic Programming is an evolutionary algorithm that employs reproduction and natural selection to breed better and better executable computer programs. It can create programs that implement subtle, non-intuitive solutions to complex problems. By taking a well-known example from the Genetic Programming community and implementing it with the .NET Framework, this article demonstrates that CodeDOM and Reflection provide all the facilities that are needed to do Genetic Programming effectively.

  • Web Parts: Use Windows SharePoint Services as a Platform for Building Collaborative Apps, Part 2
    Jason Masterman and Ted Pattison - August 2004
    Microsoft Office SharePoint Portal Server 2003, which is part of the Office System, lets you create and manage virtual servers, site collections, sites, workspaces, and users. You can also use the Windows SharePoint Services object model to design and implement user-targeted applications. In the second part of a two part series, the authors take a look at the WSS and SPS object models, Web Part Page anatomy, creating and deploying Web Parts, and Web Part security. They also discuss Web Part infrastructure and how to create custom Web Parts.

  • Virtual Server 2005: Program Customized Testing Environments Without Trashing Your Machine
    Ben Waldron - August 2004
    Efficient testing can require many different machine and server configurations but the effort needed to manage these test environments can take a toll. Microsoft Virtual Server 2005 simplifies the provisioning and management of testing environments. This article demonstrates how the extensive Virtual Server COM API can be used to create an automated application testing environment to make your testing chores a whole lot easier.

  • Data Points: Migrating from ADO to ADO.NET, Part 2
    John Papa - August 2004
    As you move forward with your use of ADO. NET, you'll need to know how to approach situations that you previously learned to handle in ADO and now have to tackle with ADO. NET. Just as n-tiered solutions developed using Visual Basic®, C++, and ASP often rely on ADO for their data access needs, Windows® Forms, Web Forms, and Web services rely on ADO.

  • Cutting Edge: Script Callbacks in ASP.NET
    Dino Esposito - August 2004
    If you're involved in Web development you may have faced a problem that you couldn't find a good solution for—making client-to-server calls outside the current page. For example, you might want to validate the content of a textbox against data stored on the server asynchronously, without interrupting the continuity of the work or without forcing a full page refresh, which is particularly heavy for UI-rich pages.

  • The XML Files: What's New in WSE 2.0
    Aaron Skonnard - August 2004
    Microsoft has recently released Web Services Enhancements for Microsoft® . NET (WSE) 2. 0. WSE 2. 0 provides extensions to the existing ASP. NET Web services framework (. asmx) as well as a standalone messaging framework that's completely transport independent.

  • Test Run: Test Automation for ASP.NET Web Apps with SSL
    James McCaffrey - August 2004
    If you're encrypting user data with Secure Sockets Layer (SSL) over HTTP and you want to test your Web applications programmatically you'll find that the techniques are not widely known. In this month's column I'll show you how to set up a test SSL server and write test automation that verifies the functionality of a simple but representative Web application.

  • Wicked Code: Foiling Session Hijacking Attempts
    Jeff Prosise - August 2004
    Let's face it: every minute of every day, someone, somewhere, is patrolling the Web looking for sites to hack. ASP. NET developers must constantly be on their guard to ensure attempted hacks can't be successful.

  • .NET Matters: Debugger Visualizations, Garbage Collection
    Stephen Toub - August 2004

  • { End Bracket }: C# to Visual Basic Translation Tool
    John Robbins - August 2004
    Having talked to thousands of developers who use the Microsoft . NET Framework, I've heard one consistent complaint: "I really wish all the samples were written in my programming language. " Nothing is more frustrating than having braved the wilds of Internet searches for a snippet of code that does exactly what you want but is written in a language you don't use.

  • User Preferences: Manage User Settings in Your .NET App with a Custom Preferences API
    Ray Djajadinata - July 2004
    There are plenty of options out there for managing user preferences including custom configuration files, the Windows registry, and the isolated storage. But each option has its pros and cons -- and a bad choice can make life difficult. In this article, the author evaluates various options and identifies the characteristics of a good preferences API. Based on those characteristics, he introduces an API that is specifically designed for preferences management, one that offers the best of all the options.

  • Web Services: Capturing and Analyzing Client Transaction Metrics for .NET-Based Web Services
    Brian Connolly - July 2004
    This article presents a general-purpose client quality reporting mechanism that can be used in any .NET-based transaction system that employs HTTP/SOAP. The design uses client response time and quality recording, upload of logs as SOAP headers attached to new transaction requests, and server handoff of these headers to a low priority queue for logging and analysis. This technique gives an enterprise near real-time information on actual end-user response times. These response times reflect network delays, client application overhead and server delays. By using this technique, enterprises can avoid the need to develop custom software to mine HTTP logs.

  • Web Q&A: Pop-Ups, Encrypting an ADO.NET Data Stream, and More
    Edited by Nancy Michell - July 2004

  • Data Points: Migrating from ADO to ADO.NET
    John Papa - July 2004
    In recent years ADO has taken the lead as the preferred method for implementing data access in Windows®-based applications. Huge numbers of ADO applications are in use today and many developers are well versed in ADO development.

  • Cutting Edge: Implement Custom Cache Dependencies in ASP.NET 1.x
    Dino Esposito - July 2004
    One of the most compelling improvements that ASP. NET brought to ASP programming was the Cache object. The Cache has some similarities to the Application object and is a container of global data (as opposed to session-specific data) that features a fair number of innovative characteristics.

  • The XML Files: Messages vs. Methods
    Aaron Skonnard - July 2004

  • Test Run: Using Combinations to Improve Your Software Test Case Generation
    James McCaffrey - July 2004

  • .NET Matters: How Microsoft Uses Reflection
    Edited by Stephen Toub - July 2004
    In this fourth installment of . NET Matters, I'm taking a breather from the Q&A format. Instead, this month I bring you stories from the trenches; developers in product groups within Microsoft describe how they use .

  • The Big Story: An Overview of the New Services, Controls, and Features in ASP.NET 2.0
    Jeff Prosise - June 2004
    ASP.NET has become a bit of a gold standard for Web programming. The upcoming version, ASP.NET 2.0 will have even more of the kinds of features that have made it the popular framework it is today. This article takes a broad look at those features, including what's new in data source controls, themes and skins, the DataGrid and its new functionality, managing roles, and other administrative tasks.

  • Security: Security Headaches? Take ASP.NET 2.0!
    Keith Brown - June 2004
    ASP.NET 2.0 provides significant advantages with respect to security, especially for folks developing Web sites that use Forms authentication. By providing a user profile repository with support for roles, Forms authentication will move beyond the purview of the ASP.NET internals guru, and should become much more broadly accessible. This article introduces security in ASP.NET 2.0 to give you a head start with upcoming features.

  • Portals: Unleash Your Site's Potential with Web Parts and Personalization in ASP.NET 2.0
    Steven A. Smith - June 2004
    ASP.NET 2.0 has addressed some of the most common problems developers face today with a suite of controls, components and IDE tools. One such issuer is maintaining preferences information about individual users of a Web application in a uniform manner. This article drills down into ASP.NET 2.0 to illustrate how it helps solve these problems far easier than is possible today, and demonstrates how these features can be combined to build powerful, personalized Websites in very little time.

  • Data: More Load, Less Code with the Data Enhancements of ASP.NET 2.0
    Dino Esposito - June 2004
    A data source control is a server control that wraps some basic functions of a data source - be it a SQL Server database, an XML document, an Excel worksheet, or a sitemap description. Through the services of a similar component, data-bound controls can fetch data as well as insert new records or update and delete existing ones. Data source controls enable a consistent model across a variety of data sources and dramatically reduce the amount of code needed to implement a two-way data-binding scenario. This article provides an introduction to data source controls and other related data binding features.

  • Master Pages: Master Your Site Design with Visual Inheritance and Page Templates
    Fritz Onion - June 2004
    Master pages in ASP.NET 2.0 solve a problem many Web developers have been solving on their own with a variety of techniques for years - providing a single master template for an entire site. This article covers the details of master pages, discussing their usage and implementation and how they are a natural evolution of custom techniques developers are using today.

  • Web Q&A: Visual Studio 2005, HTC Memory Problems, and More
    Edited by Nancy Michell - June 2004

  • Data Points: Contrasting the ADO.NET DataReader and DataSet
    John Papa - June 2004

  • Cutting Edge: Dress Your Controls for Success with ASP.NET 1.1 Themes, Part 2
    Dino Esposito - June 2004

  • .NET Column: Unexpected Errors in Managed Applications
    Jason Clark - June 2004

  • Bugslayer: Bad Code? FxCop to the Rescue
    John Robbins - June 2004

  • .NET Matters: XML Comments, Late-bound COM, and More
    Stephen Toub - June 2004

  • C# 2.0: Create Elegant Code with Anonymous Methods, Iterators, and Partial Classes
    Juval Lowy - May 2004
    C# 2.0 introduces a wealth of exiting new features, such as generics, iterators, partial classes and anonymous methods. While generics are the most talked-about feature especially for former classic C++ developers, the rest of the new features are important additions to your .NET development arsenal, enhancing power and improving overall productivity. This article is dedicated to all the new C# 2.0 capabilities besides generics to give you a good overall picture of the upcoming features.

  • .NET Framework 2.0: Craft a Rich UI for Your .NET App with Enhanced Windows Forms Support
    Michael Weinhardt and Chris Sells - May 2004
    The upcoming version of the .NET Framework offers a host of enhancements an order of magnitude over and above existing versions. In particular, developers writing Windows Forms benefit from a variety of new and improved features targeting development, deployment, increased productivity, and auto-generated code. This article covers some of the key new features including designer enhancements, new controls, data binding, and deployment to give you a taste of what's to come.

  • ClickOnce: Deploy and Update Your Smart Client Projects Using a Central Server
    Brian Noyes - May 2004
    ClickOnce is a new deployment technology that allows users to download and execute Windows-based client applications over the Web, a network share, or from a local disk. Users get the rich interactive and stateful experience of Windows Forms, but still have the ease of deployment and updates available to Web applications. ClickOnce applications can be run offline and support a variety of automatic and manual update scenarios.Learn all about it here.

  • Debugging: DataTips, Visualizers and Viewers Make Debugging .NET Code a Breeze
    Morgan Skinner - May 2004
    There is a whole host of new goodies in upcoming release of Visual Studio 2005 that will enhance your debugging experience. One such improvement will make it easy to visualize types within the debugger. This article discusses those improvements and covers debugger attributes and type visualizers. In addition, the author shows you how to extend the display of your own types with custom attributes and how to plug in an assembly to visualize.NET types built into the framework.

  • Data Points: Saving Parent-child Data in a Multitiered App Using ADO.NET
    John Papa - May 2004

  • The XML Files: XML Data Migration Case Study: GEDCOM
    Aaron Skonnard - May 2004

  • .NET Matters: Finalizers, Assembly Names, MethodInfo, and More
    Stephen Toub - May 2004

  • Testing: Perform Code Coverage Analysis with .NET to Ensure Thorough Application Testing
    James McCaffrey - April 2004
    When running your tests how do you know which parts of your product code are actually executed and tested? This article presents a complete system called Fundamental Function code coverage that operates at the method level. The author gives an overview of the system so you can understand code coverage principles, explains the key parts of the underlying code, and discusses how code coverage fits into the overall product development cycle. After reading this article you will be able to perform code coverage analysis on any .NET software system.

  • Test-Driven C#: Improve the Design and Flexibility of Your Project with Extreme Programming Techniques
    Will Stott and James Newkirk - April 2004
    Test-driven development (TDD) should be on every developer's radar screen because a comprehensive set of tests makes for maintainable code and frees you from having to create a perfect design up-front. This article explains how to perform TDD and takes you step-by-step through a number examples to get you started.

  • Stress Testing: Custom LoadGenerator Tool Identifies the Issues Your Application Faces Under Stress
    Brian Otto - April 2004
    It's easy to postpone stress testing when developing an application, and it's easy to forgo it altogether. Having an easy-to-use framework at your fingertips to conduct these tests can make the task far less painful. This article walks you through an application that eases the task of generating load for a variety of layers within an application.

  • Mobility: Add Keyboard Support to Compact Framework Apps by Trapping Windows Messages
    Alan Pulliam - April 2004
    The Compact Framework Control class doesn't provide direct access to Windows messages. However, with P/Invoke, a few lines of native code, and the Compact Framework MessageWindow class, it's still possible to access underlying Windows messages. This can be used to work around any .NET Framework features, including keyboard support, that are not included in the Compact Framework.

  • Web Q&A: JScript Leaks, Getting the XmlDataDocument, and ASPX Includes
    Edited by Nancy Michell - April 2004

  • Data Points: Creating Audit Tables, Invoking COM Objects, and More
    John Papa - April 2004
    Dealing with error handling between T-SQL and a calling application, evaluating when a field's value has changed, and creating auditing tables in SQL Server™ are all common issues that developers must tackle.

  • Cutting Edge: Image Generation Service for ASP.NET 1.1
    Dino Esposito - April 2004

  • .NET Matters: Const in C#, Exception Filters, IWin32Window, and More
    Stephen Toub - April 2004
    Welcome to . NET Matters. This new column will delve into the ins and outs of the Microsoft® . NET Framework, answering readers' questions on various topics related to its extensive libraries, languages, and the common language runtime.

  • Security Briefs: Beware of Fully Trusted Code
    Keith Brown - April 2004
    The vast majority of managed applications run with full trust, but based on my experience teaching . NET security to developers with a broad range of experience, most really don't understand the implications of fully trusted code.

  • Bugslayer: .NET Internationalization Utilities
    John Robbins - April 2004
    As you saw in last month's column, . NET internationalization support is excellent and allows you to move your application to a world audience quite easily. Before you jump into this month's discussion, you may want to go back and read the March column.

  • C# In-Depth: Harness the Features of C# to Power Your Scientific Computing Projects
    Fahad Gilani - March 2004
    The C# language has been used quite successfully in many kinds of projects, including Web, database, GUI, and more. One of the last frontiers for the application of C# code may well be scientific computing. But can C# measure up to the likes of FORTRAN and C++ for scientific and mathematical projects?In this article, the author answers that question by looking at the .NET common language runtime to determine how the JIT compiler, Microsoft intermediate language, and the garbage collector affect performance. He also considers C# data types, including arrays and matrices, along with other language features that play an important role in scientific computing applications.

  • Error Handling: Throwing Custom Exception Types from a Managed COM+ Server Application
    Bob DeRemer - March 2004
    Exception handling semantics in .NET are based on type, so you can create custom exceptions that have their own properties and methods. In .NET, exceptions are first-class citizens, and since they're the built-in error handling mechanism, all .NET-compliant languages must support exceptions. In addition, COM+ services are available to .NET code as Enterprise Services, so you can leverage exceptions in your Enterprise Services design.In this article the author describes custom exceptions, throwing exceptions across COM interop boundaries, and working with Enterprise Services.

  • Data Points: Exception-handling Techniques
    John Papa - March 2004

  • Cutting Edge: Personalization in ASP.NET 1.1
    Dino Esposito - March 2004

  • The XML Files: WS-Policy and WSE 2.0 Assertion Handlers
    Aaron Skonnard - March 2004

  • The ASP Column: Using SOAP Extensions in ASP.NET
    George Shepherd - March 2004

  • Bugslayer: Basics of .NET Internationalization
    John Robbins - March 2004

  • C++ Q&A: List View Mode, SetForegroundWindow, and Class Protection
    Paul DiLascia - March 2004

  • Types in Yukon: Managed UDTs Let You Extend the SQL Server Type System
    Peter W. DeBetta - February 2004
    The next version of SQL Server, code-named "Yukon," will offer enhanced support for user-defined types (UDTs). Because UDTs can be managed by the CLR, you can represent a wide variety of data structures to create types not possible with previous versions of SQL Server. With UDTs you can more precisely control the kind of data your type accepts, resulting in better data management. This article explores UDTs in "Yukon" and covers their design and implementation.

  • Standard I/O: Console Appplications in .NET, or Teaching a New Dog Old Tricks
    Michael Brook - February 2004
    The Microsoft .NET Framework is not just about Windows Forms and Web services. This article discusses the simplest kind of Framework-based application—the console app—along with the frequently overlooked constructs of standard input/output and the pipe. When designed carefully, console applications offer a surprisingly powerful way of solving complex programming problems. One of the more exciting aspects of this approach is that while each application in the pipe is fairly simple, the result of their interaction can be a relatively complex task. Here the author explores the ins and outs of writing these console apps.

  • Timers: Comparing the Timer Classes in the .NET Framework Class Library
    Alex Calvo - February 2004
    Timers often play an important role in both client applications and server-based components (including Windows services). Writing effective timer-driven managed code requires a clear understanding of program flow and the subtleties of the .NET threading model. The .NET Framework Class Library provides three different timer classes: System.Windows.Forms.Timer, System.Timers.Timer, and System.Threading.Timer. Each of these classes has been designed and optimized for use in different situations. This article examines the three timer classes and helps you gain an understanding of how and when each class should be used.

  • The ASP Column: Web Services: ATL Server Versus ASP.NET
    George Shepherd - February 2004

  • Wicked Code: Client-side Paging for DataGrids
    Jeff Prosise - February 2004

  • C++ Q&A: Color Support, Console Apps, and Saving User Settings
    Paul DiLascia - 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 Indigo: A Guide to Developing and Running Connected Systems with Indigo
    Don Box - January 2004
    This article describes a collection of new programming frameworks that are part of "Longhorn," the upcoming version of Windows. "Indigo," the code name for this framework, provides rich support for service-oriented design that is complementary to traditional object-oriented approaches. Indigo marries the best features of .NET Remoting, ASMX, and .NET Enterprise Services into a unified programming and administration model. Indigo's deep support for standard protocols, including HTTP, XML, and SOAP, makes it easier to integrate applications and services without sacrificing security or reliability.

  • Code Name Avalon: Create Real Apps Using New Code and Markup Model
    Charles Petzold - January 2004
    The presentation subsystem in the next version of Windows, code-named "Longhorn," offers powerful new capabilities to developers. This subsystem, code-named "Avalon," allows developers to take advantage of its capabilities through a new markup language code-named "XAML." In addition, modern object-oriented programming languages such as C# and Visual Basic .NET can be used to tie everything together. Because most applications written to Avalon will probably be a mix of XAML and programming code, this article discusses XAML tags used to control page layout along with the procedural code written to respond to events.

  • 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.

  • Cutting Edge: Extend the ASP.NET DataGrid with Client-side Behaviors
    Dino Esposito - January 2004

  • .NET Column: Practical Multithreading for Client Apps
    Jason Clark - January 2004

  • C++ Q&A: Get Logical Drives with VolInfo, Modifying the System Menu
    Paul DiLascia - January 2004

  • Remoting: Managing the Lifetime of Remote .NET Objects with Leasing and Sponsorship
    Juval Lowy - December 2003
    Leasing and sponsorship is the solution for managing the lifecycle of a remote object in .NET. Each object has a lease that prevents the local garbage collector from destroying it, and most distributed applications rely upon leasing. There are several ways in which objects and clients can extend the lease, including dedicated sponsor objects. In this article, the author explains leasing, shows how to configure it, and how it relates to the various remoting activation models. He then discusses design guidelines and options, along with their impact on throughput and performance. Additionally, he introduces a helper class used to automate the management of lease sponsors.

  • Office 2003: Host an Interactive Visio Drawing Surface in .NET Custom Clients
    Mai-lan Tomsen Bukovec and Blair Shaw - December 2003
    Microsoft Office Visio 2003 introduces a new drawing component that allows you to embed an interactive drawing surface into your application's user interface. You can drive the Visio drawing component from events in your host application or with data from a Web Service and an ADO.NET data adapter. The Visio drawing component supports the rich Visio application programming model, giving you control over how graphics are used and displayed on the drawing surface. This article explains how to embed the Visio drawing component into a C#-based Windows Forms client app that retrieves data from the Fabrikam 2.0 Web Service.

  • Cutting Edge: Custom Design-time Control Features in Visual Studio .NET
    Dino Esposito - December 2003

  • The XML Files: A Survey of Publicly Available Web Services at Microsoft
    Aaron Skonnard - December 2003

  • C++ Q&A: Docking the Menu Bar, Abstract Classes vs. Interfaces, and More
    Paul DiLascia - December 2003

  • Encrypt It: Keep Your Data Secure with the New Advanced Encryption Standard
    James McCaffrey - November 2003
    The Advanced Encryption Standard (AES) is a National Institute of Standards and Technology specification for the encryption of electronic data. It is expected to become the accepted means of encrypting digital information, including financial, telecommunications, and government data. This article presents an overview of AES and explains the algorithms it uses. Included is a complete C# implementation and examples of encrypting .NET data. After reading this article you will be able to encrypt data using AES, test AES-based software, and use AES encryption in your systems.

  • Secure It: WS-Security and Remoting Channel Sinks Give Message-Level Security to Your SOAP Packets
    Neeraj Srivastava - November 2003
    As more organizations adopt XML-based Web Services, the need for message-level security has become evident. WS-Security, now supported in the Microsoft .NET Framework, addresses this need. Using the WS-Security framework, developers can implement channel sinks to intercept Remoting messages as they pass through the .NET Remoting infrastructure. The sink can read the message, change it, and pass it along. During this process, the message can be signed for added security. This article explains how to implement a Remoting channel sink that will modify the Remoting message by including a UserName token in the header, then sign the body using the token.

  • Obfuscate It: Thwart Reverse Engineering of Your Visual Basic .NET or C# Code
    Gabriel Torok and Bill Leach - November 2003
    One of the advantages of the .NET architecture is that assemblies built with it contain lots of useful information that can be recovered using ILDASM, the intermediate language disassembler. A side effect, though, is that someone with access to your binaries can recover a good approximation of the original source code. Here the authors present program obfuscation as a way to deter reverse engineering. In addition, they discuss the different types of obfuscation technologies available and demonstrate the new obfuscation tool that is included in Visual Studio .NET 2003.

  • Web Q&A: Secure Passwords, Nested XML, and More
    Edited by Nancy Michell - November 2003

  • Cutting Edge: Custom Provider Controls
    Dino Esposito - November 2003

  • The ASP Column: ATL Server Versus ASP.NET
    George Shepherd - November 2003

  • Bugslayer: Google from Visual Studio .NET
    John Robbins - November 2003

  • Tablet PC: Achieve the Illusion of Handwriting on Paper When Using the Managed INK API
    Carlos C. Tapang - October 2003
    Creating the illusion of a pen writing on paper is no easy software task. Fortunately, the .NET Framework hosts Tablet PC extensions, which lets you create ink-aware applications for the Tablet PC. This API allows applications to draw strokes on the screen and perform a variety of tasks including document markup, storage, and transmission.This article shows you how to handle a couple of inking events as used in the InkClipboard sample. Later, it discusses how to avoid common pitfalls including too frequent redrawing, which causes the ink flow to lag behind the pen movements, diminishing the illusion of ink on paper.

  • Plug-Ins: Let Users Add Functionality to Your .NET Applications with Macros and Plug-Ins
    Jason Clark - October 2003
    Most user applications benefit from the ability to be extended by other developers. It's often easier and more efficient to extend an existing application that users are already familiar with and trained on than it is to develop one from scratch. Thus, extensibility makes your application more attractive. You can build extensibility into your application by supporting features like plug-ins or macros. This is easily accomplished using the .NET Framework even if the core application isn't a .NET Framework app. In this article, the author describes extensibility features of the .NET Framework including late binding and reflection and how to use them, along with plug-in security considerations.

  • Data Points: Exploring the ADO.NET DataRow
    John Papa - October 2003

  • Cutting Edge: Nested Grids for Hierarchical Data
    Dino Esposito - October 2003

  • .NET Column: More on Generics in the CLR
    Jason Clark - October 2003

  • C++ Q&A: Getting a Menu Handle, Declaring GetParam, and Filtering File Names
    Paul DiLascia - October 2003

  • Office 2003: Bring the Power of Visual Studio .NET to Business Solutions Built with Microsoft Office
    Ken Getz and Brian A. Randell - September 2003
    Microsoft Visual Studio Tools for the Microsoft Office System is a new technology that brings the advanced features of Visual Studio .NET and the .NET Framework to apps built on Microsoft Word 2003 and Excel 2003. Now you can use Visual Basic .NET and C# to write document-centric, managed code solutions that run in-process with Word 2003 or Excel 2003, taking advantage of the rich object models they expose. Along the way you get the benefits of the managed environment in which a fully compiled .NET-based application executes, including code access security.

  • .NET Remoting: Create a Custom Marshaling Implementation Using .NET Remoting and COM Interop
    Jim Sievert - September 2003
    The .NET Framework offers several methods for customizing the presentation of native .NET and COM object types. One such technique, custom marshaling, refers to the notion of specializing object type presentations. There are times, like when a legacy COM component needs to implement a new interface or when you need to make calls across process or machine boundaries, when custom marshaling saves the day. Elements of COM Interop permit the customizing of COM types while .NET Remoting offers the developer the ability to tailor native .NET types. This article examines these techniques.

  • Coroutines: Implementing Coroutines for .NET by Wrapping the Unmanaged Fiber API
    Ajai Shankar - September 2003
    Coroutines are a powerful feature of many programming languages including CLU, Scheme, Python, Ruby, and ICON. Coroutines can save processor overhead and reduce redundancy because they allow you to stop execution of a procedure midstream, return a value, and resume exactly where the procedure left off.This article shows how coroutines can be implemented for the .NET Framework by using the Fiber API and Managed Extensions for C++, and how they can be easily used with other .NET-compliant languages. This article also shows a sophisticated use of the runtime host for running multiple managed threads on a single OS thread.

  • Data Points: Developing Apps with the .NET Compact Framework, SQL Server CE, and Replication
    John Papa - September 2003

  • Cutting Edge: Managing Your Remote Windows Clipboard
    Dino Esposito - September 2003

  • The XML Files: Introducing the Web Services Enhancements 2.0 Messaging API
    Aaron Skonnard - September 2003

  • The ASP Column: The Internet Explorer Toolbar Control
    George Shepherd - September 2003

  • .NET Column: Introducing Generics in the CLR
    Jason Clark - September 2003

  • C++ Q&A: Retrieving Hidden Path Names, Mouse Events in C#
    Paul DiLascia - September 2003

  • DataGrid: Tailor Your DataGrid Apps Using Table Style and Custom Column Style Objects
    Kristy Saunders - August 2003
    One of the most enduring challenges in writing user interfaces is figuring out how to display large amounts of data efficiently and intuitively without bewildering the user. The problem becomes particularly thorny when the interface must reflect hierarchical relationships within the data that the user needs to modify. The Windows Forms DataGrid control gives developers a powerful and flexible tool to meet this challenge. This article explains its basic operations and shows how to extend the DataGrid to display columns of data in an application-appropriate manner.

  • XSLT: Simplify Development and Maintenance of Microsoft .NET Projects with Code Generation Techniques
    Peter Ashley - August 2003
    Code generation techniques using technologies such as XSLT are playing an increasingly important part in software projects as they support the development of a rapidly maintainable code base. This article discusses some of the benefits and possible applications of code generation.To demonstrate these techniques the author develops a Web Forms application that supports the maintenance of records in a SQL Server database, using the database's own metadata to drive the generation process. The SQL Server database schema is extracted using SQLXML 3.0 data access and processed through XSLT stylesheets that generate both a database access layer and a Web Forms user interface with query and update pages.

  • DCOM Interop: Generate Custom Managed C++ Wrappers for Easier COM Interoperation Using DCOMSuds
    Vishwas Lele - August 2003
    Now that you're writing managed code, you'll certainly want to use your existing COM components, but you can't simply call them directly. Instead, you have to wrap the COM component in a runtime-callable wrapper that acts as a proxy between the component and your managed code. While the CLR provides wrapper classes for this purpose, there will be times when you'll want custom objects to wrap your COM components. One way to get the low-level access you need to precisely control resource cleanup, pass security information, and get access to CLR features is to write your own wrapper class in managed C++. This article shows you how.

  • Web Services: Extend the ASP.NET WebMethod Framework with Business Rules Validation
    Aaron Skonnard and Dan Sullivan - August 2003
    In an earlier article the authors showed how to build a custom WebMethods extension that provides XML Schema validation, a function that is lacking in ASP.NET. In the process they established a foundation for enforcing business rules during the deserialization of XML data. The technique, which is described in this article, uses declarative XPath assertions to test business rule compliance.In building this business rules validation engine, the authors integrate the validation descriptions into the WSDL file that is automatically generated by the WebMethod infrastructure. Finally, they demonstrate how to extend wsdl.exe, the tool that generates WebMethod proxy/server code from WSDL files, to make use of their extensions.

  • Cutting Edge: Creating a Multi-table DataGrid in ASP.NET
    Dino Esposito - August 2003
    If you bind a multi-table DataSet to a DataGrid, only the first table is recognized. Here Dino Esposito writes a custom solution the the multi-table problem.

  • Security Briefs: Hashing Passwords, The AllowPartiallyTrustedCallers Attribute
    Keith Brown - August 2003
    Keith Brown describes how yo can hash passwords when you want to store them in your own custom database, and when to use the AllowPartiallyTrustedCallers attribure on your assembly.

  • DirectX 9.0: Introducing the New Managed Direct3D Graphics API in the .NET Framework
    Yahya H. Mirza and Henry da Costa - July 2003
    DirectX 9.0 is the latest evolution of the Microsoft 3D graphics technology for Windows. Direct3D, a major component of the DirectX Graphics subsystem, has evolved so rapidly in the last few years that the underlying programming paradigm has changed quite a bit from its origin. This article introduces the fundamental concepts of the unmanaged Direct3D architecture and illustrates how the managed Direct3D layer abstracts the unmanaged layer. Also, the author describes the Geometry, Texture, Device, and other classes and uses code from the Samples SDK.

  • Vector Graphics: Build Flexible, Lightweight XML-Based Images for ASP.NET Using Scalable Vector Graphics
    Dennis Forbes - July 2003
    Scalable Vector Graphics (SVG), a W3C graphics standard built around XML, is one of several vector graphics technologies that allows fast, lightweight drawings such as charts and graphs to be rendered on the fly in an appropriate viewer. There are many advantages to such vector graphics, including conservation of bandwidth and storage media, and flexibility. This article explains these benefits and shows you how to easily add powerful, dynamic, interactive visual elements to your Web applications.

  • Web Services: Extend the ASP.NET WebMethod Framework by Adding XML Schema Validation
    Aaron Skonnard and Dan Sullivan - July 2003
    WebMethods make the development of XML Web Services easier by encapsulating a good deal of functionality, but there is still a lot of underlying XML processing that you have to be responsible for. For example, WebMethods do not validate messages against the implied schema. Because they are not validated, the response that's returned can result in unintended consequences. To address this, the authors extend the WebMethod framework by adding XML Schema validation through a custom SoapExtension class.

  • Data Points: Managing Hierarchical Inserts in ASP.NET and ADO.NET
    John Papa - July 2003

  • Cutting Edge: Working with Images in the .NET Framework
    Dino Esposito - July 2003

  • The XML Files: XML Namespace Collisions, XmlNodeList and Deserialization, and More
    Aaron Skonnard - July 2003

  • .NET Column: Calling Win32 DLLs in C# with P/Invoke
    Jason Clark - July 2003

  • C++ Q&A: Parent and Child Window Captions, More MoveDlg
    Paul DiLascia - July 2003

  • ASP.NET Pipeline: Use Threads and Build Asynchronous Handlers in Your Server-Side Web Code
    Fritz Onion - June 2003
    Fortunately for developers, threading in ASP.NET is a lot easier than it was in ASP. In this article, the author takes a look at threading in the ASP.NET HTTP pipeline, and explains how threads are managed efficiently without the involvement of the developer. The article considers how the common language runtime threadpool is used by ASP.NET to service requests, looks at the pooling mechanisms used for handlers, modules, and applications, and covers both IIS 5.0 and IIS 6.0 and how they differ in their approach to request processing and thread allocation. Finally, how and when to use asynchronous handlers is discussed for developers who still need to use threads in their own applications.

  • Zip Your Data: Using the Zip Classes in the J# Class Libraries to Compress Files and Data with C#
    Ianier Munoz - June 2003
    Zip compression lets you save space and network bandwidth when storing files or sending them over the wire. In addition, you don't lose the directory structure of folders you Zip, which makes it a pretty useful compression scheme. The C# language doesn't have any classes that let you manipulate Zip files, but since .NET-targeted languages can share class implementations, and J# exposes classes in the namespace, you can get to those classes in your C# code. This article explains how to use the Microsoft J# class libraries to create an application in C# that compresses and decompresses Zip files. It also shows other unique parts of the J# runtime you can use from any .NET-compliant language to save some coding.

  • .NET Remoting: Secure Your .NET Remoting Traffic by Writing an Asymmetric Encryption Channel Sink
    Stephen Toub - June 2003
    As .NET Remoting gains popularity in the enterprise space, it must meet business demands for trustworthy computing. Remoting traffic can be secured when objects are hosted in IIS, but when they aren't hosted in IIS, custom security solutions can be developed to secure them. This article provides an in-depth look at writing channel sinks for .NET. It also details the flow of data through custom channel sinks and explains the kinds of manipulations that can be performed on that data.

  • Smart Cleanup: Achieve More Reliable Resource Management with Our Custom C++ Classes
    Eric Niebler - June 2003
    Managing resources in C++ is not easy. When you're unsuccessful, your app can leak all kinds of resources including file system handles, database connections, and, of course, memory. Even in garbage-collected languages like Managed C++, resource management is difficult because garbage collection only deals with memory management, not the other resources that cause performance problems.In this article, the author describes the SmartAny template library he created, which uses a policy-based approach to dynamic resource management. Readers will learn how to use the SmartAny classes and policies to ensure the proper cleanup of their resources, be they files, OS handles, or native and unmanaged objects.

  • Data Points: Techniques in Filling ADO.NET DataTables: Performing Your Own Analysis
    John Papa - June 2003
    How do you know which technique is best for retrieving data and populating a DataSet in ADO.NET?. Since the Microsoft .NET Framework offers so many choices on how to write the code, many developers are now taking a close look at the different options. See what they are.

  • The XML Files: Advanced Type Mappings
    Aaron Skonnard - June 2003
    Can XmlSerializer deal with choice compositors? How about mixed content models? XmlSerializer won't serialize objects that implement IDictionary by default, so how do you get arount it? And more.

  • Cutting Edge: ASP.NET Controls Templates
    Dino Esposito - June 2003
    It's easy to create a custom control in ASP.NET by deriving a new class from an already existing control. Creating a new ASP.NET control from scratch, on the other hand, is more challenging. When you need a Web server control and none of the existing ones meet your requirements, you can derive from one of the base classes - Control or WebControl. Try it out.

  • The ASP Column: Tree Controls with XSL
    George Shepherd - June 2003
    Manipulating the TreeView server-side control is very much like programming any other ASP.NET server-side control. There are a number of properties, methods, and events that are available both programmatically and through the designer. Find out how to take advantage of it.

  • .NET Column: The CLR's Thread Pool
    Jeffrey Richter - June 2003
    How does the thread pool work in the CLR?

  • C++ Q&A: Locking Column Headers, Implementing Singleton Classes
    Paul DiLascia - June 2003
    Prevent the sizing of the column headers in an ATL composite control. Also, see how you can share a small amount of simple data among multiple processes running on the same machine without Remoting.

  • Real-World XML: Manipulate XML Data Easily with Integrated Readers and Writers in the .NET Framework
    Dino Esposito - May 2003
    In the .NET Framework, XmlTextReader and XmlTextWriter provide for XML-driven reading and writing operations. In this article, the author discusses the architecture of readers and how they relate to XMLDOM and SAX parsers. He also shows how to use readers to parse and validate XML documents, how to leverage writers to create well-formed documents, and how to optimize the processing of large XML documents using functions to read and write Base64 and BinHex-encoded text. He then reviews how to implement a stream-based read/write parser that combines the functions of a reader and a writer into a single class.

  • Debugging Tool: Build a Logging and Event Viewing Library to Help Debug Your .NET Framework-based App
    Daryn Kiely - May 2003
    Building a basic, reusable application framework can make development quicker and easier. This allows you to focus more on the problems at hand and less on the repetitive tasks involved in building any application. In this article, the author presents a framework that provides facilities to access the registry and an extensible framework for logging messages to a console window or the Event Viewer. This reusable framework can be included as a library in your projects, allowing you to display an enhanced, color-coded message log and dynamically change logging levels.

  • Visual Studio .NET: Building Windows Forms Controls and Components with Rich Design-Time Features, Part 2
    Michael Weinhardt and Chris Sells - May 2003
    This is the second of two articles discussing the extremely rich design-time features of the .NET Framework. Part 1 discussed the basics, showing you where to start and how to extend your control implementation through attributes and interfaces, as well as their effects on the property browser, code serialization, and other controls. Part 2 continues the journey by concentrating on design-time functionality that you can implement beyond your components and controls, including TypeConverters, UITypeEditors, and Designers. It would be impossible to cover everything you can do in two short articles, which is a testament to just how all-encompassing and flexible the design-time capability of the .NET Framework is.

  • Cutting Edge: Form-based Programming in ASP.NET
    Dino Esposito - May 2003
    One of the most common snags that ASP developers encounter when they first approach ASP.NET is that managed Web applications must be written according to a single-form interface model. Find out how it works.

  • House of Web Services: Mandatory Headers in ASP.NET Web Services
    Tim Ewald - May 2003
    The ASP.NET Web Services infrastructure includes support for programming with SOAP message headers. Unfortunately, the model for handling mandatory headers is flawed in that you need to write additional code so that a Web Service will not execute when a mandatory header is not processed. This column explores a specific problem that arises when you deal with mandatory SOAP handles and presents three solutions.

  • C++ Q&A: Window Destruction in the .NET Framework
    Paul DiLascia - May 2003
    If a window is destroyed, does the .NET Framework immediately destroy the corresponding Form, or does it wait until a garbage collection to do this? How can you release my resources as soon as the window is destroyed? This month Paul DiLascia gives you the answers.

  • Visual Studio .NET: Building Windows Forms Controls and Components with Rich Design-Time Features
    Michael Weinhardt and Chris Sells - April 2003
    Visual Studio .NET provides support for designing rich features into your controls and components, allowing you to set properties, set form placement, inherit from base classes, and much more. So how does Visual Studio .NET do all this? What does the Windows Forms designer do? What's the difference between a control and a component? How does Visual Studio integrate your controls so that they can access features of the .NET Framework?In this article, the authors answer these common questions by building a clock control and taking the reader along for the ride. In building the control, hosts and containers are illustrated, the property browser is explained, debugging is discussed, and a general overview of the design-time infrastructure is presented.

  • ASP.NET: Nine Options for Managing Persistent User State in Your ASP.NET Application
    Steven Smith - April 2003
    ASP.NET provides many different ways to persist data between user requests. You can use the Application object, cookies, hidden fields, the Session or Cache objects, and lots of other methods. Deciding when to use each of these can sometimes be difficult. This article will introduce the aforementioned techniques and present some guidelines on when to use them. Although many of these techniques existed in classic ASP, best practices for when to use them have changed with the introduction of the .NET Framework. To persist data in ASP.NET, you'll have to adjust what you learned previously about handling state in ASP.

  • Cutting Edge: MyTracer Monitors and Traces ASP.NET Apps
    Dino Esposito - April 2003
    The Microsoft® . NET Framework comes with a rich set of programming tools for debugging and tracing applications. I'm not talking about integrated debuggers; I'm referring to software components that you use in the development cycle.

  • Wicked Code: Supporting Database Cache Dependencies in ASP.NET
    Jeff Prosise - April 2003
    Developers love the ASP. NET application cache. One reason they love it is that ASP. NET lets them create dependencies between items placed in the cache and files in the file system. If a file targeted by a dependency changes, ASP.

  • C++ Q&A: Desktop Location, sscanf Equivalents in C#, and More
    Paul DiLascia - April 2003

  • Visual Studio .NET: What You Need to Know Today About the New and Upgraded Features in Visual Studio .NET 2003
    Carl Franklin - March 2003
    Any time an upgrade of a favorite tool is released, questions about compatibility, versioning, and changes in methodology abound. The release of Visual Studio .NET 2003 is no exception. Developers will be relieved to learn that breaking changes have been kept to a minimum, and delighted to learn that important new features, like Visual J#, have been added. These and other new features of the .NET Framework 1.1 and Visual Studio .NET 2003, including mobile support and improved debugging, are discussed here.

  • Windows Forms: .NET Framework 1.1 Provides Expanded Namespace, Security, and Language Support for Your Projects
    Chris Sells - March 2003
    With the much-anticipated release of the .NET Framework 1.1, developers are eager to know what's been added to their programming bag of tricks. In this article, the author focuses on new developments in Windows Forms, such as namespace additions, support for hosting managed controls in unmanaged clients, and designer support for C++ and J#. Integrated access to the Compact Framework and new mobile code security settings also make this release noteworthy. Along with these features, the author reviews the best ways to handle multiple versions of the common language runtime and highlights some potential pitfalls.

  • Site Skinning: Rich XML Classes Let Users Personalize Their Visual Experience on Your ASP.NET Site
    Harry Pierson - March 2003
    One way that Web sites and applications become better able to meet the needs of customers is by allowing them to personalize their experience. For Web sites, this means displaying the content as the user wants to see it. For rich-client applications, this often means allowing the user to choose the user interface through a technique known as skinning, which is similar to themes in Windows XP. This article shows how you can apply skinning to Web sites, wrapping their functionality in a new user interface. The technique uses the rich XML classes in the .NET Framework and the built-in extensibility of ASP.NET.

  • Contexts in .NET: Decouple Components by Injecting Custom Services into Your Object's Interception Chain
    Juval Lowy - March 2003
    The .NET Framework can use contexts as an object's execution scope and intercept calls going to and from the object, similar to the way COM+ provides component services. What is new with this mechanism is that the runtime allows developers to take part in the interception chain and add powerful services, thus extending existing component services. This in turn decouples the business logic from the system plumbing and simplifies long-term maintenance. Presently, .NET contexts and interception are undocumented aspects of .NET. This article presents the underlying interception architecture and message processing, explains custom context attributes, and walks through a custom interception-based component service.

  • Web Q&A: IDs as Anchors, Preventing Search, and More
    Edited by Nancy Michell - March 2003

  • The XML Files: Merging XML Files, Schema Validation, and More
    Aaron Skonnard - March 2003

  • Cutting Edge: Customize Your Open File Dialog
    Dino Esposito - March 2003
    Displaying an Open File dialog is certainly easy in the Microsoft® . NET Framework with Windows® Forms, but the resulting window is not as customizable as when you create it through the Win32® API. With Windows 2000, Microsoft added a nice feature—the places bar, which is the vertical toolbar that appears on the left side of the window to let you select a frequently visited folder.

  • Design Patterns: Creating Dynamic Factories in .NET Using Reflection
    Romi Kovacs - March 2003
    Design patterns are a powerful tool for designing flexible soft-ware. They provide well-tested solutions to recurring software design problems. One such widely used pattern is the Concrete Factory.

  • House of Web Services: Accessing Raw SOAP Messages in ASP.NET Web Services
    Tim Ewald - March 2003
    Web Services exchange XML messages. Most of today's Web Service toolkits do their best to hide this fact from developers, by exposing a Web Service's behavior as method invocations against objects instead.

  • C++ Q&A: Find Icons, Launch an App from List Control, and More
    Paul DiLascia - March 2003

  • Class Templates: Bring the Power of Templates to Your .NET Applications with the CodeDOM Namespace
    Adam J. Steinert - February 2003
    In the .NET Framework, the CodeDOM object model can represent code in a variety of languages. This article examines how source code templates written with the Framework's System.CodeDom and System.CodeDom.Compiler namespaces allow developers to create reusable boilerplate source code that can be shared between projects. Components designed via templates improve productivity and shorten development time.Here C++-style classes and templates are simulated and code is generated in multiple languages through the creation of CodeDOM object graphs. Compiling object graphs and formatting output code are also explained.

  • BITS: Write Auto-Updating Apps with .NET and the Background Intelligent Transfer Service API
    Jason Clark - February 2003
    Both the .NET Framework and Windows have some very interesting APIs for creating applications that are capable of updating themselves automatically over a network. There are many advantages to writing your application to update itself like Windows Update does, including convenience for your users, from easier maintenance to network administration. Automatic updates require attention to factors such as discovery, security, and file replacement. In this article, the author covers the BITS API as well as a number of features of the .NET Framework that take care of these facets of auto-updating using the same facilities that the Windows Update uses.

  • Printing: Preview and Print from Your Windows Forms App with the .NET Printing Namespace
    Alex Calvo - February 2003
    Printing is an integral part of every complete Windows-based application. Providing robust printing capabilities in these applications has often proved to be a tedious chore. Now, printing from Windows Forms with the .NET Framework means you must adopt a document-centric approach, resulting in cleaner and more manageable code. While the System.Windows.Forms namespace provides seamless integration with all the standard print dialogs (such as Print Preview, Page Setup, and Print), the System.Drawing.Printing namespace offers numerous classes for extensibility and customization. These classes, and how they provide access to printing capabilities, are covered here. Other useful techniques, such as printing in the background to allow the user to continue other tasks, is also explained.

  • Windows Forms: Give Your .NET-based Application a Fast and Responsive UI with Multiple Threads
    Ian Griffiths - February 2003
    If your application performs any non-UI processing on the thread that controls the user interface, it may make the app seem slow and sluggish, frustrating users. But writing multithreaded apps for Windows has long been restricted to C++ developers. Now with the .NET Framework, you can take advantage of multiple threads in C# to control the flow of instructions in your programs and isolate the UI thread for a fast and snappy user interface. This article shows you how. Also, it discusses the pitfalls of multiple threads and presents a framework for safe concurrent thread execution.

  • Web-Aware Apps: Build Hyperlinks into Your Client App with the Windows Forms LinkLabel Control
    Dan Hurwitz - February 2003
    LinkLabels are Windows Forms controls that enable a user to hyperlink to a URL that points to either the Web or the local directory system. While the SDK documentation discusses the control, it does not demonstrate how linking is accomplished, nor does it outline the power and flexibility the control provides. This article fills those gaps, showing how to link using the LinkLabel control. It also shows the flexibility of this control for the programmer using the .NET Framework. In addition, the author covers the large number of properties that allow you to customize your controls and accurately place them. Their built-in behaviors are also discussed, along with their use in both Visual Basic .NET and C#.

  • The XML Files: XPath Selections and Custom Functions, and More
    Aaron Skonnard - February 2003

  • Cutting Edge: The ASP.NET View State
    Dino Esposito - February 2003
    In ASP. NET pages, the view state represents the state of the page when it was last processed on the server. It's used to build a call context and retain values across two successive requests for the same page.

  • The ASP Column: Using the Internet Explorer WebControls
    George Shepherd - February 2003
    During the lifespan of ASP, there have been many technologies developed for making browser-based user interface development easier. For example, during the early days of classic ASP development, keeping a browser-based UI consistent required many conditional statements into the ASP script.

  • C++ Q&A: Singleton Class Private Constructor, C# Singleton Class, and More
    Paul DiLascia - February 2003

  • Design: Inspect and Optimize Your Program's Memory Usage with the .NET Profiler API
    Jay Hilyard - January 2003
    Developers using .NET often make memory leak tracking a low priority because the common language runtime takes care of garbage collection. What few developers realize, however, is that their objects' lifespans, along with their size and what other objects have been instantiated, all affect how they are cleaned up. Depending on the particular circumstances, these combinations can negatively affect performance, especially over the lifetime of an application. This article presents a way for developers to see memory usage and understand garbage collection using the .NET Profiler API. Along the way, a sample application to demonstrate these principles is built.

  • Test: Build Quick and Easy UI Test Automation Suites with Visual Studio .NET
    James McCaffrey - January 2003
    The .NET Framework provides a surprising new way to quickly and easily create user interface test automation. By using objects in the System.Reflection and System.Threading namespaces, you can write automated tests in minutes instead of hours. This article walks you through the building of a typical Windows-based application that will be used as the test subject. The author then runs through the creation of a C#-based test tool that simulates clicking the test app's UI controls and checks the application's state. After the tool is built, the author explains in detail how it works so you can modify and extend it for your own use.

  • Go Mobile: Create Compact, Robust Mobile Apps with SQL Server CE 2.0 and the .NET Compact Framework
    Mark Brown and David Meunier - January 2003
    Developers have myriad options when it comes to creating solutions for mobile devices. One of the greatest challenges facing mobile developers is finding a compact yet robust local storage solution. SQL Server CE 2.0 promises to deliver on both fronts. This new release represents a tremendous leap in terms of features and performance over its predecessor. This article will review some of the platform and tools choices developers have today. The authors will compare and contrast the significant new features in SQL Server CE 2.0 with the previous release. Following that, they will build a sample app for illustration.

  • The XML Files: Introducing XPath 2.0
    Aaron Skonnard - January 2003
    Over two years ago in one of the first installments of this column, I wrote about XPath version 1. 0 (see The XML Files: Addressing Infosets with XPath for a quick review). As stated in the original specification: "XPath is a language for addressing parts of an XML document.

  • Data Points: Expressions in ADO.NET
    John Papa - January 2003
    Managing relations in a database became a whole lot easier with ADO. NET. Instead of returning a single rowset to a data store, you can return a series of rowsets and relate them within a DataSet. There are numerous advantages to using related DataTables in ADO.

  • Cutting Edge: ASP. NET Client-side Hosting with Cassini
    Dino Esposito - January 2003
    In the September and October 2000 issues of MSDN® Magazine I discussed how to build a client-side environment for ASP applications; that is, a serverless environment to run ASP pages (see Cutting Edge: A Client-side Environment for ASP Pages and Cutting Edge: A Client-side Environment for ASP Pages—Part 2).

  • .NET Column: Safe Thread Synchronization
    Jeffrey Richter - January 2003
    By far, the most common use of thread synchronization is to ensure mutually exclusive access to a shared resource by multiple threads. In the Win32® API, the CRITICAL_SECTION structure and associated functions offers the fastest and most efficient way to synchronize threads for mutually exclusive access when the threads are all running in a single process.

  • Design: Place XML Message Design Ahead of Schema Planning to Improve Web Service Interoperability
    Yasser Shohoud - December 2002
    Web Services are all about exchanging data in the form of XML messages. If you were about to design a database schema, you probably wouldn't let your tool do it for you. You'd hand-tool it yourself to ensure maximum efficiency. In this article, the author maintains that designing a Web Service should be no different. You should know what kind of data will be returned by Web Service requests and use the structure of that data to design the most efficient message format. Here you'll learn how to make that determination and how to build your Web Service around the message structure.

  • XML Schemas: Take Advantage of Existing External XML Schemas with a Custom Import Framework in ASP.NET
    Scott Short - December 2002
    Over the years, many industry-standard XML schemas and dialects have been developed. These industry-specific schemas embrace the original purpose of XML and are extremely valuable in promoting and supporting B2B interaction. Unfortunately, the ASP.NET Web Services runtime does not allow developers to directly reference external schemas from within their XML Web Services interface (the WSDL file). This article builds an external schema framework as an extension to the ASP.NET Web Services runtime to enable you to reference external schemas within your XML Web Service interface.

  • Provisioning: Use Web Services Provisioning to Control Access, Usage, and Billing on Your Site
    Chandu Thota - December 2002
    Building Web Services to provide enterprise-level solutions is only the first step. You need to take care of the infrastructure aspects of your solution as well, including provisioning, billing, security, and reporting. In this article, the author uses the .NET Framework and SQL Server 2000 to design a provisioning system that will take care of all these housekeeping tasks. He discusses the general requirements of a Web Service provisioning system, walks through the implementation, and then outlines various scenarios for putting this system to work.

  • The XML Files: WSDL, Web Services, and More
    Aaron Skonnard - December 2002

  • Cutting Edge: Binary Serialization of ADO.NET Objects
    Dino Esposito - December 2002
    One of the key elements that makes ADO. NET superior to ADO is the level of integration with XML. In ADO, XML is just an I/O format. In addition, the ADO XML format is totally inflexible and doesn't allow any type of customization.

  • .NET GUI Bliss: Streamline Your Code and Simplify Localization Using an XML-Based GUI Language Parser
    Paul DiLascia - November 2002
    While Windows Forms in .NET has lots of cool features, if you're used to MFC, there are a couple of things you'll find missing, like doc/view, command routing, and UI update. The .NET answer to this is a code generator that writes new code for every single element. But there's a better way. In this article, Paul DiLascia shows how to develop an XML-based GUI language parser for .NET that lets you code resources, menus, toolbars, and status bars in XML instead of with procedural code. He also shows how a user interface based on XML can easily be localized using standard .NET techniques, and introduces his very own library, MotLib.NET, with lots of GUI goodies for your programming pleasure.

  • Web Q&A: Mobile Internet Toolkit versus Smart Device Extensions, SSL Glitch Again, and More
    Edited by Nancy Michell - November 2002

  • The XML Files: WebMethod Validation, SOAP Validation, XmlSerializer, One-way Operations, and More
    Aaron Skonnard - November 2002

  • Data Points: DataRelations in ADO.NET
    John Papa - November 2002
    One of the biggest differences between traditional ADO and ADO. NET is that the rowsets stored within ADO. NET can be truly relational. For example, a DataSet can store one DataTable containing customers and another DataTable containing the customers' orders.

  • Cutting Edge: Using Windows Hooks to Enhance MessageBox in .NET
    Dino Esposito - November 2002
    It's fairly safe to assume that all programmers working in Windows® environments are familiar with MessageBox. The MessageBox function displays a message through a popup dialog box and lets programmers add dialog buttons and icons to the message to improve user feedback.

  • C++ Q&A: System Tray Balloon Tips and Freeing Resources Quickly in .NET
    Paul DiLascia - November 2002

  • Visual Studio .NET: Top Ten Cool Features of Visual Studio .NET Help You Go From Geek to Guru
    Jon Flanders and Chris Sells - October 2002
    Visual Studio .NET has lots of cool features. Obviously, it supports languages that target the common language runtime, like C# and Visual Basic .NET, and it lets you write CLR-managed code. But did you know that there are features of the environment itself, independent of the language features, that earn Visual Studio .NET the cool tool stamp of approval?In this article the authors count down their favorite environment features—the ones they think every developer will applaud. They include support for debugging stored procedures, project reference management, metadata in Class View, a richer immediate window, custom environment programming with macros, and more.

  • CLR Types: Use Reflection to Discover and Assess the Most Common Types in the .NET Framework
    Panos Kougiouris - October 2002
    The .NET Framework Class Library and the common language runtime (CLR) serve as the foundation for all .NET-based applications. But how much do you know about any of the thousands of CLR classes in the library and where do you begin to learn about them?In this article, the author uses the number of relationships with other types to determine which types are going to affect your programming most frequently and how often you'll encounter them. He programmatically surveys the CLR library using reflection to make that determination. Following that, an in-depth examination of the nine most important CLR types is provided.

  • Serial Comm: Use P/Invoke to Develop a .NET Base Class Library for Serial Device Communications
    John Hind - October 2002
    Out-of-the-box, the only way of coding RS232 serial communications applications in the .NET environment is to import the outdated and somewhat limited MSComm ActiveX control. This article describes the development of a lean, multithreaded, and modern RS232 base class library in C# managed code. The library uses Platform Invocation Services to interact with the Win32 API directly. Application programmers can use the library from any .NET language through inheritance; the article explores examples written in C# and Visual Basic .NET.

  • Command Management: Use Design Patterns to Simplify the Relationship Between Menus and Form Elements in .NET
    Michael Foster and Gilberto Araya - October 2002
    In Windows Forms applications, similar commands, such as those in a menu and their counterparts on a toolbar, are not automatically related. They don't fire the same event or run the same handler routine. Yet code that allows the same or similar user commands to fire the same code simplifies development.This article describes the principles of command management and why it's important to have functional commands that are not exclusive to any one UI element. In order to provide an MFC-like command management infrastructure, a design pattern is developed and applied as a series of C# classes.

  • The XML Files: The Birth of Web Services
    Aaron Skonnard - October 2002
    The XML technology receiving the most attention these days is Web Services. Web Services is a term commonly used to describe an entire new breed of applications. Unfortunately, not everyone agrees on what that breed is.

  • 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: Getting Version Info, CFolderTabCtrl Revisited
    Paul DiLascia - October 2002

  • Security Tips: Defend Your Code with Top Ten Security Tips Every Developer Must Know
    Michael Howard and Keith Brown - September 2002
    There are many ways to get into trouble when it comes to security. You can trust all code that runs on your network, give any user access to important files, and never bother to check that code on your machine has not changed. You can run without virus protection software, not build security into your own code, and give too many privileges to too many accounts. You can even use a number of built-in functions carelessly enough to allow break-ins, and you can leave server ports open and unmonitored. Obviously, the list continues to grow. What are some of the really important issues, the biggest mistakes you should watch out for right now so that you don't compromise your data or your system? Security experts Michael Howard and Keith Brown present 10 tips to keep you out of hot water.

  • Security in .NET: The Security Infrastructure of the CLR Provides Evidence, Policy, Permissions, and Enforcement Services
    Don Box - September 2002
    The common language runtime of the .NET Framework has its own secure execution model that isn't bound by the limitations of the operating system it's running on. In addition, unlike the old principal-based security, the CLR enforces security policy based on where code is coming from rather than who the user is. This model, called code access security, makes sense in today's environment because so much code is installed over the Internet and even a trusted user doesn't know when that code is safe.In this article, Don Box explains how code access security works in the CLR. He discusses the kinds of evidence required by policy, how permissions are granted, and how policy is enforced by the runtime.

  • HTTP Pipelines: Securely Implement Request Processing, Filtering, and Content Redirection with HTTP Pipelines in ASP.NET
    Tim Ewald and Keith Brown - September 2002
    ASP.NET is a flexible and extensible framework for server-side HTTP programming. While most people think of ASP.NET in terms of pages served, there is a lower-level infrastructure sitting beneath this page model. The underlying plumbing is based on a pipeline of app, module, and handler objects. Understanding how this pipeline works is key if you want to get the most out of ASP.NET as an HTTP server platform, while making your process more efficient, and keeping your server secure. This article introduces the architecture of the pipeline and shows how you can use it to add sophisticated functionality to an ASP.NET-based app.

  • Tamper-Resistant Apps: Cryptographic Hash Algorithms Let You Detect Malicious Code in ASP.NET
    Jason Coombs - September 2002
    Cryptographic hash algorithms produce fixed-length sequences based on input of arbitrary length. A given input always produces the same output, called a hash code. Using these algorithms, you can compute and validate hash codes to ensure that code running on your machine has not been tampered with or otherwise changed. ASP.NET provides a software mechanism for validating hash code fingerprints for every page requested by a client. In this article, the author shows how to use hash codes with ASP.NET applications to detect tampering and prevent malicious code from running when tampering is detected.

  • .NET Column: Run-time Serialization, Part 3
    Jeffrey Richter - September 2002
    This is the third part of my three-part series on serialization. In part one, I showed how to serialize and deserialize objects. I also showed how to define types that allow instances of themselves to be serialized.

  • Scripting and .NET: Visual Studio for Applications Provides Customized Scripting Facilities for Your .NET Project
    Chris Sells - August 2002
    In the past, the Microsoft Active Scripting architecture has allowed you to make your applications extensible. But it came with some drawbacks. You couldn't call into DLLs; you had to use COM interfaces. The scripts were not compiled, so they ran more slowly than they otherwise might, and a number of objects had to ride along with the script. To solve these problems and make extensibility easier to attain, Visual Studio for Applications was introduced. Presented here is an introduction to VSA that covers language support, types, events, and much more.

  • ASP.NET: Intercept, Monitor, and Modify Web Requests with HTTP Filters in ISAPI and ASP.NET
    Panos Kougiouris - August 2002
    There can be many reasons to reroute incoming Web requests. For instance, sometimes it's necessary to redirect a browser to a page based on user criteria without passing long lists of parameters in the URL. In the past, the only way to intercept such page requests and send them elsewhere was with ISAPI. Now, in ASP.NET, the IHttpModule interface provides notification of server requests, and lets you easily reroute them based on criteria other than browser type or version. Here the author demonstrates the use of IHttpModule for interception and explains the use of ISAPI filters for anyone who isn't yet using ASP.NET.

  • .NET Reflection: Dynamically Bind Your Data Layer to Stored Procedures and SQL Commands Using .NET Metadata and Reflection
    Atif Aziz - August 2002
    One major inconvenience of using SQL stored procedures from code is having to match type information. You have to write long wrapper functions around the procedures just to expose the data types. In the .NET Framework, however, the reflection services of the System.Reflection namespace allow you to query rich metadata that describe data types. This article explains how to use reflection in .NET to end your stored procedure nightmares. The author creates four custom classes, including one that generates a SQLCommand object based on the metadata of a method. Using this library, you'll be on your way to automating the generation of stored procedures.

  • Web Q&A: Passing XML to SQL Server, Document.write on Resize, Transformations on the Fly, and More
    Edited by Nancy Michell - August 2002

  • The XML Files: Dynamic Discovery in .NET, Codebehind, WebService Inheritance, and More
    Aaron Skonnard - August 2002

  • Wicked Code: Code Your Way to ASP.NET Excellence
    Jeff Prosise - August 2002

  • C++ Q&A: Call Unmanaged DLLs from C#, Killing Processes Cleanly
    Paul DiLascia - August 2002

  • .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.

  • Bug Tracker: Build a Configurable Web-Based Bug Management Tool Using ADO.NET, XML, and XSLT
    Roy Margolis - July 2002
    One of the most significant features of ADO.NET is its integration with XML. Developers can either use an ADO-like API to access the data or work directly with an XML representation of the data. This article demonstrates how both of these techniques can be used together to create Web applications that take advantage of XML standards such as XSLT. The example presented here is a bug tracking application built using C# and the.NET Framework. The development of the application covers several topics including data access using ADO.NET, the presentation of data using XSLT stylesheets, and the integration of ADO.NET with the .NET XML Framework.

  • .NET Column: Run-time Serialization, Part 2
    Jeffrey Richter - July 2002

  • C++ Q&A: Get the Main Window, Get EXE Name
    Paul DiLascia - July 2002

  • Go International!: Let Your Apps Span the Globe with Windows Forms and Visual Studio .NET
    Jason R. Bell - June 2002
    How would an English speaker feel if his car's owner's manual was written in German or if the dash board markings were written in Japanese because the car was manufactured in that country? This is an experience common to computer users all over the world who don't speak English as their primary language, and it's becomming more important. The Microsoft .NET Framework not only makes it possible to build international applications, but many of the tools such as Visual Studio .NET make it quite easy. This article looks at internationalization with .NET and presents real tools you can use to make all of your Windows Forms applications global-ready.

  • C#: XML Comments Let You Build Documentation Directly From Your Visual Studio .NET Source Files
    J. Andrew Schafer - June 2002
    C# allows developers to embed XML comments into their source files-a useful facility, especially when more than one programmer is working on the same code. The C# parser can expand these XML tags to provide additional information and export them to an external document for further processing. This article shows how to use XML comments and explains the relevant tags. The author demonstrates how to set up your project to export your XML comments into convenient documentation for the benefit of other developers. He also shows how to use comments to generate help files.

  • Return of the Rich Client: Code Access Security and Distribution Features in .NET Enhance Client-Side Apps
    Jason Clark - June 2002
    Rich clients employ many of the features and conveniences of the operating system they run on, and the list of these features has been growing since the dawn of the PC. But as apps have migrated to the Web, the trend towards increasing client-side functionality has ground to a virtual halt. There are several reasons for this; chief among them are security and deployment problems. But that's all about to change. With the .NET Framework, you can participate in building the distributable rich client of the future. In this article, the author enumerates the pertinent features of .NET that will allow you to build safe, easily deployable controls. The features discussed include managed code, code access security, versioning control, Windows Forms classes, and isolation.

  • The XML Files: WS-I, Exposing Stored Procedures as Web Services, and More
    Aaron Skonnard - June 2002

  • Cutting Edge: Building a Data Navigator Control, Part III
    Dino Esposito - 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.

  • Scripting: Windows Script Host 5.6 Boasts Windows XP Integration, Security, New Object Model
    Dino Esposito - May 2002
    Windows Script Host (WSH) 5.6, a major upgrade for the WSH environment, provides some significant improvements over previous versions. A brand new security model that is tightly integrated with security in Windows XP allows administrators to place fine-grained restrictions on scripts reducing the risk from malicious code. In addition, local scripts can now run on remote machines, and enhancements to the object model reduce the amount of boilerplate code needed when writing professional code. This overview of WSH 5.6 explains these changes and how .NET and scripting work together.

  • SQLXML 3.0: Build Data-Driven Web Services with Updated XML Support for SQL Server 2000
    Christian Thilmany - May 2002
    XML is becoming the ubiquitous data format on the Web, and XML support in SQL Server is evolving to meet the additional demand. Using XML, SOAP, HTTP, and SQL Server, you can now build powerful Web Services easily. To show just how simple it is with SQLXML 3.0, this article walks the reader through the process step by step, from setting up a virtual directory enabling data access via HTTP to executing queries and building Web Services. Finally, the author illustrates the creation of two Web Services clients-one with C# that works with the Microsoft .NET Framework and one with the SOAP Toolkit 2.0 for anyone still using earlier development tools.

  • ASP.NET Security: An Introductory Guide to Building and Deploying More Secure Sites with ASP.NET and IIS, Part 2
    Jeff Prosise - May 2002
    Forms authentication is one of the most compelling and useful new features of ASP.NET. It enables developers to declaratively specify which files on their site can be accessed and by whom, and allows identification of a login page. When an unauthenticated user attempts to retrieve a page protected by forms authentication, ASP.NET automatically redirects them to the login page and asks them to identify themselves. Included here is an overview of forms authentication and what you need to know to put it to work. Also included is hard-to-find information on the security of cookie authentication and on combining forms authentication with role-based URL authorizations.

  • WMI and .NET: System.Management Lets You Take Advantage of WMI APIs within Managed Code
    Zina Pozen - May 2002
    Visual Studio .NET and the Microsoft .NET Framework SDK provide a new set of APIs and tools that let you consume Windows Management Instrumentation (WMI) data and events from managed .NET applications. After presenting an overview of what's new for WMI in the .NET Framework and the Visual Studio .NET environment, the author provides an in-depth exploration of the Management Extensions in Visual Studio .NET for Server Explorer. These extensions help you develop management-aware software and come in handy in a variety of distributed application development scenarios.

  • The XML Files: XSLT Processing, Processing Instructions in XML, Parameterizing Statements in XML, and More
    Aaron Skonnard - May 2002

  • The ASP Column: HTTP Modules
    George Shepherd - May 2002

  • Cutting Edge: Building Editing Capabilities into the SqlDataNavigator ASP.NET Control
    Dino Esposito - May 2002

  • ASP.NET Security: An Introductory Guide to Building and Deploying More Secure Sites with ASP.NET and IIS
    Jeff Prosise - April 2002
    ASP.NET and Microsoft Internet Information Services (IIS) work together to make building secure Web sites a breeze. But to do it right, you have to know how the two interrelate and what options they provide for securing access to a Web site's resources. This article, the first in a two-part series, explains the ABCs of Web security as seen through the eyes of ASP.NET and includes a hands-on tutorial demonstrating Windows authentication and ACL authorizations. A range of security measures and authentication methods are discussed, including basic authentication, digest authentication, and role-based security.

  • Cutting Edge: Building a DataNavigator Control
    Dino Esposito - April 2002

  • .NET Column: Run-time Serialization
    Jeffrey Richter - April 2002

  • AOP: Aspect-Oriented Programming Enables Better Code Encapsulation and Reuse
    Dharma Shukla, Simon Fell, and Chris Sells - March 2002
    Aspect-oriented Programming (AOP), a paradigm invented at Xerox PARC in the 1990s, lets the developer better separate tasks that should not be inextricably tangled, such as mathematical operations and exception handling. The AOP approach has a number of benefits. First, it improves performance because the operations are more succinct. Second, it allows programmers to spend less time rewriting the same code. Overall, AOP enables better encapsulation of distinct procedures and promotes future interoperation.

  • .NET Web Services: Web Methods Make it Easy to Publish Your App's Interface over the Internet
    Paula Paul - March 2002
    Web Services are a great way to accept and manage contributions to a public clip art library, digital music catalog, or corporate knowledge base. Since the SOAP interface to a Web method operates over HTTP, contributors can easily publish content any time, from anywhere across the Internet. However, accepting binary content and managing content metadata through SOAP over HTTP presents Web Service developers with some interesting design decisions. This article discusses three ways to enable content publishing using Web methods.

  • The XML Files: Extending XSLT with JScript, C#, and Visual Basic .NET
    Aaron Skonnard - March 2002

  • Cutting Edge: ASP.NET Data Shaping
    Dino Esposito - March 2002

  • Visual Studio .NET: Custom Add-Ins Help You Maximize the Productivity of Visual Studio .NET
    Leo A. Notenboom - February 2002
    Regardless of how great an integrated development environment (IDE) is, there will always be features that developers wish had been included. For that reason, the Visual Studio .NET IDE provides an extensive add-in facility that allows you to add nearly unlimited numbers of features and functionalities written in Visual Basic, C, C++, C#, or any .NET-compliant language. This article explains how add-ins work in Visual Studio .NET. It then shows how to add custom text editing by creating an add-in with two editing functions, a simple text insert of the current date, and a more complex function to reformat paragraphs of text. Finally, you'll learn how to add a page to the Options dialog.

  • ASP.NET: Create Snazzy Web Charts and Graphics On the Fly with the .NET Framework
    Scott Mitchell - February 2002
    Knowledge workers can understand data more effectively when raw numbers are presented in a graphical format. This is especially true when displaying database information on a Web page, where a simple chart can make the difference between a dry presentation and a vivid data source. In the past, creating dynamic, data-based charts on the fly in ASP required purchasing a third-party, image-generating COM component. Now with ASP.NET, developers can access the .NET Framework's drawing classes directly with C# to create dynamic images and charts.

  • Data Points: Establishing Relationships Between Rowsets with ADO.NET
    John Papa - February 2002

  • Cutting Edge: Data Binding Between Controls in Windows Forms
    Dino Esposito - February 2002

  • .NET Column: Array Types in .NET
    Jeffrey Richter - February 2002

  • DHTML and .NET: Host Secure, Lightweight Client-Side Controls in Microsoft Internet Explorer
    Jay Allen - January 2002
    In the past, Web developers often used ActiveX controls if they wanted customized client-side functionality incorporated into their Web applications. Now, they can build objects supported by the Microsoft .NET Framework which are more compact, lightweight, secure, and seamlessly integrated. By hosting .NET Windows Forms controls in Internet Explorer, developers can realize many of their client-side Web development goals. This article adapts ActiveX concepts for use with Windows Forms, and builds a multifile upload application that demonstrates these techniques.

  • Cutting Edge: Understanding Templates in ASP.NET
    Dino Esposito - January 2002

  • Bugslayer: Extending the Visual Studio .NET IDE
    John Robbins - January 2002

  • Security Briefs: Managed Security Context in ASP.NET
    Keith Brown - January 2002

  • ADO.NET: Building a Custom Data Provider for Use with the .NET Data Access Framework
    Bob Beauchemin - December 2001
    The System.Data.dll assembly in the .NET Framework contains namespaces whose base classes can be used to create custom data providers. These namespaces also define a number of data access interfaces and base classes that let developers create data providers that will interoperate with other custom providers. Using the ADO.NET classes Connection, Command, DataReader, and DataAdapter, writing a provider is easier than writing one for OLE DB. This article explains these classes and their implementation, and how they can be used to write a variety of different kinds of data providers.

  • 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.

  • The ASP Column: DataList vs. DataGrid in ASP.NET
    George Shepherd - December 2001

  • Cutting Edge: Using Session and Application Objects in ASP.NET, Part 2
    Dino Esposito - December 2001

  • Data Points: Abstracting ADO.NET
    John Papa - November 2001

  • House of Web Services: Moving to .NET and Web Services
    Don Box - November 2001

  • Security Briefs: ASP.NET Security Issues
    Keith Brown - November 2001

  • Under the Hood: TypeRefViewer Utility Shows TypeRefs and MemberRefs in One Convenient GUI
    Matt Pietrek - November 2001

  • COM+ Integration: How .NET Enterprise Services Can Help You Build Distributed Applications
    Tim Ewald - October 2001
    The .NET Common Language Runtime (CLR) is Microsoft's next-generation component technology. The CLR is a replacement for COM, but not for COM+. COM+, now called .NET Enterprise Services, is the Microsoft object runtime environment for scalable system development. This article explains how to implement and deploy COM+ configured classes using the CLR, how to access object context and call context, and the rules for managing context-relative object references. Also discussed are ways to manage precious resources such as data connections and pooled objects, and the relationship between COM+ and the new .NET remoting architecture.

  • Cutting Edge: Build a Variety of Custom Controls Based on the DataGrid Control
    Dino Esposito - October 2001

  • Bugslayer: Handling Assertions in ASP.NET Web Apps
    John Robbins - October 2001

  • .NET Column: Extolling the Virtues of Enumerated Types
    Jeffrey Richter - October 2001

  • C# and the Web: Writing a Web Client Application with Managed Code in the Microsoft .NET Framework
    Avi Ben-Menahem - September 2001
    When the author wanted to build a middleware Web client to connect to other applications over the Internet, he realized that the XMLHttpRequest COM object was not sufficient for his purposes. In order to build a Web client using managed code, the author had to use the HTTPWebRequest and HTTPWebResponse classes provided by the Microsoft .NET framework. These classes are used in the sample project as a substitute for the less powerful XMLHttpRequest COM object, allowing the author to build a full-featured Web client. They also take advantage of all the benefits that the CLR and managed code have to offer.

  • ASP.NET: Collect Customer Order Information on an Internet Site Using XML and Web Forms
    Jeff Jorczak - September 2001
    XML has quickly become the new data structure standard for everything from database access to cross-platform computing. XML is typically considered to be a vehicle for data exchange, dynamic data presentation, and data storage. However, the potential of XML far surpasses those limited applications. This article examines one new use: the gathering of data across a number of forms in an ASP.NET Beta 1 framework application. The sample program is a Web app used for ordering pizza. It uses ASP and C# to gather order information and then stores it in XML. To build the application, several concepts are explained, including data collection, order persistence using cookies, grouping input forms, and formatting the data for display.

  • The ASP Column: HTMLControls and WebControls in ASP.NET
    George Shepherd - September 2001

  • The XML Files: Writing XML Providers for Microsoft .NET
    Aaron Skonnard - September 2001

  • Cutting Edge: Reusability in ASP.NET, Part 2
    Dino Esposito - September 2001

  • .NET Delegates: Making Asynchronous Method Calls in the .NET Environment
    Richard Grimes - August 2001
    One of the many great features of the .NET Framework is that it has asynchronous infrastructure built in. In .NET you can call any method asynchronously by defining a delegate for the method and calling the delegate's asynchronous methods. This is beneficial to your application because when a synchronous call is made, the calling thread is blocked until the method completes whereas an asynchronous call is made on a different thread, and this allows the original thread to continue its work while the asynchronous call is in progress.This article explains delegates in .NET and how to use them to perform asynchronous calls, eliminating age-old threading problems.

  • Cutting Edge: Reusability in ASP.NET: Code-behind Classes and Pagelets
    Dino Esposito - August 2001

  • .NET Column: Implementation of Events with Delegates
    Jeffrey Richter - August 2001

  • C++ -> C#: What You Need to Know to Move from C++ to C#
    Jesse Liberty - July 2001
    C# builds on the syntax and semantics of C++, allowing C programmers to take advantage of .NET and the common language runtime. While the transition from C++ to C# should be a smooth one, there are a few things to watch out for including changes to new, structs, constructors, and destructors. This article explores the language features that are new to C# such as garbage collection, properties, foreach loops, and interfaces. Following a discussion of interfaces, there's a discussion of properties, arrays, and the base class libraries. The article concludes with an exploration of asynchronous I/O, attributes and reflection, type discovery, and dynamic invocation.

  • Design Patterns: Solidify Your C# Application Architecture with Design Patterns
    Samir Bajaj - July 2001
    A design pattern can solve many problems by providing a framework for building an application. Design patterns, which make the design process cleaner and more efficient, are especially well-suited for use in C# development because it is an object-oriented language. Existing design patterns make good templates for your objects, allowing you to build software faster. This article describes several popular design patterns you can use in your own applications, including the singleton, the decorator, the composite, and the state classes, which can improve the extensibility of your applications and the reuse of your objects.

  • Cutting Edge: Custom Web Data Reporting
    Dino Esposito - July 2001

  • Cutting Edge: DataGrid In-place Editing
    Dino Esposito - June 2001

  • .NET Column: Delegates, Part 2
    Jeffrey Richter - June 2001

  • ASP.NET: Web Forms Let You Drag And Drop Your Way To Powerful Web Apps
    Jeff Prosise - May 2001
    Web Forms have the potential to change Web programming by introducing a new programming model built around server-side controls-a model in which controls render their own UIs by generating HTML to return to clients and firing events that are handled by server-side scripts. Since all the action takes place on the Web server, virtually any browser can run a Web Forms app. And thanks to Visual Studio .NET, building a Web Forms app is a lot like using Visual Basic: just drop a control onto a form then write an event handler. This article describes the Web Forms programming model, how it fits with ASP.NET, and introduces DataGrid, TextBox, and other classes in the .NET Framework class library.

  • Cutting Edge: Server-side ASP.NET Data Binding, Part 3: Interactive DataGrids
    Dino Esposito - May 2001

  • House of COM: Migrating Native Code to the .NET CLR
    Don Box - May 2001

  • Cutting Edge: Server-side ASP.NET Data Binding, Part 2: Customizing the DataGrid Control
    Dino Esposito - April 2001

  • .NET Column: An Introduction to Delegates
    Jeffrey Richter - April 2001

  • Wicked Code: CityView App: Build Web Service Clients Quickly and Easily with C#
    Jeff Prosise - April 2001

  • Microsoft .NET: Implement a Custom Common Language Runtime Host for Your Managed App
    Steven Pratschner - March 2001
    While most application developers may not need to write a custom host, understanding what is involved provides a great deal of insight into the architecture of the CLR. After covering how the CLR is started and loaded into a process, how to set the available configuration options, and how a host defines application domains, this article explains how to design a custom host. Important concepts include making the right decisions about the application domain boundaries for the host, configuring them correctly, loading and executing user code, and resolving references to assemblies. Setting security policy and unloading application domains as the application shuts down are also explained.

  • Cutting Edge: Server-side ASP.NET Data Binding
    Dino Esposito - March 2001

  • Visual Programmer: Advanced ASP.NET Server-side Controls, Part 2
    George Shepherd - March 2001

  • Under the Hood: Displaying Metadata in .NET EXEs with MetaViewer
    Matt Pietrek - March 2001

  • Windows Forms: A Modern-Day Programming Model for Writing GUI Applications
    Jeff Prosise - February 2001
    To write GUI applications for Microsoft .NET you'll use Windows Forms. Windows Forms are a new style of application built around classes in the .NET Framework class library's System.WinForms namespace. They have a programming model all their own that is cleaner, more robust, and more consistent than models based on the Win32 API or MFC, and they run in the managed environment of the .NET Common Language Runtime (CLR). This article details what Windows Forms are all about, from the programming model to Microsoft Intermediate Language and the JIT compiler. Two applications using forms, event handlers, anchors and persistence are built step by step.

  • .NET Framework: Building, Packaging, Deploying, and Administering Applications and Types
    Jeffrey Richter - February 2001
    Types that are built for the Common Language Runtime can be shared among applications in the Microsoft .NET Framework no matter which of the .NET languages they were built in, an obvious benefit to developers. This article describes the building, packaging, and deploying of applications and types for the .NET Framework, including the role and significance of assemblies, private and otherwise. The way metadata and assemblies help to solve some historical problems like versioning conflicts and DLL Hell, and how they improve system stability are also discussed.

  • Security in .NET: Enforce Code Access Rights with the Common Language Runtime
    Keith Brown - February 2001
    Component-based software is vulnerable to attack. Large numbers of DLLs that are not tightly controlled are at the heart of the problem. Code access security in the Common Language Runtime of the Microsoft .NET Framework addresses this common security hole. In this model, the CLR acts as the traffic cop to assemblies, keeping track of where they came from and what security restraints should be placed on them. Another way the .NET Framework addresses security is by providing preexisting classes which have built-in security. These are the classes that are invoked in .NET when performing risky operations such as reading and writing files, displaying dialog boxes, and so on. Of course, if a component calls unmanaged code, it can bypass code access security measures. This article covers these and other security issues.

  • .NET P2P: Writing Peer-to-Peer Networked Apps with the Microsoft .NET Framework
    Lance Olson - February 2001
    Peer-to-peer applications such as Napster, Gnutella, and Scour that communicate as peers sharing and receiving information are becoming commonplace as a means for users connected on large networks to take advantage of the vast resources available to them. The Microsoft .NET Framework provides a rich platform for building P2P apps. This article explains the concepts that make up peer-to-peer applications. The peer-to-peer application model, discovering other peers, and querying peers for information are discussed. The article goes on to cover the System.Net namespace for the use of Internet protocols, the System.Web.Services namespace for exposing Web Services, and firewall and port issues. Finally, the role of the .NET Framework in simplifying the design of powerful peer-to-peer applications is outlined.

  • Bugslayer: Assertions and Tracing in .NET
    John Robbins - February 2001

  • .NET Column: Special .NET Type Members
    Jeffrey Richter - February 2001

  • XML in .NET: .NET Framework XML Classes and C# Offer Simple, Scalable Data Manipulation
    Aaron Skonnard - January 2001
    Microsoft .NET introduces a new suite of XML APIs built on industry standards such as DOM, XPath, XSD, and XSLT. The .NET Framework XML classes also include innovations that offer convenience, better performance, and a more familiar programming model, tightly coupled with the new .NET data access APIs-ADO.NET. XmlWriter, XmlReader, and XmlNavigator classes and classes that derive from them, including XMLTextReader and XMLTextWriter, encapsulate a number of functionalities that previously had to be accomplished manually. A discussion of the XMLDOM-Document is also included.

  • Visual Programmer: Advanced ASP.NET Server-side Controls
    George Shepherd - January 2001

  • Garbage Collection-Part 2: Automatic Memory Management in the Microsoft .NET Framework
    Jeffrey Richter - December 2000
    The first part of this two-part article explained how the garbage collection algorithm works, how resources can clean up properly when the garbage collector decides to free a resource's memory, and how to force an object to clean up when it is freed. The conclusion of this series explains strong and weak object references that help to manage memory for large objects, as well as object generations and how they improve performance. In addition, the use of methods and properties for controlling garbage collection, resources for monitoring collection performance, and garbage collection for multithreaded applications are covered.

  • House of COM: Is COM Dead?
    Don Box - December 2000

  • .NET Column: Type Fundamentals
    Jeffrey Richter - December 2000

  • Introducing ADO+: Data Access Services for the Microsoft .NET Framework
    Omri Gazitt - November 2000
    ADO+ is the new set of data access services for the .NET Framework. ADO+ is a natural evolution of ADO, built around n-tier development and architected with XML at its core. This article presents the design motivations behind ADO+, as well as a brief introduction to the various classes in the two layers that comprise the ADO+ framework-the connected Managed Providers and the disconnected DataSet. A drilldown into DataSets that covers populating data stores, relationships, filtering, searching and data views is provided. Finally, a discussion of the integration of ADO+ with the .NET XML Framework is presented.

  • Garbage Collection: Automatic Memory Management in the Microsoft .NET Framework
    Jeffrey Richter - November 2000
    Garbage collection in the Microsoft .NET common language runtime environment completely absolves the developer from tracking memory usage and knowing when to free memory. However, you'll want to understand how it works. Part 1 of this two-part article on .NET garbage collection explains how resources are allocated and managed, then gives a detailed step-by-step description of how the garbage collection algorithm works. Also discussed are the way resources can clean up properly when the garbage collector decides to free a resource's memory and how to force an object to clean up when it is freed.

  • Visual Programmer: Server-side Controls in Active Server Pages+
    George Shepherd - October 2000

  • .NET Column: Programming for the New Platform
    Jeffrey Richter - October 2000

  • Sharp New Language: C# Offers the Power of C++ and Simplicity of Visual Basic
    Joshua Trupin - September 2000
    Many developers wish there was a language that was easy to write, read, and maintain like Visual Basic, but that still provided the power and flexibility of C++. For those developers, the new C# language is here. Microsoft has built C# with type-safety, garbage collection, simplified type declarations, versioning and scalability support, and lots of other features that make developing solutions faster and easier, especially for COM+ and Web Services. This article gives you a first look at C#, a language you are going to be hearing lots more about in the very near future.