David Bronman just posted a new version of the CLR Profiler that now also supports .NET Framework 4 as well as Silverlight 4. 
Key Features:

• Allows you to profile managed memory that uses .NET 2.0, 3.0, 3.5, or 4. 
  (However, you must always have .NET 4.0 installed on your box in order to use CLRProfiler V4, as CLRProfiler itself contains managed code that depends on .NET 4)
• Can target Silverlight 4 web apps.
• Can attach to and detach from live processes, to generate heap graphs. 
  (Note:  This feature requires the process to be running .NET 4.0, does not work against Silverlight, and does not allow gathering allocation call stacks.)
• Understands in-process side-by-side CLR instances, and can allow you to pick which CLR instance from a given process to profile

See more details here.

In the Memory Leak Hotfixes for WPF 3.5 SP1 blog post I mentioned that the memory leak fixes that went into KB981107 were only available for WPF 3.5 SP1. I am now happy to announce that these memory leak fixes are also available for WPF 4. 

You can get the fixes for WPF 4 from here: http://support.microsoft.com/kb/2297328

Enjoy. Jossef

Wanted folks know that we have started a new Blog that is dedicated to Silverlight performance.
We have uploaded two posts:

• Silverlight Startup Best Practices
• Analyzing Silverlight Memory Usage: Part 1 – Obtaining Measurements

We plan to add additional posts in the near future, so please stay tune.

In the WPFPerf Performance Profiling Tools for WPF 4 is now available! post, I mentioned that a bug caused the Visual Profiler to not display any data in certain time zones.
A patch is now available to fix this issue.
To install the patch:

1. Install the WPF Performance Tool like you normally would by installing the Windows SDK for Windows 7 and .NET Framework 4 (Windows SDK 7.1)
2. Install the patch from http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=da041972-1eb6-4a8a-97d7-d495b314505e
3. When you get to this dialog, click on 'Repair' 
    
4. On next dialog click 'Repair' again. 
   

As you know by default WPF uses Hardware acceleration (GPU) to render its content (aka Hardware rendering).
In most cases rendering using Hardware (HW) acceleration is much more performant than rendering using Software. In some small cases SW rendering may be faster (E.g. low end graphics card sometimes found in Netbooks).

WPF will always attempt to use HW rendering, but in certain cases WPF will fall to Software rendering and the application may not be aware of it.
Some folks wanted to better understand all the possible cases, so am I am listed these below.
WPF will render in Software when:

1. Machine video driver date is old (before 11/2004)
2. WPF detected a "Tier 0" graphic card.
   This means that no graphics hardware acceleration is supported and DirectX version level is less than version 7.0.
3. The rendered Window's size exceeds the max video card texture size.
   One common scenario for this to happen if you have a WPF window spanning across multiple monitors.
4. You run your application over Remote Desktop Protocol (e.g. Remote Desktop, Terminal Server, Remote Assistant, etc)
   Until NET 3.5 SP1 and earlier, remoting between Vista to Vista with DWM on, leveraged a custom WPF primitive remoting protocol. In all other scenarios content was remoted as bitmaps. Starting with the release of NET 3.5 SP1 (including NET 4), WPF renders the application content using a software rasterizer on the server and then remotes the content as bitmaps in all cases. Read more here.
5. Rendering in Virtual Machine.
   WPF will try and render in HW but on some VMs the graphic emulator that comes with the VM is not working correctly. User will have to switch to software to fix the problem. 
6. The Application is calling the force Software API. E.g.
   RenderOptions.ProcessRenderMode = RenderMode.SoftwareOnly;       // Force Software rendering per Process – New in NET4
   hwndTarget.RenderMode = RenderMode.SoftwareOnly;        // Force Software rendering per Window– Introduced in Net 3.5 SP1
7. You set the global registry key. E.g.:
   (HKEY_CURRENT_USER\Software\Microsoft\Avalon.Graphics] 
   "DisableHWAcceleration"=dword:00000000 )
   Note: Since this reg key impacts all WPF application consider using this key for testing purposes only.
8. Application uses legacy style bitmap effects.
   Note: these are obsolete in NET4.
9. Application printed content.
10. Rasterized content that uses RenderTargetBitmap
11. Tiled content that uses TileBrush
12. Use of too many light objects in your 3D scene. Read more here.
13. Layered windows (only on XP SP2/W2k3 or before that do not have Hotfix installed.
    See: http://support.microsoft.com/kb/937106/en-us.
14. Graphics hardware failures, such as "Out Of Video Memory" (OOVM).
    WPF try to free up video memory and stay in HW rendering but it may not always work and WPF will fall to Software  

Which tools can I use to detect if my app renders in Software?
The easiest way is to use Perforator which is included with the WPF Performance Profiling Tools and check below check boxes.
Read more here.

How can I detect if my app renders in Software in code?
Check the RenderingCapability.Tier . You can also listen on the Tier change event.

Hopefully folks saw my related blog post Finding Memory Leaks in WPF-based applications .
In this post below I wanted folks to be aware that we released few other KB Articles (Hotfix) that address other various memory leaks reported in .NET 3.5 SP1. Some of these fixes made it to .NET 4.

1. KB981107 (See: http://support.microsoft.com/kb/981107)

This Hotfix fixes the following memory leaks in .NET 3.5 SP1 WPF-based applications.
Issue 1:
This affects an app that contains styles or templates that refer to application resources (via StaticResource or DynamicResource), and that creates a large number of elements that use these styles or templates but never need the actual value of the resource.  In this situation, the app can leak DeferredAppResourceReference objects, even after the elements themselves have been reclaimed.  (In addition, the app can leak WeakReferences and array space, similar to the issues described below.)

An example:  App resources define   <sys:Double x:Key="{x:Static SystemParameters.HorizontalScrollBarHeightKey}">20</sys:Double>     This creates a resource that's used by any control that can display a horizontal scrollbar.  Creating a large number of such controls that never actually display their scrollbar will encounter the leak.

Issue 2:
This affects an app that creates a large number of short-lived elements with properties that are data-bound to a DependencyProperty of longer-lived elements. In this situation, the longer-lived elements maintain lists of WeakReference objects, used to notify the short-lived elements about property changes. The app can leak WeakReference objects and the array space to hold them, even after the short-lived elements have been reclaimed.

An example:   ListBoxItem binds its HorizontalContentAlignment property to a similar property on its governing ListBox.   An app that creates a large number of ListBoxItems (say by doing a large number of additions and deletions to the ListBox's ItemsSource) will encounter the leak.

Issue 3:
This issue affects classes derived from TreeView or Selector (including ListBox, ListView, Menu, DataGrid, and many others).   These classes register for an internal notification from the KeyboardNavigation class, used for controlling keyboard focus.   An app that creates a large number of these elements can leak WeakReference objects and the array space to hold them, even after the elements themselves have been reclaimed.
An example:  An app that creates a large number of short-lived ListBoxes will encounter the leak.  This can happen in a nested scenario, where an outer ListBox displays a collection that undergoes a large number of additions and deletions, and where each item is displayed using an inner ListBox.

These fixes are not included in NET4. We are considering this Hotfix also for NET4, but this decision has not been made, so stay tune.

2. KB967634: (See: http://support.microsoft.com/kb/967634 )

This fixes a memory leaks in .NET 3.5 SP1 WPF-based applications when using software 3D rendering involving a VisualBrush or DrawingBrush.
This fix is already included in .NET 4.

3. KB967328 (See: http://support.microsoft.com/Default.aspx?kbid=967328)

This Hotfix fixes memory leaks when a deferred resource isn't inflated due to the resource reference expression hooking up to the Inflated event on the resource dictionary entry.
If the resource dictionary is an application or theme dictionary, then these are essentially global and can cause these expressions to stay alive.
There are some discussions on this issue here.
This fix is already included in .NET 4.

As you may know, when you interoperate WPF with other technologies you can't overlay WPF and WinForms/Win32 content because of the "airspace" limitations (read more here).
Any given pixel in a window is either owned by WPF or WinForms/Win32, not both. On the other hand, you can overlay all the WPF content you want because WPF manages and renders all of them.

Many folks however are looking to overlay WPF content over Web content. Chris Cavanagh posted sometimes ago a blog that explain how you can do so using Google's web control.
Sources for a sample are available on Codeplex. You would need to license the wrapper called Awesomium.

Not sure if folks are aware, but Visual Studio 2010 now includes WPF Visualizer. This can really help you during debugging.
It basically allows you to explore and visualize the Visual Tree and properties of a WPF object during a debug sessions. Similar to what Mole was doing, but this is now built-in to Visual Studio 2010.

To use:
During debug, in a DataTip, Watch window, Autos window, or Locals window, next to a WPF object name, click the arrow adjacent to the magnifying glass icon.
See images below for the SDK example I used:

 Not sure if folks aware that Snoop for WPF 4.0 has been available for a while.
You can download it from here.

This version includes other impressive list of improvements that you can read about here.
Thanks to Corry Plotts and others (Dan Hanan, Mark Kharitonov, etc) who improved on Pete Blois’ original Snoop.

The WPFPerf tool comprises of a suite of performance profiling tools that allow you to analyze the run-time behavior of your WPF application and point to potential performance bottlenecks.
We finally release the version that also supports .NET Framework 4 (WPF 4).

This version of the tool (WPFPerf 4) will allow you to profile both WPF 3.5 SP1 and WPF 4 based applications.
The WPFPerf 4 tool is included with the Windows SDK for Windows 7 and .NET Framework 4 (Windows SDK 7.1). So you are welcome to download and send us your feedback.

By the way, the tool itself will run on machines with only .NET 3.5 SP1 or only .NET 4, if both are present it will use .NET 3.5 SP1.
Also, I am not sure how many people had a chance to look at the documentation that is installed with the tool , but we think it is very useful so don't forget to check it out.

Update (6/14/2010):
We heard that few folks complain that the Visual Profiler cannot correctly attach to the WPF application in the new WPFPerf for WPF 4.
After some research we think this has to do with a bug in our DateTime initialization which cause anyone in a time zone > GMT to not get any data in VisualProfiler (for a few hours at least).
Until we post a fix, a temporary workaround is to set your time zone > GMT (e.g.to Eastern or Pacific Standard Time Zones) when you first attach VisualProfiler.

Please try this workaround and let us know.

Update (8/24/2010):
A patch to that fixes the bug in Visual Profiler for certain time zones is now available.
See here.

Hopefully folks saw my first “WPF 3.5 SP1 Performance on Tablet & Touch-enabled machines” blog.

In that blog I have mentioned that depending on the WPF application and scenario you may see significant performance issues and general sluggishness on Tablet & Touch-enabled machines and even on none-touch machines when UI Automation client apps are running (such as UI Spy, Narrator, Magnifier, etc).

This was especially noticeable during scrolling if the application comprise of many visual elements.

As I mentioned we have already fixed this issue in .NET 4.

I am now happy to announce that we just posted a Hotfix for .NET 3.5 SP1 that you can download from MSDN Code Galley site here and the Connect site here.

Enjoy. Jossef.

In .NET Framework 4 we have introduced a streamlined subset and more compact version of the .NET Framework called the Microsoft .NET Framework 4 Client Profile (aka NET4 Client Profile). The Microsoft .NET Framework 4 which is the Full Framework (aka NET4 Full) still exists and it is a superset of the Client Profile.
Hopefully folks have seen Soma’s blog announcing the availability of Visual Studio 2010 , .NET Framework 4 and .NET Framework 4 Client Profile.
I have discussed some of the beta features of Microsoft .NET Framework 4 Client Profile in details in my previous Beta 1 blog and Beta 2 blog posts.  In this post I wanted to highlight some of the key changes from our previous Beta 2 public release and reiterate some of the important features

What are the reasons for a Client Profile?
Although the NET4 Client Profile is smaller and faster to install compared to the NET4 Full Framework (NET4 is 7-8MB smaller in size than the Full Framework), the main reasons are not just better deployment size/time but also:

• Reduce the Framework deployment failures.
• By keeping ASP.Net and other components (that are mostly needed for servers) out of the Client Profile, we can reduce the attack surface and the number of future servicing events which may be caused by server component (such as ASP.Net) and are not needed for desktop scenarios.
• Making NET4 Client Profile available on Windows Update will make sure that most desktop machines will include NET4 Client Profile over time and apps that target the Client Profile will not need to carry or install the Framework which will improve the overall deployment experience.
• Enable us to add features and grow the size of overall Framework in future versions but still have a smaller core.

When to use NET4 Client Profile and when to use NET4 Full Framework?
NET4 Client Profile:
Always target NET4 Client Profile for all your client desktop applications (including Windows Forms and WPF apps).

NET4 Full framework:
Target NET4 Full only if the features or assemblies that your app need are not included in the Client Profile. This includes:

• If you are building Server apps. Such as:
  • ASP.Net apps
  • Server-side ASMX based web services
• If you use legacy client scenarios. Such as:
  • Use System.Data.OracleClient.dll which is deprecated in NET4 and not included in the Client Profile.
  • Use legacy Windows Workflow Foundation 3.0 or 3.5 (WF3.0 , WF3.5)
• If you targeting developer scenarios and need tool such as MSBuild or need access to design assemblies such as System.Design.dll

How big is Client Profile?
Below are the redistributable download size improvements since NET 3.5 SP1. As you can see we have made significant improvements.
Note that if you are downloading from the Web, the actual download size could be smaller since some components may already be on your machine (for example, Software Rasterizer (rgb9rast) , etc )

What is new in NET4 Client Profile RTM vs. Beta 2 ?

What is new in Visual Studio 2010 for NET4 Client Profile

Since Beta 2 we made some small but important improvements to the he VS 2010 RTM UI:
(You can read about the changes we in Beta2 in my Beta 2 blog )
  A) Starting with VS 2010 RTM, the “Add Reference” indicates the target framework that assemblies are filtered against.
  B) The VS 2010 RTM toolbox now clearly indicates if 3^rd party controls are not available for the selected profile.

How to use Client Profile in Visual Studio 2010

Visual Studio 2008 introduced multi-targeting to allow application to target 2.0 and 3.x versions of the .NET Framework. VS 2010 has improved multi-targeting and starting in VS 2010 Beta2 many of the Client projects are targeting the NET4 Client Profile by default. I also discussed this in my Beta 2 blog .

Projects that target NET4 Client Profile by default

These projects starting with VS 20101 Beta2 target the NET4 Client Profile by default:
Windows Project (C# and VB)
- WPF Application
- WPF Browser Application
- WPF Custom Control Library
- WPF User Control Library
- Windows Forms Application
- Windows Forms Control Library
- Console Application
- Empty Project
- Window Service

Visual F#
- F# Application
- F# Tutorial

Workflow (C# & VB)
- Activity Designer Library
- Activity Library
- Workflow Console Application

WCF (C# & VB)
- WCF  Service Library

Office 2007 & 2010 templates (C# & VB)
- All Projects

All other projects, including Class Library, target the Full Framework by default.
Mixed-target scenarios using Class Library may present interesting challenges. Read more below.

How to retarget your C#/VB.Net project

To change targeting of your project, open the project properties, select the "Application" page, and change the “Target framework” drop-down.
C# project example:

VB project example (Project Properties > Compile tab > “Advanced Compile Options…”):

Note that if you right-click the project and select “Add References”, the dialog shows only the .NET Framework assemblies that are part of the selected profile. This is accomplished by using reference assemblies (metadata-only versions of assemblies). The .NET Framework 4 Client Profile Reference Assemblies are located in:
     %programfiles%\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\Profile\Client

At compile time, the reference assemblies are matched up against the known "Client List" assemblies that are included in the Client Profile. If a project targeting the Client Profile has a reference to a .NET assembly that is not included in the "Client List", Visual Studio displays compile-time errors in the Error List.

How to change targeting for other projects

Some other VS 2010 projects such as Managed C++ (C++/CLI) still target the Full Framework by default. VS 2010 unfortunately does not provide UI to change the targeting.
Fortunately, you can still edit the project file manually in order to change the profile targeting. To do so:
a) Right click “Unload Project”
b) Right-Click “Edit <project_name>”
c) Set the appropriate project property to target Client Profile. e.g.

<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<TargetFrameworkProfile>Client</TargetFrameworkProfile>

d) Right click “Reload Project”

In addition, for these projects, notice that VS does not create an <app.config> file for your project.
Note: If your project does not add references or access assemblies that are included in the Full Framework but are not part of the Client Profile, there is nothing to worry about. Your app will run on machines with either NET4 Client Profile or Full Framework just fine.
Otherwise, if you do access assemblies from the Full Framework, you should add <app.config> to indicate to CLR not to load your app if it is launched on the NET4 Client Profile.
E.g. add this:

<?xml version="1.0"?>
<configuration>
    <startup>
          <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
   </startup>
</configuration>

If you don’t do so, your app may crash at random when it needs to load the assemblies that are missing from the Client Profile.

Deployment

The project Publish property page allows you to select the prerequisite needed for your ClickOnce deployment. VS 2010 automatically selects the correct profile (Client Profile or Full) depending on your primary project target.
 

Setup and Deployment Projects

The same prerequisite dialog from above appears when you create “Setup and Deployment” project (under “Add New Project”/“Other Project Types”). The NET4 Client Profile prerequisite entry is checked by default in this case.

 
If you create a new “Visual Studio Installer” setup project (under “Setup and Deployment“) and add the output of your NET4 Client Profile to it (Right-Click ->“Add”-> “Project Output…”’ select “Primary output”) , VS2010 adds a new “Launch Condition”. (Right-click on your new Setup project and then do “View->Launch Conditions”)

By default VS2010 will add NET4 Client Profile as a launch condition.

What this means is that once all prerequisites are installed and before the main installation launches, setup checks whether all the launch conditions are met. If not, setup blocks and displays an error message.

Testing NET4 Client Profile applications
VS 2010 itself requires the NET 4 Full in order to run and it therefore install NET 4 Full.
If your target NET4 Client Profile, it is highly recommended that you test your application on a separate machine that only includes NET4 Client Profile.

Common Questions & Issues with NET4 Client Profile
1.  How can I select the .NET Profile in the “New Project” dialog?
When you create new project in VS 2010, the “New Project” dialog does not indicate if the new project you are about to create is targeting Client Profile or Full. You can always go to the project Properties (see above) and change the target if you like.

2.  I cannot find an assembly in “Add Reference” dialog
The “Add Reference” .NET tab dialog only shows the .NET Framework assemblies that are part of the selected profile. So some assemblies, such as System.Web.dll are not included in NET4 Client Profile and will only show if you target the Full framework. If you must use System.Web.dll you need to retarget to the Full framework.
Starting with VS 2010 RTM, the “Add Reference” indicates the target framework that assemblies are filtered against.
3.  My project cannot compile when I reference a Class Library
You may encounter mixed-target scenarios: for example, when your Client Profile app adds a reference to a Class Library that is targeting the Full Framework (which it targets by default). You should be able to successfully build such solutions, as long as the Class Library does not use references to assemblies that only exist in the Full Framework. If it does, you may get warning/errors that are not completely clear.

For example you may see an error in your Client Profile app saying:
“The type or namespace name 'ClassLibrary1' could not be found (are you missing a using directive or an assembly reference?)”

This error is not clear because the class library exists and can be compiled when it is compiled by itself. However, when MSBuild tries to resolve the transitive closure of the Client Profile project, it cannot find the Full Framework assembly that is referenced by the Class Library. In this case it is better to look at the generated warnings which are more informative:
“The referenced assembly " …<your assembly>.." could not be resolved because it has a dependency on ""…<some assembly only available in Full Framework>…” which is not in the currently targeted framework ".NETFramework,Version=v4.0,Profile=Client". Please remove references to assemblies not in the targeted framework or consider retargeting your project.”

4.  My controls or 3^rd party controls is now showing in the VS 2010 toolbox
Some VS 2008 3^rd party Winforms controls will not work with VS 2010 NET4 Client Profile projects.
The reason is that some of these controls have do not have separate design-time and run-time components and have dependencies on assemblies that are in the Full Framework (for example dependency on System.Windows.Forms.Design.dll which is Full).
In VS 2010 RTM we made some changes to make it easier for developers to realize that.

Per the image below you can see that the VS 2008 DevExpress Winforms control are not showing in VS 2010 Toolbox and instead you see the message “Controls in this category are unavailable for the .NET Framework 4 Client Profile. To change this setting, open the Project Properties windows.”
The Xceed VS 2008 controls on the other hand do have separate design-time and run-time components and works fine in VS 2008 and VS 2010.
The good news is that many of the control vendors plan to release update to their control soon after VS 2010 RTM. Until such updates are available you need to retarget your project to NET4 Full if you must use these controls.

 
5.  What should I do if a component that I need is not in NET4 Client Profile?
Your first option is to try to find a workaround by modifying your code to use a component that is included in NET4 Client Profile. If this is not possible retarget your project to NET4 Full. As mentioned before, this is not ideal as most desktops are ikely to only have NET4 Client Profile so your app would need to chain-install NET4 full or block your app setup on NET4 full being present.

6.  I want to write a custom WinForms control, what do I need to do for it to work with NET4 Client Profile?
When developing Windows Forms control libraries, it is necessary to separate the runtime code from the control designers in order to target the new Client Profile. If the assembly references classes that exist in the Full framework but not in the Client Profile, the project will not compile successfully. Custom control designers usually inherit from the System.Windows.Forms.Design.ControlDesigner class in System.Design.dll, which is not included in .Net Framework 4 Client Profile.

We posted a guide that can walk you through the steps of creating a Windows Forms control that can be used in the .NET Framework 4 Client Profile. See: http://code.msdn.microsoft.com/WinFormsCustomCtrl
Note that WPF custom controls do not inherit from classes in System.Design.dll and do not have this issue.

7. What’s the deal with <app.config> file ?
If you change the project to target the Full Framework, VS will add a configuration file (<app.config>) that declares the application as a "full" application.

This enables the CLR loader to block any NET4 apps that target full on machines that only have the Client Profile. In this case, the CLR prompts the user to install NET4 full. E.g. you may see this dialog:

 
Note that in NET4 Beta1 and NET3.5 SP1 Client Profile if the <app.config> was missing the CLR the assumption was that you targeted the Full Framework. This is now reversed.
In other words, if your NET4 app is missing <app.config> , by default the CLR assume that your app is targeting NET4 Client Profile! so, your app may crash at random when it needs to load the assemblies that

What components are new in NET4 Client Profile RTM?

This has not significantly changed since Beta2, so read my Beta 2 blog. We did make some tweaks however in RTM (and RC), most notably:

• Developers who need to use System.Web.HttpUtility in their client apps and had to reference System.Web.dll and therefore target NET4 full (System.Web.dll is in Full) , can now target the NET4 Client Profile by using the new System.Net.WebUtility class which is in System.dll (System.dll is in NET4 Client Profile).
  System.Net.WebUtility includes HtmlEncode and HtmlDecode. Url encoding can be accomplished using the System.Uri class (also in System.dll).
• Files moved from Client to Extended (Full):
    - csc.rsp and vbc.rsp
• Files moved from Extended (Full) to Client:
    - System.ComponentModel.DataAnnotations.dll
    - Microsoft.CSharp.Resources.dll and System.Dynamic.Resources.dll
    - InstallUtil.exe, Installutil.exe.config and InstallUtillib.dll

Enhancements in NET4 Client Profile vs. NET 3.5 SP1 Client Profile
This has not changed since Beta2, so read my Beta 2 blog .

What’s in and what’s not included in the Client Profile?
Other than the APIs that were “Grey” out in RTM (and RC) and the tweaks mentioned above, we did not make other significantly changes since Beta2, so read my Beta 2 blog.

Where can I get the NET4 Client Profile?
You can get .NET Framework 4 from here:

• dotNetFx40_Client_x86_x64.exe (41 MB): This is the Client Profile SKU that you must install on any supported 64-bit OS. This will also install on any supported 32-bit OS. Your app could run in WOW64 if it was compiled w/ "32-bit" flag or as 64-bit if you compile with "AnyCPU" or "64-bit" flags.
  If you are redistributing the Client Profile with your application you most likely want to redist this package as it can install on both 32 and 64 bit OS’s.
• dotNetFx40_Client_x86.exe (28.8 MB): This is the Client Profile SKU that you could use to install on any supported 32-bit OS.  Choose this only if all your users are running 32 bit OS. (in most times this will not be your case…)
• dotNetFx40_Full_x86_x64.exe (48.1 MB): This is the Full Framework SKU that you must install on any supported 64-bit OS. This will also install on any supported 32-bit OS.
  If you are redistributing the Full Framework with your application you most likely want to redist this package as it can install on both 32 and 64 bit OS’s.
• dotNetFx40_Full_x86.exe (35.3 MB): This is the Full Framework SKU that you could use to install on any supported 32-bit OS. Choose this only if all your users are running 32 bit OS (in most times this will not be your case…)
• NET 4 RTM Web Bootstrapper: This is what you want to install if you need NET4 Full and you are online. This will detect your OS and processor architecture and will install the appropriate Framework.
• NET 4 Client Profile RTM Web Bootstrapper: This is what you want to install if you need NET4 Client Profile and you are online. This will detect your OS and processor architecture and will install the appropriate Client Profile.

Related Blogs and Resources

• What's New in the .NET Framework 4
• NET Framework 4 Client Profile - Introduction
• What’s new in .NET Framework 4 Client Profile Beta 2.
• How to: Build Windows Forms Custom Control that Supports NetFx 4 Client Profile
• NET Framework 4 Beta 2 on WU

Appendix A:

Here are the files that exist in the NET4 Client Profile and NET4 Full framework.