For those of you who aren’t familiar with LINQ, I’ll try to sum it up in a few sentences. LINQ stands for language-integrated query. It provides .Net developers with a new syntax which makes performing set based operations on a collection, or multiple collections easier. For example, if we have an unordered list of integers which we need to sort, in the past we would have to do something similar to this:

public void RunSort()
{
  var integerList = new List<int> { 5, 63, 23, 1, 0, 91 };
  QuickSort(0, integerList.Count, integerList);
}

public void QuickSort(int left, int right, IList<int> integerList)
{
  var pivot = integerList[left];

  while (left < right)
  {
    while ((integerList[right] >= pivot) && (left < right))
    {
      right--;
    }

    if (left != right)
    {
      integerList[left] = integerList[right];
      left++;
    }

    while ((integerList[left] <= pivot) && (left < right))
    {
      left++;
    }

    if (left == right) continue;
    integerList[right] = integerList[left];
    right--;
  }

  integerList[left] = pivot;
  pivot = left;

  if (left < pivot)
  {
    QuickSort(left, pivot - 1, integerList);
  }

  if (right > pivot)
  {
    QuickSort(pivot + 1, right, integerList);
  }
}

The above example works fine, however as a developer we needed to make the decision of what sorting algorithm to use, and then go ahead and implement the sorting function. This wastes time and can sometimes be error prone. LINQ can solve this problem, and many other set based problems like it quickly and efficiently. Here is an example of the first example re-written to make use of LINQ:

public void RunSort()
{
    var integerList = new List { 5, 63, 23, 1, 0, 91 };
    var sortedIntegerList = from integer in integerList
                            orderby integer ascending
                            select integer;
}

LINQ takes care of the sorting here for us and provides a nice, easy to read syntax. When using LINQ, we can worry less about the details of working with data sets, and focus more about the business rules we are implementing. PLINQ takes LINQ a step further and extends this powerful set based functionality to take advantage of multi-core CPU’s. Here is an example of the second example converted to use PLINQ:

public void RunSort()
{
    var integerList = new List { 5, 63, 23, 1, 0, 91 };
    var sortedIntegerList = from integer in integerList.AsParallel()
                            orderby integer ascending
                            select integer;
}

When comparing the above example with the second example, only a couple of things have changed. One is obvious just by looking at the code. We are now calling the extension method .AsParallel on the list of integers. This tells PLINQ that it is OK to go ahead and try to parallelize the LINQ query. The second is a little more subtle. Instead of the LINQ query returning an IEnumerable type, it is returning an IParallelEnumerable. Luckily, IParallelEnumerable derives from IEnumerable, so existing code should work fine with this change.

This is of course a very basic example of how LINQ and PLINQ differ. But hopefully I’ve sparked some interest.

-Jon

1. Create your Windows Service project and Windows Service.
2. Navigate to the designer for your Windows Service. Under the properties for your service you should see (Name) and ServiceName. Fill in both of these properties with your desired names. You will need to reference these later.
3. In the designer for your Windows Service, right-click and click Add Installer. You should now have a ProjectInstaller.cs file, along with a designer file for the installer.
4. Navigate to the designer for your new project installer. You should see two components, a Service Process Installer and a Service Installer. Under the Service Installer properties, you will need to add a DisplayName, and provide the ServiceName of the service you will be installing. The ServiceName must match the (Name) property of the service.
5. Build your Windows Service project. Now in the same solution, add a new Setup Project. This will provide the Wizard interface for the installation process.
6. After adding the project, you need to add the primary output of your Windows Service to the Setup Project. Do this by right-clicking on the Setup Project -> Add -> Project Output. Select your Windows Service project from the drop down, highlight Primary Output and click OK.
7. Up to this point the installer will install the correct files, but it doesn’t know what to do with the files. We can add custom actions to do the service installation work. Right-click on the Setup Project -> View -> Custom Actions. For a Windows Service we need to add actions for Install, Rollback, and Uninstall. Right-click each of these and click Add Action. Double click Application Folder and select the Primary Output from your Windows Service project.
8. You can now build your Setup Project. The output of this build will be two setup files which are used to install your new Windows Service.

-Jon

For our WCF service, we’re using the wsHttpBinding. This binding provides much of the same functionality as a basic web service, with added service features such as reliable messaging, WS-Addressing, and WS-Security. Since this post is mainly on setting up security for a WCF service, I won’t go into too many details of the other features of wsHttpBinding.

After creating the WCF service, open up the web.config file for the WCF Service Application project. After scrolling down for a long time, you should come across a System.serviceModel tag. This tag contains all of the configuration settings for the WCF services contained in this project. Here’s what you should be looking at now:

<system.serviceModel>

<services>

<service name=“WcfService1.Service1“ behaviorConfiguration=“WcfService1.Service1Behavior“>

<!– Service Endpoints –>

<endpoint address=“” binding=“wsHttpBinding“ contract=“WcfService1.IService1“>

<!–

Upon deployment, the following identity element should be removed or replaced to reflect the

identity under which the deployed service runs. If removed, WCF will infer an appropriate identity

automatically.

–>

<identity>

<dns value=“localhost“/>

</identity>

</endpoint>

<endpoint address=“mex“ binding=“mexHttpBinding“ contract=“IMetadataExchange“/>

</service>

</services>

<behaviors>

<serviceBehaviors>

<behavior name=“WcfService1.Service1Behavior“>

<!– To avoid disclosing metadata information, set the value below to false and remove the metadata endpoint above before deployment –>

<serviceMetadata httpGetEnabled=“true“/>

<!– To receive exception details in faults for debugging purposes, set the value below to true. Set to false before deployment to avoid disclosing exception information –>

<serviceDebug includeExceptionDetailInFaults=“false“/>

</behavior>

</serviceBehaviors>

</behaviors>

</system.serviceModel>

By default, a WCF service will use the wsHttpBinding, this is what we want to continue using. We need to make a few modifications to this web.config in order to provide the additional functionality we want. First take a look at the serviceBehaviors section. By default we already have a behavior for our Service1. Here is an example of a modified behavior:

<behavior name=“WcfService1.Service1Behavior“>

<serviceCredentials>

<serviceCertificate findValue=“CN=ServiceCertificate“ storeLocation=“LocalMachine“

storeName=“My“ x509FindType=“FindBySubjectDistinguishedName“ />

<userNameAuthentication userNamePasswordValidationMode=“Windows“/>

</serviceCredentials>

</behavior>

There is a lot of info in this behavior pertaining to security. The first bit describes the x509 certificate we would like to use that is already installed on our machine. We can create our own test x509 certificate for development purposes if need be. We can also describe the user authentication mode, in this case we are just using Windows authentication.

The next section extends the wsHttpBinding to provide some additional features not turned on be default:

<bindings>

<wsHttpBinding>

<binding name=“wsHttpBindingSettings“ messageEncoding=“Text“>

<security mode=“Message“>

<message clientCredentialType=“UserName“ />

</security>

</binding>

</wsHttpBinding>

</bindings>

Here we can describe the transport type, as well as the client credential type. This is fairly simple, we are using Message based transport with UserName security.

Finally we need to tie these sections together with Service1:

<service behaviorConfiguration=“WcfService1.Service1Behavior“ name=“WcfService1.Service1Behavior“>

<endpoint address=“” binding=“wsHttpBinding“ bindingConfiguration=“wsHttpBindingSettings“

contract=“WcfService1.IService1“ listenUriMode=“Explicit“>

<identity>

<dns value=“ServiceCertficate“ />

</identity>

</endpoint>

<endpoint address=“mex“ binding=“mexHttpBinding“ contract=“IMetadataExchange“ />

</service>

The only changes we made here are in the bindingConfiguration property and the dns value. The bindingConfiguration allows you to bind our binding configuration to this service, and the dns value should match the x509 certificate name.

I’ll be posting some more on this topic, including writing your own custom username validation code for WCF, and creating your own test x509 certificate. Hope this helps!

-Jon

For this example we’ll be serializing an XML file and transforming it using .Net’s XSLT processor. The process is very simple, and requires very little code.

1. Load the XML File into memory using the XmlReader class.

   var reader = XmlReader.Create(xmlFileLocation);

2. Create a StreamWriter object which will be used to write the transformation to a file.

   var textWriter = new StreamWriter(outputFileLocation);

3. Create an XslCompiledTransform object which will be used to transform the XML file using the specified XSLT file.

   var xslTransform = new XslCompiledTransform();

4. Transform the XML and write to a file using the StreamWriter.

   xslTransform.Load(xsltFileLocation);
   xslTransform.Transform(reader, null, textWriter);

Hope this helps.

-Jon