VS2010学习

Simplifying Entity Framework: Data-Driven Design

革命 — Tue, 29 Dec 2009 02:47:13 GMT

Posted by Oleg Sych
December 27, 2009

As described on MSDN, ADO.NET Entity Framework is a set of technologies that enables developers to work with data in the form of domain-specific objects and properties, such as customers and customer addresses without having to concern themselves with the underlying database tables and columns where this data is stored. Developers can use Entity SQL and traditional ADO.NET reader/adapter/dataset patterns or the new LINQ to Entities to write their code. With LINQ to Entities, the Entity Framework generates strongly-typed entity classes you can use in application code and rely on the runtime to figure out how the data needs to be retrieved from the underlying data source.

Design of Entity Framework has been inspired by the traditional methodology of relational database design which suggests creating a conceptual (class) model, transforming it into logical (relational) model and finally into physical database model. While these activities are typically performed during design and initial implementation of the information system, the Entity Framework implements the physical model, makes the conceptual model a first-class citizen and explicitly defines the mapping model.

Conceptual model defines entities and their relationships from the application point of view. This model is defined using Conceptual Schema Definition Language (CSDL) and stored in a separate .csdl file or as part of a combined .edmx file in your project.
Storage model defines entities and their relationships from the database point of view. This model is defined using Store Schema Definition Language (SSDL) and stored in a separate .ssdl file or as part of a combined .edmx file in your project.
Mapping model defines how conceptual model translates into storage model. It is defined using Mapping Specification Language (MSL) and stored in a separate .msl file or as part of a combined .edmx file in your project.

The Entity Framework uses these XML-based models to transform create, read, update, and delete operations against entities and relationships in the conceptual model to equivalent operations in the data source. The storage and mapping models can change as needed without requiring changes to the conceptual model, data classes, or application code. Because storage models are provider-specific, you can work with a consistent conceptual model across various data sources. The Entity Data Model even supports mapping entities in the conceptual model to stored procedures in the data source.

What is wrong with this picture?

Entity Framework was designed to overcome the object-relational impedance mismatch and allow you to hide a difficult-to-use legacy database schema behind a modern, object-oriented entity model and make developers more productive. This description almost sounds to good to be true. Unfortunately, just like other frameworks designed to solve complex problems, the Entity Framework tends to make simple things difficult.

Having three separate database layers (or models) in the Entity Data Model means having each entity represented three times, each from a different point of view. Each time you need to make a change in your database model, which also needs to be implemented in the application, you have to make it three times. Take adding a new column to a table as an example. No matter in which order you do it, you still have to add a new property to the conceptual model, a new column to the storage model and a new mapping from one to the other. This task is tedious and error prone even with the best modeling tools imaginable. Unfortunately, Entity Framework designer limits you to a single diagram, which gradually becomes more difficult to use as the number of entities increases, becoming virtually useless when it exceeds 50.

In simplistic terms, this all means that Entity Data Model is three times as complex as a traditional database model. To implement all but trivial logic, either one developer has to understand all three models or you have to have two or more people involved in implementing it. In the end, you have to spend three times more effort to develop and maintain the EDM, you are three times more likely to make mistakes, i.e. the cost of having the EDM in your solutions is three times higher than the cost of a solution that uses a single hypothetical data model.

What is the alternative?

Majority of information systems in existence today are built using relational databases and data-oriented code. A tremendous amount of tooling, knowledge and experience has been developed over the past two decades by the industry, making low-cost development resources readily available. Although solving the object-relational impedance mismatch sounds very good in theory, in practice, the overall cost of such a solution is typically higher, in part due to additional effort required to maintain three separate database models and in part due to additional knowledge and experience required from developers.

However, the existing as well as new information systems could benefit tremendously from having a modern, strongly-typed, LINQ-enabled, automatically generated data access layer (DAL). Such a DAL would allow to significantly reduce the amount of plumbing code developers have to write today with DbConnection, DbDataReader and DataSet classes without requiring significant changes to the application architecture. In other words, as long as the effort required to maintain such a DAL is less than the effort required to maintain the data access code manually, we can take advantage of the language and data access enhancements offered by the current version of the .NET framework while reducing the overall cost of the information systems.

Entity Framework DAL generator in T4 Toolbox

In order to implement an automatically generated DAL based on Entity Framework today, you would have to use EdmGen. Unfortunately, it does not give you access to some of the options supported by the framework. The new version of T4 Toolbox includes a code generator that encapsulates the functionality built into Entity Framework and makes it available in T4-based code generation scripts. This code generator is based on the idea of using database modeling tools built into Visual Studio, which are easier to use and unlike Entity Framework’s own designer, are proven to work on the number of tables typically found in real-world databases. In the rest of this article we will review the process of using this code generator to illustrate its pros and cons.

Getting Started

In order to follow this sample, you need to have Visual Studio 2008 or 2010, Standard Edition or higher, SQL Server Express 2005 or later, T4 Toolbox and T4 Editor installed on your computer.

Create a new C# or Visual Basic console application project.
Add a new item to your project and select the Code Generation->Entity Framework Database template in the Add New Item dialog.

Enter the desired database name and click Add.

This template adds a new, empty SQL Express database to your project. Unfortunately, Visual Studio automatically displays the the Data Source Configuration Wizard whenever you add a .mdf file to a project. Normally, you would use it to create a data access layer with built-in visual designers. In this case, we have the entire data access layer generated automatically for us.

Click Cancel in the Data Source Configuration Wizard.

Notice that a number of files have been added to your project, including a .mdf file (SQL database), a .ldf file (SQL log), a .tt file (code generator), a .cs/.vb file (entity classes and object context), a .Views.cs/.vb file (precompiled entity views), a .csdl file (conceptual model), a .ssdl file (storage model) and a .msl file (mapping model). If you are using Visual Basic, you will need to click “Show All Files” button in solution explorer in order to see the files nested under .mdf and .tt.

Database Modeling

Visual Studio includes a subset of database modeling functionality from SQL Server Management Studio, including database diagrams, table designers, key and relationship designers.

Double-click the .mdf file in Solution Explorer (shown above). This will cause the database to be opened in Server Explorer (shown on the left).
Right-click Database Diagrams in Server Explorer and select Add New Diagram from the context menu.
The first time you add a diagram to a database, Visual Studio will prompts you to create database objects required for diagramming. Click Yes when prompted.

Use the diagram to create a new database model.

Database diagrams allow you to quickly model tables and their relationships. You can use the Properties Window of Visual Studio to configure individual tables and columns selected on the design surface. The toolbar and context menu provide access to commands that allow you to model keys, relationships, indexes, unique and check constraints, as well as customize the look of your diagram for display and print, add text annotations and more. Also, unlike with Entity Framework designer, you can create additional diagrams when the number of tables is too big to fit on a single diagram. This seemingly trivial feature is crucial for large database models.

Having the model database included in your project has several important benefits. It is placed under source control with the rest of the files in your project, giving you the ability to go back to previous versions when necessary. Although it may seem excessive to check in an entire database in source control, the size of a .mdf file is comparable to the size of a similar database model stored in a Visio .vsd file or an Enterprise Architect .eap file. You can also use the database file itself to store any seed data you need and with “Copy to Output Directory” option turned on, the database deployment becomes a simple xcopy on greenfield projects.

Make sure to save changes you make in any database diagram or designers you open before you proceed to the next step of generating code.

Code Generation

Double-click the .tt file in Solution Explorer (shown above) to open it in the T4 Editor.

<#@ template language=“C#“ hostspecific=“True“ #>

<#@ output extension=“cs“ #>

<#@ include file=“T4Toolbox.tt“ #>

<#@ include file=“T4Toolbox\EntityFramework.tt“ #>

var generator = new EntityFrameworkGenerator();

generator.DatabaseFile = “Database1.mdf”;

generator.Run();

<#@ template language=“VB“ hostspecific=“True“ #>

<#@ output extension=“vb“ #>

<#@ include file=“T4Toolbox.tt“ #>

<#@ include file=“T4Toolbox\EntityFramework.tt“ #>

Dim generator As New EntityFrameworkGenerator()

generator.DatabaseFile = “Database1.mdf”

generator.LanguageOption = LanguageOption.GenerateVBCode

generator.Run()

This is a T4 code generation script that creates a new instance of EntityFrameworkGenerator, configures its properties and uses it to generate all model and code files required for a ready-to-use data access layer based on Entity Framework. Note that this script is not directly associated with the database file in the Visual Studio project and has to be run manually.

Right-click the .tt file in Solution Explorer and select Run Custom Tool from its context menu to trigger the code generation.
Double-click the generated .cs/.vb file in Solution Explorer to open it in the Visual Studio editor. If you are using Visual Basic, you will need to click “Show All Files” in the toolbar of Solution Explorer in order to see this file.

This generated file contains definitions of both entity classes and object context required to access the database using LINQ to Entities.

Also note the other generated code file, in our example Database1.Views.cs/.vb. This file contains pre-generated views, which significantly improve reduce the amount of time required to connect to a database using an Entity Framework object context for the first time. This can take tens of seconds even on a medium-size database with a hundred of tables. While this performance hit does not have a meaningful effect on applications in production due to Entity Framework caching the views on per-AppDomain basis, this delay is a significant problem for developers who need to recompile and restart the application frequently. The Entity Framework designer does not generate views automatically, causing much frustration for developers and, perhaps, being the main reason for Entity Frameworks reputation of having poor performance.

Coding

At this point, you have everything you need to start coding against your new database using LINQ to Entities.

Double-click Program.cs or Module.vb in Solution Explorer.
Enter the following code in the editor.

using System;

using System.Linq;

namespace EfDalSampleCS

{

class Program

{

static void Main(string[] args)

{

var context = new Database1Entities();

context.AddToProducts(new Product() { ProductName = “Internet Explorer”, UnitPrice = 0 });

context.AddToProducts(new Product() { ProductName = “Windows 7 Ultimate”, UnitPrice = 319.99M });

context.SaveChanges();

var products = from p in context.Products select p;

foreach (var product in products)

{

Console.WriteLine(“{0} ({1})”, product.ProductName, product.UnitPrice);

}

Imports System

Imports System.Linq

Imports EfDalSampleVB.EfDalSampleVB

Module Module1

Sub Main()

Dim context As New Database1Entities

context.AddToProducts(New Product() With {.ProductName = “Internet Explorer”, .UnitPrice = 0})

context.AddToProducts(New Product() With {.ProductName = “Windows 7 Ultimate”, .UnitPrice = 319.99})

context.SaveChanges()

Dim products = From p In context.Products Select p

For Each product In products

Console.WriteLine(“{0} ({1})”, product.ProductName, product.UnitPrice)

End Sub

End Module

Press F5 to run the program. You may want to set a breakpoint and observe execution of the program in Visual Studio debugger.

A couple of things are worth explaining. How does this code know which database to connect to? The answer lies in the default constructor of Database1Entities class, which is generated to use a connection string with the same name. This connection string was automatically added to the configuration file when we added Database1.mdf to our project.

<?xml version=“1.0” encoding=“utf-8“?>

<add name=“Database1Entities”

connectionString=

”

metadata=res://*/Database1.csdl

|res://*/Database1.ssdl

|res://*/Database1.msl;

provider=System.Data.SqlClient;

provider connection string=

‘

Data Source=.\SQLEXPRESS;

AttachDbFilename=|DataDirectory|\Database1.mdf;

Integrated Security=True;

User Instance=True

‘

”

providerName=“System.Data.EntityClient” />

</connectionStrings>

</configuration>

Metadata section of the connection string specifies that .csdl, .ssdl and .msl files are embedded as resources in the executable. Provider section of the connection string instructs Entity Framework to use ADO.NET SQL Client to connect to the database. The provider connection string section contains the traditional connection string and indicates that SQL Server Express edition will be used to automatically attach the database file located in DataDirectory. For windows applications (such as the console app we have here), DataDirectory token refers to the directory where the executable is located. Our database file is copied to the output directory because the “Copy to Output Directory” option was set to “Copy Always” for the .mdf file in our project.

Customizing the list of database objects exposed by DAL

You may have noticed that among the generated entity classes, we also have sysdiagrams, which was actually the table created by SQL Server when we added the first diagram to our database. Unless you are planning to access this table from your application, it would be best to remove it from the data access layer. You can can do that by adding a filter to the code generator.

Add the following code to the .tt file before generator.Run() method is called.

generator.Filters.Add(

new EntityStoreSchemaFilterEntry(

null, // catalog

null, // schema

“sys%”, // name

EntityStoreSchemaFilterObjectTypes.Table,

EntityStoreSchemaFilterEffect.Exclude));

generator.Filters.Add( _

New EntityStoreSchemaFilterEntry( _

Nothing, _

“sys%”, _

EntityStoreSchemaFilterObjectTypes.Table, _

EntityStoreSchemaFilterEffect.Exclude))

This code creates a filter entry object that indicates that all tables whose name starts with “sys” should be excluded from the generated DAL. EntityFrameworkGenerator class contains a property called Filters to which you can add one or more filter entries and make sure that only appropriate database objects are accessible through the DAL. For complete details, please refer to EntityStoreSchemaFilterEntry, EntityStoreSchemaFilterObjectTypes and EntityStoreSchemaFilterEffect on MSDN.

Unfortunately, not all of the possible combinations of object types and filter effects are supported by the underlying Entity Framework generator. For example, creating a filter entry to include functions in the DAL has no effect because the functions are only automatically generated in the storage model (.ssdl) and not in the conceptual model (.csdl). In other words, you cannot access stored procedures using the DAL produced by this code generator in its current version.

Customizing pluralization of entity class names and set names

Entity Framework 4.0 in Visual Studio 2010 provides an option to automatically convert table names to singular form in names of entity classes and to plural form in names of entity set properties. Without this automatic conversion, both entity name and set name would be either in plural form or singular form, depending on the naming convention you use in your database model. This poses a significant limitation in Entity Framework 3.5 in Visual Studio 2008, making the resulting DAL more confusing. A complete discussion of pluralization by the Entity Framework team is available on their blog.

The code generator in T4 Toolbox has the pluralization turned on by default in Visual Studio 2010. If you need to generate the DAL without pluralization, perhaps for compatibility reasons, you can turn this option off by adding the following line to the .tt file before generator.Run() method is called.

generator.Pluralize = false;

generator.Pluralize = False

This option is not available in Visual Studio 2008 because the underlying code generator in Entity Framework does not support it.

Customizing generation of foreign key properties

Entity Framework 4.0 in Visual Studio 2010 also provides an option to generate and use foreign key properties (such as Order.ProductId) in addition to navigation properties (such as Order.Product). Detailed discussion of foreign key properties is also available on the Entity Framework team blog.

The code generator in T4 Toolbox offers an option to generate foreign key properties, however you need to turn it on explicitly, by adding the following line to the .tt file before generator.Run() method is called.

generator.GenerateForeignKeyProperties = true;

generator.GenerateForeignKeyProperties = True

This option is not available in Visual Studio 2008 because the underlying code generator in Entity Framework does not support it.

Customizing location of the model database

When storing the model database under source control is not desirable on your project, you can change the code generator to use a standalone database as the model.

Change the .tt file to specify a connection string instead of the database file.

<#@ template language=“C#“ hostspecific=“True“ #>

<#@ output extension=“cs“ #>

<#@ include file=“T4Toolbox.tt“ #>

<#@ include file=“T4Toolbox\EntityFramework.tt“ #>

EntityFrameworkGenerator generator = new EntityFrameworkGenerator();

generator.ConnectionString = “Server=.;Database=Northwind;Integrated Security=True”;

generator.Run();

<#@ template language=“VB“ hostspecific=“True“ #>

<#@ output extension=“vb“ #>

<#@ include file=“T4Toolbox.tt“ #>

<#@ include file=“T4Toolbox\EntityFramework.tt“ #>

Dim generator As New EntityFrameworkGenerator()

generator.ConnectionString = “Server=.;Database=Northwind;Integrated Security=True”

generator.LanguageOption = LanguageOption.GenerateVBCode

generator.Run()

When you save the modified .tt file, the DAL will be regenerated based on the metadata in the database you specified in the connection string. By default, database name determines the name of the generated object context class. Changing the name of the database from Database1 to Northwind will change the name of the context class from Database1Entities to NorthwindEntities.

Rename the .tt file to match the name of the database (Northwind.tt in our example).

Although this is not required, renaming the code generation script will make the names of the generated .csdl, .ssdl and .msl files match the name of the database and make the solution easier to understand.

Update the configuration file to match the changes made in generated code.

<?xml version=“1.0” encoding=“utf-8“?>

<add name=“NorthwindEntities”

connectionString=

”

metadata=res://*/Northwind.csdl

|res://*/Northwind.ssdl

|res://*/Northwind.msl;

provider=System.Data.SqlClient;

provider connection string=

‘

Server=.;

Database=Northwind;

Integrated Security=True;

‘

”

providerName=“System.Data.EntityClient” />

</connectionStrings>

</configuration>

In particular, the name of the connection string has to match the new name of the object context class (NorthwindEntities in this example); file names in the metadata section of the connection string have to match the names of the generated model files (Northwind.csdl, Northwind.ssdl and Northwind.msl in this example); and finally, the provider connection string section of the connection string has to point to the actual database in your current environment.

Note that database connection string is present in both .tt and .config files. In this example, the same Northwind database on local SQL server is used during both code generation and execution. You may want to use different databases for these purposes, perhaps an empty local database for code generation and a shared database for development and testing. In that case, make sure to use appropriate connection strings in the .tt and .config files.

Other customization options

Additional details about customization options are available in the T4 Toolbox documentation installed as part of the Visual Studio 2008 help collection. If you have it installed, you can click here to open the list of properties available for you to use in the code generation script.

Conclusion

ADO.NET Entity Framework allows you to access database in object-oriented manner at the cost of additional effort required to maintain conceptual, storage and mapping model. While sounding good in theory, solving the object-relational impedance mismatch in practice typically increases the cost of information systems due to additional knowledge, experience and effort it requires with tools available today. By implementing an automatically-generated, modern, strongly-typed, LINQ-enabled data access layer based on Entity Framework, we can improve developer productivity and reduce the system development cost without introducing the overhead and complexity of fully featured object-relational mapping. Unlike the tools built into Entity Framework, the database modeling functionality in Visual Studio and the code generator described in this article allow you to use Entity Framework effectively with more than just a few dozen tables. Unfortunately, due to limitations in the current version of Entity Framework, the solution described in this article does not allow accessing stored procedures and functions through the automatically generated DAL, making it inferior compared to a similar DAL based on LINQ to SQL today.

Download

Sample source code

T4 Templates: A Quick-Start Guide for ASP.NET MVC Developers

革命 — Thu, 24 Dec 2009 10:35:05 GMT

As mentioned in our recent blog post on the ASP.NET MVC Release Candidate, our code-generation features (namely, Add Controller and Add View) now use the T4 (Text Template Transformation Toolkit) templating technology behind the scenes. Because users can customize the templates to a great extent, we wanted to make a post to bring everyone up to speed on T4.

Template Locations and Template Override

The Add Controller and Add View dialogs both perform code generation that use T4 templates behind the scenes. These templates can be modified to customize the generated code from these tools. You can find the templates at the following location: [Visual Studio Install Directory]\Common7\IDE\ItemTemplates\[CSharp | VisualBasic]\Web\MVC\CodeTemplates\

You can also copy the ‘CodeTemplates’ folder into the root of your project to be able to override the templates at the above location and customize the templates on a per-project basis (alternatively, just create a folder named ‘CodeTemplates’ and under that create a folder named ‘AddController’ or ‘AddView’). Note that you can choose to override some templates but not others if you so wish – the dialogs will respect the precedence of what is in your project properly. Also keep in mind that for the Add View dialog, you can add your own .tt files either at the global location or in your project and have them automatically populated in the View Content drop-down in the dialog.

Please note that when you copy the above folder (really, any time you add a .tt file) into the project, you will see warnings as follows:

Hit ‘Cancel’ so that you don’t run the T4 template (if you are adding multiple .tt files like when you copy the ‘CodeTemplates’ folder, you will have to hit ‘Cancel’ each time). This happens because as soon as the project sees a .tt file, a property on the file called ‘CustomTool’ will get set to ‘TextTemplatingFileGenerator’ What this is telling Visual Studio to do is to use the default T4 host to execute the template and create a new file (nested underneath the template) based on what’s in the template.

The generator can be a great way to have one-off file generation based on a template, or to simply play around with T4 – however, because Add View and Add Controller templates have code in them that rely on a custom template host (as you’ll see later), executing these templates with the default generator will simply generate errors. Go ahead and clear out the Custom Tool property to just be empty after copying the templates into your project.

Note: If you want to get rid of the mapping that automatically sets the Custom Tool on .tt files, you can do so through the registry – please note that if you want to restore these registry keys to their default values, you can perform a Repair from the Visual Studio installer, or add the entries back manually. Start up the registry editor (Start –> Run –> ‘regedit’) and navigate to one of the following locations depending on whether you are using a 32-bit or 64-bit install of Windows:

32-bit: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\Generators

64-bit: HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\9.0\Generators

Expand each of the nodes directly under ‘Generators’ and look for any entries named ‘.tt’. Set the registry value named ‘(Default)’ to be empty. That’s it!

If you want to override the global templates but don’t want to copy a folder named ‘CodeTemplates’ into your project (since you already have a folder by that name presumably), you can change the name of the folder Add Controller and Add View look at through a registry key. Start up the registry editor (Start –> Run –> ‘regedit’) and navigate to one of the following locations depending on whether you are using a 32-bit or 64-bit install of Windows:

32-bit: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\MVC\CodeTemplates

64-bit: HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\9.0\MVC\CodeTemplates

Change the value for ‘OverrideDir’ to what you want the tooling to look for in your project. Please note that under this folder you will still have to maintain the same hierarchy as before, with a folder named ‘AddController’ and/or a folder named ‘AddView’.

Editing T4 Templates

If you open a .tt file inside Visual Studio, you may notice they look a bit flat – like a wall of black text. We highly highly recommend you download T4 Editor, an add-on to Visual Studio made by Clarius Consulting, to provide you with syntax highlighting and some basic T4 statement completion. They have a free version called the ‘Community Edition’, as well as a much more powerful ‘Professional Edition’ – check out the feature comparison if you are interested. This add-on really makes a big difference in template authoring, as you can see below.

Anatomy of a T4 Template

The easiest way to get started with editing the templates yourself is to see how our default templates work. To that end, we’re going to go through some of the pieces of the ‘Create’ template (Create.tt) for Add View. Let’s start at the top:

These four lines are all directives.

The first line is the template directive, and its main job is to tell the T4 engine what language the template itself uses. When we say the template’s language, we don’t mean the language in which the output is written, but rather the template’s control code (for example, your template might include an if-else statement to conditionally output some line of text). The ‘HostSpecific’ attribute has to be set to ‘True’ to work with Add View or Add Controller, because otherwise the template cannot access the information the Add Controller and Add View dialogs want to provide them (things like the Type to which a strongly-typed view is bound etc)
The next line is the output directive, and it simply sets the default extension for the template’s output file by informing the template host – this isn’t particularly relevant to MVC Tools since depending on the situation the default extension may be ignored (for example, if we are dealing with a partial view, where the extension should be .ascx)
The next couple lines are both import directives, and they are like ‘using’ statements in C# or ‘Imports’ statements in VB. If your template’s code uses any classes in its code, you will need to import them here.

You can find more documentation on T4 directives here: http://msdn.microsoft.com/en-us/library/bb126421.aspx

Moving down just a bit, you will notice the following line:

On this line we are creating a new variable named ‘mvcHost’, and assigning it to a casted version of a property named ‘Host’. The ‘Host’ property is something provided to the template automatically because we set the ‘HostSpecific’ attribute to ‘True’ in the template directive above. The MVC Tools provide a custom host, so as to be able to pass information to the templates that are not available outside of the tools. To access the properties provided on our host class, the ‘Host’ property needs to be casted to our host type, which is ‘MvcTextTemplateHost’.

How is this variable used? It is actually quite straightforward:

The first thing to notice is that there is code enclosed within ‘<#’ and ‘#>’ tags. These tags are called statement blocks and are used to enclose control code. Your template may want to conditionally output certain chunks of text into the output file and keep other chunks from being outputted. Above, we have an if statement (written in C# since our template’s language was set to C# in the template directive) that opens a curly brace. This if statement’s closing curly brace shows up a few lines below on Line 17, in a different statement block. Note that this particular if statement is accessing a property on the host called ‘IsViewUserControl’, which tells the template if the user chose to go with a partial view.

All the text outside of blocks in a template are actual chunks of text that are outputted to the final file. In the screenshot above, Line 14’s text is outside of any blocks and is thus part of the output – however, it will be placed into the output file only if the if statement on Line 12 evaluates to ‘true’.

You can learn more about T4 statement blocks here: http://msdn.microsoft.com/en-us/library/bb126509.aspx

The easiest way to think of the control code in a T4 template is by sewing it together in your head into one big program. The variable we declared previously on line 6 can be used in the T4 control code that follows it – and each of these if-else branches conditionally adds some text (shown in gray) to the outputted file. The if-else statements above are checking some properties exposed by our template host to the Add View templates.

Moving a bit further down, we see a curious statement block as follows:

We declare a variable called ‘properties’ of type ‘List<string>’. How are we able to use the List type in our T4 code? It is because of this import directive we saw at the top of the template:

Line 56 then calls a method called ‘FilterProperties’ – but where is this method located? It is actually defined near the bottom of the template:

If you look carefully, unlike statement blocks, this block of code begins with ‘<#+’. This is known as a class feature blocks, and they work like this: T4 takes all the class features in your template and adds them to the class that is compiled from your template behind the scenes. This isn’t just limited to methods, but also things like properties (anything that would normally go under a class). Like a member of a class in a regular code file, these now become accessible to the rest of your template’s code.

Read more about class feature blocks here: http://msdn.microsoft.com/en-us/library/bb126541.aspx

Our default templates use the ‘FilterProperties’ method from the above screenshot to by default output markup only for some properties in the type – namely ones that are public and would also be displayed in the designer by things like GridView. This logic is identical to what you would get from calling the GridView.IsBindableType method.

The ‘IsBindableType’ method called on Line 136 is defined a bit further down in the template:

If you wanted to change which properties our templates filter out, you can modify either of these methods to your liking.

Lastly, have a look at Line 65 below:

Here, we have a new construct that begins with ‘<#=’. This is called an expression block and it is used to insert values from T4 code into the outputted text. As you can see above, we have a foreach loop that is iterating properties and defines a variable local to the loop called ‘propertyName’. Because we want to output a <th> tag for each property name, we use an expression block referencing that variable.

You can find more about expression blocks here: http://msdn.microsoft.com/en-us/library/bb126508.aspx

As you can see, the various ways through which you can selectively output text in a T4 template make T4 a very powerful tool in getting the productivity of automatic code-generation with the flexibility of customized output.

MVC Tools T4 Host Properties

The Add Controller and Add View dialogs each expose different properties to templates through the template host, as demonstrated above in our breakdown of the Create template. Here is the full list of available properties exposed by our template host, for your template to use (Note: The exact names of these properties may change between the RC and the final version):

Add Controller:

Property Name	Type	Description
ItemName	System.String	The name of the Controller class, including the ‘Controller’ suffix
NameSpace	System.String	The namespace into which the Controller is being generated
ExtraActionMethods	System.Boolean	Indicates whether or not the user checked the option in the Add Controller dialog to get extra action methods
ControllerRootName	System.String	The name of the controller class without the ‘Controller’ suffix

Add View:

Property Name	Type	Description
ItemName	System.String	The name of the view (without extension), as typed in the Add View dialog
NameSpace	System.String	The default namespace of the view’s parent folder
IsViewUserControl	System.Boolean	Evaluates to true if the user chose a partial view in the Add View dialog
IsViewContentPage	System.Boolean	Evaluates to true if the user is creating a view with a master page
IsViewPage	System.Boolean	Evaluates to true if the user is creating a regular view page
MasterPage	System.String	Path to the master page the user chose in the dialog (to be used only when IsViewContentPage is true)
ContentPlaceholder	System.String	Name of the primary content place holder into which the generated content will be placed. This is the content place holder id the user typed into the Add View dialog
ContentPlaceHolders	System.Collections.Generic.List<System.String>	A list of all content place holder ID’s in the master page, if a master page was chosen for this view
LanguageExtension	System.String	The output file’s extension (including the period)
ViewDataTypeGenericString	System.String	This is a string that is used to output the generics clause for the ‘Inherits’ attribute in the view's directive (for strongly-typed views). Example: “<MyType>” or “(Of MyType)”
ViewDataType	System.Type	This is a Type object representing the type to which a strongly-typed view is bound. It can be used to get information on the properties in the type and the like

Additionally, there are a few properties exposed by the default ‘Host’ property that you may find useful, such as the path to the template currently being executed. You can read more about those properties here: http://msdn.microsoft.com/en-us/library/microsoft.visualstudio.texttemplating.itexttemplatingenginehost_properties.aspx

Summary

We hope this article has given you enough information about T4 templates and how to effectively use them in conjunction with the tooling Visual Web Developer provides for ASP.NET MVC. There is a lot more you can do with T4 than just what we went over in this post, so check out some of the information out there (Scott Hanselman’s post is a great place to start) and see what you can come up with. PLEASE post any comments, suggestions, or questions you have. Thanks for reading!

Abhishek Mishra | Software Design Engineer | Visual Studio Web Developer

Beginning Mocking With Moq 3

革命 — Wed, 23 Dec 2009 05:36:43 GMT

Part 1

While I was at the ALT.NET and MVP summits, the one topic that came up over and over again was the fact that we don’t focus on the beginners enough. And not necessarily beginners in the sense of brand new developers, but beginners in terms of those who just haven’t been exposed to many of the concepts that we work with so often. Many of us have forgotten how hard it was to grasp some of these concepts. Since Moq 3 went final while I was out of town, I felt like doing an introduction to mocking using Moq 3 was the perfect place to start!

At this point many developers are now doing automated testing, but not necessarily unit testing. The reason I say this is that most developers don’t know how to break their applications down so that the pieces can be tested independently. Mocking is an easy way to replace dependencies during testing so that you don’t need to actually call out to a database, web service, file system, or even just another class. The idea is that you are isolating small pieces of functionality during testing, hence why they call it “unit” testing.

In order to do this you must design your classes to use virtual methods or implement interfaces. To look at a simple example let’s start off with an Order class.

public class Order

{

public int OrderId { get; set; }

public decimal OrderTotal { get; set; }

}

Very simple, so that we don’t bury the concept under tons of business logic. The first thing that we are going to do is write the order out to a file, but I want to test this functionality without having to actually write my files somewhere to a disk. To do this I am first going to create an OrderWriter class:

public class OrderWriter

{

private readonly IFileWriter fileWriter;

public OrderWriter(IFileWriter fileWriter)

{

this.fileWriter = fileWriter;

}

public void WriteOrder(Order order)

{

fileWriter.WriteLine(String.Format("{0},{1}", order.OrderId, order.OrderTotal));

}

As you can see, this class takes an IFileWriter interface in its constructor and then when “WriteOrder” is called, it formats the string and passes it to the fileWriter field. The IFileWriter interface is very simple and looks like this:

public interface IFileWriter

{

void WriteLine(string line);

}

By using this interface we have isolated the actual writing of the file to the disk from the formatting of the data that is going to be written to the disk. The tests that we wrote to form our above classes (you are using TDD, aren’t you? :-) look like this:

public class When_an_order_is_to_be_written_to_disk : ContextSpecification

{

private Order order;

private Mock<IFileWriter> mockFileWriter;

private OrderWriter orderWriter;

public override void EstablishContext()

{

order = new Order();

order.OrderId = 1001;

order.OrderTotal = 10.53M;

mockFileWriter = new Mock<IFileWriter>();

orderWriter = new OrderWriter(mockFileWriter.Object);

}

public override void Because()

{

orderWriter.WriteOrder(order);

}

[Fact]

public void it_should_pass_data_to_file_writer()

{

mockFileWriter.Verify(fw => fw.WriteLine("1001,10.53"), Times.Exactly(1));

}

In this test I am using xUnit, which uses the “Fact” attribute to label something a test. It doesn’t use a “TestFixture” attribute or anything. And it uses the class constructor for setup instead of a method with a “Setup” attribute. Personally I really like many of the design decisions that the xUnit guys took.

Lame Disclaimer

You may also notice that these tests were written in the Context/Specification manner, which I am taking a risk by using. Not because the style is risky, but because I’ll probably have 800 people ripping apart the way that I did it. Honestly though, if you have any suggestions on how these could be written in a better way, please let me know. For these tests, I tried to stick to vanilla xUnit in order to keep the new concepts as few as possible.

While these tests may look very different to you, one of the advantages of this style of test comes in when you run them:

See how you can tell what is going on? When you have multiple tests in each context, it looks even better. The more I talk to people who write tests in this style, the more I am sold on it. But anyways, this post isn’t about unit testing styles, so let’s move on!

If you go back and look at the test earlier in this post you can see that we are creating a new Order in the setup:

public override void EstablishContext()

{

order = new Order();

order.OrderId = 1001;

order.OrderTotal = 10.53M;

mockFileWriter = new Mock<IFileWriter>();

orderWriter = new OrderWriter(mockFileWriter.Object);

}

Here we are setting up the context of the tests. We create a new order, set some values, then declare a mock IFileWriter and then pass it into the OrderWriter class. So we are going to test if we can write the file to disk, but we don’t want to hit the disk. So what is the point? Right? Well, not really, when writing an order to disk in a real application there could be significant logic in how to format the file. The code to actually write the file to disk should be separately tested to make sure it works, but being able to isolate the formatting of the data for the order and test it, is very useful.

We do this by creating a new “Mock” class and pass it the interface as a generic type parameter that we want to mock. Next we create the “OrderWriter” class and pass in the mocked instance of our IFileWriter interface by accessing the Object property on the Mock<IFileWriter> object. We can’t pass the Mock<IFileWriter> instance to the OrderWriter constructor because it takes an IFileWriter, and this is why the “Object” property is available. Hate to repeat myself, but the process is this:

1. Create an instance of Moq’s “Mock” class that takes a interface or class with virtual methods as a generic parameter.

2. Tell the Mock what you want to happen, specifying parameters, and even return values. We will get deeper into this later on.

3. Get back the mocked interface which will behave in the way in which you told it to. Use this mocked interface in your code.

4. Call “Verify” or “VerifyAll” on the mock to ensure that what you said would happen actually happened. This step is not always required.

Once we get the mocked interface we can create the OrderWriter class and pass the mocked interface into it. When we pass the order into it, we will format the order and the mocked interface will get called with the formatted string representing the order. Next we want to actually perform the action that we want to test:

public override void Because()

{

orderWriter.WriteOrder(order);

}

Here we pass the order into the OrderWriter and then next we assert that the method on the IFileWriter interface was called property with the correct values:

[Fact]

public void it_should_pass_data_to_file_writer()

{

mockFileWriter.Verify(fw => fw.WriteLine("1001,10.53"), Times.Exactly(1));

}

When we call “Verify” on our mock with a lambda we are telling it to check that the call we pass to it actually occurred. The second parameter that we pass to it (which is optional) tells the mock how many times we expected it to be called. So here we are asking the mockFileWriter object if the “WriteLine” method was called with the value “1001,10.53” exactly one time. If this occurred, then the test will pass.

In this post we have looked at creating a mock class, tell it that a particular method will be called, and then verify that it actually happened. In the future posts we are going to look at setting up return values, dealing with properties, dealing with parameters that we don’t know at compile time, events, etc… So stay tuned!

Part 2

In the previous entry in this series on beginning mocking using Moq, we looked at how to create a mock and then later verify that some method was called. This is probably the most basic usage of a mocking framework, which is to simply verify a method call. One of the things that is a bit confusing when looking at a statement in a test that uses a lambda is to realize that the code you are seeing in the assertion is not actually executing. So when you see a statement like this:

mockFileWriter.Verify(fw => fw.WriteLine("1001,10.53"), Times.Exactly(1));

The lambda inside of the “Verify” method:

fw => fw.WriteLine("1001,10.53")

Is being turned into an expression tree and then analyzed by Moq, not actually being executed. Whether or not you understand what I mean by that, what you need to understand is that we are merely telling Moq what to look for, not running any code.

In order to show this a bit more clearly, what would happen if in the above code we wanted to verify that any string was passed into the “WriteLine” method, not just a particular string. Well, we simply have to call the “Verify” method like this:

mockFileWriter.Verify(fw => fw.WriteLine(It.IsAny<string>()), Times.Exactly(1));

Here you can see that we replaced the “1001,10.53” string with a method call on the static class “It”:

It.IsAny<string>())

Now it may be more obvious that this code is not being executed because it no longer looks like a simple method call. You can now see that Moq will look at this method call within the “WriteLine” method and adjust the way that it verifies this method. It will still look for exactly one call to “WriteLine” but it will accept any string passed to it, and not just the one that we had previously specified.

There are also a few other ways to verify these methods calls, such as IsRegex:

fw.WriteLine(It.IsRegex("^1001"))

Here we are matching a regex to check that the string starts with 1001. There is also one additional method called “IsInRange” which will check to see if a numerical value is within a particular range.

Verifying With Predicates

To take this a step further, we can use any predicate expression to define what we want to verify as well. For those who don’t know, a Predicate is simply a delegate that returns a boolean value. So, a variable goes in, you do some sort of check and then return a true or false. So if we wanted to check for any string that is longer than 3 characters, then we could call the “It.Is” method like this:

mockFileWriter.Verify(fw => fw.WriteLine(It.Is<string>(s => s.Length > 3)), Times.Exactly(1));

Or if we wanted to check that the string started with “1001,10.53” instead of equaling that, then we could do this:

mockFileWriter.Verify(fw => fw.WriteLine(It.Is<string>(s => s.StartsWith("1001,10.53"))), Times.Exactly(1));

There is no limit to the comparisons that we can do. We could also compare against a local variable:

string expectedValue = "1001,10.53";

mockFileWriter.Verify(fw => fw.WriteLine(It.Is<string>(s => s.StartsWith(expectedValue))), Times.Exactly(1));

This way we can keep the expected value out of the verify, making it arguably easier to read.

Property Verification

Now that you know how to verify that a method was called, what happens if we need to verify that a property was set or read? Well, it actually looks very similar to method call verification above. In order to show this, lets define a “FileName” property on the IFileWriter interface that we will set with a filename by the OrderWriter class. This is likely a poor design in a real application, but it will serve our purpose here.

So now in our OrderWriter we will do this:

public void WriteOrder(Order order)

    fileWriter.FileName = order.OrderId + ".txt";

    fileWriter.WriteLine(String.Format("{0},{1}", order.OrderId, order.OrderTotal));

Here we set the filename using the order id and then call the “WriteLine” method. So we will need another test:

[Fact]

public void it_should_set_the_file_name()

    mockFileWriter.VerifySet(fw => fw.FileName);

This test will now only pass if something is assigned to the “FileName” property. The only problem is that we could set anything to this property, it isn’t necessarily what we want. Thankfully Moq provides a way for us to check that it was set to an exact value:

mockFileWriter.VerifySet(fw => fw.FileName = "1001.txt");

Sweet. Everything works as expected. Just as with the methods, we can match against the static “It” class like this:

mockFileWriter.VerifySet(fw => fw.FileName = It.Is<string>(s => s.StartsWith("1001")));

So as you can see, properties are just as easy to work with as methods are.

Wrap Up

In this post we have taken a look at how the verification lambdas work, and how we can use Moq to verify inexact parameter values. We have also taken a look at how we can check parameters using any predicate value. Then finally we take a look at how we can verify property values as well. In future entries in this series we will take a look at returning values, events, callsbacks, etc… So stay tuned!

Part 3

In the previous part of this series, we looked at how you can verify on an interface exactly what was called using Moq’s “Verify” syntax. In this entry we are going to take a look at setting up mocks with return values.

Setting Up Return Values

If you have ever done mocking before in the past then you probably know that the “classic” way of using mocks is to setup the mock before you call it. So in the last post when we had this line:

mockFileWriter.Verify(fw => fw.WriteLine("1001,10.53"), Times.Exactly(1));

which verifies, after the fact, what was called. In the “classic” way of doing things we could have written the test like this: (In Moq 2 the method was called “Expect” not “Setup”)

[Fact]

public void it_should_pass_data_to_file_writer2()

    var order = new Order();

    order.OrderId = 1001;

    order.OrderTotal = 10.53M;

    var mockFileWriter = new Mock<IFileWriter>();

    mockFileWriter.Setup(fw => fw.WriteLine("1001,10.53")).AtMostOnce();

    var orderWriter = new OrderWriter(mockFileWriter.Object);

    orderWriter.WriteOrder(order);

    mockFileWriter.VerifyAll();

Here you can see that right after we declare the mock we call “Setup” and pass the expectation to it. We then call “AtMostOnce” to make sure that it is only called a single time. After that we actually perform our test actions. At this point though we haven’t asserted anything, so we have to call “VerifyAll” on the mock that was created. This causes all setup calls to be verified, and an exception will be raised if one of the expectations weren’t met.

So the “Verify” syntax seems so much better, we don’t need to do two calls, or remember to call “VerifyAll” after the fact. So why is the original Setup syntax still there? Well, besides backward compatibility. Part of the reason is that there is one key thing that you can’t do after the fact, and that is setting up return values on method calls. Let’s start this by creating an OrderReader class which uses an IFileReader interface. The IFileReader interface has a line called “ReadLine” which returns a string.

Since we want to mock this IFileReader and call this method on it that returns a value, we need some way to setup the return value. Thanksfully, Moq provides us with an extremely easy way to do this:

public override void EstablishContext()

    var mockFileReader = new Mock<IFileReader>();

    mockFileReader.Setup(fr => fr.ReadLine()).Returns("1002,10.34");

    orderReader = new OrderReader(mockFileReader.Object);

public override void Because()

    order = orderReader.ReadOrder();

Moq can see the return type of the method that you are passing in, and then lets you return back an instance of that type. In fact, if a method is returning another interface that you need to mock, then you can return a mock type! This let’s you build up more complex interfaces from mocks.

Now that we have setup the mock and created our order, we simply call the “ReadOrder” method and we get back an order object. All that is left to assert now is that the line from the IFileReader was parsed and turned back into an order correctly:

[Fact]

public void it_should_have_order_id_set()

    Assert.Equal(1002, order.OrderId);

[Fact]

public void it_should_have_order_total_set()

    Assert.Equal(10.34M, order.OrderTotal);

And that was easy. But I mentioned earlier that we are able to setup two mocks and have one mock returned from the other mock. How does that work?

Returning Mocks From Other Mocks

Well, it works just like you are passing a mock to any other method. So if we have two interfaces like this:

internal interface IDoSomething

    IDoSomethingElse GetSomethingElse();

internal interface IDoSomethingElse

    string GetSomeValue();

Then it is as simple as doing this:

var mockSomethingElse = new Mock<IDoSomethingElse>();

mockSomethingElse.Setup(mse => mse.GetSomeValue()).Returns("Something");

var mockSomething = new Mock<IDoSomething>();

mockSomething.Setup(ms => ms.GetSomethingElse()).Returns(mockSomethingElse.Object);

And there you have it, we have created the IDoSomethingElse mock and setup expectations on its return value. Then we mock IDoSomething and when we setup its method, we simply pass the mock.Object into the “Returns” method.

Summary

In this post we have looked at setting up return values on mocks so that we can return canned values from them to satisfy the needs of calling classes. If you are setting up return values on mocks and not really verifying anything that was called on the mock, then technically you are not mocking, but instead stubbing. I guess that is a topic for another day though. I hope you enjoyed this entry, and stay tuned for the next post when we will look at mocking multiple interfaces and callbacks.

A 26-part series of Business Apps Example for Silverlight 3 & .NET RIA Services July Update

革命 — Wed, 09 Dec 2009 17:07:49 GMT

By Brad Abrams, this demo requires:

VS2008 SP1 (Which includes Sql Express 2008)
Silverlight 3 RTM
.NET RIA Services July ‘09 Preview

download the full demo files and check out the running application.

Also check out the author’s Mix09 talk “building business applications with Silverlight 3”.

Part 1: Navigation Basics

Part 2: Rich Data Query

Part 3: Authentication

Part 4: SEO, Export to Excel and Out of Browser

Part 5: Astoria, Add Service Reference and WinForms

Part 6: Data Transfer Objects (DTOs)

Part 7: ADO.NET Data Services Based Data Store

Part 8: WCF Based Data Source

Part 9: POCO and Authentication Provider

Part 10: LinqToSql

Part 11: The Client-Only World

Part 12: DataSet

Part 13: The New Class Library Project

Part 14: Visual Basic (VB) and WPF Support

Part 15: ASP.NET MVC

Part 16: Exposing a WCF Service

Part 17: Evolving an Application

Part 18: Custom Linq Provider

Part 19: ASP.NET Dynamic Data

Part 20: NHibernate

Part 21: Hierarchical Data

Part 22: Separate Solution Files

Part 23: Azure

Part 24: Stored Procedures

Part 25: ViewModel

Part 26: Authentication and Personalization

ASP.NET 2.0 Membership, Roles, Forms Authentication, and Security Resources – ScottGu’s Blog

革命 — Wed, 09 Dec 2009 17:06:12 GMT

The following is excerpt from ScottGu’s Blog:

Getting Started with ASP.NET 2.0 Membership, Roles and Forms Authentication Video

Watch this great online video. It walks through how to add Forms Authentication (using the <asp:login> control) with a secure Membership Credential Store + Role Based Security to a site, then implement pages that enable Registration (using the <asp:createuserwizard> control) + Change Password (using the <asp:changepassword> control) + Reset Password (using the <asp:recoverypassword> control), and then authorize page access and hide menu navigation links using the role groupings of the authenticated user. The video shows how to-do all of this from scratch in only 17 minutes. You can watch it here. You can also find other great ASP.NET “how to” videos here.

ASP.NET 2.0 Membership and Role Management Overview Articles

Here are a few good tutorial articles that provide a good conceptual overview of how the new membership and role management system works.

Scott Mitchell’s: Examining ASP.NET 2.0’s Membership, Roles and Profile (Part 1)

Scott Mitchell’s: Examining ASP.NET 2.0’s Membership, Roles and Profile (Part 2)

Scott Mitchell’s: Examining ASP.NET 2.0’s Membership, Roles and Profile (Part 3)

Scott Mitchell’s: Examining ASP.NET 2.0’s Membership, Roles and Profile (Part 4)

Scott Mitchell’s: Examining ASP.NET 2.0’s Membership, Roles and Profile (Part 5)

MSDN: Explained: Forms Authentication in ASP.NET 2.0

MSDN: Explained: Windows Authentication in ASP.NET 2.0

Scott Allen’s: Membership Providers (Part 1)

Scott Allen’s: Role Providers (Part 2)

ASP.NET 2.0 Security, Membership and Role Management Book

Stefan Schackow is the ASP.NET Team technical expert and feature-owner for a lot of the core sub-systems in ASP.NET, and he owned the security, membership and role management features for ASP.NET 2.0. He has recently published an awesome book on ASP.NET Security, Membership and Roles that you can buy for $26 on Amazon here.

You can read two big recommendations of it from ASP.NET MVPs here: Dave Sussman and Christoph Wille I highly recommend getting a copy.

Setting up Membership + Roles on a SQL 2000 or SQL 2005 Server

By default ASP.NET 2.0 auto-creates and uses a SQL Express database to store Membership, Roles and Profile data. If you want to instead use a SQL 2000 or SQL 2005 database, you can easily learn how to configure it using this blog post of mine.

Don’t forget to always set the “applicationName” attribute when configuring ASP.NET Membership, Roles, Profile and other providers.

One common issue people forget to-do when registering membership and other providers is to configure the “applicationName” attribute on the provider declaration. This can prevent logins from seeming to work when you copy an application to another machine. This blog post covers this scenario more and how to fix it.

Custom Membership and Roles Providers

ASP.NET 2.0 ships with built-in SQL Server, SQL Express and Active Directory Membership and Role Providers. The source code for these built-in providers can now be downloaded from here.

The nice thing about the system is that it is entirely extensible, which means you can create and configure your own custom credential/role stores into the system as well (either using the source code from the built-in providers, or just by extending the provider contract).

The ASP.NET Provider Toolkit Site provides tons of content on how to create and build your own providers (including Membership and Role Providers). It also has a link to a fully functional Membership and Role Provider that works with Access databases. This article also discusses how to build your own Membership Provider, and can be a useful guide to integrating the membership APIs with your own existing database.

Here is a list of other free custom Membership and Roles providers (with complete source code) that I know of on the web:

SQL Database Support for ASP.NET Membership, Roles and Personalization

MySQL Support for ASP.NET Membership and Roles

SQLLite3 Support for ASP.NET Membership and Roles

Oracle Support for ASP.NET Membership, Roles and Personalization (note: this is included in the PetShop sample)

You can download and configure your application to use any of the above providers. The beauty of the system is that the Membership, Roles APIs + Login Controls don’t change at all.

Storing Custom Properties about a User during Registration

One very common question I see asked a lot is how to store custom properties about a new user as they register on the system (example: zip code, gender, etc). The good news is that it is easy to-do this with the new ASP.NET Profile System and the built-in <asp:createuserwizard> control.

I have a sample here that shows how to build a registration system for a site with Membership, Login, Registration, Password Recovery, Change Password, Custom Properties and Roles support – all in 24 lines of code. If you want, you can combine this with the new SQLTableProvider for the Profile system for greater control over your profile database schema. You can learn about that in my blog post here.

Remote Server Administration Tool Mangement of Membership/Roles

The built-in Web Administration Tool with Visual Web Developer and VS 2005 makes it easy to manage the users and roles for a local ASP.NET application. One common question I get asked is how to manage these users/roles against a remote server (for example: an application running on a remote hoster. This blog post of mine points to two different solutions you can use to enable this.

Consuming an ASP.NET web service or page method using jQuery

革命 — Wed, 09 Dec 2009 17:02:07 GMT

The following is a dummy ASP .NET web service. Please note that this service is adorned with the ScriptService attribute that makes it available to JavaScript clients.

Listing 2: A Dummy web service

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[System.Web.Script.Services.ScriptService]
public class dummyWebservice : System.Web.Services.WebService
{
[WebMethod()]
public string HelloToYou(string name)
{
return "Hello " + name;
}
[WebMethod()]
public string sayHello()
{
return "hello ";
}
}

For example, we can call a specific web method in a web service as such.

Listing 4: JQuery .ajax command

$.ajax({
type: "POST",
contentType: "application/json; charset=utf-8",
url: "WebService.asmx/WebMethodName",
data: "{}",
dataType: "json"
});

Two things are worth noting in the above JQuery AJAX call. First, we must specify the contentType’s value as application/json; charset=utf-8, and the dataType as json; second, to make a GET request, we leave the data value as empty.

So put it together, the following code demonstrates how we would use JQuery to call the web service we created above.

Listing 5: Calling a web service using jQuery

<%@ Page Language="C#" %>
<%@ Import Namespace="System.Web.Services" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html >
<head id="Head1" runat="server">
<title>ASP.NET AJAX Web Services: Web Service Sample Page</title>
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jQuery/1.2.6/jQuery.min.js">
</script>
<script type="text/javascript">
$(document).ready(function() {
$("#sayHelloButton").click(function(event){
$.ajax({
type: "POST",
url: "dummyWebsevice.asmx/HelloToYou",
data: "{‘name’: ‘" + $(‘#name’).val() + "’}",
contentType: "application/json; charset=utf-8",
dataType: "json",
success: function(msg) {
AjaxSucceeded(msg);
},
error: AjaxFailed
});
});
});
function AjaxSucceeded(result) {
alert(result.d);
}
function AjaxFailed(result) {
alert(result.status + ‘ ‘ + result.statusText);
}
</script>
</head>
<body>
<form id="form1" runat="server">
<h1> Calling ASP.NET AJAX Web Services with jQuery </h1>
Enter your name:
<input id="name" />
<br />
<input id="sayHelloButton" value="Say Hello"
type="button" />
</form>
</body>
</html>

Calling an ASP .NET page method

Listing 6: A dummy hello world page method

[WebMethod()]
public static string sayHello()
{
return "hello ";
}

Please note that page methods must be declared as static, meaning a page method is completely self-contained, and no page controls are accessible through the page method. For example, if you have a textbox on the web form, there is no way the page method can get or set its value. Consequently any changes with regards to the controls have no affect on the page method. It is stateless and it does not carry any of the view-state data typically carries around by an asp .NET page.

We use the same jQuery command $.ajax to call a page method, as shown in the following example.

<script type="text/javascript">
$(document).ready(function() {
$.ajax({
type: "POST",
url: "pagemethod.aspx/sayHello",
contentType: "application/json; charset=utf-8",
data: "{}",
dataType: "json",
success: AjaxSucceeded,
error: AjaxFailed
});
});
function AjaxSucceeded(result) {
alert(result.d);
}
function AjaxFailed(result) {
alert(result.status + ‘ ‘ + result.statusText);
}
</script>

For more info please visit Xun Ding’s excellent article Using jQuery with ASP .NET

The Best jQuery Modal Dialog Plugins

Via http://www.blogrammierer.de/jquery-die-22-besten-modal-fenster-plugins/

Introduction to the simplest Mock Framework for .NET – Moq

革命 — Wed, 09 Dec 2009 16:57:31 GMT

Rate This

Moq Home

Screencasts – Introduction to Mocking with Moq
Basic Mocking with Moq

Methods

Matching Arguments

Properties

Callbacks

Verification

Also…

API (lots of examples) - API documentation

Stephen Walter - TDD : Introduction to Moq

NUnit running VS10 code

革命 — Wed, 09 Dec 2009 14:26:13 GMT

I've downloaded the NUnit 2.5 source and opened the VS2008 solution in the VS2010 beta. Once the conversion finished I opened all the projects and changed the target framework setting for all the projects to ".NET Framework 4.0". I then built the solution without any errors. I can now use the NUnit GUI app to run tests built for .NET 4.0. I've not done exhaustive testing of this build so there may be problems, but for my purposes it works fine.

Update: It is not necessary to rebuild NUnit. I discovered that if you add the following to the relevant NUnit config file you can run a test dll built for .NET 4.0.

Under <configuration> add:

<startup>
  <requiredRuntime version="v4.0.20506" />
</startup>

and under <runtime> add:

<loadFromRemoteSources enabled="true" />

Just adding the requireRuntime element is insufficient and results in an security related error message mentioning the loadFromRemoteSources switch. I found something about the switch on this social.msdn post, where David DeWinter wrote:

Caveat: I'm not on the security team but will attempt to answer this nonetheless...
What's happening here is that the build tasks for Silverlight are attempting to load an assembly that, in previous versions of the CLR, would classify it as a partial trust assembly based on its evidence (e.g. its zone) according to CAS policy.
In CLR 4.0, CAS policy is totally deprecated and is not even enabled by default. Under the circumstances, though, it appears the CLR throws an Exception when what would be a partial trust load in CLR 2.0 is a full trust load in CLR 4.0.
The loadFromRemoteSources switch the Exception message refers to is in the runtime element under configuration and looks like this:
<runtime>
<loadFromRemoteSources enabled="true|false" />
</runtime>
This will not enable legacy CAS policy but will allow you (or, in this case, the build system) to load remote assemblies with the same permissions as the host AppDomain. In this case it seems as though you could modify the configuration for the build system (which I assume in this case would be Visual Studio: %ProgramFiles%\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe.config) to enable this switch.
If you don't want to modify that configuratino then you can set the environment variable COMPLUS_EnableLegacyCASPolicy to 1, which will enable CAS Policy that was present in CLR 2.0 and also allow Silverlight to load this task.
Hope that helps. David

A lot of improvements have been made in the unit testing space w/ VS 2010 including a full test management system in TFS. In fact, this is one of the hottest areas for 2010.
Here are some helpful links:

http://blogs.msdn.com/amit_chatterjee/archive/2009/10/23/what-s-new-in-test-and-lab-management-in-vs-2010-beta-2.aspx

http://blogs.msdn.com/vstsqualitytools/default.aspx

http://msdn.microsoft.com/en-us/library/bb385901(VS.100).aspx

Why were you considering the move to NUnit?

 
Thanks for the links; they do provide some useful information. The improvements in test management are obviously welcome. However, I was hoping for new features in the unit testing libraries and the execution infrastructure itself.
I am interested in a comparison of the NUnit support for parametrized unit tests and the Visual Studio (VS) 2010 unit testing (MSTest) support for the same.
http://nunit.org/index.php?p=parameterizedTests&r=2.5.2
Currently I think MSTest has limited support for parametrized tests and it is very cumbersome and constraining. I would like to be able to specify data values inline and not have to go to heavy weight solutions like enabling deployment and using an excel sheet or a relational database. We have used Pex for some scenarios where we needed parametrized support but Pex to me is not a replacement for native support of parametrized tests in the unit testing framework.
http://research.microsoft.com/en-us/projects/Pex/
Another issue with MSTest, and this could just be ignorance on my part, is the lack of extensibility in MSTest to facilitate new scenarios. The unit testing technology area is a fast moving one (e.g. the developers of NUnit realized that they had to provide features on par with other frameworks like MbUnit and xUnit to remain competitive) with MSTest one is stuck with the current release of VS and one has to wait till the next full release of VS to get any new features for unit testing whereas with NUnit and the like you can get new features and bugs fixes quickly.
Another issue for me is limitations on how third party tools like TeamCity can work with MSTest e.g. TeamCity cannot show the results of unit tests on-the-fly it can only show them when all the tests have run, it can do that for NUnit and my guess is that this is because MSTest makes it very difficult if not impossible for third party tools to get the results on-the-fly.
http://www.jetbrains.com/teamcity/
http://www.jetbrains.net/confluence/display/TCD4/MSTest+Support
 
MS appears to have finally caved on categories in VS 2010 
http://msdn.microsoft.com/en-us/library/dd286595(VS.100).aspx http://msdn.microsoft.com/en-us/library/ms182489(VS.100).aspx#category 
 
MSTest and CruiseControl .NET 
I have been trying to get Visual Studio 2005 Team Developer style unit tests working within CruiseControl. 
The documention says it should work, but is a little scant as to the detail of how to do it. So now I have it all going I thought an example of the working ccnet.config file with some comments might help other people trying to get this going.
So the background is I have a VS.NET 2005 solution (My Sample.sln) with some projects in it. One of these is a Test Project (TestProject.csproj). This contains some test which can be run via the Test menu option is VS.NET.
CCNET.CONFIG
<project name="My Sample">
<!--Here you put any other project level settings-->
<!--the working directory is used for all relative file references-->
<workingDirectory>C:\projects\My Sample</workingDirectory>
<!--Normally you would have all your source control bits here-->
<tasks>
    <!--We use the Visual Studio build model, you could also use the MSBUILD-->
<devenv>
            <solutionfile>"C:\projects\My Sample\My Sample.sln"</solutionfile>
            <configuration>Debug</configuration>
            <buildtype>Build</buildtype>
            <!--Comment out the project block so it build the whole solution-->
            <!--<project>MyProject</project>-->
            <executable>"C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\devenv.com"</executable>
            <buildTimeoutSeconds>90</buildTimeoutSeconds>
     </devenv>
     <exec>
            <!--Call a batch file that contains del testResults.trx -->
            <!--this is required as MsTest will not create the file if it exists-->
            <!--this could be merged with the mstext action in a single batch file-->
            <executable>deleteTestLog.bat</executable>
            <baseDirectory>C:\projects\My Sample</baseDirectory>
            <buildArgs></buildArgs>
            <buildTimeoutSeconds>30</buildTimeoutSeconds>
      </exec>
      <exec>
            <!--Call mstest to run the tests contained in the TestProject -->
            <executable>C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\mstest.exe</executable>
            <baseDirectory>C:\projects\My Sample</baseDirectory>
            <!--testcontainer: points to the DLL that contains the tests -->
            <!--runconfig: points to solutions testrunconfig that is created by vs.net, list what test to run -->
            <!--resultsfile: normally the test run log is written to the uniquely named testresults directory  -->
            <!--                   this option causes a fixed name copy of the file to be written as well -->
            <buildArgs>/testcontainer:testproject\bin\debug\testproject.dll /runconfig:localtestrun.Testrunconfig /resultsfile:testResults.trx</buildArgs>
            <buildTimeoutSeconds>30</buildTimeoutSeconds>
      </exec>
</tasks>
<publishers>
         <!--to get the test results in the dashboard we have to merge the results XML file -->
         <!--the project working directory is used as the base path here -->
         <merge>
               <files>
                     <file>testResults.trx</file>
               </files>
</merge>
         <!--this is the line I missed for ages, without it you get strange missing publisher log errors -->
         <xmllogger />
</publishers>
</project>
</cruisecontrol>
DASHBOARD.CONFIG
By default with CCNET build 1277 has the entry to display MSTest results in the summary. If you want the results on a separate menu item (like nUnit or FxCop) then the dashboard.config should contain the following bits
<buildPlugins>
<buildReportBuildPlugin>
<xslFileNames>
<!--all these xsl entries are in the 1277 build -->
   <xslFile>xsl\header.xsl</xslFile>
   <xslFile>xsl\modifications.xsl</xslFile>
   <xslFile>xsl\compile.xsl</xslFile>
   <xslFile>xsl\unittests.xsl</xslFile>   
   <xslFile>xsl\MsTestSummary.xsl</xslFile>
   <xslFile>xsl\fxcop-summary.xsl</xslFile>
   <xslFile>xsl\NCoverSummary.xsl</xslFile>
   <xslFile>xsl\SimianSummary.xsl</xslFile>
</xslFileNames>
</buildReportBuildPlugin>
<buildLogBuildPlugin />
   <xslReportBuildPlugin description="NUnit Details" actionName="NUnitDetailsBuildReport" xslFileName="xsl\tests.xsl" />
   <xslReportBuildPlugin description="NUnit Timings" actionName="NUnitTimingsBuildReport" xslFileName="xsl\timing.xsl" />
   <xslReportBuildPlugin description="NAnt Output" actionName="NAntOutputBuildReport" xslFileName="xsl\Nant.xsl" />
   <xslReportBuildPlugin description="NAnt Timings" actionName="NAntTimingsBuildReport" xslFileName="xsl\NantTiming.xsl" />
   <xslReportBuildPlugin description="FxCop Report" actionName="FxCopBuildReport" xslFileName="xsl\FxCopReport.xsl" />
   <xslReportBuildPlugin description="NCover Report" actionName="NCoverBuildReport" xslFileName="xsl\NCover.xsl" />
   <xslReportBuildPlugin description="Simian Report" actionName="SimianBuildReport" xslFileName="xsl\SimianReport.xsl"/>
   <!--add the following line to add the extra menu item-->
   <xslReportBuildPlugin description="MSTest Report" actionName="MSTESTReport" xslFileName="xsl\MsTestSummary.xsl"/>
</buildPlugins>
  
How to check Exception message using MS Test
In Typemock we use both NUnit and MSTest to run our unit tests. This practice enables us to check that Isolator works fine on both unit testing framework. Most of NUnit attributes can be translated fully into MSTest attributes (and vise-versa) there is one attribute we tend to use that works differently in MSTest - ExpectedException.
ExpectedException attribute is used to specify that a test should throw an exception to pass, both framework let the user define the type of the exception thrown (i.e. typeof(ApplicationException)) the big difference between the framework lies in the 2nd (optional)  parameter of that attribute - the Message.
While NUnit compares the massage to the exception's message MSTest does not. At first I though it was a bug but further investigation revealed that this was done intentionally, Microsoft decision was that the message should be only descriptive and used to associate a message to the exception and not check it.
So what could a TDD developer do if he wants to write a test that checks the exception message as well?
One solution is to add code to the test to check the exception's message:
[TestMethod]
[ExpectedException(typeof(ApplicationException))]
public void AddNewUser_UserEmailIsEmpty_ThrowException()
{
try
    {
// This line should throw an exception
UserConnector.AddNewUser("user1", "");
    }
catch (ApplicationException exc)
    {
Assert.AreEqual("Error: user's email address missing", exc.Message);
throw;
    }
}
You can read more about this method at IMistaken Blog.
The problem with this solution is that whenever I need to check an exception message I need to write ~4 more lines of code that makes my test less readable and somewhat error prone.
After digging a bit on the net I found a better solution, it seems that both XUnit and MBUnit uses Assert.Throws method instead of an attribute to check for expected exceptions.
First I've created a new class MyAssert that handles the exception verification logic:
public class MyAssert
{
public static void Throws<T>(Action action, string expectedMessage) where T : Exception
    {
try
        {
action.Invoke();
Assert.Fail("Exception of type {0} should be thrown.", typeof(T));
        }
catch (T exc)
        {
Assert.AreEqual(expectedMessage, exc.Message);
        }
    }
}
Then all I needed to do is use the new class whenever I needed to test for an exception and verify its message:
[TestMethod]
public void AddNewUser_UserEmailIsEmpty_ThrowException()
{
MyAssert.Throws<ApplicationException>(
        () => UserConnector.AddNewUser("user1", ""),
"Error: user's email address missing");
}
Although this solution seems more complicated at first it does have two advantages:

I don't need to write the verification logic anymore 
I can specify the exact line in which I expect the exception to be thrown from. 
Some would claim that using Throws is an over specification of the test but I don't think so. If using Assert calls during unit tests to check that specific line of test returned specific value is fine so does testing that a specific line throw a specific exception is acceptable as well.
After using MyAssert.Throws for a while I have to say I prefer it to using ExpectedException attribute because of the specific meaning it bring to my unit tests.
 
MSBuild, NAnt, NUnit, MSTest, and frustration 
Oh bother. Visual Studio 2003 and Cruise Control.NET. Simple and elegant. A basic NAnt script to build the solution and you're good to go. Run NUnit, output goes to a format CC can understand and Bob's yer uncle. Let me quantify this. Our cruise server has a subversion client (command line) and the .NET 1.1 SDK. Visual Studio isn't installed because, duh, it's a server and cruise just needs something to build the system with.
Enter Visual Studio 2005. I just recently setup CI for our 2005 projects but it's just plain ugly, in so many ways. First there was trying to get the system to build using MSBuild. That was fine because you can simply enter this:
msbuild /t:rebuild solutionname.sln
(or whatever target you want like Debug or Release)
Like I said, if that's all it was no problem but it gets real ugly real fast.
First there's VSTS unit test projects. The team is all equipped with Visual Studio Team Suite. An expensive proposition, but one made long ago by someone wiser than me. No problem though. We're not really using the Test Manager much, there are no automated web tests, so we just write unit tests (and run them with Jamie Cansdales excellent TestDriven.NET). However when MSBuild gets ahold of a solution that contains a VS unit test project it needs some additional set of assemblies (assemblies buried in the GAC_MSIL and other places). The snippet in the ccnet.config file to get MSBuild going was pretty straight forward:
<msbuild>
    <executable>C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\MSBuild.exe</executable>
    <workingDirectory>D:\ccnet\projects\ProjectName</workingDirectory>
    <projectFile>SolutionName.sln</projectFile>
    <buildArgs>/noconsolelogger /p:Configuration=AutomatedBuild /v:diag</buildArgs>
    <targets>Build</targets>
    <timeout>600</timeout>
    <logger>C:\Program Files\CruiseControl.NET\server\ThoughtWorks.CruiseControl.MsBuild.dll</logger>
</msbuild>
Through brute force (run MSBuild, figure out what assembly it needs, go find it, lather, rinse, repeat) I was able to get a 2005 solution (with unit test projects) to compile. However actually running the tests is another story. Again brute force reigned supreme here as I trodded through an hour or two of running MSTest.exe to try to coax a couple hundred unit tests to run. The cc.config entry for getting some unit tests looks something like this:
<exec>
    <executable>C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\MSTest.exe</executable>
    <baseDirectory>d:\ccnet\projects\ProjectName</baseDirectory>
    <buildArgs>/testcontainer:Source\Tests\UnitTests\bin\AutomatedBuild\UnitTests.dll /runconfig:localtestrun.Testrunconfig /resultsfile:testResults.trx</buildArgs>
    <buildTimeoutSeconds>600</buildTimeoutSeconds>
</exec>
Remember that I said this sever did not have Visual Studio installed. For the VS2005 solutions, I just installed the .NET SDK 2.0 and that was good enough. Although MSTest.exe isn't included, I snagged the file (and it's crazy set of additional DLLs scattered all over the hard drive) from another system and stuck it where the EXE was so it would be happy.  
No dice on running MSTest against a unit test project. It started down the path of running the test, but then hit a crazy COM error (CLSID not registered) and that was enough for me. No way I'm going to track down all the stupid COM registry settings for Visual Studio 2005. And what the hell was this? COM? I thought we got rid of that about 3 compilers ago?
So I was stuck to installing a full Team Suite on the server. Okay, I'll bite. I mean, I don't need everything so it'll be okay (I keep telling myself as I watch a million registry entries fill up). A few hours later and I'm staring at my command prompt again and type in my MSTest.exe command. And a dialog box pops up. Yup, a modal dialog box that tells me something is wrong (I don't remember the specifics but it wasn't very informative).
Visual Studio was installed fine and I could compile and run and build the solution I was trying to, but testing from the command line with MSTest.exe was a no-go. No matter how hard I tried, how much I cleaned up, or how many virgins I sacrificed it just won't go. And there's another problem. With 2003 and our NUnit tests, we go some nice stats. Timings, informative messages, all that good stuff. With MSTest we get nothing (other than x number of tests ran and maybe a failure, but I couldn't get that far to see if it would give the details of the failure). On top of that, the MSBuild logger bites and produces about 10,000 lines of gobbly-gook that isn't very useful. Yes, I could spend my time writing new xslt to make it pretty, trim out the "Everything was okay" lines that fill up the MSBuild task logger but I think that's not value-added at my rates.
Here's a sample email I got from the build which gives you an idea of how useless a CC.NET/MSBuild/MSTest combo is:
BUILD SUCCESSFUL
Project: 
PROJECTNAME
Date of build: 
12/8/2006 8:08:30 AM
Running time: 
00:00:55
Integration Request: 
intervalTrigger triggered a build (ForceBuild)
Errors (1) 
D:\ccnet\projects\PROJECTNAME\Source\Reports\ServerReports\ServerReports.rptproj (2,1): error MSB4041: The default XML namespace of the project must be the MSBuild XML namespace. If the project is authored in the MSBuild 2003 format, please add xmlns="http://schemas.microsoft.com/developer/msbuild/2003" to the &lt;Project&gt; element. If the project has been authored in the old 1.0 or 1.2 format, please convert it to MSBuild 2003 format.
Warnings (1) 
Source\Reports\ServerReports\ServerReports.rptproj (,): warning MSB4122: Scanning project dependencies for project "Source\Reports\ServerReports\ServerReports.rptproj" failed. The default XML namespace of the project must be the MSBuild XML namespace. If the project is authored in the MSBuild 2003 format, please add xmlns="http://schemas.microsoft.com/developer/msbuild/2003" to the &lt;Project&gt; element. If the project has been authored in the old 1.0 or 1.2 format, please convert it to MSBuild 2003 format. D:\ccnet\projects\BRMS\Source\Reports\ServerReports\ServerReports.rptproj
Tests run: 0, Failures: 0, Not run: 0, Time: 0 seconds 
No Tests Run
This project doesn't have any tests
Modifications since last build (0) 
It's ugly. Really ugly. MSBuild produces a ton of crazy output. Writing a new MSBuild file is no walk in the park and even for someone like me that knows NAnt quite well, I'm still wrapping my head around how MSBuild does stuff. I had to create a special configuration inside of Visual Studio to omit our Report project because MSBuild can't build them (hence the target AutomatedBuild above which is not the same configuration that our developers use and something I don't like doing because that's one point of a CI server, consistent builds for everyone). 
From the output above, Cruise said the build was okay but there's an error message that came out of the MSBuild logger (our report project). This is a 2005 project so the information makes no sense (I belive it's a bug that's logged but who knows when it might get fixed). And I really can't integrate the MSTest output into the email because, well, there is none. There's a hundred tests or so in this project but the logger doesn't produce anything.  
Additionaly, there are some project types MSBuild can't handle and again, it takes a rocket scientist to create an MSBuild file (even using something cool like MSBuild Sidekick) that can call another MSBuild task and exclude certain projects. This certainly isn't as easy as it was in 2003 where you just created an exclusion list (we excluded our client app as there was no extra license for the grid control and a modal dialog came up when the trial version was even looked at by the compiler).
Okay, this is mostly a rant but there's some wisdom here. Continuous Integration does not need to be this hard. CruiseControl.NET is an excellent tool and very flexible with new tools and integrating output from those tools. However when those tools require a million registry settings and even more DLLs (put in very specific places, trust me, you can't just toss them in the GAC and call it a day) and dump gobs of XML that no mere mortal (well maybe DonXml could) would be able to translate, it's just wrong. And as for the built-in Team Build that you could us, that's equally as useless as a) you can't schedule builds to trigger off of code checkins and b) again it requires a full Team Suite client to be installed on the server. Worst case scenario when I first started setting up CC.NET servers it took 4 hours. Now I can get it done in an hour (which includes testing the build of the first project). I've already spent a good day on just trying to get something to compile. It's compiling now but the output is crap and no running of tests and thats just not good enough for me. You can get MSBuild and (maybe) MSTest running with CruiseControl.NET. It's not impossible. If you install the full client and your projects are "just right" it'll work but the output isn't that hot and you'll watch your server CPU slam when compiles happen.
My advice, avoid trying to combine MSBuild, MSTest, and CruiseControl and stick to NAnt, and NUnit (using MSBuild if you have to when building 2005 solutions).
Needless to say I'm looking at one option right now. Dumping the install of VS2005 on the server, changing all our unit tests back to NUnit and using NAnt to do everything (and just calling MSBuild as an exec task for VS2005 projects). I still need to run 2003 projects so our CI server is going to look like a Frankenstein monster by the time I'm done, building VS2003 and VS2005 projects, running NUnit, MSBuild, NAnt, Simian, FxCop and whatever else we have in our mix. Even given that, using NAnt the output will be simpler (and integrate well with CC.NET), test output will be useful and informative, and I don't need to install a $15,000 piece of software on a server that has the distinct possibility to pop-up a modal dialog someday when it can't find some registry key.
Grrr. Argh.

Walkthrough: Embedding Localized Resources for a JavaScript File

革命 — Fri, 06 Nov 2009 03:07:56 GMT

This walkthrough describes how to include an ECMAScript (JavaScript) file as an embedded resource in an assembly, and how to include localized strings for use in the JavaScript file. You embed a JavaScript file in an assembly when you have a client script component that must be distributed with the assembly. The JavaScript file can be referenced from a Web application that registers the assembly. You embed localized resources when you have to modify values that are used by the JavaScript file for different languages and cultures.

Prerequisites

To implement the procedures in this walkthrough you need:

Visual Studio or Visual Web Developer 2010 Express.

Creating an Assembly that Contains an Embedded JavaScript File

You will begin by creating an assembly (.dll file) that contains the JavaScript file that you want to treat as a resource. You will do so by creating a class library project in Visual Studio, which creates an assembly as its output.

To embed a client script file and resources in an assembly

In Visual Studio, create a new class library project named LocalizingScriptResources.
Add references to the System.Web and System.Web.Extensions assemblies to the project.
Add a new JScript file to the project named CheckAnswer.js.
Add the following code to the CheckAnswer.js file.

function CheckAnswer()

{

var firstInt = $get('firstNumber').innerText;

var secondInt = $get('secondNumber').innerText;

var userAnswer = $get('userAnswer');

if ((Number.parseLocale(firstInt) + Number.parseLocale(secondInt)) == userAnswer.value)

{

alert(Answer.Correct);

return true;

}

else

{

alert(Answer.Incorrect);

return false;

}

The script checks the user's result for adding two numbers. It uses the alert function to let the user know whether the answer is correct. The message displayed in the alert dialog box is read from a localized resource without a postback to the server.

A placeholder named Answer is used in the script to identify which resource files contain the localized strings. The Answer placeholder will be defined later in this procedure.

In the Properties window for CheckAnswer.js, set Build Action to Embedded Resource.

Add a class to the project named ClientVerification.
Replace any code in the ClientVerification class file with the following code:

using System;

using System.Collections.Generic;

using System.Text;

using System.Web.UI;

using System.Web.UI.HtmlControls;

using System.Web.UI.WebControls;

using System.Resources;

namespace LocalizingScriptResources

{

public class ClientVerification : Control

{

private Button _button;

private Label _firstLabel;

private Label _secondLabel;

private TextBox _answer;

private int _firstInt;

private int _secondInt;

protected override void CreateChildControls()

{

Random random = new Random();

_firstInt = random.Next(0, 20);

_secondInt = random.Next(0, 20);

ResourceManager rm = new ResourceManager("LocalizingScriptResources.VerificationResources", this.GetType().Assembly);

Controls.Clear();

_firstLabel = new Label();

_firstLabel.ID = "firstNumber";

_firstLabel.Text = _firstInt.ToString();

_secondLabel = new Label();

_secondLabel.ID = "secondNumber";

_secondLabel.Text = _secondInt.ToString();

_answer = new TextBox();

_answer.ID = "userAnswer";

_button = new Button();

_button.ID = "Button";

_button.Text = rm.GetString("Verify");

_button.OnClientClick = "return CheckAnswer();";

Controls.Add(_firstLabel);

Controls.Add(new LiteralControl(" + "));

Controls.Add(_secondLabel);

Controls.Add(new LiteralControl(" = "));

Controls.Add(_answer);

Controls.Add(_button);

}

The code creates a custom ASP.NET control. It contains two Label controls, a TextBox control, and a Button control. The code displays two randomly generated integers and provides a text box for an answer. When the button is clicked, the CheckAnswer function is called.

Add a resources file to the project and name it VerificationResources.resx.
Add a string resource named Correct with a value of "Yes, your answer is correct."
Add a string resource named Incorrect with a value of "No, your answer is incorrect."
Add a string resource named Verify with a value of "Verify Answer".

This resource is not retrieved by using client script. Instead, it is used to set to the Text property of the Button control when the button is created.

Save and close the VerificationResources.resx file.
Add a resources file named VerificationResources.it.resx to the project.

This file will contain resource strings in Italian.

Add a string resource named Correct with a value of "Si, la risposta e’ corretta."
Add a string resource named Incorrect with a value of "No, la risposta e’ sbagliata."
Add a string resource named Verify with a value of "Verificare la risposta".

As with the "Verify" resource that you created in English, this resource is not retrieved by using client script. Instead, it is used to set the Text property of the Button control when the button is created.

Save and close the VerificationResources.it.resx file.
Add the following line to the AssemblyInfo file. You can specify any name for the type name in the ScriptResourceAttribute attribute, but it must match the type name that is used in the client script. In this example, it is set to Answer.

[assembly: System.Web.UI.WebResource("LocalizingScriptResources.CheckAnswer.js", "application/x-javascript")]//用于下载js文件

[assembly: System.Web.UI.ScriptResource("LocalizingScriptResources.CheckAnswer.js", "LocalizingScriptResources.VerificationResources", "Answer")]//用于在脚本代码中使用资源（Answer对象）

Note

The AssemblyInfo.vb file is in the My Project node of Solution Explorer. If you do not see any files in the My Project node, in the Project menu, click Show All Files. The AssemblyInfo.cs file is in the Properties node of Solution Explorer.

The WebResource definition must include the default namespace of the assembly and the name of the .js file. The ScriptResource definition does not include the file name extension or the localized .resx files.

Build the project.

When compilation finishes, you will have an assembly named LocalizingScriptResources.dll. The JavaScript code in the CheckAnswer.js file and the resources in the two .resx files are embedded in this assembly as resources.

You will also have an assembly named LocalizingScriptResources.resources.dll (a satellite assembly) that contains the Italian resources for server code.

Referencing the Embedded Script and Resources

You can now use the assembly in an AJAX-enabled ASP.NET Web site. You will be able to read the .js file and the resource values in client script.

Note

Although you can create the class library project and the Web site in the same Visual Studio solution, in this walkthrough it is not assumed that you are doing this. Having the projects in separate solutions emulates how a control developer and a page developer would work separately. However, for convenience you can create both projects in the same solution and make small adjustments to procedures in the walkthrough.

To reference the embedded script and resources

In Visual Studio, create a new AJAX-enabled Web site.
Add a Bin folder under the Web site root.
Add the LocalizingScriptResources.dll assembly from the class library project to the Bin folder.

Note

If you created the class library project and the Web site in the same Visual Studio solution, you can add a reference from the class library project to the Web site. For details, see How to: Add a Reference to a Visual Studio Project in a Web Site.

Create a folder in the Bin folder and give it the name it (for Italian).
Add the LocalizingScriptResources.resources.dll satellite assembly from the it folder in the LocalizingScriptResources project to the it folder in the Web site.
Add a new ASP.NET Web page to the project.
Replace the code in the page with the following code:

<%@ Page Language="C#" AutoEventWireup="true" UICulture="auto" Culture="auto" %>

<%@ Register TagPrefix="Samples" Namespace="LocalizingScriptResources" Assembly="LocalizingScriptResources" %>

protected void Page_Load(object sender, EventArgs e)

{

if (IsPostBack)

{

System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CreateSpecificCulture(selectLanguage.SelectedValue);

}

else

{

try{

selectLanguage.Items.FindByValue(System.Threading.Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName).Selected = true;

}

catch{

selectLanguage.Items.FindByValue(“en”).Selected = true;

}

protected void selectLanguage_SelectedIndexChanged(object sender, EventArgs e)

{

System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CreateSpecificCulture(selectLanguage.SelectedValue);

}

</script>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html >

<title>Client Localization Example</title>

</head>

<body>

<asp:DropDownList runat="server" AutoPostBack="true" ID="selectLanguage" OnSelectedIndexChanged="selectLanguage_SelectedIndexChanged">

<asp:ListItem Text="English" Value="en"></asp:ListItem>

<asp:ListItem Text="Italian" Value="it"></asp:ListItem>

</asp:DropDownList>

<asp:ScriptManager ID="ScriptManager1" EnableScriptLocalization="true" runat="server">

<asp:ScriptReference Assembly="LocalizingScriptResources" Name="LocalizingScriptResources.CheckAnswer.js" />

</Scripts>

</asp:ScriptManager>

<div>

<Samples:ClientVerification runat="server" ></Samples:ClientVerification>

</div>

</form>

</body>

</html>

The control that you created in the LocalizingScriptResources project is included on the page. This control displays two numbers for the user to add and a TextBox control for the user to enter an answer. It also displays a button that calls the script in the CheckAnswer function when the button is clicked. The CheckAnswer function runs in the browser and displays a localized message that states whether the answer is correct.

You must set the EnableScriptLocalization property of the ScriptManager object to true to enable the ScriptManager control to retrieve localized resources. You must also set the culture and UI culture to "auto" to display the strings that are based on the browser's settings.

The page contains a DropDownList control that you can use to change the language settings without changing the settings in the browser. When the SelectedIndex property of the DropDownList control changes, the CurrentUICulture property of the CurrentThread instance is set to the value that you have selected.

Run the project.

You will see an addition problem with two randomly generated numbers and a TextBox control for entering an answer. When you enter an answer and click the Verify Answer button, you see the response in a message window that tells you whether the answer is correct. By default, the response will be returned in English.

However, if you have set Italian as your preferred language in the browser, the answer will be in Italian. You can change the language for the response by selecting a language in the DropDownList control or by changing the preferred language in the browser.

Review

This walkthrough introduced the concept of embedding a JavaScript file as a resource in an assembly and of including localized strings. The embedded script file can be referenced and accessed in a Web application that contains the assembly. The localized strings will be displayed based on the language setting in the browser or on the language provided by the user.

Walkthrough: Adding Localized Resources to a JavaScript File

This walkthrough shows you how to include localized resources in an ECMAScript (JavaScript) file. In this walkthrough the resources are strings. You include localized resources in a JavaScript file when you have created a standalone JavaScript file and when your application must provide different values for different languages and cultures.

A standalone JavaScript is not embedded as a resource in an assembly and therefore cannot access values in a resources file. Instead, you include the localized string values directly in the script file. The localized values are retrieved when the script runs in the browser.

You create a separate script file for each supported language and culture. In each script file, you include an object in JSON format that contains the localized resources values for that language and culture.

Prerequisites

To implement the procedures in this tutorial you need:

Visual Studio or Visual Web Developer 2010 Express.
An AJAX-enabled ASP.NET Web site.

Creating a JavaScript File That Contains Localized Resource Values

To add resource values to a JavaScript file

In the root directory of the Web site, add a folder named Scripts.
In the Scripts folder, add a JScript file named CheckAnswer.js, and then add the following code to the file.

Sys.Application.add_load(SetButton);

function SetButton()

{

$get('Button1').value = Answer.Verify;

}

function CheckAnswer()

{

var firstInt = $get('firstNumber').innerText;

var secondInt = $get('secondNumber').innerText;

var userAnswer = $get('userAnswer');

if ((Number.parseLocale(firstInt) + Number.parseLocale(secondInt)) == userAnswer.value)

{

alert(Answer.Correct);

return true;

}

else

{

alert(Answer.Incorrect);

return false;

}

Answer={

"Verify":"Verify Answer",

"Correct":"Yes, your answer is correct.",

"Incorrect":"No, your answer is incorrect."

};

The script code adds a handler for the load event of the Sys.Application class. The handler sets the button text. Instead of setting the text to a string, it sets the text to a value that is defined in a class named Answer.Verify. This enables the code to use a localized value.

The script also contains a function that checks the user's result for adding two numbers. It uses the alert function to let the user know whether the answer is correct. As with the button text, the message displayed in the alert dialog box is set to a localized string value without a postback to the server.

A type named Answer is used in the script to define the collection of localized values to use in the file. The Answer type is defined in JSON format at the end of the CheckAnswer.js file.

In the Scripts folder, add a JScript file named CheckAnswer.it-IT.js. Add the following code to the file.

Sys.Application.add_load(SetButton);

function SetButton()

{

$get('Button1').value = Answer.Verify;

}

function CheckAnswer()

{

var firstInt = $get('firstNumber').innerText;

var secondInt = $get('secondNumber').innerText;

var userAnswer = $get('userAnswer');

if ((Number.parseLocale(firstInt) + Number.parseLocale(secondInt)) == userAnswer.value)

{

alert(Answer.Correct);

return true;

}

else

{

alert(Answer.Incorrect);

return false;

}

Answer={

"Verify":"Verificare la risposta",

"Correct":"Si, la risposta e’ corretta.",

"Incorrect":"No, la risposta e’ sbagliata."

};

This file is identical to the CheckAnswer.js file except that it contains an Answer type with values in Italian.

To provide localized text in additional languages, you can create more JavaScript files. The JavaScript code is always the same, but the values that are defined in the Answer type are in different languages. The name of each JavaScript file must include the appropriate language and locale.

Using JavaScript Resource Values in an ASP.NET Page

You can now create an ASP.NET Web page that uses the script code that you have created. The page enables you to test the effect of changing a language.

To use JavaScript resource values in an ASP.NET Web page

Create an ASP.NET Web page.
Replace the content of the Web page with the following markup and code:

<%@ Page Language="C#" AutoEventWireup="true" UICulture="auto" Culture="auto" %>

protected void Page_Load(object sender, EventArgs e)

{

int _firstInt;

int _secondInt;

Random random = new Random();

_firstInt = random.Next(0, 20);

_secondInt = random.Next(0, 20);

firstNumber.Text = _firstInt.ToString();

secondNumber.Text = _secondInt.ToString();

if (IsPostBack)

{

userAnswer.Text = "";

System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CreateSpecificCulture(selectLanguage.SelectedValue);

}

else

{

selectLanguage.Items.FindByValue(System.Threading.Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName).Selected = true;

}

protected void selectLanguage_SelectedIndexChanged(object sender, EventArgs e)

{

System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CreateSpecificCulture(selectLanguage.SelectedValue);

}

</script>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html >

<title>Client Localization Example</title>

</head>

<body>

<asp:DropDownList runat="server" AutoPostBack="true" ID="selectLanguage" OnSelectedIndexChanged="selectLanguage_SelectedIndexChanged">

<asp:ListItem Text="中D文?" Value="zh"></asp:ListItem>

<asp:ListItem Text="English" Value="en"></asp:ListItem>

<asp:ListItem Text="Italian" Value="it"></asp:ListItem>

</asp:DropDownList>

<asp:ScriptManager ID="ScriptManager1" EnableScriptLocalization="true" runat="server">

<asp:ScriptReference Path="scripts/CheckAnswer.js" ResourceUICultures="it-IT,zh-CN" />

</Scripts>

</asp:ScriptManager>

<div>

<asp:Label ID="firstNumber" runat="server"></asp:Label>

<asp:Label ID="secondNumber" runat="server"></asp:Label>

<asp:TextBox ID="userAnswer" runat="server"></asp:TextBox>

<asp:Button ID="Button1" runat="server" OnClientClick="return CheckAnswer()" />

<br />

<asp:Label ID="labeltest" runat="server"></asp:Label>

</div>

</form>

</body>

The markup creates a DropDownList control, two Label controls, a TextBox control, and a Button control. The page displays two randomly generated integers and asks the user to add them, and it provides a text box for an answer. When the button is clicked, the JavaScript CheckAnswer function is called.

The DropDownList control enables you to change the language settings without changing the settings in the browser. When the SelectedIndex property of the DropDownList control changes, the CurrentUICulture property of the CurrentThread instance is set to the value that you have selected.

Note

For information about how to set culture information for a thread, see How to: Set the Culture and UI Culture for ASP.NET Web Page Globalization.

The ScriptManager control includes a reference to the CheckAnswer.js script file. This causes the page to retrieve the CheckAnswer.js file when the page runs.

The ResourceUICultures property of the reference is set to "it-IT" to indicate that the Web site contains an Italian version of the script. As a result, the ScriptManager object retrieves the Italian version when you select "Italian" from the DropDownList control or when you set "Italian" as the default language in the browser.

Run the page.

You see an addition problem with two randomly generated numbers and a TextBox control for entering an answer. When you type an answer and click the Verify Answer button, you see the response in a message window that tells you whether the answer is correct.

By default, the response is displayed in English.

Change the language to Italian by selecting "Italian" from the drop-down list.
Perform the quiz again.

This time, the answer is in Italian

Review

This walkthrough showed how to add localized resource values to a standalone JavaScript file. The localized values are created as objects in JSON format that are part of individual localized JavaScript files. Localized values are displayed by referencing the JSON object instead of by using hard-coded strings. The localized strings are displayed based on the language setting in the browser or on the language setting that is provided by the user.

Compact Web Server in Compact Framework

革命 — Mon, 26 Oct 2009 04:29:20 GMT

Monday, October 22, 2007 @ 15:42

Today I want to write about small class library I wrote some times ago. It is the compact web server written in C#. Class library implements functionality of the single threaded web server, which can run in Windows CE powered system as well as desktop version of Microsoft Windows. Currently only the GET method is supported, but it's possible to pass query strings and process 'em in custom code. Let's see some examples.

Configuring web server

Configuration for web server is stored in WebServerConfiguration class. Here it's possible to setup server root, listening port, IP address etc.. Important thing is the possibility to configure default files like default.html, index.html or other. Do not forget to register MIME types for files that will be handled by the web server. Setting right mime types is necessary for correct response header of the server.

Special files are those files, that need to be treat in custom method and not just send to the client. CompactWeb server supports virtual directories so you can request directory placed outside the server root.

WebServerConfiguration webConf = new WebServerConfiguration();

webConf.IPAddress = IPAddress.Any;

webConf.Port = 80;

// Folder where the web is stored

webConf.ServerRoot = @"\Inetpub";

webConf.AddDefaultFile("default.html");

webConf.AddMimeType(".htm", "text/html");

webConf.AddMimeType(".html", "text/html");

webConf.AddMimeType(".png", "image/png");

webConf.AddMimeType(".jpg", "image/jpg");

webConf.AddMimeType(".gif", "image/gif");

webConf.AddMimeType(".bmp", "image/bmp");

webConf.AddMimeType(".cgi", "text/html");

// .cgi files will be special handled

webConf.AddSpecialFileType(".cgi");

// Register virtual directory

webConf.AddVirtualDirectory("photos", @"\My Documents\Photos");

Necessary step is to setup server root physically in the file system. Simply create the folder and put the website in.

Start me up

Starting the web server is the easiest thing in whole process. Registering OnLogEvent is fine to track client connections, response sending and exceptions. OnSpecialFileType is raised whenever the file registered as special is requested by client. Delegate for this event can handle output to the client.

webServer = new WebServer(webConf);

webServer.OnLogEvent += new WebServer.LogEvent(webServer_OnLogEvent);

webServer.OnSpecialFileType += new WebServer.SpecialFileType(webServer_OnSpecialFileType);

webServer.Start();

From here, your server is running and ready to serve all files placed in the server root.

ASP, PHP, CGI whatever you want

If it's necessary to process some files in special way, you can use delegate to OnSpecialFileType and take the control over processing. Next piece of code handles file with .cgi extension. It takes the content of the file and replace pattern with parameter userName passed in the query string. In case that you will call following URL http://127.0.0.1/form.cgi?userNamer=Joshua the pattern will be replaced with Joshua.

void webServer_OnSpecialFileType(CompactWeb.WebRequest webRequest, out IO.Stream outputStream)

{

outputStream = new MemoryStream();

if (webRequest.FileName == "form.cgi")

{

// Read the requested file template

FileStream sourceFile = new FileStream(webRequest.FullPath, FileMode.Open);

StreamReader streamReader = new StreamReader(sourceFile);

string response = streamReader.ReadToEnd();

streamReader.Close();

sourceFile.Close();

// Parse query string into NameValueCollection

NameValueCollection query = WebServer.ParseQueryString(webRequest.QueryString);

// Replace <%=RESULT%> with the username

string userName = query["userName"];

response = response.Replace("<%=RESULT%>", userName);

// Creat response

byte[] buffer = Encoding.ASCII.GetBytes(response);

outputStream.Write(buffer, 0, buffer.Length);

}

Download and Conclusion

Complete CompactWeb class library with this sample code is possible to download here CompactWebServer.zip . Even if the code is written in compact framework it can be compiled and used with full version of .NET framework. Usage is NOT limited to windows mobile. Feel free to suggest any ideas and improvements, or change the code for your needs. I believe that you will find this library useful.

Serving Silverlight Apps from Windows Mobile

For the last Paris mobility briefing, my colleague Pierre Cauchois asked me to co-animate the Coding4Fun session…hard to refuse.

Even if mobile dev is not my every day work, thanks to the .Net Compact Framework, it’s still .Net programming.

Here is the scenario:

You come back home, you have a windows mobile phone wifi capable and you want to quickly get access to your phone pictures from your home network.
You just activate the Wifi, run my app and then browse to the provided link from any computer on the network.

Then a silverlight application is loaded from the phone and you can see any of your pictures.

Here is how it works:

I decided to use windows mobile to host a Silverlight application.

I had just needed a Mobile Web Server that I found here (thanks to Pavel Bánský). The code is full C# and really small and easy to use. I just had to add cookie support but I will talk about it later.

Now I have a basic web server hosted on my phone, I will publish some stuff.

- the main html page containing the silverlight application. I renamed the one provided by Visual Studio to “Default.html” to make it the default page of my web site.

- the xap file which is the Silverlight application itself.

- a web service to expose the list of pictures available on my phone. As I had no web service infrastructure available on my very small web server, I have decided to expose a rss feed which is made with just a few lines of Linq to Xml. Exposing pictures on http gives a lot of advantages like getting the benefits of the browser local cache. In this project it’s very useful because the mobile phone does not have a large and powerful bandwidth, so we appreciate not to reload pictures ever time. Now we just need to link some Silverlight Image controls to the pictures urls and the Silverlight image loader will work for us.

- make the pictures visible. The web server contains a virtual folder feature. I just had to make it point to the local pictures path.

Linq to Xml rss content creation on server side (Compact Framework):

var files = Directory.GetFiles(picturesPath, "*.jpg");
XElement response = new XElement("rss",
new XAttribute("version", "2.0"),
new XElement("channel",
new XElement("title", "Mobile pictures"),
new XElement("description", "Mobile pictures from my phone"),
new XElement("link", ""),
(from file in files.Select(f => Path.GetFileName(f))
select
new XElement("item",
new XElement("title", file),
new XElement("description", file),
new XElement("link", string.Format("http://{0}/photos/{1}",ipAddress,file))
)
).ToArray()
)
);

Regarding the client development, I have created a simple Silverlight 3 application (yes I also wanted to play with those new features like 3D and non linear animations).

The Silverlight application calls the web service, reads the rss content (using Linq to Xml again !) and binds the pictures paths to a listbox. The selected picture is displayed in the biggest part of the window. When you change the selected picture, an animation wipes out the existing one and another is bringing the new one with a 3D effect.

Analysing rss content with Linq to Xml on client side (Silverlight):

var root = XElement.Parse(e.Result);
var items = root.Element("channel").Elements("item").Select(i => i.Element("link").Value);
lb.ItemsSource = items;

And that’s it !

Now let’s talk about security. Once again, it’s just a little demo but we can not talk about opening a web server on your phone without talking about security.

The web server is made to respond to the user for a short time. https is complex and even basic authentication needs credentials on the server side. I have chosen another solution that I found to be more appropriate. In my scenario, the web server is requested by a single user who’s got the phone in his hands. So when a first request comes (no cookie), I am asking for a human validation (MessageBox). Of course during this time the server is stopped. The user just has to validate on the phone and then the server answers and provides an authentication cookie. Next requests will carry the cookie and the user will not have to validate again.

This remains a really really small demo. We could of course imagine having a more robust web server and some optimizations like thumbnails creation on server side but this was just a test and I hope it gave some interesting ideas to some of you.

In addition to hosting a Silverlight application on my mobile phone, the funniest was to be able to use .Net both on server and client side (Compact Framework and Silverlight) without using the Windows .Net Framework !

The source code is attached to this post.

ASP.NET动态数据查询

革命 — Mon, 26 Oct 2009 04:21:23 GMT

第1部分

Una delle novità presenti nella SP1 di .NET 3.5 sono i Dynamic Data (DD), o meglio ASP.NET Dynamic Data. SP1中。NET 3.5中的一个创新是动态数据（DD）的，或更好的ASP.NET动态数据。 In estrema sintesi i DD consentono di generare un sito web completo partendo da un modello dei dati.在一个总括来说，产生的DD可以从一个数据模型完整的Web站点。 Vi è mai capitato di dover costruire un'applicazione web in poco tempo, niente di eccezionale, solo per poter permettere di fare operazioni di interrogazione e modifica su una sorgente dati?你是否曾经不得不在短期内建立一个Web应用程序的时间，没有什么特别，只是为了能够查询和编辑数据源操作？

Bene, i DD sono pensati proprio per questi scenari: si parte da un modello dei dati costruito con LINQ to SQL o Entity Framework (ma non solo..) e su questo, delle pagine aspx fungono da template generici, essendo in grado di capire quali tabelle sono presenti nel modello dei dati, di capire come sono fatte e di visualizzarle così come renderle modificabili.那么，DD是设计正是基于这样的场景：我们从使用LINQ到SQL内置框架或实体数据模型开始（但不仅限于..）在这里，在aspx页面作为通用模板，能够理解哪些表存在于数据模型，以了解他们是如何制作，并显示它们作为使编辑。 Esiste quindi un template unico (condiviso da tutte le tabelle) per le operazioni tipiche che su queste potremmo fare (interrogazione, modifica etc).因此，有共同的模板 （共享的所有表格的典型操作，我们可以做这个（问题，编辑等））。

Un altro aspetto importante riguarda il motore di routing su cui si basano, che consente di non legare l'url che chiamiamo nel browser per richiedere una specifica pagina a dove la pagina fisica risieda oppure a come questa si chiami.另一个重要方面涉及的路由引擎所依据的，它允许你不绑定在浏览器中调用的URL来请求一个特定的页面，物理页居住或它是如何调用。 Inoltre è possibile modificare il comportamento del motore di routing tramite delle regole, in un unico punto, senza dover modificare alcunché nelle singole pagine e come queste si richiamino tra di loro.您还可以修改的路由引擎，通过在一个地方的规则的行为，而无需改变任何个人网页，以及如何绘制在一起。

Partiamo con un semplice esempio:让我们从一个简单的例子：

Da Visual Studio 2008 SP1 ( oppure con Visual Web Development Express 2008 SP1) scegliamo uno dei due nuovi template disponibili: Visual Studio 2008的SP1的（或Visual Web开发高速2008 SP1的），我们选择了两个新模板可用1：

Scegliamo Dynamic Data Web Application , perché pensiamo di generare il modello dei dati con LINQ to SQL, se volessimo usare Entity Framework dovremmo scegliere Dynamic Data Entities ….选择动态数据Web应用程序，因为我们使用LINQ生成的模型数据到SQL，实体框架我们，如果我们选择使用动态数据实体....

Date ora un rapido sguardo al progetto generato che contiene la cartella DynamicData , che a sua volta contiene i template che vi dicevo sopra, in particolare guardate la sottocartella PageTemplates che contiene i template usati dai DD. Qui trovate una descrizione delle pagine incluse di default .现在日期在生成的项目中包含的文件夹DynamicData，又包含了模板，我是说以上的PageTemplates子文件夹包含模板使用的是副署长看，快看。下面是描述网页的默认列入。

E' interessante anche il folder FiledTemplate in cui trovate come viene eseguito il rendering di uno specifico tipo, ad esempio il file Boolean.ascx e Boolean_Edit.ascx contengono il codice che viene generato a runtime tutte le volte che si deve generare la parte di pagina che visualizza una colonna del database di tipo boolean e, come avrete capito, il comportamento cambia se siamo in fase di visualizzazione piuttosto che editing del campo.和'有趣FiledTemplate的文件夹找到，因为它是提供特定类型，如文件Boolean.ascx和Boolean_Edit.ascx，包含的代码，在运行时每次必须生成的页面部分生成显示类型的布尔数据库列，和，你会看到，该行为的变化，如果我们在观看，而不是编辑领域的过程中。 Quindi, in un unico punto, è stato centralizzato il comportamento per la visualizzazione e la modifica dei singoli campi delle tabelle del database.因此，在一个地方，它是为集中查看和数据库表的各个字段编辑的做法。 Posso modificare il codice qui e vedere le modifiche apportate ogni volta che viene visualizzata una colonna che fa riferimento ad un campo boolean su db, di una qualsiasi pagina che venga renderizzata.我可以更改代码，看看这里的变化每次你看到一个列指的是一个布尔字段分贝的任何呈现网页。 I DD hanno anche un meccanismo che consente di fare un po' il contrario: di specificare cioè che un particolare campo boolean, di una particolare tabella sia visualizzato in modo completamente diverso che dagli altri.该署副署长也有一个机制，做一些'相反：如果是，指定一个特定的布尔字段，一个特定表的方式完全不同于其他显示。 Vedremo meglio questo meccanismo di estendibilità in un altro post.我们将看到在另一职位可扩展性机制。

Per ora procediamo oltre e aggiungiamo un modello dei dati basato su LINQ to SQL.现在我们采取进一步行动，向数据模型到SQL LINQ的基础。 Dal menù: Add new Item, quindi scegliamo Linq to SQL Classes, “agganciamo” il nostro database Northwind, o quello che preferite, e senza preoccuparcene troppo facciamo drag & drop di tutte le tabelle, alla fine ci troviamo più o meno nella situazione in figura:从菜单：添加新项，然后选择LINQ to SQL类，连接到我们的Northwind数据库，或任何你喜欢，也不要过于担心拖放到最后，我们或多或少的情况中的所有表数字

Nella figura trovate evidenziati il folder DynamicData e il file del modello dei Dati Northwind.dbml.显示在图DynamicData文件夹和数据模型文件Northwind.dbml。

Ora andiamo nel file global.asax , semplicemente scommentiamo la riga di codice in cui informiamo i DD del nostro modello, “registrandolo” e aggiungendo il DataContext che mi ha creato il designer, NorthwindDataContext , imponendo a true l'attributo ScaffoldAllTables , che in soldoni dice ai DD di utilizzare tutte le tabelle del mio modello dei dati.现在我们是在Global.asax文件中去，只需取消注释的代码中，我们告诉我们的模型线的DD，“注册”，并补充说，我创建了DataContext的设计师NorthwindDataContext实施ScaffoldAllTables属性为true，这soldoni副署长说，使用我的数据模型中的所有表。 E' doveroso ricordare, come il commento nella stessa pagina global.asax ricorda, questa può non essere la cosa migliore da fare, ma per ora, per il mio esempio, può andare.和'我们应该记住，因为在同一页上的global.asax记得评论，这可能不是最好的事，但现在，我的例子，它可以走了。

Premendo F5 vediamo la nostra applicazione già bella che fatta.按下F5，看到我们美丽的申请已经作出。 In figura vedete la prima schermata che mostra l'elenco delle tabelle在图片您看到的第一个屏幕，显示表的列表

Per renderci conto di quanto sia potente il meccanismo di discovery del modello dei dati usato dai DD, premiamo il link che ci porta alla tabella Products, la pagina list.aspx che viene invocata, è un template completamente generico, è in grado di visualizzare correttamente la tabella Products.为实现由副署长所使用的数据模型，发现有多么强大机制，我们按下连结，使我们的产品表，页面list.aspx被调用是一个完全通用的模板，可以正确显示产品表。

Nella seguente figura, ho evidenziato gli aspetti notevoli che i DD ci mettono a disposizione gratuitamente:在未来的数字，我强调说，我们的DD提供免费主要方面：

I DD si accorgono :我知道副署长：

che la tabella Products ha una relazione di foreign-key con la tabella Category ed invece di mostrarci l'ID della Categoria, ad esempio 1 per il primo prodotto, ci mostra il nome della categoria, cioè Beverages.该产品表有一个外商与分类表键的关系，而不是显示我们的编号，如1类，第一个产品，向我们揭示了类的名称，即饮料。 Potente, no!功能强大，没有！ Lo stesso vale per Supplier.这同样适用于供应商。
Mettono a disposizione un menù per fare operazione di filtraggio: guardate Discontinued, Category, Supplier: che è generato dinamicamente in base a quali campi boolean e alle relazioni foreign-key presenti nella tabella prodotti.提供一个菜单做的过滤操作：看停产，分类，供应商，这是动态生成什么布尔字段和外商在表中产品的关键关系的基础。
Seguendo i link Edit, Delete e Details si giunge a delle pagine che servono proprio per le operazioni suddette, che ovviamente sono generate a partire dagli altri template, anch'essi generici e adattabili a qualsiasi tabella.通过下面的链接编辑，删除和详细导致的网页是否有这种行动，很明显从其他模板，过于一般化，适应任何表生成。

Il tutto finora semplicemente scrivendo una riga di codice nel file global.asax.到目前为止，一切只写一行代码在Global.asax文件中。

Il Routing 路由

Se torniamo al file global.asax, noterete come viene generato l'url per navigare l'applicazione web generata:返回到Global.asax文件中，你会发现如何生成的URL浏览Web应用程序的生成：

L'url viene composto con il nome della tabella e il nome delle action, a cui viene aggiunta l'estensione aspx.网址是组成的表名和行动的名义，这是添加到ASPX。 Ora cos'è l'action ?现在是什么行动？ Possiamo pensare alle action come alle azioni eseguite sulla pagina dall'utente.我们可以把行动对用户执行的行动。 Esiste l'enum PageAction che contiene le action usate di default dai DD.有一个枚举PageAction包含由署长默认使用的行动。 Con un esempio si potrebbe dire che se l'utente clicca sul link Edit, per modificare come è fatto un singolo prodotto, la pagina esegue la relativa action PageAction.Edit e il motore di routing invoca la corrispondente pagina, nell'esempio sopra sarà dunque la pagina Edit.aspx, che trovate nel folder dei template in Page templates.作为一个例子，我们可以说，如果你在编辑链接编辑点击作为单一产品取得，页面执行其行动PageAction.Edit和路由引擎调用在上面的例子相应的页面因此将Edit.aspx页面，在页面的模板文件夹中找到模板。

Per renderci conto di quanto sia flessibile il motore di routing, possiamo provare ad aggiungere due nuove regole.为了实现灵活的路由引擎如何，我们可以尝试添加两个新的规则。 Le regole seguenti valgono solo sulla tabella “Supplier”.以下规则将只适用于表“供应商”。

Attenzione : le regole hanno una precedenza, quindi dobbiamo applicare queste due regole prima di quella presente di default che è più generica.注意：优先的规则，所以我们通过之前申请默认目前一，这是较为笼统的这两个规则。 Questa regola agisce quando scegliamo la tabella Supplier (durante la navigazione ).这条规则并当我们选择供应商的表（在导航）。 In questo caso sia che l'utente scelga di selezionare la lista di tutti i supplier (PageAction.List), che scelga di selezionare il singolo supplier (PageAction.Details), la pagina che la visualizza sarà la ListDetails.aspx (anche questa è una delle 4 pagine presenti di default nel folder Page Templates).在这种情况下，是用户选择，选择的所有供应商名单（PageAction.List），谁选择选择单一供应商（PageAction.Details），在出现的页面将是ListDetails.aspx虽然这（是在4页在网页模板文件夹的默认当前1）。 Nella definizione della regola ViewName è il nome della pagina aspx (senza estensione) che deve farne il rendering.在规则的视图名的定义是aspx页面（没有扩展名），必须使渲染的名称。 Mentre in verde vedete l'url che apparirà nella address bar del browser, che può essere quello che volete, in questo caso ho semplicemente rimosso l'estensione “.aspx” alla fine dell'url.当你看到绿色的网址，在您的浏览器，这可能是你想要的地址栏中，在这种情况下我只是删除了“的。aspx”在结尾。

Conclusione 结论

I DD vanno ad arricchire le funzionalità delle WebForms, offrendo un framework per realizzare applicazioni web data-driven.该署副署长应以丰富的WebForms功能，提供了一个框架，以实现数据驱动的Web应用程序。 In questo post abbiamo visto brevemente come iniziare ad usarli vedendo i principi di base del loro funzionamento.在这个后，我们看到了简要如何开始使用他们看到自己的运作的基本原则。

I DD offrono comunque un meccanismo che permette molte forme di personalizzazione , permettono di usare dei template particolari per fare il rendering di campi specifici di una tabella usando ad esempio i controlli dell' AJAX Control Toolkit o di terze parti ad esempio per selezionare un calendario, oppure uno slider per decidere una quantità numerica.副署长我仍然有一个机制，使各种形式的定制允许使用的模板，使例如细节渲染表的特定区域使用的控制氏例如AJAX控件工具包或任何第三方选择一个日历，或滑块以选择一个数字量。 Le pagine degli ASP.NET Dynamic Data sono già pensate per sfruttare i controlli ASP.NET AJAX. ASP.NET动态数据的页面已经旨在充分利用的ASP.NET AJAX控件。

Altri attributi consentono di impostare delle regole di validazione sul modello dei dati, ad esempio posso impostare tali regole direttamente sulle proprietà delle classi generate da LINQ to SQL, creando delle partial class .其他属性允许您设置数据验证规则模式，为举例来说，我可以设置这些规则直接生成的由LINQ到SQL类的属性，创建部分类。 Questo meccanismo consente di accentrare le regole di validazione, che poi “fluiscono” nella UI e valgono in qualsiasi pagina web si faccia riferimento a quella specifica classe...这种机制使集中的验证规则，然后“流”的用户界面，并且在任何网页你指的是特定类的有效...

Spero di avere stuzzicato la vostra curiosità , almeno per chi non ha ancora avuto modo di provare i nuovi ASP.NET Dynamic Data.我希望我已经激起了您的好奇心，至少对那些谁尚未有机会尝试新的ASP.NET动态数据。

第2部分

Nel primo post di questa serie abbiamo visto come realizzare una prima applicazione con ASP.NET Dynamic Data (DD).在这个系列，我们看到如何与ASP.NET动态数据（DD）的首次申请的第一篇文章。 Come dicevo i DD sono pensati per scenari di rapida prototipazione, dove con poco realizziamo un sito completo partendo dalla basedati.正如我所说的DD方案是用于快速原型，所设计的，只有建立一个网站，以完成该数据库的一部分。 Ci tengono a ricordare che questa è solo una possibilità in più, non in meno, possiamo naturalmente partire da zero usando WebForms o, quando sarà rilasciato, ASP.NET MVC e in base ai gusti scrivere più o meno codice oppure optare per un modello piuttosto che per l'altro.我们必须强调，这只是一次机会更多而不是更少，当然，我们可以从头开始使用的WebForms或者，当它被释放，ASP.NET MVC的，和您的口味或多或少不同的代码编写或选择一个模式，而对其他。

Nonostante siano pensati per scenari RAD, però, i DD danno una buona possibilità di personalizzazione: in questo post vedremo come:虽然他们是专为RAD公司的情况，但是，副署长给出了一个定制的机会：我们将看到一个职位：

Esporre solo alcune tabelle只有少数几个公开表
Visualizzare o meno le colonne delle tabelle esposte显示或隐藏的表列集
Personalizzare il comportamento di visualizzazione delle colonne自定义栏的行为展示

Quali tabelle esporre展出的表

Usando l'attributo scaffoldAllTables nel global.asax abbiamo infatti esposto tutte le tabelle del nostro db.使用属性scaffoldAllTables global.asax中，实际上我们都暴露在我们的分贝表。 Potremmo, invece, operare selettivamente impostando a false tale attributo e andando a abilitare la/le singole tabelle.我们可以，不过，操作选择地设置此属性为false，将启用/单个表。 Per ogni tabella su db, LINQ to SQL, ha creato una classe partial , che possiamo vedere nel codice del file .dbml.对于每个数据库表中，LINQ to SQL中，创造了一个局部类，我们可以看到代码文件。Dbml。 Vediamo ora proprio come estendere queste classi, aggiungiamo un nuovo file Order.cs , che definisce una nuova classe parziale con qualche attributo in più, come mostrato nel seguito:现在让我们看看是如何将这些类，我们添加一个新的文件Order.cs，它定义了另外一些属性一类新的部分，如下所示：

Il nuovo namespace System.ComponentModel.DataAnnotation consente di usare l'attributo ScaffoldTalble , con cui possiamo rendere o meno visibile la tabella ai DD.新的命名空间System.ComponentModel.DataAnnotation让你使用属性ScaffoldTalble，这使我们可以使表或不可见的副署长。 Quindi nel nostro caso abbiamo impostato l'attributo scaffoldAllTables in global.asax a false, mentre abbiamo impostato per la classe Order (e anche Product ) l'attributo ScaffoldTable a true .因此，在我们的情况下，我们将此属性设置为在Global.asax虚假scaffoldAllTables，虽然我们的Order类的集合（产品）ScaffoldTable属性设置为true。 Se lanciamo l'applicazione ora vedremo “scovate” dai DD due tabelle, come in figura:如果我们运行应用程序，我们将看到“刷新了由副署长”两个表中的图片，如下：

Controllare le colonne che vengono esposte检查列曝光

Se andiamo a vedere le colonne della tabella Orders, cliccando sul link, notiamo che sono presenti tutte le colonne definite nella tabella, nella figura vedete evidenziata anche la colonna shippedDate, che andremo a modificare nel seguito:如果我们在订单表列，点击链接看，注意，都是在表中定义的列，也可以看到图片列发货证明，我们要改变如下：

Se per qualche ragione non volessimo visualizzarla, ecco che possiamo operare sempre sulla classe parziale precedentemente definita, aggiungendo un attributo ScaffoldColumn , dal comportamento intuitivo, come mostrato in figura:如果由于某种原因，我们希望看到，在这里我们可以经常操作前面定义的部分类，增加一个属性ScaffoldColumn，直观的行为，如图所示

Questa volta abbiamo dovuto scrivere un po' di codice in più (bene :-)), definire un MetadataType , una classe nella quale poi definiamo un po' il comportamento relativo alla colonna ShippedDate.这一次，我们写了一个小的额外代码（以及:-)),定义MetadataType，那么我们定义一个类，其中一些的行为为列发货。 Il comportamento, a meno di errori :-), è quello atteso: se lanciamo il sito e andiamo nella tabella Order, non vederemo più la colonnaShippedDate, l'attributo in questione, infatti, ha detto ai DD di non visualizzarlo più.的行为，减少错误:-)，预计：如果我们推出该网站，我们去议事程序表，不再colonnaShippedDate'll看到问题中的属性，其实，不看副署长说了。 Ometto l'immagine, potete immaginare …省略了图像，你能想象...

Controlliamo il comportamento delle colonne我们监察列行为

Il comportamento in fase di visualizzazione e modifica dei singoli campi della tabella è definito, come abbiamo visto nel primo post, dai template che si trovano nella directory DynamicData\FieldTemplate , dove trovate come viene visualizzato ogni campo di uno specifico tipo: guardate ad esempio il codice di Boolean.ascx e Boolean_Edit.ascx.表中的阅读和各领域的编辑时间行为的定义，因为我们是在后看到的，从模板目录下找到DynamicData \ FieldTemplate，你会发现，因为它是显示每一个特定类型的字段，例如：看看代码Boolean.ascx和Boolean_Edit.ascx。 Ora, se volessi modificare come vengono visualizzati i campi di uno specifico tipo di tutte le tabelle potrei modificare questi template, ma se volessi operare solo sul singolo campo (ShippedDate ad esempio) di una specifica tabella (Orders) potrei (come ho fatto) sfruttare alcuni meccanismi di estendibilità offerti dai DD.现在，如果我想改变显示领域的所有表我可以改变这些模板的具体类型，但如果我想经营一个字段 （如发货特定表 （Orders））不仅可以（像我一样）利用由副署长提供的可扩展性的一些机制。 Guardate il pezzo di codice qui di seguito:看看下面的代码片：

In questo caso sto usando l'attributo DisplayFormat per definire il formato di come deve essere visualizzato il campo in questione (la ShippedDate), in questo caso è una data che verrà visualizzata nel formato mostrato in figura.在这种情况下我使用的属性DisplayFormat界定如何字段应显示在问题（发货），在这种情况下，是一个将在显示格式显示的日期格式。 Inoltre grazie all'attributo UIHint sto indicando ai DD di non usare il template di default per il rendering dell'attributo, ma ho creato un nuovo field template che utilizza il controllo Calendar dell' AJAX Control Toolkit .此外，该属性UIHint'm感谢指向副署长不使用默认的模板渲染属性，但我创建了一个新的模板字段，使用Calendar控件氏AJAX控件工具包。 Non vi mostro il codice che ho usato per la personalizzazione del controllo, che non è molto, lo sto finendo di preparare per la sessione dei Microsoft Days 08 .不显示的代码，我用自定义的控制，这不是很多，我跑出来准备微软天08届会议。 Il risultato visualizzato è il seguente:结果显示如下：

Dove si nota il calendar in fase di editing della colonna ShippedDate.如果您发现在列发货编辑日历。

Conclusione结论

In questo post avete visto come utilizzare alcune tecniche per personalizzare il comportamento di default dei DD, potendo non solo abilitare\disabilitare specifiche tabelle “scovate” dal runtime, ma anche personalizzando il singolo comportamento di un singolo campo di una specifica tabella, aprendo di fatto a molteplici utilizzi.在这个后你看到了如何使用一些技术，自定义默认行为的DD，他们不仅可以启用\禁用特定表“冲出来”的运行，而且自定义一个字段表在特定的个人行为，铺路的事实多种用途。 I DD sono, in oltre, già compatibili con ASP.NET AJAX e anche con l'AJAX Control Toolkit, non ultimo potreste anche voler utilizzare controlli di terze parti per specifiche esigenze….该署副署长的，此外，已与ASP.NET AJAX兼容，并与AJAX控件工具包，而不是至少你可能也想使用特定需要的第三方控制.... insomma non male, vero?在短，不坏，不是吗？

链接

MSDN library ASP.NET Dynamic Data MSDN库ASP.NET动态数据

www.asp.net/dynamicdata/ www.asp.net/dynamicdata/

Sharepoint 2010概述开发

革命 — Mon, 26 Oct 2009 04:13:06 GMT

第1部分

SharePoint 2010 è stato da poco prensentato al pubblico per la prima volta.共享点2010年刚刚首次prensentato公众。 Ho deciso di raccontarvi un po' le novita che saranno presenti in questa release, poichè di sicuro interesse per molti sviluppattori web e, mi aspetto, sempre più nel prossimo fututo.我决定告诉你一个小'的创新是本新闻稿中，利益关系的许多sviluppattori网站，我希望越来越多的在未来fututo。

La beta di SharePoint sarà disponibile a novembre, mentre da poco è già disponibilie la beta 2 di Visual Studio 2010 per i sottoscrittori MSDN.测试版的SharePoint将在11月，但最近已经提供的Visual Studio 2010测试版2为MSDN订户。

Per una overview della novità annunciate per SharePoint 2010 leggete il post di Jeff Teper , nei prossimi post cercherò di raccontare le novità più importanti per gli sviluppatori web.对于这一消息公布的SharePoint概述2010年，经过从杰夫泰珀后的下一个职位，我会尽量叙述了Web开发最重要的新功能。

Sviluppo in Windows 7 e Windows Vista SP1在Windows 7和Windows Vista SP1的发展

Il nuovo SharePoint 2010 supporterà solo l'archittettura a 64-bit, scelta che va a vantaggio di una maggiore scalabilità del prodotto grazie alla possibilità di sfruttare al meglio la memoria.在新的SharePoint 2010只支持64位架构的选择，是为增加产品的可扩展性利于通过利用记忆能力。

La novità più importante è che potrà essere instato, solo a scopo di sviluppo e non per la produzione, su macchine client a 64 bit, in partricolare su Windows 7 e Vista SP1 .最重要的是，只能用于发展目的，而不是用于生产，64中的 Windows 7和Vista SP1 partricolare位客户机统局。 Potrete installare sia SharePoint Foundation 2010, che SharePoint Server 2010 in locale sulla macchina in cui avete VS 2010.您可以安装这两个基金会，共享点 2010，SharePoint服务器2010年在本地计算机上，您有队2010年。

Visual Studio 2010 SharePoint Tool共享点的Visual Studio 2010工具

Visual Studio 2010 diventa lo strumento principale per lo sviluppo su SharePoint. 的Visual Studio 2010年就成为SharePoint开发的主要工具。 Appena installerete VS 2010 beta 2 troverete molti nuovi template di progetto (oltre che numerosi nuovi project item) per SharePoint 2010.刚刚安装队2010 Beta 2的引入了很多新的项目模板 （以及几个新的工程项目）用于SharePoint 2010。 Nella schermata seguente potete averne un'idea:在接下来的屏幕上，您可以有一个想法：

Lo sviluppo per SharePoint con Visual Studio 2010 si semplifica molto, infatti non solo potrete sviluppare su un sistema operativo client una progetto di tipo Visual Web Part, sfruttando l'IDE di Visual Studio 2010, ma di questo verrà creato un SharePoint Solution Package file (file WSP) di cui poi ne verrà fatto anche il deploy sul server.用于SharePoint开发与Visual Studio 2010是很容易在事实上，，不仅可以开发一个像Visual Web部件项目客户端操作系统，使用Visual Studio 2010年，但这将创建一个SharePoint解决方案包文件（ wsp文件），当年也将在服务器上部署。

Oltre ad i template di progetto presenti in Visual Studio 2010 potete anche crearne di nuovi o estenderli grazie alla nuova Visual Studio extensibility API , che vi permette di migliorarne il packaging, la validazione, il deployment, il tutto anche estendendo i nodi del Server Explorer.除了这些项目模板，您也可以创建新的或扩展新的Visual Studio 可扩展API，它允许您以改善包装，验证，部署他们，所有节点同时扩展服务器资源管理器在Visual Studio 2010。 E' possibile ad esempio personalizzare il processo di build e deploy fatto da VS 2010 di feault aggiungento eventuali azioni custom e/o rimuovendo quelle di default. é'例如，可以自定义队2010年建造的制作过程，并部署到feault添加任何自定义操作和/或删除默认的。

Infatti potete accedere ai sites di SharePoint 2010 direttamente dal Server Exporer e potrete guardare le impostazioni per siti, liste, content type, associazioni di workflow e altri oggetti.事实上，您可以从SharePoint 服务器 2010年Exporer的网站，你可以直接监视网站，列表，内容类型，协会和其他工作流对象的设置。 Nella figura seguente potete farvi un'idea di come si naviga in SharePoint da Visual Studio.下图你可以得到一个如何在SharePoint导航与Visual Studio的想法。

SharePoint Designer 2010 SharePoint设计2010

Il nuovo SP Designer è lo strumento per lavorare con SP rivolto ai “Power User”- ma non solo direi- per reallizzare applicazioni con SP 2010.新的警司Designer是工作的工具与SP给“超级用户” -但不是说在2010年reallizzare与SP应用。 Una volta che la soluzione è stata realizzata questa può essere pacchettizzata in una SharePoint Solution (WSP) per poi essere importata e modificata con Visual Studio 2010.一旦该解决方案已经实施，可以封装在一个SharePoint解决方案（WSP）和进口，然后与Visual Studio 2010年修改。

Nella schermata seguente vedete SP Designer come si presenta: il menu di navigazione sulla sinistra dà accesso alle componenti che potete sviluppare dal Designer: libraries, workflows,在下一个屏幕上可以看到它是什么样子看起来警司设计师：在左侧的导航菜单中可以访问的组件，您可以通过设计开发：图书馆，工作流程，

content types, data source, entities, site level settings etc.内容类型，数据源，实体，站点级别的设置等

SharePoint Designer 2010: Workflow SharePoint设计2010年：工作流程

Con il nuovo SP Designer si potrà importare un workflow preparato, per non dire illustrato, da un' analista usando Visio e si potrà poi dargli vita attraverso uno strumento visuale senza scrivere codice: azioni tipiche dei power users.随着新的警司设计师可以导入工作流程的准备，可以说，传单，一'分析师使用 Visio，您可以给它通过一个可视化工具，无需编写代码的生活：电力用户的典型行动。 Il nuovo Workflow potrà essere quindi esportato in un file WSP e successivamente importato in VS 2010.新的工作流，然后出口到wsp文件，并导入到2010年的队。

SharePoint Designer 2010: Business Connectivity Services Design SharePoint设计2010年：商业连接服务设计

Il Business Connectivity Services sono l'eveoluzione del BDC, consentendo di esporre in SharePoint tramite le External List dati provienienti da sorgenti esterne allo SP.商业连接服务是eveoluzione该BDC，让您在SharePoint列表的数据显示，通过外部，从外部源头到SP来源。 Lo SP Designer 2010 semplifica la creazione delle entità che rapprenentano questi dati tramite un wizard che guida verso la creazione di una connessione a servizi WCF, oggetti .NET, Database etc. 2010年的SP设计简化了实体创造，rapprenentano通过一个向导，这些数据对建立一个连接到WCF服务，指导他们的对象。NET中，数据库等。

Developer Dashboard开发仪表板

Nuovo utile strumento di debug, che ci consente di avere utili informazioni su quello che sta succedendo nella pagina: la developer dashboard colleziona informazioni statistiche relative al codice eseguito nella pagina ed eventuali eccezioni.新的有用的调试工具，它可以让我们对所发生的事情上页：仪表板的开发有关的统计资料收集的代码在页面上的任何异常运行有用的信息。

Può essere abilitata inizialmente così: 5月批准初步排定如下：

stsadm –o setproperty –pn developer-dashboard –pv OnDemand 通过Stsadm邻的setProperty -通知书开发商，仪表板，光伏按需

Può poi essere spenta e/o accessa dalla pagina dello SharePoint.然后可以关闭和/或从SharePoint访问。

第2部分

Sandboxed solutions沙箱解决方案

Una delle novità più interessanti della prossima release di SP 2010 sono le Sandboxed solution .其中一个最的SP二千○十顷沙箱解决方案的下一个版本有趣。 Un nuovo modo di creare e deploiare soluzioni in Share Point 2010 con VS 2010 che può essere scelto durante la fase di deploy, come si vede dalla figura seguente:一种新的方法来创建和共享点deploiare在2010年在VS 2010解决方案可以在部署过程中选择，如下图所示：

Le Sendboxed solution offrono le seguenti caratteristiche:该解决方案Sendboxed提供以下功能：

facilità di deploy nella farm e su SharePoint OnLine, sicurezza nel far girare le applicazioni che girando in una sandbox (=uno spazio a loro dedicato), offrendo maggior stabilità e basso rischio di compromettere l'intera farm. 易于部署 ，在农场和SharePoint网络，安全应用软件运行在沙箱中运行（=一个专门给他们空间），提供更稳定，危及整个农场的风险较低。
Lavorano con un insieme ristretto di API SharePoint : Content Types, Site Columns, Custom Actions, Workflow dichiarativi, Event Receivers, Feature Receivers, List Definitions, Site Pages, etc.工作与共享点的API有限：内容类型，网站栏目，自定义操作，工作流声明，事件接收器，接收器功能，列表定义，网站网页等。
- Un sottoinsieme di Microsoft.SharePoint. Microsoft.SharePoint一个子集。 Qui trovate la lista completa dei tipi abilitati .下面是通过类型的完整列表。
Un meccanismo di Code Access Security (CAS) ne limita le funzionalità rispetto ad una soluition che gira in full-trust.一个代码访问安全（CA）的机制，限制功能相比soluition全面运行信任。 Le impostazioni sono le seguenti:在设置如下：
- SharePointPermission.ObjectModel SharePointPermission.ObjectModel
- SecurityPermission.Execution SecurityPermission.Execution
- AspNetHostingPermissionLevel = Minimal AspNetHostingPermissionLevel =最小
Vengono deploiate in una Solution Gallery , che può essere gestita centralmente e dal Central Admin è possibile stabilire quali risorse massime l'applicazione possa consumare.是deploiate 解决方案库，可管理，由中央管理的中央有可能确定哪些资源，应用程序可以消耗最大。
- Le risorse possono essere diverse: CPU, Memoria, SQL etc e vengono misurate in 'Resource Point'.资源可能是不同的：CPU，内存时，SQL等，并在'衡量资源点'。

第3部分

Le funzionalità di SharePoint 2010 raccolte in una slide. 2010年的SharePoint功能，在幻灯片中收集的。

Non tutte per soli developer, non vi preoccupate.不是只有开发商所有，请不要担心。

Composites 复合材料

Business Connectivity Services商业连接服务
InfoPath Form Services InfoPath窗体服务
External Links外部链接
Workflow工作流
SharePoint Designer SharePoint设计
Visual Studio视觉工作室
API Enhancements API改进
REST/ATOM/RSS的REST /的Atom / RSS

Sites 网站

Ribbon UI功能区用户界面
SharePoint Workspace SharePoint工作区
SharePont Mobile SharePont手机
Office Client and Office Web Application办公室客户端和Office Web应用程序
Sandbox Support沙盒技术支持

Communities 社区

Tagging, Tag Cloud, Ratings标签，标签云，评级
Social bookmarking社会书签
Blogs and Wikis博客和wiki
MySites MySites
Activity Feeds活动订阅
Profiles and Expertise概况和专业知识
Org Browser牛津浏览器

Content 内容

Enterprice Content Types内容类型企业单位
Metadata and Navigation元数据和导航
Documents Sets文件集
Multi stage disposition多级配置
Audio and Video Content Types音频和视频内容类型
Remote Blob Storage远程一滴存储
List Enhancements名单增强

Search 搜索

Social Relevance社会意义
Phonetic Search语音搜索
Navigation导航
FAST Integration快速集成
Enhance Pipeline加强管道

Insights 见解

PerformancePoint Services的PerformancePoint服务
Execel Services精通办公自动化服务
Chart Web Part图表Web部件
Visio Services Visio的服务
Web Analytics网络分析
SQL Server Integration SQL Server集成
PowerPivot PowerPivot

Visual Studio 2010 beta 2: a quick web tour

革命 — Mon, 26 Oct 2009 04:00:06 GMT

Now that Visual Studio 2010 beta 2 has been released, you can have some fun exploring it, starting from the new splash screen :-)

In this post I’m going to explore some of the news for web developer, not all but at least some:-)

A quick look at Silverlight 3.0

Silverlight 3.0 is now integrated in Visual Studio 2010 beta 2 : the developer runtime and the SDK are installed during the setup process.

If you take a look to the project template you can see an options section with a combo-box for multi-targeting even for Silverlight.

Multi-targeting is one of the main architectural changes of Visual Studio 2010: you can now use a single IDE for targeting different versions of the full .NET and CLR. You can write code for .NET 2.0, 3.0 and 3.5: they use the CLR version 2.0 and the new .NET Framework 4 that instead uses the new CLR 4.

Note: the RIA Services are not completely integrated with this build.

With the beta 2, you can find an interactive editor for Silverlight , similar to the WPF. In the Following screen I’m using it to create some columns and rows and setting the columns size directly into the editor.

An you can now double-click on the button in the preview pane to go to the click event hander to start writing code.

Now that F# is a prime language for the .NET Framework 4 and Visual Studio 2010 you can even create a Silverlight Library in F# and start using functional programming, if you like it, even for Silverlight. The F# Silverlight Library is a project template in beta 2 that you can add to your solution.

To use it with Silverlight you can add a reference from the standard Silverlight project in Visual Studio 2010 to the F# library for Silverlight, I ‘ve tried to build some simple code in a F# module as show below; a simple example of calculus for the factorial using a recursive function.

And than you can call the MathModule as a static class from Silverlight code as usual C# or VB.NET code:

You could imagine a sophisticated computations.

A quick look at ASP.NET MVC 2

Visual Studio 2010 will be shipped with ASP.NET MVC 2 project template and you can start playing with it right now with the beta 2 bits. You can find all the stuffs that are already available with ASP.NET MVC 2 Preview 2 for Visual Studio 2008 as Validation based on Metadata, Client Side Validation and Single Project support for Areas: an easy way to logically divide you project in independent parts.

If you have already created a project with ASP.NET MVC 1.0 in Visual Studio 2008 you can’t open it in Visual Studio 2010 beta 2 and you have to migrate it manually or using this tool. If you have instead created a project with ASP.NET MVC 2 Preview 2, you should reasonably succeed to migrate it to Visual Studio 2010 beta 2. I’ve opened one of my project built on ASP.NET MVC 2 Preview 2 and the Visual Studio 2010’s wizard have done the hard work for me. A message box asked me if I wanted to update the project to .NET Framework 4, as show below:

At the end the solution works fine, at least on “My Machine” :-).

If you run the web app with the ASP.NET Developer Server you can see now that it’s running with the version 4 of the .NET Framework, as you can see below:

Thanks to the new syntax of ASP.NET 4 you can even write code without the need of using HTML.Encode, using the syntax below:

Instead of the more verbose:

Ok, some syntactic sugar, but of course if you write it hundreds of times…

For more details you can read the Phil Haack post : VS10 Beta 2 From an ASP.NET MVC Perspective.

A quick look at ASP.NET 4 Web Forms

You have now the chance to create a project structurally similar to ASP.NET MVC one: I mean with CSS, a Home and About pages. If you create a ASP.NET Web Application project and you press F5, for example, you’ll see the following screen:

In the project you can even find jQuery 1.3.2 in the Scripts folder.

If you came from Visual Studio 2008 and you prefer to have a blank solution, you have to choose the Empty Project Template.

One of the most evident new feature of ASP.NET 4 (both Web Forms and MVC), already present from beta 1, is that you can have different config files for debug and release and other configurations. For example you already have a Web.Debug.config and Web.Release.config for the two different configuration.

For example you can use the two files to set different connection strings for debugging and production.

Code Snippets

You can now find some pre-build code snippets that works in the aspx editor, for example you can choose formview snippet as show below

And the editor generate some code for you:

This make more productive writing code directly into the editor, skipping the boring stuff.

ASP.NET 4 WebForms Routing

ASP.NET 4 WebForms can now use routing rules as much as ASP.NET MVC does. You can now use urls that are SEO friendly and human readable, for example

localhost/blog/archive/1

instead of

localhost/blog/default.aspx?Id=1

Just adding some code on the global.asax to define the rules:

You can then retrieve data used in the rules and using it in code-behind or even create a new url using the same rules. I suggest you reading the ScottGu’s post on this topic here.

ClientIDMode and ViewStateMode

If in the past you have had some problem with client id generated by Web Forms , “ctrl_” nested especially when you use master-page… now you have some good news, because you can set the behavior on a control:

You can inherit from the parent, make it predictable so that it can be easily used with CSS and Javascript or just static.

And you can turn off view state for a page and enable for a control using the control property ViewStateMode.

Download

To fully explore Visual Studio 2010 beta 2 I strongly encourage you to download from here.(from 21/10). MSDN Subscriber can download just from today.

You can read the official announcement from here.

Per gli italiani che leggono questo post, ci saranno diverse occasioni durante l’anno per parlare delle novità di Visual Studio 2010, una fra tutte sono i Microsoft TechDays WPC 2009.

Web Platform Installer 2.0

革命 — Mon, 26 Oct 2009 03:43:01 GMT

Overview

Now that the Web Platform Installer 2.0 is RTW, WebPI for short, I’ll have some fun exploring some installation options with a series of posts.

The Web PI is the easiest an quickest way to install software on Windows to run web applications. You can use it to run ASP, ASP.NET and PHP applications. If you are a developer that works both in ASP.NET and PHP or you need to run multiple apps running different runtimes, I think that it’ll be a useful tool and even for free! You can install IIS and related extensions, SQL Server 2008 Express, Visual Web Developer 2008 and others free tools or trial for web developers.

After you install the Web PI you can use it even to update your current installation. The Web PI allows you to install beta/RC and RTM components. If you run it when a new release is available you can install the latest ones.

Web PI is now available in 9 different languages.

From the Web Platform Installer 2.0 you have access to Web Gallery, where you can download and run the most popular open source apps, both for ASP.NET and PHP. If you choose one of that app you have a straightforward installation experience directly inside the Web PI.

The Web PI run on Windows Vista, Windows Vista SP1, Windows XP SP2+, Windows Server 2003 SP1+, Windows Server 2008 and Windows 7.

You can download the Web PI from here, from this link you can easily choose you language.

Running Web Platform Installer from Windows XP

If you run it from Windows XP (I’m running an instance of WinXp from my Windows 7 machine using the XPMode feature), you’ll see something similar:

As you can see it’s easy to understand, there are three tabs:

What’s News ? : for the latest components available and new apps from the Gallery: you can see Moodle, SugarCRM, Sitefinity Community Editions etc.
Web Platform: all the settings related to the configuration of IIS
Web Applications: apps from the Gallery sort by categories

If you look at the left-bottoms corner you can click the Options link that opens up a new dialog where you can see more options:

You can see two check buttons for more tabs for IIS Media Features and Developers tools. Because I’m running on Windows XP, no real Media Extensions are available and I only see the Developer Tools tab. At the end you can notice the preferred language you can use for software installation. At the end you can delete the installer cache. Flagging the Developer tools you can see a new tab on the menu:

Now you can click on the link “Click to include the recommended products”, or “Customize” to see the products suggested and start the installation.

Running Web Platform Installer from Windows 7

I’m running it from Windows 7 now, and of course I can see more options, that we’ll see in more details in a different post.

After I flag the two check boxes in the options window (see the image upward for the XP) I can even see a new tab for Media stuffs: where, for example, you can install the necessary components for delivering on-demand and live contents via Media Services.

As you see from this post the Web PI is easy to use, in the following post we’ll explore some settings in the Web Platform tab in my Windows XP machine and Windows 7.

Web Platform for Windows XP

For an overview of the Web PI 2.0 you can read my previous post of these series here, before you proceed reading.

In this post I’ll dig into the options available for Windows XP users in the “Web Platform” tab, as show below (as they show on my machine):

Here you can see these sections: Web Server, Framework and Runtimes, Database and Tools. If I click customize you see the products/components you can install. If you expand clicking on customize you see the details, with a little info icon. If you click the little info icon you’ll see more info on the component to install.

In the following section you’ll see more info trying to install some software on my Windows XP virtual machine.

Installing components from Web Server

For example if you click in the Internet information services 5.1

You’ll see the description for IIS 5.1:

alt=image title=image border=0 v:shapes="_x0000_i1037">

Here you have the options to install some products, the most interesting ones for me are:

IIS 5.1 : of course for running my web apps
FastCGI 1.0 for IIS 5.1 : is an extension for IIS that you can use for running PHP application in both reliable and fastest way. I strongly recommend this if you plan to run PHP applications on Windows.
Web Deployment tool: this is a free tool that can be used for different purposes, the nicest features is that it can be used to package a site with all related contents : database, ACL, GAC, COM objects, Registry settings to be easily used for deploy on another machine or to migrate sites/web applications from IIS 6.0 to IIS 7.0

You can now select your preferred:

Then click the install button…

Now you can see that the WebPI add some dependencies for me. I’ll install the Web Deployment Tool 1.0, Italian version because I’ve selected the Italian language in the options link, see my previous post, and the Web PI added two dependencies : SQL Server 2008 Management Objects and SQL Server Native Client, nice !!

If “I Accept”, the setup starts:

And all works on my machine :-), and I can see the final screen:

etc voila, we’re done.

Installing components from Framework and Runtimes

In this section you can install .NET Framework 3.5 SP1, that is already installed on my machine and that you need if you’d like to run ASP.NET Web Forms applications. You can also install the ASP.NET MVC 1.0 framework, now you can use the Model-View-Controller pattern with ASP.NET core features. And you can install the PHP runtime 5.2.11; so you could run both ASP.NET and PHP apps on Windows Web Platform. OK I don’t suggest you using XP on production servers, but for developer purposes it could be done.

You have the review screen, again, and you’re ready to install.

Installing components from Database

From here you have the options to install SQL Server 2008 Express ( that it’ free) and related stuffs, for example the Management Studio: the console used to administer SQL Server 2008.

You can see the screenshot on my machine: SQL Server 2008 Express with Service Pack 1 and the Managements Objects are already installed.

In the review screen I can see that the Web PI installs even Windows PowerShell as a dependency from the Management Studio Express:

Installing Tools

In the tools section you can download Visual Web Developer 2008 Express with SP1, a free tool, and the Silverlight 3 tool for Visual Studio, even this tool is for free.

Ok now you’re ready for building and running web apps. We’ll see in a later post how to install one app from the Gallery.

Web Platform for Windows 7

Now I’ll use the Web PI on my Windows 7 machine and I’ll show the options available.

You can start from main screen and select the “Web Platform” tab:

Here you can see these sections: Web Server, Framework and Runtimes, Database and Tools. If I click customize you see products/components you can install. If you expand clicking on customize you see the details, with a little info icon. If you click the little info icon you’ll see more info on the component to install.

Installing components from Web Server

If you look into the options for IIS 7.x web Server you can see a lot of functionalities that you can install. I’ve already installed ASP.NET module that I use for ASP.NET apps, the CGI that install the FastCGI module and that I use for PHP apps. IIS 7 is a modular web server and you can decide which module to install based on your needed. One of my preferred module is the URL Rewriter, version 1.1. You can use to build rules to implement nice URL for users and for Search Engine Optimization (SEO). You can use Regular expression, pattern matching, Wildcard pattern matching or rewrite maps.

You can see a ton of features available for IIS 7.5:

Now I can proceed with the installation, before I need to check the software I decide to install and related dependencies.

One of the component I’d like to install is the URL Rewriter 2.0 Beta, that it’s very attractive because it supports outbound rules: that can fix links on the fly in a response from the server. Because is a Beta I don’t see in this section, so I go to the “What’s new Tab” and I can see the “Beta Extensions” where I can found the URL Rewriter 2.0 Beta.

Because the URL Rewriter 1.1 and the URL Rewriter 2.0 beta can’t run on the same machine, if I select the check box I receive a warning message.

So I need to uninstall version 1.1 from Control Panel and install the version 2.0 beta from Web PI.

Installing components from Database

In this section you can find the same components you can find for Windows XP, plus the SQL Server driver 1.0 for PHP, a native extension for PHP apps, that you can install on Windows 7, as see below:

Installing components from Framework and Runtimes, Tools

These two sections are basically the same as we saw on Window XP, and you can refer two the previous blog for details.

Next step, installing some application from the galley … stay tuned.

Installing PHP Apps

In this post I’m going to explore the most important feature for the version 2.0 of the WebPI: now you can install the most popular Open Source applications for both ASP.NET and PHP directly from the installer.

Installing WordPress (PHP)

You can use the Web Applications’ tab to choose your preferred ones, you can navigate by category or by name, for example. In the following pictures I’ve select WordPress:

You can now press install and you’ll be redirected to a summary page where the installer show all dependencies needed to run WordPress. Because I haven’t installed MySQL, the Web PI 2.0 will install it for me and even other components as the URL Rewrite module. I really love this feature!! The following is an image of that one:

I’m guided, inside the installer, to the process of installing the software.

First I need to set the password for MySQL’s root account as show below:

Than I need to enter some site information, so, for example, Web Site name in step 1, as show below:

And some information for creating and configuring the database:

And at the end of installation you can run your application from the Launch Link and you have the first screenshot of WordPress installation page:

As you have briefly seen you could easily use the Web PI both for installing and configuring your environment and for installing your preferred apps in some simple steps.

Installing ASP.NET Apps

In this post we’ll the Web PI 2.0 to install BlogEngine.NET, one of the most popular Open Source applications for ASP.NET.

Installing BlogEngine.NET (ASP.NET)

You can use the Web Applications’ tab to choose your preferred one, you can navigate by category or by name, for example. In the following pictures I’ve select BlogEngine.Net:

You can now press install and you’ll be redirected to a summary page where the installer show all dependencies needed to run BlogEngine.NET, a few on my machine, as shown in the following image:

I’m guided, inside the installer, to the process of installing the software, I need to enter site information, so for example Web Site name and others, as show below:

And at the end of installation you can run your application from the Launch Link and you have the first screenshot of BlogEngine.NET installation page:

And we’re done!

As you so you could easily use the Web PI both for installing and configuring your environment and for installing your preferred apps in some simple steps.

ASP.NET MVC 2 Preview 2: Client-Side Validation

革命 — Mon, 26 Oct 2009 02:56:53 GMT

ASP.NET MVC 2 Preview 2: Client-Side Validation

In my opinion one of the most interesting features of ASP.NET MVC 2.0 Preview 2 is the support for client-side validation.

How-to enable Client-Side validation

Client-side validation enable your application to perform client-side validation based on model’s validation by JQuery validation library. Ok, it’s simpler than it sounds.

The client-side validation framework is even extensible, but for now it suits my simple needs.

In my post on ASP.NET MVC 2.0 Preview 1 I’ve added server-side validation to my application model using metadata as ASP.NET Dynamic Data does. So, for example, in the the picture below I’ve added a partial class to my model and a class for metadata describing my requirements for validation. In the following code the attribute ‘Titolo’ must be not null, and I’ve added an Error Message if something’s wrong.

If I run the application all works fine: I show a view page to the user, user enters some value and press Save to submit to server. If the user doesn’t fill the title field he gets an error as soon as we made a POST to server. You can see the page flickering in the browser.

Client-side validation prevent your app going to the server for validation and all happens client side, but using the rules you have defined on the partial class you saw before.

To enable client side validation, you can follow these easy steps:

· use Html.EnableClientValidation method on the View file

· insert three javascript files : jquery-1.3.2.js, jquery.validate.js, MicrosoftMvcJQueryValidation.js. These files are included in the Scripts directory coming with ASP.NET MVC 2 Preview 2 project template.

I’ve put the code in my view page for editing some simple fields.

Now I can run my application and see the results, I’m using HttpWatch to see that no requests are performed to the server and the validation logic works as expected.

As soon as I type something into the textbox the red message disappears.

Nice feature! You can download the ASP.NET MVC 2 Preview 2 from here and read about all the features on Phil Haack post.

新的ASP.NET MVC 2 -预览1

Dato che oggi è stato rilasciata la preview 1 di ASP.NET MVC 2 ho deciso di aggiornare il progetto che avevo usato a Remix09 alla nuova versione per esplorare un po' delle nuove funzionalità.因为今天被释放的ASP.NET MVC 2预览1，我决定升级项目我以前Remix09新版本探索出的新功能位'。 (ASP.NET MVC 1.0 e ASP.NET MVC 2 possono coesistere side-by-side senza problemi) （ASP.NET 1.0和ASP.NET MVC的MVC的2可以共存并排而任何一方的问题）

Nella Release Note è documentato come aggiornare manunalmente il progetto, modificando gli assembly referenziati e il web.config.在发行说明文件manunalmente如何更新项目，修改程序集引用和Web.config。

Nel mio caso, dopo aver scaricato ed installato i bit ho creato un progetto con il nuovo template per Visual Studio 2008 SP1, che vedete in figura :就我而言，后下载并安装了我创建了一个新模板的Visual Studio 2008 SP1的项目位，你在图片中看到：

Quindi ho fatto un semplice taglia e copia dei folder che mi intersessavano, più qualche modifica:所以，我犯了一个简单的剪切和复制的文件夹，我intersessavano，另外还有一些变化：

AppData: che conteneva il database delle sessioni应用程序数据：含有数据库会话
il file remix09.css che ho messo nel folder Content remix09.css我把文件夹中的内容文件
il mio controller HomeController.cs我的控制器HomeController.cs
Tutto il contenuto della cartella Model, che contiene i file per implementare il Repository per le sessioni ISessionsRepository.cs, la classe repository SessioniRepository.cs ed il file di Entity Framework per le cassi del mio modello您的模型，其中包含文件来实现会议的ISessionsRepository.cs库的全部内容，班级库SessioniRepository.cs和文件实体框架来对我的模型的库房
ho aggiunto la stringa di connessione al mio web.config我添加了连接字符串以我的web.config
Ho sostituito il folder Views/Home con le view che avevo fatto余取代了我这样做了的文件夹视图/首页
Ho sostituito la pagina Views/SharedViews/Site.Master con quella usata nel vecchio progetto余取代了页面浏览量/ SharedViews / Site.master所使用的旧的项目
ho fatto il find & replace del namespace che usavo nel precedente progetto con il nuovo namespace, che nel mio caso si chiama Remix09Mvc2preview1 (il nome che ho dato al progetto).我的确发现和替换的命名空间，我在与新的命名空间，这对我来说，以前被称为Remix09Mvc2preview1项目中使用（这个名字我向项目）。 Attenzione alle views che se strongly-typed, come nel mio caso, contengono il riferimento al nome completo delle classi.注意事项的意见，如果强类型，因为在我的情况，包括对完整的类名称引用。
ho aggiunto nella sezione assemblies, nel web.config, il riferimento, prendendolo dal web.我在web.config节集会补充说，参考，从网络到它。 config del progetto vecchio, a System.Data.Entity che viene usato da Entity Framework配置旧设计的，它是由System.Data.Entity实体框架使用

Ed ecco la mia demo funzionare come prima :这里是我的工作才演示：

DataAnnotation: validazione DataAnnotation：验证

Una delle novità riguarda l'utilizzo del meccanismo delle DataAnnotation, già usato dai Dynamic Data e nei RIA Services, con cui posso aggiungere degli attributi alla mia classe del Modello, nel mio caso ho un'unica classe che descrive una “Sessione”, dato che l'intera applicazione consente di gestire le sessione dell'evento Remix.一个改变涉及的DataAnnotation机制的使用，已被俄动态数据和服务，用于我可以将属性添加到我的模型类在我的情况，我有一个类，它描述了一个“会议”，因为整个应用程序允许您管理活动会议不怕。

Nella demo di Remix, potevo creare una nuova sessione, ma non veniva verificato se, ad esempio titolo e sessione fossero valori diversi da null.在演示的不怕，我可以创建一个新的会话，但没有查证，例如标题和本届会议的非NULL值。

Con ASP.NET MVC 2 ho un reference già aggiunto, come vedete dalla figura:在ASP.NET MVC 2我已经添加了一个参考，正如你在图中看到：

Quindi, come con i Dynamic Data, posso scrivere una classe parziale, che andrò ad aggiungere al Model e che mi dà controllo server-side sulle proprietà della mia classe:因此，当与动态数据，我可以写一个局部类，我将添加的标准，使我对我的类的属性控制服务器端：

Ho creato una classe SessioneMetadata nella quale posso specificare delle regole di validazione per le proprietà della classe Sessione.我创建了一个类SessioneMetadata在我指定的类会议属性验证规则。 In questo caso l'attributo Required ed il Relativo ErrorMessage fanno si che se inserisco una sessione vuota abbia degli errori di validazione, per ora (:-) ) server-side, come vedete dalla figura, dove ho usato la stessa View, senza nessuna modifica, che ho usato con la versione 1.0 di ASP.NET MVC.在这种情况下所需的属性及其出错提示的意思是，如果我进入一个空会话已验证错误，现在(:-))服务器端，你可以看到这个数字，在那里我用同样的看法，没有，变化，我与版本的ASP.NET MVC 1.0使用。

VS2010学习

Simplifying Entity Framework: Data-Driven Design

T4 Templates: A Quick-Start Guide for ASP.NET MVC Developers

Beginning Mocking With Moq 3

Part 1

Part 2

Verifying With Predicates

Property Verification

Wrap Up

Part 3

Setting Up Return Values

Returning Mocks From Other Mocks

Summary

A 26-part series of Business Apps Example for Silverlight 3 & .NET RIA Services July Update

ASP.NET 2.0 Membership, Roles, Forms Authentication, and Security Resources – ScottGu’s Blog

The following is excerpt from ScottGu’s Blog:

Consuming an ASP.NET web service or page method using jQuery

Listing 2: A Dummy web service

Listing 4: JQuery .ajax command

Listing 5: Calling a web service using jQuery

Calling an ASP .NET page method

The Best jQuery Modal Dialog Plugins

Introduction to the simplest Mock Framework for .NET – Moq

Moq Home

Screencasts – Introduction to Mocking with Moq

Basic Mocking with Moq

Methods

Matching Arguments

Properties

Callbacks

Verification

Also…

NUnit running VS10 code

MSTest and CruiseControl .NET

How to check Exception message using MS Test

MSBuild, NAnt, NUnit, MSTest, and frustration

Walkthrough: Embedding Localized Resources for a JavaScript File

Compact Web Server in Compact Framework

Serving Silverlight Apps from Windows Mobile

ASP.NET动态数据查询

第1部分

第2部分

链接

Sharepoint 2010概述开发

第1部分

第2部分

第3部分

Visual Studio 2010 beta 2: a quick web tour

Web Platform Installer 2.0

Overview

Web Platform for Windows XP

Web Platform for Windows 7

Installing PHP Apps

Installing ASP.NET Apps

ASP.NET MVC 2 Preview 2: Client-Side Validation