SharePoint Dev Blog

We want your ideas on migrating SharePoint solutions to apps for SharePoint

Keenan Newton — Thu, 23 May 2013 13:00:00 GMT

Have you heard? The new Reimagine SharePoint Development site is now live. This site contains articles, videos, and blog posts that focus on migrating SharePoint solutions to apps. We will be adding content to the site in the months ahead, so if there is something you would like to know more about, just let us know in the comments below or in this MSDN forum thread. For more information, see the Reimagine SharePoint Development announcement post.

Several questions came up during the launch webcast. We are planning a series of blog posts that should get everybody on the same page. Stay tuned!

Reimagine SharePoint Development

Keenan Newton — Wed, 08 May 2013 13:00:00 GMT

Join us May 20, 2013, for a webcast as we kick off a new site centered on migrating SharePoint solutions to apps. We will discuss the history of SharePoint customizations and where the SharePoint development platform is going. We will also highlight the benefits of the Cloud App Model and answer any questions on migrating SharePoint solutions to apps that you may have. I will be the host, and we are welcoming Robert Lefferts, Partner Director of Apps Program Management, as a special guest speaker.

The Reimagine SharePoint Development site (http://reimaginespdev.com) officially launches on May 20. We created it specifically for current SharePoint developers who are interested in understanding more about apps, and who want to learn about the proven practices of architecting and developing apps and migrating SharePoint solutions to apps.

Our goal with this site is to help you understand when it’s best to develop an app, and when it’s not; what the proven practices are for creating apps for SharePoint; and when an existing SharePoint solution is a candidate for migration to an app, as well as how to do it. We plan to include MSDN articles and white papers, video content, blog posts from some of our MVPs about developing apps, migrating solutions to apps, and more.

As a SharePoint developer, you should make http://www.reimaginespdev.com your first stop when planning and developing your next app or migrating your existing SharePoint solution.

We want to know what you think! Please leave us comments and share your thoughts and ideas.

Related resources:

Keenan Newton is a senior product marketing manager on the SharePoint team at Microsoft.

Optimizing SharePoint 2013 websites for mobile devices

SharePoint Developer Team — Tue, 07 May 2013 13:00:00 GMT

The mobile market is growing continuously, and in the near future, more mobile devices than desktop computers will be used to surf the web. To ensure a user-friendly experience, we must optimize Internet websites for presenting content across the different devices. SharePoint 2013 offers a number of options for optimizing public-facing websites for mobile devices. Depending on your requirements, you can choose one or a combination of several options.

In the last few years, the use of mobile devices to surf the web has increased significantly. According to some researchers, by 2015, more mobile devices than desktop computers will be used to access the web. Mobile devices come in different sizes and capabilities. And since the desktop experience just isn’t good for mobile users, what are the options for improving the experience of mobile users on your website?

Improving the user experience across devices

Optimizing the user experience of a website across different devices is a complex process. Not only do you have to take into account the screen resolution of each device, but you also need to consider its capabilities (such as touch or pointer-based) and device size (1024x768 might be clearly readable for everyone on a 20-inch monitor but might result in a very bad experience on a 5-inch screen).

When you are planning improvements to the user experience of your website on mobile devices, there is no silver bullet approach. You have to research who your users are, which devices they use, and what they are trying to achieve on your website. You also have to have clear goals for what purpose your website serves and how it should guide your visitors in the process of becoming your customers.

You have several options for improving the user experience of a public-facing website. Which one you choose depends on the different factors that apply to your scenario.

Mobile websites

In the past, when the web technology wasn’t as sophisticated as it is nowadays, it was a common practice to provide mobile users with a separate mobile website to optimize their experience. Being hosted on a separated URL, such as http://m.contoso.com, the mobile site would have a user experience optimized for mobile devices. In some scenarios, organizations would even go a step further and optimize the copy on the mobile website. When a user navigated to the website using a mobile device, the main website would detect the use of a mobile device and automatically redirect the visitor to the mobile version.

It’s not that hard to imagine that building and maintaining two different sites is not only costly but also time consuming. Every update has to be done separately. Even then, with the diversity of today’s mobile devices, the questions remain whether a single mobile website would suffice and whether you wouldn’t need more websites to reach the whole spectrum of your customers.

Being able to reuse the content across the main and mobile websites simplifies the content management process. But the need to separately maintain the functionality of both websites makes it hard to justify this approach in most scenarios.

Mobile apps

One of the recent developments of the mobile market is the increased popularity of companion apps. By using the native capabilities of specific devices, you can build rich mobile apps to support different use cases. There is no better user experience on a mobile device than the native one offered by the device itself. For more information, see Build mobile apps for SharePoint 2013.

But is it realistic to build separate apps for all the different scenarios and for all the different mobile devices used to navigate the website? Although mobile apps are of great value for supporting specific use cases, there is still the need to access the information on the website from a mobile device in a user-friendly way.

Responsive web design

Instead of building separate mobile sites for mobile devices, what if we could have one website that automatically adapts itself to the particular device?

Responsive web design is a concept based on the ability to separate the design from the content on a website. Using the CSS media queries capability implemented in all modern browsers, and based on the screen dimensions of the specific device, you can load different style sheets to ensure that the website is presented in a user-friendly manner. And because CSS has its limitations, you can use JavaScript to further optimize the interface and interaction of a website on mobile devices. For more information, see Implementing your responsive designs on SharePoint 2013.

From the search engine optimization (SEO) perspective, responsive web design is the recommended way to optimize public-facing websites for mobile devices. After all, since the same HTML is sent to every device, it’s sufficient for an Internet search engine to index the content once, and it can be sure that the search results will apply the search query on every device.

Implementing responsive web design on a public-facing website is relatively easy assuming you start planning for it from the beginning. The great advantage of responsive web design above other approaches is that you maintain your website once to support a variety of audiences, and the different experiences are future-proof as they depend on the devices’ dimensions rather than their identity.

The following figures show how the sample Contoso Electronics website is displayed on different devices using responsive web design. Figure 1 shows the screen shot taken on a desktop device.

Figure 1. The Contoso Electronics website displayed on a desktop device

Figure 2 shows how the Contoso Electronics website looks like on different mobile devices.

Figure 2. The Contoso Electronics website displayed on mobile devices

SharePoint 2013 device channels

One of the new capabilities of SharePoint 2013 is device channels. You can use device channels to optimize how a website is displayed on different devices. By defining different channels and associating different devices with them, you can use different master pages to optimize how the website is presented to the user. For more information, see How to: Create device channels in SharePoint 2013. Figure 5 shows a sample configuration of device channels for a public-facing website built with SharePoint 2013.

Figure 3. Device channels configured for a public-facing website built on SharePoint 2013

Whereas responsive web design uses a device’s screen size to determine the presentation layer, device channels in SharePoint 2013 use the identity of the browser on the particular device to decide which presentation style to use. Depending on how many different devices your site visitors use, managing the different devices and experiences can become complex. By using device channels, you get more flexibility in controlling the markup of your website for the different devices. Another benefit of using device channels is that you can serve different content to different devices, whereas the same content is served when using responsive web design. With device channels, you can apply additional optimizations to your website, such as resizing images and videos server-side using the renditions capability, which further improves the performance and user experience of your website. For more information, see How to: Manage image renditions in SharePoint 2013.

With all the different options at our disposal, which one should we use to get the best results?

Improving the user experience of a public-facing website in SharePoint 2013

First and foremost, it’s important to note that SharePoint 2013 supports all the methods mentioned above for improving user experience on mobile devices. Whether you’re looking at building a separate website for mobile users, supporting certain use cases with a mobile app, implementing responsive web design, or using device channels, it can all be implemented in your website on top of SharePoint 2013.

Not only does SharePoint 2013 not stand in your way, but it also supports you in implementing some of those improvements. For example, using the cross-site publishing capability, you can easily publish the centrally managed content on both the main and the mobile websites. With the Search REST API, you can have your content published in your mobile app, and if you’re looking at optimizing the presentation of your website across different devices, SharePoint 2013 offers plenty of features to help you.

With all these techniques at your disposal, it is up to you to decide which method, or combination of methods, is the best choice for what you’re trying to achieve. While you might be interested in supporting a particular complex process with a dedicated mobile app, it might still be of added value to ensure that everyone, regardless of their device, can access all the information on your website.

In most scenarios, it’s easy to choose whether or not the particular optimization technique offers added value. A slightly more difficult choice, partly due to the similarity of both methods, is whether you should use responsive web design or device channels to optimize the presentation of your website for mobile devices.

Responsive web design and device channels comparison

Responsive web design and the SharePoint 2013 device channels capability are similar in how they let you optimize a single website to be displayed in a user-friendly way on different devices. Despite this similarity, there are a few important differences between both approaches. Table 1 presents a comparison of the different properties of both approaches.

Device channels	Responsive web design
Device management	Property management
Different HTML for every channel	Same HTML for every device
More management (support for new devices)	Future proof (device size)
More flexibility	Limited by CSS support and capabilities
Custom Vary-By User Agent response header required	Preferred by Internet search engines

Table 1. Comparison of device channels and responsive web design

Applying user experience

First of all, there is a difference in how both approaches determine which user experience should be applied for the particular user. Responsive web design uses the size of the screen to determine how the content should be laid out in the browser’s window. Device channels, on the other hand, use the identity of the browser to load the suitable channel.

While responsive web design can cause different experiences to be loaded depending on the size of the browser window, device channels will always load the same experience for the same device regardless of the browser window size. Using device channels can have great advantages, for example, from the troubleshooting point of view where the user and the helpdesk employee would see the same interface despite the possible differences in their screen resolutions or browser window sizes.

Page markup

Another difference between device channels and responsive web design is how the page contents are served. Responsive web design changes only the presentation layer of the website. Although you can hide some pieces of the page in the browser using CSS, they are still present in the website’s code and therefore loaded. When using device channels, you can use different master pages to ensure that only the relevant markup is served to users. Additionally, you can use the device channel panels to further control the content elements loaded on specific pages.

Although device channels allow for better control of the rendered HTML and therefore optimized performance of the website, more effort is required to ensure that Internet search engines will properly deal with all the different versions of the website presented to different devices. You can achieve this by using the Vary-By User Agent response header, but it has to be done manually.

Future-proofness

Responsive web design uses the size of the browser window to distinguish between the different experiences. This is a robust approach, and the chances are low that a new device will appear on the market that has a poor user experience despite the configured breakpoints. One reason for that might be related to some specific capabilities of such devices, but again, chances of this are very rare.

SharePoint 2013 device channels are based on the identity of the browser used to open the website. There are two challenges with this approach. First of all, in some situations it might be impossible to distinguish between the same browser installed on the same operating system but on two devices with distinct capabilities. Second, if a new device appears on the market, you would have to verify that this device is assigned to the right device channel on your website.

Choosing the right approach for optimizing the user experience

Although responsive web design and device channels are very similar, their capabilities differ and they have different impact when used for optimizing a website for mobile devices. Due to their similarities and their own strength, choosing between the two approaches is often difficult. Why not combine both approaches to get the best of what they offer?

Combining responsive web design and device channels

An interesting scenario worth considering is to combine responsive web design and SharePoint 2013 device channels to benefit from the strengths of both approaches.

When combining responsive web design and device channels, you could use responsive web design to create the baseline cross-device experience. Depending on your design for the different breakpoints, using responsive web design could be good for the 80%, or maybe even 90%, of the optimizations. The remainder—whether they’re caused by how the web design changes between the breakpoints or by the capabilities of the different devices that should be supported—could be covered by device channels and device channel panels.

By using responsive web design to build the baseline for the cross-browser experience, we benefit from its future-proofness and robustness. For the specific exceptions, we can benefit from the granular control that SharePoint device channels offer us.

About the author

Waldek Mastykarz is a Microsoft SharePoint Server MVP and works as a SharePoint consultant at Mavention. Waldek shares his enthusiasm about the SharePoint platform through his blog, articles published in online and off-line magazines and on MSDN SharePoint Forums. He is also a speaker at community events such as the SharePoint conference in London, SharePoint Connections Amsterdam, and SharePoint Saturday. In addition to his job at Mavention, Waldek is a Virtual Technology Solutions Sales Professional for Microsoft Netherlands. In this role he helps answer customer questions around SharePoint Web Content Management (WCM).

Blog: http://blog.mastykarz.nl
Twitter: http://twitter.com/waldekm
Mavention: http://www.mavention.com

Implementing your responsive designs on SharePoint 2013

Ricardo Loo — Mon, 01 Apr 2013 20:17:08 GMT

Learn how a SharePoint publishing site looks and reacts to different display resolutions when you implement a responsive web design.

Web designers are crucial for a successful SharePoint implementation. We all know that. With this in mind, I wanted to write an article for our SharePoint web designers out there. Not being an authority on the subject, I decided to ask someone who has been working in web design for some time. By asking my contacts, I got the email address of an expert in SharePoint branding and UX customization. Eric Overfield was the name on the contact card. I set up a conference call, and very soon we were chatting and discussing UX, branding, artists, engineers, and SharePoint.

The conversation quickly turned to devices and how to make SharePoint work as well as possible in this new and changing set of displays. Eric’s answer was: responsive web design. Responsive web design allows us to look at a site like a fluid grid. The fluid, dynamic grid adapts itself to fit the information in display resolutions as different as those in a phone, a tablet, and a full desktop monitor. Keep in mind that the mix of display resolutions doubles if you consider landscape and portrait orientations available in all these devices.

The author of the original post about responsive web design, Ethan Marcotte, provided a reference site to demo the concepts explained in his post. In this demo, you can observe how the elements in the page rearrange themselves to fit the current resolution as you resize your browser window. The demo left me wondering how a SharePoint website would react to different resolutions by using the fluid grid characteristic of responsive frameworks. Fortunately, Eric, along with some other people, developed Responsive SharePoint. Responsive SharePoint is a CodePlex project that you can use to try responsive frameworks on your SharePoint website.

I followed the provided instructions to install the resources by using Design Manager on an out-of-the-box publishing site. In no time, I was looking at how the site dynamically reacted to different resolutions as I resized my browser window. I decided to test the project by using the following display resolutions:

1200x1900 (desktop, portrait orientation)
768x1366 (tablet, portrait orientation)
480x800 (smartphone, portrait orientation)

The results were amazing. Within 10 minutes, I had a SharePoint website that automatically adapts to display resolutions commonly used in devices. The following figure compares the website in commonly used display resolutions:

Figure 1. Comparison of resolutions of the SharePoint website using a responsive framework

How is this achieved?

In this post, I can only explain that Responsive SharePoint uses media queries to match the width of the display in the device and then applies a set of styles to present the content in the available space. For this to work, you need a browser that supports media queries. The latest version of the major browsers support such functionality. The following code example shows how to declare media queries:

@media (min-width: 769px) and (max-width: 979px) {
    /*
        Styles for display width 
        between 769 and 979 pixels
    */
}

@media (max-width: 768px) {
    /*
        Styles for display width 
        equal to 768 pixels and thinner
    */
}

@media (min-width: 1200px) {
    /*
        Styles for display width 
        equal to 1200 pixels and wider
    */
}

Of course there is much more to it. You can learn more by browsing the Responsive SharePoint CodePlex project.

The new design and branding features in SharePoint 2013 make it easy to create and edit your web design, including responsive designs. You can even use the tools you are familiar with by mapping a network drive to the SharePoint 2013 Master Page Gallery. In my case, I used Microsoft Expression Web 4 to browse and edit the master pages and CSS files.

I am excited about the new design and branding features and how we can use them in responsive web designs. For more information, see What's new with SharePoint 2013 site development.

- Ricardo

Eric Overfield is the co-founder of PixelMill. PixelMill is a company that offers products and services for branding SharePoint starting with SharePoint 2007, and they have been in the web design business since 1998. Eric is very passionate about the community for whom he developed the CodePlex project Responsive SharePoint. He is also a speaker at SharePoint events, such as SharePoint Saturdays, and is in the process of writing a book about responsive design and SharePoint 2013. You can read more about Eric’s work at PixelMill’s blog and follow him on Twitter @ericoverfield.

Cross-post from the SharePoint blog: Options to create forms in SharePoint 2013

SharePoint Developer Team — Wed, 13 Mar 2013 11:00:00 GMT

Last week, Keenan Newton published a blog post on the SharePoint blog. In his post, Keenan explains the different options for creating forms in SharePoint 2013. To summarize, you can choose from several different tools for building forms in SharePoint. Depending on what your specific needs are, you will find a wide range of tools that provide flexibility for both business users and developers.

The following options are available for you to create forms in SharePoint 2013:

InfoPath
Access
Excel
Visual Studio

For more information, visit the original blog post, Options to Create Forms in SharePoint 2013.

Rounding up Office 365 developer content

SharePoint Developer Team — Tue, 12 Mar 2013 11:00:00 GMT

This week, we completed the facelift of our entry point for Office 365 developer content on MSDN.

The Office 365 Developer Center pulls together the resources that partners and developers need to build solutions for Office 365.

The new articles and code samples on the Office 365 Developer Center complement the developer content that we’ve been publishing since last July on our Dev.Office.com site.

Getting started articles

Developing solutions with Office 365

Comparing the Office 365 online and on-premises development environments

Learning about the Office 365 Reporting web service

Code samples

Don’t miss the newest Office 365 code samples, designed to help you learn how to do the following common tasks:

Use the Office 365 Reporting web service
Integrate Windows Azure
Use Windows PowerShell in Office 365
Use best practices for authentication and authorization for on-premises and Office 365 services
Use best practices for enabling applications to use Office 365 services
Use best practices for error handling in Office 365 solutions
Integrate social media into Office 365

Enjoy!

Written by Lola Jacobsen, Senior Content Project Manager of the Office 365 Developer Center

Adding a custom data source to Aggregated Business Calendar

bhkumar — Wed, 20 Feb 2013 00:14:51 GMT

With Feature Pack 1 for Duet Enterprise 1.0 and Duet Enterprise 2.0, you can add a custom data source to your Aggregated Business Calendar Web Part along with the other types of data sources. In this post, we walk you through the steps to create a SQL Server-based data source and configure the Aggregated Business Calendar Web Part to display the data from this data source.

If Feature Pack 1 for Duet Enterprise 1.0 or Duet Enterprise 2.0 is installed on your server, you will have the OBA.Server.Extensions.dll assembly in the global assembly cache (GAC). You will need this assembly for the development of the SQL Server data source.

Create a data source

First, we need to create a data source accessor, which will work as a back end and provide the data in the correct format when the aggregate calendar requests it.

Here’s how you do this:

1. Open Visual Studio, and create a new class library project—for example, Project1.

2. Now add a reference to OBA.Server.Extensions.dll in your project, and use the OBA.Server.Extensions namespace.

3. Now your DataSourceAccessor class must implement the ICalendarAccessor interface. So create a class in your project—for example, SQLDataSource : ICalendarAccessor.

4. This class needs to have the following override methods and properties:

Initialize()
RetrieveItems()
Bool CanDelete
String ViewFormURL
String CreateFormURL
Delete()
String UpdateFormURL

5. Here, the most important method is RetrieveItems. This method should return a list of calendarItems.

6. In the Initialize() method, you can perform various tasks specific to the data source, like setting some data source properties—for example, the OWA URL for an Exchange data source, or the SQL Server address for a SQL Server data source.

7. CanDelete represents whether the item can be deleted in the current context or not.

8. ViewFormUrl, CreateFormURL, and EditFormURL will be the URLs for different forms that will be used for create, read, and update operations. You can create your custom forms also. These forms are invoked with two parameters—ID (item ID) and source (URL from where we are invoking the operation).
For reference, see the Custom Data Source project. This project shows how to create a SQL Server data source accessor.

SQL table

For this project, the following table schema is used to store the time entries:

Title	varchar(50)
Location	varchar(50)
[Start Time]	datetime
[End Time]	datetime
ItemID	int

Table 1: Schema for the Time table

Code

Here is the SQLDataAccessor code:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using System.Xml;
using System.Data.Sql;
using System.Data.SqlClient;
using System.Runtime.Serialization;
using OBA.Server.Extensions;

namespace MS.Internal.Motif.Office.DataSource
{
    public class SQLDataSource : ICalendarAccessor
    {
        // This is the method that will pick the time entries from SQL and 
        //return them as a list of calendar items.

        public IEnumerable<ICalendarItem> RetrieveItems(
            DateTime startTime, 
            DateTime endTime)
        {
            string connectionString = @"Data Source=<data-source>;" + 
                @"Initial Catalog=master;user id=<user>;password=<password>";
            var list = new List<ICalendarItem>();

            // This is the data structure that we will be returning.
            string query = 
                @"SELECT * from Time where (Time.[Start Time] >= '" 
                + startTime + @"' AND Time.[Start Time] <='" + endTime + 
                @"') OR (Time.[End Time] >= '" + startTime + 
                @"' AND Time.[End Time] <='" + endTime + @"')";

            SqlConnection connection = new SqlConnection();
            connection.ConnectionString = connectionString;
            connection.Open();

            // Construct a new SqlCommand object 
            // (links the connection with the query).
            SqlCommand command = new SqlCommand(query, connection);
            // Execute the query and get a data reader.
            SqlDataReader data = command.ExecuteReader();

            // Check if no results come back.
            if (data.HasRows == false)
            {
                data.Close();
                connection.Close();
                return list;
            }

            while (data.Read()) //the .Read method automatically moves
            // The data cursor to the next 'row'.
            {
                var item = new CalendarItem();
                item.Title = HttpUtility.HtmlDecode(data.GetString(0));
                item.Location = HttpUtility.HtmlDecode(data.GetString(1));
                item.StartDate = data.GetDateTime(2);
                item.EndDate = data.GetDateTime(3);
                item.ItemID = data.GetInt32(4).ToString();
                list.Add(item);
            }

            // Close the data reader.
            data.Close();

            // Close the connection.
            connection.Close();

            return list;
        }

        // Method to implement delete functionality.
        public bool Delete(string itemId, out string failureMessage)
        {
            int id;
            if (CanDelete)
            {
                if (Int32.TryParse(itemId, out id))
                {
                    try
                    {
                        failureMessage = @"";
                        string connectionString = @"<connection string>";
                        string query = 
                            @"DELETE from Time WHERE Time.ItemID=" + id;
                        SqlConnection connection = new SqlConnection();
                        connection.ConnectionString = connectionString;
                        connection.Open();

                        // Construct a new SqlCommand object 
                        // (links the connection with the query).
                        SqlCommand command = new SqlCommand(
                                                query, 
                                                connection
                                                );

                        if (command.ExecuteNonQuery() != 1)
                        {
                            failureMessage = 
                                @"Fatal Error while deleting the item";
                            throw new Exception("Could not delete the item");
                        }
                        return true;
                    }

                    catch (Exception ex)
                    {
                        failureMessage = ex.Message;
                        return false;
                    }
                }
            }

            failureMessage = @"Item can't be deleted";
            return false;
        }

        // Represents whether or not delete is allowed 
        // in the current context.
        public bool CanDelete
        {
            get { return true; }
        }

        // URL of Edit Form. The property returns the 
        // relative URL to the edit page.
        public string EditFormUrl
        {
            get { return @"/_layouts/SQLEditForm.aspx"; }
        }

        public string CreateFormUrl
        {
            get { return @"/_layouts/SQLCreateForm.aspx"; }
        }

        public string ViewFormUrl
        {
            get { return @"/_layouts/SQLViewForm.aspx"; }
        }

        // This method can be used to set the additional calendar 
        // data source properties--for example, user credentials
        // to access the SQL data source.
        public void Initialize(IEnumerable<CalendarProperty> l)
        {
            // Nothing to do.
        }
    }
}

9. After building the project, deploy the solution on Web App. Or, you can manually add the DLL into the GAC on the server and add the layouts pages in the Layout folder.
For the demo project, you can just add the built WSPs into the Solutions Gallery and then deploy the solution globally.

Add the data source

The next step is to add this data source into the Aggregate Calendar:

1. Open the Aggregate Calendar page, and click Edit Web Part.

2. In the editor, choose to add a new custom data source.

3. Complete all the required fields. For the configuration XML, enter the following XML code:

<?xml version="1.0" encoding="utf-8"?>
<!-- Please note that all the fields are mandatory here. 
     For a few fields, you might leave the value as blank,
     but the node must be present  -->
<CalendarDataSource 
    xmlns:i="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns="http://schemas/oba/2010/extensions">
<!-- Here namespace name needs to be same as above. -->
<AssemblyName>
    MS.Internal.Motif.Office.DataSource, 
    Version=1.0.0.0, 
    Culture=neutral, 
    PublicKeyToken=38ed9c5bc913d77a
</AssemblyName>
<!-- Name of the assembly file that we created for the data source. 
     Assembly name should be fully qualified name. -->
<CalendarProperties>
</CalendarProperties>
<!-- You can have additional calendar properties here, 
     which you can use in the Initialize() method 
     of the data source accessor -->
<Color>2</Color>
<!-- Color for the data source items. -->
<DataSourceType>Custom</DataSourceType>
<!-- Please keep the value the same as above (case-sensitive) -->
<Description>custom calendar</Description>
<Id>94b8-4031-8e17-65933ce6ffbd</Id>
<ShowDefault>true</ShowDefault>
<Title>SQL DataSource</Title>
<TypeName>MS.Internal.Motif.Office.DataSource.SQLDataSource</TypeName>
<!-- Typename is the className of the data source which contains the 
     RetreiveItems and other methods. 
     Name is in format <assembly name>.<class name> -->
<Url>http://www.microsoft.com</Url>
<!-- URL to which user will navigate when clicking the data source name. -->
</CalendarDataSource>

4. After providing these values, save the configuration.
Now if all goes well, you should be able to see the items in the mash-up view, and you should be able to perform create, read, update, and delete (CRUD) operations on these items.

Troubleshooting

If you get an error message, you can try these troubleshooting steps:

1. If, while adding the data source, you get an error message stating that it could not access the DataSourceAccessor from the assembly '……', make sure that the fully qualified name of the assembly in the GAC matches the assembly specified in the XML schema.

2. If, while adding the data source, you get an error message that states it could not recognize 'Color', expected 'ID', or some similar message, make sure that the XML schema has the same sequence of the nodes.

Customize the Duet Workflow Task form in InfoPath 2013

GauravArora_blogger — Thu, 10 Jan 2013 09:21:36 GMT

Summary: Learn how to customize the Duet Workflow Task form using InfoPath Designer.

Applies To: SharePoint Server 2013, Duet Enterprise 2.0, SharePoint Designer 2013, InfoPath Designer 2013, InfoPath Filler 2013

Published: January 2013

Contents

Introduction
Displaying the SAP business properties
Adding and deleting controls on the form
Adding heading images to the form and applying a theme

Introduction

After a task site is published through SharePoint Designer, the task form ApprovalProcess.xsn is generated. The form has a default layout. But we may also want to display the SAP business properties, add some more controls relevant to the use of the form, or delete some irrelevant controls. We may also want to give a nice look and feel to the form. We can do these customizations easily with the help of InfoPath 2013.

Scenario

We have published a task site of the task type TestTask using SharePoint Designer 2013. The task form has the default layout shown below. We want to customize the form to include a SAP business property, add a control, remove a control, add a heading image, and apply a theme.

Figure 1. TestTask task form with default layout

Displaying the SAP business properties

Prerequisite: We can display the SAP business properties in the workflow task form provided that we have included the properties in the Extended Business Properties text box while creating the task site.

Steps:

1. In SharePoint Designer, click ApprovalProcess.xsn.

Figure 2. ApprovalProcess.xsn in SharePoint Designer

InfoPath Designer opens with an auto-generated layout of the form.

Figure 3. InfoPath Designer with auto-generated layout of the TestTask form

2. Insert a new row, wherever you want, for the business property LeaveDaysUsedTillToday that you want to display in the form.

a. In the first column, enter the field name as you want to see it displayed in the form, for example, Leaves Used Till Today.

Figure 4. Entering field name in the first column

b. In the second column, we need to get the value for the business property LeavesUsedTillToday from the Workflow Business Document Library. Thus, we need to create a secondary data connection with the Workflow Business Document Library.

3. Create a secondary data connection with the Workflow Business Document Library as follows:

a. Under Actions, click Manage Data Connections.

Figure 5. Clicking Manage Data Connections in InfoPath

The Data Connections dialog box appears.

Figure 6. Data Connections dialog box

b. In the Data Connections dialog box, select Context from the list of Data Connections for the form template, and click Add. The Data Connection Wizard starts.

Figure 7. Data Connection Wizard

c. Click Next without changing any settings. The wizard now asks for the source of data. Select SharePoint library or list as the source of data.

Figure 8. Selecting SharePoint library or list in the Data Connection Wizard

d. Click Next. The wizard now prompts you to enter the location of the SharePoint site.

e. Enter the URL of the task site, and click Next.

Figure 9. Entering task site location in the Data Connection Wizard

f. Select the Workflow Business Data Document Library for the data connection, and click Next.

Figure 10. Selecting Workflow Business Data Document Library for the data connection

g. Select the Title and LeavesUsedTillToday fields, and click Next. The Title field will help us filter the data corresponding to a task from the Workflow Business Data Document Library. The Title field is the concatenation of the Related Content field in the main data connection and the string ".xml".

Figure 11. Selecting the Title field and LeaveDaysUsedTillToday field

h. Click Next.

Figure 12. Data Connection Wizard

i. Click Finish.

Figure 13. Finishing the Data Connection Wizard

j. Close the Data Connections dialog box that now has the data connection to the Workflow Business Data Document Library.

Figure 14. Data Connections dialog box with the new data connection

4. Click in the second column of the new row that we inserted in step 3. On the Home tab in the ribbon, click Calculated Value (fx) button in the Controls pane.

Figure 15. Choosing Calculated Value in InfoPath

The Insert Calculated Value dialog box appears.

5. Click the fx button next to the XPath text box.

Figure 16. Insert Calculated Value dialog box

The Insert Formula dialog box appears as shown in the following figure.

6. Click Insert Field or Group.

Figure 17. Insert Field or Group button

The Select a Field or Group dialog box appears, as shown in the following figure.

7. Click Show advanced view.

Figure 18. Show advanced view link

Now, we have the option to select the data connection also.

Figure 19. Select a Field or Group dialog box

8. Select the secondary data connection to the Workflow Business Document Library from the drop-down list.

Figure 20. Choosing a secondary data connection

9. Expand the dataFields tree structure until you see LeaveDaysUsedTillToday. Select LeaveDaysUsedTillToday. Since we want to get only the business property for the corresponding task, we need to filter the data received from the data connection. Click Filter Data.

Figure 21. Filter Data button

10. The Filter Data dialog box appears. Click Add.

Figure 22. Add button in the Filter Data dialog box

The Specify Filter Conditions dialog box appears.

Figure 23. Specify Filter Conditions dialog box

11. Specify the filter conditions as follows:

a. In the first drop-down list, choose Select a field or group.

Figure 24. Choosing Select a field or group

b. Choose Workflow Business Data Document Library as the data source.

c. Expand the dataFields tree structure until you see Title. Select Title, and then click OK.

Figure 25. Title in the Select a Field or Group dialog box

d. In the second drop-down list in the Specify Filter Conditions dialog box, select is equal to.

e. In the third drop-down list in the Specify Filter Conditions dialog box, select Use a formula.

Figure 26. Selecting Use a formula in the list

f. The Insert Formula dialog box opens. Click Insert Function.

Figure 27. Insert Function button

The Insert Function dialog box opens.

Figure 28. Insert Function dialog box

g. Select Text in the Categories list, and then select concat in the Functions list. Click OK.

Figure 29. Choosing category and function

The formula corresponding to the selection appears in the Insert Formula dialog box.

Figure 30. Concat Formula prototype (skeleton) in the Insert Formula dialog box

h. Double-click the first argument in the concat function. The Select a Field or Group dialog box opens. Under the Main data connection, expand the dataFields tree structure till you see Related Content. Select the subfield :Description under Related Content. Click OK.

Figure 31. :Description subfield under Related Content

i. Write the string ".xml" as the second argument in the concat function. Delete the comma following the second argument and the third argument.

The updated formula is as shown in the following figure. Click OK.

Figure 32. Updated concat formula (with provided arguments) in Insert Formula dialog box

j. Click OK in the dialog boxes in the order: Specify Filter Conditions, Filter Data, Select a Field or Group.

The final overall formula appears in the Insert Formula dialog box. (This dialog box was opened in step 5 and is still open)

Figure 33. Final formula in the Insert Formula dialog box

12. Click OK in the Insert Formula dialog box (shown above) to return to the Insert Calculated Value dialog box where the XPath corresponding to our selections has been updated.

Figure 34. Updated XPath in the Insert Calculated Value dialog box

Click OK.

13. Click the File tab on the ribbon. Click Quick Publish.

Figure 35. Publish your form

14. The Save As dialog box opens.

Figure 36. Saving the form template

15. Click Save. The Microsoft InfoPath dialog box stating the successful publishing of the form template appears. Click OK.

Figure 37. Form template published successfully

16. Open the task site and look up any of the tasks. The task appears as shown in the following figure. The SAP business property LeavesUsedTillToday has the value 10 in this task.

Figure 38. Task on the task site with LeavesUsedTillToday business property

Adding and deleting controls on a form

Suppose we want to add a control—for example, ID—from the main data connection to the workflow task form, and delete the control Consolidated Comments from the form.

1. Insert a new row for the ID field.

Figure 39. Inserting a new row for the ID field

2. Drag the ID field from the Fields task pane onto the canvas. The label for the control appears automatically in the left column when you drag the field into the right column of the table. However, this is true only if you highlight both columns when you release the mouse.

Figure 40. ID field in right column

3. Delete the row containing the control for Consolidated Comments.

Figure 41. Consolidated Comments row deleted

3. Click the File tab on the ribbon. Click Quick Publish. The Microsoft InfoPath dialog box stating the successful publishing of the form template appears.

4. Click OK.

5. Open the task site and look up any of the tasks. The task appears as shown in the following figure. The task has the ID field with value 1 and no Consolidated Comments control.

Figure 42. Task on the task site with ID control and without Consolidated Comments control

Adding heading images to the form and applying a theme

1. Place your cursor in the title area of the page layout. Add a title—for example, MyTask—in the required format and font.

Figure 43. Title area of the page layout

2. Add the heading image to the form by inserting a picture from the Insert tab on the ribbon.

3. On the Page Design tab, apply the Professional – Standard theme. The easiest way to select the theme is to expand the Themes gallery by clicking the arrow at the lower-right corner. Professional – Standard is the first theme in the Professional section.

Figure 44. Page Design tab

The title, heading image, and page design should now resemble the following figure.

Figure 45. New title, heading image, and page design

4. Click the File tab on the ribbon. Click Quick Publish. The Microsoft InfoPath dialog box stating the successful publishing of the form template appears.

5. Click OK.

6. Open the task site and look up any of the tasks. The task appears as shown in the following figure. The task has the desired heading image and theme.

Figure 46. Task on the task site with desired heading image and theme

BCS OData Custom Authentication using Extension Provider

Venkatesh Narayanan — Fri, 30 Nov 2012 13:28:00 GMT

Business Connectivity Services (BCS) in SharePoint 2013 supports connecting to OData-based LOB systems. BCS supports the following authentication modes for authenticating against the OData service:

PassThrough
RevertToSelf
Credentials
Windows Credentials
Digest Credentials
Custom Authentication using OData Extension Provider

In this article, we cover in detail how to connect from SharePoint on-premises to any OData service with custom authentication using an OData extension provider.

Some examples of custom authentication schemes that the OData service provider could support are:

Authenticating using Windows Azure Access Control Service (ACS)
Client certificate-based authentication

To enable these custom authentication mechanisms, you need to implement an OData extension provider and configure the same in BCS. The OData extension provider is invoked by BCS for every call to the OData LOB Service.

Note: BCS supports custom authentication using an OData extension provider only for apps hosted in on-premises SharePoint or for those apps that connect using hybrid (SharePoint Online to on-premisea-based LOB through hybrid). This restriction is because it is not possible to install custom assemblies in SharePoint Online.

Implementing an OData extension provider

Create a new project in Visual Studio 2010. Select Class Library as the project type:
Change the file name and class name to ODataOAuthExtensionProvider.
Add a reference to the Microsoft.BusinessData.dll assembly to the project. Add the namespace Microsoft.BusinessData.SystemSpecific.OData to the class.
The empty custom OData extension provider implementation should be as follows:
Sign the assembly by selecting the “Signing” options under the project settings. Build the SampleODataExtensionProvider.dll assembly.

Installing the OData extension provider assembly

Install the SampleODataExtensionProvider.dll in the global assembly cache (GAC) on the SharePoint web front-end (WFE) machines.

If BCS is configured to connect from SharePoint Online to an on-premises LOB system through a hybrid, then the SampleODataExtensionProvider.dll has to be installed in the GAC in the SharePoint on-premises WFE.

Configuring a connection to the OData service from SharePoint on-premises

In order to connect to the OData service from BCS, a connection setting has to be created in SharePoint using a BCS Windows PowerShell commandlet.

The connection setting contains information required by SharePoint BCS to connect to the OData LOB system (OData Service URI, OData Service Metadata URI, Authentication Mode, and Extension Provider).

New-SPODataConnectionSetting -Name "ContosoServiceApp" -ServiceContext "http://contoso" -ServiceAddressURL "http://tv.telerik.com/services/OData.svc" -AuthenticationMode "Anonymous" -ExtensionProvider "SampleODataExtensionProvider. ODataOAuthExtensionProvider, SampleODataExtensionProvider, Version=1.0.0.0, Culture=neutral, PublicKeyToken=34c4d4fa89a6bb3b

Parameter Name	Description
Name	Connection setting Id should be mentioned in the BCS model and should be unique.
ServiceContext	SharePoint Site Collection URI
ServiceAddressUrl	OData Service Address URI. The OData metadata URI is the service URI+ $metadata. If the OData Metadata URI is different, specify through the parameter MetadataAddressUrl.
AuthenticationMode	The authentication mode to be used while authenticating against the OData Service URI. “Anonymous” here indicates that BCS does not do any authentication.
ExtensionProvider	Fully qualified assembly name of the OData extension provider. This assembly should have been installed in the GAC on the SharePoint WFEs.

Configuring the connection in the BCS model

The connection information has to be specified in the BCS model. The BCS runtime uses the connection information for invoking the OData LOB service.

To specify the connection information, add the following property in the BCS model by adding it to the LOB System and LOB System Instance.

<Property Name="ODataConnectionSettingsId" Type="System.String"> ContosoServiceApp </Property>

Summary

This article describes in detail how to support custom authentication with a BCS OData connector using an OData extension provider.

By following the steps mentioned here, you should be able to import a BCS model that connects to an OData service with an extension provider that does custom authentication. In the next article, we will change the OData extension provider to authenticate against Windows Azure ACS.

Content enrichment service scaling and aggregation

Niels Petter R-O — Wed, 21 Nov 2012 13:17:00 GMT

WCF Routing Service with content based routing

The configuration of the content enrichment feature only supports a single web service endpoint. This can be limiting for a number of common scenarios:

You want to integrate more than one content enrichment web service into content processing.
Your web service is time-consuming and you want to load balance between different instances of the web service.
You have a scaled out search topology with multiple content processing components, and you want to scale up the web service to match the load.
You want fault tolerance for the web service.

There are several possible technologies one could consider to solve these scenarios. This blog post focuses on using the Windows Communication Foundation (WCF) Routing Service technology included in .NET Framework 4.0. You can also check out our upcoming blog post on how to deploy a network load balancing cluster for high performance and availability.

WCF Routing enables development of complex routing logic, load-balancing, and fault tolerance. All of these mechanisms support our underlying requirement for scaling out, but not all of them need to be implemented for all scenarios. We’ll look closer at routing logic in particular in this blog post.

In short, the benefits of WCF Routing are:

Simple and quick technology to implement and deploy.
Allows for a varying degree of routing logic complexity.

A set of pre-defined filters that can be customized.
Completely custom filter implementations.

Service aggregation through routing rules that inspect managed properties.
Fault tolerance through backup endpoints.
Load balancing through custom filter implementations.

Search topology and WCF Routing

We’ll start by recapping some basics, and then move on to a concrete example.

A search topology can consist of anywhere from 1 to n content processing components. The role of a content processing component is to parse and transform the data coming into the system before delivering it to the indexing component. This processing takes place in discrete processing flows that can range from 0 to n instances within a specific content processing component. The number of active flow instances will depend on available resources and the amount of data being crawled. A ballpark figure can be calculated as the number of physical cores on the host multiplied by three. There’s no guarantee that this calculation will be true in the future.

When content enrichment is enabled for the Search service application, all active flow instances will potentially call out to the configured web service endpoint for every document. Assuming a web service that has no temporal cost, the web service will receive roughly the same number of calls per second as the crawl rate (documents per second) of the farm. How much of a bottleneck the web service becomes, if at all, depends on the following factors:

The amount of resources consumed by the web service implementation.
The hardware specification of the web service host.
The number of calls per second.
The size of the configured payload to send and receive between the content processing component and the web service.

Including network topology.

The number of concurrent calls per second.

Depends on the number of content processing components and active flow instances.

The following is a simple visual representation of how a search topology with two content processing components can be configured to communicate with a single WCF Routing Service. The WCF Routing Service in turn distributes incoming requests to the appropriately registered service endpoints based on a set of defined filters and the content of the received SOAP envelope. Each service implementation has a backup endpoint that will ensure high availability in case of a failure situation. Typically a CommunicationException or TimeoutException will cause the router to try the backup endpoint.

Even though a single connector appears between nodes in the drawing, there will most likely be multiple HTTP connections at run time. The number of allowed active connections can be throttled through the service throttling subsection of the service behavior section in the web configuration file (for IIS hosting). By default the underlying connections will be persistent, which creates less overhead than re-creating an http-connection for every call.

Example implementation of content based routing

There may be situations where you have different web service implementations aimed at different types of content. You can pack all of them into a single service and handle requests differently depending on content, but in other cases you may know a priori that some content will be tougher to process and that it’s desirable to dedicate a particularly beefy host to those documents. Also important, maintainability of your service implementations may decrease if you have no separation of business logic. To show you how to achieve this, we’ll walk through an implementation of a WCF Routing Service where we do content-based routing predicated on the content source of an item.

Creating the WCF Routing Service

The following fictitious values are used in the example.

Role	Value
Web Service 1	servicehost1.contoso.com
Web Service 1 backup	servicehost2.contoso.com
Web Service 2	servicehost3.contoso.com
Web Service 2 backup	servicehost4.contoso.com
WCF Routing Host	routinghost.contoso.com

While there are different ways of implementing a WCF Routing Service, and different levels of complexity, we’ll focus on a very simple router that we can express mostly declaratively through the web configuration file. Initially you’ll need to have Internet Information Services (IIS) set up on a server and create a new site (including a new directory on your local drive for the site).

Let’s start with the web.config file and look the different sections in it separately before tying it all together in a full example. Every section described below will be a descendant of the <system.serviceModel> node. We’ll start with the binding used by both the router’s exposed service, and the clients it talks to.

Bindings

We’ve created a single basicHttpBinding where we’ve configured large values for the readerQuotas and the maxReceivedMessageSize. These values can be reduced later on once you know the limits you want to have in place. They are used to limit the allowed size and complexity of the received SOAP envelope.

<basicHttpBinding>
    <binding 
        name="basicHttpBinding_IContentProcessingEnrichmentService" 
        maxReceivedMessageSize = "8388608">
        <readerQuotas 
            maxDepth="32" 
        maxStringContentLength="2147483647" 
            maxArrayLength="2147483647" 
            maxBytesPerRead="2147483647" 
            maxNameTableCharCount="2147483647" />
        <security mode="None" />
    </binding>
</basicHttpBinding>

Services

This is where we define the endpoint that the router uses to expose itself. We will configure the content enrichment feature in SharePoint to use this endpoint through the cmdlets later. Take note that the baseAddress attribute is not required when hosting in IIS, it’s simply here to make it clear what host this service is for.

<service 
    behaviorConfiguration="RoutingServiceBehavior" 
    name="System.ServiceModel.Routing.RoutingService">
    <host>
        <baseAddresses>
            <add baseAddress="http://routinghost.contoso.com:800"/>
        </baseAddresses>
    </host>
    <endpoint 
        name="RoutingServiceEndpoint" 
        address="" 
        binding="basicHttpBinding" 
        bindingConfiguration=
        "basicHttpBinding_IContentProcessingEnrichmentService"
        contract="System.ServiceModel.Routing.IRequestReplyRouter" />
</service>

Clients

Here we define the endpoints to the content enrichment web service implementations that the router will route to. These are not different from a normal implementation that you host in a single-service scenario. As can be seen in the following example, we’re configuring a total of four client endpoints. These cover our two different service implementations, with an additional backup for each in case of a failure.

<client>
    <endpoint 
        name="Service1" 
        address=
"http://servicehost1.contoso.com:800/ContentEnrichmentService.svc"
        binding="basicHttpBinding" 
        bindingConfiguration=
"basicHttpBinding_IContentProcessingEnrichmentService" 
        contract="*" />
    <endpoint 
        name="Service1Backup" 
        address=
"http://servicehost2.contoso.com:800/ContentEnrichmentService.svc" 
        binding="basicHttpBinding" 
        bindingConfiguration=
"basicHttpBinding_IContentProcessingEnrichmentService" 
        contract="*" />
    <endpoint 
        name="Service2" 
        address=
"http://servicehost3.contoso.com:800/ContentEnrichmentService.svc" 
        binding="basicHttpBinding" 
        bindingConfiguration=
"basicHttpBinding_IContentProcessingEnrichmentService" 
        contract="*" />
    <endpoint 
        name="Service2Backup" 
        address=
"http://servicehost4.contoso.com:800/ContentEnrichmentService.svc" 
        binding="basicHttpBinding" 
        bindingConfiguration=
"basicHttpBinding_IContentProcessingEnrichmentService" 
        contract="*" />
</client>

Service behavior

We need to create a service behavior where we reference the name of the filter table that will be defined in the next step. In addition, to enable full inspection of the SOAP envelopes in our XPath filters, we set the attribute routeOnHeadersOnly to false.

<behavior name="RoutingServiceBehavior">
    <routing 
        filterTableName="ContentSourceFilters" 
        routeOnHeadersOnly="False"/>
</behavior>

Routing

Here we define the filters and the filter table where we map the filters to normal endpoints and backup endpoints. The XPath expressions look for all Property nodes in the SOAP envelope by using a predicate that specifies the name of the property and the value. This predicate is used to match against specific content sources. There are various types of filters that we can use, but the XPath type is sufficient in speed and functionality for this example. To develop more complex scenarios, take a look at custom filters in the online WCF documentation.

<routing>
    <namespaceTable>
        <!-- Define prefix for Content Enrichment namespace, 
        used in XPath filters -->
        <add 
            prefix="cc" 
            namespace=
"http://schemas.microsoft.com/office/server/search/
contentprocessing/2012/01/ContentProcessingEnrichment"/>
    </namespaceTable>
    <!-- Filter definitions -->
    <filters>
        <filter 
            name = "Sharepoint" 
            filterType = "XPath" 
            filterData= 
"//cc:Property[cc:Name[. = 'ContentSource'] and 
cc:Value[. = 'Local Sharepoint Sites']]"/>
        <filter 
            name = "Fileshare" 
            filterType = "XPath" 
            filterData= 
"//cc:Property[cc:Name[. = 'ContentSource'] and 
cc:Value[. = 'Large Fileshare']]"/>
    </filters>
    <!-- Filter mappings -->
    <filterTables>
        <filterTable name="ContentSourceFilters">
            <add 
                filterName="Sharepoint" 
                endpointName="Service1" 
                backupList="BackupSharepoint"/>
            <add 
                filterName="Fileshare" 
                endpointName="Service2" 
                backupList="BackupFileshare"/>
        </filterTable>
    </filterTables>
    <!-- Backup lists -->
    <backupLists>
        <backupList name="BackupSharepoint">
            <add endpointName="Service1Backup" />
        </backupList>
        <backupList name="BackupFileshare">
            <add endpointName="Service2Backup" />
        </backupList>
    </backupLists>
</routing>

Web.config

It’s time to tie it all together in a single configuration. The following example uses all the previous pieces to build a complete configuration file.

<?xml version="1.0"?>
<configuration>
    <system.serviceModel>
        <bindings>
            <basicHttpBinding>
                <binding 
                    name=
"basicHttpBinding_IContentProcessingEnrichmentService" 
                    maxReceivedMessageSize = "8388608">
                    <readerQuotas 
                        maxDepth="32" 
                        maxStringContentLength="2147483647" 
                        maxArrayLength="2147483647" 
                        maxBytesPerRead="2147483647" 
                        maxNameTableCharCount="2147483647" />
                    <security mode="None" />
                </binding>
            </basicHttpBinding>
        </bindings>
        <services>
            <service 
                behaviorConfiguration="RoutingServiceBehavior" 
                name="System.ServiceModel.Routing.RoutingService">
                <host>
                    <baseAddresses>
                        <add 
                            baseAddress=
                            "http://routinghost.contoso.com:800" />
                    </baseAddresses>
                </host>
                <endpoint 
                    name="RoutingServiceEndpoint" 
                    address="" 
                    binding="basicHttpBinding" 
                    bindingConfiguration=
"basicHttpBinding_IContentProcessingEnrichmentService" 
                    contract= "System.ServiceModel.Routing.IRequestReplyRouter" />
            </service>
        </services>
        <client>
            <endpoint 
                name="Service1" 
                address= 
"http://servicehost1.contoso.com:800/ContentEnrichmentService.svc" 
            binding="basicHttpBinding" 
                bindingConfiguration= 
"basicHttpBinding_IContentProcessingEnrichmentService" 
                contract="*" />
            <endpoint 
                name="Service1Backup" 
                address= 
"http://servicehost2.contoso.com:800/ContentEnrichmentService.svc" 
                binding="basicHttpBinding" 
                bindingConfiguration= 
"basicHttpBinding_IContentProcessingEnrichmentService" 
                contract="*" />
            <endpoint 
                name="Service2" 
                address=
"http://servicehost3.contoso.com:800/ContentEnrichmentService.svc" 
                binding="basicHttpBinding" 
                bindingConfiguration= 
"basicHttpBinding_IContentProcessingEnrichmentService" 
                contract="*" />
            <endpoint 
                name="Service2Backup" 
                address= 
"http://servicehost4.contoso.com:800/ContentEnrichmentService.svc" 
                binding="basicHttpBinding" 
                bindingConfiguration= 
"basicHttpBinding_IContentProcessingEnrichmentService" 
                contract="*" />
        </client>
        <behaviors>
            <serviceBehaviors>
                <behavior 
                    name="RoutingServiceBehavior">
                    <routing 
                        filterTableName="ContentSourceFilters" 
                        routeOnHeadersOnly="False"/>
                </behavior>
            </serviceBehaviors>
        </behaviors>
        <routing>
            <namespaceTable>
                <add 
                    prefix="cc" 
                    namespace= 
"http://schemas.microsoft.com/office/server/search/
contentprocessing/2012/01/ContentProcessingEnrichment"/>
            </namespaceTable>
            <filters>
                <filter 
                    name = "Sharepoint" 
                    filterType = "XPath" 
                    filterData = 
 "//cc:Property[cc:Name = 'ContentSource' and 
 cc:Value = 'Local Sharepoint Sites']"/>
                <filter 
                    name = "Fileshare" 
                    filterType = "XPath" 
                    filterData =  
"//cc:Property[cc:Name = 'ContentSource' and 
 cc:Value = 'Large Fileshare']"/>
            </filters>
            <filterTables>
                <filterTable name="ContentSourceFilters">
                    <add 
                        filterName="Sharepoint" 
                        endpointName="Service1" 
                        backupList="BackupSharepoint"/>
                    <add 
                        filterName="Fileshare" 
                        endpointName="Service2" 
                        backupList="BackupFileshare"/>
                </filterTable>
            </filterTables>
            <backupLists>
                <backupList name="BackupSharepoint">
                    <add endpointName="Service1Backup" />
                </backupList>
                <backupList name="BackupFileshare">
                    <add endpointName="Service2Backup" />
                </backupList>
            </backupLists>
        </routing>
    </system.serviceModel>
</configuration>

The service file

The markup code of the service file needs to reference the RoutingService class and Routing assembly, rather than your own implementation/assembly, which would be the normal procedure. The code part can be just an empty implementation since it won’t be used.

<%@ 
    ServiceHost="" 
    Language="C#" 
    Debug="true" 
    Service=
    "System.ServiceModel.Routing.RoutingService, 
    System.ServiceModel.Routing, 
    version=4.0.0.0, 
    Culture=neutral, 
    PublicKeyToken=31bf3856ad364e35" 
%>

Final remarks

To summarize, we’ve shown how it is possible to overcome some of the limitations with a single web service endpoint through the use of WCF Routing. The fact that the router itself is still a single point of failure can be overcome through other load balancing mechanics like NLB.

If you want to learn more about how to customize search with content enrichment, check out the official documentation on MSDN, and the other blog posts on content enrichment.