This articles examines ten different ways you can change your code to make it ready to be tested. By doing so, you will be creating a more loosely coupled, flexible and transparent architecture, which will benefit you not only in testing but in documentation, maintenance and, eventually, modification. With a little forethought and some careful implementation, the unit tests can drive more than the QA process; it can help you design a more robust application in the first place.

This article provides an introduction to Test-Driven Development with concrete examples using Nunit.

This article demonstrates building a PostgreSql provider for the Microsoft Sync Framework.

It is rarely cost-effective or feasible to manually port or rewrite code from one language into another. Java is a popular language for building applications for Unix*, while Microsoft has developed .NET and the Common Language Runtime (CLR)* for building cross-language applications under Windows*. Java and the CLR use different executable formats, which makes it challenging to build applications that need to integrate existing compiled Java class files into a .NET solution. Java class files can be integrated into the .NET CLR using the JbImp.exe utility (a command-line tool included in Microsoft Visual J#*). This paper shows how to use to JbImp.exe to convert working sets of Java .class files into .NET executables and .NET assemblies.

This article presents shortly the .NET architecture and compare its components with the J2EE alternatives.

This article examines the whys and wherefores of continuous integration, and examines two of the leading (open source) tools for providing this service: Draco.NET and CruiseControl.NET. You will see how to get each up and running, and compare their strengths and weaknesses to determine when each is a better fit for your organization.

You've heard of it. It is the latest buzz term for web programmers these days. AJAX is an acronym that stands for Asynchronous JavaScript and XML. AJAX gains its popularity by allowing data on a page to be dynamically updated without having to make the browser reload the page. I will describe more about how AJAX works, and then go into some sample code to try out.

WCF introduces a claims-based approach to security at service boundaries, improving on role-based and permission-based security models. Claims can represent many different types of information including identity, roles, permissions or rights and even general information about the caller that may be useful to the application. A set of claims is also vouched for by an issuer such as a security token service, adding credibility to the information described by each claim – something not present in role-based or permission-based models. An additional benefit of using a claims-based security model is that it supports federated and single sign-on scenarios. This two-part article will explain how claims-based security is supported by WCF, and show you how to implement a claims-based security model for your services. In this first article I’ll start by providing a quick review of the traditional role-based model most .NET applications rely on, and then I’ll compare this model to the claims-based model supported by WCF. In the process, I’ll explain how different security tokens are converted into claims, how the security context for each request is initialized with those claims, and how you can interact with claims to authorize calls. I’ll also explain how to define custom claims for an application, how to normalize different credentials into that set of claims using a custom authorization policy, and how to handle authorization centrally or at each service operation. In the second article I’ll show you how to refine this claims-based authorization model working with custom security principals and claims-based permission demands. I’ll then explain how you can decouple authentication using security token services or CardSpace, and how to work with SAML tokens that carry normalized claims.

With a number of clients, I have been provided a sample format for a transactions along with instructions to develop a process to load it into a database as quickly and painlessly as possible. This usually comes with the requirements that the XML data file can have any number of records from 1 to n. This example demonstrates the most efficent and scalable way that I have found to solve this. Not to mention that it can be maintained without rebuilding the solutions each time the data format changes.

In Part 1 of this article I discussed the motivation behind implementing a claims-based security model for your WCF services and introduced a simple approach to normalizing claims for different credential types using a custom authorization policy. During the article, I discussed the following:
* How different user credentials are mapped to a set of claims that are attached to the security context for each request.
* How to access those claims through the AuthorizationContext to perform authorization, in lieu of role-based security checks.
* How to create a custom authorization policy to issue a set of normalized claims for any credential, and attach those claims to the AuthorizationContext for later authorization checks.

Part 1 introduces some of the benefits of a claims-based security model. Specifically, that it enables service developers to focus on application-specific claims to authorize calls to each operation, while decoupling the authentication step and removing dependencies on specific credential types. This model also allows applications to support more than one credential type by mapping authenticated callers to a set of normalized claims. In this article I will discuss other design decisions related to the claims-based security model. I’ll walk through the process for creating a set of claims-based utilities to encapsulate claims authorization at the service tier; and explain how SAML tokens can be issued by a security token service for authentication, supplying normalized claims to the security context.