Google Chrome Offline installer

I always use Google Chrome for Web development, simply because it is way better than IE and offers a lot more tools and plug-ins. However, especially with SharePoint development, sometimes internet connectivity or proxy settings prevent you from acquiring Chrome using its web installer.

So the workaround is to download the official Standalone installer for Google Chrome (about 30MB)

SharePoint Development VM on Azure

If you are a working with SharePoint chances are you have an MSDN subscription and that is good news. You get a free USD200 worth of Windows Azure credit the first month you sign up for the trial and monthly credit according to your subscription level as per the following MSDN offer.

SharePoint 2013 demands hardware that many does not have on their local machine, yes? So naturally one would think about having a development VM that one can simply connect to, and for that you have come to the right place. Recently Microsoft have made available Visual Studio 2013 preview and with that, we see that we can now create a Visual Studio Ultimate 2013 Preview VM on Azure that apparently has SharePoint 2013 Trial on it.

If you have not already, sign up for Windows Azure Trial or activate your Windows Azure subscription from your MSDN subscription benefits.

If this is your first time with Windows Azure, you will need to configure a few basic things to be able to provision your VM properly. For this, Keith Mayer have an excellent blog entry that tells you what you need. Make sure you follow the instructions in his blog before creating your Development VM.

To create your VM, simply click on the New icon at the bottom of the Windows Azure management portal page then choose Compute > Virtual machine > From Gallery

 

Pick Visual Studio Ultimate 2013 Preview from the list and give it a name. I recommend choosing the Extra Large instance for this, although Large instance should be the minimum.

After the virtual machine is provisioned, simply go to Virtual Machines (from left menu), then pick your newly created VM and click on Connect on the bottom of the page to download an RDP file. Log in with the credentials you specified when creating the VM and have a good time.

 

 

Windows error 0x800F0906 while enabling IIS on Windows 8 RTM

While enabling IIS on Windows 8 RTM, it prompted me for retrieving files from Windows update, so I clicked it and kept getting stuck with windows error 0x800F0906.

The answer is simple, thanks to this Technet thread. You basically have to do the following:

1. Mount your Windows 8 image, take note of the drive letter

2. Open command prompt with administrator privileges and run the following command, replacing the <drive_letter> with your win 8 mounted image drive letter:

dism.exe /online /enable-feature /featurename:NetFX3 /Source:<drive_letter>:\sources\sxs

For example, if your drive letter is G, then the command above would look like:

dism.exe /online /enable-feature /featurename:NetFX3 /Source:G:\sources\sxs

This would first install .NET 3.5, after the operation has completed you can go back to control Panel > Programs > Turn windows features on or off and happily enable IIS.

Is Duet Enterprise Workflow the weakest link?

Duet Enterprise FP1, as great as it sounds, forms a glue between Microsoft and SAP. This blog post talks about how Duet Enterprise workflow may be the weakest link of features that comes with Duet Enterprise.

In a nutshell, workflow in Duet Enterprise is implemented as two-way communication between SharePoint and SAP Netweaver Gateway. End users in SharePoint see workflow tasks with action buttons, nothing different from the way they would approve or reject a sharepoint workflow task, because it is a sharepoint workflow task. All great and good, but under the covers, implementation is not as elegant as it look.

Workflows in Duet Enterprise are exposed per user-decision interaction step, more simply, this is the diamond shapes in a workflow sketch. At its plain configuration, each one of this interaction step is mapped as a subsite which hosts workflow task for this ‘type’ in SharePoint side. Yes, one step – one subsite.

Source: Plan for SAP workflow tasks for Duet Enterprise

This would mean that administrators and developers would need to maintain a list of user decision points which has been exposed. For SAP, it means at any time when any of these decision points change, they may need to reconfigure workflow pattern customizations and/or filters. Then all changes would need to be captured and documented clearly and handed over to SharePoint administrators and/or developers.

On the SharePoint side, Microsoft seems to be missing a few core operations that make this maintenance even harder. A workflow task type is configured in SharePoint by specifying task type and outcomes as they appear in SAP. For example, task of type CampaignApproval has been configured with outcomes Approve=001 and Reject=002.

When the scenario where additional outcome has been configured on SAP side (eg. Revision Required=003), this CampaignApproval subsite has to be reconfigured in SharePoint, which is fair. Question is, how?

1. Deleting the workflow subsite will not work, because then the workflow parent site still thinks that the workflow type is still configured and render the task not usable, and we won’t be able to create a task with the same name either.

2. Changing the outcomes in sharepoint designer and republish workflow might work, but really?

There are few options provided in the site actions menu, but it looks like when one is configured, there is no way of reversing it, modifying it and clean it up properly without destroying the whole site altogether.

I am puzzled indeed. May look into doing it programmatically next, but certainly Microsoft, I wonder if this has been thought through?

Must have tools for BCS development

Creating a BCS model and external list with SharePoint Designer 2010 makes things a breeze: just few clicks and we are done, but this typically does not work in development environment. Why? Simply because we need to package this up, and to package this up, we need to be able to extract the BCS artifacts into a Visual Studio solution.

Well, lucky that there are tools for that, check out this blog post by Russell Palmer. These tools are:

1. BCS Artifact generator
2. BCS Solution Packaging tool

Writing to event log and ULS in Sharepoint 2010

No logging means no visibility

Logging is a prime and most basic feature that any software need to have, and there are many ways to implement logging. In this post, I will illustrate a way to implement logging to windows application event log and/or the ULS when developing custom sharepoint 2010 solutions.

The assumption here is that the solution will be deployed as a farm solution.

A log entry can have various attributes or properties, but most likely we would want to use the following attributes:

1. Source
2. Severity
3. Correlation ID
4. Message

When writing to the application event log, it is advisable to create the event sources beforehand. Identify your event sources that you want to use and create these sources, one way is to use the script in this post.

Typically I would advise against logging to the application event log on production systems, for sharepoint solutions, use the ULS, but alas, reading ULS every time things goes wrong can be time consuming, yeah we have great tools like the ULS viewer, but it is still not as easy to read as the event viewer. Therefore, I typically write my logs to the application event log on my DEV machine.

For this, I need a switch that enables me to direct all my log entries to the application event log, the ULS, or both (or other sources). Astute .NET developers would probably think of Enterprise Library when it comes to this scenario. Yes EntLib is collection of great components, but if all we want is a simple logger that writes to two sources, we might as well write common logic and be done in 30 minutes or less rather than trying to bake in and configure EntLib, think about the web.config changes you have to do with EntLib.

For me, my switch is simply a couple of constants in a static class:

namespace Department.Solution.Common
{
    public static class Constants
    {
        public static class AppSettings
        {
            public const bool LOG_TRACE = true;
            public const bool LOG_EVENTLOG = true;
        }
    }
}

We should also ideally put our event sources in constants:

namespace Department.Solution.Common
{
    public static class Constants
    {
        public static class LogSource
        {
            public const string LOGSRC_COMMON = "ProductXYZ Common";
            public const string LOGSRC_WEBPART = "ProductXYZ WebParts";
        }
    }
}

Then I have these methods in my common logger class to write to event log and/or the ULS depending on those flags:

private static void WriteToTrace(Guid correlationGuid, string source, string message, EventLogEntryType entry)
{
    if (!Constants.AppSettings.LOG_TRACE) return;
    var diagSvc = SPDiagnosticsService.Local;
    var traceSeverity = TraceSeverity.Unexpected;
    var evtSeverity = EventSeverity.Error;

    switch (entry)
    {
        case EventLogEntryType.Information:
        case EventLogEntryType.FailureAudit:
        case EventLogEntryType.SuccessAudit:
            traceSeverity = TraceSeverity.Verbose;
            evtSeverity = EventSeverity.Information;
            break;
        case EventLogEntryType.Warning:
            traceSeverity = TraceSeverity.Medium;
            evtSeverity = EventSeverity.Warning;
            break;
        default:
            traceSeverity = TraceSeverity.Unexpected;
            evtSeverity = EventSeverity.Error;
            break;
    }
    SPSecurity.RunWithElevatedPrivileges(() =>
        diagSvc.WriteTrace(0,
        new SPDiagnosticsCategory(source, traceSeverity, evtSeverity), traceSeverity,
        "Correlation Guid {0}: {1}", new object[] { correlationGuid.ToString("B"), message })
    );
}

private static void WriteEventLogEntry(Guid correlationGuid, string source, string message, EventLogEntryType entry)
{
    if (!Constants.AppSettings.LOG_EVENTLOG) return;
    SPSecurity.RunWithElevatedPrivileges(() =>
            {
                var appLog = new EventLog { Source = source };
                appLog.WriteEntry(string.Format("Correlation Guid {0}{1}{2}", correlationGuid.ToString("B"), System.Environment.NewLine, message), entry);
            });
}

Simply put wrappers and overrides around these two methods, for example:

public static string LogError(string source, string format, params object[] args)
{
    return LogError(source, string.Format(format, args));
}
public static string LogError(string source, string message)
{
    Guid correlationGuid = Guid.NewGuid();
    WriteEventLogEntry(correlationGuid, source, message, EventLogEntryType.Error);
    WriteToTrace(correlationGuid, source, message, EventLogEntryType.Error);
    return correlationGuid.ToString();
}

Then whenever you want to log anything, simply call the public method and pass in your source string in one line (for example, if the logger is implemented within your custom LoggerInstance class):

LoggerInstance.LogError(Constants.LogSource.LOGSRC_WEBPART, "Woops, web part {0} errored out!", webPart.Title);

Logging would be a breeze if you have this helper class, because it simply provide a layer of abstraction.

Granting replicating directory changes permission to profile synchronization account

In order to allow Sharepoint 2010 User Profile Service (UPS) to do a profile synchronization to Active Directory, a service account needs to be provisioned and correct level of access needs to be granted for this account. This technet article describes the access needed for this service account. For consistency, we will be referring to this account as the profile synchronization account (PFS account). Refer to this wiki entry for more information about the user profile synchronization service.

This article tells us the steps in regards to how to grant permissions to this PFS account.

Here are the screenshot of the steps to grant read access and replicate directory access to PFS account, with a sample scenario of using a newly created account called SRV-PFS:

A. Granting access to the PFS account so it can read enumerate and read user properties
Note: The steps within this particular section needs to be reviewed.

1. In ACL Editor, right click on the domain object, and choose Delegate Control
   
2. Add the PFS account, and then click Next
   
3. In the next screen, check “Read all user information” and click next, then click finish
   

B. Granting access to the PFS account to query for changes within the domain

1. Within the ACL Editor, click on the View menu, then enable Advanced features. This would bring up additional options available in the ACL Editor when the screen refreshes
   
2. Right click on the domain object, and choose Properties
   
3. Click on the security tab and locate the PSF account. in the permissions section, check to allow the Replicating Directory Changes. Click OK.
   

Sharepoint 2010 user profile synchronization service

In this post, I am trying to bring together information from various sources in relation to the User profile Synchronization Service in Sharepoint 2010 for easy reference and starting point. Some parts of this post are copies from the articles that I refer to, all of which are publicly available information.

Profile synchronization overview
The User Profile Synchronization service allows you to create user profiles by importing information from other systems that are used in your organization. This service is the core of the synchronization architecture in SharePoint Server 2010. When you start the User Profile Synchronization service on the synchronization server, SharePoint Server 2010 provisions a version of Microsoft Forefront Identity Manager (FIM) to participate in synchronization.
You can create new profiles and import profile properties by synchronizing with a directory service. When you synchronize with a directory service, SharePoint Server 2010 does the following:

• Creates a user profile for each new user in the directory service containers that are being synchronized, and fills in the properties of each new profile with data from the directory service.
• Deletes the profile of any user that was removed from the directory service.
• For properties that are being imported, updates the property in the SharePoint user profile if the corresponding value in the directory service has changed.

For more information, please refer to this article.

Plan for profile synchronization
Note: For more information and complete planning worksheet, please refer to this article.

Each property in a user’s profile can come from an external system. There are two types of external systems: directory services and business systems. The phrase business system is used to mean an external system that is not a directory service. SAP, Siebel, SQL Server, and custom applications are all examples of business systems. This wiki entry assumes and focus on properties that come from directory services alone.

Each user that you want to have a profile in SharePoint Server must have an identity in a directory service. If users are not represented in a directory service, you cannot synchronize user profiles.

To indicate that a user profile property comes from an external system, you map the property to a specific attribute of the external system. Certain user profile properties are mapped by default. For a list of the default mappings for each type of directory service, see Default user profile property mappings (SharePoint Server 2010). When you synchronize profile information, in addition to importing profile properties from external systems, you can also write data back to a directory service. To indicate that SharePoint Server should export (ie, write back to directory services) a user profile property, you map the property, and set the direction of the mapping to Export. Note that all mapping direction are set to Import by default.

Under the hood: How user profile synchronization works in SharePoint 2010
This MSDN blog post describes the concepts and how user profile synchronizatin happens within Forefront Identity Manager 2010.

Account permissions for Active Directory Domain Services (AD DS)
In order to allow Sharepoint 2010 User Profile Service (UPS) to do a profile synchronization to Active Directory, a service account needs to be provisioned and correct level of access needs to be granted for this account. This technet article describes the access needed for this service account. For consistency, we will be referring to this account as the profile synchronization account (PFS account).

An extract from the technet article:

• It must have Replicate Directory Changes permission on the domain that you will synchronize with. For more information, see the Grant Replicate Directory Changes permission on a domain section of the “Grant Active Directory Domain Services permissions for profile synchronization” procedural reference article.
  Note: The Replicate Directory Changes permission allows an account to query for the changes in the directory. This permission does not allow an account to make any changes in the directory.
• If the domain controller is running Windows Server 2003, the synchronization account must be a member of the Pre-Windows 2000 Compatible Access built-in group. For more information, see the Add an account to the Pre-Windows 2000 Compatible Access group section of the “Grant Active Directory Domain Services permissions for profile synchronization” procedural reference article.
• If the NetBIOS name of the domain differs from the fully qualified domain name, the synchronization account must have Replicate Directory Changes permission on the cn=configuration container. For example, if the NetBIOS domain name is contoso and the fully qualified domain name is contoso-corp.com, you must grant Replicate Directory Changes permission on the cn=configuration container. For more information, see the Grant Replicate Directory Changes permission on the cn=configuration container section of the “Grant Active Directory Domain Services permissions for profile synchronization” procedural reference article.
• If you will export property values from SharePoint Server to AD DS, the synchronization account must have Create Child Objects (this object and all descendants) and Write All Properties (this object and all descendants) permissions on the organizational unit (OU) that you are synchronizing with. For more information, see the Grant Create Child Objects and Write permission section of the “Grant Active Directory Domain Services permissions for profile synchronization” procedural reference article.

This is the official documentation on MSDN in regards to the replicate directory changes extended right on AD schema.

According to the MSDN blog post above, the profile synchronization service leverages FIM to query for attribute changes within the directory service (in this case, AD DS). This KB article provides additional information about the rights required to poll these changes.

There are official articles by Microsoft and few sources such as this KB article, excellent blog post on harbar.net and this MSDN blog post maintained by microsoft employee which states that replcate directory changes does not mean write access to the directory. To further prove this, Active Directory auditing exercise can be conducted. Here is a step-by-step guide on how to perform this.

First class resource
This official article on how to configure profile synchronization service is a first-class resource provided by Microsoft.

Viewing XML data on Content by Query Web Part (CQWP)

How many times have you been tasked to customize a Content by Query Web Part in SharePoint? In my case, this task often involves customizing the XSL used by the web part. The pain is, without knowing the data we are working with, we are basically trying to aim our arrows in darkness.

If we can see the data (ie, XML) that we are dealing with, then it would become much easier to write an XSL that achieves what we want. This post aims to give you a way to dump out the XML content of the content query web part to allow you to visualize what you are working with.

To do this, first step is to download a copy of the default xsl that all CQWP uses, this usually exist in Style Library/XSL Style Sheets subfolder and is called ContentQueryMain.xsl
Download this to your local folder now, and rename it as something else, eg. ContentQueryDump.xsl

Now open the ContentQueryDump.xsl file in your favourite XSL editor or text editor, and locate the template root node

Change the inner XML of this node to dump out the xml content by surrounding it in TEXTAREA tag

<xsl:template match="/">
    <TEXTAREA style="width:200px;" rows="10">
        <xsl:copy-of select="*"/>
    </TEXTAREA>
</xsl:template>

Save this file, and upload it to the Style Library within the XSL Style Sheets folder.

Now picture this: I have a custom list in my site that contains 2 custom columns, and I want a Content by Query Web Part to display data on this list according to the XSL that I specify.

I set up a content by query web part on my home page, set the query scope to my custom list, and this is what I get:

Let us take this web part and dump its XML data on screen. Export the web part from your page, and save it locally:

Crack it open in your favourite XML Editor or text editor, then locate the property node with name attribute of MainXslLink. Put the reference to the xsl file you uploaded earlier, as follows:

<property name="MainXslLink" type="string">
    /Style Library/XSL Style Sheets/ContentQueryDump.xsl
</property>

Save this .webpart file, then import and add this web part to the page

The result is as follows:

And voila! You have your content result XML, this is what your XSL will be looking at. You can see all the attributes, which makes things much easier from here onwards.

<dsQueryResponse>
  <Rows>
    <Row Title="Item 3" FileRef="/Lists/MyList/3_.000" Author="George Lucas" Editor="George Lucas" FSObjType="0" PermMask="0x400000300c231061" ProgId="" File_x005F_x0020_Type="" File_x005F_x0020_Size="" PublishingRollupImage="" Comments="" ID="3" Modified="2011-11-02 11:33:02" Created="2011-11-02 11:33:02" _Level="1" WebId="bf499d62-67d5-46af-9746-acd74885fa45" ListId="19877173-9e7a-4543-962b-c4dc4261aceb" _x007B_94f89715_x002D_e097_x002D_4e8b_x002D_ba79_x002D_ea02aa8b7adb_x007D_="Lists/MyList/3_.000" PubDate="Wed, 02 Nov 2011 00:33:02 GMT" FileExtension="" FileSize="" DocumentIconImageUrl="/_layouts/IMAGES/icgen.gif" LinkUrl="http://localhost/Lists/MyList/3_.000" Style="Default" GroupStyle="DefaultHeader" __begincolumn="True" __begingroup="False"></Row>
    <Row Title="Item 2" FileRef="/Lists/MyList/2_.000" Author="George Lucas" Editor="George Lucas" FSObjType="0" PermMask="0x400000300c231061" ProgId="" File_x005F_x0020_Type="" File_x005F_x0020_Size="" PublishingRollupImage="" Comments="" ID="2" Modified="2011-11-02 11:32:47" Created="2011-11-02 11:32:47" _Level="1" WebId="bf499d62-67d5-46af-9746-acd74885fa45" ListId="19877173-9e7a-4543-962b-c4dc4261aceb" _x007B_94f89715_x002D_e097_x002D_4e8b_x002D_ba79_x002D_ea02aa8b7adb_x007D_="Lists/MyList/2_.000" PubDate="Wed, 02 Nov 2011 00:32:47 GMT" FileExtension="" FileSize="" DocumentIconImageUrl="/_layouts/IMAGES/icgen.gif" LinkUrl="http://localhost/Lists/MyList/2_.000" Style="Default" GroupStyle="DefaultHeader" __begincolumn="False" __begingroup="False"></Row>
    <Row Title="Item 1" FileRef="/Lists/MyList/1_.000" Author="George Lucas" Editor="George Lucas" FSObjType="0" PermMask="0x400000300c231061" ProgId="" File_x005F_x0020_Type="" File_x005F_x0020_Size="" PublishingRollupImage="" Comments="" ID="1" Modified="2011-11-02 11:32:30" Created="2011-11-02 11:32:30" _Level="1" WebId="bf499d62-67d5-46af-9746-acd74885fa45" ListId="19877173-9e7a-4543-962b-c4dc4261aceb" _x007B_94f89715_x002D_e097_x002D_4e8b_x002D_ba79_x002D_ea02aa8b7adb_x007D_="Lists/MyList/1_.000" PubDate="Wed, 02 Nov 2011 00:32:30 GMT" FileExtension="" FileSize="" DocumentIconImageUrl="/_layouts/IMAGES/icgen.gif" LinkUrl="http://localhost/Lists/MyList/1_.000" Style="Default" GroupStyle="DefaultHeader" __begincolumn="False" __begingroup="False"></Row>
  </Rows>
</dsQueryResponse>

Using BackgroundWorker to get around non-responsive UI

Think about this scenario: you are developing windows forms application, there is a button, when clicked, the whole application stopped responding, because it is doing something heavy in the background. Sounds familiar? This is most typical when user demands the application to show status message when a process is running, or to show progress status when a process is running, while keeping the UI responsive.

As we all know it, the easiest way of implementing logic behind a button is to use the OnClick event handler, but if we expect a process to take more than a second, then we might want to rethink whether or not it should be executed on the UI thread. Yes, thread – and first reaction I often get is “oh no! that can of worms!”. OK let me give you a mentality standpoint here, developers who run away from learning core concepts and new technologies should just get another job and click on get off my lawn.

If you are still here, congratulations, you are about to find out a very simple way of implementing threading in WinForm. For the purpose of this, I will be using a very simple Winform app. This is not the evil Application.DoEvents, which I stay away from.

When the Go button is clicked, it will simulate a time-consuming routine by counting from 1 to 10, pausing every second in between counts. As it counts, it will report its progress on the progress bar.
When the Add button is clicked, it simply increments the value next to it.

What we notice is that when the go button is clicked, clicking on the Add button will not increment the value, which shows that the UI is not responsive.

What we want is a responsive UI, so when the Go button is clicked, it does not affect other parts of the form. So let’s get our hands dirty by first creating this simple app in few simple steps:

1. Open Visual Studio, create a Winform app
2. Put a button, name it btnAdd, double click on it to allow Visual Studio to generate a click event handler method for you
3. Put a label next to btnAdd, name it lblValue
4. Put a button, name it btnGo, double click on it to allow Visual Studio to generate a click event handler method for you
5. Put a progress bar, name it progressBar, set the maximum to 10
6. Go to source view and paste in the following code

private void btnAdd_Click(object sender, EventArgs e)
{
    lblValue.Text = (int.Parse(lblValue.Text) + 1).ToString();
}
private void btnGo_Click(object sender, EventArgs e)
{
    btnGo.Enabled = false;
    TimeConsuming(progressBar.Maximum);
    btnGo.Enabled = true;
}

private void TimeConsuming(int maxValue)
{
    for (int i = 1; i     {
        progressBar.Value = (int) ((i / (double)maxValue) * progressBar.Maximum);
        Thread.Sleep(new TimeSpan(0, 0, 1));
    }
}

And Voila! we have just created an unresponsive app 🙂

Now let us enhance this. Drag a (BackgroundWorker) component from the toolbox onto the form, name it bgw.
Pay attention to the properties of the bsw control. This is what we will use to execute our time-consuming code. Because I want to report back to the UI thread during processing, I need to set the bgw.WorkerReportsProgress property to true.
Now switch to the events for the bsw component. Double click on each of the event (DoWork, ProgressChanged and RunWorkerCompleted) to let Visual Studio generate the event handler methods for you. We will implement these methods later, but for now, here is a brief overview:

private void bgw_DoWork(object sender, DoWorkEventArgs e)
{
    //your time consuming process goes here
}

private void bgw_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    //thigs which should happen when the worker thread reports a progress
}

private void bgw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    //things which should happen when the worker thread completes
}

Let us refactor the code that handles the button click event. We will make it run a worker thread instead of calling the time consuming routine, and make the DoWork method call the time consuming routine. Also remember to take out the line that enables the button.

private void btnGo_Click(object sender, EventArgs e)
{
    btnGo.Enabled = false;
    if (!bgw.IsBusy)
        bgw.RunWorkerAsync(progressBar.Maximum);
}

private void bgw_DoWork(object sender, DoWorkEventArgs e)
{
    TimeConsuming(bgw, (int)e.Argument);
}

Because the TimeConsuming routine now does not report progress directly to the UI, we will have to modify it a little bit, making it to report its progress to the worker thread instead:

private void TimeConsuming(BackgroundWorker worker, int maxValue)
{
    for (int i = 1; i     {
        worker.ReportProgress((int)((i / (double)maxValue) * 100));
        Thread.Sleep(new TimeSpan(0, 0, 1));
    }
}

The rest is simple: Whenever the progress changed is reported, we simply update the value of progress bar based on percentage reported and when the worker thread completes, we enable the go button:

private void bgw_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    progressBar.Value = (int)((e.ProgressPercentage / 100.0) * progressBar.Maximum);
}

private void bgw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    btnGo.Enabled = true;
}

Here is the complete source code of the form, the original TimeConsuming method have been renamed to TimeConsumingOnUIThread for the ease of testing in case we need to switch back to the old scenario:

public partial class Main : Form
{
    public Main()
    {
        InitializeComponent();
    }

    private void btnAdd_Click(object sender, EventArgs e)
    {
        lblValue.Text = (int.Parse(lblValue.Text) + 1).ToString();
    }

    private void btnGo_Click(object sender, EventArgs e)
    {
        btnGo.Enabled = false;
        if (!bgw.IsBusy)
            bgw.RunWorkerAsync(progressBar.Maximum);
        //TimeConsumingOnUIThread(progressBar.Maximum);
        btnGo.Enabled = true;
    }

    private void TimeConsumingOnUIThread(int maxValue)
    {
        for (int i = 1; i         {
            progressBar.Value = (int)((i / (double)maxValue) * progressBar.Maximum);
            Thread.Sleep(new TimeSpan(0, 0, 1));
        }
    }

    private void TimeConsuming(BackgroundWorker worker, int maxValue)
    {
        for (int i = 1; i         {
            worker.ReportProgress((int)((i / (double)maxValue) * 100));
            Thread.Sleep(new TimeSpan(0, 0, 1));
        }
    }

    private void bgw_DoWork(object sender, DoWorkEventArgs e)
    {
        TimeConsuming(bgw, (int)e.Argument);
    }

    private void bgw_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        progressBar.Value = (int)((e.ProgressPercentage / 100.0) * progressBar.Maximum);
    }

    private void bgw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        btnGo.Enabled = true;
    }

}