Topic: .NET

O'Reilly Network articles about this topic:

Build Dynamic Database Applications in .NET with Project Codename "Jasper" (Windows DevCenter)
Instead of moving to Ruby on Rails, ASP.NET developers might consider Project Codename "Jasper" and the growing number of .NET dynamic languages. In this article, you'll learn how to use Jasper.

Using the Cryptography APIs in .NET (Windows DevCenter)
The .NET framework contains a number of cryptography services that allow you to incorporate security services into your .NET applications. In this article, Wei-Meng Lee shows you how to use some of the common security APIs to make your .NET applications more secure.

Managing Printing in Your .NET Application (Windows DevCenter)
The .NET Framework makes it easy to support printing. In this article, Wei-Meng Lee shows you the basics of printing in .NET 2.0, including how to configure page setup, print multiple pages, preview a document before it is printed, as well as let users select a printer to which to print.

The Logic of Service-Orientation Plus 14 SO Tenets and Practical Principles (Windows DevCenter)
What exactly is service orientation, and what does it mean for the future of the software industry? What are the principles that should guide any developer using it? In this excerpt from Programming WCF Services, Juval Lowy explains what it's about and offers practical principles for its use.

Logging with Custom Web Events (Windows DevCenter)
Every serious ASP.NET application requires logging. Jesse Liberty shows how to use the little-known ASP.NET Health Monitoring system to create a robust and extensible, yet minimal, logging system that will send email in a crisis and routinely log to a database.

Analyzing Assemblies with Reflector (Windows DevCenter)
It's tough to to understand how a class, method, or entire assembly fits into your overall system. In this excerpt from Windows Developer Power Tools, James Avery and Jim Holmes show you how to use Reflector freeware to explore any .NET assembly and find its dependencies and callers, or dive down and explore an entire assembly.

Top 10 Tips for Using Windows PowerShell (Windows DevCenter)
PowerShell is Microsoft's newest replacement for the command line, and it's far more powerful than any command-line prompt Microsoft has given us before. Starting to learn it, unfortunately, can be a bit overwhelming. Jeff Cogswell offers his top 10 tips for getting the most out of it.

Creating Visual Studio Project Templates (Windows DevCenter)
Visual Studio 2005 offers a great tool for those who create largely identical projects--custom project and item templates--that automates project creation and eliminates the need to add the same references, project items, or even largely identical code to new projects. Ron Petrusha shows you how.

Drag and Drop Ajax Programming with Atlas (Windows DevCenter)
Think you need to write scripts and use JavaScript if you want to write Atlas apps? Think again. Jesse Liberty shows you an easier, more effective, and more productive way--using drag-and-drop programming.

Build a Web-Based Bug Tracking App, Part 2 (Windows DevCenter)
In part two of this series, Jesse Liberty shows you how to build a web-based bug-tracking application using ASP.NET.

Build a Web-Based Bug Tracking App (Windows DevCenter)
Having problems tracking bugs every time you create a new project? Jesse Liberty has the solution. Here, he shows you how to build a Web-based bug-tracking application using ASP.NET.

Programming Word from .NET (Windows DevCenter)
Using .NET with Word can be a potent combination. Jesse Liberty shows you how to take advantage of Word's formatting features and add the power of .NET's programmability.

Object-Oriented Data Programming: C# Meets Caché (Windows DevCenter)
There are plenty of legacy databases using MUMPS and Caché--but what do you do when you need to bring them into the modern world? Jesse Liberty shows you how to bridge the worlds of object-oriented data programming and old-time databases.

Creating an Application from Scratch, Part 3 (Windows DevCenter)
Jesse Liberty is creating an application from scratch in ASP.NET 2.0 while you watch over his shoulder. In part 3, he builds the engine and implements it.

Creating an Application from Scratch, Part 2 (Windows DevCenter)
Jesse Liberty is creating an application from scratch in ASP.NET 2.0 while you watch over his shoulder. In part 2, he starts building the application, making use of Amazon Web Services.

What Are Web Parts? (Windows DevCenter)
Today's web application is customizable in ways that could only have been dreamed of five years ago, partially because of Web Parts. Jesse Liberty shows how they work by guiding you through building a simple application in ASP.NET. Jesse is the author of Programming ASP.NET, Third Edition.

Unit Testing in Visual Studio 2005 Team System (Windows DevCenter)
Unit testing is one of the tasks that every programmer worth their salt needs to do. Wei-Meng Lee shows you how to use the new Unit Testing feature of Visual Studio 2005 Team System to auto-generate the code needed to test your application.

Just-In-Time Data Loading For DataGrids (Windows DevCenter)
One of Jesse Liberty's clients has a problem: she has a database with 2 million records and wants to display these records in a data grid, but does not want to load them all into memory from the database. She wants them loaded "just in time." Jesse shows how to use the new DataGridView to neatly solve the problem.

What Are Generics (Windows DevCenter)
Generics provide the ability to create type-safe collections in .NET. Jesse Liberty explains why they're important, and how to best make use of them. Jesse is the author of Programming ASP.NET, Third Edition.

Creating an Application from Scratch, Part 1 (Windows DevCenter)
Watch over Jesse Liberty's virtual shoulder as he documents his creation of a real-world application from scratch. In real time--that is, as he develops it.

C#: Yesterday, Today, and Tomorrow: An Interview with Anders Hejlsberg, Part 2 (Windows DevCenter)
Anders Hejlsberg, in charge of the ongoing development of the C# programming language for Microsoft, talks about the past, present, and future of C#. Among other topics, he covers the implementation of C# generics (compared to Java), nullable types, and how language integrated query is implemented.

C#: Yesterday, Today, and Tomorrow: An Interview with Anders Hejlsberg, Part 1 (Windows DevCenter)
Anders Hejlsberg, in charge of the ongoing development of the C# programming language for Microsoft, talks about the past, present, and future of C#. Among other topics, he covers the implementation of C# generics (compared to Java), nullable types, and how language integrated query is implemented.

What Is C# (Windows DevCenter)
Jesse Liberty reveals this little-understood secret: C# is really one of two "coatings" of MSIL, the Microsoft Intermediate Language (the second is Visual Basic 2005). Both C# and VB 2005 produce MSIL, and it is MSIL that runs on the .NET platform. Jesse provides an overview of the C# language and how it works within the .NET platform, and concludes with resources for coding in C#. Jesse is the author of Programming C#, 4th Edition.

Tell Us What You Think: The Second ONDotnet Survey (Windows DevCenter)
We're asking ONDotnet readers to participate in our second online survey. We've sweetened the pot with a chance to win books and MAKE magazine subscriptions. Here's how it works.

What Is ASP.NET (Windows DevCenter)
Part of the .NET Framework, ASP.NET allows developers to build dynamic web apps and web services using compiled languages like VB.NET and C#. Wei-Meng Lee provides a look under the ASP.NET hood, describing how it works, its improved support in areas like state management and tracing and debugging, and important new features in version 2.0. Wei-Meng is the author of ASP.NET: A Developer's Notebook.

What Is .NET (Windows DevCenter)
.NET is probably one of the more muddled and mismanaged brands in the history of Microsoft. Elucidator James Avery clarifies things by describing the two chambers at the heart of .NET: the Common Language Runtime (CLR) and its essential components, and the Base Class Library (BCL) and its major features.

What Is Visual Studio (Windows DevCenter)
What can you really do with Visual Studio? James Avery discusses some of the various applications you can build using Visual Studio, some of its most compelling development features, and what you need to know to get started writing quality applications in Visual Studio. James is the author of Visual Studio Hacks.

Localization in ASP.NET 2.0 (Windows DevCenter)
The web is an international place. Why shouldn't your websites be ready for international visitors? With the introduction of ASP.NET 2.0, Microsoft aims to make it easy to localize your website for individual users, no matter where they hail from. Wei-Meng Lee shows you how you can localize your ASP.NET 2.0 web applications. Wei-Meng is the author of ASP.NET 2.0: A Developer's Notebook.

Calling Web Services Asynchronously (Windows DevCenter)
Making synchronous calls to web services can be problematic on occasion, because they have the potential to cause considerable delay. The reason for this is the manner in which synchronous calls work: the application blocks the client until the web service call returns. To overcome the necessity of having to wait for the web service response, we can call web services asynchronously. Raj Makkapati walks you through how to call web services asynchronously.

Understanding the BackgroundWorker Component (Windows DevCenter)
Multithreading is one of the most powerful concepts in programming. Using multithreading, you can break a complex task into multiple threads that execute independently of one another. By default, your Windows application uses a single thread of execution. Wei-Meng Lee shows you how multithreading has been simplified in VB2005 using the BackgroundWorker component.

Unit Testing in .NET Projects (Windows DevCenter)
Now is a pretty exciting time for unit testing in .NET. Tremendous progress is being made on several fronts: IDE integration, process integration, and new test fixtures. Jay Flowers and Andrew Stopford explain how to use Visual Studio's new integrated unit testing, as well as the NUnit and MbUnit testing frameworks.

Building a Complex Custom Control: Rolodex (Windows DevCenter)
This article marks the end of "Liberty on Whidbey" and the beginning of a new column: "Liberty On Beta 2." Each article will demonstrate a real-world problem Jesse's had to solve for a client, and will leave you with a complete design and working code. Jesse had a customer who asked for a complex Windows application that would let him scroll through a list of customers, suppliers, or employees, using the visual metaphor of a Rolodex, much as he might look at contacts in Outlook.

Building Web Parts, Part 3 (Windows DevCenter)
In this last installment of his Web Parts series, Wei-Meng Lee will show you how to let users dynamically add Web Parts to page and how to restore Web Parts that they have closed.

Refactoring with Visual Studio Macros (Windows DevCenter)
Refactoring is a method of improving your code without breaking or modifying the external functionality of your application. Refactoring has been growing in popularity partially because it is one of the key practices of extreme programming and because it goes hand in hand with test driven development. Refactoring consists of a plethora of different small changes (or “refactorings”) that you can make to your code. These changes are small enough to quickly test and have a low risk factor, but in total, they increase the overall quality of your code base or application. In this new article,James Avery discusses a macro approach to refactoring.

Generics in .NET 2.0 (Windows DevCenter)
Generics in .NET 2.0 permeates with potential. But what are generics? Are they for you? Should you use them in your apps? Venkat Subramaniam, author of .NET Gotchas, answers these questions and take a closer look at using generics, and their capabilities and limitations.

Porting a Project from Visual Studio .NET to Mono (Windows DevCenter)
Three years ago, when .NET was still in pre-release status, Kevin Farnham developed a C# application to automatically generate stock market web pages. Recently, he ported the project to Mono and Debian Linux. Follow along to see how the port went.

What's New in Beta 2: Web Parts Revisited (Windows DevCenter)
Jesse Liberty has been working with Whidbey (.NET 2005) for a little over a year, and believes that .NET 2005 2.0 is a great improvement over 1.x. That said, the beta has had a bit of a hard time settling down, and so many of the earlier columns he wrote about Whidbey are, at best, a bit out of date. In this column he revisits, fixes, and expands on one of his favorite 2.0 features: Web Parts.

Building Web Parts, Part 2 (Windows DevCenter)
In part one of this series, Wei-Meng Lee discussed how to create Web Parts and configure them to look good. But he didn't touch on one of the most important feature of Web Parts; that is, how to let users move the Web Parts from one zone to another. In this article, he shows you how to move Web parts and how you can configure Web Parts to make use of SQL Server 2000.

Refactoring Support for Visual Basic 2005 (Windows DevCenter)
Microsoft recently announced that they have teamed up with Developer Express Inc. to release Refactor! for Visual Basic 2005 Beta 2, a free plugin for Visual Studio that enables Visual Basic developers to simplify and restructure source code inside of Visual Studio 2005. Wei-Meng Lee walks you through the new refactoring.

Building Web Parts, Part 1 (Windows DevCenter)
Websites today contain a wealth of information; so much that a poorly designed site can easily overwhelm users. To better help users cope, portal websites today (such as MSN) often organize their data into discrete units that support a degree of personalization. In this first of three articles, Wei-Meng Lee discusses how to use Web Parts for user customization in your ASP.NET 2.0 websites.

Hacking Visual Studio (Windows DevCenter)
Author James Avery has selected five hacks from his recently released book, Visual Studio Hacks. Learn to create comments faster using GhostDoc; to refactor your code with Visual Studio 2005's new Refactor menu; and more.

Putting a Browser into Your Windows Application (Windows DevCenter)
There are times when it would be convenient to have the capabilities of Internet Explorer inside your Windows application. The classic case is when you want to look at an XML document, and you'd like to take advantage of IE's ability to show the document as a collapsible and expandable hierarchy. In this article, Jesse Liberty will show you how to do that, in just a few easy steps.

XML DataSource Controls in .NET 2.0 (Windows DevCenter)
With .NET 2.0's XML DataSource control, you can bind to an XML document just as easily as you bind to tables in a database. If the XML document you load is hierarchical, the data is exposed hierarchically, which makes it ideal for mapping an XML document to a TreeView control. Jesse Liberty explains how the XML DataSource works in ASP.NET.

C# Generics: Collection Interfaces (Windows DevCenter)
The .NET framework provides two sets of standard interfaces for enumerating and comparing collections: the traditional (non-type-safe) and the new generic type-safe collections. In this excerpt from Programming C#, 4th Edition, Jesse Liberty focuses on the key type-safe collection interfaces, reviewing each collection interface and providing code examples that demonstrate how to implement each one.

Building .NET Add-Ins for Windows Media Center Edition (Windows DevCenter)
Windows XP Media Center Edition 2005 is an exciting platform for enjoying all of your media from the comfort of your sofa. However, in many cases you might wish to extend Media Center to perform functionality that it does not have "out of the box." Microsoft has created a software development kit that lets you write your own software that runs in Media Center. In this article, Michael Earls shows you how to write your first .NET add-in for Media Center Edition of Windows XP.

Enhanced Text Input in Windows Forms 2.0 (Windows DevCenter)
Visual Studio 2005 provides enhanced controls for managing data input in Whidbey. To get you started, Jesse Liberty takes a look at the masked editing control, which allows you to restrict the input from a user that a Windows Form will accept and to control how it is displayed by using a mask.

Miguel de Icaza Explains How to "Get" Mono (Windows DevCenter)
It's perhaps the most controversial project in the open source world, but this mostly stems from misunderstanding: Mono, the open source development platform based upon Microsoft's .NET framework. Immediate reactions from many dubious Linux developers have ranged from confusion over its connection with .NET to wondering what the benefits of developing under it are. Throughout the course of its four years of intense development, sponsored by Novell, Mono founder Miguel de Icaza has had to frequently clarify the .NET issue and sell the community on it. In this new interview, Howard Wen asks Miguel to explain himself one more time.

Enhanced Text Input in Windows Forms 2.0 (Windows DevCenter)
Visual Studio 2005 provides enhanced controls for managing data input in Whidbey. In this new column by Jesse Liberty, he discusses the advanced WinForms Text Input control.

An Introduction to Developing Software for Microsoft Windows XP Media Center Edition 2005 (Windows DevCenter)
At a recent consumer electronics show, Bill Gates suggested that the Media Center PC would be the centerpiece for combining online entertainment sources with existing video sources. As Sean Alexander (a product manager for Media Center) later suggested, Windows Media Center Edition will be the "hub for whole-home entertainment". Windows XP Media Center Edition allows you to do those things today. Michael Earls starts you out with how to write applications for Windows Media Center.

Data Binding in ASP.NET 2.0 (Windows DevCenter)
Not only has Microsoft made radical changes in how data binding is done between ASP.NET 1.x and 2.0, but it has also created significant differences between how it is done in Windows Forms and ASP.NET in 2.0. This keeps life interesting (Jesse Liberty says, gnashing his teeth). In this new column, he dives into data binding in the new Web Forms.

Encrypting Connection Strings in Web.config (Windows DevCenter)
One of the best practices in ASP.NET is to save your database connection strings in the Web.config file instead of hard-coding it in your code. It's not such a good idea to save your connection strings as plain text in Web.config – you should ideally encrypt the connection strings so it leaves no chance for a potential hacker to easily get more information about your database server. In ASP.NET 2.0, Microsoft has taken this further by allowing you to encrypt the connection strings in Web.config, all without much plumbing on your part. In this new article by Wei-Meng Lee, he shows you how it works!

Building Mono on Windows (Windows DevCenter)
Mono, the open source implementation of the CLR, is not just for non-Microsoft platforms. Kevin Shockey walks you through the three phases required to build Mono on Windows without using the .NET framework.

Using SQL Cache Dependency (Windows DevCenter)
Caching has long been recognized as one of the more effective ways to improve your ASP.NET web applications. One particular caching feature missing in ASP.NET 1.x was SQL cache dependency: the ability to invalidate a database cache if data in a table is changed. In ASP.NET 2.0, Microsoft has added the new SQL cache dependency feature. Wei-Meng Lee discusses the SQL cache dependency in ASP.NET 2.0, and how you can manually implement it in ASP.NET 1.x.

Web Parts in ASP.NET 2.0 (Windows DevCenter)
In a previous article, Jesse Liberty discussed how personalization works. This article picks up from where he left off and shows you how to use Web Parts to allow your users to further personalize users' interactions with your web site.

Using the Observer Pattern in .NET (Windows DevCenter)
Recently, after visiting a friend who received a binary clock as a gift, Michael Weier thought it would be a great example to show how to use the Observer pattern.

Learning ASP.NET for the ASP Developer - Part 3 (Windows DevCenter)
In the final part of this tutorial, Nihal Mehta will demonstrate how to construct largescale ASP.NET websites. In the previous tutorials of this series, Nihal showed how to build single ASP.NET pages where all the code for a page was written on the page itself. This approach can quickly get tedious when you have code that is common across several pages. Thus, one of the most important elements in sites with a large number of pages is the ability to share code.

Using the SQL Server 2000 Reporting Services (Windows DevCenter)
Microsoft has finally added reporting capabilities to its flagship database server, SQL Server 2000. In this article, Wei-Meng Lee walks you through the basics of creating a simple report using the SQL Server 2000 Reporting Services.

Skins and Themes (Windows DevCenter)
In his previous column, Jesse Liberty showed you how to use web forms security to create a personalized site. Here, he builds on that work to introduce the concepts of skins and themes, which allow users to configure the look and feel of your site.

ASP.NET 2.0 Databinding (Windows DevCenter)
In ASP.NET 2.0, a great deal of the ADO.NET object model has been incorporated into controls that let you interact with data declaratively, and that spare you from writing boilerplate code to create datasets, extract tables, bind tables or views to controls, and so forth. Jesse Liberty shows you how ADO.NET 2.0 and ASP.NET 2.0 are now meaningfully matched.

Introducing SQL Server Reporting Services (Windows DevCenter)
Microsoft has finally added reporting capabilities to SQL Server 2000. Wei-Meng Lee walks you through the basics of creating a simple report using the SQL Server 2000 Reporting Services.

Personalization in ASP.NET 2.0 (Windows DevCenter)
In previous articles, Jesse discussed security and managing users' roles. This article picks up from where those articles left off, and show you how to provide personalized web pages for your users. Personalization allows your web site to welcome the user and to persist the user's state.

Learning ASP.NET for the ASP developer - Part 2 (Windows DevCenter)
In the first part of this tutorial, we showed how ASP.NET allows us to cleanly separate presentation markup from server side script code. In this second part, we will continue our investigation of ASP.NET from a classic ASP developer's perspective. We will delve deeper and demonstrate how an ASP.NET page is put together.

The Magic of ClickOnce (Windows DevCenter)
One of the major attractions of the web application is its ubiquitous access--anyone with a web browser can access the application and there are no setup issues to worry about. With the advent of web services, a new model can be drawn from the best of both worlds--harnessing the rich capability of the client-side Windows environment as well as the distributed and connected model of web services. This new model is known as smart clients. In this article, Wei-Meng Lee shows you how smart clients are supported in Visual Studio 2005 and how it makes deploying them easy and painless.

Cooking with ASP.NET, Part 2 (Windows DevCenter)
Last week, in part one of this two-part excerpt from the ASP.NET Cookbook , authors Michael Kittel and Geoffrey LeBlond cooked up three recipes to make ASP.NET work for you. This week, they're back in the kitchen with two more recipes: one to create a reusable handler that reads image data from the database and sends it to the browser, and another to improve the performance of pages that rarely change by saving and reusing HTML output.

Making Sense of Partial Classes (Windows DevCenter)
In Whidbey, Microsoft has introduced partial classes, with which we can spread the definition of a class over multiple files. The use of partial classes attempts to solve the problem of separation of designer code and implementation code. Nick Harrison shows you these solutions and explores the benefits of using partial classes in your own projects.

Cooking with ASP.NET (Windows DevCenter)
Michael Kittel and Geoffrey LeBlond have selected a few of their favorite recipes from O'Reilly's recently released ASP.NET Cookbook. Learn how to add a Totals row to a DataGrid, communicate between user controls, and display user-friendly error messages. Check back next week, as the authors offer two more recipes--for creating a reusable image handler and saving and reusing HTML output.

Master Pages in ASP.NET (Windows DevCenter)
On many web sites, it is important to achieve a consistent "look and feel" as the user moves from page to page. While this was possible with .NET 1.1, it was difficult and required both programmer and designer discipline. ASP.NET 2.0 makes this far easier with the creation of master pages. Jesse Liberty shows you how master pages work in ASP.NET 2.0.

Learning ASP.NET for the ASP Developer, Part 1 (Windows DevCenter)
You may be an ASP developer. After the boom of the 1990s, there are thousands of you out there. We know you want to learn ASP.NET. In this, the first of three articles by Dr. Nahal J. Mehta, he shows you how to leverage your ASP knowledge to learn how to think like an ASP.NET developer.

Site Navigation in ASP.NET 2.0 (Windows DevCenter)
As your web site grows in complexity, it is imperative that you make the effort to make your site much more navigable. A common technique employed by web sites today uses a site map to display a breadcrumb navigational path on the page. ASP.NET 2.0 comes with the SiteMapPath control to help you in site navigation. Wei-Meng Lee shows you how it all works.

Logical and Physical Software Design with Microsoft .NET (Windows DevCenter)
When integrated circuit engineers design components, they pay attention not only to the logical design of the chip, but also to the way it is physically implemented in silicon. With improved .NET deployment technology, programmers must do likewise. Michael Stiefel and George Wesolowski show you how physical and logical design can help you with .NET applications.

Introducing Themes and Skins in ASP.NET 2.0 (Windows DevCenter)
Most web designers use Cascading Style Sheets (CSS) to maintain a consistent look and feel on their web sites. ASP.NET 2.0 introduces a new way to maintain a consistent look and feel without having to manage your own CSS files. This new article by Wei-Meng Lee introduces the new feature and shows you how it works.

Personalization in ASP.NET (Windows DevCenter)
Personalizing your web site can enhance the experiences of users visiting your site. Personalization allows information about visitors to be persisted so that the information can be useful to the visitor when he visits your site again. Wei-Meng Lee shows you how it all works in ASP.NET 2.0.

Using the New Callback Manager in ASP.NET 2.0 (Windows DevCenter)
One of the inherent limitations of web applications is the costly round-trip delay when a web page posts something back to the server and reloads the page. Wei-Meng Lee shows you how to use the new Callback Manager to eliminate this limitation.

Using the Gtk Toolkit with Mono (Windows DevCenter)
As a cross-platform UI framework, Gtk allows you to develop graphical user interfaces for applications on Microsoft Windows, various flavors of Unix and Linux, and Mac OS X, without having to write OS-specific UI code. Because it is cross-platform and object-oriented, the Mono team decided to use Gtk as the basis for its UI framework. Gtk#, the C# wrapper for Gtk, is the result. Niel Bornstein, coauthor of Mono: A Developer's Notebook, shows you how to get started with Gtk#.

Rapid Application Development with VB.NET 2.0 (Windows DevCenter)
For a couple of years now, Jesse Liberty been touting the Microsoft endorsed-sentiment that it really doesn't matter if you program in C# or in VB.NET, since both are just syntactic sugar layered on top of MSIL (Microsoft Intermediate Language, the true language of .NET). That appears to be changing a bit with Whidbey. Jesse Liberty investigates the new My object in VB.NET 2.0.

Writing Cross-Platform Mobile Applications Using Crossfire (Windows DevCenter)
If you are a Microsoft developer familiar with the .NET Framework, you generally have two options if you want to write mobile applications. For mobile handsets, you can develop mobile Web applications using the ASP.NET Mobile controls. For standalone applications, you can use the .NET Compact Framework. However, using the .NET Compact Framework you can only target Pocket PC devices. And that essentially means that you are out of luck when it comes to developing for competing devices such as Palm and Symbian Smartphones. In this article, Wei-Meng Lee introduces you to a new open source project known as Crossfire that promises to close the gap.

Refactoring in Whidbey (Windows DevCenter)
Code refactoring means restructuring your code so that the original intention of the code is preserved. In this article, Wei-Meng Lee walks you through Whidbey's new support for code refactoring.

ASP.NET Forms Security, Part 2 (Windows DevCenter)
In his previous column, Jesse Liberty showed how to add web form security to your ASP.NET 2.0 application, and how to add users. In this follow-up, he demonstrates how easy it is to create and manage roles.

ASP.NET Forms Security (Windows DevCenter)
Jesse Liberty shows how easy it is to provide forms-based security via login screens and authentication in Whidbey.

C# Iterators (Windows DevCenter)
If you are creating a class that looks and behaves like a collection, it is handy to allow your users to iterate through the members of your collection with the foreach statement. This is easier to do in C# 2.0 than it is in 1.1. In this new column by Jesse Liberty, he shows you what is coming up in .NET 2.0 to make this common task easier.

New Features in VB.NET — Generics (Windows DevCenter)
One of the new features in .NET Framework 2.0 is the support of Generics in the Intermediate Language (IL). As such, languages such as C# and VB.NET now support this new feature. You've heard a lot about Generics in C#, but seldom hear people talk about it in VB.NET. In this article, Wei-Meng Lee introduces Generics to the VB.NET programmer.

C# Generics (Windows DevCenter)
The single most anticipated (and dreaded?) feature of Visual C# 2.0 is the addition of Generics. Jesse Liberty shows you what problems Generics solve, how to use them to improve your code, and why you need not fear them.

Creating an FTP Client in .NET (Windows DevCenter)
"The .NET framework provides the plumbing, allowing you to concentrate on the application you are building." At least, that's the theory, but when it comes to FTP, .NET has a bit of a gap in the pipes. Jesse Liberty shows you how to write a simple FTP application in .NET.

New Features in VB.NET Whidbey, Part 1 (Windows DevCenter)
Microsoft has recently released the Community Preview of the next Visual Studio .NET, Whidbey. One of the enhancements in Whidbey is the new improved VB.NET language. Wei-Meng Lee shows you what is in store with the new language features.

DataGrids, Improved (Windows DevCenter)
In Jesse Liberty's book Programming ASP.NET, he was unable to begin the discussion of DataGrids without first describing, in some detail, the ADO.NET object model, including DataAdapters, DataTables, DataSets and DataReaders. In this, the first column on Whidbey, he shows how to use Whidbey's new ASP.NET DataGrids.

Introducing WiX (Windows DevCenter)
Microsoft recently surprised quite a few people by releasing the WiX toolset under an open source license (the Common Public License, to be precise) and hosting its source code on the premier open source community site SourceForge. In this article, Mike Gunderloy gets you started with WiX.

New Language Features in C# 2.0, Part 2 (Windows DevCenter)
The first part of this series introduced three new C# language features: anonymous methods, iterators, and partial types. In this second part, Matthew MacDonald tackles the last and most exciting new feature: Generics.

New Language Features in C# 2.0, Part 1 (Windows DevCenter)
Four years ago, a new upstart language named C# surprised the development world with its elegance and consistency. Now that Microsoft has released a technology preview version of Visual Studio 2005 (formerly codenamed Whidbey), .NET's favorite language is back, with some new innovations. In this two-part servies by Matthew MacDonald, you'll get a first look at three of the four major language refinements in the latest version of C#.

Writing Managed Wrappers with Managed C++ (Windows DevCenter)
The second article of this series focused on the ability to mix managed and unmanaged code in the same module, which is an ability that is unique to Managed C++. In this latest installment, Sam Gentile takes this one step further to show you how to take existing legacy unmanaged C++ code and make it usable from any CLR language in the managed world.

Create Project Item Wizards (Windows DevCenter)
In a recent project, Niel Bornstein and his team had to produce a platform that included a set of base classes that other developers could use to develop Windows forms in Visual Studio .NET 2003. As the team worked on the base classes, it became clear that the developers would be able to crank out their forms a lot faster if they could also generate stubs and skeleton code for all the methods they needed to override in their own classes. Niel explains how to do it in this article.

Graphical Composition in Avalon (Windows DevCenter)
Longhorn introduces significant new graphics technology, codenamed "Avalon." Avalon renders an application's visual elements onto the screen using a much more sophisticated approach than Windows has previously used. In this article, Ian Griffiths show how this new graphical composition model solves various limitations of Win32, what new user interface design techniques this enables, and what it means to developers.

Serialization in .NET, Part 2 (Windows DevCenter)
In a previous article, Dan Frumin discussed the benefits of using .Net's built-in serialization support in your applications. As you probably realize, the objects offered to us by .Net are quite powerful and useful. However, not every core class within .Net implements serialization, so sooner or later you're going to run into its limitations. In this second article, Dan shows you a solution. 

Cooking with C#, Part 2 (Windows DevCenter)
In this second and final batch of recipes excerpted from the recently released C# Cookbook, learn how to obtain the HTML from a URL and how to efficiently synchronize the reading and writing of a resource.

Developing Web-Service-Driven, Smart Mobile Applications (Windows DevCenter)
Working with web services and other network protocols that were designed with broadband in mind can become a real burden to making applications really mobile. But there is hope. Michael Yaun walks through the design and implementation of a complete end-to-end mobile application that solves these difficult problems.

Effective Forms Authentication, Part 2 (Windows DevCenter)
In the first article in this series, we introduced the basics of forms authentication in ASP.NET. By the end of the article, you saw how to use code in a login page to authenticate users according to various custom schemes, and how to use additional code to build custom principal and identity objects to fully identify users and their roles. That earlier solution, while complete, is a bit unsatisfying. In this second article, Mike Gunderloy explains how to make authentication more than satisfying.

ADO.NET Connection Pooling Explained (Windows DevCenter)
Because the .NET managed providers manage the connection pool for us, using shared database connections is as easy as a summertime splash in the kiddie pool. But if those connections unexpectedly become invalid you could find yourself floundering in the deep end. In this new article, James Still will have you doing laps in no time.

Cooking with C# (Windows DevCenter)
Learn how to convert a string returned as a Byte[ ] back into a string, and how to handle an exception that occurs within a method invoked via reflection, in these sample recipes from C# Cookbook.

Effective Forms Authentication, Part 1 (Windows DevCenter)
ASP.NET offers several possibilities for authenticating users, but when you come right down to it, there's only one reasonable alternative for most applications: forms authentication. Mike Gunderloy takes you step-by-step through creating a forms authentication project and helps you avoid the potholes.

Serialization in .NET, Part 1 (Windows DevCenter)
Serialization of data using built-in .NET support makes persistence easy and reusable. Dan Frumin reviews the support available for serialization and look at a couple of scenarios for using it.

Cooking with ADO.NET, Part 2 (Windows DevCenter)
In O'Reilly's ADO.NET Cookbook, you'll find more than 150 solutions and best practices for everyday dilemmas. This week, we're offering two more recipes from the book that show how to create and then synchronize a master-detail pair of DataGrid controls, as well as how to improve performance when a user pages through a large result set in a data grid.

Inside XAML (Windows DevCenter)
One of Longhorn's most interesting technologies for developers is its new XML-based markup language, codenamed XAML (short for eXtensible Application Markup Language, and pronounced "Zammel"). User interfaces in Longhorn applications are typically built using XAML. Ian Griffiths looks at how XAML relates to the underlying support provided by WinFX.

New Data Controls in ASP.NET Whidbey (Windows DevCenter)
One of the design goals of the next release of ASP.NET, codenamed ASP.NET Whidbey, is to reduce the amount of code you write for common tasks such as data access. Wei-Meng Lee discusses two new controls that drastically reduce the amount of code you typically need to write in ASP.NET.

Using the Security Controls in ASP.NET Whidbey (Windows DevCenter)
Forms authentication in .NET has been a godsend, making general authentication a whole lot easier. But Microsoft is not stopping there. Wei-Meng Lee shows how the new Whidbey Security Controls makes simple authentication even easier.

Cooking with ADO.NET (Windows DevCenter)
O'Reilly's recently released ADO.NET Cookbook contains over 150 solutions and best practices for everyday dilemmas. This week, we're excerpting three recipes from the book that show how to asynchronously update data in a database, how to protect login credentials during network transmissions, and how to enforce a business rule with column expressions.

Master and Content Pages in Whidbey (Windows DevCenter)
Most web sites have a consistent look and feel, containing a company logo and perhaps a navigational menu. In ASP.NET 1.0, there was no a good way to handle this; luckily, Microsoft now has a solution. Wei-Meng Lee shows you the Master and Content Pages feature in ASP.NET 2.0.

Creating Your Own Code Snippets with Whidbey (Windows DevCenter)
One of the new features found in Visual Studio .NET Whidbey is Insert Snippets. The Insert Snippets feature allows you to insert commonly-used code blocks into your project, thereby improving the efficiency of your development process. Wei-Meng Lee shows you how to add your own snippets to Whidbey.

WinFX: An All-Managed API (Windows DevCenter)
In Longhorn, Win32 will no longer be the principal API. It will, of course, continue to be supported; 20-year-old DOS applications still run on the latest version of Windows, and likewise, Win32 applications will also continue to work for the foreseeable future. But just as DOS and 16-bit Windows applications were superseded by Win32 applications, so in Longhorn will Win32 become the "old way" of doing things. In the first edition of this new column by Ian Griffiths, he explains why an all-managed API is a good thing.

Longhorn SDK Annotations (Windows DevCenter)
At last month's Professional Developers Conference, Microsoft unveiled the core features that will be added to the Windows platform, code-named Longhorn. Among the new features is a new experimental facility to the MSDN library: the Longhorn SDK. Working closely with Microsoft, O'Reilly has seized upon this new feature that allows third parties to use RSS feeds to enhance the Longhorn SDK docs. O'Reilly is the first to provide a Microsoft-recommended source of annotations through this new mechanism. Ian Griffiths looks at the anatomy of the annotation source, as well as the inner workings of the client-side RSS component.

Understanding Reflection, Part 2 (Windows DevCenter)
In the first article of this series, Nick Harrison explored some of the basic objects used to make reflection work. In this second part, he shows you how to use custom attributes to define and reference metadata that the original .NET designers never imagined.

Using the eBay SDK (Windows DevCenter)
Unless you've been living in a cave, you probably already know that eBay enables people and businesses to buy and sell items online. But you might not have known that you can write software applications that integrate with eBay through a handy set of .NET components. Jeffrey McManus gives you an overview of how to write apps using the eBay SDK for .NET.

.NET Serialization, Part 2 (Windows DevCenter)
In his last article, Wei-Meng Lee discussed how to serialize objects into a binary stream, as well as into a SOAP message. In this new article, he shows you how to serialize objects into an XML document.

What Is Being Unveiled at the PDC this Year? (Windows DevCenter)
This week, Microsoft is holding their periodic developer conference, the Professional Developers Conference (PDC) in Los Angeles. Much like most PDCs, this event is a time to unveil their new plans for software across their developer products. Hopefully, this article will help you associate the codenames with the content. In the coming weeks, you will hear, from every media outlet, these codenames being bandied about. Shawn Wildermuth gives you an overview of the codenames and their meanings to you, the working developer.

Filtering HTTP Requests with .NET (Windows DevCenter)
ASP.NET has a number of extensibility points that developers can use. One such point is response filtering, accessible via the Filter property of the HttpResponse class. Ben Lowery shows you how to use HTTP filters in your own code.

.NET Serialization, Part 1 (Windows DevCenter)
Many a time, you may need to persist the value of an object to secondary storage. For example, you may wish to save the values of a couple of Point objects, representing the positioning of an item on screen, to secondary storage. The act of “flattening” an object into a serial form is known as serialization. Wei-Meng Lee discusses serialization as supported in the .NET framework –- Binary and SOAP serialization.

Understanding Reflection, Part 1 (Windows DevCenter)
Sometimes it is useful to be able to examine information about the objects in your applications. In this article, Nick Harrison starts you out with the basics of reflection.

Globalizing and Localizing Windows Application, Part 2 (Windows DevCenter)
In his last article, Wei-Meng Lee discussed about how to localize your Windows application using the CurrentCulture property. In this article, he leads you through continuing work on localizing a Windows application so that it can now display different languages according to the culture selected.

Debugging ASP.NET (Windows DevCenter)
Those of you who have developed Web applications using ASP before know how cumbersome debugging your application is. Things have changed drastically with the launch of the .NET framework. In .NET, you can use the debugger in Visual Studio .NET to trace through the execution of your web application. Wei-Meng Lee shows you how it is much easier in ASP.NET.

Enhancing ASP.NET Pages with JavaScript (Windows DevCenter)
A sprinkling of JavaScript code can enhance the reach and responsiveness of your ASP.NET web pages without sacrificing ASP.NET's secure, server-based model for your coding. Matthew MacDonald, coauthor of ASP.NET in a Nutshell, 2nd Edition, shows you how to use JavaScript in an ASP.NET web page to perform three common tasks: showing a pop-up window, changing control focus, and handling frame navigation. You can use these tricks to quickly solve problems that have no native .NET solution.

Debugging Windows Services (Windows DevCenter)
Debugging Windows services is not as trivial as debugging Windows applications because they do not run directly within Visual Studio .NET. Hence, more elaborate techniques must be deployed to effectively develop and debug Windows services. In this article, Wei-Meng Lee will discuss two techniques that you can use to debug and test your Windows services.

Implementing Custom Data Bindable Classes: IList (Windows DevCenter)
It's no accident that DataSet, Array, TreeNodeCollection, and many other collection classes all behave in a predictably similar fashion. Each of them derives from the IList interface and each of them fully implements all of the methods defined by that interface's contract. Thus, you can use them as data sources for iterative controls like the DataGrid or list controls like DropDownList. In this article, James Still explains how to implement the last of our Data Binding interfaces.

Globalizing and Localizing Windows Applications, Part 1 (Windows DevCenter)
With the explosive growth of the Internet and rapid globalization of the world's economies, the earth is getting smaller and smaller. The applications that you develop for a local market may soon be used in another country. If the world used a common language, that would make the life of developers much easier. However, reality is far from perfect. Wei-Meng Lee shows you how to make your applications ready for the global marketplace.

Service-Oriented Architecture Explained (Windows DevCenter)
SOA (service-oriented architecture) has become a buzzword of late. Although the concepts behind SOA have been around for over a decade now, SOA has gained extreme popularity of late due to web services. Before we dive in and talk about what SOA is and what are the essentials behind SOA, it is a useful first step to look back at the evolution of SOA. To do that, we have to simply look at the challenges developers have faced over the past few decades and observe the solutions that have been proposed to solve their problems. Sayad Hashimi gets you started with SOA.

Developing Windows Services (Windows DevCenter)
A Windows Service is an application that does not have a user interface. It commonly runs without human intervention and can be automatically started when the computer starts up. Examples of Windows Services are IIS (Internet Information Server), Telnet and FTP. Windows Services were formerly known as NT Services. Wei-Meng Lee illustrates how to create a Windows Service using Visual Studio .NET 2003.

The Factory Design Pattern (Windows DevCenter)
Many popular software libraries make extensive use of design patterns so that the APIs can be abstracted out at a high level for the end programmer. The .NET Framework Class Library (FCL) is no exception. Given that the FCL builds on the strengths of Microsoft's experience with developing software libraries, one can assume that instances of design patterns found in the FCL are fairly appropriate usages of these patterns. In this article, Amit Goel describes some instances of a commonly occurring design pattern in the FCL: the Factory Method design pattern.

Introduction to System.DirectoryServices, Part 2 (Windows DevCenter)
In the conclusion to this two-part series on using the .NET Framework's System.DirectoryServices namespace, Robbie Allen, coauthor of Active Directory, 2nd Edition, looks at how to search with the DirectorySearcher class.

Introduction to System.DirectoryServices, Part 1 (Windows DevCenter)
The .NET Framework's System.DirectoryServices namespace contains numerous classes, but two you should become familiar with are DirectoryEntry and DirectorySearcher. In Part 1 of this two-part series, Robbie Allen, coauthor of Active Directory, 2nd Edition, covers the DirectoryEntry class and shows examples of how to iterate over the attributes of an object. In Part 2 next week, he'll cover the DirectorySearcher class and show examples of how you can modify objects.

Understanding Attributes (Windows DevCenter)
Attributes are widely used in the .NET Framework to annotate code. For example, XML serialization uses attributes to control how a class is serialized. The syntax of attributes can be confusing until you realize that attributes are actually just managed classes. Satya Komatineni provides a quick guide to understanding attribute syntax, how to read it, and how to look up attribute documentation in order to be able to specify them in your programming practice.

StringBuilders Explained (Windows DevCenter)
Visual Basic programmers have long enjoyed ease in string manipulations. It is easy to create a string, split it up, concatenate multiple strings, etc. However, this seemingly innocent piece of code is not the recommended way to perform string manipulations in .NET. Wei-Meng Lee shows you how to make sense of the StringBuilder class.

XSLT Performance in .NET (Windows DevCenter)
The Microsoft .NET Framework brings with it many new tools and improvements for developers. Among them is a very rich and powerful set of XML classes that allow the developer to tap into XML and XSLT in their applications. Before the Microsoft .NET Framework was released, Microsoft published the XML SDK, now in version 4.0. Which raises the question: how do these two engines compare to each other in performance? Dan Furmin shows you the results of his performance comparison.

Using Network Streams (Windows DevCenter)
Wei-Meng Lee's earlier article on .NET streams talked about the various implementations of the Stream class, such as the BufferedStream, FileStream, MemoryStream, and CryptoStream classes. One class which wasn't discussed is the NetworkStream class. In this article, he discusses the use of the NetworkStream class for network communication and how easy it is to use it for socket programming.

Static Constructors Demystified (Windows DevCenter)
Static classes in C# are an important tool that most developers should know how to use effectively. The confusion usually surfaces when dealing with static constructors to set up a static class. Understanding some of the issues surrounding static constructors, like beforeFieldInit and static field initialization, will help you effectively use static initialization features of your static class. Satya Komatineni explains the intricate nature of static classes and their constructors.

Implementing Custom Data Bindable Classes: IEnumerable (Windows DevCenter)
Most of us remain blissfully unaware of the implementation details behind the scenes when we use foreach to iterate over an array or some other collection. And as long as we use one of these out-of-the-box data structures we don't have to worry about it. But many times, the standard collection classes fail to meet our specific needs. James Still explains how to make this work for your own classes.

Understanding Interfaces in .NET (Windows DevCenter)
.NET introduces the potentially confusing concept of an interface. An interface is a contract that defines the signature of some piece of functionality. Throughout the .NET framework, interfaces are used to define that certain types have well-known behaviors. Nick Harrison explains what interfaces are and how to use them in your own classes.

Effective Interop with Managed C++ (Windows DevCenter)
Managed C++ offers unmatched power to developers who need legacy C++ applications to interoperate with .NET. The hybrid nature of managed C++ becomes a strength in these situations because you're able mix your legacy C++ code with managed C++ in nearly any combination. John Bush shows you how to interoperate between managed and unmanaged C++.

Using Delegates to Implement Event Handling (Windows DevCenter)
In this article, Jesse Liberty focuses on how delegates are used to implement event handling, with a look at the implementation of a custom event. Jesse is the author of the recently released Programming C#, 3rd Edition.

Using log4net (Windows DevCenter)
Logging is an essential tool in every developer's arsenal. It helps them to identify problems faster by showing them the state of an application at any given point. Nauman Leghari shows you how to use the open source log4net.

Using Regular Expressions and XML Classes to Parse Your Log Files (Windows DevCenter)
Most systems these days can generate log files to store activity of the system. What about when you are asked to transform all that data into usuable information? Roy Osherove shows you how to use regular expressions and .NET's XML classes to turn your log files into a DataSet to allow you to search, sort, or report on your data.

Implementing Custom Data Bindable Classes: CollectionBase (Windows DevCenter)
By now, everyone is familiar with grabbing a DataSet from the database and binding it at runtime to an ASP.NET list control. This works just fine. But DataSets are weakly typed, providing late bound access to their properties. What if you want to use your own strongly typed custom object with meaningful properties and methods instead of a generic DataSet? James Still shows you how to create them for your own classes.

Introduction to Programming with Managed DirectX 9.0 (Windows DevCenter)
The industry standard 3D API, OpenGL, is not the only 3D API that you can use on the .NET platform in the Microsoft Windows environment. Another choice is DirectX, which has been steadily increasing its functionality, stability, and market share among developers writing all sorts of Windows multimedia software, games, and other applications that make use of 2D and 3D graphics. Jacek Artymiak shows you how to write 3D applications using the Managed Interface to DirectX 9.0.

Using Calculated DataColumns in ADO.NET (Windows DevCenter)
If you have a background in database work, you have undoubtedly run into the rules of normalization. But even though ADO.NET's DataSet class is sometimes described as a "relational database in memory," it's important to remember that there are differences between databases and DataSets. In this particular case, the DataSets are designed to manage calculated columns. In this article Mike Gunderloy will show you the syntax for building calculated columns in your own DataSets, and discuss some of the pros and cons of using such columns.

Top Ten Gotchas in Upgrading to .NET Framework 1.1 (Windows DevCenter)
Some of the most interesting changes from .NET 1.0 to .NET 1.1 are in the Framework Class Library. Microsoft has catalogued over 100 breaking changes as a result of the new version. While many of these changes are in specialized areas that most .NET developers will never visit, there are some major changes that you should be aware of, lest they bite you when you upgrade.

Introduction to VB.NET Object-Oriented Features (Windows DevCenter)
It used to be the case that Visual Basic was regarded as a "toy" language. This is partly due to the fact that VB does not contain certain advanced features like pointers access and object-oriented programming. Not anymore! Wei-Meng Lee introduces these features to Visual Basic programmers everywhere.

Instrumenting Your .NET Applicaiton (Windows DevCenter)
As they refine the .NET story, Microsoft seems to be getting more and more serious about pushing into the "enterprise" space. One of the latest pieces of evidence of this push is the release of the Enterprise Instrumentation framework (EIF), a set of classes and utilities that work with the .NET languages to provide white-box monitoring for distributed applications. Mike Gunderloy shows you how to add instrumentation to your own .NET applications.

What's New in Windows Server 2003 (Windows DevCenter)
They did it. Microsoft has finally released Windows Server 2003. Sure, they did a ninth-inning renaming of the operating system from Windows .NET Server to Windows Server 2003. But there are still many features that the .NET developer should be salivating over. Shawn Wildermuth counts down the top ten features that you should know about.

Basic Drawing with GDI+ (Windows DevCenter)
The .NET framework and GDI+ introduce a new paradigm for drawing in Windows. It drastically simplifies your code, while still providing you with powerful access to the underlying Win32 routines through a rich set of classes. Niklas Gustavsson explains how to get started with GDI+.

The Secrets of Strong Naming (Windows DevCenter)
If you've been working with .NET for any length of time, you've probably run across the concept of a strong name. No, that doesn't mean that your assemblies should have names like MyCompany.Gorilla.Biceps. The strength of a strong name lies in the protection that it offers your assemblies. The .NET Framework uses strong names to identify assemblies and to protect them from tampering. In this article, Mike Gunderloy shows you how strong names are constructed and demonstrates the mechanics of working with strong names in .NET.

Using OpenGL with VB.NET (Windows DevCenter)
Although VB.NET is not the first programming language that comes to mind when you are thinking of writing applications that use the OpenGL API, it is possible (and not that difficult), if you are willing to dip your toes in the warm waters of open source software. In this article, Jacek Artymiak shows you how to use OpenGL in your own .NET apps.

Isolated Storage Basics (Windows DevCenter)
It's not unusual for an application to need to store some data for later use; maybe your application allows the user to set persistent options or save work in progress. But even the simple act of saving data can be fraught with dangers in today's world. In this article, Mike Gunderloy shows you how to use isolated storage to save your data.

Client/Server Rendezvous on the LAN (Windows DevCenter)
You're a grizzled, veteran network programmer. You've mastered RPC and DCOM, and you think .NET remoting is child's play. Web services? Web schmervices. And yet, could it be that of all of the aforementioned networking technologies, none of them provide an easy way for your clients and servers to find each other on the network? Have you now designed, developed and shipped a dozen different client-server software products, with a dozen different clumsy dialog boxes prompting your poor, confused users to enter host/endpoint information in order to establish a connection? Is there not a better way? Shawn Van Ness shows you how its done.

.NET Streams Explained (Windows DevCenter)
On of the common challenges facing beginning .NET programmers is the large number of classes in the .NET Class Library. Looking for the correct class to use for file handling can be confusing. There are many classes in the System.IO namespace, each looking not much different from the others. Wei-Meng Lee explains the differences between the Stream classes.

A Quick Introduction to WMI from .NET (Windows DevCenter)
Windows Management Instrumentation (WMI) is Microsoft's implementation of the Web Based Enterprise Management Initiative. There is a lot to the WMI architecture, making it the preferred technology for monitoring applications on the Windows platform. Luckily, it's a lot easier with .NET.

Managing ASP.NET Navigation (Windows DevCenter)
In an ASP.NET application, you can move between Web Forms in a variety of ways: with hyperlinks, with Response.Redirect, with Server.Transfer, or with Server.Execute. Mike Gunderloy takes a look at these various navigation methods and help you choose the appropriate one for your application.

Using the XmlDataDocument Class (Windows DevCenter)
The DataSet class in ADO.NET provides the developer with a relational view of data. Using the DataSet, data are stored as tables, which allows for easy retrieval using SQL statements. However, there are times when you need a hierarchical representation of the data, allowing you to perform quick searches using, say, XPath queries. You may also need to transform a set of data into another format using XSLT. In such cases, the .NET framework provides you with the XmlDocument class for this purpose. Wei-Meng Lee shows you how to use this bridge between ADO.NET and the XML namespaces.

Improving Typed DataSets (Windows DevCenter)
The first time Shawn Wildermuth used a typed DataSet, it was much like the beginning of a relationship. After dealing with raw DataSets, typed DataSets seemed elegant and perfect. Soon the cracks in the facade appeared. He knew that typed DataSets were much easier to work with than raw DataSets, but he still longed to be able to change some of the way that the code was generated. Unlike relationships, we have some limited control of how typed DataSets work. In this article, Shawn will show you how to use typed DataSet annotations and how they can change the way that typed DataSets are generated.

Choosing the Right Session State Storage (Windows DevCenter)
You probably already know about the use of Session variables to store information in an ASP.NET session. Determining where this session state actually resides depends on a number of different criteria. In this article by Mike Gunderloy, he will show you how to make the right decision.

Configuration Handlers in .NET (Windows DevCenter)
In the shiny new world of .NET-based applications with xcopy deployment and smart clients, we can no longer use the registry to hold application configuration information. Instead, we're supposed to use XML-based configuration files accessed via the CLR's pluggable configuration framework. In this article by Ben Lowery, he explains how this all works.

Binding Policy in .NET (Windows DevCenter)
So you're ready to deploy version 1.1 of your library, and you'd like it to replace version 1.0 for existing applications. Or perhaps something else has globally upgraded to 1.1, and you need to downgrade it for a particular application where 1.1 is causing problems. Handling these issues for .NET applications is the job of runtime binding policy. In this article, Mike Gunderloy explains the basics of runtime binding policy, and shows you how you can customize the process for your own applications.

ASP.NET Data Controls Part 3: DataList (Windows DevCenter)
In this third part of the ASP.NET Data Controls series, Wei-Meng Lee talks about the DataList control. The DataList control is somewhat of a combination of the DataGrid and Repeater controls. It works like the Repeater control, allowing you to create templates so that it can be bound to a data source. It also allows you to edit records, much like the DataGrid control.

Writing Type-Safe Collections in C# (Windows DevCenter)
Compiled programming languages allow earlier error checking, better enforcement of programming styles, and generation of more efficient object code than interpreted languages, where all type consistency checks are performed at run time. However, even in compiled languages, there is often the need to deal with data whose type cannot be determined at compile time. This article by Amit Goel shows you how to create compile-time checked collections in C#.

ASP.NET Data Controls Part 2: Repeater (Windows DevCenter)
In his last article, Wei-Meng Lee talked about using the DataGrid server control. The DataGrid control is a versatile control and allows a high degree of customization. However, if your intention is to simply display items from a data source as a HTML table, there is a simpler control–-the Repeater control.

Intro to Managed C++, Part 2: Mixing Managed and Unmanaged Code (Windows DevCenter)
In the first article of the series, Sam Gentile focused on what Managed C++ was, some of its advantages and roles, and scenarios in which it excelled. One of those scenarios is the focus of this article: the ability to mix managed and unmanaged code in the same module.

ASP.NET Data Controls Part 1: DataGrids (Windows DevCenter)
One of the most powerful server controls in ASP.NET is no doubt the DataGrid control. The DataGrid control is a multi-column, data-bound ASP.NET server control. Using the DataGrid control, you can display records from a database using a variety of formats. In this article, Wei-Meng Lee shows you how to create and use the DataGrid.

Using Delegates Asynchronously (Windows DevCenter)
In Satya Komatineni's article "Understanding the Nuances of Delegates in C#," the concept of delegates and their general pattern of usage in C# was introduced. This article by Richard Blewett takes the subject further and looks at another feature of delegates-–the built-in ability to perform tasks asynchronously by handing off work to the system thread pool.

Plumbing the Depths of the ThreadAbortException Using Rotor (Windows DevCenter)
Chris Sells was asked the other day how calling Thread.Abort could raise an exception in a completely different thread. Finding the answer led him on a merry chase.

Understanding .NET Permissions: Where Did That Permission Come From? (Windows DevCenter)
The .NET security system is a marvelously intricate invention. You can customize the permissions available to an individual assembly or a group of assemblies (such as all code from a particular publisher) on an amazingly granular level. But many developers are a bit hazy on how all the pieces fit together to generate these permissions. In this article, Mike Gunderloy will walk you through the process of calculating permissions by hand. Armed with this knowledge, you can more effectively configure .NET to secure your assemblies.

Five Quick Tips for Using XSLT (Windows DevCenter)
Like so many acronyms before it, XSLT (eXtensible Stylesheet Language Transformations) comes across as YAOT--Yet Another Obfuscated Technology. But it doesn't have to be that way. XSLT promises many advantages when applied to the right problems. All you need is a quick guide on using the XSLT basics. In this article, Dan Frumin gets you started with this powerful language.

Basic Crypto w/ the .NET Framework (Windows DevCenter)
The .NET Framework offers basic support for cryptographic operations inside of the System.Security.Cryptography namespace in the mscorlib assembly. Out of the box, you are provided with implementations of many common symmetric key and public key-based algorithms. In addition, the cryptography framework was designed to be extensible, so that your implementation of any algorithm can be plugged in quite easily. In this article by Ben Lowery, he gets you started with Cryptography in .NET.

Using the CodeDOM (Windows DevCenter)
One of the promises of .NET is that the language used is secondary to the framework. The classes in the CodeDom namespace really drive this point home. Using CodeDom, we build a tree, or graph, populated with objects from the System.CodeDom namespace, and after the tree is populated, we use the CodeProvider object provided by every .NET language to convert the tree into code in that language. This makes switching languages as simple as switching the CodeProvider used at the end. In this article, Nick Harrison shows you the ins and outs of using the CodeDOM.

Using NAnt to Build .NET Projects (Windows DevCenter)
With Visual Studio .NET, you can easily build and compile .NET projects that contain any number of sub-projects —- collections of interdependent web pages, executables, DLL assemblies, and so forth — with a single menu command. But relying on a single programmer hitting the "compile" button doesn't always work for large and complicated projects. This article by Jeffrey P. McManus shows you how to use NAnt to build complicated projects.

Distributed .config Files with Smart Clients (Windows DevCenter)
The new model provided by .NET smart clients has really taken hold in the imaginations and the business plans of .NET developers. The idea of getting the best of both the richness of real Windows applications and the zero-touch installation of web-based applications is turning the heads of many an IT professional. Of course, as soon as a brand new model starts being put to real use, problems show themselves. In this new article, Chris Sells shows you how to solve these problems.

ASP.NET Forms Authentication, Part 2 (Windows DevCenter)
ASP.NET brought us Forms Authentication, which encompasses and extends the application security layer seen in most Web applications. We can extend Forms Authentication's functionality to authenticate against the Active Directory, hence adding an OS security level without the user having to provide his or her credentials multiple times. In this article, Abdel Banda explains how to log in with Forms Authentication using an active account in Active Directory.

Hosting Windows Forms Controls in COM Control Containers (Windows DevCenter)
As wonderful as the new WinForms control model is, if you still need to host controls in COM control containers, you are limited to exactly one control host that also supports the hosting of WinForms controls: Internet Explorer. If you want to host your controls in COM containers, Chris Sells shows you how in this article.

Dealing with Group By and Order By in .NET (Windows DevCenter)
In many situations, an ADO.NET developer will want to use the Order By and Group By semantic of SQL. This article by Satya Komatineni will show you how to do it.

Introduction to Managed C++ (Windows DevCenter)
Managed C++ often gets a bum rap in the world of .NET. Some of it is deserved, some is not, and some comes from just plain misunderstanding. In this article, Sam Gentile demystifies Managed C++.

ASP.NET Forms Authentication - Part 1 (Windows DevCenter)
In many Web applications, there is a need to authenticate users to allow them access to different parts of a site based on their credentials. This article by Abel Banda shows you how you can do this in ASP.NET with Forms Authentication.

Using Remote Data Access with SQL Server CE 2.0 (Windows DevCenter)
Microsoft SQL Server CE edition is the database server built by Microsoft to run on mobile devices. Besides being a standalone database for mobile applications, SQL Server CE also allows you to connect to your desktop SQL Server 2000 and perform remote data access and merge replication. In this article, Wei-Meng Lee will show you how to build a .NET Compact Framework mobile application using Visual Studio .NET 2003 and how it can perform remote data access using SQL Server CE 2.0.

ASP.NET Caching (Windows DevCenter)
Caching is an important concept in computing. When applied to ASP.NET, it can greatly enhance the performance of your Web applications. In this article, Wei-Meng Lee discusses some of the techniques for caching ASP.NET pages on the server side.

Transparent Database Access with ADO.NET (Windows DevCenter)
The dream of transparent data access is to not have to care about where the data is coming from; you have more important things to worry about, like providing a nice user interface and getting the business logic right on time. Ideally, it should not matter whether the data is coming from SQL Server, Oracle, Outlook, or anywhere else useful data may be stored. This article by Nick Harrison explains how to achieve this nirvana in .NET.

Multiple ResultSets in ADO.NET (Windows DevCenter)
Most Web Forms applications need to load multiple pieces of data. Many times we end up querying the database again and again for different data, and this reduces scalability and adds more stress to the backend database. This article by Srinivasa Sivakumar explains how to use multiple ResultSets in SQL Server and Oracle.

Using NDoc: Adding World-Class Documentation to Your .NET Components (Windows DevCenter)
Shawn Van Ness had never been a big fan of source-code-based documentation generators - tools that attempt to produce reference documentation by mining specially-formatted comments from source code. The concept is clearly of great value: by scanning the source code, the doc-generator can alert the author to any code items that are missing documentation. But the rumors are true - he recently met a new documentation generator, and he's fallen in love. Its name is NDoc, and he does believe it loves him too.

Using Visual Studio .NET Macros (Windows DevCenter)
One of the often-overlooked features of Visual Studio .NET's productivity tools is the macro engine and extensibility model that's built into Visual Studio .NET. This model provides almost 200 objects that give you unprecedented control over the IDE. In this new article by Matthew MacDonald, he shows you how they can work for you.

Data Management in Windows Forms Applications, Part 1 (Windows DevCenter)
Chris Tavares has always enjoyed doing user interface work. As he puts it, the ability to put his work right on the screen in full view is what makes UI work different from back-end business logic, and it feels more satisfying somehow to write code that does something on the screen, rather than just adjust an account balance somewhere in some database. In this article, he will show you how the typical Model-View architecture works in .NET.

C# Generics in Rotor (Windows DevCenter)
If you want to try using generic classes and methods in C#, you don't have to wait -- Microsoft Research has released an experimental implementation. In this article by Dave Berry, he shows you how you can start working with it right away.

VB.NET OOP Part 4: Determining Constructors (Windows DevCenter)
We all know that constructors can be used to initialize values. But did you know that you can use determining constructors to "shape" the objects of a class? In this OOP series article, Budi Kurniawan shows what a determining constructor is and why it is sometimes imperative to have one.

Copying, Cloning, and Marshalling in .NET (Windows DevCenter)
Even after spending the last few years with the C# language, Shawn Van Ness recently found it worthwhile to step back and analyze what happens in some very simple scenarios, such as copying a value from one variable to another, or passing those variables as arguments to a method call. And that is the focus of this article.

What's New in Visual C++ .NET 2003 (Windows DevCenter)
The Visual C++ .NET 2003 release is out and it is perhaps the most significant and exciting release of the product since Visual C++ 4.0! In this article by Sam Gentile, he explains what has changed.

Announcing .NET Framework 1.1 (Windows DevCenter)
The next release of Visual Studio .NET is finally available for final public beta testing. Code named Everett, Visual Studio .NET 2003 comes with a new version of the .NET Framework. This article will explain what's in this new release.

VB.NET OOP Part 3: The Singleton Pattern (Windows DevCenter)
The Singleton pattern is a well-worn way to ensure that every client uses one instance of a particular class. In this article, Budi Kurniawan explains how to design a Singleton class and what the pattern is good for.

Implementing Drag and Drop in Windows Forms (Windows DevCenter)
One of the benefits of using a windowing system is the ability to drag and drop objects from one window to another. In this article I will discuss how you can use Windows Forms to develop applications that supports drag and drop operations.

VB.NET OOP Part 2 - Understanding Constructors (Windows DevCenter)
Beginners of OOP with VB.NET often don't pay enough attention to constructors. The reason for this is that their classes are usable even without a constructor. What's worse, many think constructors are just another type of method, which is simply not true. This article focuses on constructors and what they are used for, and shows some examples of using them.

Understanding the Nuances of Delegates in C# (Windows DevCenter)
C# introduced a keyword called delegate for utilizing such things as function pointers and call backs. The syntax of a delegate can be confusing, but one sure way to get latched on to the syntactical nuances of delegates is to understand a delegate's dual nature -- it exhibits the qualities of both a class and a function.

Working with ListView (Windows DevCenter)
Conventionally, you use the ListBox or ComboBox controls to display a collection of items in a Windows program. However, if you want more flexibility and capability, you can use the ListView control. The ListView control looks exactly like the right pane in your Windows Explorer, and you can display items in one of four views. Each item is represented by the ListViewItem class. This article is a technical how-to on ListView and ListViewItem and offers three examples on how to use ListView.

.NET Localization, Part 4: Localizing Units (Windows DevCenter)
When a Web site is accessible by the international community, one of the considerations is how we present units of measure: Length, Width, Height, Weight, Area, Volume, etc. .NET provides some support by making available a RegionInfo class, which identifies whether a locale is mks (metric) or fps (imperial). Satya & Elena show you how.

.NET Localization, Part 3: Localizing Text (Windows DevCenter)
Localization is a process by which you allow people of different cultures, languages and nationalities access your Web site. Although still a difficult process, all things considered, it is gradually becoming easier. Both the Java platform and the .NET platform have some nice features to aid localization.

Using .NET Sockets (Windows DevCenter)
Writing programs that access the network used to be a relatively difficult task. With .NET, this is no longer the case. This article shows how to use the Socket class in a .NET client application.

C# News Ticker Multithreaded Application (Windows DevCenter)
Writing multithreaded applications is one of the more advanced topics in computer programming. Fortunately, the .NET Framework makes it a piece of cake by hiding the complexity in the classes in the System.Threading framework. This article shows you how to create a news ticker by using .NET's Threading and Synchronization Classes.

.NET Localization, Part 2: Creating Satellite Assemblies (Windows DevCenter)
Creating satellite assemblies is one of the major keys to developing large-scale localized projects. This article will show you how and why to use satellite assemblies.

Top Five ASP.NET Web Services Tips (Windows DevCenter)
Alex Ferrara, coauthor of Programming .NET Web Services, offers a brief comparison between ASP.NET Web services and .NET remoting, and then delves into five useful tips for developing ASP.NET Web services.

.NET Localization, Part 1: Resource Managers (Windows DevCenter)
Localization in ASP.NET happens with the resource manager. This article looks at some issues between resource manager and Visual Studio.

Creating ASP.NET Web Services, Part 1 (Windows DevCenter)
In part one in this series of book excerpts from Programming .NET Web Services, learn how to write an ASP.NET HelloWorld Web service application.

Getting Started with C#, Part 2 (Windows DevCenter)
In this final installment from Learning C#, we'll break down your first C# program by examining the details that went into creating it.

Introduction to OOP in VB.NET (Windows DevCenter)
With VB.NET, Visual Basic is, for the first time, an object-oriented language. Why did Microsoft makes the switch to OOP? Why is OOP superior? And why is it so hard to learn, even for experienced procedural programmers?

Getting Started with C#, Part 1 (Windows DevCenter)
Find out how to write your first C# program in this book excerpt from Learning C#. This is the first of two excerpts on getting started with C#.

.NET Application Services Part 2: A Unified Factory service (Windows DevCenter)
In part 2 of this series, we look at how the factory service builds on the simple config service to increase the flexibility of your .NET applications.

Object Serialization with the Memento Pattern (Windows DevCenter)
Using the memento pattern removes many of the problems with straight object serialization in C#. Budi Kurniawan shows you how.

Web Services: Objects or XML Endpoints? (Windows DevCenter)
Matthew MacDonald, coauthor of Programming .NET Web Services offers valuable advice for every .NET Web service programmer.

A Roadmap to the Recently Released Windows APIs (Windows DevCenter)
Motivated by the U.S. Department of Justice, Microsoft unleashes its once secret "Coca-Cola-like" recipe--the settlement Windows API documentation--for its operating system. Get a roadmap for shell functions, crypto functions, multimedia, RTL, and more.

C# Object Serialization (Windows DevCenter)
In object-oriented programming, you sometimes need to persist the state of an object into a file and then retrieve it later. The .NET Framework's object serialization technique makes this easy. Budi Kurniawan explains and demonstrates the underlying technology with a simple vector-based drawing application.

Beginnings of a Flexible .NET Architecture: A Simplified Config Service (Windows DevCenter)
Every app reads in configuration information at runtime. In .NET, this is done with an XML-based configuration file. This article proposes a "configuration service," which represents the beginning of a flexible architecture.

An Introduction to the .NET FCL, Part 5 (Windows DevCenter)
In this final installment from VB.NET Core Classes in a Nutshell, learn how to approach the .NET FCL.

Introducing ASP.NET Web Matrix (Windows DevCenter)
ASP.NET Web Matrix is Microsoft's latest offering for .NET programmers. Positioned somewhere between Visual Studio .NET and plain text editors, it provides a useful tool to accelerate development. This article looks at the capabilities of ASP.NET Web Matrix.

An Introduction to the .NET FCL, Part 4 (Windows DevCenter)
In part four in this five part series on the .NET FCL from VB.NET Core Classes in a Nutshell, learn the types of a .NET namespace.

C# Input/Output Classes Simplified (Windows DevCenter)
I/O operations in .NET can be confusing because there are so many similar classes. This article tries to clarify matters by showing you the appropriate classes for reading and writing bytes, characters, and binary data.

An Introduction to the .NET FCL, Part 3 (Windows DevCenter)
In part three in this series of book excerpts on the .NET Framework Class Library from VB.NET Core Classes in a Nutshell, learn how to work with the .NET FCL.

2002 OSCON .NET Report (Windows DevCenter)
Back from the 2002 O'Reilly Open Source Convention, we fill you in on developments on .NET.

An Introduction to the .NET FCL, Part 2 (Windows DevCenter)
In part two of this book excerpt series on the .NET Framework Class Library from O'Reilly's VB.NET Core Classes in a Nutshell, get an introduction to the .NET Framework Class Library (FCL).

The Rotor Architecture Revisited (Windows DevCenter)
Microsoft's Dave Stutz reports on activity around the Rotor project, which was recently refreshed. Besides .NET developers diving into the CLI source code, teachers and students are using it for compsci curriculum development, Microsoft is working on a project to add generics, and as reported on these pages, "diverse porting activity in the wild" has been sighted.

An Introduction to the .NET FCL, Part 1 (Windows DevCenter)
In part one of a five-part series of book excerpts from VB.NET Core Classes in a Nutshell, learn what it's like to develop without the .NET FCL library and its core classes.

Using Amazon's New Web Services (Windows DevCenter)
Amazon.com recently launched its Web services API initiatives, allowing customers to integrate its vast online content with their own web site. The author demonstrates how you can make use of this Web service using Visual Studio .NET.

User Controls and Custom Server Controls, Part 4 (Windows DevCenter)
In this final installment in a series of excerpts from ASP.NET in a Nutshell, learn how to share ASP.NET controls across applications.

Efficient String Manipulations with StringBuilder (Windows DevCenter)
In .NET programming, string manipulation with the String class is problematic, but there is an alternative -- the StringBuilder class. Learn how to use it in this article.

Developing Pocket PC Apps with SQL Server CE (Windows DevCenter)
A look at the new SQL Server CE edition, included in the .NET Compact Framework, in Pocket PC applications.

User Controls and Custom Server Controls, Part 3 (Windows DevCenter)
Part 3 of this four-part excerpt from ASP .NET in a Nutshell covers custom server contols.

User Controls and Custom Server Controls, Part 2 (Windows DevCenter)
In Part 2 in this series of excerpts from ASP.NET in a Nutshell, learn ASP.NET custom server controls.

Rotor Comes to Linux (Windows DevCenter)
Shaun Bangay has ported the shared source .NET CLI project, Rotor, to Linux. It's not just for FreeBSD anymore.

C# Printing Functions (Windows DevCenter)
In .NET, simple printing is simple, but functions such as choosing which printer to use or printing more than one copy are more complex. This tutorial shows how to use System.Drawing.Printing for these functions.

User Controls and Custom Server Controls, Part 1 (Windows DevCenter)
In part one from this series of book excerpts from ASP.NET in a Nutshell, get an overview on ASP.NET controls, and learn about ASP.NET user controls.

Controlling Web Pages on the Server Side (Windows DevCenter)
.NET's server-side programming model boasts huge advantages for Web development.

Building Palm Conduits, Part 4 (Windows DevCenter)
This final book excerpt in this series from Programming Palm OS with Visual Basic covers data formats, and packing and unpacking record data in a Palm application.

Building Palm Conduits, Part 3 (Windows DevCenter)
Learn about synchronization logic in building Palm conduits, in this excerpt from Programming Visual Basic for the Palm OS.

Exploring ASP.NET with the IBuySpy Case Studies (Windows DevCenter)
Matthew MacDonald looks at Microsoft's online examples of an e-commerce system and a Web portal created with ASP.NET. Matthew is coauthor of ASP.NET in a Nutshell.

Building Palm Conduits, Part 2 (Windows DevCenter)
In this excerpt from Programming Visual Basic for the Palm OS, learn how to design conduits using VB for the Palm OS.

VB .NET Custom Controls (Windows DevCenter)
Roll up your sleeves and write your own custom C# controls, using the Control and UserControl classes.

Building Palm Conduits, Part 1 (Windows DevCenter)
This excerpt from Programming VB for PalmOS, offers an introduction to building conduits, synchronization software that connects Palm apps and data stores.

Previewing the .NET Compact Framework (Windows DevCenter)
A quick look at Microsoft's Compact Framework for PocketPCs.

System.Drawing with C# (Windows DevCenter)
Learn the System.Drawing namespace, which contains types that help you with drawing. This crash course willl enable you to write better -- and probably faster -- code. Here is a 10-minute crash course.

An Introduction to VB.NET Attributes, Part 3 (Windows DevCenter)
The third and final part of this excerpt from O'Reilly's VB .NET Language in a Nutshell, the authors address custom attributes.

A Template for C# Windows Applications (Windows DevCenter)
Why go through the hassle of creating the same components and event handlers for every C# Windows application? This article offers a template for quickly creating menus, toolbars, buttons and other Windows components.

An Introduction to VB.NET Attributes, Part 2 (Windows DevCenter)
In this part two of three from a series of book excerpts from O'Reilly's VB.NET Language in a Nutshell, the authors show you how to define custom attributes.

Previewing Windows .NET Servers (Windows DevCenter)
At first glance, it may look like the differences between Windows 2000 servers and the .NET servers are minor. In fact, the changes mean substantial performance upgrades, improvements in IIS, and more than 50 handy command-line utilities.

An Introduction to VB.NET Attributes, Part 1 (Windows DevCenter)
In Part One of a three-part excerpt from O'Reilly's VB .NET Language in a Nutshell, the authors give an introduction to Attributes and its syntax and use.

C# in a Nutshell: Introducing C# and the .NET Framework, Part 3 (Windows DevCenter)
One of the most encouraging aspects about the .NET Framework is the degree of openness that Microsoft has shown during its development. This excerpt from C# in a Nutshell details how C# became an ECMA standard.

C# Key Processing Techniques (Windows DevCenter)
Capturing and processing keyboard input from the user are important tasks in various Windows programs. Even simple interactions require prompting the user for a keystroke or two. Depending on which keys you want to process, there are several techniques for capturing and processing keyboard input. In this article, Budi Kurniawan explores these possibilities.

C# in a Nutshell: Introducing C# and the .NET Framework, Part 2 (Windows DevCenter)
In the second part of our excerpt from O'Reilly's C# in a Nutshell, the authors introduce the Common Language Runtime and the Framework Class Library.

Top Ten Tips for Programming ASP.NET (Windows DevCenter)
From changing the default names of controls and forms to using the StringBuilder class, here are ten tips for programmers working with ASP.NET.

Writing C# Custom Events (Windows DevCenter)
In C# ,you can write your own events in your controls, which others can capture. In the article, you'll learn to use the Observer design pattern to handle events for your .NET control.

C# in a Nutshell: Introducing C# and the .NET Framework, Part 1 (Windows DevCenter)
What makes C# different? Besides being a full-fledged object-oriented language, C# was designed from the ground up for component-based programming, a unified type system, type safety, and most of all a pragmatic world view. Get a full introduction to C# is a three-part installment of O'Reilly's C# in a Nutshell.

Programming ASP.NET: Custom and User Controls, Part 2 (Windows DevCenter)
In Part 2 of this chapter from Programming ASP.NET, the authors describe how to program custom controls.

New Promises That Come with .NET (Windows DevCenter)
Are there new promises that come with .NET? Time will tell, but as 2002 unfolds, it's becoming more evident that Microsoft's .NET programming and Web services platform will be interoperable with operating systems other than Windows.

ASP.NET File Uploading (Windows DevCenter)
File upload and download are much simpler tasks in ASP.NET than in classic ASP, thanks to the extensive .NET Framework class library. While file upload in ASP.NET is as easy as retrieving an HTML form value, file download is still a bit tricky.

Programming ASP.NET: Custom and User Controls, Part 1 (Windows DevCenter)
In Part 1 of this chapter from Programming ASP.NET, the authors describe how to program user controls.

An Architectural Tour of Rotor (Windows DevCenter)
Microsoft's Dave Stutz provides a guided tour of the Shared Source CLI Implementation (Rotor), which Microsoft announced today. Rotor includes implentations of C# and CLI, and will build and run under Windows XP and FreeBSD 4.5.

Get Your Rotor Running (Windows DevCenter)
At 9,700 files and 1.9 million lines of code, Microsoft's Rotor is definitely a little intimidating. Brian Jepson helps demystify Microsoft's Shared Source CLI implementation to get you up and running.

Microsoft's Shared Source Record (Windows DevCenter)
Instead of open source, shared source is more in line with how Microsoft wants to release code outside its organization. It has released several shared source products, in addition to the CLI it plans to release.

Creating Custom .NET Controls with C# (Windows DevCenter)
When you need more functionality than .NET's built-in controls supply, it's time to roll your own. With the Control and UserControl classes, it's surprisingly simple.

.NET Framework Essentials, 2nd Ed.: Web Services, Part 4 (Windows DevCenter)
This fourth and final excerpt from O'Reilly's .NET Framework Essentials, covers Web services and security from the perspective of both system-level and application-level security.

C# Regular Expressions, Revisited (Windows DevCenter)
Brad Merrill, co-author of C# Essentials, 2nd Edition, explains what's changed with C# Regular Expressions since Beta1.

.NET Framework Essentials, 2nd Ed.: Web Services, Part 3 (Windows DevCenter)
In this book excerpt, O'Reilly's .NET Framework Essentials, 2nd Ed. authors Thuan L. Thai and Hoang Lam cover Web services consumer clients.

.NET Framework Essentials, 2nd Ed.: Web Services, Part 2 (Windows DevCenter)
In this book excerpt, O'Reilly's .NET Framework Essentials, 2nd Ed. authors Thuan L. Thai and Hoang Lam discuss Web Services service providers, which implement Web Services and advertise them so that the clients can discover and make use of the services.

Uncovering Rotor -- A Shared Source CLI (Windows DevCenter)
O'Reilly .NET editor Brian Jepson shares what he took from a recent BOF at BSDCon 2002 hosted by Microsoft's David Stutz on the shared source ECMA Common Language Infrastructure (CLI) implementation project known as Rotor, which would ideally foster true .NET language interoperability on other OS platforms like FreeBSD.

.NET Framework Essentials, 2nd Ed.: Web Services, Part 1 (Windows DevCenter)
In this article, O'Reilly's .NET Framework Essentials, 2nd Ed. authors Thuan L. Thai and Hoang Lam discuss Web Services in practice and provides a .NET Web services framework overview.

A Quick Tour of .NET Web Services (Windows DevCenter)
Brian Jepson gives you a quick tour of .NET Web services, using code snippets from recent talk given at a Visual Foxpro symposium. And yes, Foxpro can be used for .NET Web services as well.

Using P/Invoke to Access Win32 APIs (Windows DevCenter)
While the .NET Framework class libraries offer signficant functionality, COM interoperability is necessary in order to access native system APIs. This article demonstrates COM interoperability from within C#.

Top Ten Traps in C# for C++ Programmers (Windows DevCenter)
There are a number of features in C# that are potential traps for the unwary C++ programmer. Learn about the ten most dangerous in this article by Jesse Liberty, author of O'Reilly's Programming C#, 2nd Edition.

You Can Hack .NET Without Buying Visual Studio .NET (Windows DevCenter)
Brian Jepson explains how programmers can get started working with C#, without purchasing Visual Studio .NET.

What .NET Got Right (Windows DevCenter)
While .NET is not a J2EE killer, writes O'Reilly .NET editor Brian Jepson, it offers not only competitive features but a far superior development experience for newcomers.

ADO.NET, Part 5 (Windows DevCenter)
This final excerpt from Programming Visual Basic .NET concludes this series of excerpts with Typed DataSets, reading data into a DataReader, and executing stored procedures through a SqlCommand object.

Miguel on Mono (Windows DevCenter)
Miguel de Icaza gives an update on the developmental and licensing progress of Mono, the effort to bring .NET's functions to the Unix world.

Writing Your First COM Component, Part 2 (Windows DevCenter)
In Part 1 of this step-by-step guide, we created a COM component. In this installment, you'll complete the transformation from a standard DLL to a COM component.

ADO.NET, Part 4 (Windows DevCenter)
This is the forth installment from Programming Visual Basic .NET, focusing on binding a DataSet to a Windows and a Web Forms DataGrid.

ADO.NET, Part 3 (Windows DevCenter)
This is the third installment from Programming Visual Basic .NET, focusing on the relations between DataTables in a DataSet, and the DataSets XML capabilities.

Top Five Visual Basic .NET Tips (Windows DevCenter)
Every time Dave Grundgeiger digs down to find out how something is done in .NET, he's pleased by the simplicity and elegance of the solution. Dave's tips will help you get comfortable with VB .NET, and so will his new book, Programming Visual Basic .NET.

Writing Your First COM Components, Part 1 (Windows DevCenter)
With all the buzz surrounding COM+ components and n-tier applications, you're probably eager to learn how to build your first COM component. This short guide steps you through the process of creating your first component in minutes.

ADO.NET, Part 2 (Windows DevCenter)
In this second installment from Programming Visual Basic .NET, learn to connect to an OLE DB data source and read data into a dataset using ADO.NET.

ADO.NET, Part 1 (Windows DevCenter)
Many software applications benefit from storing their data in database management systems. In this excerpt from Chapter 8 of Programming Visual Basic .NET, the author show you how to connect to a SQL Server using ADO.

Object Oriented Programming for VB.NET - Part 2 (Windows DevCenter)
Interfaces, inheritance and polymorphism ... what do all those cool words mean? This article presents an introduction to object-oriented programming with VB.NET, a language that fully support OOP features.

Pulling Stock Quotes into Microsoft Excel (Windows DevCenter)
Steve Roman, the author of O'Reilly's Writing Excel Macros, shows how to keep a spreadsheet up to date by pulling stock quotes from the Web.

Using Python and XML with Microsoft .NET My Services (Windows DevCenter)
Chris Jones, coauthor of Python & XML, talks about using Python and XML with Microsoft .NET My Services, and he shows how to create a request for the simple .NET Contacts service using Python and XML on Linux.

.NET Serviced Components (Windows DevCenter)
This chapter from COM and .NET Component Services shows you how to create .NET serviced components that can take advantage of the COM+ component services that you have learned to apply from this book.

Hailstorm in Hand (Windows DevCenter)
Developers interested in Microsoft's .NET My Services (formerly Hailstorm) can now get a software developers kit (SDK) that lets them run the service locally and experiment with its capabilities.

A Visual J# .NET Primer (Windows DevCenter)
Microsoft's JUMP to .NET promises tools to migrate Java programs to C#, as well as support for the Java SDK class library. When news of Visual J# reached O'Reilly's Brian Jepson, he had to check it out. The first thing he tried was "Hello, World."

Create Dynamic Banners Using ASP.NET (Windows DevCenter)
Do you have the time and artistic skills to develop banners? If not, there's an easier way to make simple banners in HTML. In this article, you'll write a method that can create a simple banner on the fly.

VB .NET Language in a Nutshell: What's New and Different in VB .NET (Windows DevCenter)
Learn about the fundamental changes to the VB language syntax, functionality, error handling and additional object-oriented programming (OOP) support in this excerpt from VB .NET Language in a Nutshell.

Object Oriented Programming for VB.NET - Part 1 (Windows DevCenter)
VB.NET offers the full features of an object oriented programming (OOP) language. Even though the concept of objects is not entirely new to VB programmers, writing object oriented code probably is.

Build a Simple Web Service (Windows DevCenter)
Learn how to build simple Web services using ASP.NET for addition and multiplication.

Learning the C# Error Handling Mechanism (Windows DevCenter)
Learn C# error handling so that you can write robust applications that won't crash when users forget to type in the file path.

Introduction to VB.NET Windows Forms (Windows DevCenter)
VB.NET WinForms have changed completely. Now a Windows form is a representation of the System.Windows.Forms.Form class in the .NET Framework, and this article shows you how to create a form with controls and event handling.

Programming C#: Attributes and Reflection (Windows DevCenter)
NET applications contain code, data, and metadata. Metadata is information about the data--that is, information about the types, code, assembly, and so forth--that is stored along with your program. This excerpt from Chapter 18 of Programming C# will explore how some of that metadata is created and used.

Corel's Comeback: What's .NET's Role? (Windows DevCenter)
The revelation that Microsoft's contract with Corel to port .NET to Linux was secretly extended to include FreeBSD, followed by announcements of Open Source .NET projects from Ximian and the Free Software Foundation, showed that Corel is once again the canny survivor dancing on the edge.

Migrating ADO.NET Code (Windows DevCenter)
James Culshaw illustrates some of these changes and allows you to move your ADO code from Beta 1 to Beta 2 as simply as possible.

Multithreading with C# (Windows DevCenter)
Raffi Krikorian will focus on the syntactical differences between Java and C# threading capabilities, as well as presenting a translation of a few common Java usage patterns into C#.

VB.NET Data Types (Windows DevCenter)
Budi gives us a tour of the new data types in VB 7 (VB .NET) that are different from VB 6. These are not the only changes in the language, but hopefully this is a good start for VB 6 programmers to begin migrating to VB 7.

C# I/O and Networking (Windows DevCenter)
Java is favored as a language partly because of the way it has abstracted away the difficulties in performing input/output and networking operations. C# has taken the same approach and has provided libraries that hide these complications.

GNOME's Miguel de Icaza on .NET (Windows DevCenter)
Open Source developer Miguel de Icaza, leader of the GNOME project and founder of Ximian, has been exploring Microsoft's .NET platform with an open mind. Find out why he claims that .NET is "the new development environment for the next 20 years."

Mono Unveiled (Windows DevCenter)
GNOME and .NET are getting together. According to today's announcement, Ximian is working on an implementation of the .NET CLI called Mono, the first steps toward an open source .NET framework.

Microsoft Plans Shared Source .NET (Windows DevCenter)
Microsoft has announced its first foray into the waters of publicly shared source. Tim O'Reilly talks to Microsoft program manager (and FreeBSD sympathizer) Dave Stutz about Redmond's plans to release shared-source code of parts of the .NET framework.

Writing ASP.NET Web Forms with C# (Windows DevCenter)
Budi Kurniawan presents Web Forms as a programming model in ASP.NET. He covers server controls with an overview of how separation between business logic and presentation layer is achieved in Web Forms along with new session management strategy. Budi concludes with his programming experience building Web Forms using the C# language.

Contrasting C# and Java Syntax (Windows DevCenter)
Raffi Krikorian discusses the differences in syntax between these two object-oriented programming languages.

Comparing C# and Java (Windows DevCenter)
Many people think that C# is a clone of, or Microsoft's replacement for, Java. Is it true?

Conversational C# for Java Programmers (Windows DevCenter)
Raffi Krikorian helps introduce Java programmers to how C# and Java differ.

Why O'Reilly and .NET? (Windows DevCenter)
At O'Reilly, because we are closely identified with open source, I expect that the opening of our .NET DevCenter on O'Reilly Network will raise some eyebrows. Well, here's why we are covering it.

---

Other documents about this topic:

Below are other references available on the web for this topic. Since other sites may change their links, please if you find any that may need to be updated.

---