WebForms 3.5

Track and quash bugs

2009-09-02T07:34:00.001-05:00

Bugs in software are inevitable and unavoidable probably because most software today is written by humans. Its not that humans are sloppy information systems creators, its because programming is both an art and a science which means there is a lot of variation in how to do it. This means every programmer has to address the issue of bugs in software. This blog post discusses the rationale for bug tracking and How to track bugs.

Why Track bugs.

The one article that every programmer should read on Bug Tracking is Painless Bug Tracking by Joel Spolsky. In the article he covers why you need a bug tracking solution with a real database.

The Reasons for having a bugs database:

Nobody can keep track of all the bugs on pieces of paper or in their head.
You often need to prioritize what bugs to fix.
You often need to be able to reproduce the bug while fixing it.
You often need to be able to track the history of the bug
You need all kinds of metrics that most good bug databases provide to determine the quality of your software or development effort.

There are probably a few other reasons you should manage bugs, but the above should enable you to convince anyone that might think that bug tracking is another unnecessary effort in the software development effort.

If you are developing code, even on a team of one, without an organized database listing all known bugs in the code, you are simply going to ship low quality code. On good software teams, not only is the bug database used universally, but people get into the habit of using the bug database to make their own "to-do" lists, they set their default page in their web browser to the list of bugs assigned to them, and they start wishing that they could assign bugs to the office manager to stock more Mountain Dew. Painless Bug Tracking by Joel Spolsky.

How to track (and quash) the bugs

Testers usually capture the bug in testing. Software should always be tested by someone that didn’t write it. Always remember that Programmers will inevitably create bugs not because they are sloppy but because they are human.

When the bug is captured, the steps that caused the bug should be captured in the bug database. Having the list of reproduction steps is crucial for the programmer that has to fix it.Always reduce the number of steps when possible to enable the person doing the fixes to work faster.

Work hard to make sure that you create good bug reports because bad bug reports waste everyone’s time. Every bug needs to be assigned to exactly one person at all times, until it is closed.

When a bug is resolved, it gets assigned back to the person who opened it. Only the person who opened the bug can close the bug.

Three Parts To Every Good Bug Report

And the Lord spake, saying, "First shalt thou take out the Holy Pin. Then, shalt thou count to three, no more, no less. Three shall be the number thou shalt count, and the number of the counting shalt be three. Four shalt thou not count, nor either count thou two, excepting that thou then proceed to three. Five is right out. Once the number three, being the third number, be reached, then lobbest thou thy Holy Hand Grenade of Antioch towards thou foe, who being naughty in my sight, shall snuff it."

-- Monty Python and the Holy Grail

It's pretty easy to remember the rule for a good bug report. Every good bug report needs exactly three things.

Steps to reproduce,

What you expected to see, and

What you saw instead.

Seems easy, right? Maybe not. As a programmer, people regularly assign me bugs where they left out one piece or another.

If you don't tell me how to repro the bug, I probably will have no idea what you are talking about. "The program crashed and left a smelly turd-like object on the desk." That's nice, honey. I can't do anything about it unless you tell me what you were doing. Now, I admit that there are two cases where it's hard to get exact steps to repro. Sometimes you just don't remember, or you're just transcribing a bug from "the field." (By the way, why do they call it "the field"? Is it, like, a field of rye or something? Anyway...) The other time it's OK not to have repro steps is when the bug happens sometimes but not all the time, but you should still provide repro steps, with a little annotation that says that it doesn't happen too often. In these cases, it's going to be really hard to find the bug, but we can try.

If you don't specify what you expected to see, I may not understand why this is a bug. The splash screen has blood on it. So what? I cut my fingers when I was coding it. What did you expect? Ah, you say that the spec required no blood! Now I understand why you consider this a bug.

Part three. What you saw instead. If you don't tell me this, I don't know what the bug is. That one is kind of obvious.(Painless Bug Tracking by Joel Spolsky.)

Top Ten Tips for Bug Tracking (Painless Bug Tracking by Joel Spolsky.)

A good tester will always try to reduce the repro steps to the minimal steps to reproduce; this is extremely helpful for the programmer who has to find the bug.
Remember that the only person who can close a bug is the person who opened it in the first place. Anyone can resolve it, but only the person who saw the bug can really be sure that what they saw is fixed.
There are many ways to resolve a bug. FogBUGZ allows you to resolve a bug as fixed, won't fix, postponed, not repro, duplicate, or by design.
Not Repro means that nobody could ever reproduce the bug. Programmers often use this when the bug report is missing the repro steps.
You'll want to keep careful track of versions. Every build of the software that you give to testers should have a build ID number so that the poor tester doesn't have to retest the bug on a version of the software where it wasn't even supposed to be fixed.
If you're a programmer, and you're having trouble getting testers to use the bug database, just don't accept bug reports by any other method. If your testers are used to sending you email with bug reports, just bounce the emails back to them with a brief message: "please put this in the bug database. I can't keep track of emails."
If you're a tester, and you're having trouble getting programmers to use the bug database, just don't tell them about bugs - put them in the database and let the database email them.
If you're a programmer, and only some of your colleagues use the bug database, just start assigning them bugs in the database. Eventually they'll get the hint.
If you're a manager, and nobody seems to be using the bug database that you installed at great expense, start assigning new features to people using bugs. A bug database is also a great "unimplemented feature" database, too.
Avoid the temptation to add new fields to the bug database. Every month or so, somebody will come up with a great idea for a new field to put in the database. You get all kinds of clever ideas, for example, keeping track of the file where the bug was found; keeping track of what % of the time the bug is reproducible; keeping track of how many times the bug occurred; keeping track of which exact versions of which DLLs were installed on the machine where the bug happened. It's very important not to give in to these ideas. If you do, your new bug entry screen will end up with a thousand fields that you need to supply, and nobody will want to input bug reports any more. For the bug database to work, everybody needs to use it, and if entering bugs "formally" is too much work, people will go around the bug database.

Domain Modeling

2009-08-21T08:16:00.000-05:00

Domain modeling is the determination of a conceptual model of a system. This describes the various entities involved in a system and their relationships.

The key items in a domain model are the entities and their relationships to each other. Domain modeling can be done with specialized tools but is usually done with UML Class diagrams.

Domain modeling addresses the issue of complexity in designing software.

The Challenge of Complexity

of course many things can put a project off course, bureaucracy, unclear objectives, lack of resources, to name a few, but it is the approach to design that largely determines how complex software can become. When complexity gets out of hand, the software can no longer be understood well enough to be easily changed or extended. By contrast, a good design can make opportunities out of those complex features.

Some of these design factors are technological, and a great deal of effort has gone into the design of networks, databases, and other technical dimension of software. Books have been written about how to solve these problems. Developers have cultivated their skills.

Yet the most significant complexity of many applications is not technical. It is in the domain itself, the activity or business of the user. When this domain complexity is not dealt with in the design, it won’t matter that the infrastructural technology is well-conceived. A successful design must systematically deal with this central aspect of the software.

The domain model is created in order to document the key concepts, and the domain-vocabulary of the system being modeled. The model identifies the relationships among all major entities within the system, and usually identifies their important methods and attributes. The domain model provides a structural view of the system that can be complemented by additional dynamic views in Use Case models.

The domain model can be used at the construction phase of the software development cycle since the semantics shown in the model can be used in the source code. Entities become classes, while methods and attributes can be implemented in the source code; the same names typically appear in the source code. The process of generating code from the model in this scenario is called forward engineering.

The domain model is one of the central artifacts in the project development approach called Feature Driven Development (FDD).

In UML, a class diagram is used to represent the domain model.

In Domain-driven design, the domain model (Entities and Value objects) is a part of the Domain layer which also includes other concepts such as Services.

An important benefit of a domain model is that it describes and constrains the system scope. The domain model can be effectively used to verify and validate the understanding of the problem domain among various stakeholders of the project group. It is especially helpful as a communication tool and a focusing point between technical and business teams.

The domain layer

The domain layer is a software concept. It is one of the layers in a typical multilayered architecture for information systems. One of the best and most well-known sources of information about how to use a domain layer can be found in Eric Evans's book about Domain-driven design.

The domain model is a part of the domain layer. It is a software model with classes that represents actual concepts from the reality. These concepts are called Entities and Value objects in the terminology of Domain-driven design (DDD). There are some other DDD concepts that are not part of a domain model, e.g. Services and Repositories, but still part of the domain layer.

The Domain layer is also known as the Business layer.

Glossary of Domain-Driven Design Terms

Excerpted from Domain-Driven Design Book
Aggregate A cluster of associated objects that are treated as a unit for the purpose of data changes. External references are restricted to one member of the AGGREGATE, designated as the root. A set of consistency rules applies within the AGGREGATE'S boundaries.
Analysis Pattern A group of concepts that represents a common construction in business modeling. It may be relevant to only one domain or may span many domains (Fowler 1997, p. 8).
Assertion A statement of the correct state of a program at some point, independent of how it does it. Typically, an ASSERTION specifies the result of an operation or an invariant of a design element.
Bounded Context The delimited applicability of a particular model. BOUNDING CONTEXTS gives team members a clear and shared understanding of what has to be consistent and what can develop independently.
Client A program element that is calling the element under design, using its capabilities.
Cohesion Logical agreement and dependence.
Command (a.k.a. modifier) An operation that effects some change to the system (for example, setting a variable). An operation that intentionally creates a side effect.
Context The setting in which a word or statement appears that determines its meaning. See Bounded Context.
Conceptual Contour An underlying consistency of the domain itself, which, if reflected in a model, can help the design accommodate change more naturally.
Context Map A representation of the Bounded Contexts involved in a project and the actual relationships between them and their models.
Core Domain The distinctive part of the model, central to the user's goals, that differentiates the application and makes it valuable.
Declarative Design A form of programming in which a precise description of properties actually controls the software. An executable specification.
Deep Model An incisive expression of the primary concerns of the domain experts and their most relevant knowledge. A deep model sloughs off superficial aspects of the domain and naive interpretations.
Design Pattern A description of communicating objects and classes that are customized to solve a general design problem in a particular context. (Gamma et al. 1995, p. 3)
Distillation A process of separating the components of a mixture to extract the essence in a form that makes it more valuable and useful. In software design, the abstraction of key aspects in a model, or the partitioning of a larger system to bring the CORE DOMAIN to the fore.
Domain A sphere of knowledge, influence, or activity.
Domain-Driven Design An approach to software development that suggests that (1) For most software projects, the primary focus should be on the domain and domain logic; and (2) Complex domain designs should be based on a model.
Domain Expert A member of a software project whose field is the domain of the application, rather than software development. Not just any user of the software, the domain expert has deep knowledge of the subject.
Domain Layer That portion of the design and implementation responsible for domain logic within a LAYERED ARCHITECTURE. The domain layer is where the software expression of the domain model lives.
Entity An object fundamentally defined not by its attributes, but by a thread of continuity and identity.
Factory A mechanism for encapsulating complex creation logic and abstracting the type of a created object for the sake of a client.
Function An operation that computes and returns a result without observable side effects.
Immutable The property of never changing observable state after creation. implicit concept A concept that is necessary to understand the meaning of a model or design but is never mentioned.
Intention-Revealing Interface A design in which the names of classes, methods, and other elements convey both the original developer's purpose in creating them and their value to a client developer.
Invariant An Assertion about some design element that must be true at all times, except during specifically transient situations such as the middle of the execution of a method, or the middle of an uncommitted database transaction.
Iteration A process in which a program is repeatedly improved in small steps. Also, one of those steps.
Large-Scale Structure A set of high-level concepts, rules, or both that establishes a pattern of design for an entire system. A language that allows the system to be discussed and understood in broad strokes.
Layered Architecture A technique for separating the concerns of a software system, isolating a domain layer, among other things.
Life Cycle A sequence of states an object can take on between creation and deletion, typically with constraints to ensure integrity when changing from one state to another. May include migration of an Entity between systems and different Bounded Contexts.
Model A system of abstractions that describes selected aspects of a domain and can be used to solve problems related to that domain.
Model-Driven Design A design in which some subset of software elements corresponds closely to elements of a model. Also, a process of codeveloping a model and an implementation that stay aligned with each other.
Modeling Paradigm A particular style of carving out concepts in a domain, combined with tools to create software analogs of those concepts (for example, object-oriented programming and logic programming).
Repository A mechanism for encapsulating storage, retrieval, and search behavior which emulates a collection of objects.
Responsibility An obligation to perform a task or know information (Wirfs-Brock et al. 2003, p. 3).
Service An operation offered as an interface that stands alone in the model, with no encapsulated state.
Side Effect Any observable change of state resulting from an operation, whether intentional or not, even a deliberate update.
Side Effect Free Function See Function.
Standalone Class A class that can be understood and tested without reference to any others, except system primitives and basic libraries.
Stateless The property of a design element that allows a client to use any of its operations without regard to the element's history. A stateless element may use information that is accessible globally and may even change that global information (that is, it may have side effects) but holds no private state that affects its behavior.
Strategic Design Modeling and design decisions that apply to large parts of the system. Such decisions affect the entire project and have to be decided at team level.
Supple Design A design that puts the power inherent in a deep model into the hands of a client developer to make clear, flexible expressions that give expected results robustly. Equally important, it leverages that same deep model to make the design itself easy for the implementer to mold and reshape to accommodate new insight.
Ubiquitous Language A language structured around the domain model and used by all team members to connect all the activities of the team with the software.
Unification The internal consistency of a model such that each term is unambiguous and no rules contradict.
Test-Driven Development TDD is a lightweight programming methodology that emphasizes fast, incremental development and especially writing tests before writing code. Ideally these follow one another in cycles measured in minutes. (see full definition under Test-Driven Development topic)
Value Object An object that describes some characteristic or attribute but carries no concept of identity.
Whole Value An object that models a single, complete concept.

WebForms validation

2009-08-10T10:05:00.001-05:00

I am still surprised at how many web forms I come across that do not perform good validation or provide a substandard user experience when doing validation. Clearly the optimal place to do lots of simple form validation should be on the client and probably in real-time as the user fills out the form. Sadly most form field validation implementations do this on the server requiring a postback and the crappy user experience that comes with that. In this day and age, I would hope that all validation could happen on the client. A few Ajax libraries like jQuery provide client side form field validation components and Flex provides for a truly flexible form field validation framework.

ASP.NET provides server side validation controls that perform server side validation and you can use also do Forms Authentication with ASP.NET AJAX. There is also a client side validation implemented using JScript. (see Client-Side Validation)

In ASP.NET, there are six validation controls included. They are:

The RequiredFieldValidation Control
The CompareValidator Control
The RangeValidator Control
The RegularExpressionValidator Control
The CustomValidator Control

All of the validation controls inherit from the base class BaseValidator. The all have the following common properties and methods.

ControlToValidate - This value is which control the validator is applied to.
ErrorMessage - This is the error message that will be displayed in the validation summary.
IsValid - Boolean value for whether or not the control is valid.
Validate - Method to validate the input control and update the IsValid property.
Display - This controls how the error message is shown. Here are the possible options:
- None (The validation message is never displayed.)
- Static (Space for the validation message is allocated in the page layout.)
- Dynamic (Space for the validation message is dynamically added to the page if validation fails.)

Understanding the Difference Between Server-Side and Client-Side Validation

Many people new to ASP.NET don't know the difference between client-side and server-side validation. You must understand these two different ways of validating the data users input into a Web form.

After the user enters data into a Web form, clicks the Submit button, and sends the form data to the server as a request, you can perform server-side validation on the data. If the data is incorrect or not valid, you can send back a response stating this. If, however, when the user clicks the Submit button, a scripting language that is part of the overall HTML page is initiated to check the validity of the data before it is sent to the server, this is client-side validation.

It was a lot easier to understand the difference between these forms of validation when you coded Active Server Pages 3.0 because, as the programmer, you personally performed almost all data validation. You yourself either programmed it to be client-side or server-side.

When you used server-side validation with ASP 3.0, if something the user entered was wrong, you could repost the form and ask the user to correct the information in that particular field of the form. Sometimes, you carried the correct input from the other fields back to the form page, and populated the fields for the users so they didn't have to re-enter the same information again. Some sites on the Internet don't carry this inputted information back to the form page, and the user is then required to enter all the information into the form a second time. Obviously, this may cause people to leave your site for another.

The bad thing about server-side validation is that it requires trips back and forth to the server. This takes a lot of resources and makes for a slower-paced form for the user. Nothing is more annoying to a user who is on a dial-up connection than clicking the Submit button on the form and then waiting for 20 seconds to find out that they didn't enter their password correctly.

The other option for form validation is to put some client-side JavaScript or VBScript at the top of the ASP page that checks if the information in the fields is correct. This takes care of the problem of making unnecessary trips to the server, but it requires another language to learn and manage. JavaScript is a great language, but takes a lot of time to master, and there are always problems getting your JavaScript code to work on different browsers. Listing 1 shows you an example of using client-side JavaScript to perform form validation.

Listing 1: Client-side JavaScript for form validation
<script language="javascript">

</script>
This sample piece of JavaScript does some validation, but it doesn't check for all the in-formation that you might need on the form you are building. This piece of code determines only whether the user entered anything at all in all five fields within the form. It does not determine whether the user entered an actual e-mail address within the e-mail address text box, whether the user entered a number between two given numbers, or whether the password and the confirm password text boxes match. After awhile, you can see that you need many JavaScript functions to obtain the level of form validation required.

.NET to the Rescue!

Developers who used classic Active Server Pages 3.0 to develop Web pages might remember that they used to spend a considerable amount of their time developing validation mechanics in their pages. It was time consuming if you did it right. It was most efficient to do the validation of the form on the client-side to limit the number of requests and responses required to work through an application. As I stated, however, you were never quite sure if the requesting browser would understand the scripting code that you used for the validation. So, it was usually better, especially for critical Web applications, to bring the validation to the server.

ASP.NET has changed this by giving you the capability to use the validation server controls that are provided with the other new controls at your disposal. What makes these validation server controls effective is that when an ASP.NET page containing these controls is requested, it is the ASP.NET engine that decides whether to perform the validation on the client or on the server depending on the browser that is making the request. Therefore, your page's functionality changes depending on the requesting browser—thus enabling you to make your Web pages the best they can possibly be—rather than dummying-down your Web applications for the lowest common denominator.

Validation server controls are the only type of ASP.NET server controls that also generate client-side script. All the other controls work with the idea of making postbacks to the server (a request to the server to get a response).

Presently, six different validation server controls are available for ASP.NET:

RequiredFieldValidator

CompareValidator

RangeValidator

RegularExpressionValidator

CustomValidator

ValidationSummary

You can also customize validation for your own needs. Then, if there are any errors in the form data, these validation server controls enable you to customize the display of error information on the browser.

You place validation server controls on your page as you would any other type of controls. After the user submits the form, the user's form information is sent to the appropriate validation control, where it is evaluated. If the information doesn't validate, the control sets a page property that indicates this. After all the form information is sent to all the validation server controls, if one or more of the validation server controls cannot validate the information sent to it, the entire form input is found to be invalid, and the user is notified.

see Understanding the Difference Between Server-Side and Client-Side Validation

Client-Side Validation

If client-side validation is enabled for your page, a whole different sequence occurs in-between the round trips. Client-side validation works using client JScript®. No binary components are needed to make it work.

While the JScript language is reasonably well standardized, the Document Object Model (DOM) for interacting with HTML documents in browsers did not have a widely adopted standard at the time these components were developed and tested. As a result, client-side validation only takes place in Internet Explorer 4.0 and later, because it targets the Internet Explorer DOM.

From a server point of view, client-side validation just means that the validation controls emit different stuff into the HTML. Other than that, their sequence of events is exactly the same. The server-side checks are still carried out. This may seem redundant, but it is important because of the following:

Some validation controls may not support client scripting. A good example: if you are using a CustomValidator with a server validation function but no client validation function.

Security considerations. Someone can very easily take a page with script and disable or change it. You should not rely on script to stop bad data getting into to your system, only to provide more immediate feedback to your users. For this reason, if you are using a CustomValidator, you should not provide a client validation function without a corresponding server validation function.

Every validation control makes sure that a standard block of client script is emitted into the page. This is actually just a small amount of script that includes a reference to code in a script library called WebUIValidation.js. This file, which is downloaded separately and can be cached by the browser, contains all of logic for client-side validation.

About the Script Library

Because the validation Web controls script that is in a script library, it is not necessary to emit all of the code for client-side validation directly into the page, although it acts as though this is what has happened. The main script file reference looks like this:
<script language="javascript" 
        src="/aspnet_client/system_web/1_0_3617_0/WebUIValidation.js">
</script>
By default, the script file will be installed into your default root in the aspnet_client directory, and it is referenced using a root-relative script include directive, which begins with the forward slash. This reference means that each individual project does not have to include the script library inside it, and all pages on the same machine can reference the same file. You will notice that it also has the common language runtime version number in the path, so that different versions of the runtime can run on the same machine.

If you take a look around your default virtual root, you can find this file and take a look inside it. The location of these files is specified in the machine.config file, an XML file used for most ASP.NET settings. Here is the definition of the location within that file:
        <webControls
            clientScriptsLocation="/aspnet_client/{0}/{1}/"
        />
You are encouraged to read the script to see more of what is going on. However, it is not recommended that you modify these scripts, because their function is very closely tied to a particular version of the run time. If the run time is updated, the scripts may need a corresponding update, and you will have to either lose your changes or face problems with the scripts not working. If you must change the scripts for a particular project, take a copy of the files and point your project to them by overriding the location of the files with a private web.config file.It is perfectly fine to change this location to be a relative or absolute reference.

Disabling Client-Side Validation

There are some cases where you may not want client-side validation. If the number of input fields is very small, client-side validation may not be of much benefit. You may have logic that needs a round trip to the server every time anyway. You may find that the dynamically appearing messages on the client have an adverse affect on your layout.

Note The way to disable client-side validation is to set the EnableClientScript property of the validator or ValidationSummary control to False. It is possible to have a mixture of server-only and client-sever validation components on the same page.

The Client-Side Sequence

This is the sequence of events when a page with client-side validation runs:

As the page is loaded into the browser, there is some initialization done on each validation control. The controls are emitted as <span> tags with HTML attributes that correspond closely to their properties on the server. The most important thing that happens here is that any input elements referenced by the validators are "hooked up." The referenced input elements have their client events modified so that the validation routines are called whenever the input is changed.

Code in the script library will be executed as users tab from field to field. The validation conditions are re-evaluated when a dependent field is changed, and the validator is made visible or invisible as appropriate.

When the user pushes a button that has the CausesValidation property set to True, the validators are all re-evaluated. If they are all valid, then the form is posted to the server. If there are one or more errors, a number of things happen:

The submit is cancelled. The form does not get posted back to the server.

Any invalid validators become visible.

If there is a validation summary with ShowSummary=true, it will collect all the errors from the validation controls and update its contents with them.

If there is a validation summary with ShowMessageBox=true, it will collect the errors and display them in client message box.

Because they are executed whenever the inputs change as well as at submit time, client side validation controls generally evaluate two or more times on client. Remember that they will still be re-evaluated on the server once the submit takes place.

The Client-Side API

There is a mini-API that you can use on the client to achieve various effects with your own client-side code. Because it is not possible to make certain routines hidden, you can theoretically make use of any of the variables, attributes, and functions defined by client-side validation script. However, many of them are implementation details that may be changed.

see Client-Side Validation

Some useful ASP.NET validation links

ASP.NET Validation in Depth

Client-Side Validation

Validating ASP.NET Server Controls

Validation ASP.NET Controls

The RequiredFieldValidator Control

The CompareValidator Control

The RangeValidator Control

The RegularExpressionValidator Control

The CustomValidator Control

The ValidationSummary Control

ASP.NET Validator Controls

Validating User Input in ASP.NET Web Pages

What's New in Validation

Types of Validation for ASP.NET Server Controls

Specifying Validation Groups

Client-Side Validation for ASP.NET Server Controls

Special-Case Validation Results for ASP.NET Server Controls

Validation Error Message Layout for ASP.NET Server Controls

How to: Test Validity Programmatically for ASP.NET Server Controls

How to: Disable Validation for ASP.NET Server Controls

How to: Validate Programmatically for ASP.NET Server Controls

Microsoft Web Platform Installer 2.0 RC

2009-07-28T23:17:00.001-05:00

At long last there is an integrated installation solution for MS web solutions.

The Microsoft Web Platform Installer 2.0 (Web PI) is a free tool that makes it simple to download, install and keep up-to-date with the latest components of the Microsoft Web Platform, including Internet Information Services (IIS), SQL Server Express, .NET Framework and Visual Web Developer. In addition, install popular open source ASP.NET and PHP web apps with the Web PI.

What's Inside?

: Popular Web Apps

Install free popular ASP.NET and PHP web apps such as DotNetNuke and WordPress.

: .NET Framework

Install the latest version of the .NET Framework. This includes everything you need to work with ASP.NET.

: IIS and Extensions

Install the latest version of IIS, including latest IIS Web extensions like IIS Media Services.

: SQL Server

Install the latest version of SQL Server 2008 Express. This includes both the database engine and tools.

: Visual Web Developer

Install the latest version of Visual Web Developer Express, Our full featured free web development tool.

: Extra and Goodies

In addition to everything above, the Web PI also includes the latest community version of PHP for Windows.

Some coverage about it:

From the Scott

Microsoft Web Platform Installer

One of the cool new releases coming out this year is a small download manager - the Microsoft Web Platform Installer - that makes installing and configuring web server and web development stacks really easy. It is a free tool that you can download from the www.microsoft.com/web site (here is the direct link to the installer – choose the 2.0 version). It works with Windows XP, Vista, Windows 7, Windows Server 2003 and Windows Server 2008.

The Web Platform Installer provides an easy way to quickly install and customize all the software you need to develop or deploy web sites and applications on a Windows machine. The tool automatically analyses what your system currently has installed, allows you to easily mark additional components to be added, and then automates installing them all at once when you click the install button (saving you from having to manually install each one yourself).

For example, you can click the “Web Server” section above to customize the individual IIS web server modules installed on the box. This includes both the built-in IIS modules that ship with Windows (like the directory browsing module), as well as additional modules available as separate downloads. Below I’ve selected two additional modules – the Application Request Routing and URL Rewrite modules – to be installed:

The URL Rewrite module is a free Microsoft module that enables you to publish custom URLs from your sites and optimize them for search engine optimization (SEO). You can enforce SEO rules (consistent casing, embedded keywords, etc) and customize how your site looks from an external perspective however you want (the admin tool will even help guide you to write the regular expression rules):

The Application Request Routing is a free Microsoft module that supports forward-proxy style scenarios, and enables dynamic load-balancing of requests across multiple web-server machines (allowing you to scale out, move machines behind DMZ firewall scenarios, and bring machines in and out of a farm for maintenance without disruption).

In addition to URL Rewrite and Application Request Routing, there are dozens of other web server modules you can select that enable WebDAV, Secure FTP, automated deployment, remote database management through the IIS admin tool for hosted scenarios, media server streaming scenarios, and more. You can also install framework additions like ASP.NET MVC, .NET 3.5 SP1, SQL Express and associated SQL administration tools, Visual Web Developer 2008 Express, and more.

Windows Web Application Gallery

The web platform installer also integrates with the new Windows Web Application Gallery now online: www.microsoft.com/web/gallery

This gallery allows you to easily install existing web applications onto your server. The gallery contains a variety of popular .NET open source applications (like DotNetNuke, ScrewTurn Wiki and Umbraco CMS) as well as PHP open source applications (including WordPress and Drupal). You can easily browse and install them using the Web Platform Installer as well (just click the “Web Applications” tab and check the applications you want to install):

;

In addition to downloading the application, the web platform installer will create a new site/application root and configure the appropriate site settings and optionally install the database.

Summary

If you haven’t downloaded the Web Platform Installer yet I’d recommend taking a look at it. I think you’ll find it makes it much easier to configure and get a box up and running, and makes it much easier to find and install the various components of the Windows web server stack, as well as find and install applications to use on top of it. Overtime you’ll see us ship more and more functionality this way.

You can download and start using the Web Platform Installer 2.0 Beta today. We’ll ship the final release of it this summer.

Hope this helps,

Scott

From the other Scott

There's a renewed focus, in my opinion, to make things easier to find around The Big Blue Monster. I'm working with a bunch of folks on a more official version of http://www.smallestdotnet.com and some changes around making the .NET Framework easier to find, as a small example.

Getting a machine up to speed for Web Development is another thing that's kind of a hassle because you need to go get (and know to go get) IIS7, Visual Web Developer 2008 Express Edition, SQL Server 2008 Express Edition and the .NET Framework, yada yada yada.

There's a new site at http://www.microsoft.com/web and a new (beta) of the Microsoft Web Platform Installer (blog announcement). It's basically a super bootstrapper that keeps track of where to get stuff and organizes them as profiles.

If I select "Your Choice" I get a complete list from a catalog of things that can be downloaded. I can auto-select options from a dropdown like "PHP Developer" or "Classic ASP Developer." Cool that those options are there as well as ASP.NET Developer. There's a manifest that it downloads to get the latest versions of each of these.

On the Web Server tab, it'll pick the right IIS modules you'd need to get a site up, but it also shows as options some of the more interesting (and not well publicized) modules like ARR and BitRate Throttling that have been released since IIS7 came out.

If you're running a Web Development shop, it's certainly a quick way to get everything you'd need installed, including the free version of Visual Studio Web Express.

Check it out, and if you have any trouble or find anything interesting, you can report it directly to the team at the Web Platform Installer Forum. If you like it or hate it, let them now. It'd be interesting to see how extensible it can be and if they choose to extend it other developer products.

from Web Platform Installer: Trying to make it easier to setup for web development

From MikeOrmond

Web Platform Installer

I’ve realised that despite all the noise about it, I’ve pretty much managed to ignore the Web Platform Installer (WebPI) to date. Which is a shame because I know it does some pretty cool things, takes a lot of the drudgery out of configuring your machine and, from today, I’m actually convinced that I would use it myself even though I’m pretty comfortable setting up my dev environment on a new box. (when I say a new box I really mean the same box fdisk’d. I like to think of that as new box so my satisfaction levels aren’t dependent on fickle things like capex budgets).

When you visit the download page, you’ll see two versions available. There’s the boring-but-safe released version 1.0 or the racey, throw-caution-to-the-wind 2.0 Beta. I of course went with 2.0 Beta as I’ve nothing-to-lose (and I was installing in a freshly-created, just for this purpose VM).

Enough with the hyphen-fest already!

The Web Platform Installer is a simple, integrated way to download, install and configure the Microsoft web platform (ie IIS, SQL Server Express, .NET Fx, VWD etc) and popular open source web apps. Nifty.

It’ll even install and configure PHP for you if that’s your thing and, of course, PHP runs great on IIS with IIS7’s FastCGI support. This saves you wading through this article or watching these videos that I made explaining how to do this.

When you fire up the WebPI 2.0 Beta you’re presented with 3 vertical tabs. Personally, I found it more intuitive to start on tab “2” and decide which core platform elements I wanted. I opted for all of them. Why not?

Tab 3 lets you choose any application you want to install. There’s a mix of ASP.NET and PHP applications. The Web PI is pretty good at warning you about dependencies but clearly if you’re adding an ASP.NET app you’re going to need to enabled to ASP.NET platform components and the same goes for PHP.

Having tackled tabs 2 & 3, tab 1 lets me choose any other “bits” I want to install. I opted for PHP and the SQL Server driver for PHP (oh yes, just because you’re doing some PHP it doesn’t mean you can’t enjoy the loveliness that is SQL Server) as well as SQL Server Express, the SQL management tools, ASP.NET MVC and the SEO Toolkit Beta.

I set things off and it whirled away for a while with a single reboot early on (there were 23 separate packages downloading, installing and configuring). As it turned out, PHP failed to install due to a signature verification issue and therefore the SQL Server driver wasn’t installed either. I simply re-ran the install and both installed fine.

Now to employ my PHP ninja skills and deploy the page to my IIS root directory \inetpub\wwwroot.

And, amazingly (and I was genuinely quite surprised) it worked first time. I had no config to do – that was all taken care of by the Web PI.

For ASP.NET, either make sure you configure this via the WebPI (Web Platform tab – Web Server – Customize) which saves you messing about in Server Manager afterwards. Or do it through Server Manager in WS2008 (Control Panel – Programs – Turn Windows Features On / Off in Vista / Win7) by configuring the Web Server role.

Finally I checked that Visual Web Developer worked. It did.

And that SQL Server Express worked. It did.

Overall I’m mightily impressed and I wasn’t even installing any apps. If I also wanted WordPress or DotNetNuke or Drupal etc this would save me a huge amount of time. I still have to play with some of the components (in particular the SEO toolkit) but from what I’ve seen I really like the WebPI.

Posted: Friday, June 19, 2009 5:50 PM by MikeOrmond

Deploying ASP.NET Web Services

2009-07-24T12:19:00.001-05:00

Deploying ASP.NET Web services is exactly the same as deploying ASP.NET Applications, Deploying an ASP.NET Web service involves copying the .asmx file and any assemblies used by the XML Web service, but not part of the Microsoft .NET Framework, to the Web server.

For example, suppose you have an ASP.NET Web service named StockServices. To deploy the XML Web service, you create a virtual directory on your Web server and place the ASP.NET Web service .asmx file in that directory. The virtual directory should also be an Internet Information Services (IIS) Web application, although it is not required. A typical deployment would have the following directory structure:

\Inetpub

\Wwwroot

\StockServices

StockServices.asmx

\Bin

Assemblies used by your XML Web service
that are not part of the Microsoft .NET Framework.

Items Published with an ASP.NET Web Service

When you publish an ASP.NET Web service, the following items are deployed to a Web server.

Web application directory
Acts as the root directory for your ASP.NET Web service. All the remaining files are placed within this directory.

This directory should be flagged as an Internet Information Services (IIS) Web application.

<MyXMLWebService>.asmx file
Acts as the base URL for clients calling the XML Web service. The name of the file can be any valid file name.

<MyXMLWebService>.disco file
(Optional) Acts as a discovery mechanism for the XML Web service. The .disco file is not automatically created for an XML Web service. For information on creating a discovery file for your XML Web service, see Enabling Discovery for an XML Web Service. The name of the file can be any valid file name.

Web.config file
(Optional) If you need to override the default configuration settings, you can include a Web.config file. XML Web services use the configuration file to allow customization and extensibility of the system.

For example, you might supply an XML Web service–specific Web.config file if your XML Web service requires authentication, but other Web applications on the system do not.

\Bin directory
Contains the binary files for the XML Web service. If your XML Web service class is not in the same file as the .asmx file, then the assembly containing the class must be in the \Bin directory.

See the documentation at Microsoft. They called them XML Web Services back then.

Deploying ASP.NET Web services is the same as deploying ASP.NET Applications, so check out Thiru Thangarathinam article that covers all the scenarios.

Structure of an ASP.NET Web Application

An ASP.NET application consists of all the Web pages (.aspx and HTML files), handlers, modules, executable code, and other files (such as images and configuration files) that can be invoked from a virtual directory and its subdirectories on a Web server. An ASP.NET application also includes the compiled assembly (if the code-behind feature of .aspx files is used) and typically other assemblies that are used to provide functionality for the application. For example, you might have the business logic of the application encapsulated in a separate assembly. These assemblies are located in the bin directory underneath the virtual directory of the application. To understand how VS .NET simplifies the deployment process, you need to understand the structure of the assembly that provides for this simplification. Assemblies contain four elements:

MSIL (Microsoft Intermediate Language) Code: When you compile your application code, it gets compiled into what is known as an MSIL code. MSIL is the code that the common language runtime can understand.

Meta-data: Contains information about the types, methods and other elements defined in the code

Manifest: Contains name and version information, a list of included files in the assembly, security information and so on

Supporting files and resources

As you can see from the structure, assemblies are so comprehensive and self-describing that VS .NET applications don't need to be registered with registry, as is the practice when you are dealing with COM components. This means that VS .NET applications can be installed by simply copying the required files to the target machine as long as the target machine has the .NET Framework installed. This is called XCOPY Deployment. However, it is also possible to automate the deployment process by making use of the deployment projects that are provided by VS .NET. In the next section, we will see how to deploy a Web application using various deployment options provided by VS .NET.

Deployment Options Supported by .NET

You can deploy an ASP.NET Web application using any one of the following three deployment options.

XCOPY Deployment

Using the Copy Project option in VS .NET

Deployment using VS.NET installer

Also see a dated tutorial from Rick Strahl that covers developing web services.

WCF Web Services Vs ASP.Net Web Services

2009-07-24T09:47:00.001-05:00

First lets agree that WCF Services are better than ASP.Net Web services. Here’s why in a nutshell:

WCF enables .NET Framework applications to exchange messages with other software entities. The messages can be in any format, and conveyed by using any transport protocol.

The long explanation is that:

ASP.NET Web services was developed for building applications that send and receive messages by using the Simple Object Access Protocol (SOAP) over HTTP. The structure of the messages can be defined using an XML Schema, and a tool is provided to facilitate serializing the messages to and from .NET Framework objects. The technology can automatically generate metadata to describe Web services in the Web Services Description Language (WSDL), and a second tool is provided for generating clients for Web services from the WSDL.

WCF is for enabling .NET Framework applications to exchange messages with other software entities. SOAP is used by default, but the messages can be in any format, and conveyed by using any transport protocol. The structure of the messages can be defined using an XML Schema, and there are various options for serializing the messages to and from .NET Framework objects. WCF can automatically generate metadata to describe applications built using the technology in WSDL, and it also provides a tool for generating clients for those applications from the WSDL.

The standards supported by ASP.NET Web services are documented in XML Web Services Created Using ASP.NET. The more extensive list of standards supported by WCF are listed at Web Services Protocols Supported by System-Provided Interoperability Bindings.

The definitive guide is Microsoft’s documentation:

ASP.NET provides .NET Framework class libraries and tools for building Web services, as well as facilities for hosting services within Internet Information Services (IIS). Windows Communication Foundation (WCF) provides .NET Framework class libraries, tools and hosting facilities for enabling software entities to communicate using any protocols, including those used by Web services. Migrating ASP.NET Web Services to WCF allows your applications to take advantage of new features and improvements that are unique to WCF.

WCF has several important advantages relative to ASP.NET Web services. While ASP.NET Web services tools are solely for building Web services, WCF provides tools that can be used when software entities must be made to communicate with one another. This will reduce the number of technologies that developers are required to know in order to accommodate different software communication scenarios, which in turn will reduce the cost of software development resources, as well as the time to complete software development projects.

Even for Web service development projects, WCF supports more Web service protocols than ASP.NET Web services support. These additional protocols provide for more sophisticated solutions involving, amongst other things, reliable sessions and transactions.

WCF supports more protocols for transporting messages than ASP.NET Web services. ASP.NET Web services only support sending messages by using the Hypertext Transfer Protocol (HTTP). WCF supports sending messages by using HTTP, as well as the Transmission Control Protocol (TCP), named pipes, and Microsoft Message Queuing (MSMQ). More important, WCF can be extended to support additional transport protocols. Therefore, software developed using WCF can be adapted to work together with a wider variety of other software, thereby increasing the potential return on the investment.

WCF provides much richer facilities for deploying and managing applications than ASP.NET Web services provides. In addition to a configuration system, which ASP.NET also has, WCF offers a configuration editor, activity tracing from senders to receivers and back through any number of intermediaries, a trace viewer, message logging, a vast number of performance counters, and support for Windows Management Instrumentation.

The MS documentation is pretty comprehensive and covers all the issues that need to be covered about WCF Web Services and ASP.Net Web Services.

Additional information about WCF Web Services Vs ASP.Net Web Services:

A great blog article Posted By: Kalyan Bandarupalli titled WCF vs ASP.NET Web services covers it better.

The development of web service with ASP.NET relies on defining data and relies on the XmlSerializer to transform data to or from a service.

Key issues with XmlSerializer to serialize .NET types to XML

Only Public fields or Properties of .NET types can be translated into XML.
Only the classes which implement IEnumerable interface.
Classes that implement the IDictionary interface, such as Hash table can not be serialized.

The WCF uses the DataContractAttribute and DataMemeberAttribute to translate .NET FW types in to XML.

[DataContract]
public class Item
{
    [DataMember]
    public string ItemID;
    [DataMember]
    public decimal ItemQuantity;
    [DataMember]
    public decimal ItemPrice;

}

The DataContractAttribute can be applied to the class or a strcture. DataMemberAttribute can be applied to field or a property and theses fields or properties can be either public or private.

Important difference between DataContractSerializer and XMLSerializer.

A practical benefit of the design of the DataContractSerializer is better performance over XMLserialization.
XMLSerialization does not indicate the which fields or properties of the type are serialized into XML where as DataCotratSerializer Explicitly shows the which fields or properties are serialized into XML.
The DataContractSerializer can translate the HashTable into XML.

Developing Service

To develop a service using ASP.NET we must add the WebService attribute to the class and WebMethodAttribute to any of the class methods.

Example

[WebService]
public class Service : System.Web.Services.WebService
{
    [WebMethod]
    public string Test(string strMsg)
    {
       return strMsg;
    }
}

To develop a service in WCF we will write the following code

[ServiceContract]
public interface ITest
{
    [OperationContract]
    string ShowMessage(string strMsg);
}
public class Service : ITest
{
    public string ShowMessage(string strMsg)
    {
        return strMsg;
    }
}

The ServiceContractAttribute specifies that a interface defines a WCF service contract, OperationContract Attribute indicates which of the methods of the interface defines the operations of the service contract.

A class that implements the service contract is referred to as a service type in WCF.

Hosting the Service

ASP.NET web services are compiled into a class library assembly and a service file with an extension .asmx will have the code for the service. The service file is copied into the root of the ASP.NET application and Assembly will be copied to the bin directory. The application is accessible using url of the service file.

WCF Service can be hosted within IIS or WindowsActivationService.

Compile the service type into a class library
Copy the service file with an extension .SVC into a virtual directory and assembly into bin sub directory of the virtual directory.
Copy the web.config file into the virtual directory.

Client Development

Clients for the ASP.NET Web services are generated using the command-line tool WSDL.EXE.

WCF uses the ServiceMetadata tool(svcutil.exe) to generate the client for the service.

Message Representation

The Header of the SOAP Message can be customized in ASP.NET Web service.

WCF provides attributes MessageContractAttribute , MessageHeaderAttribute and MessageBodyMemberAttribute to describe the structure of the SOAP Message.

Service Description

Issuing a HTTP GET Request with query WSDL causes ASP.NET to generate WSDL to describe the service. It returns the WSDL as response to the request.

The generated WSDL can be customized by deriving the class of ServiceDescriptionFormatExtension.

Issuing a Request with the query WSDL for the .svc file generates the WSDL. The WSDL that generated by WCF can customized by using ServiceMetadataBehavior class.

Exception Handling

In ASP.NET Web services, Unhandled exceptions are returned to the client as SOAP faults.

In WCF Services, unhandled exceptions are not returned to clients as SOAP faults. A configuration setting is provided to have the unhandled exceptions returned to clients for the purpose of debugging.

Other interesting ASP.NET and WCF web services related articles:

http://jeffblankenburg.com/2009/07/day-7-using-wcf-web-services-with.aspx

Creating RESTful Web Services with Windows Communication Foundation
By Aaron Lerch

WCF web Service - Hosting in IIS 6.0 with Windows Authentication and Web client impersonation

Video: Creating a Web Service with Windows Communication Foundation (WCF)

lab exercises to step you through the ways to create and host services in chapter 1 here: www.thatindigogirl.com

Simple Web Service using WCF By Mark Pryce-Maher

The Simplest C# code to execute a stored procedure or a SQL statement.

2009-07-23T10:33:00.001-05:00

I often need to do a simple select from a database table. The code snippet below shows the simplest code required to execute a stored procedure or a SQL statement in C#.

// 1.  Create your SQL Connection
SqlConnection conn = null; 

// 2.  Create and open a connection object
conn = new SqlConnection("Connection String Goes Here"); 

// 3.  Open the Connection
conn.Open(); 

// 4.  Create the SQL Command and assign it it a string
string strSQLCommand = "SELECT * FROM TABLE"; 

// 5.  Execute the SQL Command
SqlCommand command = new SqlCommand(strSQLCommand, conn); 

// 6.  Use ExecuteScalar() to return the first result
string returnvalue = (string)command.ExecuteScalar(); 

// 7.  Close the Connection
conn.Close(); 

// 8.  Return the Value
return returnvalue;

Used in an actual example:

Code Snippet

private void button1_Click(object sender, EventArgs e)

        {

            // 1.  Create your SQL Connection

            SqlConnection conn = null;

            // 2.  Create and open a connection object

            conn = new SqlConnection(connString);

            // 3.  Open the Connection

            conn.Open();

            // 4.  Create the SQL Command and assign it it a string

            string strSQLCommand = "SELECT UrlToSend FROM DocumentDelivery where GeneratedCode = '" 

                + textBox1.Text + "'";

            // 5.  Execute the SQL Command

            SqlCommand command = new SqlCommand(strSQLCommand, conn);

            // 6.  Use ExecuteScalar() to return the first result

            string returnvalue = (string)command.ExecuteScalar();

            // 7.  Close the Connection

            conn.Close();

            // 8.  Return the Value

            //return returnvalue; 

            label1.Text =  returnvalue; 

        \

The same code used in a web service:

Code Snippet

 [WebMethod]

    public String GetDocumentsUrl(string generatedCode)

    {

        try

        {

            // 1.  Create your SQL Connection

            SqlConnection conn = new SqlConnection(connString); ;

            // 2.  Create and open a connection object

            conn = new SqlConnection(connString);

            // 3.  Open the Connection

            conn.Open();

            // 4.  Create the SQL Command and assign it it a string

            string strSQLCommand = "SELECT UrlToSend FROM DocumentDelivery where GeneratedCode = '"

                + generatedCode + "'";

            // 5.  Execute the SQL Command

            SqlCommand command = new SqlCommand(strSQLCommand, conn);

            // 6.  Use ExecuteScalar() to return the first result

            string returnvalue = (string)command.ExecuteScalar();

            // 7.  Close the Connection

            conn.Close();

            // 8.  Return the Value

            //return returnvalue; 

            return returnvalue; 

        }

        catch (Exception ex)

        {

            return ex.Message;

        }

        finally

        {

            //conn.Close(); should happen here but we are trying to keep it all in the web service

        }

*connection strings information removed from the example ;).

This code snippet was copied from Execute SQL Query from within a C# function, Thanks Eric.

Random string generator web service

2009-07-10T08:44:00.001-05:00

There are times when you want to generate a Random string for maybe passwords or access codes. Below is a simple ASP.NET web service that i wrote for a project. It generates a string of length 10 with first 4 letters lowercase, next 4 letters numbers, and last 2 letters as uppercase. In my case I was using it for generating an access code for a user.

Code Snippet



 /// <summary>
     /// Summary description for random string generator
     /// </summary>
     [WebService(Namespace = "http://tempuri.org/")]
     [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
     [ToolboxItem(false)]
     // To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line. 
     // [System.Web.Script.Services.ScriptService]
     public class Service1 : System.Web.Services.WebService
     {
 
         [WebMethod]
         public string GetAccessCode()
         {
             //return RandomString(5, true);
             return GetMixedRandomNumber();
         }
 
         /// <summary>
         /// Generates a random string with the given length
         /// </summary>
         /// <param name="size">Size of the string</param>
         /// <param name="lowerCase">If true, generate lowercase string</param>
         /// <returns>Random string</returns>
         private string RandomString(int size, bool lowerCase)
         {
             StringBuilder builder = new StringBuilder();
             Random random = new Random();
             char ch;
             for (int i = 0; i < size; i++)
             {
                 ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65)));
                 builder.Append(ch);
             }
             if (lowerCase)
                 return builder.ToString().ToLower();
             return builder.ToString();
         }
 
         /// <summary>
         /// generate a random number between min and max
         /// </summary>
         /// <param name="min"></param>
         /// <param name="max"></param>
         /// <returns></returns>
         private int RandomNumber(int min, int max)
         {
             Random random = new Random();
             return random.Next(min, max);
         }
 
         public string GetMixedRandomNumber()
         {
             StringBuilder builder = new StringBuilder();
             builder.Append(RandomString(4, true));
             builder.Append(RandomNumber(1000, 9999));
             builder.Append(RandomString(2, false));
             return builder.ToString();
         }
 
     \

The code uses the Random class from the .NET Framework class library which provides functionality to generate random numbers.
The Random class constructors have two overloaded forms. It takes either no value or it takes a seed value.
The Random class has three public methods - Next, NextBytes, and NextDouble. The Next method returns a random number, NextBytes returns an array of bytes filled with random numbers, and NextDouble returns a random number between 0.0 and 1.0. The Next method has three overloaded forms and allows you to set the minimum and maximum range of the random number.
The following code returns a random number:

int num = random.Next();

The following code returns a random number less than 100.

int num = random.Next(100);
The following code returns a random number between min and max:

private int RandomNumber(int min, int max)
{
Random random = new Random();
return random.Next(min, max);
}

The web service code:

/// <summary>
    /// Summary description for random string generator
    /// </summary>
    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [ToolboxItem(false)]
    // To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.
    // [System.Web.Script.Services.ScriptService]
    public class Service1 : System.Web.Services.WebService
    {

        [WebMethod]
        public string GetAccessCode()
        {
            //return RandomString(5, true);
            return GetMixedRandomNumber();
        }

        /// <summary>
        /// Generates a random string with the given length
        /// </summary>
        /// <param name="size">Size of the string</param>
        /// <param name="lowerCase">If true, generate lowercase string</param>
        /// <returns>Random string</returns>
        private string RandomString(int size, bool lowerCase)
        {
            StringBuilder builder = new StringBuilder();
            Random random = new Random();
            char ch;
            for (int i = 0; i < size; i++)
            {
                ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65)));
                builder.Append(ch);
            }
            if (lowerCase)
                return builder.ToString().ToLower();
            return builder.ToString();
        }

        /// <summary>
        /// generate a random number between min and max
        /// </summary>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <returns></returns>
        private int RandomNumber(int min, int max)
        {
            Random random = new Random();
            return random.Next(min, max);
        }

        public string GetMixedRandomNumber()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append(RandomString(4, true));
            builder.Append(RandomNumber(1000, 9999));
            builder.Append(RandomString(2, false));
            return builder.ToString();
        }

}

Object-relational mapping (ORM)

2009-07-02T18:00:00.000-05:00

NHibernate 2.0 released August 23, 2008 makes it easier to write modularized .NET applications.

NHibernate is a great framework for doing object-to-relational mapping (ORM).

Some of the beginner issues about NHibernate is that the documentation is lacking. Look to the Java Hibernate project, for examples . Also read Paul Wilson's .NET Blog for great examples and a "Real" NHibernate Example App

As most of you know that follow my blog, I not only have my own WilsonORMapper, but I've also been tinkering with NHibernate some. Why? I needed to use a "free" set of code for my recent presentation on O/R Mapping at the Atlanta Code Camp. Anyhow, here's the long promised link to download my "real" NHibernate example app. What do I mean by calling it "real"? Well to put it bluntly, my experience is that its impossible to find a realistic and decently complex app for NHibernate (or Hibernate). My example app is the exact same one I updated for my WilsonORMapper, except I modified it slightly to support NHibernate. This means that it is first of all a real and fully functioning WinForm app -- complete with data-binding in grids and all your basic CRUD. It also means that this example includes several types of primary keys, relationships, and inheritance -- and did I mention it works!
Sure there is lots of documentation for Hibernate (and thus for NHibernate too), including books, but the examples are either typically small snippets, and many are outdated and just don't work with NHibernate v0.8. Some people have criticized the small amount of documentation I have for my WilsonORMapper, and rightly so, but I've always included a real example app that goes a long way in getting people started -- and without this I found it quite difficult to get up to speed on NHibernate since I was forced to dig into scattered documents, forums, and just plain old-fashioned trial-and-error in many cases! Here's an example -- NHibernate has multiple ways to model related collections (sets, bags, lists, and maps), which certainly is an advantage if you need flexibility, but just try to figure out which one to use for a many-to-many related collection that you want to be bindable -- the answer is use the bag.
Anyhow, what's intriguing to me is how close both the basic approach and the mapping file syntax is for my WilsonORMapper andNHibernate -- they are remarkably similar and there's very little effort to switch between them. Of course there are certainly differences too -- NHibernate is more flexible if you need that (most don't), while my WilsonORMapper is a little easier (far simpler codebase), supports more databases (including Access), and provides DAL capabilities as well as O/R Mapping. Both mappers have features the other lacks -- but they both have the basic set of features that most people need -- and both work as my example apps demonstrate. What are some other features my WilsonORMapper has? Supports stored procedures, custom collection types, real batch updates/deletes, server-side paging, lazy-loading without keeping "session" open, interface to avoid reflection, null values even in .NET v1.1, and I'm sure there are others I could list.
What about NHibernate you ask? I can't do it much justice to be fair since I'm not that experienced with it, but a few come to mind: more caching options, normalized inheritance, built-in one-to-one, two-way graph syncs, more cascade options, eager load option -- and again there are bound to be more. But the basics are pretty similar (although I prefer my WilsonORMapper of course) -- so if you're anNHibernate fan, then please download and enjoy my "real" NHiberate example app -- and feel free to add your own comments here on either mapper (or others), although please include some real details if you do.

NHibernate is a port of Hibernate Core for Java to the .NET Framework. It handles persisting plain .NET objects to and from an underlying relational database. Given an XML description of your entities and relationships, NHibernate automatically generates SQL for loading and storing the objects. Optionally, you can describe your mapping metadata with attributes in your source code.

NHibernate supports transparent persistence, your object classes don't have to follow a restrictive programming model. Persistent classes do not need to implement any interface or inherit from a special base class. This makes it possible to design the business logic using plain .NET (CLR) objects and object-oriented idiom.

NHibernate is an Object-relational mapping (ORM) solution for the Microsoft .NET platform: it provides a framework for mapping an object-oriented domain model to a traditional relational database. Its purpose is to relieve the developer from a significant portion of relational datapersistence-related programming tasks.

NHibernate is free as open source software that is distributed under the GNU Lesser General Public License.

NHibernate is a port of the popular Java O/R mapper Hibernate to .NET. Version 1.0 mirrored the feature set of Hibernate 2.1, as well as a number of features from Hibernate 3.

NHibernate 1.2.1, released in November 2007, introduced many more features from Hibernate 3 and support for .NET 2.0, stored procedures, generics, and nullable types.

NHibernate 2.0 was released August 23, 2008. It is comparable to Hibernate 3.2 in terms of features. With the version 2.0 release, NHibernate dropped support for .NET 1.1.

NHibernate key features:

Natural programming model - NHibernate supports natural OO idiom; inheritance, polymorphism, composition and the .NET collections framework, including generic collections.

Native .NET - NHibernate API uses .NET conventions and idioms

Support for fine-grained object models - a rich variety of mappings for collections and dependent objects

No build-time bytecode enhancement - there's no extra code generation or bytecode processing steps in your build procedure

The query options - NHibernate addresses both sides of the problem; not only how to get objects into the database, but also how to get them out again

Custom SQL - specify the exact SQL that NHibernate should use to persist your objects. Stored procedures are supported on Microsoft SQL Server.

Support for "conversations" - NHibernate supports long-lived persistence contexts, detach/reattach of objects, and takes care of optimistic locking automatically

Free/open source - NHibernate is licensed under the LGPL (Lesser GNU Public License)

Internet Information Services

2009-06-26T11:16:00.001-05:00

What would you like to know about IIS? Below is everything i found about IIS on the web. IIS still serves over a third of all the websites on the web according to Netcraft.

Internet Information Services (IIS) - formerly called Internet Information Server - is a set of Internet-based services for servers created by Microsoft for use with Microsoft Windows. It is the world's second most popular web server in terms of overall websites behind the industry leader Apache HTTP Server. As of June 2008 it served 35.39% of all websites according to Netcraft.^[1] The servers currently include FTP, SMTP, NNTP, and HTTP/HTTPS.

Versions

IIS 1.0, Windows NT 3.51 available as a free add-on
IIS 2.0, Windows NT 4.0
IIS 3.0, Windows NT 4.0 Service Pack 3
IIS 4.0, Windows NT 4.0 Option Pack
IIS 5.0, Windows 2000
IIS 5.1, Windows XP Professional,Windows MCE
IIS 6.0, Windows Server 2003 and Windows XP Professional x64 Edition
IIS 7.0, Windows Server 2008 and Windows Vista and Windows 7 (Pre-beta)

History

The first Microsoft webserver was a research project by the European Microsoft Windows NT Academic Centre (EMWAC), part of the University of Edinburgh in Scotland, and was distributed as freeware.^[2] However since the EMWAC server was unable to scale sufficiently to handle the volume of traffic going to microsoft.com, Microsoft was forced to develop its own webserver, IIS.^[3]

IIS was initially released as an additional set of Internet based services for Windows NT 3.51. IIS 2.0 followed, adding support for the Windows NT 4.0 operating system; and IIS 3.0 introduced the Active Server Pages dynamic scripting environment.^[4]

IIS 4.0 dropped support for the Gopher protocol and was bundled with Windows NT as a separate "Option Pack" CD-ROM.^{[citation needed]}

The current shipping version of IIS is 7.0 for Windows Vista and Windows Server 2008, 6.0 for Windows Server 2003 and Windows XP Professional x64 Edition, and IIS 5.1 for Windows XP Professional. Windows XP has a restricted version of IIS 5.1 that supports only 10 simultaneous connections and a single web site.^[5] IIS 6.0 added support for IPv6. A FastCGI module is also available for IIS5.1, IIS6^[6] and IIS7.^[7]

IIS 7.0 is not installed by Windows Vista by default but it can be selected from the list of optional components. It is available in all editions of Windows Vista save Home Basic and Starter. IIS 7 on Vista does not limit the number of allowed connections as IIS on XP did but limits concurrent requests to 10 (Windows Vista Ultimate, Business, and Enterprise Editions) or 3 (Vista Home Premium). Additional requests are queued which hampers performance but they are not rejected as with XP which resulted in the 'server too busy' error message. ^[8]

Security

Earlier versions of IIS were hit with a number of vulnerabilities, chief among them CA-2001-19 which led to the infamous Code Red worm; however, both versions 6.0 and 7.0 currently have no reported issues that affect them.^{[citation needed]} In IIS 6.0 Microsoft opted to change the behaviour of pre-installed ISAPI handlers,^[9] many of which were culprits in the vulnerabilities of 4.0 and 5.0, thus reducing the attack surface of IIS. In addition, IIS 6.0 added a feature called "Web Service Extensions" that prevents IIS from launching any program without explicit permission by an administrator. With the current release IIS 7.0 the components are modularised so that only the required components have to be installed, thus further reducing the attack surface. In addition, security features are added such as URLFiltering which rejects suspicious URLs based on a user-defined rule set.

By default IIS 5.1 and lower run websites in-process under the SYSTEM account,^[10] a default Windows account with 'superuser' rights. Under 6.0 all request handling processes have been brought under a Network Services account with significantly fewer privileges so that should there be an vulnerability in a feature or custom code it won't necessarily compromise the entire system given the sandboxed environment these worker processes run in. IIS 6.0 also contained a new kernel HTTP stack (http.sys) with a stricter HTTP request parser and response cache for both static and dynamic content.

Authentication Mechanisms

IIS 5.0 and higher support the following authentication mechanisms:

Version 7.0

Debuting with Windows Vista, and included in Windows Server 2008, IIS 7.0 features a modular architecture. Instead of a monolithic server which features all services, IIS 7 has a core web server engine. Modules offering specific functionality can be added to the engine to enable its features. The advantage of having this architecture is that only the features required can be enabled and that the functionalities can be extended by using custom modules.

IIS 7 will ship with a handful of modules, but Microsoft will make other modules available online.^[11] The following sets of modules are slated to ship with the server:

HTTP Modules
Security Modules
Content Modules
Compression Modules
Caching Modules
Logging and Diagnostics Modules

Writing extensions to IIS 7 using ISAPI has been deprecated in favor of the module API, which allows modules to be plugged in anywhere within the request processing pipeline. Much of IIS's own functionality is built on this API, and as such, developers will have much more control over a request process than was possible in prior versions. Modules can be written using C++, or using the IHttpModule interface from a .NET Framework language. Modules can be loaded globally where the services provided by the module can effect all sites, or loaded on a per-site basis. IIS 7 has an integrated mode application pool where .NET modules are loaded into the pipeline using the module API, rather than ISAPI. As a result ASP.NET code can be used with all requests to the server.^[12] For applications requiring strict IIS 6.0 compatibility, the Classic application pool mode loads asp.NET as an ISAPI.

A significant change from previous versions of IIS is that all Web server configuration information is stored solely in XML configuration files, instead of in the metabase. The server has a global configuration file that provides defaults, and each virtual web's document root (and any subdirectory thereof) may contain a web.config containing settings that augment or override the defaults. Changes to these files take effect immediately. This marks a significant departure from previous versions whereby web interfaces, or machine administrator access, were required to change simple settings such as default document, active modules and security/authentication. It also eliminates the need to perform metabase synchronization between multiple servers in a farm of web servers.

IIS 7 also features a completely rewritten administration interface that takes advantage of modern MMC features such as task panes and asynchronous operation. Configuration of ASP.NET is more fully integrated into the administrative interface.

Other changes:

PICS content ratings, support for Microsoft Passport, and server-side image maps are no longer included.
Executing commands via server-side includes is no longer permitted.
IISRESET -reboot has been removed.
The CONVLOG tool, which converts IIS log files into NCSA format, has been removed.
Support for enabling a folder for "Web Sharing" via the Windows Explorer interface has been removed.
IIS Media Pack (see below), which allows IIS to be used as a bare-bones media server, without using Windows Media Services.^[13]
New FTP module, that integrates with the new configuration store, as well as the new management environment.^[14]

IIS Media Pack

The IIS Media Pack^[15] is a set of free add-on modules for delivering digital audio and video files from an Internet Information Services 7.0 (IIS7) Web server. Download delivery from a Web server to media player software is often as a progressive download, which allows the end user's media player to quickly start rendering the media file even as the download is still in progress. Examples of media player software that will work with the IIS Media Pack include Adobe Flash Player, Apple QuickTime Player, RealNetworks RealPlayer, Microsoft Windows Media Player, and Microsoft Silverlight. The IIS Media Pack provides some of the cost savings and content control benefits of streaming media servers to Web server delivery of media files.

The first module, Bit Rate Throttling, was released to the general public on March 14, 2008^[16]. For media files, Bit Rate Throttling downloads the first few seconds of the file as fast as possible, allowing playback to begin very quickly, and then automatically detects the encoded bit rate of the file and meters out the rest of the download at that bit rate. If an end user stops playback before the end of the file, the server has only downloaded a few more seconds of file than were actually consumed, reducing bandwidth costs when compared to traditional send-and-forget HTTP downloads. Metering the delivery of media files also reduces overall bandwidth and CPU usage on the IIS server, freeing resources to serve a higher number of concurrent users. The following eleven media file formats are supported by default in the Bit Rate Throttling module: ASF, AVI, FLV, M4V, MOV, MP3, MP4, RM, RMVB, WMA, WMV. Additional media file formats can be added using the IIS configuration system. Non-media files may also be throttled at a server-administrator-specified delivery rate.

The second module is called Web Playlists, and is now in its second Customer Technology Preview (CTP) release^[17]. This feature allows an IIS server administrator to specify a sequenced playback order for a set of media files without exposing the source URLs. Playback order and the ability to limit whether an end user can seek within or skip a file are controlled on the IIS server. The Web Playlists feature can also be used to dynamically generate personalized playlists for users.

Internet Information Services (IIS) 7.0 provides a new request-processing architecture that includes:

A new service, Windows Process Activation Service (WAS), which enables sites to use protocols other than HTTP and HTTPS
A Web server engine that can be customized by adding or removing modules
A new approach to processing requests, integrating the request-processing pipelines from IIS and ASP.NET

This article describes the components, modules and request-processing architecture in the following sections:

IIS 7.0 Components

IIS 7.0 contains several components that perform important functions for the application and Web server roles in Windows Server® 2008. Each component has responsibilities, such as listening for requests made to the server, managing processes, and reading configuration files. These components include protocol listeners, such as HTTP.sys, and services, such as World Wide Web Publishing Service (WWW service) and Windows Process Activation Service (WAS).

Protocol Listeners

Protocol listeners receive protocol-specific requests, send them to IIS for processing, and then return responses to requestors. For example, when a client browser requests a Web page from the Internet, the HTTP listener, HTTP.sys, picks up the request and sends it to IIS for processing. Once IIS processes the request, HTTP.sys returns a response to the client browser.

By default, IIS 7.0 provides HTTP.sys as the protocol listener that listens for HTTP and HTTPS requests. HTTP.sys was introduced in IIS 6.0 as an HTTP-specific protocol listener for HTTP requests. HTTP.sys remains the HTTP listener in IIS 7.0, but includes support for Secure Sockets Layer (SSL).

To support services and applications that use protocols other than HTTP and HTTPS, you can use technologies such as Windows Communication Foundation (WCF). WCF has listener adapters that provide the functionality of both a protocol listener and a listener adapter. Listener adapters are covered later in this document. For more information about WCF, see Windows Communication Foundation on MSDN.

Hypertext Transfer Protocol Stack (HTTP.sys)

The HTTP listener is part of the networking subsystem of Windows operating systems, and it is implemented as a kernel-mode device driver called the HTTP protocol stack (HTTP.sys). HTTP.sys listens for HTTP requests from the network, passes the requests onto IIS for processing, and then returns processed responses to client browsers.

In IIS 6.0, HTTP.sys replaced Windows Sockets API (Winsock), which was a user-mode component used by previous versions of IIS to receive HTTP requests and send HTTP responses. IIS 7.0 continues to rely on HTTP.sys for HTTP requests.

HTTP.sys provides the following benefits:

Kernel-mode caching. Requests for cached responses are served without switching to user mode.
Kernel-mode request queuing. Requests cause less overhead in context switching because the kernel forwards requests directly to the correct worker process. If no worker process is available to accept a request, the kernel-mode request queue holds the request until a worker process picks it up.
Request pre-processing and security filtering.

World Wide Web Publishing Service (WWW service)

In IIS 7.0, functionality that was previously handled by the World Wide Web Publishing Service (WWW Service) alone is now split between two services: WWW Service and a new service, Windows Process Activation Service (WAS). These two services run as LocalSystem in the same Svchost.exe process, and share the same binaries.

Note You may also see the WWW Service referred to as W3SVC in documentation.

How WWW Service works in IIS 6.0

In IIS 6.0, WWW Service manages the following main areas in IIS:

HTTP administration and configuration
Process management
Performance monitoring

HTTP Administration and Configuration

WWW Service reads configuration information from the IIS metabase and uses that information to configure and update the HTTP listener, HTTP.sys. In addition, WWW service starts, stops monitors, and manages worker processes that process HTTP requests.

Performance Monitoring

WWW Service monitors performance and provides performance counters for Web sites and for the IIS cache.

Process Management

WWW Service manages application pools and worker processes, such as starting, stopping, and recycling worker processes. Additionally, WWW Service monitors health of the worker processes, and invokes rapid fail detection to stop new processes from starting when several worker processes fail in a configurable amount of time.

How WWW Service works in IIS 7.0

In IIS 7.0, WWW service no longer manages worker processes. Instead, WWW Service is the listener adapter for the HTTP listener, HTTP.sys. As the listener adapter, WWW Service is primarily responsible for configuring HTTP.sys, updating HTTP.sys when configuration changes, and notifying WAS when a request enters the request queue.

Additionally, WWW Service continues to collect the counters for Web sites. Because performance counters remain part of the WWW Service, they are HTTP specific and do not apply to WAS.

Windows Process Activation Service (WAS)

In IIS 7.0, Windows Process Activation Service (WAS) manages application pool configuration and worker processes instead of WWW Service. This enables you to use the same configuration and process model for HTTP and non-HTTP sites.

Additionally, you can run WAS without WWW Service if you do not need HTTP functionality. For example, you can manage a Web service through a WCF listener adapter, such as NetTcpActivator, without running the WWW Service if you do not need to listen for HTTP requests in HTTP.sys. For information about WCF listener adapters and hosting WCF applications in IIS 7.0 by using WAS, see Hosting in WCF on MSDN.

Configuration Management in WAS

On startup, WAS reads certain information from the ApplicationHost.config file, and passes that information to listener adapters on the server. Listener adapters are components that establish communication between WAS and protocol listeners, such as HTTP.sys. Once listener adapters receive configuration information, they configure their related protocol listeners and prepare the listeners to listen for requests.

In the case of WCF, a listener adapter includes the functionality of a protocol listener. So, a WCF listener adapter, such as NetTcpActivator, is configured based on information from WAS. Once NetTcpActivator is configured, it listens for requests that use the net.tcp protocol. For more information about WCF listener adapters, see WAS Activation Architecture on MSDN.

The following list describes the type of information that WAS reads from configuration:

Global configuration information
Protocol configuration information for both HTTP and non-HTTP protocols
Application pool configuration, such as the process account information
Site configuration, such as bindings and applications
Application configuration, such as the enabled protocols and the application pools to which the applications belong

If ApplicationHost.config changes, WAS receives a notification and updates the listener adapters with the new information.

Process Management

WAS manages application pools and worker processes for both HTTP and non-HTTP requests. When a protocol listener picks up a client request, WAS determines if a worker process is running or not. If an application pool already has a worker process servicing requests, the listener adapter passes the request onto the worker process for processing. If there is no worker process in the application pool, WAS will start a worker process so that the listener adapter can pass the request to it for processing.

Note: Because WAS manages processes for both HTTP and non-HTTP protocols, you can run applications with different protocols in the same application pool. For example, you can develop an application, such as an XML service, and host it over both HTTP and net.tcp.

IIS 7.0 Modules

IIS 7.0 provides a new architecture that is different from previous versions of IIS. Instead of keeping the majority of functionality within the server itself, IIS 7.0 includes a Web server engine in which you can add or remove components, called modules, depending on your needs.

Modules are individual features that the server uses to process requests. For example, IIS uses authentication modules to authenticate client credentials, and cache modules to manage cache activity.

The new architecture provides the following advantages over previous versions of IIS:

You can control which modules you want on the server.
You can customize a server to a specific role in your environment.
You can use custom modules to replace existing modules or introduce new features.

The IIS 7.0 architecture also improves security and eases administration. By removing unnecessary modules, you reduce the server's attack surface and memory footprint, which is the amount of memory that server worker processes use on the machine. You also eliminate the need to manage features that are unnecessary for your sites and applications.

Native Modules

The following sections describe the native modules that are available with a full installation of IIS 7.0. You can remove them or replace them with custom modules, depending on your needs.

HTTP Modules

Several modules in IIS 7.0 perform tasks specific to Hypertext Transfer Protocol (HTTP) in the request-processing pipeline. HTTP modules include modules to respond to information and inquiries sent in client headers, to return HTTP errors, to redirect requests, and more.

Module Name	Description	Resource
CustomErrorModule	Sends default and configured HTTP error messages when an error status code is set on a response.	Inetsrv\Custerr.dll
HttpRedirectionModule	Supports configurable redirection for HTTP requests.	Inetsrv\Redirect.dll
ProtocolSupportModule	Performs protocol-related actions, such as setting response headers and redirecting headers based on configuration.	Inetsrv\Protsup.dll

Security Modules

Several modules in IIS 7.0 perform tasks related to security in the request-processing pipeline. In addition, there are separate modules for each of the authentication schemes, which enable you to select modules for the types of authentication you want on your server. There are also modules that perform URL authorization, and a module that filters requests.

Module Name	Description	Resource
AnonymousAuthenticationModule	Performs Anonymous authentication when no other authentication method succeeds.	Inetsrv\Authanon.dll
BasicAuthenticationModule	Performs Basic authentication.	Inetsrv\Authbas.dll
CertificateMappingAuthenticationModule	Performs Certificate Mapping authentication using Active Directory.	Inetsrv\Authcert.dll
DigestAuthenticationModule	Performs Digest authentication.	Inetsrv\Authmd5.dll
IISCertificateMappingAuthenticationModule	Performs Certificate Mapping authentication using IIS certificate configuration.	Inetsrv\Authmap.dll
RequestFilteringModule	Performs URLScan tasks such as configuring allowed verbs and file extensions, setting limits, and scanning for bad character sequences.	Inetsrv\Modrqflt.dll
UrlAuthorizationModule	Performs URL authorization.	Inetsrv\Urlauthz.dll
WindowsAuthenticationModule	Performs NTLM integrated authentication.	Inetsrv\Authsspi.dll
IpRestrictionModule	Restricts IPv4 addresses listed in the ipSecurity list in configuration.	Inetsrv\iprestr.dll

Content Modules

Several modules in IIS 7.0 perform tasks related to content in the request-processing pipeline. Content modules include modules to process requests for static files, to return a default page when a client doesn't specify a resource in a request, to list the contents of a directory, and more.

Module Name	Description	Resource
CgiModule	Executes Common Gateway Interface (CGI) processes to build response output.	Inetsrv\Cgi.dll
DefaultDocumentModule	Attempts to return a default document for requests made to the parent directory.	Inetsrv\Defdoc.dll
DirectoryListingModule	Lists the contents of a directory.	Inetsrv\dirlist.dll
IsapiModule	Hosts ISAPI extension DLLs.	Inetsrv\Isapi.dll
IsapiFilterModule	Supports ISAPI filter DLLs.	Inetsrv\Filter.dll
ServerSideIncludeModule	Processes server-side includes code.	Inetsrv\Iis_ssi.dll
StaticFileModule	Serves static files.	Inetsrv\Static.dll
FastCgiModule	Supports FastCGI, which provides a high-performance alternative to CGI.	Inetsrv\iisfcgi.dll

Compression Modules

Two modules in IIS 7.0 perform compression in the request-processing pipeline.

Module Name	Description	Resource
DynamicCompressionModule	Compresses responses and applies Gzip compression transfer coding to responses.	Inetsrv\Compdyn.dll
StaticCompressionModule	Performs pre-compression of static content.	Inetsrv\Compstat.dll

Caching Modules

Several modules in IIS 7.0 perform tasks related to caching in the request-processing pipeline. Caching improves performance of your Web sites and Web applications by storing processed information, such as Web pages, in memory on the server, and then reusing that information in subsequent requests for the same resource.

Module Name	Description	Resource
FileCacheModule	Provides user mode caching for files and file handles.	Inetsrv\Cachfile.dll
HTTPCacheModule	Provides kernel mode and user mode caching in HTTP.sys.	Inetsrv\Cachhttp.dll
TokenCacheModule	Provides user mode caching of user name and token pairs for modules that produce Windows user principals.	Inetsrv\Cachtokn.dll
UriCacheModule	Provides user mode caching of URL information.	Inetsrv\Cachuri.dll

Logging and Diagnostics Modules

Several modules in IIS 7.0 perform tasks related to logging and diagnostics in the request-processing pipeline. The logging modules support loading of custom modules and passing information to HTTP.sys. The diagnostics modules follow and report events during request processing.

Module Name	Description	Resource
CustomLoggingModule	Loads custom logging modules.	Inetsrv\Logcust.dll
FailedRequestsTracingModule	Supports the Failed Request Tracing feature.	Inetsrv\Iisfreb.dll
HttpLoggingModule	Passes information and processing status to HTTP.sys for logging.	Inetsrv\Loghttp.dll
RequestMonitorModule	Tracks requests currently executing in worker processes and reports information with Runtime Status and Control Application Programming Interface (RSCA).	Inetsrv\Iisreqs.dll
TracingModule	Reports events to Microsoft Event Tracing for Windows (ETW).	Inetsrv\Iisetw.dll

Managed Support Modules

A couple of modules in IIS 7.0 support managed integration in the IIS request-processing pipeline.

Module Name	Description	Resource
ManagedEngine	Provides integration of managed code modules in the IIS request-processing pipeline.	Microsoft.NET\Framework\v2.0.50727\webengine.dll
ConfigurationValidationModule	Validates configuration issues, such as when an application is running in Integrated mode but has handlers or modules declared in the system.web section.	Inetsrv\validcfg.dll

Managed Modules

In addition to native modules, IIS 7.0 enables you to use managed code modules to extend IIS functionality. Some of the managed modules, such as UrlAuthorization, have a native module counterpart that provides a native alternative to the managed module.

Note Managed modules depend on the ManagedEngine module.

The following table lists the managed modules that are available with a full installation of IIS 7.0.For more information about the managed modules, see the .NET Framework SDK 2.0 on MSDN.

Module Name	Description	Resource
AnonymousIdentification	Manages anonymous identifiers, which are used by features that support anonymous identification such as ASP.NET profile.	System.Web.Security.AnonymousIdentificationModule
DefaultAuthentication	Ensures that an authentication object is present in the context.	System.Web.Security.DefaultAuthenticationModule
FileAuthorization	Verifies that a user has permission to access the requested file.	System.Web.Security.FileAuthorizationModule
FormsAuthentication	Supports authentication by using Forms authentication.	System.Web.Security.FormsAuthenticationModule
OutputCache	Supports output caching.	System.Web.Caching.OutputCacheModule
Profile	Manages user profiles by using ASP.NET profile, which stores and retrieves user settings in a data source such as a database.	System.Web.Profile.ProfileModule
RoleManager	Manages a RolePrincipal instance for the current user.	System.Web.Security.RoleManagerModule
Session	Supports maintaining session state, which enables storage of data specific to a single client within an application on the server.	System.Web.SessionState.SessionStateModule
UrlAuthorization	Determines whether the current user is permitted access to the requested URL, based on the user name or the list of roles that a user is a member of.	System.Web.Security.UrlAuthorizationModule
UrlMappingsModule	Supports mapping a real URL to a more user-friendly URL.	System.Web.UrlMappingsModule
WindowsAuthentication	Sets the identity of the user for an ASP.NET application when Windows authentication is enabled.	System.Web.Security.WindowsAuthenticationModule

IIS 7.0 Request Processing

In IIS 7.0, the IIS and ASP.NET request pipelines combine to process requests with an integrated approach. The new request-processing architecture consists of an ordered list of native and managed modules that perform specific tasks in response to requests.

This design provides several benefits over previous versions of IIS. First, all file types can use features that were originally available only to managed code. For example, you can now use ASP.NET Forms authentication and Uniform Resource Locator (URL) authorization for static files, Active Server Pages (ASP) files, and all other file types in your sites and applications.

Second, this design eliminates the duplication of several features in IIS and ASP.NET. For example, when a client requests a managed file, the server calls the appropriate authentication module in the integrated pipeline to authenticate the client. In previous versions of IIS, this same request would go through an authentication process in both the IIS pipeline and in the ASP.NET pipeline.

Third, you can manage all of the modules in one location, instead of managing some features in IIS and some in the ASP.NET configuration. This simplifies the administration of sites and applications on the server.

IIS 7.0 Application Pools

Application pools separate applications by process boundaries to prevent an application from affecting another application on the server. In IIS 7.0, application pools continue to use IIS 6.0 worker process isolation mode. In addition, you can now specify a setting that determines how to process requests that involve managed resources: Integrated mode or Classic mode.

Note: In IIS 6.0, worker process isolation mode and IIS 5.0 isolation mode are set at the server level. This makes it impossible to run both isolation modes on the same server. However, in IIS 7.0, Integrated mode and Classic mode are set at the application pool level, which enables you to run applications simultaneously in application pools with different process modes on the same server.

Integrated application pool mode

When an application pool is in Integrated mode, you can take advantage of the integrated request-processing architecture of IIS and ASP.NET. When a worker process in an application pool receives a request, the request passes through an ordered list of events. Each event calls the necessary native and managed modules to process portions of the request and to generate the response.

There are several benefits to running application pools in Integrated mode. First the request-processing models of IIS and ASP.NET are integrated into a unified process model. This model eliminates steps that were previously duplicated in IIS and ASP.NET, such as authentication. Additionally, Integrated mode enables the availability of managed features to all content types.

Classic application pool mode

When an application pool is in Classic mode, IIS 7.0 handles requests as in IIS 6.0 worker process isolation mode. ASP.NET requests first go through native processing steps in IIS and are then routed to Aspnet_isapi.dll for processing of managed code in the managed runtime. Finally, the request is routed back through IIS to send the response.

This separation of the IIS and ASP.NET request-processing models results in duplication of some processing steps, such as authentication and authorization. Additionally, managed code features, such as forms authentication, are only available to ASP.NET applications or applications for which you have script mapped all requests to be handled by aspnet_isapi.dll.

Be sure to test your existing applications for compatibility in Integrated mode before upgrading a production environment to IIS 7.0 and assigning applications to application pools in Integrated mode. You should only add an application to an application pool in Classic mode if the application fails to work in Integrated mode. For example, your application might rely on an authentication token passed from IIS to the managed runtime, and, due to the new architecture in IIS 7.0, the process breaks your application.

HTTP Request Processing in IIS 7.0

IIS 7.0 has a similar HTTP request-processing flow as IIS 6.0. The diagrams in this section provide an overview of an HTTP request in process.

The following list describes the request-processing flow that is shown in figure 1:

When a client browser initiates an HTTP request for a resource on the Web server, HTTP.sys intercepts the request.
HTTP.sys contacts WAS to obtain information from the configuration store.
WAS requests configuration information from the configuration store, applicationHost.config.
WWW Service receives configuration information, such as application pool and site configuration.
WWW Service uses the configuration information to configure HTTP.sys.
WAS starts a worker process for the application pool to which the request was made.
The worker process processes the request and returns a response to HTTP.sys.
The client receives a response.

Figure 1: Overview of an HTTP Request

In a worker process, an HTTP request passes through several ordered steps, called events, in the Web Server Core. At each event, a native module processes part of the request, such as authenticating the user or adding information to the event log. If a request requires a managed module, the native ManagedEngine module creates an AppDomain, where the managed module can perform the necessary processing, such as authenticating a user with Forms authentication. When the request passes through all of the events in the Web Server Core, the response is returned to HTTP.sys. Figure 2, below, shows an HTTP request entering the worker process.

Figure 2: Detail of a HTTP request inside the Worker Process

Data modeling process and steps

2009-06-24T11:57:00.002-05:00

Most applications need a data model to be developed or improved. There are lots of websites that cover data modeling in detail but i typically use the below steps to create a data model. The steps can be carried out iteratively or in sequence. Often times the process is an iterative process that never really ends.

The most important thing is to get a good conceptual model together. This often includes a couple of simplified business data and work flow diagrams. This are useful for talking about the business or need with your teams.

Business data and work flow diagrams.
Conceptual data model
Data requirements
Data definitions
Business concepts
Entity classes and attributes
Relationships (associations )
Logical Data Model
Physical Data Model (create objects in the database)

Below are some possible steps often involved in data modeling. The should be performed in an iterative manner.

Identify entity types
Identify attributes
Apply naming conventions
Identify relationships
Apply any required data model patterns
Assign keys
Normalize to reduce data redundancy
Denormalize to improve performance

Data modeling is the process of creating and extending data models which are visual representations of data and its organization. The ERD Diagram (Entity Relationship Diagram) is the most popular type of data model. Data models typically exist as Conceptual, Logical and Physical Data models.

Actual implementation of the conceptual model is called a logical data model. To implement one conceptual data model may require multiple logical data models. Data modeling defines the relationships between data elements and structures. Data modeling techniques are used to model data in a standard, consistent, predictable manner in order to manage it as a resource. The use of this standard is strongly recommended for all projects requiring a standard means of defining and analyzing the data resources within an organization.

Data modeling may be performed during various types of projects and in multiple phases of projects. Data models are usually progressive and there should be is no such thing as the final data model for a business or application. A data model should be considered a living document that will change in response to business needs and situations. The data models should ideally be stored in a repository so that they can be retrieved, expanded, and edited over time. Some two possible types of data modeling are Strategic data modeling and Tactical data modeling. Strategic data modeling: This is part of the creation of an information systems strategy, which defines an overall vision and architecture for information systems is defined. Information engineering is a methodology that embraces this approach.

Tactical or Analytic data modeling during systems analysis are usually logical data models are created as part of the development of new databases. Data modeling also enables the development business requirements for a database. It is sometimes called database modeling because a data model is eventually implemented in a database.

A conceptual schema or conceptual data model is a map of concepts and their relationships. This describes the semantics of an organization and represents a series of assertions about its nature. Specifically, it describes the things of significance to an organization (entity classes), about which it is inclined to collect information, and characteristics of (attributes) and associations between pairs of those things of significance (relationships).

Web Deployment Projects with Visual Studio 2008

2009-06-24T08:09:00.003-05:00

Visual Studio 2008 provides deployment support through its Copy Web Site and Publish Web Site features. While these are ideal for many scenarios, there are other, more advanced scenarios where developers need the following capabilities:

More control over assembly naming and output.
Custom pre-processing and post-processing for the build.
The ability to exclude, add, and transform files and directories during builds.
The ability to modify the Web.config file to change database connection strings, application settings, or the URLs for Web references, depending on the build configuration. (For example, it might be necessary to use different values for development, test, staging, and release settings).

Web Deployment Projects

Web Deployment Projects is an add-in package to Visual Studio 2008 . It does not change the behavior of any feature in Visual Studio 2008 ; it simply adds additional functionality specific to Web site deployment.

A Web Deployment project is an MSBuild project file for a Web site. It fully integrates into the Visual Studio 2008 build configuration manager and supports configuration options for compilation and deployment, such as Debug and Release. A Web Deployment project is extensible, enabling you to create pre-build and post-build actions.

Web Deployment projects do not change the way Visual Studio 2008 Web site projects build. Instead, they take an existing Web site project as input and generate a precompiled Web site as output. A Web Deployment project does not change the files in the source Web site project in any way.

Feature Summary

A Web Deployment project provides the following features for building and deploying ASP.NET 2.0 or greater Web sites:

ASP.NET 2.0 precompilation as part of the build process.
More flexible options for generating compiled assemblies from a Web project, including these alternatives:
- A single assembly for the entire Web site.
- One assembly per content folder.
- A single assembly for all UI components.
- An assembly for each compiled file in the Web site.
Assembly signing options.
The ability to define custom pre-build and post-build actions.
The ability to exclude folders from the build.
The ability to modify settings in the Web.config file, such as the <connectionString> element, based on the Visual Studio build configuration.
Support for creating .msi files with setup projects.

The extensibility of Web Deployment projects enables you to tailor the build and deploy process to suit your needs. This is done without sacrificing the optimized workflow improvements achieved with Visual Studio 2008 Web site projects.

Installing Web Deployment Projects

Installing Web Deployment projects installs both a Visual Studio 2008 add-in package and the new ASP.NET merge utility (aspnet_merge.exe).

By default, the installation process installs files into the locations listed in the following table.

Location/Files

C:\Program Files\MSBuild\Microsoft\WebDeployment\v8.0
aspnet_merge.exe ,Microsoft.WebDeployment.targets,Microsoft.WebDeployment.Tasks.dll

C:\Program Files\Microsoft Visual Studio 8\Common7\Packages
MsWebDeployProj.dll , WebDeploy.wdproj

C:\Program Files\Microsoft Visual Studio 8\Common7\Packages\1033
MsWebDeployProjUi.dll

You can install Web Deployment projects on a computer that does not have Visual Studio 2008 installed. This is useful if you want to use MSBuild features on a dedicated build computer. MSBuild is part of the Microsoft .NET Framework version 2.0 and does not require installation of Visual Studio 2008.

New Menu Commands

Installing Web Deployment Projects adds the Add Web Deployment Project command to the Build menu and to the shortcut menu for the selected Web project in Solution Explorer. The new command is supported only for local IIS Web sites and for file system Web sites. Web Deployment Projects do not support remote FrontPage or FTP Web sites.

Note The Add Web Deployment Project command is the only way to add a Web Deployment project to the solution. This new project type is not available in the New Project dialog box.

When you create a Web Deployment project, the new Web Deployment project is associated with the Web site you created it for. Generally there is a one-to-one relationship between the Web site and the Web Deployment project. Each Web site in a solution can have its own Web Deployment project. You can also optionally create multiple Web Deployment projects for the same site.

Advanced scenarios merging multiple Web sites into a single Web site can be achieved through custom build actions as described in the section Customizing Web Deployment Projects later in this paper.

Adding a Web Deployment Project

To add a Web Deployment project to a Web site, follow these steps.

In Solution Explorer, select the name of the Web site to work with.
In the Build menu, choose Add Web Deployment Project.
The Add Web Deployment Project dialog box is displayed:
Specify a name and location for the project.
By default, the project name is the same as the Web site with _deploy appended to the name. The default location is in the same folder as the solution.

In the example shown here, the Web site path is C:\MyProjects\MyWeb. The project file will be named MyWeb_deploy.webdeployproj, and the project folder path will be C:\MyProjects\MyWeb_deploy\.
Click OK.
A new project is added to the solution and automatically associated with the Web site. The new Web Deployment project is now part of the build process.

Tip When creating a new Web site project that you will add other projects to (such as a class library project or a Web Deployment project), start by creating an empty solution in the location of your choice. Then add the new Web site to that solution. This ensures that Visual Studio puts all of the project files in the same set of directories and subdirectories.

The new Web Deployment project does not contain any files or child nodes in the solution hierarchy. Instead, it is an MSBuild project file that enables you to customize the build rules for the associated Web site.

You can view properties for the current Web Deployment project in the Properties window. (These properties are distinct from the settings for build configurations, which you edit using the Property Pages dialog box, as discussed in the next section.)

Web Deployment Project Property Pages

You can create and edit individual configurations for the current Web Deployment project using the Property Pages dialog box. (This dialog box is available by right-clicking the project in Solution Explorer and then selecting Property Pages). The Property Pages dialog box for a Web Deployment project displays four property pages:

Compilation
Output Assemblies
Signing
Deployment

The properties on each of these property pages can have unique values for each build configuration. Visual Studio 2005 provides two default configurations: Debug and Release. You can use these predefined configurations or define new configurations (such as Staging or Production), depending on your needs. All the settings you make in the Property Pages dialog box apply to the selected configuration.

Compilation Page

The Compilation page of the Web Deployment project's property pages dialog box looks like the following:

The following table describes the properties you can set in the Compilation page.

Setting/Description

Output folder
Specifies the folder to contain the precompiled image of the Web site. The default is to create a subfolder with the same name as the configuration in the folder where the Web Deployment project file is stored.

Generate debug information
Generates .pdb files when compiling. This setting will also update the value of the <compilation debug="true"/> element in the configuration file of the precompiled Web site.

Use IIS Metabase path for source input
Specifies the full IIS metabase path of the source Web site application. This setting corresponds to the –m option of the aspnet_compiler.exe command.

For example, a metabase path might be /LM/W3SVC/1/ROOT/MyWeb/, where MyWeb is the virtual directory.

This setting is useful if your Web site contains one or more sub-Web sites. During compilation, the compiler processes all the files in a directory tree. If there are sub-Web sites, this will result in build errors. To avoid these errors, you can specify the IIS metabase path of the Web site you are compiling, which causes the ASP.NET compiler to skip any sub-Web sites defined in the IIS metabase.

To compile the sub-Web sites, you must add a separate Web Deployment project for each of the sub-Web sites.

Allow this precompiled site to be updatable
Enables ASP.NET Web pages and user controls (.aspx and .ascx files) to be updated after compilation; only the code-behind files are compiled. If this option is not checked, the HTML markup for pages and controls is removed and compiled into the assembly output.

Output Assemblies Page

The Output Assemblies page of the Web Deployment project's property pages dialog box looks like the following:

The following table describes the properties you can set in the Output Assemblies page.

Setting / Description

Merge all outputs to a single assembly
Merges all the output assemblies from the compiler into a single assembly. This setting is equivalent to the -o assemblyname option of the aspnet_merge.exe command. This results in the same behavior that Visual Studio .NET 2003 supports, where one assembly is generated for each Web project.

Treat as library component
Removes the App_code.compiled file. This enables the project's App_Code.dll assembly to be added to the Bin folder of another Web site without conflicting with the App_Code.dll assembly in the other Web site. This setting is equivalent to the -r option of the aspnet_merge.exe command.

This option is useful for building a library of .ascx controls.

Merge each folder output to its own assembly
Creates a separate output assembly for each folder. This enables you to update your Web site at the folder level rather than updating the entire application. This setting is equivalent to the -prefix prefixname option of the aspnet_merge.exe command.

You can optionally specify a prefix that will be pre-pended to all generated assembly names. For example, if you specify the prefix MyCompany, the name becomes MyCompany.SubfolderName.

Merge all pages and controls to a single assembly
Merges the output assemblies for all pages and user controls in the Web site into a single assembly. This enables you to update UI elements separately from updating other code. Special folders such as App_Code, App_WebReferences, and so on are each compiled into a separate assembly.

This setting is equivalent to the –w assemblyname option of the aspnet_merge.exe command.

Create a separate assembly for each page and control
Compiles each page and user control into a separate assembly. This setting does not run aspnet_merge.exe. Instead, it uses the -fixednames option of the aspnet_compiler.exe command.

Note Compiling with the -fixednames option disables the compiler's batch optimizations and can result in longer compile times for large Web sites.

This option is useful for granular updates of your deployed Web site.

Version Output Assemblies

Assembly Version

File Version

Sets the assembly version and/or the file version attribute of merged assemblies. The format is 0.0.0.0.

This setting overrides the assembly attributes defined in the AssemblyInfo.vb or AssemblyInfo.cs file in the App_Code directory.

This setting is equivalent to the -copyattrs assemblyfile option of the aspnet_merge.exe command.

Signing Page

The Signing page of the Web Deployment project's property pages dialog box looks like the following:

The following table describes the properties you can set in the Signing page.

Setting /Description

Key file location
Specifies the path to the keyfile used to sign the assemblies. Keyfiles are produced with the Sn.exe utility included with the .NET Framework SDK.

Delay signing
Compiles the assemblies with delay signing. This enables the assemblies to be signed as part of a post-build process.

Mark assemblies with AllowPartiallyTrustedCallers attribute (APTCA).
Specifies that types in strongly named assemblies can be called by partially trusted code only when the assemblies have been marked with the AllowPartiallyTrustedCallers attribute (APTCA). This attribute removes the implicit link demand for the Full trust permission set that is otherwise automatically enforced on each publicly accessible method in each type.

Deployment Page

The Deployment page of the Web Deployment project's property pages dialog box looks like the following:

The following table describes the properties you can set in the Deployment page.

Setting /Description

Enable Web.config file section replacement
Enables the replacement of any section in the root Web.config file with the content of a matching section in a separate (external) .config file. The external file can contain only the section being replaced.

This option enables you to define elements that are written to the root Web.config file at deployment time, which in turn provides a way to create deployment-specific configuration sections.

Enforce matching section replacements
Requires that the specified section in the Web.config file have the same number of elements as the replacement section in the external .config file. A build error occurs if there is a mismatch in the number of elements. This option helps you detect when changes have been made to the Web.config file but are not reflected in external .config files.

Use external configuration source file
Updates the Web.config file by replacing existing sections with elements that reference a .config file, using the configSource attribute:

<appSettings
configSource="appSettings.config" />

If this option is not selected, the section is replaced entirely with the elements in the .config file.

This option is useful for changing the database connection strings or Web reference URLs for each build configuration.

Create an IIS virtual directory for the output folder

Creates an IIS virtual directory pointing to the output folder for this build configuration, using the name you specify. This is useful for immediate testing of the precompiled Web application. To avoid conflict with other configurations, include the configuration name as part of the virtual directory name. For example, use virtual directory names such as MyWeb_Staging and MyWeb_Release.

Replace the existing virtual directory

If the virtual directory already exists and is pointing to a different folder, updates the metabase to point to the output folder for this configuration . If this option is not selected, an error occurs if the virtual directory path does not match the output folder.

Remove the App_Data folder

Removes the App_Data folder from the precompiled image of the Web site. This is useful if you are changing connection strings to access a SQL Server database and no longer require a SQL Server Express or Access database in the App_Data folder.

Managing Custom Build Configurations

Using Visual Studio build configurations, you can define the specific build processes that are necessary for producing a staging or release build of your Web application. There are three build configurations commonly used for building Web site applications:

Debug build configuration This is the default build configuration used at design time. In team development scenarios, it is often desirable to isolate developers so that they do not overwrite one another's changes while editing and debugging. In those cases, developers typically use either a local IIS Web site (and a locally installed instance of IIS) or a file system Web site and the built-in ASP.NET development server. Similarly, each developer will typically use a local SQL Server, SQL Server Express, or Access database. Developers can even implement Web services locally and consume them using a Web reference that points to http://localhost/.

Staging build configuration Once developers have a version of the Web site ready for testing, they can produce a build configured for a testing or staging environment. The staging environment is often a replica of the production or release environment. For example, a staging environment will likely use a shared SQL Server database containing test data. Web services may also be distributed across other computers in the staging environment.

Release build configuration When the Web site is ready for a production release, database connections and Web references must be changed to reflect the production environment. For optimal performance, it is also recommend that the Debug compilation mode be set to False in the application's Web.config file.

Web Deployment projects enable you to customize the build process and tailor the Web site application to the environment in which it will be deployed.

All property values for a Web deployment project apply to a specific build configuration. By changing the selected configuration, you can change the settings for a specific configuration. Alternatively, by selecting All Configurations, you can apply a change globally across all configurations.

To create a new configuration, in the project Property Pages dialog box, click the Configuration Manager button:

This displays the Configuration Manager dialog box. The configuration manager enables you to create new configurations and to specify which projects to build as part of that configuration.

Visual Studio exposes two levels of build configurations: solution configurations and project configurations. For more information about build configurations, see Build Configurations on the MSDN Web site.

The configuration manager shows the active solution configuration and the build configuration setting for each project for that solution configuration. After you add a Web Deployment project to the solution, the configuration manager lists both the Web site project and the Web Deployment project. By default, both projects are configured to build whenever the solution is built:

You should disable building the Web Deployment project in the Debug configuration. Building a Web Deployment project unnecessarily increases the time it takes to build a solution or start a debug session when you press F5. You should enable building the Web Deployment project only in solution configurations intended for deployment builds.

Using the Configuration Manager dialog box, you can create a new Staging configuration. You can also specify which projects should build when a specific solution configuration is built. For more information about the configuration manager, see Configuration Manager Dialog Box on the MSDN Web site.

The builds for Web site projects are optimized for developer productivity and do not run the ASP.NET 2.0 compiler to precompile the site. The build for the Web Deployment projects invoke the ASP.NET 2.0 compiler to precompile the site and take advantage of the new assembly merge utility (aspnet_merge.exe). When you create your solution configurations, you should build either the Web site project or the Web Deployment project, but not both. The following table presents a matrix suggesting the project build settings for different solution configurations.

Solution configuration

Build strategy

Debug

Staging

Release

Build Web site project

True

False

False

Build Web Deployment project

False

True

True

To specify the solution configuration to use when you build, select the configuration name from the Solution Configurations list on the toolbar:

Note Some Visual Studio Development Settings, such as the Web Development Settings and Visual Basic Development Settings, do not include the Solution Configurations command on the toolbar. To add the command, from the Tools menu, choose Customize. Click the Commands tab, select the Build category, and then from the commands list drag the Solution Configurations command to the toolbar.

Building a Web Deployment Project

When you have your build configurations established, you can initiate a build for any configuration. There are two ways to build a Web Deployment project—from within Visual Studio 2008 or from the command line using MSBuild.

Building Within Visual Studio 2008

To build within Visual Studio 2008, in the toolbar, select Release from the Solution Configurations list in the toolbar. This makes Release the current solution configuration. Then from the Build menu, choose Build Solution.

The output for the build is displayed in the Output window. An example of the output from a build is shown in the following listing. Notice that in this example, the Web site project was skipped, and instead the Web Deployment project was built.

------ Skipped Build: Project: c:\...\MyWeb\, Configuration: Debug .NET ------
Project not selected to build for this solution configuration
------ Build started: Project: MyWeb_deploy, Configuration: Release Any CPU ------
Build started 11/7/2005 9:40:09 AM.
Target AspNetCompiler:
  C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\aspnet_compiler.exe –
v /MyWeb -p c:\MyProjects\MyWeb\MyWeb -u -f
c:\MyProjects\MyWeb\MyWeb_deploy\Release\
  Updateing web.config compilation debug = 'False' ...
  Successfully updated web.config compilation debug = 'False' ...
  Removing directory "c:\MyProjects\MyWeb\MyWeb_deploy\Release\\App_Data".
Target GenerateAssemblyInfo:
  Generating AssemblyInfo ...
  Setting [assembly: AssemblyFileVersion("2.0.0.0")]
  Setting [assembly: AssemblyVersion("2.0.0.0")]
  Successfully Generated AssebmlyInfo ...
  C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Csc.exe
/out:c:\MyProjects\MyWeb\MyWeb_deploy\AssemblyInfo\Release\AssemblyInfo
.dll /target:library
c:\MyProjects\MyWeb\MyWeb_deploy\AssemblyInfo\Release\AssemblyInfo.cs
Target AspNetMerge:
  Running aspnet_merge.exe ...
  C:\Program Files\MSBuild\Microsoft\WebDeployment\v8.0\aspnet_merge.exe
c:\MyProjects\MyWeb\MyWeb_deploy\Release -o MyCompany.MyWeb -copyattrs
c:\MyProjects\MyWeb\MyWeb_deploy\AssemblyInfo\Release\AssemblyInfo.dll
  Successfully merged 'c:\MyProjects\MyWeb\MyWeb_deploy\Release'.
Target ReplaceWebConfigSections:
  Updating web.config: RootPath =
c:\MyProjects\MyWeb\MyWeb_deploy\Release\, ValidateSections = False,
UseExternalConfigSource = True
  Replacing section connectionStrings with file release.config
  Update of web.config Succeeded.
Target CreateVirtualDirectory:
  Initializing IIS Web Server...
  Successfully created virtual directory 'MyWeb_Release'.
  Granting IIS read access to the folder 'c:\MyProjects\MyWeb\MyWeb_deploy\Release'...
  Grant folder access successful.
  Not setting IIS access to folder
'c:\MyProjects\MyWeb\MyWeb_deploy\Release\App_Data'. Folder does not exist.

Build succeeded.

Time Elapsed 00:00:11.52
========== Build: 1 succeeded or up-to-date, 0 failed, 1 skipped
==========

To control the amount of information displayed by MSBuild, from the Tools menu, choose Options. Choose Projects and Solutions, and under Build and Run, select the level of detail you want from the MSBuild project build output verbosity list. The settings are Quiet, Minimal, Normal, Detailed, and Diagnostic.

Building from the Command Line Using MSBuild

You can also build the solution or .wdproj file from the command line using the msbuild.exe command. To specify which configuration to build, set the configuration to use by passing it on the command line with the /p switch, as shown in the following example:

C:\MyProjects\MyWeb>msbuild MyWeb.sln /p:Configuration=Release

The output from the build process will look like the following listing:

Microsoft (R) Build Engine Version 2.0.50727.42
[Microsoft .NET Framework, Version 2.0.50727.42]
Copyright (C) Microsoft Corporation 2005. All rights reserved.

Build started 11/7/2005 10:01:05 AM.
__________________________________________________
Project "C:\MyProjects\MyWeb\MyWeb.sln" (default targets):

Target ValidateSolutionConfiguration:
  Building solution configuration "Release|Mixed Platforms".
Target Build:
  Target MyWeb_deploy:
      __________________________________________________
      Project "C:\MyProjects\MyWeb\MyWeb.sln" is building
"C:\MyProjects\MyWeb\MyWeb_deploy\MyWeb_deploy.wdproj" (default
targets):

      Target AspNetCompiler:
        
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\aspnet_compiler.exe -v
/MyWeb -p C:\MyProjects\MyWeb\MyWeb -u -f
C:\MyProjects\MyWeb\MyWeb_deploy\Release\
          Updateing web.config compilation debug = 'False' ...
          Successfully updated web.config compilation debug = 'False' ...
          Removing directory
"C:\MyProjects\MyWeb\MyWeb_deploy\Release\\App_Data".
      Target GenerateAssemblyInfo:
          Generating AssemblyInfo ...
          Setting [assembly: AssemblyFileVersion("2.0.0.0")]
          Setting [assembly: AssemblyVersion("2.0.0.0")]
          Successfully Generated AssebmlyInfo ...
          C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Csc.exe
/out:C:\MyProjects\MyWeb\MyWeb_deploy\AssemblyInfo\Release\AssemblyInfo.dll /target:library
C:\MyProjects\MyWeb\MyWeb_deploy\AssemblyInfo\Release\AssemblyInfo.cs
      Target AspNetMerge:
          Running aspnet_merge.exe ...
          C:\Program
Files\MSBuild\Microsoft\WebDeployment\v8.0\aspnet_merge.exe
C:\MyProjects\MyWeb\MyWeb_deploy\Release -o MyCompany.MyWeb -copyattrs
C:\MyProjects\MyWeb\MyWeb_deploy\AssemblyInfo\Release\AssemblyInfo.dll
          Successfully merged
'C:\MyProjects\MyWeb\MyWeb_deploy\Release'.
      Target ReplaceWebConfigSections:
          Updating web.config: RootPath =
C:\MyProjects\MyWeb\MyWeb_deploy\Release\, ValidateSections = False,
UseExternalConfigSource = True
          Replacing section connectionStrings with file
release.config
          Update of web.config Succeeded.
      Target CreateVirtualDirectory:
          Initializing IIS Web Server...
          Successfully created virtual directory 'MyWeb_Release'.
          Granting IIS read access to the folder
'C:\MyProjects\MyWeb\MyWeb_deploy\Release'...
          Grant folder access successful.
          Not setting IIS access to folder
'C:\MyProjects\MyWeb\MyWeb_deploy\Release\App_Data'. Folder does not
exist.

Build succeeded.
  0 Warning(s)
  0 Error(s)

Time Elapsed 00:00:14.13

The files generated for this build are in the MyWeb_deploy\Release folder. Note the single output assembly MyCompany.MyWeb.dll.

Location

Files

C:\MyProjects\MyWeb\MyWeb_deploy\Release

Default.aspx

PrecompiledApp.config

release.config

web.config

C:\MyProjects\MyWeb\MyWeb_deploy\Release\bin

App_Code.compiled

MyCompany.MyWeb.dll

Customizing Web Deployment Projects

Web Deployment projects are MSBuild project files. The Web Deployment project file has the file name extension .wdproj. All the properties you set using the Web Deployment projects property pages are persisted in the .wdproj file as MSBuild properties or items. For more information about MSBuild and its properties and settings, see MSBuild Overview on the MSDN Web site.

You can customize the build process for Web Deployment projects by editing the Web Deployment project file. To do this, right-click the Web deployment project in Solution Explorer, and then select Open Project File.

In the file you will find one property group for each configuration. This is where the Web Deployment Property Pages dialog box persists the settings for each configuration you create.

Near the bottom of the file you see a comment block containing four MSBuild targets:

  <!-- To modify your build process, add your task inside one of the
targets below and uncomment it.
Other similar extension points exist, see
Microsoft.WebDeployment.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="BeforeMerge">
</Target>
<Target Name="AfterMerge">
</Target>
<Target Name="AfterBuild">
</Target>
-->

You can override these targets to add custom build tasks. For example, the Personal Web Starter Kit included with Visual Studio 2005 uses a special folder named Upload for uploading images from users. This folder must exist for upload functionality to work properly. To ensure that this folder always exists in the precompiled Web site, you can add the following target and task:

  <Target Name="AfterBuild">
  <MakeDir Directories="$(TargetDir)\Upload" />
</Target>

MSBuild includes many predefined tasks, such as MakeDir. MSBuild also provides a way for you to create your own tasks. For more information on custom MSBuild tasks, see How To: Write a Task on the MSDN Web site.

In addition to overriding targets and creating custom tasks, you can add properties and items to the MSBuild tasks included with Web Deployment projects. For example, by adding the following <ItemGroup> section to a Web Deployment project, you can exclude the Test and Images folder from the build process:

  <ItemGroup>
  <ExcludeFromBuild Include="$(SourceWebPhysicalPath)\Test\**\*.*"/>
  <ExcludeFromBuild
Include="$(SourceWebPhysicalPath)\Images\**\*.*"/>
</ItemGroup>

This is useful if you have test code in the Web site project that should not be included in the staging or release builds.

By default, the ASP.NET merge tool applies the assembly attributes from the compiler-generated App_Code assembly to the merged assemblies. The attributes are defined in the AssemblyInfo.cs or AssemblyInfo.vb file included in the App_Code folder. Alternatively, you can define assembly attributes in the Web Deployment project file. This is useful if the attributes will vary between configurations. For example, when you define Assembly Version and File Version in the Web Deployment project property pages, the following <ItemGroup> section is added to the Web Deployment project file:

  <ItemGroup>
  <AssemblyAttributes Include="AssemblyVersion">
    <value>3.0.0.0</value>
  </AssebmlyAttributes>
  <AssebmlyAttributes Include="AssemblyFileVersion">
    <value>3.0.0.0</value>
</ItemGroup>

This <ItemGroup> section could also contain any other assembly attribute you want to be included in the merged assemblies. The following listing shows examples of additional assembly attributes defined in an <ItemGroup> section:

  <ItemGroup>
  </AssebmlyAttributes>
  <AssemblyAttributes Include="AssemblyTitle">
    <value>MyCompany MyWeb</value>
  </AssemblyAttributes>
  <AssemblyAttributes Include="AssemblyDescription">
    <value>Corporate Site</value>
  </AssemblyAttributes>
  <AssemblyAttributes Include="AssemblyCompany">
    <value>MyCompany</value>
  </AssemblyAttributes>
  <AssemblyAttributes Include="AssemblyCopyright">
    <value>Copyright © MyCompany 2005</value>
  </AssemblyAttributes>
</ItemGroup>

Web Deployment Projects Reference

The following table lists the MSBuild tasks included in Web Deployment projects.

Tasks

Description

ReplaceConfigSections

Replaces a section in the Web.config file with the matching section from an external (.config) file.

CreateVirtualDirectory

Creates an IIS virtual directory.

AspNetCompiler

Calls aspnet_compiler.exe.

AspNetMerge

Calls aspnet_merge.exe.

GrantServerAccess

Grants ASP.NET read or write access to specific folders.

ToggleDebugCompilation

Changes the value of compilation debug setting in the Web.config file.

GenerateAssemblyInfo

Generates an assembly with the assembly attributes defined in the AssemblyAttributes MSBuild item.

The following table lists the MSBuild properties included in Web Deployment projects.

Properties

Description

EnableCopyBeforeBuild

Makes a copy of the Web site before running aspnet_compiler.exe. This is useful for modifying files before they are compiled.

CopyBeforeBuildTargetPath

Specifies the folder where the copied Web site should be placed.

SourceWebPhysicalPath

Specifies the path to the Web site being compiled.

EnableUpdateable

Enables the Web site to be updatable.

AllowPartiallyTrustedCallers

Allows partially trusted callers.

DeleteAppDataFolder

Deletes the App_Data folder in the precompiled Web site.

UseMerge

When true, causes the AspNetMerge target to execute.

AssemblyPrefixName

Specifies the prefix for merged assemblies.

SingleAssemblyName

Specifies the assembly name used when merging into a single assembly.

ContentAssemblyName

Specifies the assembly name used when merging into a separate content assembly.

MergeErrorStack

Adds error stack trace information to the build output.

DeleteAppCodeCompiledFiles

Deletes the App_Code.compiled file.

CopyAssemblyAttributes

Specifies that aspnet_merge.exe should copy the assembly attributes from the App_Code assembly into the merged assemblies.

AssemblyInfoDll

Specifies an alternate DLL containing the assembly attributes that aspnet_merge.exe should use.

MergeXmlDocs

Merge the xml documentation files associated with the assemblies compiled by the aspnet_compiler.exe. This is equivalent to the –xmldocs argument of aspnet_merge.exe.

MergeErrorLogFile

Specifies an alternate log file for the merge process.

UseWebConfigReplacement

When true, causes the ReplaceWebConfigSections target to execute.

UseExernalWebConfigReplacementFile

Specifies whether replaced sections will use the configSource file reference. If false, the section is replaced in place.

ValidateWebConfigReplacement

Validates that the Web.config file section being replaced has the same number of elements as the replacement section.

VirtualDirectoryAlias

Specifies the alias for the virtual directory that is created for the precompiled build output.

VirtualDirectoryServer

Specifies the server on which to create the virtual directory. The default is 1.

ReplaceExistingVirtualDirectory

Replaces the existing virtual directory. If false, the build will fail if the path of the existing virtual directory in the IIS metabase does not match the path of the precompiled Web site.

The following table lists the MSBuild items included in Web Deployment projects.

Items

Description

ExcludeFromBuild

Files to exclude from a build.

WebConfigReplacementFiles

Sections to replace in the Web.config file.

AssemblyAttributes

Assembly attributes to apply to merged assemblies.

PrecompiledOutput

All output files from the AspNetCompiler or AspNetMerge targets.

The following table lists the MSBuild targets included in Web Deployment projects.

Targets

Description

Clean

Executes when performing a complete build.

Rebuild

Executes when rebuilding.

AspNetCompiler

Invokes the AspNetCompiler task.

AspNetMerge

Invokes the AspNetMerge task.

ReplaceWebConfigSections

Invokes the ReplaceConfigSections task.

CreateVirtualDirectory

Invokes the CreateVirtualDirectory task.

BuiltProjectOutputGroup

Populates the project output group.

GenerateAssemblyInfo

Invokes the GenerateAssemblyInfo task.

BeforeBuild

Specifies an override for the BeforeBuild target.

BeforeMerge

Specifies an override for the BeforeMerge target.

AfterMerge

Specifies an override for the AfterMerge target.

AfterBuild

Specifies an override for the AfterBuild target.

IIS ASP.NET Web Deployment Tool (MS Deploy)

2009-06-17T13:11:00.001-05:00

The Web Deployment Tool (MS Deploy) is a command-line tool that is used for migrating and synchronizing Web sites and Web servers. See the following links for more information about the Web Deployment Tool (also referred to as MS Deploy)

Introducing MS Deploy

MS Deploy Core Tasks

MS Deploy Reference

Web Deployment Tool Resources on IIS.NET

The Web Deployment Tool is a tool for simplifying the deployment, management and migration of Web applications, sites and even entire servers. Developers can package a Web site, automatically including content, configuration, certificates and databases. These packages can be directly deployed to a server or packaged and shared with others. IT Professionals can enable developers to deploy these packages to a server and delegate access to non-admins. IT Professionals can also use the tool in their infrastructure to synchronize servers easily on both IIS 6.0 and IIS 7.0, or even to accomplish a migration from IIS 6.0 to IIS 7.0.

Here are just a few of the tasks that be accomplished using the tool:

1. Create a package that contains content, configuration and databases for deployment or sharing with others.

2. Use the package as a way to version your application or create backups.

3. Add parameters to replace a connection string or other value in a file during install of a package.

4. Enable non-administrators to deploy packages and granularly control their access.

5. Synchronize or migrate both sites and servers running IIS 6.0 and IIS 7.0.

Where to Get the Tool

Download the x86 version: http://go.microsoft.com/fwlink/?LinkId=109365

Download the x64 version: http://go.microsoft.com/fwlink/?LinkId=109366

Web Deployment Tool forum: http://forums.iis.net/1144.aspx

Web Deployment Team blog: http://blogs.iis.net/msdeploy/

Download the Help file: http://go.microsoft.com/?linkid=8100895

Start Using the Tool

The following articles cover the functionality of the tool and how to use it for common tasks.

Learn the Basics

1. Web Deployment Tool Overview (overview of the features)

2. Installing the Web Deployment Tool (installation and remote service options)

Package and Deploy Applications

1. Export a Package through IIS Manager (create an application package including content, databases and more)

2. Import a Package through IIS Manager (install an application package to a local or remote machine)

3. Configure the Web Deployment Handler (enable remote deployment to an IIS 7.x server)

Synchronize Web Servers

1. Migrating from IIS 6.0 to IIS 7.0

2. Syncing between two IIS 7.0 servers

3. Syncing between two IIS 6.0 servers

Advanced Topics

1. Viewing Dependencies of a Web site (how to use the output of getDependencies)

2. Using Custom Manifests (how to define your own web site)

3. Troubleshooting MS Deploy (how to enable verbose output)

Internet Information Server (IIS) versions

2009-06-17T09:08:00.001-05:00

What versions of IIS are you running? How do you determine What version of IIS is installed on your server or desktop? You can look in IIS Manager to see what version of IIS you are using. Select the top node that is titled Internet Information Services and look in the details, for Windows 2003 it should say II V6.0

Every Windows version has it's own IIS version:

Windows Server 2000      5.0
Windows XP Professional  5.1
Windows Server 2003      6.0
Windows Vista            7.0
Windows Server 2008      7.0

It is recommended that folks upgrade to Microsoft Internet Information Services (IIS) version 7.0 running on Microsoft Windows Server 2008 because IIS 7.0 significantly increases Web infrastructure security

Below is a list of all versions of IIS, and how they can be obtained.

IIS Version: 1.0
Obtained from:Included with Windows NT 3.51 SP 3 (or as a self-contained download). Operating System:Windows NT Server 3.51

IIS Version: 2.0
Obtained from:Included with Windows NT Server 4.0. Operating System:Windows NT Server 4.0

IIS Version:3.0
Obtained from:Included with Windows NT Server 4.0 Service Pack 3 (http://www.microsoft.com/NTServer/nts/downloads/archive/NT4SvcPk3/default.asp) (Internet Information Server 2.0 is automatically upgraded to Internet Information Server 3.0 during the install of SP3). Operating System:Windows NT Server 4.0

IIS Version:4.0
Obtained from:Self-contained download from www.microsoft.com (http://www.microsoft.com/NTServer/nts/downloads/recommended/NT4OptPk/default.asp) or the Windows NT Option Pack compact disc. Operating System:Windows NT Server 4.0 SP3 and Microsoft Internet Explorer 4.01

IIS Version:5.0
Obtained from:Built-in component of Windows 2000. Operating System:Windows 2000

IIS Version:5.1
Obtained from:Built-in component of Windows XP Professional.
Operating System:Windows XP Professional

IIS Version: 6.0
Obtained from:Built-in component of Windows Server 2003.
Operating System:WIndows Server 2003

IIS Version:7.0
Obtained from:Built-in component of Windows Vista and Windows Server 2008. Operating System:Windows Vista and WIndows Server 2008

How do I determine which version of IIS / ASP I'm running?

If you are running Windows Server 2003, you are running IIS 6.0 / ASP 3.0 (though some people like to call this ASP 4.0).
If you are running Windows XP, you are running IIS 5.1 / ASP 3.0.
If you are running Windows 2000, you are running IIS 5.0 / ASP 3.0.
If you are running Windows NT 4.0 or Windows 9x, you can determine which version of IIS / PWS you are running by one of the following methods:
<%
response.write(Request.ServerVariables("SERVER_SOFTWARE"))
' returns "Microsoft-IIS/4.0" for IIS 4.0 + ASP 2.0
%>

OR
OR
1. Do a search for ASP.DLL on your system
2. right-click it and select Properties
3. Check the version tab:

Using ASP.NET 3.5 with Visual Studio 2008

2009-06-16T14:24:00.003-05:00

Web development couldn’t have got better with ASP.NET and VS 2008. Ajax is in the runtime, new controls, LINQ and CSS and JavaScript support. Below are all the new things that make the VS + ASP combination pretty cool.

New Features in ASP.NET 3.5

ASP.NET AJAX

With ASP.NET AJAX, developers can quickly create pages with sophisticated, responsive user interfaces and more efficient client-server communication by simply adding a few server controls to their pages. Previously an extension to the ASP.NET runtime, ASP.NET AJAX is now built into the platform and makes the complicated task of building cross-platform, standards based AJAX applications easy.

More Information

New ListView and DataPager Controls

The new ListView control gives you unprecedented flexibility in how you display your data, by allowing you to have complete control over the HTML markup generated. ListView‘s template approach to representing data is designed to easily work with CSS styles, which comes in handy with the new Visual Studio 2008 designer view. In addition, you can use the DataPager control to handle all the work of allowing your users to page through large numbers of records.

More Information

LINQ and other .NET Framework 3.5 Improvements

With the addition of Language Integrated Query (LINQ) in .NET Framework 3.5, the process of building SQL queries using error-prone string manipulation is a thing of the past. LINQ makes your relational data queries a first-class language construct in C# and Visual Basic, complete with compiler and Intellisense support. For Web applications, the ASP.NET LinqDataSource control allows you to easily use LINQ to filter, order and group data that can then be bound to any of the data visualization controls like the ListView and GridView controls. In addition, all the other improvements to .NET Framework 3.5, including the new HashSet collection, DateTime offset support, diagnostics, garbage collection, better thread lock support, and more, are all available to you in your ASP.NET applications.

More Information

WCF Support for RSS, JSON, POX and Partial Trust

With .NET Framework 3.5, Windows Communication Foundation (WCF) now supports building Web services that can be exposed using any number of the Internet standard protocols, such as SOAP, RSS, JSON, POX and more. Whether you are building an AJAX application that uses JSON, providing syndication of your data via RSS, or building a standard SOAP Web service, WCF makes it easy to create your endpoints, and now, with .NET Framework 3.5, supports building Web services in partial-trust situations like a typical shared-hosting environment.

More Information

Using ASP.NET Web Services Roadmap

New Web Features in Visual Studio 2008

New Web Design Interface

Visual Studio 2008 has incorporated a new Web designer that uses the design engine from Expression Web. Moving between design and source view is faster than ever and the new split view capability means you can edit the HTML source and simultaneously see the results on the page. Support for style sheets in separate files has been added as well as a CSS properties pane which clarifies the sometimes-complex hierarchy of cascading styles, so that it is easy to understand why an element looks the way it does. In addition Visual Studio 2008 has full WYSIWYG support for building and using ASP.NET Nested Master Pages which greatly improves the ability to build a Web site with a consistent look and feel.

More Information

JavaScript Debugging and Intellisense

In Visual Studio 2008, client-side JavaScript has now become a first-class citizen in regards to its debugging and Intellisense support. Not only does the Intellisense give standard JavaScript keyword support, but it will automatically infer variable types and provide method, property and event support from any number of included script files. Similarly, the JavaScript debugging support now allows for the deep Watch and Locals support in JavaScript that you are accustomed to having in other languages in Visual Studio. And despite the dynamic nature of a lot of JavaScript, you will always be able to visualize and step into the JavaScript code, no matter where it is generated from. This is especially convenient when building ASP.NET AJAX applications.

More Information

Multi-targeting Support

In previous versions of Visual Studio, you could only build projects that targeted a single version of the .NET Framework. With Visual Studio 2008, we have introduced the concept of Multi-targeting. Through a simple drop-down, you can decide if you want a project to target .NET Framework 2.0, 3.0 or 3.5. The builds, the Intellisense, the toolbox, etc. will all adjust to the feature set of the specific version of the .NET Framework which you choose. This allows you to take advantage of the new features in Visual Studio 2008, like the Web design interface, and the improved JavaScript support, and still build your projects for their current runtime version.

More Information

ASP.NET 3.5 and Visual Studio 2008

ASP.NET 3.5 and Visual Studio 2008 bring great new functionality around Web development and design that makes building standards based, next generation Web sites easier than ever. From the inclusion of ASP.NET AJAX into the runtime, to new controls, the new LINQ data capabilities, to improved support for CSS, JavaScript and others, Web development has taken a significant step forward.

Other Resources

What‘s New in ASP.NET and Web Development

Learn More about Visual Studio 2008

Forums

NUnit Quick Tutorial

2009-06-09T15:47:00.000-05:00

Unit testing is not only good practice but essential to developing great software. My favorite Unit testing framework is NUnit. I have used unit testing frameworks and love Test driven development too. Below is a short introduction to Unit Testing, TDD and some related links.

Unit Tests

A unit test is the smallest testable part of an application. Ideally, each test case is independent from the others: substitutes like method stubs, mock objects, fakes and test harnesses can be used to assist testing a module in isolation. Unit tests are typically written and run by software developers to ensure that code meets its design and behaves as intended. Its implementation can vary from being very manual (pencil and paper) to being formalized as part of build automation. Unit testing allows the programmer to refactor code at a later date, and make sure the module still works correctly (i.e. regression testing).

NUnit Basics

NUnit is a unit-testing framework for all .Net languages. Initially ported from JUnit, the current production release, version 2.5, is the sixth major release of this xUnit based unit testing tool for Microsoft .NET. It is written entirely in C# and has been completely redesigned to take advantage of many .NET language features, for example custom attributes and other reflection related capabilities. NUnit brings xUnit to all .NET languages.

To get started using NUnit, read the Quick Start page. This article demonstrates the development process with NUnit in the context of a C# banking application. Check theSamples page for additional examples, including some in VB.Net, J# and managed C++.

Which Test Runner to use?

NUnit has two different ways to run your tests. The console runner, nunit-console.exe, is the fastest to launch, but is not interactive. The gui runner, nunit-gui.exe, is a Windows Forms application that allows you to work selectively with your tests and provides graphical feedback.

The key concepts and ideas behind NUnit can be learned by visiting the below links from the documentation.

NUNIT 2.5

TDD

TDD or Test Driven Development is the practice of writing unit tests for your code before you actually write that code. By writing a test and then writing the code to make that test pass you have a much better idea of what the goal and purpose of your code is. Test Driven Development not only increases the quality of your code, but also allows you to refactor the internals of a method or class and quickly and easily test the outside interface of the object.

Test-driven development (TDD) is a software development technique that uses short development iterations based on pre-written test cases that define desired improvements or new functions. Each iteration produces code necessary to pass that iteration's tests. Finally, the programmer or team refactors the code to accommodate changes. A key TDD concept is that preparing tests before coding facilitates rapid feedback changes. Note that test-driven development is a software design method, not merely a method of testing

TestDriven.Net is a unit testing add-in for Visual Studio. It supports multiple unit testing frameworks including NUnit, MbUnit, xUnit and MSTest.

TestDriven.Net makes it easy to run unit tests with a single click, anywhere in your Visual Studio solutions. It supports all versions of Microsoft Visual Studio and it integrates with the best .NET development tools.

Other Unit testing Frameworks

csUnit http://www.csunit.org/

Description: csUnit is a unit testing framework for the Microsoft .NET Framework. It targets test driven development using C#, Visual Basic .NET, and managed C++.
Requirement : csUnit has been tested using the Microsoft .NET framework 1.0 Service Pack 2 runtime on an Intel-compatible platform.

Unit Testing with C# Tutorial
How do I make use of the Assert class? How do I implement simple test cases for my class? How do I integrate csUnit with my code? These are some of the questions, which are answered in this all new tutorial.

Nester http://nester.sourceforge.net/

Description: Nester is a tool for mutation analysis of your source code in order to assess the adequacy of your tests. It involves modification of programs to see if existing tests can distinguish the original program from the modified program.
Requirement: Win32; .NET Framework 1.1; NUnit 2.1.5

NUnit http://www.nunit.org/

Description: NUnit is a unit-testing framework for all .Net languages. Initially ported from JUnit, the current version, 2.0 is the second major release of this xUnit based unit testing tool for Microsoft .NET. It is written entirely in C# and has been completely redesigned to take advantage of many .NET language features, for example custom attributes and other reflection related capabilities. NUnit brings xUnit to all .NET languages.
Requirement: Windows NT/2000

NUnit Addin for Visual Studio.NET http://sourceforge.net/projects/nunitaddin/

Description: Point and Test NUnit integration for Visual Studio.NET. The aim of this project it to simplify testing and debugging using the NUnit framework inside of Visual Studio.NET.
Requirement: Windows

NUnitAsp http://nunitasp.sourceforge.net/
Description: NUnitAsp is a tool for automatically testing ASP.NET web pages. It's an extension to NUnit, a tool for test-driven development in .NET.
Requirement: Windows NT/2000

NUnitForms http://nunitforms.sourceforge.net/
Description: An NUnit extension for testing Windows Forms applications, making it easy to write unit tests for your Windows Forms classes.
Requirement: Windows NT/2000

Zanebug http://www.adapdev.com/zanebug/
Description: Zanebug is an advanced unit testing application for .NET. It supports existing NUnit tests, performance metrics, multiple test iterations, in-depth error information, pass / fail stats, perfmon integration, result graphing, etc.
Requirement: Windows

Also read Scott White’s NUnit Best Practices

Programming is not just an art, not just a science, but a discipline. Part of what we all know we should be doing includes solid unit testing. Below is my list of best practices, feel free to comment and add others I enjoy feedback.

Create a separate assembly for your test fixtures
- i.e. don't be lazy and put your test fixtures in the same assembly as the application code)
Create a bin folder per solution and place nunit.framework.dll in there
Each project should copy their binaries to the solution bin folder. Your Post-Build event should look like this: copy $(TargetFileName) "../../../bin/"
Categorize your test fixtures such as DAO, ETL and BusinessRules. This will let you test pieces of your application more easily: [Category("ETL")]
Once you have the basic interface of a class written, it is time to write your unit test for it. Even though it will fail it will at least serve as a place holder to go back to as well as serving as a test for when things are working
Make sure each test is atomic. Therefore if you are inserting data into a table and you know say CustomerName must be unique, then the second time you run your test it will fail because of uniqueness. For this reason have your persistence tests be all inclusive, include an insert, update and delete. Put your delete code into a finally so that it is always executed regardless of if the other tests succeed or not
If you notice all of your test fixtures perform certain setup every time, create a base class for this, let's say each one of your DAO classes will be instantiating a connection and opening it before starting and this connection needs to be closed at the end of testing whether it fails or succeeds
- Obviously we would never want to handle connection objects in our Unit Tests, this would be bad design, in the real world it may be a stream or nhibernate session that you are configuring.

[TestFixture]
public class DAOBaseFixture
{
SqlConnection cn;
[SetUp]
public void Init()
{
cn = new SqlConnection();
cn.Open("...");
}
[TearDown]
public Cleanup()
{
cn.Close();
}

}

Now derivatives of this class won't even have to implement the [TestFixture] attribute nor take care of their setup. They will be free to just take care of their own tests.

public class CustomerDAOTests : DAOBaseFixture

{

[Test]

[Category("DAO")]

public void FindAll()

{...}

}

Moving from IIS 6.0 to IIS 7.0

2008-09-19T01:39:00.001-05:00

Web applications in IIS 7.0 can be configured to use either Classic mode or Integrated mode. Classic mode maintains backward compatibility with earlier versions of IIS by using an ISAPI extension to invoke the ASP.NET runtime. This option usually requires few or no modifications to existing applications.IIS 7.0 Integrated mode is a unified request-processing pipeline that combines the ASP.NET request pipeline with the IIS core request pipeline. The integrated pipeline provides improved performance, provides modularity for configuration and administration, and adds flexibility for extending IIS with managed-code modules. For example, you can define a managed-code module in the App_Code folder of the Web application and register it to apply to all IIS requests, which includes requests for static files.Using IIS 7.0 Integrated mode might require minor changes to an application’s Web.config file. Some additional changes might be needed if the application uses any custom modules that implement the IHttpModule interface.For an overview of the request processing pipeline in Integrated mode in IIS 7.0, see ASP.NET Application Life Cycle Overview for IIS 7.0. When you use IIS 7.0, you can run applications in Classic mode and Integrated mode side-by-side on the same server. Both Classic and Integrated mode support the .NET Framework version 2.0 and later releases. The .NET Framework version 1.1 is supported in Classic mode only. For more information about how to upgrade from earlier versions of IIS to IIS 7.0, see Upgrading ASP.NET Applications to IIS 7.0: Differences between IIS 7.0 Integrated Mode and Classic mode.Note:You can use the information in this topic to move Web applications from IIS 5.x to IIS 7.0. However, additional changes might be necessary, which are not discussed here. For more information see .

Moving an ASP.NET Application from IIS 6.0 to IIS 7.0
This topic describes how to move a Web application from Internet Information Services (IIS) 6.0 to IIS 7.0. Web applications in IIS 7.0 can be configured to use either Classic ...
more ...
go to website
Cached

How to: Create and Configure Virtual Directories in IIS 5.0 and 6.0
You can use IIS Manager to create a virtual directory for an ... Moving an ASP.NET Application from IIS 6.0 to IIS 7.0 Running Web Applications on Windows Vista with IIS 7.0 and ...
more ...
go to website
Cached

IIS 7.0 Server-Side : Creating portable ASP.NET applications that work ...
... moving the module and handler configuration from the ASP.NET’s and sections to the IIS 7.0 ... ASP.NET application running on IIS 6.0, or running in Classic mode on IIS 7.0
more ...
go to website
Cached

IIS7 Hosting, IIS 7.0 Hosting, IIS 7 Hosting, Internet Information ...
... ASP.NET Team "I will be moving ... 6.0 may or may not migrate as is to IIS 7.0 ... application configuration can now be stored in web.config with ASP.NET configuration, and be deployed with content. IIS 7.0 ...
more ...
go to website
Cached

IIS 7.0: Top 10 Performance Improvements in IIS 7.0
... Moving PHP and other application frameworks to IIS 7.0 and FastCGI will allow you to take advantage of various IIS 7.0 features, including the ASP.NET ... ASP.NET, PHP, and any other IIS 7.0-compatible application ...
more ...
go to website
Cached

Web.config Files in IIS 7.0When you move an ASP.NET Web application to IIS 7.0 Integrated mode, you must update the Web.config file. IIS 7.0 includes changes in how you can administer Web.config files and in the types of settings that can be stored in the Web.config files. The new settings are in a new configuration section named system.webServer.In IIS 6.0, the ASP.NET MMC snap-in provides IIS-related administration features for configuring ASP.NET. For more information, see Walkthrough: Configuring ASP.NET Applications in IIS 6.0 using MMC.In IIS 7.0, the administration of ASP.NET applications is integrated more closely with IIS administration, and there is no separate snap-in. Instead, all IIS and ASP.NET configuration is done by using IIS Manager. Because IIS 7.0 configuration information is based on the .NET Framework configuration system, the Web.config file for an application that runs in IIS 7.0 contains both Web server and ASP.NET configuration settings. For example, in a Web.config file for an ASP.NET application running in IIS 7.0, you can specify the default file to return when a browser does not request a specific file. (In IIS 6.0 and earlier versions of IIS, this was a setting that was maintained in the IIS metabase.)Editing Web.config FilesYou can change the Web.config file for a Web application that is running in IIS 7.0 in the following ways:Editing the Web.config file directly, either by using Visual Studio or Visual Web Developer, or by using a text editor program.Using IIS Manager. For more information, see Internet Information Services (IIS) Manager.Using the ASP.NET Web Site Administration Tool. For more information, see ASP.NET Web Site Administration Tool.Note:Changes made in the Web Site Administration Tool do not affect child configuration elements in the system.webServer element.Using the IIS 7.0 command-line tool (Appcmd.exe). This utility enables you to specify IIS configuration settings and Web application configuration settings at the command line. For more information, see IIS 7.0 Command-Line Tool.The system.webServer SectionThe system.webServer configuration section in the Web.config file specifies IIS 7.0 settings that are applied to the Web application. The system.WebServer section is a child of the configuration element. For more information, see IIS 7.0: system.webServer Section Group (IIS Settings Schema).Examples of Web server settings that you can set in the system.WebServer configuration group include the following:The default document that the Web server returns to a client when request does not include a specific resource (defaultDocument element).The compression settings for responses (httpCompression element).Custom headers (customHeaders element of the httpProtocol section).Modules (modules element).Handlers (handlers element).Some settings apply only to IIS 7.0 Integrated mode and do not apply to Classic mode. For example, if the application is running in Classic mode, any managed-code modules and handlers specified in the system.WebServer section of the Web.config file are ignored. Instead, the managed-code modules and handlers must be defined as in earlier versions of IIS, by using the httpModules and httpHandlers elements of the system.web section.For examples of using the system.webServer configuration section, see How to: Configure the Section for IIS 7.0. Moving a Web Application to Classic ModeTypically, moving a Web application from IIS 6.0 to IIS 7.0 Classic mode requires only that you put the application in an application pool that is running in Classic mode. For example, when you install IIS 7.0 with , by default the Web server is configured to operate in Integrated mode. It is also configured to run under the default application pool, which is called DefaultAppPool. To run a Web application in Classic mode, use the Classic.NETAppPool application or create a new application pool that is configured to run in Classic mode. For information about how to create an application pool, see Create an Application Pool.Any custom modules that implement the IHttpModule interface in an application that runs in Classic mode are notified only about pipeline requests that are handled by the ASP.NET runtime. For example, they are notified about requests for an .aspx page. The application life cycle for Classic mode is the same as the life cycle for ASP.NET in IIS 6.0. For more information, see ASP.NET Application Life Cycle Overview for IIS 5.0 and 6.0.If an application that runs in Classic mode contains a handler that requires a script map to handle a custom extension in IIS, you must register the handler in both the httpHandler group and the handler group. You map the custom file-name extension to the ASP.NET ISAPI extension (Aspnet_isapi.dll) by specifying the modules and scriptProcessor attributes in the handler element. These attributes specify that the module that defines the handler is an ISAPI extension, and they specify the path of that extension. This is how IIS 7.0 in Classic mode provides backward compatibility with earlier versions of IIS. However, if you run the application in Integrated mode, you must remove the modules and scriptProcessor attributes. For more information, see How to: Configure an HTTP Handler Extension in IIS.When you move a Web application from IIS 6.0 to Classic mode, it is not guaranteed to work in Integrated mode without changes. If you switch an application from Classic mode to Integrated mode (and change any custom modules and handlers), you might have to make additional changes for the application to run correctly in Integrated mode. The next section in this topic explains how to move an application to IIS 7.0 Integrated mode. Moving a Web Application to Integrated ModeWeb applications that do not include custom modules or handlers will usually work without changes in Integrated mode in IIS 7.0. Web applications that rely on custom modules or handlers require the following steps to enable the application to run in Integrated mode:Register custom modules and handlers in the system.webServer section of the Web.config file by using one of the methods described in the Migrating a Web Config File to Integrated Mode section later in this topic.Define event handlers for HttpApplication request pipeline events like BeginRequest and EndRequest only in the Init method of the custom module.Make sure that you have addressed any issues discussed in the "Known Differences Between Integrated Mode and Classic Mode" section of Upgrading ASP.NET Applications to IIS 7.0: Differences between IIS 7.0 Integrated Mode and Classic mode.Modules that implement the IHttpModule interface are referred to as managed-code modules because they are built by using the .NET Framework. Managed-code modules can be registered at the server level or at the application level. Native-code modules are DLLs (non-managed code) that are registered only at the server level. Core ASP.NET features, such as session state and forms authentication, are implemented as managed modules in Integrated mode.When you move an application from Classic to Integrated mode, you can leave custom modules and handler registrations for Classic mode, or you can remove them. If you do not remove the httpModules and httpHandlers registrations that are used in Classic mode, you must set the validation element’s validateIntegratedModeConfiguration attribute to false to avoid errors. The validation element is a child element of the system.webServer element. For more information, see the section “Disabling the migration message” in ASP.NET Integration with IIS 7.0.Migrating a Web.config File for Use in Integrated ModeIf a module or handler is defined at the application level, the module or handler is not automatically invoked. This includes modules or handlers that are defined in an assembly in the Bin folder or as source code in the App_Code folder, and that are not registered defined in the system.webServer section of the Web.config file. In order for the module or handler to participate in the Integrated mode request pipeline, you must register the module or handler by using one of the following methods:Edit the Web.config directly and add the modules or handlers element to the system.webServer element. Note the difference from Classic mode in the element name—modules compared to httpModules and handlers compared to httpHandlers.Use IIS Manager to configure the module or handler. For more information, see Configuring Handler Mappings in IIS 7.0 and Configuring Modules in IIS 7.0.Use the IIS 7.0 command-line tool (Appcmd.exe). For more information, see Configure Settings for a Site, Application, Virtual Directory or URL by Using Appcmd.exe.Classes and Properties for Working with Integrated ModeWhen you work with an application in IIS 7.0 Integrated mode and the .NET Framework version 3.0 or later, you can use the following classes and members that are not available in Classic mode:The SubStatusCode() property of the HttpResponse object, which lets you set codes that are useful when failed request tracing is configured. For more information, see Troubleshooting Failed Requests Using Failed Request Tracing in IIS 7.0.The Headers() property of the HttpResponse object, which provides access to response headers.The IsPostNotification() and CurrentNotification() properties of the HttpContext object, which are used when you provide handlers for HttpApplication events.The Headers and ServerVariables properties of the HttpRequest object, which are write-enabled.

Videos from YouTube
Title: ASP.NET 2.0 Nested GridView
Categories: Screencast,Simple,Gridview,2.0,Example,Howto,Nested,Sample,ASP.NET,

Published on: 2/22/2007 10:55:45 AM
Title: Data Access in the ASP.NET 2.0 Framework
Categories: 2.0,Walther,Data,Framework,Stephen,Howto,the,Access,Windows,Programming,in,ASP.NET,

Published on: 10/25/2007 7:32:57 PM
Title: ASP.Net (VB.Net) Session Variable ArrayList - Shalvin
Categories: Tech,VB.Net,Shalvin,.Net,Session,ArrayList,Microsoft,Variable,

Published on: 2/2/2008 10:58:58 PM
Title: asp asp.net programacion tutorial master pages c#
Categories: c#,video,pages,asp.net,Film,master,tutorial,asp,programacion,

Published on: 11/3/2006 8:19:39 AM
Title: AJAX Y ASP.NET
Categories: Howto,AJAX,ASP.NET,

Published on: 5/26/2007 2:39:34 PM

ASP.NET Configuration

2008-09-19T01:30:00.001-05:00

Using the features of the ASP.NET configuration system, you can configure all of the ASP.NET applications on an entire server, a single ASP.NET application, or individual pages or application subdirectories. You can configure features, such as authentication modes, page caching, compiler options, custom errors, debug and trace options, and much more.The following sections describe the features of the ASP.NET configuration system.For information about configuring .NET Framework client applications, see Configuring Applications.Note:The features of the ASP.NET configuration system only apply to ASP.NET resources. For example, Forms Authentication only restricts access to ASP.NET files, not to static files or ASP (classic) files unless those resources are mapped to ASP.NET file name extensions. Use the configuration features of Internet Information Services (IIS) to configure non-ASP.NET resources. For information, see Working with the IIS Metabase and IIS Metabase Property Reference. Configuration FilesASP.NET configuration data is stored in XML text files that are each named Web.config. Web.config files can appear in multiple directories in ASP.NET applications. These files allow you to easily edit configuration data before, during, or after applications are deployed on the server. You can create and edit ASP.NET configuration files by using standard text editors, the ASP.NET MMC snap-in, the Web Site Administration Tool, or the ASP.NET configuration API.ASP.NET configuration files keep application configuration settings separate from application code. Keeping configuration data separate from code makes it easy for you to associate settings with applications, change settings as needed after deploying an application, and extend the configuration schema.For more information about how data is organized in ASP.NET configuration files, see ASP.NET Configuration Files. Available configuration settings are described in the ASP.NET Configuration Settings.Configuration File Hierarchy and InheritanceEach Web.config file applies configuration settings to the directory that it is in and to all of the child directories below it. Settings in child directories can optionally override or modify settings that are specified in parent directories. Configuration settings in a Web.config file can optionally be applied to individual files or subdirectories by specifying a path in a location element.The root of the ASP.NET configuration hierarchy is the systemroot\Microsoft.NET\Framework\versionNumber\CONFIG\Web.config file, which includes settings that apply to all ASP.NET applications that run a specific version of the .NET Framework. Because each ASP.NET application inherits default configuration settings from the root Web.config file, you need to create Web.config files only for settings that override the default settings.Note:The root Web.config file inherits some basic configuration settings from the Machine.config file, which is located in the same directory. Some of these settings cannot be overridden in Web.config files. For more information, see ASP.NET Configuration File Hierarchy and Inheritance.At run time, ASP.NET uses the Web.config files to hierarchically compute a unique collection of configuration settings for each incoming URL request. These settings are calculated only once and then cached on the server. ASP.NET detects any changes to the configuration files and then automatically applies those changes to the affected applications, restarting the applications in most cases. Hierarchical configuration settings are automatically calculated and cached again whenever a configuration file in the hierarchy is changed. The IIS server does not have to be restarted for the changes to take effect unless the processModel section has been changed.For more information about how the ASP.NET configuration hierarchy works, see ASP.NET Configuration File Hierarchy and Inheritance and ASP.NET Configuration Scenarios.Directly Editing Configuration FilesYou can use a text editor or an XML editor to edit the configuration files directly. For proper syntax, see the reference topics in the configuration sections in ASP.NET Configuration Settings and General Configuration Settings (ASP.NET).

ASP.NET Configuration
The ASP.NET configuration system features an extensible infrastructure that enables you to define configuration settings at the time your ASP.NET applications are first deployed so ...
more ...
go to website
Cached

Web Site Administration Tool Security Tab
ASP.NET Configuration ... Use the Security tab of the Web Site Administration Tool to manage rules for ...
more ...
go to website
Cached

Configuration and Deployment - ASP.NET Forums
Microsoft’s Joe Stagner recommends the following books on ASP.NET configuration and deployment.
more ...
go to website
Cached

ASP.NET Wiki: Configuration
Microsoft portal site for the ASP.NET development community. Download Visual Web Developer, post to the forums, read ASP.net blogs and learn about ASP.net.
more ...
go to website
Cached

ASP.NET.4GuysFromRolla.com: Encrypting Configuration Information in ...
This article, by Scott Mitchell, examines how to encrypt portions of the Web.config file in an ASP.NET 2.0 application.
more ...
go to website
Cached

Create Master Pages in ASP.NET 2.0
configuration> configuration> ASP.NET 2.0 also allows you to nest master pages. For example, you might want to define the overall ...
more ...
go to website
Source: VisualStudio Magazine
NewsDateTime: 9/16/2008

Add Reports and Charts to Web Pages
The ASP.NET 2.0 version of Visual Studio 2005's ReportViewer control and its Report Designer let Web page developers ... four basic steps: embed the ReportViewer server control; specify a report data source with the Table Adapter Configuration ...
more ...
go to website
Source: VisualStudio Magazine
NewsDateTime: 9/12/2008

Windows IT Pro Innovators Share Their Successes
Rowdy’s solution consists of a combination of ASP and ASP.NET, plus several Microsoft utilities (adsutil.vbs, iisvdir ... The solution handles multiple site-configuration options, including basic sites, FrontPage-extended sites, multimedia ...
more ...
go to website
Source: WinInfo
NewsDateTime: 9/8/2008

on IT managers fear job loss after data breach
... analysing source code and supports many different languages, including C/C++, Java/JSP,.NET (C#, VB.NET, ASP.NET) Classic ... It is based on three primary views that reflect configuration, triage and analysis respectively. The product performed very well ...
more ...
go to website
Source: Securecomputing.net.au
NewsDateTime: 9/6/2008

Windows XP SP3 Continues a Legacy of Failure
Embedding Flash Games in Web Sites » Software Review – NetAdvantage For .NET Suite- NetAdvantage For ASP.NET 2008 Volume ... remove it again, winds up hanging at the same spot. I reboot yet again, hit F8 to try to bring up "Last Known Good Configuration ...
more ...
go to website
Source: Blogcritics.org
NewsDateTime: 9/7/2008

Configuration ToolsThe ASP.NET configuration system provides tools that make application configuration easier than using a text editor because they include error detection.ASP.NET MMC Snap-inThe Microsoft Management Console (MMC) snap-in for ASP.NET provides a convenient way to manipulate ASP.NET configuration settings at all levels on a local or remote Web server. The ASP.NET MMC snap-in uses the ASP.NET configuration API, but it simplifies the process of editing configuration settings by providing a graphical user interface (GUI). In addition, the tool supports the ASP.NET configuration API features that control whether settings can be inherited by Web applications, and manage the dependencies between levels of the configuration hierarchy.Note:To use the ASP.NET MMC snap-in, you must log on to the computer with an account that has administrative privileges.The ASP.NET MMC snap-in appears as an ASP.NET tab on the property sheet of a virtual directory.For more information, see MMC Snap-In for ASP.NET.Web Site Administration ToolThe Web Site Administration Tool allows anyone with administrative privileges for the Web site to manage the configuration settings for that Web site. The Web Site Administration Tool is designed to provide a user-friendly, graphical editing tool for the configuration settings that are most commonly used in individual Web sites. Because the tool uses a browser-based interface, it allows you to change Web site settings remotely, which is useful for administering a site that is already deployed to a production Web server, such as a hosted Web site.The Web Site Administration Tool differs from the ASP.NET MMC snap-in in several ways. For instance, the ASP.NET MMC snap-in is ideal for administrator-level configuration because it provides access to the entire hierarchy of configuration files on the Web server instead of the configuration settings for a single Web site. Also, you must be an administrator to use the ASP.NET MMC snap-in, whereas the Web Site Administration Tool only allows individual Web site owners to configure the Web.config file in the root directory of sites to which they have administrative privileges. Finally, you cannot use the ASP.NET MMC snap-in to administer IIS remotely, but the browser interface for the Web Site Administration Tool allows remote configuration for versions of IIS beginning with IIS 6.0.The Web Site Administration Tool includes a tabbed interface that groups related configuration settings on the following tabs:A Security tab, which contains settings to help secure Web-application resources and to manage user accounts and roles.A Profile tab, which contains settings to manage how visitor information is gathered by the Web site.An Application tab, which contains settings to manage configuration elements that affect ASP.NET applications.A Provider tab, which contains settings to add, edit, delete, test, or assign application providers.The Web Site Administration Tool is automatically installed with the .NET Framework version 2.0 and later. For information about how the tool works, see ASP.NET Web Site Administration Tool.Command-line ToolsThe .NET Framework includes command-line tools that perform specific configuration operations. For example, the Aspnet_regiis.exe tool allows you to specify which version of the .NET Framework applies to your ASP.NET application. For more information, see .NET Framework Tools. ASP.NET Configuration APIThe ASP.NET configuration system provides a complete managed interface for programmatically configuring ASP.NET applications without directly editing the XML configuration files. In addition, the ASP.NET configuration API does the following:Simplifies administrative tasks by providing an integrated view of data from all levels of the configuration hierarchy.Supports deployment tasks, including creating configurations and configuring multiple computers with one script.Provides a single programming interface for developers who build ASP.NET applications, console applications and scripts, Web-based management tools, and MMC snap-ins.Prevents developers and administrators from making invalid configuration settings.Allows you to extend the configuration schema. You can define new configuration parameters and write configuration section handlers to process them.Provides static methods for obtaining configuration information from the application that is currently running, and non-static methods for obtaining configuration information from a separate application. Using static methods allows your application to run faster, but these methods can only be used from within the application about which you are obtaining configuration data.For more information, see ASP.NET Configuration API. Configuration SecurityThe ASP.NET configuration system helps protect configuration files from access by unauthorized users. ASP.NET configures IIS to deny access to any browser that requests access to the Machine.config or Web.config files. HTTP access error 403 (Forbidden) is returned to any browser that attempts to request a configuration file directly.Additionally, configuration files in one ASP.NET application are prevented from accessing configuration settings in other ASP.NET applications unless your configuration application is running in Full trust under an account that has permissions to read the configuration file in the other application.

Videos from YouTube
Title: ASP.NET 2.0 Nested GridView
Categories: Screencast,Simple,Gridview,2.0,Example,Howto,Nested,Sample,ASP.NET,

Published on: 2/22/2007 10:55:45 AM
Title: Data Access in the ASP.NET 2.0 Framework
Categories: 2.0,Walther,Data,Framework,Stephen,Howto,the,Access,Windows,Programming,in,ASP.NET,

Published on: 10/25/2007 7:32:57 PM
Title: ASP.Net (VB.Net) Session Variable ArrayList - Shalvin
Categories: Tech,VB.Net,Shalvin,.Net,Session,ArrayList,Microsoft,Variable,

Published on: 2/2/2008 10:58:58 PM
Title: asp asp.net programacion tutorial master pages c#
Categories: c#,video,pages,asp.net,Film,master,tutorial,asp,programacion,

Published on: 11/3/2006 8:19:39 AM
Title: AJAX Y ASP.NET
Categories: Howto,AJAX,ASP.NET,

Published on: 5/26/2007 2:39:34 PM

ASP.NET Login Controls

2008-09-19T01:26:00.001-05:00

The ASP.NET login controls provide a robust login solution for ASP.NET Web applications without requiring programming. By default, login controls integrate with ASP.NET membership and forms authentication to help automate user authentication for a Web site. For information about how to use ASP.NET membership with forms authentication, see Introduction to Membership.By default, the ASP.NET login controls work in plain text over HTTP. If you are concerned about security, use HTTPS with SSL encryption. For more information about SSL, see Configuring SSL on a Web Server or a Web Site in the IIS documentation.Note:Login controls might not function correctly if the Method of the ASP.NET Web page is changed from POST (the default) to GET.You can customize the contents of several ASP.NET login controls by specifying control templates and adding your own controls to the user interface (UI) of the control, or by replacing or removing optional controls not required for the UI of the control.You can also use the style properties of login controls as well as themes and skins to tailor the appearance of the control.Securing Login ControlsUpdated: November 2007ASP.NET login controls enable you to offer a solution for controlling access to Web pages based on user authentication, membership, and roles. Login controls include the CreateUserWizard control, Login control, LoginStatus control, LoginView control, PasswordRecovery control and ChangePassword control. The information in this topic describes how to improve the security of the login controls through best practices in configuration and coding.While following coding and configuration best practices can improve the security of your application, it is also important that you continually keep your Web server computer up to date with the latest security patches for Microsoft Windows and Internet Information Services (IIS), as well as any patches for Microsoft SQL Server or other data sources.

ASP.NET Login Controls Overview
The ASP.NET login controls provide a robust login solution for ASP.NET Web applications without requiring programming. By default, login controls integrate with ASP.NET membership ...
more ...
go to website
Cached

ASP.NET Login Controls Overview
The ASP.NET login controls work together to provide for your ASP.NET Web applications a robust login solution that requires no programming. By default, login controls integrate ...
more ...
go to website
Cached

Login Control in ASP.NET 3.5
In this step by step tutorial, I am going to discuss the Login control available in ASP.NET 3.5. ... Login Control in ASP.NET 3.5 By Raj Beniwal July 28, 2008. In this step by step ...
more ...
go to website
Cached

Login Control Adapter: ASP.NET 2.0 CSS Friendly Control Adapters 1.0
The adapters are currently turned on. Do you want to keep them enabled?
more ...
go to website
Cached

ASP.NET Login Control with C# - ASP.NET Forums
Hi to all. I'm new using the Login control. I'm trying to use this so it can connect to MYSQL Database with a Username and Password from that DB, but don't know how this works.
more ...
go to website
Cached

Secure ASP.NET sites with Membership API
The Membership API provides methods for providing this functionality, and these methods are tied to the Login controls available for use on ASP.NET Web Forms. What ASP.NET 2.0 features simplify your projects? What features would you like to see added ...
more ...
go to website
Source: Zd Net Asia.com
NewsDateTime: 9/5/2008

The Login ControlThe Login control displays a user interface for user authentication. The Login control contains text boxes for the user name and password and a check box that allows users to indicate whether they want the server to store their identity using ASP.NET membership and automatically be authenticated the next time they visit the site.The Login control has properties for customized display, for customized messages, and for links to other pages where users can change their password or recover a forgotten password. The Login control can be used as a standalone control on a main or home page, or you can use it on a dedicated login page.If you use the Login control with ASP.NET membership, you do not need to write code to perform authentication. However, if you want to create your own authentication logic, you can handle the Login control's Authenticate event and add custom authentication code. The LoginView ControlThe LoginView control allows you to display different information to anonymous and logged-in users. The control displays one of two templates: the AnonymousTemplate or the LoggedInTemplate. In the templates, you can add markup and controls that display information appropriate for anonymous users and authenticated users, respectively.The LoginView control also includes events for ViewChanging and ViewChanged, which allow you to write handlers for when the user logs in and changes status. The LoginStatus ControlThe LoginStatus control displays a login link for users who are not authenticated and a logout link for users who are authenticated. The login link takes the user to a login page. The logout link resets the current user's identity to be an anonymous user.You can customize the appearance of the LoginStatus control by setting the LoginText and LoginImageUrl properties. The LoginName ControlThe LoginName control displays a user's login name if the user has logged in using ASP.NET membership. Alternatively, if your site uses integrated Windows authentication, the control displays the user's Windows account name. The PasswordRecovery ControlThe PasswordRecovery control allows user passwords to be retrieved based on the e-mail address that was used when the account was created. The PasswordRecovery control sends an e-mail message containing a password to the user.You can configure ASP.NET membership to store passwords using non-reversible encryption. In that case, the PasswordRecovery control generates a new password instead of sending the original password to the user.You can also configure membership to include a security question that the user must answer to recover a password. If you do, the PasswordRecovery control asks the question and checks the answer before recovering the password.The PasswordRecovery control requires that your application can forward e-mail message to a Simple Mail Transfer Protocol (SMTP) server. You can customize the text and format of the e-mail message sent to the user by setting the MailDefinition property.Note:Password information sent in an e-mail message is sent as clear text.The following example shows a PasswordRecovery control declared in an ASP.NET page with MailDefinition property settings to customize the e-mail message. The CreateUserWizard ControlThe CreateUserWizard control collects information from potential users. By default, the CreateUserWizard control adds the new user to the ASP.NET membership system.The CreateUserWizard control gathers the following user information:User namePasswordConfirmation of passwordE-mail addressSecurity questionSecurity answerThis information is used to authenticate users and recover user passwords, if necessary.Note:The CreateUserWizard control is inherited from the Wizard control.The following example shows a typical ASP.NET declaration for the CreateUserWizard control: The ChangePassword ControlThe ChangePassword control allows users to change their password. The user must first supply the original password and then create and confirm the new password. If the original password is correct, the user password is changed to the new password. The control also includes support for sending an e-mail message about the new password.The ChangePassword control includes two templated views that are displayed to the user. The first is the ChangePasswordTemplate, which displays the user interface used to gather the data required to change the user password. The second template is the SuccessTemplate, which defines the user interface that is displayed after a user password has been successfully changed.The ChangePassword control works with authenticated and non-authenticated users. If a user has not been authenticated, the control prompts the user for a login name. If the user is authenticated, the control populates the text box with the user's login name.

Videos from YouTube
Title: ASP.NET 2.0 Nested GridView
Categories: Screencast,Simple,Gridview,2.0,Example,Howto,Nested,Sample,ASP.NET,

Published on: 2/22/2007 10:55:45 AM
Title: Data Access in the ASP.NET 2.0 Framework
Categories: 2.0,Walther,Data,Framework,Stephen,Howto,the,Access,Windows,Programming,in,ASP.NET,

Published on: 10/25/2007 7:32:57 PM
Title: ASP.Net (VB.Net) Session Variable ArrayList - Shalvin
Categories: Tech,VB.Net,Shalvin,.Net,Session,ArrayList,Microsoft,Variable,

Published on: 2/2/2008 10:58:58 PM
Title: asp asp.net programacion tutorial master pages c#
Categories: c#,video,pages,asp.net,Film,master,tutorial,asp,programacion,

Published on: 11/3/2006 8:19:39 AM
Title: AJAX Y ASP.NET
Categories: Howto,AJAX,ASP.NET,

Published on: 5/26/2007 2:39:34 PM

Detect Browser Types in ASP.NET Web Pages

2008-09-19T00:15:00.001-05:00

In your application, you might need to determine what type of browser a user is viewing pages with, and perhaps determine if the browser supports certain features.Note:ASP.NET can automatically determine browser capabilities and use this information to render appropriate HTML markup for ASP.NET server controls. o detect browser types in an ASP.NET pageQuery the Browser property, which contains an HttpBrowserCapabilities object. This object gets information from the browser or client device during an HTTP request, telling your application the type and level of support the browser or client device offers. The object in turn exposes information about browser capabilities using strongly typed properties and a generic name-value dictionary.The following code example shows how you can displays browser information the information in a text box on the page.Note:The properties exposed by the HttpBrowserCapabilities object indicate inherent capabilities of the browser, but do not necessarily reflect current browser settings. For example, the Cookies property indicates whether a browser inherently supports cookies, but it does not indicate whether the browser that made the request has cookies enabled.

How to: Detect Browser Types in ASP.NET Web Pages
Different browsers and different versions of the same browsers support different features. In your application, you might need to determine what type of browser a user is viewing ...
more ...
go to website
Cached

How Do I: Detect Browser Capabilities in ASP.NET Web Pages : The ...
How Do I: Detect Browser Capabilities in ASP.NET Web Pages ... in the HttpBrowserCapabilities object such as the type of browser and ...
more ...
go to website
Cached

CodeProject: Detect the browser using ASP.NET and C#. Free source code ...
... browser type that clients use; Author: Agus Kurniawan; Section: ASP.NET; Chapter: Web ... Detect the browser using ASP.NET and C# By ... for ASP.NET using C# language: <%@ Page ...
more ...
go to website
Cached

CodeProject: Browser Detection using ASP.NET. Free source code and ...
... detect browser type in ASP.NET; Author: Chris Maunder; Section: ASP.NET; Chapter: Web ... ASP.NET test page; Download Owen Brady's NUnit test library; The old method: Determining browser type in ASP. In web ...
more ...
go to website
Cached

BrowserCaps and other Browser Testing/Detection Resources
BrowserCaps and other Browser Testing/Detection Resources BrowserCaps XML for ASP.Net -- accurately detect Mozilla/Firefox ... is working, copy my sample test page into your web ...
more ...
go to website
Cached

Autodetection of Browser TypesBy default, the ASP.NET page framework determines browser capabilities by reading the user-agent information passed from the browser to the server during a request. (This information is available as the UserAgent property of the HttpRequest object.) The page matches the user-agent information against agent entries in configuration files and browser definition files.Note:The browserCaps section of configuration files (.config) has been deprecated in the .NET Framework version 2.0. For backward compatibility, the configuration settings in this section are still effective if they are set at the application level, but are merged with the information contained in browser definition files (.browser) located in the machine-level %SystemRoot%\Microsoft.NET\Framework\versionNumber\CONFIG\Browsers folder and any existing application-level App_Browser folders. For more information, see Browser Definition File Schema (browsers Element).When the page finds a match between the current user-agent information and user agents listed in the file, it can read the corresponding browser capabilities, such as whether the browser supports scripting, styles, frames, and so on. Based on these capabilities, the controls on the page render Web controls using appropriate markup, such as XHTML, HTML 3.2, and so on. If ASP.NET is rendering HTML, it can determine whether to render recent (cascading style sheet-compliant) or earlier (non-CSS-compliant) versions of HTML elements. For older browsers, ASP.NET renders formatting information using elements (for example, a font element) rather than using CSS styles. Overriding Browser Type DetectionIf you want to explicitly control how the page is rendered instead of relying on automatic browser detection, you can set the page's ClientTarget property. You can set the property declaratively as an attribute of the @ Page directive for that page, or you can set it programmatically.The value of the ClientTarget property is an alias for the type of browser you want to render the page for. For example, to force the page to render for Microsoft Internet Explorer 6.0, you can use the alias uplevel. The alias must be defined in the clientTarget section of the configuration file. The predefined defaults are ie5, ie4, uplevel, and downlevel.By specifying the alias downlevel, you can force the page to render HTML 3.2-compatible elements no matter what browser has requested the page. Similarly, by specifying uplevel, you can force the page to render CSS style attributes even for older browser versions.You can create additional aliases by defining them in the Machine.config or Web.config file, which enables you to create custom browser definitions. For more information, see ASP.NET Configuration Settings. AJAX-enabled ASP.NET Controls and FeaturesAJAX-enabled features in ASP.NET are compatible with most modern browsers and run with the default security settings for these browsers. These controls and features require that the browser be able to run client script. The UpdatePanel and ScriptManager controls are examples of AJAX-enabled controls. For a list of compatible browsers and of recommended security settings for AJAX-enabled controls and features, see Browser Security Settings for AJAX Enabled ASP.NET Pages.Note:You can use the properties exposed by the HttpBrowserCapabilities object to determine whether a browser supports ECMAScript (JScript, JavaScript).For an overview of AJAX features in ASP.NET, see Adding AJAX and Client Capabilities Roadmap. Client ScriptSome functionality of ASP.NET server controls depends on being able to run client script. The client script is automatically generated and sent as part of the page, if the browser is capable of executing script. Even so, some users might have turned off script execution in their browsers, and will therefore not be able to fully use the control's capabilities. For more information, see Client Script in ASP.NET Web Pages. Working with Earlier Versions of BrowsersBrowsers are split into two groups, which are sometimes referred to as "uplevel" browsers (newer versions) and "downlevel" browsers (earlier versions). These groups define the type of native support that a browser offers, and they generally determine the presentation and behavior of a Web page.Browsers that are considered "uplevel" usually support at least the following:ECMAScript (JScript, JavaScript) version 1.2.HTML version 4.0.The Microsoft Document Object Model (MSDOM).Cascading style sheets (CSS)."Downlevel" browsers and client devices support the following only:HTML version 3.2The server control properties listed in the following table render differently in uplevel and downlevel browsers.Server control propertyRendering behavior in uplevel and downlevel browsersAccessKeyThis property does not work on any downlevel browsers for any controls. It is not HTML 4.0 and works only in Internet Explorer 4.0 or later.BackColorThis property works on downlevel browsers for only certain controls: Table, Panel, GridView, Calendar, and ValidationSummary. It also works for CheckBoxList, RadioButtonList, and DataList if the layout is in a Table control. In general, only controls that render as a table element can output a background color in HTML 3.2, whereas almost anything can in HTML 4.0. For controls that render span elements, including Label controls, validator controls, and list controls in Flow mode, BackColor works in Internet Explorer 5 and later but not in Internet Explorer 4.0.BorderColorThis property works on downlevel browsers only for the same table-based controls as BackColor. However, it is output as the bordercolor attribute, which is not part of the HTML 3.2 standard. Some browsers support this attribute, including Internet Explorer 3.0 and later, but not all browsers do.BorderStyleThis property does not work on any downlevel browsers. There is no equivalent to it in HTML 3.2.BorderWidthThis property works only in controls that render as an HTML table element (Table, Panel, GridView, and Calendar) or as an img element (Image, AdRotator). BorderWidth only works on downlevel browsers if specified in pixels; otherwise, it is always rendered as either border=1 or border=0. Also, BorderWidth only works with table-based controls if GridLines is set to a value other than None. This is because there is no way to specify a border without gridlines in HTML 3.2. For controls that render span elements, including Label controls, validator controls, and list controls in Flow mode, BorderWidth works in Internet Explorer 5 or later, but not in Internet Explorer 4.0.CssClassThis property is always rendered as the class attribute, regardless of the browser. Most uplevel browsers recognize the class attribute.EnabledThis property is used to specify whether a control raises its events and functions. In Internet Explorer 4.0 or later, setting Enabled to false has the effect of making the control appear unavailable and locked from input, using the disabled=true attribute.Font-Bold, Font-Italic, Font-Strikeout and similar propertiesThese properties are rendered as style attributes for uplevel browsers (for example, Font-Weight for bold and Font-Style for italic) and as independent elements (for example, b and i) for downlevel browsers.Font-SizeThis property works on downlevel browsers for all controls only if named font sizes are used (Small, Smaller, and so on). In uplevel browsers, this property is rendered as a style attribute; in downlevel browsers, it is rendered as a font element.Font-OverlineThis property does not work on any downlevel browser.ForeColorThis property works on downlevel browsers for all controls except Image, AdRotator, HyperLink, and LinkButton. For downlevel browsers, ForeColor is rendered by using font elements.HeightThis property does not work on downlevel browsers for Label controls, validator controls, HyperLink controls, or LinkButton controls. Height also does not work for CheckBoxList, RadioButtonList, and DataList controls if the layout for those controls is set to Flow. Only pixel and percentage measurements work.For table-based controls, height on inner tables is not rendered for downlevel browsers because the Height attribute has been deprecated in HTML 4.01. This results in a slightly different appearance between the uplevel and downlevel rendering. The most obvious difference will be if BackColor is set on the SideBarStyle property: in uplevel the BackColor appears to be the entire length of that column and in downlevel browsers it will only be as long as required to accommodate the text buttons.TabIndexThis property does not work on any downlevel browsers for any controls. It is not HTML 4.0 and only works in Internet Explorer 4.0 or later.ToolTipThis property does not work on any downlevel browsers.WidthThis property does not work on downlevel browsers for Label, HyperLink, LinkButton, or validator controls. Width also does not work for CheckBoxList, RadioButtonList, and DataList controls if the layout is set to Flow. Only pixel and percentage measurements work.

Videos from YouTube
Title: ASP.NET 2.0 Nested GridView
Categories: Screencast,Simple,Gridview,2.0,Example,Howto,Nested,Sample,ASP.NET,

Published on: 2/22/2007 10:55:45 AM
Title: Data Access in the ASP.NET 2.0 Framework
Categories: 2.0,Walther,Data,Framework,Stephen,Howto,the,Access,Windows,Programming,in,ASP.NET,

Published on: 10/25/2007 7:32:57 PM
Title: ASP.Net (VB.Net) Session Variable ArrayList - Shalvin
Categories: Tech,VB.Net,Shalvin,.Net,Session,ArrayList,Microsoft,Variable,

Published on: 2/2/2008 10:58:58 PM
Title: asp asp.net programacion tutorial master pages c#
Categories: c#,video,pages,asp.net,Film,master,tutorial,asp,programacion,

Published on: 11/3/2006 8:19:39 AM
Title: AJAX Y ASP.NET
Categories: Howto,AJAX,ASP.NET,

Published on: 5/26/2007 2:39:34 PM

ASP.NET Web Server Control Event Model

2008-09-19T00:09:00.001-05:00

An important feature of ASP.NET is that it allows you to program Web pages using an event-based model that is similar to that in client applications. As a simple example, you can add a button to an ASP.NET Web page and then write an event handler for the button's click event. Although this is common in Web pages that work exclusively with client script (by handling the button's onclick event in dynamic HTML), ASP.NET brings this model to server-based processing.Events raised by ASP.NET server controls work somewhat differently than events in traditional HTML pages or in client-based Web applications. The difference arises primarily because of the separation of the event itself from where the event is handled. In client-based applications, events are raised and handled on the client. In ASP.NET Web pages, however, events associated with server controls originate on the client (browser) but are handled on the Web server by the ASP.NET page.For events raised on the client, the ASP.NET Web control event model requires that the event information be captured on the client and an event message transmitted to the server, through an HTTP post. The page must interpret the post to determine what event occurred and then call the appropriate method in your code on the server to handle the event.ASP.NET handles the task of capturing, transmitting, and interpreting the event. When you create event handlers in an ASP.NET Web page, you can typically do so without thinking about how the event information is captured and made available to your code. Instead, you can create event handlers in much the same way you would in a traditional client form. However, there are some aspects of event handling in ASP.NET Web pages that you should be aware of.

ASP.NET Web Server Control Event Model
An important feature of ASP.NET is that it allows you to program Web pages using an event-based model that is similar to that in client applications. As a simple example, you can ...
more ...
go to website
Cached

ASP.NET Server Control Event Model
Events raised by ASP.NET server controls work somewhat differently than events in traditional client forms or in client-based Web applications.
more ...
go to website
Cached

ASP.NET AJAX > ASP.NET AJAX Extensibility > Adding Client Capabilities ...
... Model (DOM) elements by using a client control ... event of the DOM element. Creating the Web Server Control. A Web server control that includes client features by using ASP.NET 2 ... Web server control in an ASP.NET ...
more ...
go to website
Cached

ASP.NET Extensions > ASP.NET Controls for Silverlight > MediaPlayer ...
ASP.NET MediaPlayer Server Control Introduction. The ASP.NET ... client script class (based on the model used in the ASP.NET ... Studio to create the MediaPlayer control and use Web ...
more ...
go to website
Cached

ASP.NET MVC Framework - ScottGu's Blog
... years with ASP.NET is built-in support for developing web applications using a model ... The server control model also ... postback model? Will ASP.NET MVC support using existing server ...
more ...
go to website
Cached

Microsoft Outlines Pricing, Packaging and Licensing for Windows Server ...
... nears the final stages of Windows Server 2008 development and the Feb. 27, 2008, worldwide launch event ... give customers greater control ... Services (IIS) 7.0, ASP.NET, and the Microsoft .NET Framework, Windows Web Server 2008 helps ...
more ...
go to website
Source: PR Newswire
NewsDateTime: 11/14/2007

Event Set for Server Controls and PagesBecause most ASP.NET server control events require a round trip to the server for processing, they can affect the performance of a page. Therefore, server controls offer a limited set of events, usually only click-type events. Some server controls support change events. For example, the CheckBox Web server control raises a CheckedChanged event in server code when the user clicks the box. Some server controls support more abstract events. For example, the Calendar Web server control raises a SelectionChanged event that is a more abstract version of a click event.Events that occur often (and can be raised without the user knowing it), such as an onmouseover event, are not supported for server controls. ASP.NET server controls can still call client-side handlers for those events, as explained later under ASP.NET Web Server Control Event Model.Controls and the page itself also raise life-cycle events at each processing step, such as Init, Load, and PreRender. You can take advantage of these life-cycle events in your application. For example, in a page's Load event, you can set default values for controls. Event ArgumentsServer-based ASP.NET page and control events follow a standard .NET Framework pattern for event-handler methods. All events pass two arguments: an object representing the object that raised the event, and an event object containing any event-specific information. The second argument is usually of type EventArgs, but for some controls is of a type specific to that control. For example, for an ImageButton Web server control, the second argument is of type ImageClickEventArgs, which includes information about the coordinates where the user has clicked.Note:Events for the page (for example, the page's Load event) can accept the standard two arguments, but no values are passed in these arguments. Postback and Non-Postback Events in Server ControlsIn server controls, certain events, typically click events, cause the page to be posted back immediately to the server. Change events in HTML server controls and Web server controls, such as the TextBox control, do not immediately cause a post. Instead, they are raised the next time a post occurs.Note:If the browser supports it, validation controls can check user input using client script, without a round trip to the server. For details, see Validating User Input in ASP.NET Web Pages.After a page has been posted back, the page's initialization events (Page_Init and Page_Load) are raised, and then control events are processed. You should not create application logic that relies on the change events being raised in a specific order unless you have detailed knowledge of page event processing. For details, see ASP.NET Page Life Cycle Overview.If it useful for your application, you can specify that change events cause the page to post. Web server controls that support a change event include an AutoPostBack property. When this property is true, the control's change event causes the page to post immediately, without waiting for a click event. For example, by default, a CheckBox control's CheckedChanged event does not cause the page to be submitted. However, if you set the control's AutoPostBack property to true, as soon as a user clicks the check box, the page is sent to the server for processing.Note:For the AutoPostBack property to work properly, the user's browser must be set to allow scripting. This is the default in most cases. However, some users disable scripting for security reasons. For details, see Client Script in ASP.NET Web Pages. Forwarded EventsWeb server controls such as the Repeater, DataList, GridView, FormView, and DetailsView controls can contain button controls that themselves raise events. For example, each row in a GridView control can contain one or more buttons created dynamically by templates.Rather than each button raising an event individually, events from the nested controls are forwarded to the container control. The container in turn raises a generic ItemCommand event with parameters that allow you to discover which individual control raised the original event. By responding to this single event, you can avoid having to write individual event handlers for child controls.The ItemCommand event includes the two standard event arguments, an object referencing the source of the event and an event object containing event-specific information.Note:The GridView, DataList, and other data controls support additional events, such as EditCommand, DeleteCommand, and UpdateCommand, that are special cases of forwarded events.With buttons, you can use the CommandArgument property to pass a user-specified string to the event handler to help you identify what button raised the event. For example, in a DataList control, buttons raise the ItemCommand event. You can set the CommandArgument property of each button to a different value—perhaps one button's value is "ShowDetails" and another button's value is "AddToShoppingCart"—and then capture those values in the event handler later. Binding Events to MethodsAn event is a message like "a button has been clicked". In your application, the message must be translated into a method call in your code. The binding between the event message and a specific method—that is, an event handler—is done using an event delegate. For more information, see Events and Delegates.In ASP.NET Web pages, you do not need to explicitly code delegates if the control is created declaratively (in markup) on the page. Event binding can be accomplished in various ways, depending on what event you are binding and what programming language you are using. For details, see How to: Create Event Handlers in ASP.NET Web Pages.Binding Control EventsFor controls declared on the page, you can bind an event to a method by setting an attribute (property) in the control's markup. The following code example shows how to bind the Click event of an ASP.NET Button control to a method named ButtonClick.When the page is compiled, ASP.NET looks for a method named ButtonClick and confirms that the method has the appropriate signature (it accepts two arguments, one of type Object and another of type EventArgs). ASP.NET then automatically binds the event to the method.In Visual Basic, you can alternatively bind events to methods using the Handles keyword in the event handler declaration, as in the following code example:Binding Page EventsASP.NET pages raise life-cycle events such as Init, Load, PreRender, and others. By default, you can bind page events to methods using a naming convention of Page_eventname. For example, to create a handler for the page's Load event, you can create a method named Page_Load. At run time, ASP.NET will find methods based on this naming convention and automatically perform the binding between the event and the method. You can use the convention of Page_eventname for any event exposed by the Page class.Note:Page event-handling methods do not require any arguments.If you prefer, you can bind handlers to events explicitly. The automatic binding of page events based on the method naming convention is controlled by a page property named AutoEventWireup. By default, for C#, this property is set to true, and ASP.NET performs the automatic lookup and binding described earlier. Alternatively, you can set this property to false by adding the attribute AutoEventWireup=false in the @ Page directive. You can then create methods with any name and bind them to page events explicitly.By default, for Visual Basic, this property is set to false. In Visual Basic, handlers are bound to events by using the Handles keyword. This keyword is inserted automatically by Visual Studio as part of the method that you create when you select a page event from the drop-down box. The following example illustrates use of the Handles keyword:One disadvantage of the AutoEventWireup attribute is that it requires that the page event handlers have specific, predictable names. This limits your flexibility in how you name event handlers. Another disadvantage is that performance is adversely affected, because ASP.NET searches for methods at run-time. For a Web site with high traffic volumes, the impact on performance could be significant.Note:If you include explicit binding for page events, be sure that the AutoEventWireup property is set to false so that the method is not called twice.Explicit Binding for Dynamic ControlsIf you create controls by declaring them in markup, you can bind events to methods using an attribute (for example, onclick) or in Visual Basic, by using the Handles keyword. If you create controls dynamically (in code), you cannot use either of these methods, because the compiler does not have a reference to the control at compilation time.In that case, you must use explicit event binding. In Visual Basic, you can use the AddHandler statement to bind an event in a dynamically created control to an existing method. In C#, you create a delegate and associate it with the control's event. The following code example shows how you can bind a method named ButtonClick to a button's Click event:C#Button b = new Button;b.Text = "Click";b.Click += new System.EventHandler(ButtonClick);Placeholder1.Controls.Add(b); Responding to Both Client and Server Events in ASP.NET Server ControlsThis topic has discussed how to work with events raised in server code. Controls render elements to the browser, and those elements can also raise client-side events that you can handle in client script. Using client script, you can add mouse and keyboard event handling to ASP.NET server controls. For more information, see Client Script in ASP.NET Web Pages and How to: Add Client Script Events to ASP.NET Web Server Controls. Application and Session EventsIn addition to page and control events, ASP.NET provides ways for you to work with life-cycle events that are raised when your application starts or stops or when an individual user's session starts or stops, including the following:Application events are raised for all requests to an application. For example, the BeginRequest event of the HttpApplication object (Application_BeginRequest) is raised when any ASP.NET Web page or XML Web service in your application is requested. This event allows you to initialize resources that will be used for each request to the application. A corresponding event, the EndRequest event of the HttpApplication object (Application_EndRequest), provides you with an opportunity to close or otherwise dispose of resources used for the request.Session events are similar to application events (there is a Start and an End event), but are raised with each unique session within the application. A session begins when a user requests a page for the first time from your application and ends either when your application explicitly closes the session or when the session times out.Note:The Session_End event is not raised under all circumstances. For details, see End.

Videos from YouTube
Title: ASP.NET 2.0 Nested GridView
Categories: Screencast,Simple,Gridview,2.0,Example,Howto,Nested,Sample,ASP.NET,

Published on: 2/22/2007 10:55:45 AM
Title: Data Access in the ASP.NET 2.0 Framework
Categories: 2.0,Walther,Data,Framework,Stephen,Howto,the,Access,Windows,Programming,in,ASP.NET,

Published on: 10/25/2007 7:32:57 PM
Title: ASP.Net (VB.Net) Session Variable ArrayList - Shalvin
Categories: Tech,VB.Net,Shalvin,.Net,Session,ArrayList,Microsoft,Variable,

Published on: 2/2/2008 10:58:58 PM
Title: asp asp.net programacion tutorial master pages c#
Categories: c#,video,pages,asp.net,Film,master,tutorial,asp,programacion,

Published on: 11/3/2006 8:19:39 AM
Title: AJAX Y ASP.NET
Categories: Howto,AJAX,ASP.NET,

Published on: 5/26/2007 2:39:34 PM

ASP.NET Page Class

2008-09-18T23:51:00.001-05:00

When an ASP.NET page is requested and renders markup to a browser, the code that runs is not solely the code that you created for your page. Instead, at run time, ASP.NET generates and compiles one or more classes that actually perform the tasks required to run the page. This topic provides an overview of the code that is generated at run time. Generating and Running the Page Class CodeAn ASP.NET page runs as a unit, combining the server-side elements in a page, such as controls, with the event-handling code you have written. You do not have to precompile pages into assemblies. ASP.NET dynamically compiles pages and runs them the first time they are requested by a user. If there are any changes to the page or resources the page depends on, the page is automatically recompiled. The class or classes that the compiler creates depends on whether the page uses the single-file model or the code-behind model.ASP.NET also supports precompilation of a Web site to enhance performance and perform error checking as well as to support site deployment. For more information, see ASP.NET Web Site Precompilation Overview. Precompilation works for both single-file and code-behind page models, and the compiler output is the same for both models. Single-File PagesIn a single-file page, the markup, server-side elements, and event-handling code are all in a single .aspx file. When the page is compiled, the compiler generates and compiles a new class that derives from the base Page class or a custom base class defined with the Inherits attribute of the @ Page directive. For example, if you create a new ASP.NET Web page named SamplePage1 in your application's root directory then a new class named ASP.SamplePage1_aspx is derived from the Page class. For pages inside of application subfolders, the subfolder name is used as part of the generated class. The generated class contains declarations for the controls in the .aspx page and contains your event handlers and other custom code.After page generation, the generated class is compiled into an assembly, the assembly is loaded into the application domain, and then the page class is instantiated and executed to render output to the browser. If you make changes to the page that would affect the generated class—whether by adding controls or modifying your code—the compiled class code is invalidated and a new class is generated

ASP.NET Page Class Overview
When an ASP.NET page is requested and renders markup to a browser, the code that runs is not solely the code that you created for your page. Instead, at run time, ASP.NET generates ...
more ...
go to website
Cached

ASP.NET Wiki: Internationalization: How to: Adding localization ...
How to: Adding localization support to ASP.NET web by extending Page class (C#)
more ...
go to website
Cached

ASP.NET - Wikipedia, the free encyclopedia
After the request has been processed, the instance of the page class is discarded and with it the entire control tree. State management. ASP.NET applications are hosted in a web ...
more ...
go to website
Cached

ASP.NET AJAX > Client Reference > Sys.WebForms > PageRequestManager ...
Documentation for: ASP.NET Ajax Version 1.0. This documentation is for a previous version. For the current released version, see the ASP.NET Ajax documentation ...
more ...
go to website
Cached

ASP.NET AJAX > Web Services > Exposing Web Services to Client Script
... the whole page, because only data is transferred between the browser and the Web server. ASP.NET AJAX automatically creates JavaScript proxy classes for ... methods to an ASP.NET page ...
more ...
go to website
Cached

Create Master Pages in ASP.NET 2.0
Opening up the code-behind file for the first time on a master page, you'll see code that looks pretty much like your normal ASP.NET page code: Partial Class BasicMasterPage_master Sub Page_Load (ByVal sender As Object, _ ByVal e As System ...
more ...
go to website
Source: VisualStudio Magazine
NewsDateTime: 9/16/2008

Build Printable ASP.NET Pages
Rename the file and all the class name references to this new name (by default, VS.NET creates a Page class that matches the ... You can get the same result with fewer pages by creating a more generic printing ASP.NET page to handle all print requests ...
more ...
go to website
Source: VisualStudio Magazine
NewsDateTime: 9/5/2008

ASP.NET MVC Framework and Routing
The ASPX page has a code-behind class but usually does all of its work through markup and ASP-style code blocks. In ASP.NET MVC framework the view is an extremely thin object:

<%= Html.Encode(ViewData["Message"]) %>

Communication between ...
more ...
go to website
Source: Dr. Dobb's Portal News
NewsDateTime: 9/8/2008

Hacking SQL Server
... Microsoft has updated ASP and ADO under the .NET platform, both ASP.NET and ... The ASP page would build the SQL statement to look something like this: ... the Events tab and remove all items from the “Selected Event Class ...
more ...
go to website
Source: MCPmag.com
NewsDateTime: 8/18/2008

Code-Behind PagesIn the code-behind model, the page's markup and server-side elements, including control declarations, are in an .aspx file, while your page code is in a separate code file. The code file contains a partial class—that is, a class declaration with the keyword partial (Partial in Visual Basic) indicating that it contains only some of the total code that makes up the full class for the page. In the partial class, you add the code that your application requires for the page. This typically consists of event handlers, but can include any methods or properties that you need.The inheritance model for code-behind pages is slightly more complex than that for single-file pages. The model is this:The code-behind file contains a partial class that inherits from a base page class. The base page class can be the Page class, or it can be another class that derives from Page.The .aspx file contains an Inherits attribute in the @ Page directive that points to the code-behind partial class.When the page is compiled, ASP.NET generates a partial class based on the .aspx file; this class is a partial class of the code-behind class file. The generated partial class file contains declarations for the page's controls. This partial class enables your code-behind file to be used as part of a complete class without requiring you to declare the controls explicitly.Finally, ASP.NET generates another class that inherits from the class generated in Step 3. This second generated class contains the code required to build the page. The second generated class and the code-behind class are compiled into an assembly that runs to render output to the browser.

Videos from YouTube
Title: ASP.NET 2.0 Nested GridView
Categories: Screencast,Simple,Gridview,2.0,Example,Howto,Nested,Sample,ASP.NET,

Published on: 2/22/2007 10:55:45 AM
Title: Data Access in the ASP.NET 2.0 Framework
Categories: 2.0,Walther,Data,Framework,Stephen,Howto,the,Access,Windows,Programming,in,ASP.NET,

Published on: 10/25/2007 7:32:57 PM
Title: ASP.Net (VB.Net) Session Variable ArrayList - Shalvin
Categories: Tech,VB.Net,Shalvin,.Net,Session,ArrayList,Microsoft,Variable,

Published on: 2/2/2008 10:58:58 PM
Title: asp asp.net programacion tutorial master pages c#
Categories: c#,video,pages,asp.net,Film,master,tutorial,asp,programacion,

Published on: 11/3/2006 8:19:39 AM
Title: AJAX Y ASP.NET
Categories: Howto,AJAX,ASP.NET,

Published on: 5/26/2007 2:39:34 PM

ASP.NET Web Page Code Model

2008-09-18T23:46:00.001-05:00

An ASP.NET Web page consists of two parts:Visual elements, which include markup, server controls, and static text.Programming logic for the page, which includes event handlers and other code.ASP.NET provides two models for managing the visual elements and code — the single-file page model and the code-behind page model. The two models function the same, and you can use the same controls and code for both models........ Choosing a Page ModelThe single-file and code-behind page models are functionally the same. At run time, the models execute the same way, and there is no performance difference between them. Choosing a page model therefore depends on other factors, such as how you want to organize the code in your application, whether it is important to separate page design from coding, and so on.Note:Examples you read in the documentation are often presented as single-file pages. This is primarily as a convenience for the reader, because it avoids having to illustrate two files for each example. The fact that you find single-file examples in the documentation should not be interpreted to mean that single-file pages are favored over code-behind pages or that there is some other inherent benefit to single-file pages.Advantages of Single-File PagesAs a rule, the single-file model is suitable for pages in which the code consists primarily of event handlers for the controls on the page.Advantages of the single-file page model include the following:In pages where there is not very much code, the convenience of keeping the code and markup in the same file can outweigh other advantages of the code-behind model. For example, it can be easier to study a single-file page because you can see the code and the markup in one place.Pages written using the single-file model are slightly easier to deploy or to send to another programmer because there is only one file.Because there is no dependency between files, a single-file page is easier to rename.Managing files in a source code control system is slightly easier, because the page is self-contained in a single file.Advantages of Code-Behind PagesCode-behind pages offer advantages that make them suitable for Web applications with significant code or in which multiple developers are creating a Web site.Advantages of the code-behind model include the following:Code-behind pages offer a clean separation of the markup (user interface) and code. It is practical to have a designer working on the markup while a programmer writes code.Code is not exposed to page designers or others who are working only with the page markup.Code can be reused for multiple pages. Compilation and DeploymentCompilation and deployment of both single-file and code-behind pages is similar. At its simplest, you copy the page to the target server. If you are working with code-behind pages, you copy both the .aspx page and the code file. When the page is first requested, ASP.NET compiles the page and runs it. Note that in both scenarios you deploy source code with the markup.Alternatively, you can precompile your Web site. In that case, ASP.NET produces object code for your pages that you can copy to the target server. Precompilation works for both single-file and code-behind models, and the output is the same for both models.

ASP.NET Web Page Code Model
An ASP.NET Web page consists of two parts: ... An ASP.NET Web page consists of two parts: Visual elements, which include markup, server controls, and static text.
more ...
go to website
Cached

Web Forms Code Model
An ASP.NET Web page consists of two parts: ... An ASP.NET Web page consists of two parts: Visual elements, which include markup, server controls, and static text.
more ...
go to website
Cached

ASP.NET - Wikipedia, the free encyclopedia
ASP.NET pages, known officially as "web forms", are the main building block for application ... ASP.NET's code-behind model marks a departure from Classic ASP in that it encourages ...
more ...
go to website
Cached

INFO: ASP.NET Code-Behind Model Overview
... article provides a brief overview of the code-behind model, which is introduced in ASP.NET. ... use Microsoft Visual Studio .NET to create ASP.NET Web Forms, code-behind pages ...
more ...
go to website

ASP.NET Library - ASP.NET Articles, Code and Tips
ASP.NET Articles, Code and Tips ... In an asynchronous model, all the server side ... to use GDI to draw an image or text on your ASP.NET Web page
more ...
go to website
Cached

Visual Studio 2008 SP1 is icing, and more cake
... improved IntelliSense and code ... two ways of creating the data model: one using LINQ to SQL and the other using the Entity Framework. Check the Dynamic Data in Action section of the official ASP.Net page ... create routing tables for your ASP.Net Web ...
more ...
go to website
Source: Computerworld
NewsDateTime: 9/11/2008

ASP.NET MVC Framework and Routing
... Castle MonoRail, the ASP.NET MVC framework is based on an extremely popular Web adaptation of the Model-View ... The ASPX page has a code-behind class but usually does all of its work through markup and ASP-style code blocks. In ASP.NET MVC framework the ...
more ...
go to website
Source: Dr. Dobb's Portal News
NewsDateTime: 9/8/2008

Building Line-of-Business Apps with Silverlight 2
... have authentication built into its core, you can easily re-use the ASP.NET authentication model ... This can be done through a typical ASP.NET login page which acts as the gateway to ... the service wrapper, you must also enable the service in the web ...
more ...
go to website
Source: Dr. Dobb's Portal News
NewsDateTime: 9/3/2008

Secure ASP.NET sites with Membership API
... forms-based model. An issue with these approaches is the amount of development work that's necessary to get them working. In ASP.NET 2.0 ... name on the page ... the following code snippet shows how the CreateUserWizard control may be used on an ASP.NET Web ...
more ...
go to website
Source: Zd Net Asia.com
NewsDateTime: 9/5/2008

What's New
... with ASP.NET features and one configuration store for all Web platform configuration settings across IIS 7.0 and ASP.NET. A flexible extensibility model enables customization such as the addition of new modules using either native or managed code.
more ...
go to website
Source: MSDN Online Deutschland
NewsDateTime: 8/13/2008

The Single-File Page ModelIn the single-file page model, the page's markup and its programming code are in the same physical .aspx file. The programming code is in a script block that contains the attribute runat="server" to mark it as code that ASP.NET should execute.The following code example shows a single-file page containing a Button control and a Label control. The highlighted portion shows the Click event handler for the Button control inside a script block.C#<%@ Page Language="C#" %> Single-File Page Model The scriptblock can contain as much code as the page requires. The code can consist of event handlers for controls on the page (as in the example), methods, properties, and any other code that you would normally use in a class file. At run time, a single-file page is treated as a class that derives from the Page class. The page does not contain an explicit class declaration. Instead, the compiler generates a new class that contains the controls as members. (Not all controls are exposed as page members; some are children of other controls.) The code in the page becomes part of the class; for example, event handlers that you create become members of the derived Page class.Because all code in the page becomes members of the Page class, you cannot have a using statement in your code. Instead, add a @ Import directive that specifies the namespace to import. You might also need to add a reference to the DLL that contains the namespace.For more information, see ASP.NET Page Class Overview. The Code-Behind Page ModelThe code-behind page model allows you to keep the markup in one file—the .aspx file—and the programming code in another file. The name of the code file varies according to what programming language you are using.Note:Not all .NET programming languages allow you to create code-behind files for ASP.NET Web pages. Languages must support partial classes. For example, J# does not support partial classes, and therefore does not support creating code-behind files for ASP.NET pages.For example, if you are working with a page named SamplePage, the markup is in the file SamplePage.aspx and the code is in a file named SamplePage.aspx.vb (for Visual Basic), SamplePage.aspx.cs (for C#), and so on.Note:The code-behind model used in the .NET Framework version 2.0 is different than the one used in earlier versions.In the code-behind model, the example used in the preceding section for the single-file page would be in two parts. The markup would be in one file (in this example, SamplePage.aspx) and would be similar to the single-file page, as shown in the following code example.C#<%@ Page Language="C#" CodeFile="SamplePage.aspx.cs" Inherits="SamplePage" AutoEventWireup="true" %> Code-Behind Page Model There are two differences in the .aspx page between the single-file and the code-behind models. In the code-behind model, there is no script block with the runat="server" attribute. (The page can contain script blocks without the runat="server" attribute if you want to write client-side script in the page.) The second difference is that the @ Page directive in the code-behind model contains attributes that reference an external file (SamplePage.aspx.vb or SamplePage.aspx.cs) and a class. These attributes link the .aspx page to its code.The code is in a separate file. The following code example shows a code-behind file that contains the same Click event handler as the example for the single-file page.C#using System;using System.Web;using System.Web.UI;using System.Web.UI.WebControls;public partial class SamplePage : System.Web.UI.Page{ protected void Button1_Click(object sender, EventArgs e) { Label1.Text = "Clicked at " + DateTime.Now.ToString(); }}The code-behind file contains the complete class declarations in the default namespace. However, the class is declared with the partial keyword, which indicates that the class is not contained entirely in one file. Instead, when the page runs, the compiler reads the .aspx page and the file it references in the @ Page directive, assembles them into a single class, and then compiles them as a unit into a single class.The partial class file inherits from the page Page class.

Videos from YouTube
Title: ASP.NET 2.0 Nested GridView
Categories: Screencast,Simple,Gridview,2.0,Example,Howto,Nested,Sample,ASP.NET,

Published on: 2/22/2007 10:55:45 AM
Title: Data Access in the ASP.NET 2.0 Framework
Categories: 2.0,Walther,Data,Framework,Stephen,Howto,the,Access,Windows,Programming,in,ASP.NET,

Published on: 10/25/2007 7:32:57 PM
Title: ASP.Net (VB.Net) Session Variable ArrayList - Shalvin
Categories: Tech,VB.Net,Shalvin,.Net,Session,ArrayList,Microsoft,Variable,

Published on: 2/2/2008 10:58:58 PM
Title: asp asp.net programacion tutorial master pages c#
Categories: c#,video,pages,asp.net,Film,master,tutorial,asp,programacion,

Published on: 11/3/2006 8:19:39 AM
Title: AJAX Y ASP.NET
Categories: Howto,AJAX,ASP.NET,

Published on: 5/26/2007 2:39:34 PM

WebForms 3.5

Track and quash bugs

Why Track bugs.

How to track (and quash) the bugs

Three Parts To Every Good Bug Report

Top Ten Tips for Bug Tracking (Painless Bug Tracking by Joel Spolsky.)

Related quotes and Links

Domain Modeling

The Challenge of Complexity

The domain layer

Glossary of Domain-Driven Design Terms

WebForms validation

Understanding the Difference Between Server-Side and Client-Side Validation

.NET to the Rescue!

Client-Side Validation

About the Script Library

Disabling Client-Side Validation

The Client-Side Sequence

The Client-Side API

Some useful ASP.NET validation links

Microsoft Web Platform Installer 2.0 RC

What's Inside?

Popular Web Apps

.NET Framework

IIS and Extensions

SQL Server

Visual Web Developer

Extra and Goodies

Microsoft Web Platform Installer

Windows Web Application Gallery

Summary

Web Platform Installer

Deploying ASP.NET Web Services

Items Published with an ASP.NET Web Service

WCF Web Services Vs ASP.Net Web Services

The Simplest C# code to execute a stored procedure or a SQL statement.

Random string generator web service

Object-relational mapping (ORM)

NHibernate key features:

Internet Information Services

Versions

History

Security

Authentication Mechanisms

Version 7.0

IIS Media Pack

IIS 7.0 Components

Protocol Listeners

Hypertext Transfer Protocol Stack (HTTP.sys)

World Wide Web Publishing Service (WWW service)

How WWW Service works in IIS 6.0

HTTP Administration and Configuration

Performance Monitoring

Process Management

How WWW Service works in IIS 7.0

Windows Process Activation Service (WAS)

Configuration Management in WAS

Process Management

IIS 7.0 Modules

Native Modules

HTTP Modules

Security Modules

Content Modules

Compression Modules

Caching Modules

Logging and Diagnostics Modules

Managed Support Modules

Managed Modules

IIS 7.0 Request Processing

IIS 7.0 Application Pools

Integrated application pool mode

Classic application pool mode

HTTP Request Processing in IIS 7.0

Links

Data modeling process and steps

Web Deployment Projects with Visual Studio 2008

Web Deployment Projects

Feature Summary

Installing Web Deployment Projects

New Menu Commands