Satter Ramblings

Microsoft .NET Framework 4 Favorite Feature #1

2009-11-04T12:01:15-08:00

.NET Framework 4 has a lot of new features and it can be daunting to decide what to look at first. Fortunately or unfortunately (it has been a long trek from start to Beta 2) I have been working with Visual Studio 2010 and .NET 4 for the last 16 months. I will share with you my favorite features starting with Managed Extensibility Framework (MEF).

MEF is a simple but powerful set of classes to allow for application composition and extension. Huh? Let me show you and then decide for yourself if my description is valid.

Fire up Visual Studio and join me as I walk through a simple example of MEF. If you have not downloaded VS2010 yet you can get it from the Visual Studio 2010 and .NET Framework 4 Beta 2 page.

Visual Studio 2010 Start Page

From the Start Page click New Project and launch the New Project Window. The Window will be similar to below depending on your language. Make sure you have .NET Framework 4 selected. Then Select Windows Form Application, name the project HelloMEF, select the location and click OK.

New Project Window

The next step is to modify the basic Form class that is created by the template.

Open the Solution Explorer and rename Forrm1.cs to FormMEF.cs
Click yes to rename the Form1 class to FormMEF
Open the Form design if it is not for FormMEF
Click on the Form and change the text from Form1 to Hello MEF
Drop a MenuStrip on the Form
Change the name to menuStrip
Add the following menu items
1. &Addin
2. E&xit
Double click on E&xit and put this.Close(); in the method handler.
Now copy the method handler and name it templateToolStripMenuItem_Click

Then type the follow code

private void templateToolStripMenuItem_Click(object sender, EventArgs e)
{
  ToolStripMenuItem tempMenuItem = sender as ToolStripMenuItem;
  ((IAddin)tempMenuItem.Tag).Show();
}

Right Click on the IAddin type and select Generate|New Type...

Here is a cool new feature. I use to have to stop and go manually insert the new type. It would stop the flow of my coding. Now I just go write code. Then go back and generate the missing stub code!
Once you have the IAddin interface created the Show will get a squiggle line. Right click and have it add the method to the interface.
Add a reference to System.ComponentModel.Composition. This is the key MEF assembly to use. MEF works on the notion of an object container with support for a catalog. When you want a type from MEF you make a request of the container for the type or name requested. In the next step, we will create the catalog and container.
Add a using statement for System.ComponentModel.Composition.
MEF works by telling a catalog what is available (Export types) and types using the contents of the catalog (Import). In this case we want to dynamically add “Addins”. A property will be created that MEF can load up with IAddins.
```
[ImportMany]
public IAddin[] Addins { get; set; }

```
This tells MEF that it should find IAddins and return all of the objects that satisfy this condition in an array of IAddin.

Jump back to the Form and double click on the Form to generate the Form Load event. In this event will be the wiring of IAddins into the menu.

private void FormMEF_Load(object sender, EventArgs e)
{
  ToolStripMenuItem menuItem;

  foreach (IAddin addin in Addins)
  {
    menuItem = new ToolStripMenuItem(addin.Name);
    menuItem.Tag = addin;
    menuItem.Click += new EventHandler(templateToolStripMenuItem_Click);
    addinToolStripMenuItem.DropDownItems.Add(menuItem);
  }
}

Use Generate Property to add Name to IAddin. You will need to change the type to string as it will potentially use Image since the construct can take an Image or a String.
Click on the Program.cs file.
First add the following using statements (note this will not work if you do not have both using statements)
1. System.ComponentModel.Composition
2. System.ComponentModel.Composition.Hosting
As I said earlier MEF requires a catalog and a container. To create a catalog to find types and contracts
```
AggregateCatalog catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
catalog.Catalogs.Add(new DirectoryCatalog(Application.StartupPath));
```
In this case I am creating a catalog that contains exported types from my executing assembly and any assembly that is in the application startup path.

The next step is to create the container

var container = new CompositionContainer(catalog);

This next part is create the form and have the container fulfill its imports
```
Form frm = new FormMEF();
```
Finally change the Run parameter and run the program. You should at this point get a form with no Addin menu items.
```
Application.Run(frm);
```

Now to create an Addin.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.ComponentModel.Composition;

namespace HelloMEF
{
  [Export(typeof(IAddin))]
  public class FirstAddin : IAddin
  {
    public void Show()
    {
      MessageBox.Show("Hello from 1st Addin");
    }

    public string Name
    {
      get
      {
        return "First Addin";
      }

    }
  }
}

Run the application again.

Create another assembly with an IAddin and have it compile into the same directory as HelloMEF. When you run the application you now get to Addin menu items.

If you want to be even more scary here is the instructions to have MEF find the Form and dynamically use a different Form at run time.

Export the form using
```
[Export("FormMEF", typeof(Form))]

```
Modify the Program Main method

[STAThread]
static void Main(string[] parameters)
{
  string loadForm = "FormMEF";

  if (parameters.Count() > 0)
  {
    loadForm = parameters[0];
  }

  Application.EnableVisualStyles();
  Application.SetCompatibleTextRenderingDefault(false);

  // Setup MEF
  AggregateCatalog catalog = new AggregateCatalog();
  catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
  catalog.Catalogs.Add(new DirectoryCatalog(Application.StartupPath));
  var container = new CompositionContainer(catalog);

  // Get FormMEF and satisfy its imports
  var frm = container.GetExportedValue<Form>(loadForm);
  container.SatisfyImportsOnce(frm);

  // Use form supplied by MEF
  Application.Run(frm);
}

Move your addin class and Forrm into its own class library.
You can create another form with a different contract name. Then pass it into the program. Voila.

By the way there is a Compact Framework version. You can find it on CodePlex.

Deploying .NET Framework 4 Beta 2

2009-10-27T09:28:55-07:00

Now that Beta 2 is out I can talk more freely about what is happening with the .NET Framework. The most visible changes are the installation size, speed, and error rate of the Framework. There are also a lot of great new features

Installation

Architecture specific installers that are smaller sizes ranging from 76-86% decrease in installation size from 3.5 SP1.
enabled more features on the Client Profile

Language Features

dynamic (c#),
optional/default parameters (c#),
named parameters (c#),
no more line continuation character (VB),

Runtime Features

multi-core support,
background garabage collection for desktops although not servers
side by side runtime allows .NET 2.0/3.0/3.5 applications to run along side .NET 4 and even within the same process
Limited supportr for code contracts

Base Class types

BigInteger to support integers larger than 64 bit
Complex to support complex numbers

Class Libraries

Managed Extensibility Framework
Workflow Framework v2 (new rewritten based on common XAML stack with WPF)
Entity Framework v2

Lots more

In this article, I am going to discuss some of the overall aspects, architecture, and installation of the .NET Framework.

.NET Profiles

In .NET 3.5 SP1, the .NET team began looking at how to break up the Framework. This was due in part to the installation size and the fact that Client application needs differ from server needs. A concept called a profile was created. A profile is a subset of .NET and used for specific application types. The result was the addition of two profiles

Client Profile – this Profile is a subset of .NET Framework tailored for client applications. It should be used for .NET applications requiring WinForm, WPF, Console and basic non-server functionality.
Server Core Profile – this Profile is a subset of the .NET framework for server applications. It can run server oriented applications like ASP.NET and WCF. In addition, Powershell is integration is supported. It is used to give a production server the minimal feature set to run ASP.NET, WCF and Powershell applications. It is intended to reduce the size of the framework and give a smaller attack surface which reduces servicing requirements. It is only available on Windows 7 Server Core installations.

The Full Framework is required for development. If the profile you targeted does not have everything you need, you would also use the Full Framework.

Visual Studio installs the Full Framework. That also means your debugging and unit tests if run on the same machine are actually testing against the Full Framework. Make sure you test on your target profile.

In .NET Framework 4, the team further refined our approach. First, there is not yet a Server Core Profile. The team is looking at what will go into the next version of Windows as always. With the Client Profile, the team made substantial differences to make the Client Profile more than just a stub of .NET that still needed to be upgraded to the Full Framework. The new Client Profile can be installed, upgraded and serviced independently of the Full Framework. You can go from Client Profile 4 to Client Profile 4.x or even upgrade to the Full .NET stack.

To address complaints about the size of the installer the Framework now ships with architecture specific installers. In addition, better compression and how the Framework is installed has led to smaller installation sizes.

Installation Sizes

Installation Option	Initial Size	Addl. Download	Notes
.NET 3.5 SP1			Installs on all OSs and architectures
Redist Package	231.5 MB	N/A
Web Installer	2.8 MB	10 MB – 60 MB	Depends on what is already installed

.NET 4 Beta 2 (Full)			All OSs but architecture dependent
x86 Redist Package	37.7 MB	N/A	Only x86
x64 Redist Package	54.5 MB	N/A	Installs on x86 and x64 (recommend)
Ia64 Redist Package	56.4 MB	N/A	Only ia64
Web Installer	850 KB	25 MB – 56 MB	All architectures and download varies by architecture and what is already installed

.NET 4 Beta 2 Client Profile			All OSs but architecture dependent
x86 Redist Package	30.9 MB	N/A	Only x86
x64 Redist Package	47.1 MB	N/A	Installs on x86 and x64 (recommend)
Web Installer	850 KB	25 MB – 54 MB	All architectures and download varies by architecture and what is already installed

What makes up the install?

The .NET Frameworks are made up of several parts. At the bottom are components that are shared by all the Frameworks for example MSCoree.dll. Most of these are binaries that act as shims that direct to the right CLR/Framework based on the calling application. These shims call version specific implementations like the CLR. And finally the .NET Framework library runs on top like the .NET Framework 2.0, 3.0, 3.5, or 4.

Basic Architecture of .NET

As you can see from the above diagram the 2.0, 3.0 and 3.5 versions of the Framework are built and depend upon the older versions. The Framework 4 is a single unified Framework built upon a new version of the CLR and lives side by side with the CLR v2 based Frameworks.

The installation is composed of Shared Components, CLR and the Framework. With the Framework being broken into Client, Server Core and Full the deployment team looked at best how to ensure a unified experience. Server Core will be a future OS only feature so I will ignore it. This left Client Profile and the Full Framework.

Since the Client Profile is a subset of the Full Framework you could say the Full Framework is composed of the Client Profile and the remaining portion of the Framework. This is exactly what the team did. There are the Shared Components which are an OS update. Then there is a Client MSI and the remainder called Extended MSI. After installing the Full Framework on a computer opening up Programs and Features will have two new entries. In addition, once the localization of the Framework you could have a language pack per language.

Programs and Features

To uninstall the Framework you must uninstall the language packs and then Extended, Client and finally the OS Update containing the Shared Components (KB958488).

Unlike the older Frameworks the new installers are single unified packages. DO NOT break them up. The deployment team wrote a robust chainer that includes the ability to heal and retry if an error is encountered. In addition, the 7zip compression is being used to further compress the package as small as possible. These changes in the installer have led to a higher install success rate.

Microsoft .NET Framework 4 Beta

2009-10-19T10:34:27-07:00

Today Microsoft announced that the Beta 2 of Visual Studio 2010 and .NET Framework 4 will be released. If you have MSDN subscriptions you can downloaded now. Otherwise it will be available on Wednesday publically.

Microsoft .NET 4 Client Profile

2009-05-27T15:55:12-07:00

.NET 4 continues with the new concept of profiles. A profile is a subset of the Full Framework that can control what run time assemblies you can use. This can allow for a smaller install when redistributing .NET. For more information check Jossef Goldberg's blog - http://blogs.msdn.com/jgoldb/archive/2009/05/27/net-framework-4-client-profile-introduction.aspx

Also see my new blog on deployment which discusses the new .NET 4 Client Profile.

Microsoft .NET 4 and Visual Studio 2010 Beta 1 Available

2009-05-18T11:27:44-07:00

Today if you go on MSDN Subscriber downloads you can get the beta of Visual Studio 2010 and Microsoft .NET 4. The public will get the beta in a couple of days. For more information, please visit the Visual Studio 2010 Product Page.

Microsoft Product Blogs

2009-02-24T07:30:58-08:00

Have you ever wonder how to keep up with the flood of information coming from Microsoft? It turns out that there are lots of resources provided by Microsoft. And a good place to look turns out to be a blog, specifically BlogMS! BlogMS was started by Daniel Goodman (a Sr. Technical Account Manager) in his words he started BlogMS in May 2008 in response to customers who wanted to feel closer to Microsoft in order to keep up-to-date with what's going on across Microsoft including the products groups. Think of this website as connecting the dots!

In one place you can find

Report about new blog entries in official team blogs,
Support resources (hey he is a TAM),
Microsoft Newsletters,
how to get involved in feedback, bugs and more via Microsoft Connect,
Free Software and On-line Services and
Information about Microsoft Software + Services and Cloud Computing.

It is a great resource and pulls together nicely in one place critical information.

CodeDOM

2008-11-03T11:03:34-08:00

Reed Robinson has been talking about the Mobile LOB Accelerator lately. This got me thinking how I could make it easier to write applications based on it. This then lead me to CodeDOM. Ok I am lying but then I can't give away all of my secrets.

So what is CodeDOM? Say you want to generate code. You could write a program or class that can output source by writing to a file. However what happens when you want to manipulate the code before writing for example renaming a class or namespace. This becomes difficult if you are just maintaining a string copy in memory. And worst what happens when now you need to output VB rather than C#. You could write a set of objects that represent parts of the code. That is what CodeDOM is a document model for source code. It is essentially a framework of objects used to generate source code or even compiled code. It can be very quirky but powerful and useful.

So first let me back up and give a simplistic view of compiling an application. From the diagram above you can see that essential a source code file is transformed by the compiler into machine instructions. Ok that sounds familar I have an XML file and it is transformed into HTML via XSLT. So what if rather than a compiler I sent the source code into a parser that returned the structure of source code as a set of objects. I then take these objects manipulate them and then compile them or output them as source code. CodeDOM achieves this by allow you to use a CodeDOMProvider to generate a compiled .NET program or source code in CSharp or VB.NET.

Further investigation into the CodeDOMProvider is that it can generate source from

CompileUnit - a single grouping of namespaces, think source file.
Expression - a math or logical expression.
Member - a property, constructor, method or field in a class.
Namespace - says it all.
Statement - a code statement or block of code.
Type - a type including struct, enum, class or delegate.

The CodeDOM grammer is very complex consisting of 81 objects. For this posting I will just show you have to create a simple Class and output it in VB or C#. The listing is below. The steps are

Create the Code graph
Output Source in C#
Output Source in VB

I put the requirement for VB to show the true power of CodeDOM. The biggest step is the creation of the code graph. The code graph requires a CodeCompileUnit, Namespace, Class, field, property and method. I will leave you to explorer the code below and ponder why I am linking Mobile LOB and CodeDOM.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
using Microsoft.VisualBasic;
using System.IO;


namespace GenerateClass
{
 class Program
 {

 public static void GenerateSource(CodeDomProvider provider,
   CodeCompileUnit codeUnit)
 {
 StringBuilder sourceFile;
 IndentedTextWriter writer;

 sourceFile = new StringBuilder(@"c:\temp\HelloWorld");
 if (provider.FileExtension[0] != '.')
 {
  sourceFile.Append('.');
 }
 sourceFile.Append(provider.FileExtension);

 // Create a TextWriter to a StreamWriter to the output file.
 writer = new IndentedTextWriter(
 new StreamWriter(sourceFile.ToString(), false), " ");

 // Generate source code using the code provider.
 provider.GenerateCodeFromCompileUnit(codeUnit, writer, 
    new CodeGeneratorOptions());

 // Close the output file.
 writer.Close();

 }

 static void Main(string[] args)
 {
 CodeCompileUnit codeUnit;
 CodeFieldReferenceExpression fieldReference;
 CodeTypeDeclaration newClass;
 CodeMemberMethod newMethod;
 CodeMemberField newField;
 CodeMemberProperty newProperty;
 CodeNamespace ns;
 CodeTypeReference propertyType;
 CodeDomProvider provider;

 // Create Unit
 codeUnit = new CodeCompileUnit();

 // Create Namespace
 ns = new CodeNamespace("CodeDOMTest");
 ns.Imports.Add(new CodeNamespaceImport("system.IO"));
 codeUnit.Namespaces.Add(ns);

 // Create Class
 newClass = new CodeTypeDeclaration("HelloClass");
 newClass.IsClass = true;
 newClass.Attributes = MemberAttributes.Public;
 ns.Types.Add(newClass);

 // Create Property
 // Step 1. Create Type to be used by the field and property
 // Step 2. Create Field
 // Step 3. Create Property
 // Step 4. Add Get and Set statements

 propertyType = new CodeTypeReference(typeof(string));
 newField = new CodeMemberField(propertyType,"_name");
 newField.Attributes = MemberAttributes.Private;
 newClass.Members.Add(newField);
 fieldReference = new CodeFieldReferenceExpression();
 fieldReference.FieldName = "_name";
 newProperty = new CodeMemberProperty();
 newProperty.Name = "Name";
 newProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
 newProperty.Type = propertyType;

 // Get statement will be return _name
 newProperty.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));

 // Set statement will be _name = value
 newProperty.SetStatements.Add(new CodeAssignStatement(fieldReference,
     new CodeArgumentReferenceExpression("value")));
 newClass.Members.Add(newProperty);

 // Create Method
 newMethod = new CodeMemberMethod();
 newMethod.Name = "SayHello";
 newMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
 newMethod.Statements.Add(new CodeSnippetExpression(
   "Console.WriteLine(\"Hello \" + Name)"));
 newClass.Members.Add(newMethod);

 // Write CSharp
 GenerateSource(new CSharpCodeProvider(), codeUnit);

 // Write VB
 GenerateSource(new VBCodeProvider(), codeUnit);
 }
 }
}

.NET Deployment Landscape

2008-10-26T15:47:23-07:00

So since middle of June I have been working on the .NET CLR team. I am responsible for deployment of the .NET Framework. And boy is there some work to do. First things first though just how do you deploy applications written in .NET. It turns out that is a very complex topic.

Deployment Technology

So just how complex is .NET deployment -- it is as complex as how simple it can. You can deploy applications via

xcopy deploy
Visual Studio Setup Projects or 3rd party installers
Web Publish from Visual Studio
Clickonce
XBap
System Management tools like SMS and AD

The above is not even a complete list. So where do you start if you are writing a .NET application? The first thing is to not make the mistake of thinking deployment is the last thing you do.

Mobile Deployment

In the mobile world when picking which version of the Compact Framework one of the considerations is how the Compact Framework is deployed. Is the Framework already on the phone or will it have to be put on the phone? Typical if the application is an Enterprise Application using the latest Framework benefits outweigh the issues of deploying both the application and framework. If the application is consumer oriented then basing on the minimum platform Windows Mobile 5 or Windows Mobile 6 is a better chose. You pick Compact Framework 1.0 or Compact Framework 2.0 based on target hardware. This allows for targeting the largest audience while minimizing deployment and size issues.

Server Deployment

The server world might seem the simplest so I will start there. With servers the type of applications are typically web or server applications. In this scenario the application is deployed to one or more servers. Typically the .NET Framework has been installed or pushed to the servers usually via a application management system like System Center Configuration Manager. ASP.NET or WCF is stopped, xcopied over and then restarted. The difference when using SCCM is that the process is automated to allow deploying the application to tens or hundreds of servers without human intervention.

Client Deployment

So far it seems that deployment is simple deploy the .NET Framework and then the application. It turns out that device and server developers have it easy compared to desktop developers. Updating an application seems even easier just copy over the application. If only.

It turns out that just like device developers - desktop developers need to make some choices upfront. Desktop developers need to ask themselves how will the application be deployed. If you are desktop developer you have a lot of choices. Do you deploy via

Simple xcopy of the >NET application
Application management tool that deploys the framework and then your .NET applications
XBap allows for using the browser as the UI container. In this scenario the application is setup on a web server and hosted inside IE. Note you must push out the framework.
Clickonce is a technology that creates a package that ensures the framework is deployed before deploying and running the application. In fact Clickonce will ensure that the framework and application is up-to-date before running the application.
Finally a installer can be created to install just the .NET application or also the framework.

The space is large and this blog only gives you a glimpse into the deployment space. Hopefully you will find it useful.

One Click Download of .NET

2008-10-23T20:35:40-07:00

One of the parts of my job will be helping define the message around deploying .NET Applications. One of the feedbacks that I heard loud and clear is finding the .NET Framework is challenging. So here you go a single quick url for downloading the .NET Framework - http://www.microsoft.com/net.

On the page you can see a button on the right - Install it now. This will allow you to launch the .NET Framework web installer and get the latest version, currently 3.5 SP1.

The web installer is about 2.8 MB download that will examine your system and then download the appropiate components to install. Most people think the .NET Framework 3.5 SP1 231 MB which is actually the redistributable file size. However keep in mind that this package installs on XP, W2K3, Vista, W2K8 along with 32 bit, 64 bit and Itanium platforms. The last two platforms 64 bit and Itanium has to install the appropiate platform plus X86 WOW (32 bit compatibility mode). So while the package size is huge it has a lot of duplication due to carrying multiple MSI and CBS installers. So at the end of the day you end up downloading a much smaller size than the 231MB. Here are some rough numbers on platforms that I have checked.

OS & Platform	Size
XP 32 bit	54 MB
W2K3 64 bit	99 MB
Vista 32 bit	39 MB
Vista 64 bit	58 MB

Rob Tiffany and .NET Rocks

2008-10-09T10:48:13-07:00

My friend Rob Tiffany will be on .NET Rocks. Join him as he spends an hour discussing all aspects of Windows Mobile with Carl Franklin and Richard Campbell on .NET Rocks! at http://www.dotnetrocks.com/default.aspx?showNum=384. He takes the listeners on an irreverent, deep dive on the current state of Windows Mobile development as well as the benefits of System Center Mobile Device Manager.