Wenfeng's Blog

ASP.NET MVC

2009-06-17T14:14:00.000-07:00

Building Web Apps without Web Forms by Chris Tavares
Cutting Edge: ASP.NET Presentation Patterns by Dino Esposito
The Life And Times of an ASP.NET MVC Controller by Scott Allen
RESTful Services With ASP.NET MVC by Aaron Skonnard
Building Testable ASP.NET MVC Applications by Justin Etheredge

Programming with FileStreams in SQL Server 2008

2009-06-14T13:59:00.000-07:00

Programming with FileStreams in SQL Server 2008 by Bob Beauchemin.

Build Better Data-Driven Apps With Distributed Caching

2009-06-13T12:13:00.000-07:00

Build Better Data-Driven Apps With Distributed Caching by Aaron Dunnington.

Although this article is about Velocity, a feature MS product, the idea of data classification as reference data, activity data, and resource data can be applied anywhere.

Anti-Patterns To Avoid In Entity Framework N-Tier Applications

2009-06-08T13:42:00.000-07:00

Anti-Patterns To Avoid In N-Tier Applications by Daniel Simmons

Memory Usage Auditing For .NET Applications

2009-06-08T13:39:00.000-07:00

Memory Usage Auditing For .NET Applications by Subramanian Ramaswamy and Vance Morrison.

Optimizing A Large Scale Software + Services Application

2009-04-13T13:26:00.000-07:00

Optimizing A Large Scale Software + Services Application by Udi Dahan.

Two Good ASP.NET Articles

2009-02-15T10:00:00.000-08:00

Performance: Scaling Strategies for ASP.NET Applications by Richard Campbell and Kent Alstad
ASP.NET Workflow: Web Apps That Support Long-Running Operations by Michael Kennedy

LINQ: deferred execution and lazy evaluations

2008-09-15T11:02:00.000-07:00

This is a technique to achieve maximum performance from LINQ queries on large sets of data in order to create a responsive UI.

Read more details on Increase LINQ Query Performance by Jared Parsons.

The Open Closed Principle

2008-07-29T12:44:00.000-07:00

Patterns in Practice: The Open Closed Principle by Jeremy Miller

Build Scalable Systems That Handle Failure Without Losing Data

2008-07-29T12:40:00.000-07:00

Build Scalable Systems That Handle Failure Without Losing Data by Udi Dahan

OutOfMemoryException and Pinning

2008-07-04T11:23:00.000-07:00

OutOfMemoryException and Pinning

Some fundamentals of memory

2008-07-04T10:39:00.000-07:00

Some fundamentals of memory

Large Object Heap

2008-07-03T14:01:00.000-07:00

For LOH, though, because compaction is expensive the CLR team chose to sweep them, making a free list out of dead objects that can be reused later to satisfy large object allocation requests. Adjacent dead objects are made into one free object.

If I don't have enough free space to accommodate the large object allocation requests, I will first attempt to acquire more segments from the OS. If that fails, then I will trigger a generation 2 garbage collection in hope of freeing up some space.

During a generation 2 garbage collection, I take the opportunity to release segments that have no live objects on them back to the OS. Memory from the last live object to the end of the segment is decommitted. And the free spaces remain committed though they are reset, meaning the OS doesn't need to write data in them back to disk.

A garbage collection occurs if one of the following conditions happens:

Allocation Exceeds the Generation 0 or Large Object Threshold (this is the most typical case).
System.GC.Collect Is Called
System Is in Low Memory Situation This happens when I receive the high memory notification from the OS.

LOH Performance Implications

Allocation costs.The CLR makes the guarantee that the memory for every new object I give out is cleared. This means the allocation cost of a large object is completely dominated by memory clearing (unless it triggers a garbage collection). If it takes two cycles to clear 1 byte, it means it takes 170,000 cycles to clear the smallest large object. For a 16MB object on a 2GHz machine, it will take approximately 16ms to clear the memory.

Collection costs. LOH and generation 2 are collected together. If either one's threshold is exceeded, a generation 2 collection will be triggered. If many large objects are allocated on a very temporary basis and you have a big SOH, you could be spending too much time running garbage collections; not to mention that the allocation cost can really add up if you keep allocating and letting really large objects go.

From Large Object Heap Uncovered by Maoni Stephens.

LinkedIn Architecture

2008-06-24T10:12:00.000-07:00

http://hurvitz.org/blog/2008/06/linkedin-architecture

Streamed vs. Buffered in WCF

2008-03-07T12:13:00.000-08:00

http://msdn2.microsoft.com/en-us/library/ms789010.aspx

TreeView Binding in WPF

2008-03-04T16:49:00.000-08:00

Binding a TreeView to a DataSet

DataContractSerializer.MaxItemsInObjectGraph in WCF

2008-02-21T15:18:00.000-08:00

There are several things that control a huge list returned from a WCF call. DataContractSerializer.MaxItemsInObjectGraph, Binding.maxBufferSize, and Binding.maxReceivedMessageSize are commonly used.

According to SDK, DataContractSerializer.MaxItemsInObjectGraph = the maximum number of items in an object graph to serialize or deserialize.
NetTcpBinding.MaxReceivedMessageSize = the maximum size for a received message that is processed by the binding.
NetTcpBinding.MaxBufferSize = a value that specifies the maximum size, in bytes, of the buffer used to store messages in memory.

The default value for all three setting is 65,536. You can tweak this number to support large returned lists.

One thing that you should know is that TheNumberYouSet != MaxListCountExpected. TheNumberYouSet should be far bigger than MaxListCountExpected because of this "graph" thing.

To add a DataContractSerializer.MaxItemsInObjectGraph , you create an endpoint behavior (rather than a service behavior), and add the behavior to the endpoint (not at the service level).

SQL Server Remote Connection between XP server and Vista server

2008-02-20T12:02:00.000-08:00

I got the following link from a coworker.
http://blogs.msdn.com/sql_protocols/archive/2006/09/30/SQL-Server-2005-Remote-Connectivity-Issue-TroubleShooting.aspx

The Microsoft UI Automation Library

2008-02-20T11:55:00.000-08:00

The Microsoft UI Automation library is included in the .NET Framework 3.0 as part of Windows Presentation Foundation (WPF). Read Dr. James McCaffrey's article The Microsoft UI Automation Library in more details.

WCF Binding

2007-11-25T09:27:00.000-08:00

In WCF, the communication concepts—the transport, the message encoding, and the suite of protocols are handled by the channel stack.

It’s the binding, however, that provides the recipe for building the channel stack needed to properly process the messages. When you load a service, WCF follows the instructions outlined by the binding description to create each channel stack. The binding binds your service implementation to the wire through the channel stack in the middle.

Within the WCF programming model, bindings are represented by the System.ServiceModel.Channels.Binding class. The figure Figure 2 summarizes the built-in binding classes that come with WCF out of the box.

Unlike the HTTP bindings, the various "Net" bindings were not designed for interoperability. In fact, each was designed for optimizing a different communication scenario when you can safely assume you have the Microsoft® .NET Framework 3.0 installed on both sides.

From Service Station: WCF Bindings In Depth by Aaron Skonnard.

Scott Berkun on Politics

2007-09-28T15:44:00.000-07:00

According to Scott Berkun, Politics is the skill of managing people and organizations.

Politics is not a dirty word.
All leaders have political and power constraints.
The ratio of power to responsibility is constant.
Politics is a kind of problem solving.

Any political or management action that takes place, no matter how stupid or evil it seems, is always one of a limited number of possible choices managers have. The alternatives might be even worse for the project than the choice that was made. Without understanding something of the constraints, judgment will always be based more on venting frustration than on the reality of the situation.

Serializing and Encoding in WCF

2007-09-24T08:18:00.000-07:00

Whereas serialization defines how .NET objects map to XML Infosets, the encoding defines how the XML Infoset is written out to a stream of bytes.

The serializer is considered part of the service contract because it directly impacts your code. The encoding isn't considered part of the service contract, but rather a configuration detail since it doesn't impact your code—you control the encoding by configuring the endpoint's binding.

The separation of serialization from encoding makes it possible to build your applications on a consistent data model (the XML Infoset) while providing flexibility in representation (the encoding).

Windows Communication Foundation supports three serializers: XmlSerializer, DataContractSerializer, and NetDataContractSerializer. DataContractSerializer is the default.

WCF currently supports the following encodings: text, binary, Message Transmission Optimization Mechanism (MTOM), and your own custom encodings.

From Service Station: Serialization in Windows Communication Foundation by Aaron Skonnard.

Security in WCF

2007-09-17T08:53:00.000-07:00

Credentials

None, UserName, Windows, Certificate, and IssuedToken.

Default Security in Standard Bindings

basicHttpBinding supports the WS-I basic profile. This particular binding doesn't provide CIA by default like most of the others. The most popular way to secure this binding is by simply running over HTTPS.

wsHttpBinding uses message security by default, with WS-Security and WS-SecureConversation. The default client credential type is Windows. One of the most common security tweaks to use on this binding is to switch it to use TransportWithMessageCredential.

netTcpBinding encodes each SOAP envelope using a proprietary binary encoding of the XML Infoset instead of the traditional angle bracket encoding. By default this binding uses transport security with Windows credentials, and is very efficient. The default binding uses transport security with negotiated authentication. If you want raw speed for Web services on a Windows-based intranet, you should seriously consider using this binding.

Discovering Client Identity

By far the simplest way to discover a client's identity is to leverage Thread.CurrentPrincipal. You can see which groups the user belongs to by calling WindowsPrincipal.IsInRole. For security reasons you really should specify the fully qualified group name, which includes the domain or machine on which the group is defined.

WCF doesn't always set Thread.CurrentPrincipal. It does that only if PrincipalPermissionAttribute is used or if the configuration says it should. Instead of relying on Thread.CurrentPrincipal, you should use ServiceSecurityContext.Current.WindowsIdentity to get the client's identity if one is available.

If the client is using an issued token credential to authenticate, you'll need to use ServiceSecurityContext.AuthorizationContext to pick up those details. If the client is authenticating with a certificate not mapped to a Windows account, ServiceSecurityContext.Current.PrimaryIdentity can be used.

Transparency is important when you're building a secure system. If the security features you build into the system aren't relatively transparent, users will be put off and will generally try to avoid using them.

From Security Briefs: Security in Windows Communication Foundation by Keith Brown.

WCF Addressing

2007-09-01T10:47:00.000-07:00

You can specify an absolute address for each endpoint or you can supply the ServiceHost with a base address and then specify relative paths for each endpoint. Specifying absolute addresses is a little easier to understand, but the base address technique typically makes things easier to manage.

The base address technique is mostly a convenience to reduce the number of places you’ll have to make changes when modifying the locations of your endpoints. Windows Communication Foundation also uses the base HTTP address by default to expose metadata when GET retrieval has been enabled (via the serviceMetadata behavior). You can, however, change the retrieval location using the behavior’s httpGetUrl property.

It’s also possible to specify the base addresses in the configuration file along with the endpoints themselves by listing the base addresses within the host element for each service.

IIS Addressing Considerations

When hosting in IIS, you simply map a .svc endpoint to your service class, configure the service endpoints and behaviors in web.config, and let WCF manage the process of creating and configuring the ServiceHost instance at runtime.

In this hosting scenario, the base HTTP address is determined by the IIS virtual directory housing the service along with the name of the .svc file. If you want to change the base address for your endpoints, you’ll need to move the service to a different IIS virtual directory.

Not only does IIS control the base address, it forces all of your endpoints to actually use the same base address (unlike self-hosting). As a result, it really only makes sense to use relative addresses when hosting in IIS.

Suppose you have a file named calc.svc and you place it in a virtual directory that corresponds to http://localhost:8080/calcservice. The base address for this service will be http://localhost:8080/calcservice/calc.svc. If a relative addresss "secure" is provided, then its address is http://localhost:8080/calcservice/calc.svc/secure. You have to remember that calc.svc is part of the base address so it has to work this way.

Logical vs. Physical Addresses

WCF refers to the logical address as "Address" or "Endpoint Address" and the physical address as "ListenUri".

From Service Station: WCF Addressing In Depth by Aaron Skonnard.

The InstanceContextMode Property

2007-08-10T07:57:00.000-07:00

You can apply the ServiceBehavior attribute with the InstanceContextMode property set to the following:

InstanceContextMode.PerCall - Per-Call Services.
InstanceContextMode.PerSession - Per-Session Services, default.
InstanceContextMode.Sharable - Shareable Services, not included in the current release.
InstanceContextMode.Single - Singleton Services, with sessions or without sessions.

A service that implements a session-aware contract requires that all the endpoints that expose the contract use bindings that support reliable transport session. One exception to this rule is the named pipes binding.

A shareable service behaves much like a per-session service, with one important additional aspect: the instance has a unique ID, and when a client establishes a session with a shareable service, the client can pass a logical reference to that instance to another client. The second client will establish an independent session but will share the same instance. Also, each of these sessions may use different inactivity timeouts, and expire independently of any other session.

WCF Essentials: Discover Mighty Instance Management Techniques For Developing WCF Apps by Juval Lowy.

Some Basic WCF Concepts

2007-08-07T07:55:00.000-07:00

WCF unifies the existing suite of .NET distributed technologies into a single programming model that improves the overall developer experience through a consistent architecture, new levels of functionality and interoperability, and all the extensibility points you could want. WCF was designed according to the tenets of service orientation.

A service is a piece of code you interact with through messages. Services are passive. They wait for incoming messages before doing any work. Clients are the initiators. Clients send messages to services to request work.

Services expose one or more endpoints where messages can be sent. Each endpoint consists of an address, a binding, and a contract. The address specifies where to send messages. The binding describes how to send messages. And the contract describes what the messages contain. Clients need to know this information before they can access a service.

Services can package up endpoint descriptions to share with clients, typically by using Web Services Description Language (WSDL). Then clients can use the provided service description to generate code within their environment capable of sending and receiving the proper messages.

WCF Programming Model

With WCF, you're either writing services that expose endpoints or you're writing clients that interact with endpoints. Hence, endpoints are central to the WCF programming model and infrastructure.

When building a WCF service, you typically start by defining a .NET interface definition to serve as the service contract. Then you implement the service contract in a .NET class, known as the service type, and configure its behavior. Next, you define the endpoints the service will expose, specifying the address, binding, and contract for each one. Finally, you host the service type in an application using the WCF hosting infrastructure. Once the service type is hosted, clients can retrieve its endpoint descriptions and begin integrating with it.

When building a WCF client, you first need the description of the target endpoint you want to access. The endpoint description can be used to dynamically create a typed proxy. Then you can write code against the typed proxy to access the service by sending the appropriate messages to the target endpoint.

Service Contracts and Dispatch Behavior

WCF uses the information found in the service contract to perform dispatching and serialization. Dispatching is the process of deciding which method to call for an incoming SOAP message. Serialization is the process of mapping between the data found in a SOAP message and the corresponding .NET objects used in the method invocation. This mapping is controlled by an operation's data contract.

Data Contracts

The way WCF serializes .NET classes depends on the serialization engine in use. The default serialization engine is known as DataContract, a simplified version of XmlSerializer, the default serialization engine used in ASMX today.

With DataContract, only fields marked with DataMember will be serialized. And you can serialize private fields.

Attribute List

ServiceContract, OperationContract, DataContract, DataMember, MessageContract, MessageBody, MessageHeader, ServiceBehavior.

From Distributed .NET: Learn The ABCs Of Programming Windows Communication Foundation by Aaron Skonnard.

Performance Implications on Collections

2007-07-21T09:29:00.000-07:00

When you want additions, removals, and lookups to be very quick, and when you are not concerned about the order of the items in the collections, your first inclination should be to use a System.Collections.Generic.Dictionary.

On the other hand, with a List, inserting and removing items can take a variable amount of time. (List stores items in an underlying array that maintains order. If your usage pattern requires few deletions and mostly additions, and if it is important for you to keep the collection in order, you may still want to choose a List.

Using the new LinkedList collection can potentially help you improve performance in scenarios where you need to maintain order yet still achieve fast inserts. Unlike List, LinkedList is implemented as a chain of dynamically allocated objects. In comparison to List, inserting an object in the middle only requires updating two connections and adding the new item. The downside of a linked list from a performance point of view is increased activity by the garbage collector as it has to traverse the entire list to make sure objects were not disposed of. Additionally, performance problems can arise with large linked lists due to the overhead associated with each node as well as where in memory each node lives.

SortedDictionary, uses a balanced tree implementation as the underlying data store; this provides relatively fast lookups and maintains items in a sorted order, but insertions will most likely be slower.

From CLR Inside Out: Collections Best Practices by Inbar Gazit.

Generic Counterparts to Non-Generic Collections

2007-07-21T09:03:00.000-07:00

Separating Administrative Events and Operational, Analytical, or Trace/Debug Messages

2007-07-08T09:10:00.000-07:00

If there's one thing an IT pro really hates, it's an application that makes a lot of noise in the application event log, drowning out the really important messages that well-behaved applications produce from time to time. You shouldn't be writing operational, analytical, or trace/debug messages to the application log! These are more appropriate for a custom application log.

From Security Briefs: Improve Manageability through Event Logging by Keith Brown.

Localization Strategy Used in the Windows Event Log

2007-07-08T08:40:00.000-07:00

The Windows® event log was designed with localization and efficiency in mind. For example, a well-designed event found in the Application log should contain just enough prose to explain a problem to the administrator and provide a suggested course of action. The vast majority of this prose should be localized for the reader, who may very well be on a remote machine in a different country. To support reading the log in your own native language, the localizable prose in the message is not actually stored in the log; rather, it is merged with the log locally as you read it. The actual prose is stored in a localized resource DLL on the reader's machine. This also has the effect of keeping the log files smaller and reducing the amount of network traffic required to read them.

Before the .NET Framework came along, this was all very clear to developers because you had to create and register these resource DLLs yourself. A typical message in a resource DLL might look like this: "Failed to connect to database %1 using connection string %2. Check to see that the database is available."

In this example, the only data about the event that would be stored in the event log would be the event ID, source, category, and a few other bits of metadata, along with the arguments supplied when the event was logged: the database name (%1) and the connection string (%2). When you use a tool such as Event Viewer to read an event like this, Windows will load the message resource DLL installed on your machine, look up the localized message based on the event ID, then merge the arguments from the log in order to display the message to you.

The way Windows figures out which resource DLL to use is by looking at the name of the event source in the log and mapping it to a registry key. This registry key contains the path to the resource DLL that should be used to display the message.

In version 1.x of the .NET Framework, the simple call to CreateEventSource wires your event source up with a default message file. This file is called EventLogMessages.dll, and it contains 65,536 event descriptions, each of which consists of the string "%1", a placeholder for whatever string you want to write. While this may have encouraged a few more people to use the event log, it defeated the purpose of having message files in the first place: to allow localized viewing of messages in the reader's language, and to keep the size of the event logs in check.

Fortunately, version 2.0 of the .NET Framework remedies this and allows you to gain the full power of the event log by registering a message file when you create your event source. This lets you support localized categories and messages, and it reduces the size of your messages in the log.

From Security Briefs: Improve Manageability through Event Logging by Keith Brown.

Write Code Once For Both Mobile And Desktop Apps

2007-07-01T13:41:00.000-07:00

Differences in the tools, the languages, the libraries, and the runtime engine affect the goal of writing cross-platform code.

The .NET Compact Framework achieves 80 percent of the relevant functionality found in the .NET Framework with only 20 percent of the footprint. Major areas of the .NET Framework that are absent from the compact version include: ASP.NET, CLR hosting, code access security (CAS), binary serialization, Reflection.Emit, and CodeDOM. Windows Presentation Foundation and Windows Workflow Foundation are not going to be supported any time soon.

System.Data.SqlServerCe, System.Net.IrDA, Microsoft.WindowsMobile.DirectX and Microsoft.WindowsCE.Forms are four device-specific assemblies that are in the .NET Compact Framework and not in the the .NET Framework. So the .NET Compact Framework is not a strict subset of the .NET Framework.

IL opcodes that are not supported by the .NET Compact Framework common are: jmp, calli, refanyval, refanytype, mkrefany, arglist, localloc, unaligned, and tail.

The implementations of the garbage collector and the just-in-time (JIT) compiler are different in the .NET Compact Framework than they are in the .NET Framework.

Note that the public key token for the .NET Compact Framework assemblies starts with 9 whereas the desktop equivalents start with B. You can use that information to quickly determine whether what you are deploying or referencing is a desktop or a device framework assembly.

Implementation approaches: retargeting, conditional branching, or a mix of both.

A runtime check is not enough because of JIT compiling.

Share the Code, Not the Binary.

There are two limitations with the retargetable approach: First, you can’t use any desktop-only types or methods in your code. They simply will not compile. Second, you must be careful not to load any device-specific assemblies on the desktop as they will fail with run-time exceptions.

From Share Code: Write Code Once For Both Mobile And Desktop Apps by Daniel Moth

IIS 7.0

2007-06-30T10:06:00.000-07:00

Be Extensible and Manageable. The vision for IIS 7.0 was to take the speed, reliability, and security of the IIS 6.0 codebase and turn it into a highly extensible and manageable Web server platform powerful enough to run Web applications of the future.

At the core of the IIS 7.0 release is a completely modular Web server, comprised of more than 40 features that can be assembled into small-footprint Web servers optimized for the desired role in your application topology. These features are built on top of a new extensibility layer that allows developers to extend or replace virtually any aspect of the server, in native code or with the Microsoft® .NET Framework. IIS 7.0 offers extensibility throughout its runtime, management, and operational features to help you build end-to-end solutions for your specific needs. On top of the core platform, IIS 7.0 tackles many of the problems associated with the manageability and operation of the server. It features a brand new configuration system that enables fully delegated management of sites and finally makes xcopy deployment of Web applications a reality. The new management APIs and diagnostic features make deployment, administration, and troubleshooting of the server significantly easier and more convenient than ever before.

The centralized configuration store of the previous IIS releases, known affectionately as the metabase, is gone. IIS 7.0 features a new delegated configuration system based on a hierarchy of distributed XML configuration files. This hierarchy is comprised of a global applicationHost.config file, which contains server-level configuration defaults, and distributed web.config files within the application's directory structure.

In the past, IIS application settings had to be explicitly configured in the machine-level metabase repository before the application could function correctly. With distributed web.config files, applications encapsulate the required server configuration within their directory structure. This dramatically simplifies deployment, allowing self-contained applications to be simply copied to the target server's application directory and thus be up and running immediately with the desired settings.

IIS 7.0 continues to support existing setup code that uses the Admin Base Object (ABO) APIs to write to the legacy metabase or scripts that use the higher-level Active Directory® Service Interfaces (ADSI) and Windows Management Instrumentation (WMI) objects to configure IIS. It does this by providing a compatibility layer that emulates the ABO APIs, on top of which all other legacy configuration APIs are based, allowing such scripts to read and change configuration just like they did in the previous releases of IIS.

Remote Management Tool. IIS 7.0 provides a tool that enables delegated management, letting application owners manage their applications remotely without having administrative access to the server computer. Server administrators, of course, have complete control over what management features are delegated to application owners.

Microsoft.Web.Administration, the new .NET Administration API, makes it easy for managed code applications to programmatically provision IIS sites and applications, access important state and diagnostic information, and otherwise configure the server.

In IIS 7.0, ASP.NET comes in two versions: Classic mode and Integrated mode. Classic mode works exactly the same way as it did in previous versions of IIS. Integrated mode, the new platform default, uses a brand new engine to provide unparalleled integration with the IIS Web server.

IIS on Windows Vista is limited to 10 concurrent requests at a time.

The modular nature of the server allows administrators to remove unneeded server features, saving memory and CPU usage during request processing.

The new IIS Output Cache provides support for re-using responses to expensive dynamic pages on the server, alleviating the need to perform the expensive rendering and database transactions in order to return the response to the client.

From IIS 7.0: Explore The Web Server For Windows Vista And Beyond by Mike Volodarsky

Can Sql Server Run Entirely In Ram?

2007-06-11T09:50:00.000-07:00

Database pages that have been accessed are stored in the buffer pool. (Pages are placed in RAM only when needed, and SQL Server™ doesn't reload pages.) These pages are kept in RAM as long as possible—that is, until memory becomes a problem. So let's say you've set SQL Server to the proper memory footprint and you've run some queries that touched every page in the database. The entire database would then be in RAM and it would stay there until you ran out of buffer pool space to hold new pages, or until other processes on the system cause physical memory pressure.

During each checkpoint, any modified pages are flushed to disk, so committed changes are taken care of. Log records are not cached per se. As soon as a commit is issued, the records are flushed to disk. So even if all dirty pages are still in RAM, a restart of SQL Server will replay the log records. Don't take this to mean you should rely on the log in this way. A huge log could mean a very long recovery period.

So pages stay in RAM until space is needed; a least recently used (LRU) algorithm is applied so that hot pages stay longer. Most of the time, you won't need the entire database in the cache anyway. So you shouldn't buy a ton of RAM to hold pages that probably aren't touched too often—you likely won't see any performance improvement.

From Running in RAM, Agent Jobs, and More by Nancy Michell.

Guidance On Forest Trusts

2007-06-11T09:37:00.000-07:00

The following documents provide valuable guidance on creating forests and implementing trust:

From Running in RAM, Agent Jobs, and More by Nancy Michell.

Monitoring SQL Server Health

2007-06-11T09:20:00.000-07:00

See "Troubleshooting Performance Problems in SQL Server 2005" and "Tips for Using SQL Server Performance Monitor Counters"). The key to running traces in the most efficient manner is to run the traces locally on the machine running SQL Server and pipe the output to a local file.

In addition to capturing and analyzing performance counters and profiler information you may want to look into identifying where the engine is spending its time waiting, which tells you if you are I/O constrained, CPU constrained, memory constrained, and so on. For more on this see "How do you measure CPU pressure?".

You should also consider implementing Microsoft® Operations Manager (MOM) 2005 as a part of your SQL Server 2005 monitoring plans. The SQL Server 2005 Management Pack is quite useful. Even without it you can get a good understanding of what's going on with your servers just by using the MOM operator console and warehouse and associated reports that expose counters like CPU, Memory, Disk Queuing, and so on.

From Predicates, Stored Procedures, and More by Nancy Michell

Rebuilding Indexes in SQL Server

2007-06-09T10:00:00.000-07:00

At the simplest level, indexes are rebuilt by constructing a new copy of the index and then deleting the old one. This means that essentially there are two copies of the index for a short period of time. Constructing the new index could require as much database file space as the original index, and if the rebuild requires a sort operation, then an additional 20 percent of the index size is required for the sort.

So the worst case is that rebuilding an index requires 1.2 times the space of the old index. If the database file does not have enough free space, then the file will have to grow as the operation proceeds. It's possible that if autogrow is not enabled or there is not enough space on the disk volume, then there may not be enough free space available and the rebuild operation will fail.

Whether the operation fails or not, the extra space allocated to the database file is not freed up after the rebuild operation completes. The assumption is that the space will be used for regular database operations.

Using DBCC INDEXDEFRAG (or ALTER INDEX … REORGANIZE in SQL Server™ 2005) has the advantage that it uses almost no additional database file space, but it can take longer and generate a lot more transaction logging than an index rebuild. DBCC INDEXDEFRAG is always fully logged, regardless of the recovery mode in use, whereas in simple recovery mode an index rebuild will be bulk-logged. There are a variety of pros and cons to each method and they are explained more fully in the SQL Server Index Defragmentation Best Practices whitepaper.

Before making the decision on how to fix fragmentation, first decide whether to fix fragmentation at all. Depending on the type of operations the index is used for, fragmentation may have no effect on performance and so fixing it is a waste of resources. The whitepaper has great detail.

Rebuilding Indexes, Disk Queue Length, and Moreby Nancy Michell

EXECUTE AS Clause (T-SQL)

2007-06-09T09:24:00.000-07:00

In SQL Server 2005 you can define the execution context of the following user-defined modules: functions (except inline table-valued functions), procedures, queues, and triggers.

By specifying the context in which the module is executed, you can control which user account the SQL Server 2005 Database Engine uses to validate permissions on objects that are referenced by the module. This provides additional flexibility and control in managing permissions across the object chain that exists between user-defined modules and the objects referenced by those modules. Permissions must be granted to users only on the module itself, without having to grant them explicit permissions on the referenced objects. Only the user that the module is running as must have permissions on the objects accessed by the module.

USE Sales;
GO
CREATE PROCEDURE dbo.usp_Demo
WITH EXECUTE AS 'CompanyDomain\SqlUser1'
AS
SELECT user_name();
GO

From SQL Server 2005 Books Online

Perform highly privileged activities in SQL Server

2007-06-09T09:20:00.000-07:00

Define the minimal permissions necessary to perform the action.
Define a database role that contains those permissions.
Assign a user to that role.
Create a stored procedure with the EXECUTE AS clause that will perform those functions.

Best Practices Analyzer, Multi-Core Processors, and More by Nancy Michell

T-SQL to find the size of total and free physical memory

2007-06-09T08:12:00.000-07:00

With VASummary(Size,Reserved,Free) AS
(SELECT
Size = VaDump.Size,
Reserved = SUM(CASE(CONVERT(INT, VaDump.Base)^0)
WHEN 0 THEN 0 ELSE 1 END),
Free = SUM(CASE(CONVERT(INT, VaDump.Base)^0)
WHEN 0 THEN 1 ELSE 0 END)
FROM
(
SELECT CONVERT(VARBINARY, SUM(region_size_in_bytes))
AS Size,
region_allocation_base_address AS Base
FROM sys.dm_os_virtual_address_dump
WHERE region_allocation_base_address <> 0x0
GROUP BY region_allocation_base_address
UNION
SELECT CONVERT(VARBINARY, region_size_in_bytes),
region_allocation_base_address
FROM sys.dm_os_virtual_address_dump
WHERE region_allocation_base_address = 0x0
)
AS VaDump
GROUP BY Size)

SELECT SUM(Size*Free)/1024 AS [Total avail mem, KB] ,CAST(MAX(Size) AS INT)/1024
AS [Max free size, KB]
FROM VASummary
WHERE Free <> 0

Best Practices Analyzer, Multi-Core Processors, and More by Nancy Michell

Using GC Efficiently

2007-06-02T09:53:00.000-07:00

Maoni Stephens's blogs:

Using GC Efficiently – Part 1
Using GC Efficiently – Part 2
What’s new in the CLR 2.0 GC?

Rico Mariani's blog:
Mid-life crisis

GC Performance Counters

2007-06-01T13:00:00.000-07:00

The .NET Memory performance counters are updated only when a collection occurs; they are not updated according to the sampling rate used in the Performance Monitor application.

The % Time in GC indicates the percentage of time spent in the GC since the end of the last collection. If you see a really high value (say 50 percent or more), then you should look at what is going on inside the managed heap. If, instead, % Time in GC does not go above 10 percent, it usually is not worth spending time trying to reduce the time the GC spends in collections because the benefits will be marginal.

If you think your application is spending too much time performing garbage collections, the next performance counter to check is Allocated Bytes/sec. This shows the allocation rate. Unfortunately, this counter is not highly accurate when the allocation rate is very low. The counter may indicate 0 bytes/sec if the sampling frequency is higher than the collection frequency since the counter is only updated at the beginning of each collection. This does not mean there were no allocations; rather, the counter was not updated because no collection happened in that particular interval.

If you suspect that you are allocating a lot of large objects (85,000 bytes or bigger), check the Large Object Heap (LOH) size. This is updated at the same time as Allocated Bytes/sec.

A high allocation rate can cause a lot of collection work and as a result might be reflected in a high % Time in GC. A mitigating factor is if objects usually die young, since they will typically be collected during a Gen 0 collection. To determine how object lifecycles impact collection, check the performance counters for Gen collections: # Gen 0 Collections, # Gen 1 Collections, and # Gen 2 Collections. These show the number of collections that have occurred for the respective generation since the process started. Gen 0 and Gen 1 collections are usually cheap, so they don't have a big impact on the application's performance.

As a rule of thumb, a healthy ratio between generation collections is one Gen 2 collection for every ten Gen 1 collections. If you are seeing a lot of time spent in garbage collection, it could be that Gen 2 collections are being done too often.

You may find that % Time in GC is high but the allocation rate is not high. This can happen if many of the objects you allocate survive garbage collection and are promoted to the next generation. The promotion counters—Promoted Memory from Gen 0 and Promoted Memory from Gen 1—can tell you if the promotion rate is an issue. You want to avoid a high promotion rate from Gen 1.

High values for the Gen 1 and Gen 2 heap sizes are usually associated with high values in the promotion rate counters. You can check the GC heap sizes by using Gen 1 heap size and Gen 2 heap size. There is a Gen 0 heap size counter, but it doesn't measure Gen 0 size. Instead, it indicates the budget of Gen 0—meaning how much you can allocate in Gen 0 before the next Gen 0 collection will be triggered.

In all scenarios where you use a lot of objects that need finalization—for instance, objects that rely on COM components for some processing—you can take a look at the Promoted Finalization-Memory from Gen 0 counter. This tells you the amount of memory that cannot be reused because the objects that use the memory need to be added to the finalization queue and therefore cannot be collected immediately. IDisposable and the using statements in C# and Visual Basic® can help reduce the number of objects that end up in the finalization queue, thus reducing the associated cost.

It's also worth checking if the application is inducing too many collections. The # Induced GC counter tells you how many collections have been induced since the process started. In general it is not recommended that you induce GC collections. In most cases, if # Induced GC indicates a high number, you should consider it a bug. Most of the time people induce GCs in hopes of cutting down the heap size, but this is almost never a good idea. Instead, you should find out why your heap is growing.

Adopted from CLR Inside Out: Investigating Memory Issues by Claudio Caldato and Maoni Stephens.

Possible Performance Hits from Event Handlers and Callbacks

2007-02-12T10:06:00.000-08:00

If a delegate uses an instance callback method, then the delegate contains an implicit this pointer, where this is the instance of the class A containing the callback methed. When a garbage collection occurs, the instance of the class A remains reachable from a rooted reference if the delegate instance is reachable. To allow a GC collects the instance of the class A, make the callback function static.

Adopted from Debug Leaky Apps: Identify And Prevent Memory Leaks In Managed Code by James Kovacs.

Large Object Heap Fragmentation

2007-02-12T09:12:00.000-08:00

If an object is 85,000 bytes or larger, it is allocated on the large object heap. Unlike the rest of the managed heap, the Large Object Heap is not compacted due to the cost of moving the large objects.

To avoid Large Object Heap fragmentation, the basic strategy is to determine how to reduce the application's reliance on temporary large objects, which are causing the gaps in the large object heap. If the fragmentation is due to re-allocating buffers, maintain a fixed set of buffers that are reused. If the fragmentation is being caused by concatenation of large numbers of strings, examine whether the System.Text.StringBuilder class can reduce the number of temporary strings created.

Adopted from Debug Leaky Apps: Identify And Prevent Memory Leaks In Managed Code by James Kovacs.

Leaking Stack Memory in Managed Code

2007-02-12T09:03:00.000-08:00

There are only two real ways to leak stack space. The first is to have a method call that consumes significant stack resources and that never returns, thereby never releasing the associated stack frame. The other is by leaking a thread, and thus that thread's entire stack.

By default, the stack size on modern desktop and server versions of Windows® is 1MB.

Adopted from Debug Leaky Apps: Identify And Prevent Memory Leaks In Managed Code by James Kovacs.

Checking for Leaks in Managed Code

2007-01-28T10:10:00.000-08:00

Signs that an application is leaking memory:

Throwing an OutOfMemoryException
Responsiveness is growing very sluggish because it started swapping virtual memory to disk
Memory use is gradually (or not so gradually) increasing in Task Manager

Using PerfMon to determine what kind of memory is leaking:

Process/Private Bytes
.NET CLR Memory/# Bytes in All Heaps
.NET CLR LocksAndThreads/# of current logical Threads

The Process/Private Bytes counter reports all memory that is exclusively allocated for a process and can't be shared with other processes on the system. The .NET CLR Memory/# Bytes in All Heaps counter reports the combined total size of the Gen0, Gen1, Gen2, and large object heaps. The .NET CLR LocksAndThreads/# of current logical Threads counter reports the number of logical threads in an AppDomain.

If an application's logical thread count is increasing unexpectedly, thread stacks are leaking. If Private Bytes is increasing, but # Bytes in All Heaps remains stable, unmanaged memory is leaking. If both counters are increasing, memory in the managed heaps is building up.

Adopted from Debug Leaky Apps: Identify And Prevent Memory Leaks In Managed Code by James Kovacs.

What Security Means

2006-11-02T12:42:00.000-08:00

Security means that the systems have the properties of confidentiality, integrity, and availability, that users are authenticated and authorized correctly, and that transactions are non-repudiable.

The following explains each property.

Confidentiality - Data is only available to the people intended to access it.
Integrity - Data and system resources are only changed in appropriate ways by appropriate people.
Availability - Systems are ready when needed and perform acceptably.
Authentication - The identity of users is established (or you’re willing to accept anonymous users).
Authorization - Users are explicitly allowed or denied access to resources.
Nonrepudiation - Users can’t perform an action and later deny performing it.

The following maps threats to the properties that guard against them.

Spoofing - Authentication
Tampering - Integrity
Repudiation - Non-repudiation
Information disclosure - Confidentiality
Denial of service - Availability
Elevation of privilege - Authorization

Adopted from Threat Modeling: Uncover Security Design Flaws Using The STRIDE Approach.

Saltzer and Schroeder's Security Design Principles

2006-11-02T12:36:00.000-08:00

Principles:

Open design - Assume the attackers have the sources and the specs.
Fail-safe defaults - Fail closed; no single point of failure.
Least privilege - No more privileges than what is needed.
Economy of mechanism - Keep it simple, stupid.
Separation of privileges - Don’t permit an operation based on a single condition.
Total mediation - Check everything, every time.
Least common mechanism - Beware of shared resources.
Psychological acceptability - Will they use it?

Adopted from Threat Modeling: Uncover Security Design Flaws Using The STRIDE Approach.

Documenting and Evaluating the Security Guarantees of Your Apps

2006-10-30T11:52:00.000-08:00

In the article Extending SDL: Documenting And Evaluating The Security Guarantees Of Your Apps, Mark Pustilnik pointed out the missing link in SDL:

Tying secure design and implementation of software directly to the functional specifications of security features in a way that can be understood by customers at any level of depth they require (and that your licensing terms allow).

According to Mark, security of software is not a compliance artifact. Rather, it is a set of key features that can and should be documented, evaluated, and used when making purchasing decisions.

Today's software is, by and large, developed and distributed in a manner that is most suited to the following two principles:

Utilizing sound software engineering practices during implementation
Patching vulnerabilities found by hackers after software has been deployed

Mark intruduced three rules:

Design and develop software that addresses the stated as well as implicit security requirements placed upon it by users.
Avoid introducing features into the software that imply, but cannot deliver, defensible security guarantees.
Publish sufficient information about the design of security features to convince your users that the design is solid.

Security considerations and guarantees apply to many features of the software, even those that on the surface are not primarily security features. Listing requirements in conjunction with the associated security guarantees is the key to understanding a full range of protections afforded by the software.

UAC Resources

2006-08-03T16:51:00.000-07:00

The following are some UAC resouces I found helpful.

My last four posts used these resources freely.

UAC Data Virtualization

2006-08-03T16:26:00.000-07:00

Windows Vista includes file and registry virtualization technology for applications that are not UAC compliant and that have historically required an administrator's access token to run correctly. Virtualization ensures that even applications that are not UAC compliant will be compatible with Windows Vista. When a non-UAC-compliant administrative application attempts to write to a protected directory, such as Program Files, UAC gives the application its own virtualized view of the resource it is attempting to change, using a copy-on-write strategy. The virtualized copy is maintained under the user's profile. As a result, a separate copy of the virtualized file is created for each user that runs the non-compliant application.

For example, if an application attempts to write to “C:\program files\appname\settings.ini” and the user doesn’t have permissions to write to that directory, the write will get redirected to “C:\Users\username\AppData\Local\VirtualStore\Program Files\appname\.” A write to "
HKLM\Software\AppName" will get redirected to "
HKCU\Software\Classes\VirtualStore\Machine\Software\AppName".

Virtualization is enabled by default in Windows Vista. Virtualization does not apply to applications that are elevated and run with a full administrative access token. Virtualization is disabled for an application if a program includes an application manifest with a requested execution level attribute.

Although virtualization allows the overwhelming majority of pre-Windows Vista applications to run, it is a short-term fix and not a long-term solution. Application developers should modify their applications to be compliant with the Windows Vista Logo program as soon as possible, rather than relying on file, folder, and registry virtualization.

Consent/Credential Prompt

2006-07-30T09:27:00.000-07:00

The UAC elevation prompts are also customized based on the type of executable that is requesting elevation. The diagram above illustrates the different UAC prompts that are displayed based on the type and state of the requesting executable. This behavior is the default for Windows Vista and is not configurable, with one exception-- the ability to configure blocked applications with Group Policy and to block applications that are not signed and validated.

You can control what kind of user input that the prompt requires by configuring a new security policy setting introduced in Windows Vista. The setting is located in the Security Policy Manager Microsoft Management Console (MMC) snap-in under the path: Local Security Settings->Local Policies->Security Options.

Privilege Specification Model

2006-07-30T09:20:00.000-07:00

UAC extends the access token system already in use for managing Windows logons with a new access token mechanism that supplies each administrator logon with two security access tokens: a UAC access token and a full administrator access token. The default access token is a standard user access token.

The default access token that is used to launch the desktop, the explorer.exe process, is a standard user access token, and any child processes of explorer.exe will inherit this standard user access token.

UAC Technologies

2006-07-30T09:09:00.000-07:00

User Account Control (UAC) is a new security component of the Microsoft® Windows Vista operating system. UAC will be one of the first technologies you will likely encounter in Windows Vista. User Account Control is a collection of technologies in Windows Vista that enables users to run as standard users, with low privilege, while still being able to perform common tasks and enjoy high application compatibility. UAC technologies include:

Privilege Specification Model
Consent/Credential Prompt
Application Information Service (AIS)
Installer Detection
Data Virtualization
ActiveX Installer Service
And more ...

The Layers of a Manageable System

2006-06-14T13:11:00.000-07:00

In Craig McMurtry's talk, he spent most of his time on the layers of a manageable system. These layers are:

Instruments (Data & Control Points). These are discernable properties for ascertaining the health of the application, and various controls that can be manipulated to adjust its behavior. Configuration System, Events, Performance Counters, Logs, Traces, WMI Providers.
Monitoring and Manipulation Tools. Management Interfaces, Configuration Editor, Event Viewer, WS-Management, WMI Clients, MONAD Scripts and CmdLets, TraceViewer.
Management Model (Aspects and States:Microsoft Management Model Designer). Now given the instrumentation points that one can examine and manipulate, and given all one’s tools for accessing them … when you organize those logically so that you know how to use them to detect what states your applications are in, and how to use them to move the application from worse states into better ones … that logical organization of one’s tools and one’s knowledge of the application is called a Management Model or a Health Model.
Integrated Management Solution. MOM Pack can be used to implement your management model.

As an application developer or architect, it is your job to provide the instrumentation at the lowest level, and you need to ensure that instrumentation is accessible using standard tools, so that system administrators are not required to learn a whole bunch of new tricks, but can monitor and manage your application with the tools they already know. And it is also your job to capture your knowledge of how the application should work and how to keep it working in the form of a management model. Finally, it is your job to realize that management model in an integrated management solution.

Adopted from Craig's talk.

Crown Jewels of Windows Communication Foundation

2006-06-14T12:25:00.000-07:00

Craig McMurtry gave an excellent talk on Windows Communication Foundation: Enabling Manageable Systems. In his talk, he indicated that WCF has at least four crown jewels:

Service model programming model.
Pluggable software factory architecture
Claims-based authorization
Management facilities

The Hardest Single Part of Building a Software System Is Deciding What to Build

2006-05-30T09:32:00.000-07:00

A quote from Fred Brooks:

The hardest single part of building a software system is deciding what to build. No other part of the conceptual work is as difficult in establishing the detailed technical requirements, including the interfaces to people, to machines, and to other software systems. No other part of the work so cripples the results if done wrong. No other part is more difficult to rectify later. Therefore, the most important function that the software builder performs for the client is the iterative extraction and refinement of the product requirements.

What Must Happen for Schedules to Work

2006-05-28T14:31:00.000-07:00

The following is Scott Berkun's list on what must happen for schedules to work

Milestone length should match project volatility.
Be optimistic in the vision and skeptical in the schedule.
Bet on design.
Plan checkpoints for add/cut discussions.
Inform the team about planning philosophy.
Gauge the team's experience with the problem space.
Gauge the team's confidence and experience in working together.
Take on risks early.

Adopted from The Art of Project Management by Scott Berkun.

Project Schedules

2006-05-28T14:22:00.000-07:00

Schedules serve three functions: allowing for commitments to be made, encouraging everyone to see her work as a contribution to a whole, and enabling the tracking of progress. Even when schedules slip, they still have value.

I like the following Scott Berkun's statements regarding schedules:

Until there is a draft schedule suggesting specific dates and times for when things have to be ready, it's unlikely that connections and dependencies across people or teams will be scrutinized.
Schedules force everyone whose work appears on them to carefully think through the work they need to do and how it fits into what others are doing.
Good schedules come only from a leader or a team that relentlessly pursues and achieves good judgment in many different aspects of software development.
A schedule doesn't have to be perfect. Schedules need to be good enough for the team and the leaders to believe in, provide a basis for tracking and making adjustments, and have a probability of success that satisfies the client, the business, or the overall project sponsor.
Despite how perfect and wonderful all the estimates for work items are, the real schedule risks are the things not written down.
Big schedules should be divided into small schedules to minimize risks and increase the frequency of adjustments.

Adopted from The Art of Project Management by Scott Berkun.

Good Estimates Come From Good Designs

2006-05-28T14:04:00.000-07:00

The most important thing about good estimates is that they only come from credible designs and requirements. Good engineering estimates are possible only if you have two things: good information and good engineers.

Here are some additional ways to ensure good estimates:

Establish baseline confidence intervals for estimates.
Lead programmers must set the bar for quality estimations by asking good questions and taking wise approaches that the team can emulate.
Programmers should be trusted.
Estimates depend on the programmer's understanding of the project goals.
Estimates should be based on previous performance.
Specification or design quality should be to whatever point engineering needs to make good estimates.
There are known techniques for making better estimates. For example, PERT.

Adopted from The Art of Project Management by Scott Berkun.

Software as a Service (SaaS)

2006-05-23T20:55:00.000-07:00

Expressed most simply, software as a service can be characterized as follows:

"Software deployed as a hosted service and accessed over the Internet."

It doesn't prescribe any specific application architecture; it doesn't say anything about specific technologies or protocols; it doesn't draw a distinction between business-oriented and consumer-oriented services, or require specific business models. According to this definition, the key distinguishing features of software as a service are where the application code resides, and how they are deployed and accessed.

For example, consider Web-based e-mail services, such as Microsoft Hotmail. It meets all of the basic criteria: a vendor hosts all of the program logic and data, and provides end users with access to this data over the public Internet, through a Web-based user interface.

From an application architect's point of view, there are three key differentiators that separate a well-designed SaaS application from a poorly designed one. A well-designed SaaS application is scalable, multi-tenant-efficient, and configurable.

SaaS is going to have a major impact on the software industry, because software as a service will change the way people build, sell, buy, and use software.

Adopted from Architecture Strategies for Catching the Long Tail by Frederick Chong and Gianpaolo Carraro.

Benefits of Software as a Service

2006-05-23T19:27:00.000-07:00

SaaS provides the following benefits:

Transferring IT responsibilities. A much larger percentage of the IT budget is available to spend on software, typically in the form of subscription fees to SaaS providers. The budget spent on hardware and professional services will be much less.
Leveraging economy of scale. Even accounting for the hardware and professional services costs incurred by SaaS vendors, customers can still obtain significantly greater pure software functionality for the same IT budget,
Selling to the long tail. SaaS vendors can offer solutions at a much lower cost than traditional vendors, not only in monetary terms, but also by greatly reducing the need for customers to add complexity to their IT infrastructure. This gives SaaS exclusive access to an entirely new range of potential customers that have always been inaccessible to traditional solution vendors, because it has never before been cost-effective to serve them.

Adopted from Architecture Strategies for Catching the Long Tail by Frederick Chong and Gianpaolo Carraro.

ADO.NET vNext

2006-05-12T16:02:00.000-07:00

Carl Perry gave a talk on ADO.NET vNext, the future version of ADO.NET. Frankly speaking, I don't quite understand his talk. Here are some high level recap of his talk:

Focus on EDM, entity data model
E-SQL is created and used to query entities
Support LINQ
The model is flexible on the provider, the provide could be Oracle provider, or Web services, etc

I don't like E-SQL simply because I need to learn another new language.

The Simpler Your View of What You Do the More Power and Focus You Will Have in Doing It

2006-05-06T16:42:00.000-07:00

In his book The Art of Project Management, Scott Berkun states: The simpler your view of what you do, the more power and focus you will have in doing it. I like this statement very much. This statement can be applied to many things. Scott explained it as “Periodically maintain a simple view of our work.” I like to apply it to software requirements and designs.

In the past, I saw that many projects failed because the designers of requirements and designs seeked too much on “perfectness”, fancy, and overly complete. If they can see every detail down the road and the future trend, they are able to design a rather perfect product. In reality, that’s not the case.

Only a small percentage of designers know that it is way better to figure out core pieces of the product, focus on them, implement them first, and even consider releasing them first. Here are some reasons.

First, it’s simpler to do that. A simple math explains that. Assume that you are given three requirements and they are not independent. You might drill down to a dozen of requirements. So you have a dozen of requirements in front of you. You focus on them and won’t MISS any of them. Now assume that you are given twenty requirements and they are not independent. You might drill down to over a hundred requirements. It’s much more complicated to create a design covering all of them and fine tuning all the relationships. It’s very easy to miss a couple of requirements.

Core pieces of your product are much more solid. You have fewer requirements; the project size (for this phase) is smaller; the structure is simpler. These all help on your design and implementation.

It’s much easier to adjust directions according to customer feedbacks. Your design might not be exactly what customers expect. It’s much easier to adjust directions because the product size is smaller and the structure is simpler. You might adjust the priority of your future feature list according to customer feedbacks.

You might earn market share because you release your product earlier.

You might make money earlier to sustain your future development.

You might adopt latest technology in your next phase of your product. Technology changes rapidly, especially on application side. You might expect that there are significant changes every two years. If you phase out, you might apply the latest technology to your next phase of the product.

You should keep one thing in mind: You should design your components in the way that it is easier to extend them.

Let me conclude this post with a quote from Albert Einstein: Any fool can make things bigger, more complex, and more violent. It takes a touch of genius – and a lot of courage – to move in the opposite direction.

ASP.NET Health Monitoring

2006-05-06T14:23:00.000-07:00

Erik Reitan gave a talk on ASP.NET Health Monitoring. ASP.NET 2.0 provides an easy way to monitor the health of deployed ASP.NET applications, providing you with detailed run-time information about ASP.NET resources. You might only need to tweak a few settings on Web.config. Awsome!

Useful Links on Localization

2006-03-24T15:41:00.000-08:00

I 'm working on a localization project now. I found that the follwing links are helpful:

Resource Fallback Process

2006-03-20T10:21:00.000-08:00

The hub and spoke model for packaging and deploying resources uses a fallback process to locate appropriate resources. If an application user requests a ResourceSet that is unavailable, the common language runtime searches the hierarchy of cultures looking for an appropriate fallback resource that most closely matches the user's request, and raises an exception only as a last resort. At each level of the hierarchy, if an appropriate resource is found, the runtime uses it. If the resource is not found, the search continues at the next level. The resource fallback process is described in the following steps:

The runtime first checks the GAC for an assembly matching the requested culture for your application.
The runtime next checks the directory of the currently executing assembly for a directory matching the requested culture. If it finds the directory, it searches that directory for a valid satellite assembly for the requested culture.
The runtime next searches the global assembly cache again, this time for the parent assembly of the requested resource. The parent is defined as the appropriate fallback culture. Consider parents as best-fit candidates; providing any resource is preferable to throwing an exception.
The runtime next checks the directory of the currently executing assembly to see if it contains a parent directory. If a parent directory exists, the runtime searches the directory for a valid satellite assembly for the parent culture.
The runtime next searches parent assemblies, as in the previous step, through many potential levels. Each culture has only one parent, but a parent might have its own parent.
If the culture that was originally specified and all parents have been searched and the resource is still not found, the resource for the default (fallback) culture is used.
Finally, if the runtime does not find a resource for a default (fallback) culture, an exception is thrown indicating that the resource could not be found.

Adopted from SDK.

How to Enable CLR in SQL Server 2005

2006-03-16T12:56:00.000-08:00

CLR is disable by default in SQL Server 2005. So if you write a SQL assembly and deploy it to your SQL Server 2005. It won't let you execute it.

The SQL Server 2005 Surface Area Configuration let you enable CLR - without having to do it the t-sql way. The tool is under start/All programs/sql server 2005/Configuration Tools. Once in there, you can choose between "Surface Area Config for Services & Connections" or "surface Area Config for Features". Choose Features and you will see the CLR checkbox.

I learned this from Julie Lerman.

List of .NET 2.0 and C# 2.0 new features

2006-03-02T13:55:00.000-08:00

In his article List of .NET 2.0 and C# 2.0 new features, Patrick Smacchia gave short descriptions on .NET 2.0 and C# 2.0 new features. Here is an example (quoted from his article).

The use of the AssemblyKeyFile attribute to sign an assembly is to be avoided. It is now preferred that you use the /keycontainer and /keyfile options of csc.exe, or the new project properties of Visual Studio 2005.

I'll use his list to check if I do something that are not favorable to .NET 2.0 and C# 2.0.

How to Create a Debugger Visualizer

2006-03-02T13:46:00.000-08:00

In his article Create a Debugger Visualizer in 10 Lines of Code, Tomer Noy shows how to create a debugger visualizer to view Image objects. Very cool.

Security Training Modules

2006-02-27T14:14:00.000-08:00

The following is the link to short training videos and labs by Keith Brown on some common security issues:

patterns & practices Security Training Modules Index

Infrastructure architects and the Logical Datacenter Designers in VSTS

2006-01-17T18:31:00.000-08:00

The infrastructure architect's primary task is to model the network and datacenter onto which the application will be deployed.

Although not directly related to the software development effort, these models are critical to the success of an application because the application must be validated against these constraints to prove that it can be deployed to that environment. This concept is known as Design for Deployment.

Using Logical Datacenter Designers the architect will define the following:

Type of servers (application Hosts: Web server, database server, and generic)
Communication pathways between Hosts (server endpoints: HTTP, TDS, and generic)
Type of communication boudaries (Zones: Intranet, VPN, DMZ, and Firwalls)
Communication connection points (zone endpoints)
Type of services enabled
Configuration of application services
Adding or removing setting resources to logical servers and endpoints

Adopted from Richard Hundhausen's book Working With Microsoft Visual Studio 2005 Team System.

What Are Software Factories?

2006-01-04T18:50:00.000-08:00

Software Factories consist of specialized tools, processes, and other assets, such as patterns, architectures, frameworks, templates, requirements, test cases, and deployment topologies; that encapsulate the business and technical knowledge of specific problem domains.

Instead of taking a generic, one-size-fits-all approach, Software Factories use custom collections of DSLs to provide sets of abstractions customized to meet the needs of specific families of systems like ecommerce, financial arbitrage, or home banking applications. With Software Factories, models are used not only for analysis and design, but to support many varied types of computation across the entire software life cycle—even at run time. This is a fundamental principle of Software Factories, and also of Microsoft's Dynamic Systems Initiative (DSI), which implements and complements the Software Factories Initiative.

A Software Factory defines a tailored methodology for a specific family of systems using a graph of viewpoints. Each viewpoint defines some aspect of the life cycle for members of the system family, such as requirements capture, database design, or service contract definition. The factory associates reusable assets with each viewpoint, and delivers them in the context of that viewpoint to the team's development members of the system family, eliminating the need to search for applicable assets, enabling validation, and supporting manual and automatic guidance enactment.

Software Factories automate the packaging and delivery of the reusable assets, including models and model-driven tools, other types of tools, such as wizards, templates and utilities, development processes, implementation components, such as class libraries, frameworks and services, and content assets, such as patterns, style sheets, help files, configuration files, and documentation.

Software Factories are not in any way, shape, or form intended to turn developers into menial laborers. Software Factories will instead make developers more productive, by automating rote and menial tasks, and by helping them work at higher levels of abstraction. Programmable tools supplied by factories will enable developers to spend more time thinking about how to solve problems, and less time doing all the housekeeping work required to create, build, and deploy their solutions.

Adpoted from Visual Studio 2005 Team System Modeling Strategy and FAQ.

DSL vs. UML

2006-01-03T19:13:00.000-08:00

Microsoft would recommend using UML and UML-based tools for:

Sketching.
White boarding.
Documentation.
Conceptual drawings that do not directly relate to code.

Microsoft would recommend precisely defined DSLs and DSL-based tools for:

Precise abstractions from which code is generated.
Precise abstractions that map to variation points in frameworks and components.
Precise mappings between DSLs.
Conceptual drawings that have precisely specifiable mappings to other DSLs or to code artifacts.

Adpoted from Visual Studio 2005 Team System Modeling Strategy and FAQ.

Modeling Strategy in VSTS

2006-01-03T18:12:00.000-08:00

VSTS's vision is to change the way developers perceive the value of modeling. To shift their perception that modeling is a marginally useful activity that precedes real development, to recognition that modeling is an important mainstream development task and not an activity primarily focused on documentation. This shifting has the following benefits:

Developers write less conventional code since more powerful application abstractions can be employed. Model-driven development is thus inherently more productive and agile.
Others involved in development, from business analysts, architects, designers to network staff, and system management specialists, will perceive modeling as adding value to the tasks for which they are responsible.
Communication between people can be optimized, and traceability enabled across the life cycle in any direction.

Microsoft adopts an approach to model-driven development based on the following ideas:

A model should be a first-class artifact in a project—not just a piece of documentation waiting to become outdated.
A model represents a set of abstractions that support a developer in a well-defined aspect of development.
Since models can abstract and aggregate information from a number of artifacts, they can more readily support consistency checks and other forms of analysis.
Models can be implemented by a process similar to compilation, where the code, configuration files, and other implementation artifacts generated by the compiler are never edited by hand.

Microsoft calls modeling languages defined in these ways Domain Specific Languages or DSLs.

So a domain-specific language (DSL) is a language designed to be useful for a specific task in a fixed problem domain, in contrast to a general-purpose language.

Adpoted from Visual Studio 2005 Team System Modeling Strategy and FAQ.

Notes on Application Designer in VSTS

2005-12-27T19:52:00.000-08:00

You can have only one application diagram in your solution because it describes the overall structure of the solution in terms of interconnected applications. However, a solution can have multiple system, deployment, and logical datacenter diagrams.

Some of the Microsoft-provided application types support a full round-tripping experience with code—notably ASP.NET applications and Windows applications. That is, changes made to code are reflected in the designers, while changes made in the designer are reflected in code.

The ASP.NETWebService prototype is in effect an ASP.NETWebApplication prototype that has the Web content endpoint removed and a Web service endpoint added for your convenience.

Applications communicate through endpoints, and for two applications to be connected together, there must be a provider endpoint at one end of the connection and a consumer endpoint at the other end.

Adopted from Tony Loton's article Introduction to the Visual Studio 2005 Application Designer, Part 1

Distributed System Designers in VSTS

2005-12-27T19:34:00.000-08:00

The Visual Studio 2005 Team Architect edition provides four visual designers collectively known as the Distributed System Designers. These four visual designers are:

Application Designer
System Designer
Logical Datacenter Designer
Deployment Designer

Application Designer allows you to define the applications that comprise a distributed system. You can then use those application definitions in System Designer to compose applications into deployable systems. Following this, you can evaluate system deployment using Deployment Designer.

Independently, Logical Datacenter Designer allows you to define a logical representation of the target datacenter in which applications (composed into systems) will be deployed. Consequently, Deployment Designer takes as input not only a set of system definitions from System Designer, but also a set of logical server definitions from Logical Datacenter Designer.

Adopted from Tony Loton's article Introduction to the Visual Studio 2005 Application Designer, Part 1

Some Tenets That the Agile Alliance Agrees On

2005-12-27T14:08:00.000-08:00

Here are some tenets that the Agile Alliance agrees on:

Individuals and interactions are more important than processes and tools
Customer collaboration is more important than contracts
Working software is more important than comprehensive documentation
Responding to change is more important following a plan

I know several interpretations of the tenets that the Agile Alliance agrees on. I like this one the most. This one is adopted from Richard Hundhausen's book Working With Microsoft Visual Studio 2005 Team System.

PM Skills

2005-12-27T13:41:00.000-08:00

Chris Sells posted some excellents points on PM skills. The following are some highlights:

PM Skill #0: Know Your Job
PM Skill #1: Communicate, Communicate, Communicate

A PM's job is to ship the right thing on time and on budget, while keeping your team happy.

Read more details from his posts.

Notes on Billy Hollis's Talks

2005-12-19T20:02:00.000-08:00

I read quite a few Billy Hollis's articles from VB.NET columns, but I never meet him in person until this "P & P" summit. He gave two talks at "P & P" Summit : "Smart Client Case Study" and "Re-engineering to support workflow." Here are some notes from his talks:

If we try to convert a legacy system to an .NET application, read his slides first for the lessons he learned.
Declarative programming is what you want whenever possible
Deal with developers who are not familar with .NET programming
Workflow = Work + Flow
Service Broker is the best for "Work"
BitTalk is good for "Flow"

Benefits Of LINQ

2005-12-19T19:50:00.000-08:00

The follow are benefits of LINQ:

Unified querying of objects, relational, XML
Type checking and IntelliSense for queries
SQL and XQuery-like power in C# and VB
Extensibility model for languages / APIs

Taken from Anders Hejlsberg's slides.

Exception Policies

2005-12-19T19:42:00.000-08:00

The following are some “Exception Policies” from Patterns & Practices:

Exceptions of type ApplicationException should be logged
Exceptions of type SqlClientException should be caught and wrapped with an exception of type DataLayerException and re-thrown
Exceptions of type SecurityException should caught and replaced with an AccessDeniedException which will be thrown

Adopted from Tom Hollander's slides: Enterprise Library for .NET 2.0:Architecture & Lessons Learned.

UI Thread Rule in .NET Framework 2.0

2005-12-11T12:09:00.000-08:00

Windows Forms relies on the underlying Win32® messages. Therefore, it inherits the classic Windows programming requirement that only the thread that created the window can process its messages.

The UI Thread rule states that you must never use any member of a Control on any thread other than the one that created it with exceptions of Control.Invoke, Control.BeginInvoke, Control.EndInvoke, and Control.CreateGraphics.

In his article: C# 2.0: Create Elegant Code with Anonymous Methods, Iterators, and Partial Classes, Joval Lowy stated that calls on the wrong thread will always trigger an exception under Windows Forms in the .NET Framework 2.0. I haven't yet verified this from official source, but I trust Joval. This is great!

When using multithreaded programming in Windows Forms, you should begin to use the BackgroundWork component. Check my post BackgroundWorker Component in Windows Forms 2.0.

Anonymous Methods in C# 2.0

2005-12-11T11:07:00.000-08:00

Anonymous methods is a new feature in C# 2.0 that lets you define an anonymous (that is, nameless) method called by a delegate. Creating anonymous methods is essentially a way to pass a code block as a delegate parameter.

// Create a handler for a click event
button1.Click += delegate(System.Object o, System.EventArgs e) { System.Windows.Forms.MessageBox.Show("Click!"); };

The anonymous method is defined in-line and not as a member method of any class.

Anonymous methods can be used anywhere that a delegate type is expected. You can pass an anonymous method into any method that accepts the appropriate delegate type as a parameter. A concrete and useful example for passing an anonymous method as a parameter is launching a new thread without explicitly defining a ThreadStart delegate or a thread method:

void StartThread(){
System.Threading.Thread t1 = new System.Threading.Thread(delegate() {
System.Console.Write("Hello, ");
System.Console.WriteLine("World!");
});
t1.Start();
}

An anonymous method can use any class member variable, and it can also use any local variable defined at the scope of its containing method as if it were its own local variable.

An anonymous method can use generic parameter types, just like any other method. Because delegates can define generic parameters, an anonymous method can use generic types defined at the delegate level.

Anonymous Methods are quite useful because it replaces the need for creating a simple method in cases where only a delegate will suffice.

Adopted from Joval Lowy's article C# 2.0: Create Elegant Code with Anonymous Methods, Iterators, and Partial Classes and C# Programmer's Reference: Anonymous Methods.

Iterators in C# 2.0

2005-12-10T12:55:00.000-08:00

An iterator is a section of code that returns an ordered sequence of values of the same type.

In C# 1.1, the Iterator design pattern is used to shield iterating clients from the actual implementation details of the underlying data structure, enabling the use of the same client-side iteration logic over multiple data structures.

But there are some problems. The first is that if the collection contains value types, obtaining the items requires boxing and unboxing them because IEnumerator.Current returns an Object. This results in potential performance degradation and increased pressure on the managed heap. Even if the collection contains reference types, you still incur the penalty of the down-casting from Object. While unfamiliar to most developers, in C# 1.0 you can actually implement the iterator pattern for each loop without implementing IEnumerator or IEnumerable.

The Microsoft .NET Framework 2.0 solves this problem by defining the generic, type-safe IEnumerable and IEnumerator interfaces.

Besides making use of generics, the new interfaces are slightly different than their predecessors. Unlike IEnumerator, IEnumerator derives from IDisposable and does not have a Reset method.

The second and more difficult problem is implementing the iterator. Although that implementation is straightforward for simple cases, it is challenging with more advanced data structures, such as binary trees.

Using iterators in C# 2.0, you can have the C# compiler generate the implementation of IEnumerator for you. The C# compiler can automatically generate a nested class to maintain the iteration state. You can use iterators on a generic collection or on a type-specific collection. All you need to do is tell the compiler what to yield in each iteration. The following is an example.

public class CityCollection : IEnumerable
{
string[] m_Cities = {"New York","Paris","London"};
public IEnumerator GetEnumerator()
{
for(int i = 0; i << m_Cities.Length; i++)
yield return m_Cities[i];
}
}

Your collection can easily expose multiple iterators, each used to traverse the collection differently. For example, to traverse the CityCollection class in reverse order. You can stop the iteration midstream by using the yield break statement.

The compiler-generated iterator object (and its state) does not persist across foreach loops. This is why IEnumerabledoes not define a Reset method.

Adopted from Joval Lowy's article C# 2.0: Create Elegant Code with Anonymous Methods, Iterators, and Partial Classes.

Review on My Past Posts

2005-12-02T21:51:00.000-08:00

It’s amazing to see that I have blogged for more than one year. Some of my posts are about things and lessons that I learned from work and research. But most of them are notes taken by reading articles and books. I recorded things that I felt touching and useful. My posts represent my interests at the time when they are posted. Actually I use my blog as my notebook. I need to come to my blog quite often to check things. Since I have many posts, now it’s a good time to group them so that I can check thing more efficiently. That’s the purpose of this post.

IIS and ASP.NET security:
Protected Directories in ASP.NET
Protecting Resources in IIS
Accessing Files in IIS 6.0

IIS:
SSL Session Key and Key Pair
Compatibility Issues From IIS 5.0 to IIS 6.0

Enhanced Security Configuration for IE:
IE Enhanced Security Configuration and Smart Clients on SSL
Enhanced Security Configuration for Internet Explorer

SQL Server security:
Phases of SQL Injection
The Main Threats to a Database Server
Some Common SQL Injection Commands
Preventing SQL Injection Attacks
How to Grant Access to SQL Server for the Network service account
Find Other Procedures Using the Same DLL
Some Useful SQL Queries

ASP.NET security:
The Main Threats to a Web Server
How to Create a Service Account for ASP.NET
New Security Features in ASP.NET 2.0
The one-click attack and ViewStateUserKey

ASP.NET
Web Parts in ASP.NET 2.0
ViewState in ASP.NET 2.0
ViewState in ASP.NET 1.x
Reviewing State Management in ASP.NET
Instrument and Monitor Your ASP.NET Apps Using WMI

ACLs and privileges:
Manipulate Privileges in Managed Code
Access to ACLs with the .NET Framework
Some Basic Facts about Access Control

Encryption:
XML Signatures and Encryption

.NET Framework 2.0 resources:
WinForms 2.0 resources

Version compatibility in .NET:
Upgrade to .NET Framework 2.0
Assembly Binding Redirection
Determining Which Version of the Runtime to Load
Version Compatibility

Smart clients:
Identifying Data Stored on the Client for Smart Clients

.NET CF:
The Challenge with Smart Device Development Using the .NET CF
Mobile Device Supports in Visual Studio 2005
The .NET CF Shipped with Visual Studio 2003

Sockets in .NET:
NegotiateStream
Sockets in .NET
Aborting a TcpListener listening thread
Derived TcpClient classes used on the server side

Reflection:
Improving Reflection Performance
What Reflection APIs Are Slow and What Are Not?

Images and drawing:
How to create a 1-bit-per-pixel image from a true-color image in .NET
Some Basic Facts about GIFs

Web services:
Three ways to consume Amazon Web services in .NET
Consuming Web Services Efficiently
Amazon Simple Queue Service (Beta)

SOA and WSE:
Signed Messages in WSE
Securing Service Oriented Architecture with WSE 2.0

Multithreaded:
Concurrency: What Every Dev Must Know About Multithreaded Apps
Ian Griffiths on UI Thread
BackgroundWorker Component in Windows Forms 2.0

CLR internals:
Method Slot Table and MethodDesc
ObjectInstance
Type Fundamentals
Domains Created by the CLR Bootstrap

Localization:
Thread.CurrentCulture and Thread.CurrentUICulture
CultureInfo.CurrentCulture and CultureInfo.CurrentUICulture
Globalization Features in Whidbey

X.509 Certificates:
Using an X.509 Certificate in WSE 2.0
X.509 Certificates

Logging and event log:
Security Log
Network Service and Event Log
Tampering with Log Files
Richard Grimes on EventLog

Generics:
What Are the Benefits of Generics?
How Are Generics Implemented?
How Are Generics Different from Classic Visual C++ Templates?

VSTS:
Visual Studio 2005 Team System

Windows Vista:
Security in Windows Vista: UAP and NAP Framework

Misc on .NET:
System.DirectoryServices
Constrained Execution Regions in the .NET Framework 2.0
You can't directly change boxed values in an array list
Export ASP.NET Data to Microsoft Office
One Issue on FxCop
All about Statics

Design patterns:
Static Classes in C# 2.0 and Abstract and Sealed Pattern
Abstract and Sealed Pattern in .NET
Bridge Pattern and Abstract Factory Pattern
Bridge Pattern and Strategy Pattern
Some mandates of the design pattern community

Design related:
Emergent Design
Alan Shalloway's Rules
A XP Developer's View Point
Steve McConnell's Comment
XP and design

Debugging:
A SOS Extension Issue in VS 2005 Beta 2
SOS Commands
Some Useful Tools in Production Debugging

Unit tests:
Best Practices for Writing Unit Tests
Benifits of Team Test

Data Execution Prevention (DEP):
An Example of Compatibility Issues with Data Execution Prevention
Data Execution Prevention in XP Service Pack 2

Software security lifecycle:
SD3+C: High-level Principles for Building More Secure Software
Three Facets to Building More Secure Software

Security related coding:
WindowsIdentity.Groups
Thread.CurrentPrincipal in .NET Framework 2.0
How to Handle Exceptions Securely
Keeping Attackers Out of the Control Channel
How to Develop Code as a Non Admin
Where to store data files?
Using the ASP.NET Credentials Management Infrastructure in a Windows Forms Application
Application Development Security Guidance for .NET 2.0

Network security:
A Definition of Network Security
The Defense-in-Depth Model
Keep Security Simple
People+Processes+Technology
System Admin vs. Security Admin
Types of Network Attacks
Emergency Response Process
The Goal of a Security Audit
Accessing and Managing Security Risks

Security policies:
Policy, Process, and Technology
Why a Security Policy Is Necessary
How to Make Users Aware of Securities Policies
Some Policies You Might Need

CIA:
Credentials and Delegation
How to Provide CIA for A Network Connection?
What Does A Network Authentication Protocol Do?

Detection and avoiding detection:
Some Common Ways an Attacker Can Attack IDSs and IPSs
IDSs and IPSs
How Attackers Avoid Detection Post-Intrusion
Some Common Ways Attacks Avoid Detection

Penetration Testing and Vulnerability Scanning:
Difference between Penetration Testing and Vulnerability Scanning
Steps for a Vulnerability Scanning

DNS:
Some Useful nslookup Commands
Types of DNS Zones
Three DNS Server Configuration Roles
How does DNS resolve FQDNs to IP addresses?

IPsec:
Using IPsec for Domain Isolation
Using IPsec to Protect Servers
IPsec over NAT
Notes on IPsec

Misc on network security:
Notes on VPN
Hacking the Windows SMB tutorial
Network Sniffers
Well-known Ports

Misc:
Watching the First XAML Presentation
NTFS Alternate File Streams
Hiding Files on Windows Systems
CodeAsDocumentation by Martin Fowler
The 46 Best-ever Freeware Utilities
Gordon Moore: Software is too complex
Microsoft® Dynamic Systems Initiative
The Philosophy of Profilers
How to get around "right click disabled" on some websites?
Windows XP Service Pack 2

How Are Generics Different from Classic Visual C++ Templates?

2005-12-01T18:30:00.000-08:00

Generics are similar in concept to classic C++ templates: both allow data structures or utility classes to defer to the client the actual types to use, and both offer productivity and type-safety benefits.

There are two main differences: in the programming model and in the underlying implementation. In the programming model, .NET generics can provide enhanced safety compared to classic Visual C++ templates. .NET generics have the notion of constraints, which gives you added type safety. On the other hand, .NET generics offer a more restrictive programming model—there are quite a few things that generics cannot do, such as using operators, because there is no way to constraint a type parameter to support an operator. This is not the case in classic Visual C++ templates where you can apply any operator you like on the type parameters. At compile time, the classic Visual C++ compiler will replace all the type parameters in the template with your specified type, and any incompatibility is usually discovered then.

Both templates and generics can incur some code bloat, and both have mechanisms to limit that bloat. Instantiating a template with a specific set of types instantiates only the methods actually used; and then all methods that result in identical code are automatically merged by the compiler which prevents needless duplication. Instantiating a generic with a specific set of types instantiates all of its methods, but only once for all reference type arguments; bloat comes only from value types, because the CLR instantiates a generic separately once for each value type argument. Finally, .NET generics allow you to ship binaries, while C++ templates require you to share some code with the client.

Adopted from Generics FAQ: Fundamentals by Juval Lowy.

What Are the Benefits of Generics?

2005-11-27T13:22:00.000-08:00

Generics offer significant benefits, including productivity, type safety and performance.

What is special about generic types is that you code them once, yet you can use them with different parameters. Doing so has significant benefits—you reuse your development and testing efforts, without compromising type safety and performance, and without bloating your code.

With the object-based solutions, mismatch in type will still get complied, but yield an error at runtime. With generics, such code would never get compiled.

Various benchmarks have shown that in intense calling patterns, generics yield on average 200 percent performance improvement when using value types, and some 100 percent performance improvement when using reference types. However, performance is not the main benefit of generics. In most real-life applications, bottle necks such as I/O will mask out any performance benefit from generics. The most significant benefit of generics is type-safety.

Adopted from Generics FAQ: Fundamentals by Juval Lowy.

How Are Generics Implemented?

2005-11-27T13:13:00.000-08:00

Generics have native support in IL and the CLR itself. When you compile generic server-side code, the compiler compiles it into IL, just like any other type. However, the IL only contains parameters or place holders for the actual specific types. In addition, the metadata of the generic server contains generic information such as constraints.

The client-side compiler uses that generic metadata to support type safety. When the client provides a type arguments, the client's compiler substitutes the generic type parameter in the server metadata with the specified type. This provides the client's compiler with type-specific definition of the server, as if generics were never involved. At run time, the actual machine code produced depends on whether the specified types are value or reference type.

If the client specifies a value type, the JIT compiler replaces the generic type parameters in the IL with the specific value type, and compiles it to native code. However, the JIT compiler keeps track of type-specific server code it already generated. If the JIT compiler is asked to compile the generic server with a value type it has already compiled to machine code, it simply returns a reference to that server code. Because the JIT compiler uses the same value-type-specific server code in all further encounters, there is no code bloating.

If the client specifies a reference type, then the JIT compiler replaces the generic parameters in the server IL with object, and compiles it into native code. That code will be used in any further requests for a reference type instead of a generic type parameter. Note that this way the JIT compiler only reuses actual code. Instances are still allocated according to their size off the managed heap, and there is no casting.

Adopted from Generics FAQ: Fundamentals by Juval Lowy.

Protected Directories in ASP.NET

2005-11-26T13:57:00.000-08:00

By default, ASP.NET 2.0 will block access to all URLs that contain directory segments named App_Data, App_Code, App_Browsers, App_WebReferences, App_GlobalResources, and App_LocalResources anywhere in the URL. ASP.NET 1.1 and 2.0 will both also block access to the /Bin directory. This support is conditional on having the aspnet_filter.dll ISAPI filter registered with IIS, which is done by default during ASP.NET installation. By placing your content in these directories, you can prevent HTTP access to it regardless of the file extensions being requested.

Adopted from Are You Protected? Design and Deploy Secure Web Apps with ASP.NET 2.0 and IIS 6.0 by Michael Volodarsky.

Protecting Resources in IIS

2005-11-26T13:45:00.000-08:00

Here are some rules/methods regarding how to protect resources in IIS 6.0 (adopted from Michael Volodarsky's article Are You Protected? Design and Deploy Secure Web Apps with ASP.NET 2.0 and IIS 6.0:

If your application is programmatically accessing data or supporting files during its execution, you should place them outside the Web namespace.
If you cannot remove all such files, make sure that IIS is configured not to serve these files to Web clients. This should be accomplished by mapping the extensions for the protected files to ASP.NET in the IIS script processor map configuration, and subsequently mapping those extensions to the HttpForbiddenHandler or HttpNotFoundHandler in the ASP.NET configuration for the application or directory. By default, ASP.NET already blocks access to a number of extensions common to Web applications, including .cs, .java, .mdb, .mdf, .vb, and others.
If you use the IIS static file handler, you should also make the files hidden for additional protection because the IIS static file handler will not serve files that have been given the hidden attribute.

It is frequently thought that removing a corresponding extension entry from the IIS MIME mapping configuration will prevent the static file handler from serving files with that extension. In actuality this is not always true because the static file handler will also honor the registry MIME mapping configuration and therefore will still serve the extension if the registry entry is present. Because of this, you would have to make sure that both the metabase MIME mapping configuration and the registry key in HKEY_CLASSES_ROOT do not contain an extension entry for the forbidden extension. Due to the management complexity, this practice is not recommended as a way of securing content.

Of course, this guidance regarding the IIS static file handler only applies to extensions that are not mapped to an ISAPI extension in the IIS script mapping configuration.

Accessing Files in IIS 6.0

2005-11-25T13:48:00.000-08:00

What are the operations in order performed by IIS 6.0 if you launch IE to send a request via the URL http://myServer/myApp/test.xyz?

Here is what I found by performing some testing. I might be wrong at some points. So be cautious.

IIS performs authentication/authorization. If it fails at this step, a HTTP Error 401.1 is returned.
IIS does MINE maps.
IIS 6.0 will not deliver content for which there is no MIMEMap entry at the Computer level and in the registry MIME mapping configuration. In this case, a HTTP Error 404 is returned and a HTTP Error 404.3 is logged.
If there is no MIMEMap entry at myApp (site) level and there is a MIMEMap entry at the Computer level or in the registry MIME mapping configuration, then the request will be processed by the IIS static file handler.
If there is a MIMEMap entry at myApp (site) level, then the ISAPI extension in the corresponding IIS script mapping will be responsible for processing the request. Assume that this is the case by now.
IIS starts to check "Execution Permission" on the Virtual Directory tab of the Properties dialog box. If "Execution Permission" is not allowed to process the request, a HTTP Error 403.1 is returned.
Next IIS starts to check "Web Service Extensions". If there is a corresponding Web Service Extension and the Web Service Extension is prohibited, then a HTTP Error 404 is returned and a HTTP Error 404.2 is logged.
Now IIS starts to load the ISAPI extension in the corresponding IIS script mapping to process the request.

Recently I read the following two articles regarding to IIS security:

Are You Protected? Design and Deploy Secure Web Apps with ASP.NET 2.0 and IIS 6.0 by Michael Volodarsky
Essential Security Administration For IIS 6.0 by Brett Hill

Neither articles are made clear on MIMEMaps. Michael's article is excellent except the tiny thing on MIMEMaps. Every developer working on ASP.NET and IIS should read this article.

WinForms 2.0 resources

2005-11-20T10:17:00.000-08:00

The WinForms team has put up all kinds of WinForms 2.0 resources, including a bunch of FAQs and samples.

Adopted from Chris Sells's post.

NegotiateStream

2005-11-14T19:23:00.000-08:00

As SDK states, using NegotiateStream, you can do the following.

Send the client's credentials to the server for Impersonation or Delegation.
Request server authentication.
Encrypt and/or sign data before transmitting it.

If you want CIA protection, the client must first call AuthenticateAsClient and the server must call AuthenticateAsServer. Both calls block. If you miss one on one side, then you are not able to use NegotiateStream on this side and the other side is blocked. As Keith Brown points out, these functions map down to SSPI's InitializeSecurityContext and AcceptSecurityContext, and basically implement an authenticated key exchange using a protocol called SPNEGO, which stands for "secure, protected negotiation."

The client should also specify a service princpal name (SPN) if its wants to use Kerberos.

WindowsIdentity.Groups

2005-11-13T13:59:00.000-08:00

WindowsIdentity.Groups can be used to display the list of groups that an account belongs to. The following code enumerates the group list and displays both the group name and SID.

WindowsIdentity wi = WindowsIdentity.GetCurrent();
foreach (IdentityReference id in wi.Groups)
{
Console.WriteLine(@" {0}, {1}",
((NTAccount)((SecurityIdentifier)id).Translate(typeof(NTAccount))).Value,
id.Value);
}

However, this property is buggy. So be cautious to use it. I found strange (wrong) behaves.

If you list the groups that Network Service or Local Service belongs to, you get two Users groups with the same SID.
If you create a local normal user named tmpUser and then remove it from the Users group, then you log out and relog in your system, and then launch your app under the tmpUser account to display the list of groups that it belongs to. You'll find that the Users group still shows up in the list!

Thread.CurrentPrincipal in .NET Framework 2.0

2005-11-12T12:16:00.000-08:00

Thread.CurrentPrincipal is simply a helpful property for keeping track of a principal, and is primarily used in server applications to track client identity. As Keith Brown pointed out that
Thread.CurrentPrincipal propagates during asynchronous activities such as asynchronous delegates and creating new threads, but doesn't propagate during ThreadPool.QueueUserWorkItem and System.Threading.Timer, in .NET Framework 1.1.

I found that
Thread.CurrentPrincipal propagates during
ThreadPool.QueueUserWorkItem in .NET Framework 2.0.

Upgrade to .NET Framework 2.0

2005-11-12T12:12:00.000-08:00

Our company has an application built and running against .NET Framework 1.1. The client side is a Windows Forms control embedded in IE. So the client requires .NET Framework. The control makes Web service calls to a Web server and Web services make ADO.NET calls to a SQL Server database.

Recently I tested the app under .NET Framework 2.0 with all the combinations: client 1.1 + server 2.0, client 2.0 + server 1.1, client 2.0 + server 2.0. It worked very well and no change was made. Amazing!

I found that MSDN documentation in this area is very poor. So I record a couple of things that I feel useful. Assume that .NET Framework 2.0 is installed on top of an existing .NET Framework 1.1.

IE always loads .NET Framework 2.0 no matter which version of .NET Framework your Windows Forms control is built against if both 2.0 and 1.1 are present. This is against .NET rule. The rule says that, if the version of the .NET Framework that the application was built against is present on the computer, the application runs on that version. Our control was built against .NET 1.1, but .NET 2.0 was loaded by IE instead of .NET 1.1.
If .NET 2.0 is installed on top of .NET 1.1, the combo box on the ASP.NET tab in IIS will contain two entries: .NET 2.0 and .NET 1.1. But .NET 1.1 remains the default. This is very good because it causes the least pain when upgrading of servers. If you want to run your Web app against .NET 2.0, then you need to change the framework version to 2.0 on the ASP.NET tab.

Watching the First XAML Presentation

2005-11-08T16:04:00.000-08:00

I read a couple of Chris Sells's articles on Longhorn two years ago, but I never had chance to watch presentations on Avalon and try Avalon myself. Gary Fuhr gave a presentation on XAML yesterday at .NET Developers Association. WPF is cool! It seems to me that it's not hard for an experienced WinForm developer to work with WPF.

Many Windows developers like me are not good at graphic design. We spent most of our time on how to wire things up using frameworks provided by Microsoft. WPF provides much more ways to create much cooler graphics and graphic design is tougher than before. We (Windows developers) really need an easy-to-use graphic design tool to help us. After done with graphic design using the tool, the tool should be able to export XAML for us to use in VS .NET.

Best Practices for Writing Unit Tests

2005-10-26T12:31:00.000-07:00

Here are some principals that will help with successful testing:

Avoid creating dependencies between tests such that tests need to run in a particular order. Each test should be autonomous.
Use test initialization code to verify that test cleanup executed successfully and re-run the cleanup before executing a test if it did not run.
Write tests before writing the any production code implementation.
Create one test class corresponding to each class within the production code.
Use Visual Studio to generate the initial test project. This will significantly reduce the number of steps needed when manually setting up a test project and associating it to the production project.
Avoid creating other machine dependent tests such as tests dependent on a particular directory path.
Create mock objects to test interfaces. Mock objects are implemented within a test project to verify that the API matches the required functionality.
Verify that all tests run successfully before moving on to creating a new test. That way you ensure that you fix code immediately upon breaking it.
Maximize the number of tests that can be run unattended. Make absolutely certain that there is no reasonable unattended testing solution before relying solely on manual testing.

Adpoted from A Unit Testing Walkthrough with Visual Studio Team Test by Mark Michaelis.

Benifits of Team Test

2005-10-26T11:59:00.000-07:00

Team Test is a Visual Studio integrated unit-testing framework that enables:

Code generation of test method stubs.
Running tests within the IDE.
Incorporation of test data loaded from a database.
Code coverage analysis once the tests have run.

Adpoted from A Unit Testing Walkthrough with Visual Studio Team Test by Mark Michaelis.

Assembly Binding Redirection

2005-10-10T13:01:00.000-07:00

A binding redirection in an application configuration file for a unified .NET Framework assembly cancels the unification for that assembly.

Explicit assembly binding redirection in an application configuration file requires a security permission. The permission is granted by setting the BindingRedirects flag on the SecurityPermission Class. Managed assemblies have no permissions by default.

The security permission is granted to applications running in the Trusted Zone (local machine) and Intranet Zone. Applications running in the Internet Zone are strictly prohibited from performing assembly binding redirection.

Adopted from SDK.