We are super-excited to announce that our team will be at the event of the year in Italy: Microsoft Tecnical Conferences 2011.

This event groups three of the most important conferences in Italy about SharePoint 2010, SQL Server and Unified Comunication.
The location is Milan and the dates to save are: 19-20-21 April 2011.

Check-out the Agenda and register to attend the event !

Hope to see you there !

WCF Client Error:: Can't find method: 'Boolean System.IdentityModel.Selectors.SecurityTokenRequirement. get_IsOptionalToken()'

Be aware that this is a bug that can be solved after installing a Microsoft hotfix and after restarting your server even if the kb article says that the reboot is not required.

Windows 2008 R2 and Windows 7
KB article: http://support.microsoft.com/kb/976462
Hotfix: http://code.msdn.microsoft.com/KB976462

Windows 2008 and olders
KB-article: http://support.microsoft.com/kb/976394
Installer: http://code.msdn.microsoft.com/KB976394

At the beginning, after reading all data of  the SharePoint list, I haven't noticed anything weird, but later on, I have noticed a mismatch between the dates in my application and the ones visible in the SharePoint 2010 interface.

Just try to create a new Task list in one of your SharePoint 2010 sites, add some tasks with different dates and paste this code in a console application (after having added the reference both to the Microsoft.SharePoint.dll library and to the Microsoft.SharePoint.Client.dll client object model libraries and Microsoft.SharePoint.Client.Runtime.dll):

Console.WriteLine("Client object model:");
ClientContext context = new ClientContext("http://sharepoint2010/");
using (context)
{
    List l = context.Web.Lists.GetByTitle("Tasks");
    ListItemCollection items = l.GetItems(CamlQuery.CreateAllItemsQuery());
    context.Load(items, its => its.Include(i => i["StartDate"]));
    context.ExecuteQuery();
    foreach (ListItem item in items)
    {
        Console.WriteLine("{0}", (DateTime)item["StartDate"]);
    }
}

Console.WriteLine("Server object model:");
SPSite site = new SPSite("http://sharepoint2010/");
using (site)
{
    SPWeb web = site.OpenWeb();
    SPList list = web.Lists["Tasks"];
    foreach (SPListItem item in list.GetItems("StartDate"))
    {
        Console.WriteLine("{0}", (DateTime)item["StartDate"]);
    }
}

If you follow this code on any SharePoint site (created with any language, even the one of your client machine), I am sure you will realize that there are different values for date and time.

If you don't believe me, have a look at this screenshot:

As you can see, the first 4 dates are different from those in the same list through the side server object model. Don't look at the hours (as in my "Date and time" field the user was allowed to add only the dates),  but in these 4 values there is a discrepancy of a day.
I focused immediately on the bug (you can imagine why… :), then it came up in my mind that my application is executed on the client, so it is very likely that the language used is different then the one used to create the SharePoint site (or the language used to set the "Regional settings" section). As a matter of fact, getting back the ToUniversalTime() method of the DateTime class, I understood that the dates were exactly the same.
Therefore, the problem was: "What can I do to visualize the dates through the same culture of my client application?".
I tried to use the ConvertToDateTime method moving the same culture in the "Regional Settings" page of the SharePoint site, but it did not work! Dates were still diverse.

DateTime s = Convert.ToDateTime(((DateTime)item["StartDate"]), new CultureInfo("en-US"));
Console.WriteLine("{0}", s);

By seeking in the SDK, I finally find the fantastic Utility class and the even more amazing FormatDateTime  method, which executes the DateTime conversion according to the format you want in the SharePoint 2010 "Regional Settings".
When I apply it to my code, my date values are correctly visualized as in my site interface.

Console.WriteLine("Client object model:");
ClientContext context = new ClientContext("http://sharepoint2010/");
using (context)
{
    Web web = context.Web;
    List l = web.Lists.GetByTitle("Tasks");
    ListItemCollection items = l.GetItems(CamlQuery.CreateAllItemsQuery());
    context.Load(web, w => w.Language);
    context.Load(items, its => its.Include(i => i["StartDate"]));
    context.ExecuteQuery();

    foreach (ListItem item in items)
    {
        DateTime start = ((DateTime)item["StartDate"]);
        ClientResult result = Utility.FormatDateTime(context, context.Web, start, DateTimeFormat.DateTime);
        context.ExecuteQuery();
        DateTime rightStart = Convert.ToDateTime(result.Value, new CultureInfo((int)web.Language));
        Console.WriteLine("{0}", rightStart);
    }
}

Practically, during a normal query through the SharePOint 2010 clinet object model, dates go back to the client application in the UTC format and need to be converted.
Here it is the result when executing the second method (correct) together with the first one (incorrect).

I also want to give you the sources, so you can try yourself what I just said (without writing from scratch):

ClientObjectModelDates.zip (37,4 Kb)

Hope this helps..

Retrieving the COM class factory for component with CLSID {BDEADF26-C265-11D0-BCED-00A0C90AB50F} failed due to the following error: 800703fa.

and every SharePoint's page looks like this:

Server Error in '/' Application.

Retrieving the COM class factory for component with CLSID {BDEADF26-C265-11D0-BCED-00A0C90AB50F} failed due to the following error: 800703fa.

Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.

Exception Details: System.Runtime.InteropServices.COMException: Retrieving the COM class factory for component with CLSID {BDEADF26-C265-11D0-BCED-00A0C90AB50F} failed due to the following error: 800703fa.

Source Error:

Stack Trace:

you can fix this issue by setting the Load User Profile to True in your site's Application pool's advanced settings:

After that, just reload your page and the problem should be fixed.

A Javascript function, which is added in the definition related to the Ribbon command, will do the control. In particular, this function should be added in the "EnableScript" attribute of the "CommandUIHhandler" element and should be a Boolean value, so the SharePoint 2010 interface can understand when enabling or disabling the control.

In order to enable or disable our Ribbon control on the basis of the selection by the user on the list elements, we have to use the Client Object Model for ECMAScript offered by SharePoint 2010 and its classes for the selection. Let's see how:

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction Id="Ribbon.HelloWorld"
                RegistrationId="101"
                RegistrationType="List"
                Location="CommandUI.Ribbon"
                Title="Hello world ribbon">
    <CommandUIExtension>
      <CommandUIDefinitions>
        <CommandUIDefinition Location="Ribbon.Documents.Manage.Controls._children">
          <Button Id="Ribbon.HelloWorld.Button"
                  LabelText="Hello world"
                  TemplateAlias="o1"
                  Image32by32="/_layouts/images/PeppeDotNet/HelloWorld32by32.png"
                  Sequence="31"
                  Command="HelloWorld" />
        </CommandUIDefinition>
      </CommandUIDefinitions>
      <CommandUIHandlers>
        <CommandUIHandler Command="HelloWorld"
                          CommandAction="javascript:alert('Action for only one item !');"
                          EnabledScript="javascript:SP.ListOperation.Selection.getSelectedItems().length == 1;"/>
      </CommandUIHandlers>
    </CommandUIExtension>
  </CustomAction>
</Elements>

In the example, we have decided that our trial Ribbon should be enabled only when the user has selected a single element. In the SharePoint team blog you can find another implementation of this behaviour, available through the CountDictionary() function.

If the user has selected more elements or if he has not chosen any yet, the button is disabled.

This allows to execute operations on single items of a SharePoint list. Similarly, if we want to execute operations on more than one item selected from a list, we would have to write the code controlling that the user selection contains more than one element (just the opposite as written before).

<CommandUIHandler Command="HelloWorld"
                  CommandAction="javascript:alert(Action for multiple items !');"
                  EnabledScript="javascript:SP.ListOperation.Selection.getSelectedItems().length > 1;"/>

This allows to execute the same operation on more documents (or items) selected by the user. In fact, the SP.ListOperation.Selection.getSelectedItems() function, peculiar of the client-side object model for ECMAScript (we will see a brief introduction later on), will return a collection of elements containing all the objects that have been selected by the user, with their identifier, which are useful to execute our custom operations.

If the selection is single, that function will return a collection containing a single element.

In these examples, we have used classes exposed by the client-side object model for ECMAScript in order to enable or disable our Ribbon control.  We have the opportunity to do any kind of calculation in our script, using one or more functions, keeping in mind that the main function should return a Boolean value.

<CommandUIHandler Command="HelloWorld"
                  CommandAction="javascript:alert('Action only for work-hours !');"
                  EnabledScript="javascript:function enableRibbonOnWorkingHours() {
                                    var hour = getCurrentHour();
                                    return (hour &gt;= 9 &amp;&amp; hour &lt;= 18);
                                  };
                                  function getCurrentHour()
                                  {
                                    var d = new Date();
                                    return d.getHours();
                                  }
                                  enableRibbonOnWorkingHours();"/>

In the following post we will see how to move externally to the XML file of custom Ribbon definition (this means in a specific .js file) all Javascript code that is used both for the control activation and inactivation  and for the action that needs to be copied after the user has clicked on the control itself.

In detail, some kind of controls can be represented by two different images, obviously of different dimensions:

• Image 32 x 32: its URL should be defined in the "Image32by32" attribute
• Image 16 x 16: its URL should be defined in the "Image16by16" attribute

Controls that offer the possibility of visualizing these two different image formats are the following:

• Button
• SplitButton
• ToggleButton
• FlyoutAnchor

We can define a further series of attributes which modify the visualization in any of these two images. Here they are in detail:

• Image32by32Class / Image16by16Class: CSS class name will be applied to the image.
• Image32by32Left / Image16by16Left: negative value representing the offset to the left margin with which the image is renderized.
• Image32by32Top / Image16by16Top: negative value representing the offset to the top margin with which the image is renderized.

The last two attributes are utilized by SharePoint to renderize part of images containing icons that are useful to different controls.

Other controls, which can be configured in order to visualize an image in the Ribbon Bar, are the GalleryButton control (through the "Image" attribute)and the Label control (which only contains the "Image16by16" attribute).

If you wish more information about the schema of all the controls you can add in the Ribbon Bar, please have a look at the on-line documentation on this address:
http://msdn.microsoft.com/en-us/library/ff458369.aspx

In order to do so, any control, which can be added in the extension of the developing SharePoint interface, shows the TemplateAlias attribute. This attribute is necessary to specify the template identifier you intend to use in order to set a width and a size to this control, when a template is applied to a group in which our custom Ribbon has to be added.

In the first example, we have applied to the button the template with alias "o1". This alias allows the rendering system of the SharePoint 2010 Ribbon bar to set the maximum width and height to the button. Besides, it applies to this button the image in which the URL is defined in the "Image32by32" attribute.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction Id="Ribbon.HelloWorld"
                RegistrationId="101"
                RegistrationType="List"
                Location="CommandUI.Ribbon"
                Title="Hello world ribbon">
    <CommandUIExtension>
      <CommandUIDefinitions>
        <CommandUIDefinition Location="Ribbon.Documents.Manage.Controls._children">
          <Button Id="Ribbon.HelloWorld.Button"
                  LabelText="Hello world"
                  TemplateAlias="o1"
                 Image32by32="/_layouts/images/PeppeDotNet/HelloWorld32by32.png"
                  Sequence="31"
                  Command="HelloWorld" />
        </CommandUIDefinition>
      </CommandUIDefinitions>
      <CommandUIHandlers>
        <CommandUIHandler Command="HelloWorld"
                          CommandAction="javascript:alert('Hello world from BIG Ribbon !');" />
      </CommandUIHandlers>
    </CommandUIExtension>
  </CustomAction>
</Elements>

We are already concerned in the result of a button with "TemplateAlias" attribute valued with "o1".

If we want to visualize our custom Ribbon in a smaller format, we have to specify a new value for the TemplateAlias attribute. This is the "o2" value, which specifies the maximum text dimension, the position and the use of the image whose URL is defined in the "Image16by16" attribute.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction Id="Ribbon.HelloWorld"
                RegistrationId="101"
                RegistrationType="List"
                Location="CommandUI.Ribbon"
                Title="Hello world ribbon">
    <CommandUIExtension>
      <CommandUIDefinitions>
        <CommandUIDefinition Location="Ribbon.Documents.Manage.Controls._children">
          <Button Id="Ribbon.HelloWorld.Button"
                  LabelText="Hello world"
                  TemplateAlias="o2"
                  Image16by16="/_layouts/images/PeppeDotNet/HelloWorld16by16.png"
                  Sequence="31"
                  Command="HelloWorld" />
        </CommandUIDefinition>
      </CommandUIDefinitions>
      <CommandUIHandlers>
        <CommandUIHandler Command="HelloWorld"
                          CommandAction="javascript:alert('Hello world from LITTLE Ribbon !');" />
      </CommandUIHandlers>
    </CommandUIExtension>
  </CustomAction>
</Elements>

Once the deployment is done, you will see our custom button appearing in the second control group (in the "Manage" group of the "Documents" tab), together with all those controls with minimum height. If you wish to move before, during or after the other controls already there, you can play with the "Sequence" attribute values (as explained in this post).

The template alias we have seen so far ("01" and "o2") are valid when we want to add a control in one of the groups that already exist in the SharePoint 2010 Ribbon bar. If we want to create custom tabs and groups, we can define our custom templates for the controls visualization.

Note: In this sense, it is necessary to define what we mean with "last", as these controls will be visualized after all those defined with the same "TemplateAlias" (in the following posts we will explain how useful this attribute can be).

In the figure below, what we see is that the "Manage" group of "Documents" tab (belonging to every SharePoint 2010 site Document Library) has two controls with "TemplateAlias" attribute with "o1" value. These controls are needed in order to visualize the document properties or their modification.

In the previous example, the custom Ribbon is positioned with a "Hello World" label, after the other two.

If we want to move our custom button ahead (or in any other position), we have to give our control "Sequence" attribute a whole value.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction Id="Ribbon.HelloWorld"
                RegistrationId="101"
                RegistrationType="List"
                Location="CommandUI.Ribbon"
                Title="Hello world ribbon">
    <CommandUIExtension>
      <CommandUIDefinitions>
        <CommandUIDefinition Location="Ribbon.Documents.Manage.Controls._children">
          <Button Id="Ribbon.HelloWorld.Button"
                  LabelText="Hello world"
                  TemplateAlias="o1"
                  Sequence="1"
                  Command="HelloWorld" />
        </CommandUIDefinition>
      </CommandUIDefinitions>
      <CommandUIHandlers>
        <CommandUIHandler Command="HelloWorld" 
                         CommandAction="javascript:alert('Hello world from Ribbon !');" />
      </CommandUIHandlers>
    </CommandUIExtension>
  </CustomAction>
</Elements>

In this way, choosing to give the value 1 to the attribute (or a number lower than 10), we have decided that our custom button should be renderized as first in the "Manage" group of the "Documents" tab.

If you specify the value 11 (greater than 10 and lower than 20), our custom Ribbon will be positioned between the control of properties visualization and of editing.

This is because every Ribbon, already present in the bar, has a "Sequence" attribute value starting from 10 (for the first control on the left) and goes in tens for every single following control.
In our example, the controls present in the "Documents" tab of the "Manage" group have the following values for the "Sequence" field:

• View properties - 10
• Edit properties - 20

In order to visualize the correct values of each of the controls present in the Ribbon bar and in the specific group that we have chosen for the visualization of our customization to the SharePoint 2010 interface, we can sift through "CMDULXML" definition file in the path:

C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\GLOBAL\XML

Here you can see how these two controls are defined:

<Button Id="Ribbon.Documents.Manage.ViewProperties"
        Sequence="10"
        ...
        TemplateAlias="o1" />
<Button Id="Ribbon.Documents.Manage.EditProperties"
        Sequence="20"
        ...
        TemplateAlias="o1" />

If you are familiar with the custom actions in WSS 3.0/MOSS 2007, you have realized that the concept of sequence of action visualization is exactly the same, with the only difference that, in this specific case, this concept is applied to the Ribbon bar and not to the context menu in the SharePoint interface.

In the next post we will see which are the available templates to renderize a control in a group present in the SharePoint Ribbon 2010 Ribbon Bar.

In order to define a Ribbon within Visual Studio 2010, we have to create a "Empty Share Point Project" project type and add  a new "Empty element" element type.

This template type contains an empty xml file in which we can define our Ribbon. As I said, the link between a Ribbon and the custom actions we got to know in MOSS 2007 is very important, as we use the "CustomAction" tag for the definition of our first custom Ribbon.
Here is an example that helps us clarify this last concept:

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction Id="HelloWorld"
                Title="Hello World"
                Location="CommandUI.Ribbon"
                RegistrationType="List"
                RegistrationId="101">
    <CommandUIExtension>
      <CommandUIDefinitions>
        <CommandUIDefinition Location="Ribbon.Documents.Manage.Controls._children">
          <Button Id="Ribbon.HelloWorld"
                  TemplateAlias="o1"
                  Command="HelloWorld"
                  LabelText="Hello world"/>
        </CommandUIDefinition>
      </CommandUIDefinitions>
      <CommandUIHandlers>
        <CommandUIHandler Command="HelloWorld"
                          CommandAction="javascript:alert('Hello world from ribbon !");" />
      </CommandUIHandlers>
    </CommandUIExtension>
  </CustomAction>
</Elements>

As you can see, like the custom actions of Sharepoint previous version, we can choose to add our Ribbon in its related bar (through "Location" attribute), the contest in which our Ribbon will appear (through "RegistrationType" and "RegistrationId" attributes) and what's new compared to the old version. We can define which is going to be the extension to the interface represented by our Ribbon.
The extension is a single control or a series of controls (in our example a simple button) that are going to be visualized in Ribbon bar, in any of the available tabs and give custom actions to the final users.
In the following example, I have chosen my extension position in the "Documents" tab that is present in all SharePoint 2010 Document Library and in the "Manage" group. This choice is specified in the "Location" attribute of the "CommandUIDDefinition" element which represents my extension.

In general, to add our Ribbon in the different tabs and groups, you have to follow this simple rule:


Ribbon.[Tab].[Group].Controls._children

If you want the list of all the available tab and list identifiers, you can address to the documentation of this website:

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

Then, we can bind a specific command to every control (button, checkbox, etc)that is present in our extension to the SharePoint interface. This command will be one or more Java Script instructions we can define in the "CommandAction" attribute of the "CommandUIHandler" element, and this command is useful to define the Ribbon behavior.

I'm not going more into details because there is a vast of information that I will pick up in the next posts.
I remind you if you want a pre-made project template for the creation of a ribbon, you can find it in the Microsoft Code Gallery on this address:

http://code.msdn.microsoft.com/vsixforsp

However, while working I have encountered this error:

'b' is null or not an object 

This was triggered when I tried to retrieve properties of a selected item, soon after having executed the executeQueryAsync() method.
This method requires the specification of two delegates in order to call server side or to manage a possible error.
In my case, the script did not reach neither the first administrator nor the second one, but it was stopped during the callback.

Here you can see the WRONG code I wrote:

var selectedItem;

function initializeScript() { 
   var items = SP.ListOperation.Selection.getSelectedItems(); 
   var context = new SP.ClientContext.get_current();
   var currentList = context.get_web().get_lists().getById(SP.ListOperation.Selection.getSelectedList()); 
   selectedItem = currentList.getItemById(items[0].id); 
   context.load(selectedItem);
   context.executeQueryAsync(Function.createDelegate(this, this.onSuccessMethod), Function.createDelegate(this, this.onFailureMethod));
}

function onSuccessMethod(sender, args) { 
   alert('success');
}

function onFailureMethod(sender, args) {
   alert('fail');
}

Where is the error? The error is in the specification of the two delegates names.
In my script, I refer to onSuccessMethod and onFailureMethod methods with the keyword "this". This script would work if I extracted it from the "initializeScript" function, but being in the function, the keyword causes error in the callback because the two delegates cannot be found.
Deleting the keyword "this", the callback mechanism understands which are the methods that need to manage all the events. In this way, everything works again.

var selectedItem;

function initializeScript() { 
   var items = SP.ListOperation.Selection.getSelectedItems(); 
   var context = new SP.ClientContext.get_current();
   var currentList = context.get_web().get_lists().getById(SP.ListOperation.Selection.getSelectedList()); 
   selectedItem = currentList.getItemById(items[0].id); 
   context.load(selectedItem);
   //context.executeQueryAsync(Function.createDelegate(this, this.onSuccessMethod), Function.createDelegate(this, this.onFailureMethod));
   context.executeQueryAsync(Function.createDelegate(this, onSuccessMethod), Function.createDelegate(this, onFailureMethod));
}

function onSuccessMethod(sender, args) { 
   alert('success');
}

function onFailureMethod(sender, args) {
   alert('fail');
}

So, If you encounter this error, you should know that the two delegates names managing the callback should be written without any errors.

Error occurred in deployment step 'Recycle IIS Application Pool': The local SharePoint server is not available. Check that the server is running and connected to the SharePoint farm.

Such error does not allow any solution deployment (even if it is correctly compiled), because the logged on user in the SharePoint machine and in Visual Studio 2010 does not have the permissions in the following databases: 

• SharePoint_Config
• SharePoint_AdminContent_[guid]

If you try immediately to deploy the solution to a specific SharePoint 2010 web application, you will encounter this second error:

Error occurred in deployment step 'Recycle IIS Application Pool': Cannot connect to the SharePoint site: http://YOUR_SITE_NAME/. Make sure that this is a valid URL and the SharePoint site is running on the local computer. If you moved this project to a new computer or if the URL of the SharePoint site has changed since you created the project, update the Site URL property of the project.

We have already discussed this error, as it can also be triggered when you manually move a project from a Sharepoint machine to another one.

In this case, you need to have the permissions on the content database linked to the deploying web application.
It is commonly known that you create ad hoc virtual machines for development activities where the current user is an administrator on the machine, but it can also happen that you need to develop  a server that you do not directly administrate and that you access as a normal domain user.

When it comes to managing the fields (through SPField class)in SharePoint lists, what we would usually do is adding our SPField in the SPFieldCollection exposed to the "Fields" property of our content type:

SPContentType ct = web.ContentTypes["CONTENT TYPE NAME"];
SPField field = web.Fields.GetFieldByInternalName("COLUMN INTERNAL NAME");
ct.Fields.Add(field);
ct.Update(true);

Well, when you add an SPField in a content type and NOT in a list, this code IS WRONG!

In fact, if you try to execute it, you will get this error:

This functionality is unavailable for field collections not associated with a list

Error triggered by the execution of SPFieldCollection Add() method.
The correct method to add a SpField (our site column) to a content type is by using SPFieldLink class. Here is an example:

SPContentType ct = web.ContentTypes["CONTENT TYPE NAME"];
SPField field = web.Fields.GetFieldByInternalName("COLUMN INTERNAL NAME");
SPFieldLink link = new SPFieldLink(field);
ct.FieldLinks.Add(link);
ct.Update(true);

I hope it can be of help for you.

This white paper has been upgraded to SharePoint 2010 and Office 2010. You can find it in Microsoft download site.

This paper describes how the 2010, 2007 and 2003 versions of Office can interact with SharePoint 2010, which are the characteristics that are "lost" when utilizing a previous version to Office 2010 and the integration innovations of these two products.

As you know, every single SharePoint  version gives its best with the corresponding Office version.

SPS 2003 --> Office 2003
WSS 3.0/MOSS 2007 --> Office 2007
SharePoint 2010 --> Office 2010

Obviously, the basic characteristics functioning of this integration for the previous Office versions is guaranteed,  but for all the features of a new product there are some limitations. These limitations are not present in the corresponding Office version.

I suggest you to read the white paper where you can find a very good explanation.

In fact, using one of Share Point 2010 Server-side object model  class, you will encounter this error:

System.PlatformNotSupportedException
Microsoft SharePoint is not supported with version 4.0.30319.1 of the Microsoft .Net Runtime.

In other cases, it can happen that straight after having inserted the reference to SharePoint dll, everything seems to work properly (intellisense, etc). But, with its first compilation, you will find among the exceptions the following:

The type or namespace name 'SharePoint' does not exist in the namespace 'Microsoft' (are you missing an assembly reference?)

You cannot help that! Microsfot would say: "It's like that by design". You cannot do anything about it.
If we want to read or edit data in SharePoint from an application that has been written using .NET Framework 4.0, we have to use the exposed web services.

This vulnerability has full effect if the ASP.NET application has been configured through web.config to show the complete error.

Microsoft has made a script available to control automatically if your web.config files have this problem or not. You can find more information about this directly on  Scott Guthrie's website.

Beside, we should know that even SharePoint Foundation 2010 and SharePoint Server 2010 are affected by the same vulnerability and in SharePoint team blog you can find all the steps to correct it.

The steps are the following:

• Open the directory %CommonProgramFiles%\Microsoft Shared\Web Server Extensions\14\template\layouts.
  
  
• Create a new file, named "error2.aspx" and add this content:
  
  
  

  <%@ Page Language="C#" AutoEventWireup="true" %>
  <%@ Import Namespace="System.Security.Cryptography" %>
  <%@ Import Namespace="System.Threading" %>
  
  <script runat="server">
  
     void Page_Load() {
        byte[] delay = new byte[1];
        RandomNumberGenerator prng = new RNGCryptoServiceProvider();
        prng.GetBytes(delay);
        Thread.Sleep((int)delay[0]);
        IDisposable disposable = prng as IDisposable;
        if (disposable != null) { disposable.Dispose(); }
      }
  
  </script>
  <html>
  <head runat="server">
      <title>Error</title>
  </head>
  <body>
      <div>
          An error occurred while processing your request.
      </div>
  </body>
  </html>
  
  

• Open the directory %SystemDrive%\inetpub\wwwroot\wss\virtualdirectories
• For each subdirectory, follow these instructions:
  - edit the web.config file
  - retrieve customErrors section and change it as follows:
  
  

  <customErrors mode="On" redirectMode="ResponseRewrite" defaultRedirect="/_layouts/error2.aspx" />
  
  

• Save
• Execute IISRESET /NOFORCE

Please note that if you have changed the paths for your web applications on file system, you should also change the contained web.config.

If you don't want to do these operation manually, a WSP solution has been created for you: you need to install it and it is able to automatically adjust the vulnerability. You can find it on this address:
http://shojeeb.com/sharepoint/security-advisory-2416728-vulnerability-in-asp-net-and-sharepoint/

I recommend to check immediately all these cases!

If you want to learn more, here there is a list of useful links:
- Microsoft Security Advisory (2416728) (Vulnerability in ASP.NET Could Allow Information Disclosure)
- Security Advisory 2416728 Released (from Microsoft Security Response Center blog)
- Important: ASP.NET Security Vulnerability (from Scott Guthrie's blog)

Going into details, with a standard SharePoint installation, if you try to develop a workflow that uses a Listen activity containing a Delay activity that blocks the workflow for a set number of minutes, you will notice that the operation flow will stop forever. There will be no other way to make the workflow start again after the defined set number of minutes contained in Delay activity.

You can see in the picture below the workflow I used to test this behaviour:

Surfing on the net, we found that this problem has already existed in the old SharePoint version (WSS 3.0/MOSS 2007) and it has not been corrected.
But... there is a solution!

In order to make a workflow using a Delay activity work, you need to set a property on the site where you intend to run your workflow, through STSADM utility.
The property is "jabo-workflow", which should be valued with "Every 5 minutes between 0 and 59".

So, firstly we try to print the actual value of the property at issue:

stsadm -o getproperty -pn job-workflow -url http://siteurl

Then, we can set it:

stsadm -o setproperty -pn job-workflow -pv "Every 5 minutes between 0 and 59" -url http://siteurl

When you are done with all the operations through STSADM utility, you should remember that you need an IISRESET and a restart of SharePoint timer service.
In this way, the Timer service can control our workflows every 5 minutes and the Delay activity can work correctly.
Do not forget that in order to debug such workflow, it is necessary to attach to SharePoint OWSTimer process, otherwise our breakpoints will never be caught by the debugger.
Here you are the test solution I used to find the bug on my machine:

/media/7161/peppedotnet.delayactivitybug.zip

Hope this helps..

• Microsoft SharePoint Foundation 2010 Technical Library in Compiled Help format
  
  
• Microsoft SharePoint Server 2010 Technical Library in Compiled Help format

Hope this helps.