NuPack - Package Management System for the .NET platform Released

NuPack is a free, open source developer focused package management system for the .NET platform intent on simplifying the process of incorporating third party libraries into a .NET application during development.

There are a large number of useful 3rd party open source libraries out there for the .NET platform, but for those not familiar with the OSS ecosystem, it can be a pain to pull these libraries into a project.

NuPack is a free open source package manager that makes it easy for you to find, install, and use .NET libraries in your projects. It works with all .NET project types (including, but not limited to, both ASP.NET Web Forms and ASP.NET MVC).

NuPack enables developers who maintain open source projects (for example, projects like Moq, NHibernate, Ninject, StructureMap, NUnit, Windsor, RhinoMocks, Elmah, etc) to package up their libraries and register them with an online gallery/catalog that is searchable.  The client-side NuPack tools – which include full Visual Studio integration – make it trivial for any .NET developer who wants to use one of these libraries to easily find and install it within the project they are working on.

NuPack handles dependency management between libraries (for example: library1 depends on library2). It also makes it easy to update (and optionally remove) libraries from your projects later. It supports updating web.config files (if a package needs configuration settings). It also allows packages to add PowerShell scripts to a project (for example: scaffold commands). Importantly, NuPack is transparent and clean – and does not install anything at the system level. Instead it is focused on making it easy to manage libraries you use with your projects.

NuPack is itself an open-source project.  The Outercurve Foundation (formerly CodePlex Foundation) today announced the acceptance of the NuPack project to the ASP.NET Open Source Gallery.  Developers - both inside and outside Microsoft – will contribute features, bug fixes and patches to NuPack.

Our goal with NuPack is to make it as simple as possible to integrate open source libraries within .NET projects.  It will be supported in all versions of Visual Studio.  You can start using the first developer preview of it today.

Let’s take ELMAH as an example. It’s a fine error logging utility which has no dependencies on other libraries, but is still a challenge to integrate into a project. These are the steps it takes:

1. Find ELMAH
2. Download the correct zip package.
3. “Unblock” the package.
4. Verify its hash against the one provided by the hosting environment.
5. Unzip the package contents into a specific location in the solution.
6. Add an assembly reference to the assembly.
7. Update web.config with the correct settings which a developer needs to search for.

And this is for a library that has no dependencies. Imagine doing this for NHibernate.Linq which has multiple dependencies each needing similar steps. We can do much better!
NuPack automates all these common and tedious tasks for a package as well as its dependencies. It removes nearly all of the challenges of incorporating a third party open source library into a project’s source tree. Of course, using that library properly is still up to the developer.
Here's a small sampling of what NuPack can do:

To get started using NuPack, you’ll need Visual Studio 2010 installed. NuPack is implemented as a Visual Studio Extension (VSIX). Download the latest release and double click on the NuPack.Tools.vsix file to launch the NuPack Visual Studio Extension Installer.

Launching the Add Package Reference Dialog

There are two ways to interact with the package manager:

• The Add Package Reference Dialog GUI, which gets you started quickly and easily.
• The Powershell based Package Console, for when you need more power and tools.

Let’s start with the Add Package Reference dialog.

1. First, create a new VB.NET or C# application in Visual Studio.

By pure random chance, I’ve chosen to create an ASP.NET MVC 2 application.

2. Right click on the References node within the Solution Explorer and select the Add Package Reference menu option.

This will bring up the Add Package Reference dialog, seen here (click for larger).

The dialog allows you to page through the list of available NuPack packages as well as perform searches against the list of online package. The list of packages is being pulled from an ATOM feed, which can be configured using the Settings button.

Installing a Package

Installing a package is very easy now that we have the dialog up and running.

1. Find the package.

You can either page through the results, or use the search feature. In the Search Online box, type in “elmah”. You should see the following filtered view.

2. Double click the Elmah entry.

That’s it! Behind the scenes, NuPack added the Elmah assembly into a subfolder of your solution, added an assembly reference to that assembly, and also modified your Web.config file with minimal settings to get you started. You’ll probably want to change those settings for a real application.

But you are all set to start using and programming against ELMAH. Visit /elmah.axd within your project to try it out.

Using the Package Console

For those who prefer using the keyboard, NuPack also includes a PowerShell based console for managing packages. The console enables a feature that isn’t available via the Add Package Reference dialog as you’ll see.

To get to the Package Console window, select the View | Other Windows | Package Manager Console menu option.

1. Listing available Packages (List-Package)

Use the List-Package command to list available packages as seen in the screenshot. Note that you get intellisense within the console so if you type List and hit tab, you’ll see a list of options.

This queries the package source and lists the available packages. The nice thing about using PowerShell is that it provides a powerful way of filtering and composing commands. For example, if I only want to list the Id and Description, I can pipe the command to the select command List-Package | select Id, Description

2. Installing a package (Add-Package)

To install a package, run the Add-Package command and specify the Id.

The package will be installed to the default project (specified in the console). You can use the –Project flag to explicitly specify the project.

The console also supplies Intellisense for the package Id.

3. Installing new Console Commands

Earlier, I mentioned that the package console enables a feature that’s not available in the dialog. The feature in question is the ability for a package to contain tools which add new commands to the console.

For example, if you install the prototype Mvc-Scaffold package, a new Add-MvcView command is now available to be called from the console.

This provides a powerful way of extending and automating Visual Studio. In the future, this package might contain commands for completely scaffolding a web application from an object model or a database.

 

Scott Guthrie has posted a good blog on the topic as has Scott Hanselman.

NuPack – Open Source Package Manager for .NET

NuPack is a free open source package manager that makes it easy for you to find, install, and use .NET libraries in your projects. It works with all .NET project types (including, but not limited to, both ASP.NET Web Forms and ASP.NET MVC).

NuPack enables developers who maintain open source projects (for example, projects like Moq, NHibernate, Ninject, StructureMap, NUnit, Windsor, RhinoMocks, Elmah, etc) to package up their libraries and register them with an online gallery/catalog that is searchable.  The client-side NuPack tools – which include full Visual Studio integration – make it trivial for any .NET developer who wants to use one of these libraries to easily find and install it within the project they are working on.

NuPack handles dependency management between libraries (for example: library1 depends on library2). It also makes it easy to update (and optionally remove) libraries from your projects later. It supports updating web.config files (if a package needs configuration settings). It also allows packages to add PowerShell scripts to a project (for example: scaffold commands). Importantly, NuPack is transparent and clean – and does not install anything at the system level. Instead it is focused on making it easy to manage libraries you use with your projects.

NuPack is itself an open-source project.  The Outercurve Foundation (formerly CodePlex Foundation) today announced the acceptance of the NuPack project to the ASP.NET Open Source Gallery.  Developers - both inside and outside Microsoft – will contribute features, bug fixes and patches to NuPack.

Our goal with NuPack is to make it as simple as possible to integrate open source libraries within .NET projects.  It will be supported in all versions of Visual Studio.  You can start using the first developer preview of it today.

A Simple NuPack Scenario – Enabling ELMAH

As a simple example to show off what NuPack enables – let’s assume we are working on a brand new ASP.NET application and want to use the popular open-source “ELMAH” library to log and report errors with our site.  To install ELMAH today, you’d need to manually download it, unzip it, add a reference to your project, make sure you have source control bindings for the library setup correctly, and update the web.config file of your application to include the Elmah HttpModule entries.  All doable – but a little tedious.

With NuPack installed, you can simply open the new “Package Manager Console” that NuPack enables inside VS and type “Add-Package elmah” within it:

Typing "Add-Package elmah” causes NuPack to check an online feed to locate the Elmah library, download it, add a reference of it to your current project, and automatically add the appropriate Elmah registration entries within your application’s web.config file:

And now we have Elmah setup and installed for our project, and error report logging enabled.  No additional manual steps required to make it work.

Learn More About NuPack

Check out the following links to learn more about NuPack and some of the many scenarios it enables:

• Scott Hanselman’s NuPack Tutorial
• Phil Haack’s NuPack Post
• Bill Simser’s Post on NuPack (he is a non-Microsoft dev working on it)
• Rob Reynold’s “Evolution of Package Management on .NET” Post (Rob is one of the leaders of the Nu project and is on the NuPack team)
• David Ebbo’s NuPack Post
• Documentation and tutorials on nupack.codeplex.com

.NET and Open Source

We think NuPack will be a fundamental component of the .NET stack going forward.  It will encourage more .NET developers to use open-source libraries.  Having a standard package manager integrated into millions of copies of Visual Studio will hopefully also encourage the creation of more open source projects with .NET.

 

References

http://nupack.codeplex.com/

http://weblogs.asp.net/scottgu/archive/2010/10/06/announcing-nupack-asp-net-mvc-3-beta-and-webmatrix-beta-2.aspx

http://www.hanselman.com/blog/IntroducingNuPackPackageManagementForNETAnotherPieceOfTheWebStack.aspx

MVC in VB.NET Explained – An Introduction Written So You Can Understand It

If your new to MVC (Model, view, controller) and need a simple yet complete introduction to the topic this is a great article bu Dan Mabbut with About.com. (http://jpda.me/d06VCT).

MVC in VB.NET Explained, An Introduction Written So You Can Understand It.

In the beginning, there was Input-Process-Output. Everything since then is just more details.

That's literally true. The original computer, Eniac, input data about artillery, processed it, and spit out gunnery tables. But they soon learned that it could do so much more. They used it for computations necessary to create the first Hydrogen Bomb. (What would we do without war to underwrite invention?)

The way to understand MVC is to realize that it's just the latest detail on Input-Process-Output. Except that now, it's called Model-View-Controller. Model is Input, View is the Output, and Controller is Process. Sort of. Most authorities recommend that you put your "process" in "Model" and let "Controller" simply act as a switching function. But we're getting ahead of ourselves.

Although I'll be covering the same ground again, I've written several short articles about MVC:

Sorting Through the New Toys - MVC (April 28, 2010)

MVVM - A Fad or The Future? (May 27, 2010)

My new book, Pro ASP.NET 4 in VB 2010 also has a chapter about MVC where much more advanced concepts are explained, such as using MVC to create web pages based on an Entity Data Model generated from a database.

If you're a VB.NET programmer (and I assume that you are), then you now have your mind wrapped around something called the "event driven model". Just like MVC, programming this model depends on having a clear mental image of what the software does automatically and what you have to add. The key to doing MVC is to shift gears to a different mental image. So, let's consider event driven programming for just a second so we can contrast it with MVC.

When you write the standard "Hello World" program using event driven programming, you typically put a Button and a Label on a Form. When the Button is clicked, .NET creates an "event" called the "click event". Your task as a programmer is to anticipate that event and write the code that inserts a String into the Text property of a Label control.

Public Class Form1
    Private Sub Button1_Click(
        ByVal sender As System.Object,
        ByVal e As System.EventArgs
        ) Handles Button1.Click
        Label1.Text = "Hello World"
    End Sub
End Class

The key here is that nothing works unless .NET generates that magical "event" that triggers the execution of your code. MVC is like that. You anticipate things that MVC does and then just insert your code into the right places to make the resulting system do what you want it to do. But you don't code for "events" anymore. (Well ... you can. But then you're working in parallel with MVC. MVC will allow you to insert event driven programming. But that works "on top of MVC" rather than being part of it. When learning MVC, the first thing to do is banish event driven programming from your mind.)

That's why the three circle diagram of MVC is used so much. (I've illustrated the first article linked above with the standard version.) Those three circles are the part that happens "automagically" and where you need to think about putting your code. Unfortunately, it's nowhere near as simple as Windows Forms, as we will see.

To see what the difference is, we're going to code a "Hello World" app using MVC from the ground up. That last part is important. Nearly every other example you will see on the web starts with a runable MVC shell app that is just modified. On the next page, we code an MVC app using the empty app template and add everything we need manually so you can understand what's there and why.

Step 1

You might already have VB.NET 2010 Express fired up and ready to go. Not so fast! Microsoft has chosen not to put any MVC templates in VB.NET Express. Right now, it's exclusively an ASP.NET web technology. So you have to have Visual Web Developer 2010 Express downloaded and fired up instead. (Fortunately, also free.) Or the full Visual Studio 2010 which can do anything.

Fundamentally, MVC is a "design pattern" and you could implement it by simply following the pattern and coding your own classes. I mention this because somebody will inevitably write in and tell me that "we don' need no steekin' templates". (Apologies to Treasure of the Sierra Madre.) Fundamentally, you could also code your own programs with nothing more than the vbc compiler and Notepad, too. We're talking about what's reasonable here.

So fire up Visual Web Developer 2010 Express and select New Project. Under Visual Basic and the Web subheading, you will see two likely templates:

• ASP.NET MVC 2 Web Application



• ASP.NET MVC 2 Empty Web Application

The first one is the one usually used. You can create a new project using that template and run it unchanged to get something like this:

--------

Click here to display the illustration.


--------

There's a lot going on there! And it's all included in the app. Here's the Solution Explorer view of the app:

--------

Click here to display the illustration.


--------

All of the code in those files fit together in an intricate interlocking scheme. Get one parameter out of place and it doesn't run. It's a lot easier to start with an app that already runs and then add, change, and delete to get what you want. But you don't learn as much, so we're going to start with an empty MVC app. When you do that, you get this result:

--------

Click here to display the illustration.


--------

Quite a difference. The error, by the way, is one of the most common ones that you will see as you learn to code using MVC. But all of the necessary pieces are still there. They just don't have the code to fit together anymore. That's what we're going to add. (But I'll still have to sprinkle "programmer pixie dust" in a few places before it will run.)

Step 2

Let's start at the data end: Models. In a realistic business app, the Models folder contains the code to interface with a database or some other source of data. Much of the actual processing takes place in the Models because an underlying philosophy of MVC is complete isolation of function. MVC gurus call this the "Single Responsibility Principal". The other parts of MVC, Controllers and Views, should not know or care where the data comes from. In a real world app, globalization, validation, authorization ... anything necessary to get the data ... will be found here.

In our little "Hello World" app, we only have one piece of data: the string "Hello World!" To add that to the Models folder, right-click the Models folder and add a class named HelloDataModel.vb. Here's the code that goes in this file:

Namespace MVCHelloWorld.Models
    Public Class HelloDataModel
        ' The data: A Hello World string
        Public Property theHello As String = "Hello World!"
    End Class
End Namespace

It looks pretty simple because it's just one class containing one property. But it's not quite that simple because MVC ties together with names and all the names have to be present and match before it works. So, for example, you will find that you use the Namespace keyword a lot. In Windows Forms, you can pretty much ignore it most of the time. In a realistic app, much of the actual work is done by attributes that are used to decorate the classes. For example, in the boilerplate AccountModel file for the non-empty MVC app, the Password property is decorated with four attributes:

<Required()> _
<ValidatePasswordLength()> _
<DataType(DataType.Password)> _
<DisplayName("Password")> _
Public Property Password() As String
...

Often, these attributes have to be supported by other classes that you code. And so on and so on ...

On the next page, we code the heart of MVC, the controller.

Next, let's look at the controller. You can add a file named HelloController.vb to the Controller's folder by right-clicking the Controllers folder and selecting Add. Once you get the boilerplate in place, modify it as shown here:

Namespace MVCHelloWorld.Models
    Public Class HelloController
        Inherits System.Web.Mvc.Controller
        Public Function Greet() As ActionResult
            Dim theHelloGreeting As New HelloDataModel
            ViewData("Message") =
                theHelloGreeting.theHello
            Return View()
        End Function
    End Class
End Namespace

The first thing to notice is that we use the same Namespace that we used in the Models. This won't always be the case. In MVC, things are organized into logical categories using namespaces. You could have several in your program.

The second thing to notice is that this class inherits System.Web.Mvc.Controller. That's where the class gets most of its core functionality. Controllers do things that you won't expect coming from a Windows Forms background because those functions are built into the parent.

And the third thing to notice is that the end product of this class is an ActionResult named Greet. The ActionResult types in the non-empty MVC app are named Index and About. The standard CRUD (Create-Read-Update-Delete) functions are all ActionResults in a real world app. List is an ActionResult. The controller classes usually don't do anything. They just decide what gets done next as a result of what they're passed. This one decides that displaying a greeting should be done next. But it doesn't actually display it. That's done by a view.

Once you have coded the controller, you can also create a view by right-clicking the code in the controller.

--------

Click here to display the illustration.


--------

The Microsoft team has done some good work supporting MVC in their development tools. The linkage between controllers and views is one of the more intricate ways that MVC ties together and they've made it somewhat easier. But the dialog window that is displayed next will still raise a lot of questions if you haven't seen it before.

--------

Click here to display the illustration.


--------

To make things easier, I copied a Master Page from another project and then modified it to remove all the things I wouldn't use. A master page isn't required, but it's a good idea. Here's the page I used:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title><asp:ContentPlaceHolder
    ID="TitleContent" runat="server" /></title>
    <link href="../../Content/Site.css"
    rel="stylesheet" type="text/css" />
</head>

<body>
    <div class="page">
        <div id="main">
            <asp:ContentPlaceHolder
            ID="MainContent" runat="server" />
        </div>
    </div>
</body>
</html>

You can see that things are still linking together by name. For example, you'll see the ID MainContent again in the view, which we consider next.

If you used the dialog to create the view, you will notice that both a Hello folder and a Greet.aspx file in the folder have been added for you. The .aspx files in Views aren't normal .aspx files. For one thing, there is no corresponding .vb code behind file. You don't do any processing in Views, so there is no place to put code. I modified the Greet.aspx file to contain this code:

<%@ Page Title="" Language="VB" 
    MasterPageFile="~/Views/Shared/Site.Master" 
    Inherits="System.Web.Mvc.ViewPage" %>
<asp:Content ID="Content1" 
    ContentPlaceHolderID="MainContent" runat="server">
<h1><%=ViewData("Message") %></h1>
</asp:Content>

The ViewData object is just a keyed dictionary. In this case, Message is the key. It was created in the controller. A lot of MVC purists don't like this technique because (they say) the controller shouldn't be doing any processing. Because MVC is still under active development, and there are lots of other flavors other than the Microsoft brand, you'll see this sort of debate if you start reading about it.

You might think that you're finished now. You might be wrong. There's still more plumbing to put in place and on the next page, we complete the app.

The final code we need is in a file that has been there in other ASP.NET applications, but is used a lot more in MVC: Global.asax. Actually, the code is in the partial code-behind class, Global.asax.vb. (There are also sections added to Web.config to make routing work, but you normally don't have to do anything with them, so you can delay figuring out what they do.) The primary thing that is added to Global.asax is routing. This is a critical part of MVC and defines how incoming browser requests are mapped to particular MVC controller actions. Routing instructions are created in a table when the application is started. The Application_Start() subroutine executes another sub:

RegisterRoutes(RouteTable.Routes)

RegisterRoutes actually builds the table with a series of instructions that are helpfully documented in comments in Global.asax along with the default that is used in the non-empty MVC app:

' MapRoute takes the following parameters, in order:
' (1) Route name
' (2) URL with parameters
' (3) Parameter defaults
routes.MapRoute( _
    "Default", _
    "{controller}/{action}/{id}", _
    New With {.controller = "Home",
              .action = "Index",
              .id = UrlParameter.Optional} _
)

This is why MVC apps don't use normal looking URL's. A typical MVC URL might look like this:

http://myDomain.com/Home/Index/3

The routing table will send this to the Home controller; the Index action; and pass the parameter 3, which is often an index into a database.

Routing instructions in the table are used in sequence. If an earlier table entry satisfies the incoming browser request, then later entries aren't used. You can code these table entries so that multiple requests will "match" table entries for enormous flexibility (and not just a little complexity too). For this reason, you will normally place your routing instructions above the generated entries that are already in Global.asax. In my case, I didn't use a Home controller or an Index action, so I recoded the default this way:

routes.MapRoute(
    "Default", "{controller}/{action}",
    New With {
        .controller = "Hello",
        .action = "Greet"
    })

So for my app, the "Default" url will call Hello.Greet() with this result:

--------

Click here to display the illustration.


--------

Ta-Da!!!

If you think this is a lot of trouble to display "Hello World!" you're right. The main features of MVC do not include simplicity; they include long term application maintainability, flexible design, and efficient execution. (For example, there are no No ViewState and PostBack events clog up the network.) But it does take some getting used to!

LINQ – Language Integrated Query 101

This is a collection of information related to LINQ.  The primary purpose is to provide a reference for getting started with LINQ.

LINQ is a set of extensions to the .NET Framework that encompass language-integrated query, set, and transform operations. It extends C# and Visual Basic with native language syntax for queries and provides class libraries to take advantage of these capabilities.

Language-Integrated Query (LINQ) is an innovation introduced in Visual Studio 2008 and .NET Framework version 3.5 that bridges the gap between the world of objects and the world of data.

Traditionally, queries against data are expressed as simple strings without type checking at compile time or IntelliSense support. Furthermore, you have to learn a different query language for each type of data source: SQL databases, XML documents, various Web services, and so on. LINQ makes a query a first-class language construct in C# and Visual Basic. You write queries against strongly typed collections of objects by using language keywords and familiar operators. The following illustration shows a partially-completed LINQ query against a SQL Server database in C# with full type checking and IntelliSense support.

In Visual Studio you can write LINQ queries in Visual Basic or C# with SQL Server databases, XML documents, ADO.NET Datasets, and any collection of objects that supports IEnumerable or the generic IEnumerable(Of T) interface. LINQ support for the ADO.NET Entity Framework is also planned, and LINQ providers are being written by third parties for many Web services and other database implementations.

You can use LINQ queries in new projects, or alongside non-LINQ queries in existing projects. The only requirement is that the project target .NET Framework 3.5 or later.

A query is an expression that retrieves data from a data source. Queries are expressed in a dedicated query language. Over time, different languages have been developed for different types of data sources, for example, SQL for relational databases and XQuery for XML. This makes it necessary for the application developer to learn a new query language for each type of data source or data format that is supported.

Language-Integrated Query (LINQ) simplifies the situation by offering a consistent model for working with data across various kinds of data sources and formats. In a LINQ query, you are always working with objects. You use the same basic coding patterns to query and transform data in XML documents, SQL databases, ADO.NET datasets and entities, .NET Framework collections, and any other source or format for which a LINQ provider is available. This document describes the three phases of the creation and use of basic LINQ queries.

Three Stages of a Query Operation

---

LINQ query operations consist of three actions:

1. Obtain the data source or sources.

2. Create the query.

3. Execute the query.

In LINQ, the execution of a query is distinct from the creation of the query. You do not retrieve any data just by creating a query. This point is discussed in more detail later in this topic.

The following example illustrates the three parts of a query operation. The example uses an array of integers as a convenient data source for demonstration purposes. However, the same concepts also apply to other data sources.

' Data source.
Dim numbers() As Integer = {0, 1, 2, 3, 4, 5, 6}

' Query creation.
Dim evensQuery = From num In numbers
                 Where num Mod 2 = 0
                 Select num

' Query execution.
For Each number In evensQuery
    Console.Write(number & " ")
Next

Output:

0 2 4 6

The Data Source

---

Because the data source in the previous example is an array, it implicitly supports the generic IEnumerable(Of T) interface. It is this fact that enables you to use an array as a data source for a LINQ query. Types that support IEnumerable(Of T), or a derived interface such as the generic IQueryable(Of T), are called queryable types.

As an implicitly queryable type, the array requires no modification or special treatment to serve as a LINQ data source. The same is true for any collection type that supports IEnumerable(Of T), including the generic List(Of T), Dictionary(Of TKey, TValue), and other classes in the .NET Framework class library.

If the source data does not already implement IEnumerable(Of T), a LINQ provider is needed to implement the functionality of the standard query operators for that data source. For example, LINQ to XML handles the work of loading an XML document into a queryable XElement type, as shown in the following example. For more information about standard query operators, see Standard Query Operators Overview.

' Create a data source from an XML document.
Dim contacts = XElement.Load("c:\myContactList.xml")

With LINQ to SQL, you first create an object-relational mapping at design time, either manually or by using the Object Relational Designer (O/R Designer). You write your queries against the objects, and at run-time LINQ to SQL handles the communication with the database. In the following example, customers represents a specific table in the database, and Table(Of TEntity) supports generic IQueryable(Of T).

' Create a data source from a SQL table.
Dim db As New DataContext("C:\Northwind\Northwnd.mdf")
Dim customers As Table(Of Customer) = db.GetTable(Of Customer)

For more information about how to create specific types of data sources, see the documentation for the various LINQ providers. (For a list of these providers, see Language-Integrated Query (LINQ).) The basic rule is simple: a LINQ data source is any object that supports the generic IEnumerable(Of T) interface, or an interface that inherits from it.

Note

Types such as ArrayList that support the non-generic IEnumerable interface can also be used as LINQ data sources. For an example that uses an ArrayList, see How to: Query an ArrayList with LINQ.

The Query

---

In the query, you specify what information you want to retrieve from the data source or sources. You also have the option of specifying how that information should be sorted, grouped, or structured before it is returned. To enable query creation, Visual Basic has incorporated new query syntax into the language.

When it is executed, the query in the following example returns all the even numbers from an integer array, numbers.

' Data source.
Dim numbers() As Integer = {0, 1, 2, 3, 4, 5, 6}

' Query creation.
Dim evensQuery = From num In numbers
                 Where num Mod 2 = 0
                 Select num

' Query execution.
For Each number In evensQuery
    Console.Write(number & " ")
Next

The query expression contains three clauses: From, Where, and Select. The specific function and purpose of each query expression clause is discussed in Basic Query Operations (Visual Basic). For more information, see Queries (Visual Basic). Note that in LINQ, a query definition often is stored in a variable and executed later. The query variable, such as evensQuery in the previous example, must be a queryable type. The type of evensQuery is IEnumerable(Of Integer), assigned by the compiler using local type inference.

It is important to remember that the query variable itself takes no action and returns no data. It only stores the query definition. In the previous example, it is the For Each loop that executes the query.

Query Execution

---

Query execution is separate from query creation. Query creation defines the query, but execution is triggered by a different mechanism. A query can be executed as soon as it is defined (immediate execution), or the definition can be stored and the query can be executed later (deferred execution).

Deferred Execution

A typical LINQ query resembles the one in the previous example, in which evensQuery is defined. It creates the query but does not execute it immediately. Instead, the query definition is stored in the query variable evensQuery. You execute the query later, typically by using a For Each loop, which returns a sequence of values, or by applying a standard query operator, such as Count or Max. This process is referred to as deferred execution.

' Query execution that results in a sequence of values.
For Each number In evensQuery
    Console.Write(number & " ")
Next

' Query execution that results in a single value.
Dim evens = evensQuery.Count()

For a sequence of values, you access the retrieved data by using the iteration variable in the For Each loop (number in the previous example). Because the query variable, evensQuery, holds the query definition rather than the query results, you can execute a query as often as you want by using the query variable more than one time. For example, you might have a database in your application that is being updated continually by a separate application. After you have created a query that retrieves data from that database, you can use a For Each loop to execute the query repeatedly, retrieving the most recent data every time.

The following example demonstrates how deferred execution works. After evensQuery2 is defined and executed with a For Each loop, as in the previous examples, some elements in the data source numbers are changed. Then a second For Each loop runs evensQuery2 again. The results are different the second time, because the For Each loop executes the query again, using the new values in numbers.

Dim numberArray() = {0, 1, 2, 3, 4, 5, 6}

Dim evensQuery2 = From num In numberArray
                  Where num Mod 2 = 0
                  Select num

Console.WriteLine("Evens in original array:")
For Each number In evensQuery2
    Console.Write("  " & number)
Next
Console.WriteLine()

' Change a few array elements.
numberArray(1) = 10
numberArray(4) = 22
numberArray(6) = 8

' Run the same query again.
Console.WriteLine(vbCrLf & "Evens in changed array:")
For Each number In evensQuery2
    Console.Write("  " & number)
Next
Console.WriteLine()

Output:

Evens in original array:

0 2 4 6

Evens in changed array:

0 10 2 22 8

Immediate Execution

In deferred execution of queries, the query definition is stored in a query variable for later execution. In immediate execution, the query is executed at the time of its definition. Execution is triggered when you apply a method that requires access to individual elements of the query result. Immediate execution often is forced by using one of the standard query operators that return single values. Examples are Count, Max, Average, and First. These standard query operators execute the query as soon as they are applied in order to calculate and return a singleton result. For more information about standard query operators that return single values, see Aggregation Operations, Element Operations, and Quantifier Operations.

The following query returns a count of the even numbers in an array of integers. The query definition is not saved, and numEvens is a simple Integer.

Dim numEvens = (From num In numbers
                Where num Mod 2 = 0
                Select num).Count()

You can achieve the same result by using the Aggregate method.

Dim numEvensAgg = Aggregate num In numbers
                  Where num Mod 2 = 0
                  Select num
                  Into Count()

You can also force execution of a query by calling the ToList or ToArray method on a query (immediate) or query variable (deferred), as shown in the following code.

' Immediate execution.
Dim evensList = (From num In numbers
                 Where num Mod 2 = 0
                 Select num).ToList()

' Deferred execution.
Dim evensQuery3 = From num In numbers
                  Where num Mod 2 = 0
                  Select num
' . . .
Dim evensArray = evensQuery.ToArray()

In the previous examples, evensQuery3 is a query variable, but evensList is a list and evensArray is an array.

Using ToList or ToArray to force immediate execution is especially useful in scenarios in which you want to execute the query immediately and cache the results in a single collection object. For more information about these methods, see Converting Data Types.

You can also cause a query to be executed by using an IEnumerable method such as the IEnumerable.GetEnumerator method.

The standard query operators are the methods that form the Language-Integrated Query (LINQ) pattern. Most of these methods operate on sequences, where a sequence is an object whose type implements the IEnumerable(Of T) interface or the IQueryable(Of T) interface. The standard query operators provide query capabilities including filtering, projection, aggregation, sorting and more.

There are two sets of LINQ standard query operators, one that operates on objects of type IEnumerable(Of T) and the other that operates on objects of type IQueryable(Of T). The methods that make up each set are static members of the Enumerable and Queryable classes, respectively. They are defined as extension methods of the type that they operate on. This means that they can be called by using either static method syntax or instance method syntax.

In addition, several standard query operator methods operate on types other than those based on IEnumerable(Of T) or IQueryable(Of T). The Enumerable type defines two such methods that both operate on objects of type IEnumerable. These methods, Cast(Of TResult)(IEnumerable) and OfType(Of TResult)(IEnumerable), let you enable a non-parameterized, or non-generic, collection to be queried in the LINQ pattern. They do this by creating a strongly-typed collection of objects. The Queryable class defines two similar methods, Cast(Of TResult)(IQueryable) and OfType(Of TResult)(IQueryable), that operate on objects of type Queryable.

The standard query operators differ in the timing of their execution, depending on whether they return a singleton value or a sequence of values. Those methods that return a singleton value (for example, Average and Sum) execute immediately. Methods that return a sequence defer the query execution and return an enumerable object.

In the case of the methods that operate on in-memory collections, that is, those methods that extend IEnumerable(Of T), the returned enumerable object captures the arguments that were passed to the method. When that object is enumerated, the logic of the query operator is employed and the query results are returned.

In contrast, methods that extend IQueryable(Of T) do not implement any querying behavior, but build an expression tree that represents the query to be performed. The query processing is handled by the source IQueryable(Of T) object.

Calls to query methods can be chained together in one query, which enables queries to become arbitrarily complex.

The following code example demonstrates how the standard query operators can be used to obtain information about a sequence.

Dim sentence = "the quick brown fox jumps over the lazy dog"
' Split the string into individual words to create a collection.
Dim words = sentence.Split(" "c)

Dim query = From word In words
            Group word.ToUpper() By word.Length Into gr = Group
            Order By Length _
            Select Length, GroupedWords = gr

Dim output As New System.Text.StringBuilder
For Each obj In query
    output.AppendLine(String.Format("Words of length {0}:", obj.Length))
    For Each word As String In obj.GroupedWords
        output.AppendLine(word)
    Next
Next

'Display the output
MsgBox(output.ToString())

' This code example produces the following output:
'
' Words of length 3:
' THE
' FOX
' THE
' DOG
' Words of length 4:
' OVER
' LAZY
' Words of length 5:
' QUICK
' BROWN
' JUMPS

Query Expression Syntax

---

Some of the more frequently used standard query operators have dedicated C# and Visual Basic language keyword syntax that enables them to be called as part of a query expression. For more information about standard query operators that have dedicated keywords and their corresponding syntaxes, see Query Expression Syntax for Standard Query Operators.

Extending the Standard Query Operators

---

You can augment the set of standard query operators by creating domain-specific methods that are appropriate for your target domain or technology. You can also replace the standard query operators with your own implementations that provide additional services such as remote evaluation, query translation, and optimization. See AsEnumerable(Of TSource) for an example.

References;

Video on getting started with LINQ, ttp://msdn.microsoft.com/en-us/vbasic/bb735955.aspx

Video on writing LINQ, http://msdn.microsoft.com/en-us/library/bb820884(VS.90).aspx

Guy Burstein’s Blog on Like Operators, http://blogs.microsoft.co.il/blogs/bursteg/archive/2007/10/16/linq-to-sql-like-operator.aspx

Guy Burstein’s LINQ blog posts, http://blogs.microsoft.co.il/blogs/bursteg/archive/tags/LINQ/default.aspx

Microsoft LINQ Developer Center, http://msdn.microsoft.com/en-us/netframework/aa904594.aspx

Microsoft LINQ sorting, http://msdn.microsoft.com/en-us/library/bb546145.aspx

Microsoft LINQ filtering, http://msdn.microsoft.com/en-us/library/bb546161.aspx

Microsoft LINQ set operations, http://msdn.microsoft.com/en-us/library/bb546153.aspx

Microsoft LINQ quantifier operations, http://msdn.microsoft.com/en-us/library/bb546128.aspx

Microsoft Visual Basic .Net CPT for Windows Phone Developer Tools Released!

Many of you have asked if Visual Basic can be used to write Windows Phone applications. 

As of today, the answer is "yes!"

Starting today, you can download Microsoft Visual Basic CTP for Windows Phone Developer Tools.  This is a great milestone as it enables our Visual Basic developers to be able to build applications for Windows Phone.

Applications built using the CTP run on both the emulator and the phone. To try the CTP, you'll need the final version of Windows Phone Developer Tools and Visual Studio 2010 Professional or higher. If you don't have Visual Studio 2010 Professional, you can install the free trial of Visual Studio Professional. 

The CTP includes Visual Studio 2010 project templates, item templates, designer support, emulator support, debugging, and IntelliSense for Visual Basic.  After installing the CTP, Visual Studio 2010 Professional and higher users will find Windows Phone project types for Visual Basic in the New Project Dialog, as you can see below.

Resource Refactoring Tool

Microsoft http://resourcerefactoring.codeplex.com/

Resource Refactoring Tool provides developers an easy way to extract hard coded strings from the code to resource files.

Features for Resource Refactoring Tool

• Works with C#, VB.Net languages. Supports all project types that ships with Visual Studio 2005 including web sites and web application projects.
• A preview window to show changes.
• Finds other instances of the text being replaced in the project automatically.
• Lists existing resources by their similarity level to the text being replaced.
• Automatically replaces hard coded string with a reference to resource entry.

Quick Start to using Resource Refactoring Tool

1. Run ResourceRefactor.msi to install. If you have any earlier version please uninstall those versions first and run Visual Studio at least once before installing the new version.
2. Launch Visual Studio 2005
3. Open either a VB.Net or C# project
4. Right click on a hard coded string in a a code window and choose Refactor - Extract to resource. If you don't see the menu item and you had a previous version of Resource Refactoring Tool installed before, you may have to reset the addin by running Visual Studio from Visual Studio 2005 Command Prompt with the following arguments: devenv.exe /resetaddin Microsoft.VSPowerToys.ResourceRefactor.Connect. This should fix the missing menu items.
5. 
6. Choose the resource file you want to use and either choose an existing resource or create a new one. After closing the dialog window, string will automatically be replaced with the reference to resource you have chosen.

Contributing to Resource Refactoring Tool
We're looking for developers to join us in future releases. Check out the current work items at issue tracker.
Feel free to contribute by

1. Reading Getting Started with Resource Refactoring Tool Development.
2. Either creating new or finding existing bugs or feature requests you want to work on
3. Leave a note in the comments that you're going to investigate this bug (until you have developer rights, you won't be able to assign bugs to yourself)
4. Download the latest sources and create a bug fix
5. Zip up your changes and post them as an attachment to the work item
6. Fill out the Project_Assignment_Agreement.TIF form and follow the Assignment Agreement Instructions to send it to us.

Note that by posting your submission to the Issue Tracker, you agree to do so under the CodePlex TOU
Join the Community
There are numerous ways you can participate in the Resource Refactoring Tool community

• Blog about Resource Refactoring Tool
• Ask and answer questions regarding Resource Refactoring Tool on the discussions tab
• Fix bugs or check in new features - see above section

Visual Studio 2010 Image Insertion

Image Insertion

Microsoft http://jpda.me/aoFW9n

This sample was created to show how easy it is to extend the Visual Studio 2010 editor.  The Image Insertion sample lets you insert images directly in line with your code to help you visualize aspects of your code.  The editor extension supports drag and drop from the solution explorer and automatically sizes images to the space available pushing aside the text to make sure everything is readable.

msDev.com Microsoft Training Pivot view

Check out the msdev Pivot site at http://jpda.me/cSMLQj to experience a great new way to find the right courses for your needs! Pivot makes it easier to interact with massive amounts of data in ways that are powerful, informative and fun.

Windows Phone 7 in 7 Minutes! Free webcasts to get you started!

msDev.com is offering several good short video on windows 7 phone.
http://jpda.me/coHrdk

Microsoft Web Farm Framework

This is a great article on the new free product from Microsoft by Scott Guthrie. http://jpda.me/bQ0Ysk

Introducing the Microsoft Web Farm Framework

Last month we released a beta of the Microsoft Web Farm Framework. The Microsoft Web Farm Framework is a free product we are shipping that enables you to easily provision and mange a farm of web servers.  It enables you to automate the installation and configuration of platform components across the server farm, and enables you to automatically synchronize and deploy ASP.NET applications across them.  It also supports integration with load balancers - and enables you to automate updates across your servers so that your site/application is never down or unavailable to customers (it can automatically pull servers one-at-a-time out of the load balancer rotation, update them, and then inject them back into rotation).

The Microsoft Web Farm Framework is a 1 MB download, and can be installed on IIS 7 and above. It is available for free. You can download the first preview of this beta here: x86 / x64.

Why Is the Web Farm Framework Useful?

Running a web farm requires you to provision and manage multiple servers.  Running a web farm involves (among other things):

1. Installing IIS, ASP.NET and all of the core platform components on the servers
2. Installing and configuring custom IIS modules (UrlRewite, Media Services, etc)
3. Configuring IIS Application Pools and Sites
4. Setting up SSL certificates for things like HTTPs endpoints
5. Copying and synchronizing the appropriate sites/applications/content across the various boxes
6. Coordinating the various web servers with a HTTP load balancer to distribute load

Administrators and developers managing a web farm today often perform a lot of manual steps to do the above (which is error prone and dangerous), or write a lot of custom scripts to automate it (which is time consuming and hard).  Adding new servers or making configuring or application changes can often be painful and time-consuming.

The Microsoft Web Farm Framework makes this process much easier, and enables you to manage web farms in a completely automated way. Best of all, it is really easy to setup and use.

Using Web Farm Framework to Provision and Scale a Web Farm

The Microsoft Web Farm Framework enables you to easily define a “Server Farm” that you can add any number of servers into.  Servers participating in the “Server Farm” will then be automatically updated, provisioned and managed by the Web Farm Framework. 

What this means is that you can install IIS (including modules like UrlRewrite, Media Services, etc), ASP.NET, and custom SSL certificates once on a primary server – and then the Web Farm Framework will automatically replicate and provision the exact same configuration across all of the other web servers in the farm (no manual or additional steps required). 

You can then create and configure an IIS Application Pool and a new Site and Application once on a primary server – and the Web Farm Framework will automatically replicate and provision the settings to all of the other web servers in the farm.  You can then copy/deploy an ASP.NET application once on the primary server – and the Web Farm Framework will automatically replicate and provision the changes to all of the web servers in the farm (no manual or additional steps required).

The Web Farm Framework eliminates the need to manually install/manage things across a cluster of machines.  It handles all of the provisioning and deployment for you in a completely automated way.

Load Balancer Integration

In addition to making it easy to provision/deploy servers and applications, the Web Farm Framework also includes load balancer integration. Specifically, the Web Farm Framework can integrate with an HTTP load balancer so that as web servers in the farm are updated with changes, they can be automatically pulled out of a load balancer rotation, updated, and then added back in.  The Web Farm Framework can also optionally update the machines one at a time – so that you always have servers available to handle heavily load.  This enables you to keep your site always available during updates – without you having to write any manual scripts to control or manage the update roll-out.

The current beta of the Web Farm Framework includes built-in support for the IIS Application Request Routing (ARR) service (which supports automatic load balancing of HTTP requests across multiple machines in a web-farm).  The Web Farm Framework makes it really easy to integrate your web farm of servers with ARR for load-balancing, and includes the support to automatically pull a server out of rotation as it is being updated, and then have it added back into rotation once the update is done.

The final Web Farm Framework release will enable extensibility with other load-balancing technologies as well – enabling the same ability to automatically pull/inject servers from a load balancing rotation as they are updated.

Scenario Walkthrough: Setting up and Provisioning a Web Farm

Let’s walkthrough a simple scenario where we want to setup and manage a server farm made up of two web servers.  We’ll call these two web-servers the “DemoPrimary” and “DemoSeconday” servers.  We’ll use a third “DemoController” machine to coordinate and manage the web farm.  DemoController doesn’t technically need to be a separate machine – but makes it easier to understand the various roles in the walkthrough.

Installing the Web Farm Framework

We’ll begin by installing the current beta of the Microsoft Web Farm Framework using the Microsoft Web Platform Installer on our “DemoController” machine. It works with any machine that has IIS 7 (and above) installed.

Creating and Provisioning a Web Farm

Once the Microsoft Web Farm Framework is installed, you’ll find a new “Server Farm” node listed within the left-hand tree view of the IIS Admin Tool on the “DemoController” machine.  If you right-click on this “Server Farm” node you’ll see an option to “Create Server Farm…”

Selecting this option will bring up a “Create Server Farm” dialog – and allow us to configure and setup a farm of machines that we want to manage together.

We’ll name the new server farm we want to create “DemoFarm”, and indicate that we want to automatically provision all of the servers in the farm (by checking the “Provision Server Farm” option in the dialog).  We’ll also indicate that we want to make it available for load-balancing with the IIS Application Request Routing (ARR) load-balancer:

When we click the “Next” button the wizard will bring up an “Add Servers” dialog that allows us to specify the servers we want to have in the web farm. We can add any number of servers at the time of first setup.  We can also come back and add more servers to the server farm later.  When you add more servers to the farm later, the Web Farm Framework will automatically provision and update them to have the latest changes (allowing us to easily add additional capacity at any time).

For this walkthrough we’ll add our two servers – “DemoPrimary” and “DemoSeconday” to our server farm.  We’ll start by adding the “DemoPrimary” machine.  We’ll select the “Primary Server” checkbox in the dialog – which will indicate that its role is to act as the primary server that the other servers in the farm will replicate:

Once we add the “DemoPrimary” server we’ll also add the “DemoSecondary” server to the farm.  

When we click the “Finish” button the Web Farm Framework will connect to the servers we’ve added to the farm and automatically provision the appropriate management software on them for us (no need for us to install anything manually – the web farm framework will automatically install its management service on the target machines).  Clicking the “servers” tab in the “Server Farm” node in the IIS Admin tool always provides an up-to-date view of the provisioning and deployment operations happening across all the farm (you can also filter it by individual server if you want):

At this point we are completely done configuring our web farm.  We now have a working, automated, web farm enabled. 

We have setup our web farm for automated provisioning and synchronization/replication.  If we were to create sites or application pools on the “DemoPrimary” web server, or install or update applications on it, they would be automatically replicated/synchronized on the “DemoSeconday” server.  This is also true for any web platform components we install. We do not need to manually install or configure anything on any additional secondary servers we add to the farm. The Web Farm Framework will automate keeping them synchronized with our Primary Server – and enable us to manage the entire farm of servers as a group.

Managing a Web Farm

Clicking on the “DemoFarm” sub-node within the IIS Admin Tool enables us to manage, track and configure our server farm:

The view above combines the settings of both the Web Farm Framework, as well as the Application Request Routing capability of IIS (which adds load-balancing and cache management support). 

You can click on the “Servers” sub-node of “DemoFarm” to see how the servers within the web farm are doing, if they are currently performing any deployment/provisioning operations, and if any errors have occurred on them.  If any provisioning/deployment errors have occurred anywhere in the farm, you can drill down to detailed tracing to see what they were.

Platform Provisioning using the Web Farm Framework

The Web Farm Framework enables you to easily add more platform components to your server-farm machines at anytime by using the “Platform Provisioning” icon above.  This integrates our Microsoft Web Platform Installer technology, and enables you to easily install platform components on all of your web farm machines.  It also allows you to easily check for any version differences in platform components between your primary and secondary machines in the farm.

Below we can add “ASP.NET MVC 2” to the server farm configuration:

Notice that the “Enable Platform Provisioning” checkbox is selected – this will ensure that products we add to the list are automatically provisioned across all of the servers in the farm.  By default the Web Farm Framework will update each server in the farm one-by-one, and take it out of the load-balancer rotation while it does it, and then automatically add it back into the load balancer rotation once it is complete (ensuring your site never goes down).  The Web Farm Framework will even handle scenarios where a server reboot is necessary – and complete the provisioning step and re-add the server back to rotation once the reboot is done.

Application Provisioning using the Web Farm Framework

The Web Farm Framework enables you to easily deploy and replicate/synchronize Sites, Applications, Content and Settings across a Web Farm.  It uses the Microsoft Web Deploy technology to enable application deployment in an automated fashion (no manual steps required for both adding new applications and updating existing ones).

By default, the Web Farm Framework will automatically synchronize the Sites, Applications, Content and Settings we’ve configured on our “DemoPrimary” server to our “DemoSeconday” server (and any other web-servers we later add to the server farm).  We can use any application deployment mechanism we want to create and copy the application up onto the “DemoPrimary” machine.  This means we could use FTP/SFTP or the Microsoft Web Deploy framework to deploy the sites/content to “DemoPrimary”.  It also means any web applications that use a custom MSI installer or custom batch-file/powershell script to deploy applications onto our “DemoPrimary” will also work.

The benefit of supporting any deployment mechanism is that you can leverage any of the existing application/site/app-pool deployment approaches you already use with IIS to update your primary server – and then use the Web Farm Framework to automatically have the installed application/site/content automatically replicated across the other machines in the web-farm.  This makes it easier to integrate the Microsoft Web Farm Framework into your existing deployment workflows.

If you click the “Application Provisioning” icon in the IIS admin tool you can specify the synchronization frequency with which you want the servers in the web-farm to check for application/site/content updates (by default it happens every 30 seconds). 

You can also optionally specify any additional Microsoft Web Deploy providers you want to use to copy custom settings across machines in the web-farm.  For example, if you want a custom registry setting copied – you can enable that.  If you want to set a custom NTFS security ACL – you can enable that.  If you want to copy/register a COM object – you can enable that.  If you’ve built your own custom “FooProvider” to do some custom stuff – you can enable that too.

When you make changes or updates to applications on your primary server, the Web Farm Framework will automatically synchronize and copy them to the other servers in the server-farm for you.  No manual steps required.

Running Operations and Managing the Server Farm

The Web Farm Framework includes some built-in management infrastructure that allows you to check on the health of a server, and track its status.  You can also use a product like Microsoft System Center (or any custom monitoring software or scripts you have) to monitor the server status within the farm.  If you are using ARR for load-balancing, it also supports a bunch of monitoring and load-balancing settings that allow you to dynamically shift loads across the farm based on server performance and available utilization.

The Web Farm Framework also supports a “Server Farm Operations” task link within the IIS Admin Tool (on the right-hand side of the tool) that you can use to easily run commands across the server farm.  For example, we could flash a command to all the servers in the web farm to ensure that a “MyCustomWindowsService” is started and running using the screen below:

You can also fully automate tasks using PowerShell scripts.

Summary

You can take advantage of the Microsoft Web Farm Framework to simplify the provisioning and deployment of your web server infrastructure – both the servers themselves, as well as the web applications and sites you run on top of them.  It enables a smoother continuous deployment workflow.  It also makes it easy to seamlessly scale your infrastructure by adding servers to it without additional management overhead.  Best of all it is available at no extra cost and works with all editions of Windows Server.

Click here to learn more about the Microsoft Web Farm Framework. You can download a beta of the Microsoft Web Farm Framework here.

Silverlight 4 service release

Microsoft released a service release of Silverlight 4 last week.  The update build is 4.0.50826.0 and you can find all the details about it at http://jpda.me/dzXlXu KB2164913.

The primary changes are;

• SDK feature to enable Add New Row capabilities in DataGrid control
• Improving startup performance of Silverlight applications
• Adding mouse wheel support for out-of-browser applications on the Mac platform
• Various media-related fixes around DRM content
• Fixed memory leak when MouseCapture is used
• Fixed memory leak for DataTemplate usage

For end users

For end users, having them simply install the runtime will provide them with the updated bits and benefits of the fixes/features in this service release.  The best way to force encourage your users to upgrade to this service release would be to leverage the MinRuntimeVersion attribute of your object tag:

Notice lines 5 and 6 above.  This would trigger that the end user is required for your application to run and require them to upgrade. The minRuntimeVersion/autoUpgrade are the minimum to require your user to upgrade to the later version.  Ideally you would follow good installation experience guidance (see “Installation Experience Whitepaper” with complete sample source code) to customize your install and/or upgrade experience.

For Developers

If you are a developer and authoring Silverlight applications you may want to grab the new developer bits and updated SDK:

• Windows developer runtime



• Mac developer runtime



• Silverlight 4.0.50826.0 SDK

I would install the developer build first and then the SDK and you’ll have a refreshed environment. 

Note that when you now create a new project you’ll be using the new SDK and so the minRuntimeVersion (see above) of the project templates as well as compiled bits for your SL4 application will be using/requiring the updated runtime.

There are NO Visual Studio tools updates for this release so the Silverlight4_Tools.exe package is not needed to re-install.

Reference

Tim Heuer’s blog Method ~ of ~ failed, http://jpda.me/bCu6Zv

Class View and Object Browser Icons

If you have ever wondered what the icons in the class view and object browser meant here is a legend;

 

http://msdn.microsoft.com/en-us/library/y47ychfe.aspx

Past, Present and Future? An interesting video!

How to implement TextWrapping in a Silverlight AutoCompleteBox

The Silverlight AutoCompleteBox control is a great control, however, there are some properties that it does not expose like TextWrapping that you might need to access.

The AutoCompleteBox inherits from the TextBox control so accessing the underlying controls properties will allow you to do so.

Simple create a new class file like below which inherits the AutoCompleteBox and on the loaded event gets a reference to the underlying TextBox by calling the GetTemplateChild function of the class.  The GetTempleteChild returns the named element in the visual tree of an instantiated ControlTemplete.  Then simply set the value of the TextBox property.

Public Class clsMyTextBox
    Inherits AutoCompleteBox
    Private _text As TextBox
 
    Private Sub clsMyTextBox_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        _text = GetTemplateChild("Text")
        _text.TextWrapping = System.Windows.TextWrapping.Wrap
 
    End Sub
End Class

Some lesser-known truths about programming

Some lesser-known truths about programming
by Dot MacAdventures with OS X and DotNet


My experience as a programmer has taught me a few things about writing software. Here are some things that people might find surprising about writing code:


•A programmer spends about 10-20% of his time writing code, and most programmers write about 10-12 lines of code per day that goes into the final product, regardless of their skill level. Good programmers spend much of the other 90% thinking, researching, and experimenting to find the best design. Bad programmers spend much of that 90% debugging code by randomly making changes and seeing if they work.

“A great lathe operator commands several times the wage of an average lathe operator, but a great writer of software code is worth 10,000 times the price of an average software writer.” –Bill Gates

•A good programmer is ten times more productive than an average programmer. A great programmer is 20-100 times more productive than the average. This is not an exaggeration – studies since the 1960′s have consistently shown this. A bad programmer is not just unproductive – he will not only not get any work done, but create a lot of work and headaches for others to fix.

•Great programmers spend very little of their time writing code – at least code that ends up in the final product. Programmers who spend much of their time writing code are too lazy, too ignorant, or too arrogant to find existing solutions to old problems. Great programmers are masters at recognizing and reusing common patterns. Good programmers are not afraid to refactor (rewrite) their code constantly to reach the ideal design. Bad programmers write code which lacks conceptual integrity, non-redundancy, hierarchy, and patterns, and so is very difficult to refactor. It’s easier to throw away bad code and start over than to change it.

•Software obeys the laws of entropy, like everything else. Continuous change leads to software rot, which erodes the conceptual integrity of the original design. Software rot is unavoidable, but programmers who fail to take conceptual integrity into consideration create software that rots so so fast that it becomes worthless before it is even completed. Entropic failure of conceptual integrity is probably the most common reason for software project failure. (The second most common reason is delivering something other than what the customer wanted.) Software rot slows down progress exponentially, so many projects face exploding timelines and budgets before they are killed.

•A 2004 study found that most software projects (51%) will fail in a critical aspect, and 15% will fail totally. This is an improvement since 1994, when 31% failed.

•Although most software is made by teams, it is not a democratic activity. Usually, just one person is responsible for the design, and the rest of the team fills in the details.

•Programming is hard work. It’s an intense mental activity. Good programmers think about their work 24/7. They write their most important code in the shower and in their dreams. Because the most important work is done away from a keyboard, software projects cannot be accelerated by spending more time in the office or adding more people to a project.

VS2010 Toolbox Search

Have you ever wanted to be able to search the VS2010 toolbox for the control your looking for?  Well you can!

The visual studio team has added the ability to search for controls in the toolbox by name.  To use it, put focus in the toolbox (by clicking in it, for example) and then start typing the name of the control you want to find.  As you type, the selection will move to the next item that matches what you've typed so far.  The text you've typed is shown in the status bar, like this:

You can hit Backspace if you mistyped a character, or Tab to go to the next match for the current string.  To cancel the search, you can hit Escape, move the selection, or click on another window.

You can also collapse all the groups by pressing "/" (and you can expand them all with "*")