Steve Fox's OBA Ramblings : SharePoint development

Sharepoint 2010 development using bcs

Steve Fox — Sat, 26 Dec 2009 02:15:28 GMT

One of the big features for SharePoint 2010 (and for building OBAs) is the Business Connectivity Services (BCS). I’ve written a few posts on this, but wanted to follow up on these early posts with some additional detail on how to create a solution leveraging web services. I see many customers trying to tie together SharePoint with external systems using a service-oriented design.

In this post, I’ll walk through how you can leverage a web service using the BCS (specifically employing the BDC Model project template in VS 2010) to create a read-only relationship with an external data source. This will be the first post in a series that will eventually cover the broad CRUD spectrum. So, let’s get down to it.

The high-level process you will want to go through is as follows:

Create the data source;
Create a service that interacts with your data source;
Create the external content type using VS 2010; and
Use the external content type in SP 2010 to create a web-service enabled external list.

Creating the Data Source

In this example, the data source is a SQL Server db with a single table with five records—see figure below. The number of records are less important than the structure of the columns.

You can choose to use something similar or create something different. If you use the code in this blog-post and you’re new to this, then create a db table with a similar structure. The following shows the data types in this simple table.

You create the new data source in SQL Server 2008 by right-clicking the Databases node and selecting New Database. Design your columns as per the above and then save the db when complete.

Creating the Web Service

With your db created, you now want to create a web service to interact with that db. We’ll create an ASP.NET service in this example to again keep things simple. (Note that you could equally apply much of the code to a WCF service.)

Open Visual Studio 2010 and create a new ASP.NET service application. You’ll want to add a new data source as an entity model. You can do this by click Data and then Add Data Source and then walking through the new data source wizard. I called my new data model CustomerSale—see the figure below to understand how Visual Studio interprets the data types.

You’ll need an in-memory object, so right-click your project and click Add and then select Class. Call your class CustomerSalesInfo.cs (or <name>.vb) and then click OK. You want to map the properties of your object to that of the data source. Here is the code for that object. You’ll note that I didn’t map the data types exactly. I do some in-code translation of data types.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace CustomerServiceBCSApp
{
    public class CustomerSalesInfo
    {
        public string custID { get; set; }
        public string custName { get; set; }
        public string custEmail { get; set; }
        public string custRegion { get; set; }
        public string custFY08Sales { get; set; }
        public string custFY09Sales { get; set; }
    }
}

Now you can write some code in your core service class. As this blog post is about read only, it will cover two web methods: one for reading the entire list and another for reading one item in a list. You’ll note that you require these two methods to create an external content type using BCS. In the code below, note that I’m creating a data context for my entity model called myCustomerData and there’s a class-level list collection I’m also creating called myCustomerList. The list collection is what I use to build out and populate my in-memory object (which I’ll return in the getAllCustomers() method. In fact, in the getAllCustomers() method I simply use a LINQ statement to query and get all of the data in the data context, and then I iterate through the members of the var returnListOfData object to creater my in-memory object. You may choose another method here (maybe even foregoing the in-memory object) to optimize your code. I pass no parameters to the getAllCustomers method as this is my, so to speak, “SELECT *” statement.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;

namespace CustomerServiceBCSApp
{

    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]

    public class Service1 : System.Web.Services.WebService
    {
        CustomersEntities myCustomerData = new CustomersEntities();
        List<CustomerSalesInfo> myCustomerList = new List<CustomerSalesInfo>();

        [WebMethod]
        public List<CustomerSalesInfo> getAllCustomers()
        {
                var returnListOfData = (from customer in myCustomerData.CustomerSales
                                  select customer).ToArray();

                foreach (var cust in returnListOfData)
                {
                    CustomerSalesInfo tempCustomer = new CustomerSalesInfo();
                    tempCustomer.custID = cust.CustomerID.ToString();
                    tempCustomer.custName = cust.CustomerName.ToString();
                    tempCustomer.custEmail = cust.CustomerEmail.ToString();
                    tempCustomer.custRegion = cust.CustomerRegion.ToString();
                    tempCustomer.custFY08Sales = cust.CustomerFY08Sales.ToString();
                    tempCustomer.custFY09Sales = cust.CustomerFY09Sales.ToString();
                    myCustomerList.Add(tempCustomer);
                };

return myCustomerList;
}

        [WebMethod]
        public string[] getACustomer(string strparamCustomerID)
        {
            int tempIntCustomerIDParam = Int32.Parse(strparamCustomerID);
            string[] myCustomerList = new string[6];

            var returnIndiviualDataItem = (from customer in myCustomerData.CustomerSales
                                .Where(x => x.CustomerID == tempIntCustomerIDParam)
                                           select customer);

            foreach (var cust in returnIndiviualDataItem)
            {
                myCustomerList[0] = cust.CustomerID.ToString();
                myCustomerList[1] = cust.CustomerName.ToString();
                myCustomerList[2] = cust.CustomerEmail.ToString();
                myCustomerList[3] = cust.CustomerRegion.ToString();
                myCustomerList[4] = cust.CustomerFY08Sales.ToString();
                myCustomerList[5] = cust.CustomerFY09Sales.ToString();
            }

return myCustomerList;
}

}
}

The second method takes a string parameter (a customer ID) and then builds a LINQ query based on that parameter. In this instance, I wanted to use a string array that I can easily parse on the other side. I do prefer to leverage generics wherever possible because I like the flexibility of dynamic collections as opposed to hard-coded lengths, but for this sample I though it interesting enough to show both examples.

Once you’ve gotten this far, you can test out the web service to make sure it runs. Test it from VS 2010 and then deploy it to IIS. To do this, create a new folder in your wwwroot folder (I called mine SPConnections) and then publish your service to that directory.

To publish the service, right-click your web service project select Publish and complete the options in the Publish Web dialog. Specifically, change the Publish Method to File System and then point the Target Location to the folder you just created under wwwroot.

Click Publish to publish the service to that directory. Now, any time you make changes you can simply click Publish and your service definition and code will be updated.

Since you’ve published your service to the file system, you’ll now want to create a web application in IIS that points to this service. To do this, open IIS and right-click the Sites node and select Add Web Site. Provide a name for the site, map the physical path to the folder under wwwroot (where you published your service to), give the site a unique port (e.g. 1111), click the Connect As button to provide the appropriate permissions for the service. (Note that you may have issues accessing the SQL Server if you have not configured the App Pool correctly—e.g. you can access using Local System or Network Service as opposed to the native Application Pool Identity.) Enable Windows Forms authentication by clicking Authentication and then clicking Windows and then Enable.

To test the service from IIS, click the Content tab and then right-click Service1.asmx and select Browse. You should be able to execute both methods—one to get all of the customers in your db and the other (by passing a customer ID that exists within your db) to get a specific customer.

Creating the External Content Type (ECT)

You’ll create the ECT using the new BDC Model project. To find this, click File, New, Project, and then in the SharePoint 2010 folder select Business Data Connectivity Model. Provide a name for your project and click OK.

Using this template is a little different from SharePoint Designer (SPD) 2010, which also enables you to build out ECTs. My personal feeling is that SPD is a little easier to create the ECTs, but then if you want to have more complex projects that perhaps leverage other parts of the .NET Framework then using the VS project is better. Note that VS also deploys the ECT (and all associated code) as a feature as opposed to an XML file to the Metadata Store (as is the case with SPD 2010).

Okay, now you have your project set up you need to edit the Entity1 object to map to your external data source entity. You’ll note that I’ve kept a lot of the default namespaces and objects in this example. I’ll change these in future posts and keep you apprised as to the places you’ll need to look out for when trying to update/change these. To follow is what your Entity1 should now look like.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WroxTestBDC.BdcModel1
{
        public partial class Entity1
    {
        public string Identifier1 { get; set; }
        public string custName { get; set; }
        public string custEmail { get; set; }
        public string custRegion { get; set; }
        public string custFY08Sales { get; set; }
        public string custFY09Sales { get; set; }
    }
}

As a general rule of thumb, as soon as you’ve made the change to your Entity1 object go immediately to your .bdcm (the ECT model) and amend the entity structure there as well, or your deploy will fail. Also note that the way in which you edit your methods should actually correspond to the code-behind. For example, the structure of my ReadItem method (which is where I’ll call my getACustomer web method) passes the Identifier1 parameter and returns an object from my database via the web method. Similarly, the ReadList method will return a list of objects, and it defines this return object through the Entity1List object in the taxonomy below.

Now, note again I’m only doing a read-only transaction—mostly because this is a good jumping off point but also because these two methods are created by default for you.

Okay, before we jump to the code behind add a reference to the web service. To do this, right-click the BCS project and select Add Service Reference. Add the URL to the service (copy and paste the URL from your IIS browse) in the Service field, provide a name for your service and click OK.

At this point, you are now ready to implement the service (i.e. the two web methods you created) in the VS project.

Navigate to the Entity1Service.cs file and make sure your code looks like the following code snippet. You can see that I create an instance of the service and then call the appropriate method on that service to return the code from my external data source. Note that in the case of the ReadItem method, it takes a string parameter (which would get activated when you click on a record in the external list). I’ve changed the default IEnumerable return object to use my preferred List<> object (which is essentially a list collection of the Entity1 object).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using WroxTestBDC.CustomerSalesWS;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Linq;

namespace WroxTestBDC.BdcModel1
{
    public class Entity1Service
    {
        public static Entity1 ReadItem(string id)
        {
            CustomerSalesWS.Service1SoapClient myWSProxy = new CustomerSalesWS.Service1SoapClient();
            string[] returnedData = new string[6];
            returnedData = myWSProxy.getACustomer(id).ToArray();

Entity1 entity1 = new Entity1();

            entity1.Identifier1 = id;
            entity1.custName = returnedData[1];
            entity1.custEmail = returnedData[2];
            entity1.custRegion = returnedData[3];
            entity1.custFY08Sales = returnedData[4];
            entity1.custFY09Sales = returnedData[5];

return entity1;
}

        public static List<Entity1> ReadList()
        {
            CustomerSalesWS.Service1SoapClient myWSProxy = new CustomerSalesWS.Service1SoapClient();
            var salesData = myWSProxy.getAllCustomers();

List<Entity1> mySalesInfoList = new List<Entity1>();

            foreach (var item in salesData)
            {
                Entity1 tempEntity = new Entity1();
                tempEntity.Identifier1 = item.custID.ToString();
                tempEntity.custName = item.custName.ToString();
                tempEntity.custEmail = item.custEmail.ToString();
                tempEntity.custRegion = item.custRegion.ToString();
                tempEntity.custFY08Sales = item.custFY08Sales.ToString();
                tempEntity.custFY09Sales = item.custFY09Sales.ToString();
                mySalesInfoList.Add(tempEntity);
            }

return mySalesInfoList;
}

}
}

At this point, you can build and deploy the ECT by right-clicking the project and selecting Deploy.

Before you go to SharePoint, one thing you’ll need to make sure you do is to copy the property settings for your system.serviceModel in your app.config file to your SharePoint’s web.config file—else you will get nasty web configuration errors.

<system.serviceModel>
        <bindings>
            <basicHttpBinding>
                <binding name="Service1Soap" closeTimeout="00:01:00" openTimeout="00:01:00"
                    receiveTimeout="00:10:00" sendTimeout="00:01:00" allowCookies="false"
                    bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard"
                    maxBufferSize="65536" maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
                    messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered"
                    useDefaultWebProxy="true">
                    <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                        maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                    <security mode="None">
                        <transport clientCredentialType="None" proxyCredentialType="None"
                            realm="" />
                        <message clientCredentialType="UserName" algorithmSuite="Default" />
                    </security>
                </binding>
            </basicHttpBinding>
        </bindings>
        <client>
            <endpoint address="http://localhost:289/Service1.asmx" binding="basicHttpBinding"
                bindingConfiguration="Service1Soap" contract="CustomerSalesWS.Service1Soap"
                name="Service1Soap" />
        </client>
    </system.serviceModel>

After this, you are now ready to create the external list in SharePoint 2010 using your newly create web-service enabled ECT.

Creating the External List

You can now create the external list in SharePoint. To do this, click the All Site Content link and click Create. Then in the Create options, click List and click External List. Click Create.

When the External List page opens, provide a name for the list and then in the External Content Type field click the right-most icon to browse for external content types that have been deployed to SharePoint. Click Create when complete.

At this point, your external list will have been created. The two read operations will enable you to have the full list of your records in the Customers database (via web service) rendered in the list—see below.

And if you click on one of the records it will display the individual record—see below.

And there you have it. You now have a web-service enabled external list.

In future posts, I will show you how to add new web methods to handle update, create and delete and then add the corresponding code in the BDC project you just created.

But for now, enjoy your holiday dinners!

Steve

get trained with Sharepoint 2010 and office 2010 videos

Steve Fox — Sat, 05 Dec 2009 17:01:11 GMT

One of the charters of my team is to make sure that we provide collateral for developers to get up and running with a program called Metro—an early adoption program for ISVs (to sign up for Metro or get more information, you can email metroreq@microsoft.com). Part of this program is creating things like training videos, Hands-on labs, and source-code; all for the developer to get up to speed quickly and efficiently with SharePoint and Office 2010. (We also cover CRM and UC.)

One of the first publicly-facing things we’ve done is to begin posting our PowerPoint decks and SharePoint and Office 2010 developer videos on Channel 9 in our new Learning Centers as a complement to other collateral that is out there today. There are some great videos here that you can watch for 10-15 minutes at a time. To get them, navigate to the top-level learning center on Channel 9 (http://channel9.msdn.com/learn/ or go straight to the either of the learning centers:

SharePoint 2010: http://channel9.msdn.com/learn/courses/SharePoint2010Developer/

Office 2010:

http://channel9.msdn.com/learn/courses/Office2010/

There are some great videos here, and the guys (Donovan Follette and Paul Stubbs) have done a fantastic job rallying this content.

There’ll be more to come with full downloadable packages coming next week and hands-on labs and source code coming at the beginning of January.

Happy Coding!

Steve

Tweeting from SharePoint 2010 Visual Web Part

Steve Fox — Wed, 02 Dec 2009 01:12:00 GMT

I’m still trying to get into the whole Tweet thing, so in an attempt to dig into it a little I took a look at the API and found out it’s pretty functional. My version of a Hello World app was having the ability to call the REST Twitter API to update my status on Twitter. I figure if I can figure out how to integrate this social networking experience into my daily routine, then why not.

To get started, I downloaded the .NET Twitter API wrapper—this makes it super easy to build .NET-based apps that communicate with Twitter. You can get it here. After you’ve downloaded the DLL, open Visual Studio 2010 and create a new Visual Web Part project. Add a reference to the Twitter.Framework.dll and then create your UI. My UI look somewhat el lamo, as you can see from the below:

However, design skills notwithstanding, I put together a fairly straightforward UI which made coding it up easy. The main (non-production) code I added is bolded as follows:

using System;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

using Twitterizer;

using Twitterizer.Framework;

namespace MyTwitterFeedWebPart.TwitterWebPart

{

public partial class TwitterWebPartUserControl : UserControl

{

string strTweet = "";

string myTweetUsername = "";

string myTweetPassword = "";

protected void Page_Load(object sender, EventArgs e)

{

}

protected void btnTweet_Click(object sender, EventArgs e)

{

myTweetUsername = txtUsername.Text;

myTweetPassword = txtPassword.Text;

strTweet = txtbxTweet.Text;

Twitter myTweet = new Twitter(myTweetUsername, myTweetPassword);

myTweet.Status.Update(strTweet);

}

protected void btnClear_Click(object sender, EventArgs e)

{

txtbxTweet.Text = "";

txtPassword.Text = "";

txtUsername.Text = "";

}

When you deploy and run the sample app, you have a functional web part app that enables you to submit tweets from your web part and post them to your Twitter account.

Yeah, success:

How useful is this in the long-term? Well, that remains to be seen…but it does begin to show you that integrating with SharePoint 2010 is definitely possible. You’d want to obviously add checks like character length of tweet < 140, tweet signing, Internet connectivity check, etc., etc., but the .NET wrapper enables you to do some powerful integrations.

Happy coding!

Steve

Technorati Tags: MSDN,SharePoint 2010,Twitter,SharePoint development,SharePoint visual web part

VSLive Virtual SharePoint 2010 Conference

Steve Fox — Sat, 07 Nov 2009 16:32:00 GMT

I participated in a virtual conference this week that was all about SharePoint 2010. I presented a couple of sessions, one on a Developer Roadmap and the other on the Developer Tools. I posted the decks here:

http://cid-40a717fc7fcd7e40.skydrive.live.com/browse.aspx/VSLive%5E_Virtual

I’m cleaning up some of the code and will post before the Beta 2 becomes available.

Cheers,

Steve

Retrieve SharePoint List Data with XLINQ using VS 2010 Beta 1

Steve Fox — Wed, 17 Jun 2009 22:30:28 GMT

One of the key things you’ll likely want to do with SharePoint is interact a lot with lists. In earlier posts on this blog, I’ve discussed adding data to a SharePoint list using both custom and native SharePoint services (i.e. services that ship with either WSS or MOSS—when I say SharePoint I include both of these SharePoint pieces). A recent post got me thinking about how to not only retrieve data from SharePoint, but then having the ability to take that data offline (e.g. save to a file) or to use it in-memory for other types of processing (e.g. filtering/management within a UI), so I put together a small application that does a couple of things:

1. Retrieves data from a SharePoint list using the Lists web service (a service native to SharePoint 2007);

2. Uses XML to add items to a custom object; and

3. Uses LINQ to query the object and filter/manage into a XAML UI.

All this using the latest Visual Studio 2010 Beta bits.

First, let’s take a quick look at the SharePoint list. It’s called “Products” and lives on my test SharePoint server (“http://stefoxdemo”). You can see a cropped screenshot of the list. It’s pretty simple and should be thought of as such because we really just want to show data coming from the list—not hoards of data.

If you’ve never created a list, you open SharePoint, navigate to your home page, click View All Site Content, click Create, and under Custom Lists click Custom List. Complete the Name and Description fields for your new list and click Create.

Now that you’ve created the list, open Visual Studio 2010 and click File, New Project. Select WPF Application and provide a name (e.g. MySharePointData) and location for your project and click OK—see the figure below.

We’re going to keep things simple here and add nine controls to the WPF UI:

Four labels
One listbox
Two textboxes
Two buttons

If you inspect the XAML code below, you’ll see that this is the resulting code that was generated from me dragging and dropping controls from the VS 2010 Toolbox onto the XAML designer. Check out the different properties of the controls.

The resulting UI from the above code looks like the following:

Once you’ve created your WPF UI, you now will want to add some code-behind to actually do something. The first thing you’ll want to do is to add the SharePoint Lists web service. This provides you with the ability to interact with lists and data in your lists. You can see from the figure below the subset of methods that are available to you. To add the web service to the VS 2010 project, right click References and select Service References. Click Advanced and then click Add Web Reference, and then discover the Lists web service by clicking Web Services on the Local Machine (or entering the service URL in the URL: field, e.g. “http://stefoxdemo/_vti_bin/Lists.asmx”). Provide a name for the service reference (e.g. SPListGetData) and click Add Reference. You now have a reference added to the Lists web service and can use it in code.

One thing I used in my solution was a custom object, which I used to store (in-memory) a list collection of the different elements in my list. This allowed me to use the collection of objects later and run a simple LINQ query against it. To add an object, right-click the project node and select Add, and then select Class.

The custom object comprises three strings (mapping to the three parts of my SharePoint list): 1) a title (or product name), 2) a product number, and 3) a sales figure. The code I have for my custom object is as follows—note that I’ve set the properties on my object to both read/write, but in this file all we’re really doing is reading.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MySharePointData
{
   public class MySPData
    {
        public string clsTitle { get; set; }
        public string clsProductNum { get; set; }
        public string clsSales { get; set; }
    }
}

After you’ve added the class to the project, you can now add some of the heavier-weight code. This code is going to set some class-level variables, use the Lists web service to get the data in my list, iterate through the list and use XLINQ to create and populate the custom object, and then if the user changes the selection on the list the fields will be updated through a LINQ query.

Let’s start with the class-level variables. I’ve added a string to represent the selected item in the listbox, a list collection object (which will be in-memory collection object) called lstSPData, and the declaration of an XDocument (called myXMLDoc), which will be used as the document to which I’ll add the items from the SharePoint list.

…

string strSelectedItem = "";

List<MySPData> lstSPData = new List<MySPData>();

XDocument myXMLDoc = new XDocument();

…

Once you’ve added these three top-level items to the class, you’ll want to double-click on one of the buttons you added to the UI and then add some code for that. In my case, the name of the button was btnGetData and the subsequent event was called btnGetData_Click. The code below shows what I added into that method. There are a few things that are interesting in the code. For example, note that one of the first things we do is create a proxy for the web service, pass my default credentials to call the service (SharePoint must know who you are even at the service level), and then uses an XMLNode object to get all of the items from the Products list. You’ll then also see that I’ve began creating an XML object, but creating an XElement and then setting the declaration type of the XML Document I created earlier. Then to get the data out of the object, you iterate through the nodes and grab the inner text of the XML. In this case, you need to be sure you’re pulling from the SharePoint XML (this is the “ows_Title,” “ows_ProductNum,” and “ows_Sales”). From there on, two major things are happening. The first is that I’m reassigning the XML data from the object being passed back from the web service call with some XML that I’m more comfortable with (and a structure that I prefer to work with), and then I’m creating an instance of the custom object I created and then am populating the list collection for that custom object as I iterate through each of the XML nodes of the returned XML data. You’ll then see two lines of code lying outside of the foreach statement, and this is where I’m first adding the more comfortable version of the XML data to my originally-created XML document, and then I’m saving that XML document to a file share.

private void btnGetData_Click(object sender, RoutedEventArgs e)
{

    MySharePointData.SPListGetData.Lists proxy = new MySharePointData.SPListGetData.Lists();
    proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
    proxy.Url = "http://stefoxdemo/_vti_bin/Lists.asmx";

XmlNode myLIstItems = proxy.GetListItems("Products", null, null, null, null, null, null);

XElement newRootElement = new XElement("NewData");

myXMLDoc.Declaration = new XDeclaration("1.0", "utf-8", "true");

foreach (XmlNode outerNode in myLIstItems.ChildNodes)
{

if (outerNode.NodeType.Equals(System.Xml.XmlNodeType.Element))
{

foreach (XmlNode node in outerNode.ChildNodes)
{

if (node.NodeType.Equals(System.Xml.XmlNodeType.Element))
{

                    XmlNode listFieldTitle = node.Attributes.GetNamedItem("ows_Title");
                    XmlNode listFieldProductNum = node.Attributes.GetNamedItem("ows_ProductNum");
                    XmlNode listFieldSales = node.Attributes.GetNamedItem("ows_Sales");

                    string strListFieldTitle = listFieldTitle.InnerText;
                    string strListFieldProductNum = listFieldProductNum.InnerText;
                    string strListFieldSales = listFieldSales.InnerText;

                    XElement xmlData = new XElement("MyData",
                            new XElement("Title", strListFieldTitle),
                            new XElement("ProductNum", strListFieldProductNum),
                            new XElement("Sales", strListFieldSales));

newRootElement.Add(xmlData);
lstBxProducts.Items.Add(strListFieldTitle);

MySPData clsSPDataInstance = new MySPData();

                    clsSPDataInstance.clsTitle = strListFieldTitle;
                    clsSPDataInstance.clsProductNum = strListFieldProductNum;
                    clsSPDataInstance.clsSales = strListFieldSales;
                    lstSPData.Add(clsSPDataInstance);

                }
            }
        }

}

myXMLDoc.Add(newRootElement);
myXMLDoc.Save("c:\\SPData\\MySharePointData.xml");
}

The key takeaway from this, though, is that there are now two data structures in this app: one that I’ve created as an XML file and saved to disk (or alternatively could be used to inject into another program, say a Word document through Open XML); and one that now represents a list collection of the custom object—this is my in-memory version of the data that I can use for querying.

The next bit of code we’ll look at handles the user interacting with the listbox; that is, when the user changes their selection this will invoke the lstBxProducts_SelectionChanged event, which triggers the following code. This code is fairly straight-forward. I’ve set three string variables as temporary variables, grabbed the currently selected item in the listbox (and am storing it in strSelectedItem) and then am using a LINQ query to get the other data in the record that maps to the product name selected in the listbox. Given the fact that this results in a list of one record, I’m then using the First method to grab the first (and only) element in that record and assigning the text property of the controls to those strings.

private void lstBxProducts_SelectionChanged(object sender, SelectionChangedEventArgs e)
   {
       string strTempTitle = "";
       string strTempProductNum = "";
       string strTempSales = "";

strSelectedItem = lstBxProducts.SelectedItem.ToString();

       var lstXMLObject = from lstXML in lstSPData
                          where lstXML.clsTitle == strSelectedItem
                          select new
                          {
                              strTempTitle = lstXML.clsTitle,
                              strTempProductNum = lstXML.clsProductNum,
                              strTempSales = lstXML.clsSales

};

txtBxProductNum.Text = lstXMLObject.First().strTempProductNum;
txtBxSales.Text = lstXMLObject.First().strTempSales;

}

The finished product results in the following cool and slick (okay, not so much…but functional) WPF UI first getting SharePoint list data and then allowing you to query that data in the context of your whiz-bang UI. Note that it also saves the XML to your local file system. When you F5, you should see the following UI. Click the Get Data button, which triggers the service call. This will populate the Product Name listbox and subsequently allow you to click on an item in the listbox and filter on that item.

If you browse to the location where you saved your XML file (in my case this was c:\SPData), you will find an XML file that hopefully resembles the data you have in your list.

<?xml version="1.0" encoding="utf-8"?>
<NewData>
<MyData>
    <Title>ALK-Bike Crank</Title>
    <ProductNum>0398021</ProductNum>
    <Sales>$209,002.98</Sales>
</MyData>
<MyData>
    <Title>OUU-Bicycle Riding Helmet</Title>
    <ProductNum>38271920</ProductNum>
    <Sales>$901,199.23</Sales>
</MyData>
<MyData>
    <Title>YTT-Road Bicycle Wheel</Title>
    <ProductNum>03929901</ProductNum>
    <Sales>$890,872.12</Sales>
</MyData>
<MyData>
    <Title>HGT-Off-Road Bike Gear Pack</Title>
    <ProductNum>3746281</ProductNum>
    <Sales>$459,922.10</Sales>
</MyData>
<MyData>
    <Title>BKP-Bianchi Racing Bike</Title>
    <ProductNum>3902443</ProductNum>
    <Sales>$2,019,100.29</Sales>
</MyData>
</NewData>

Lastly, the Exit button you see on my UI also calls a method; basically a simple method to exit the application. The code for this is as follows:

private void btnExit_Click(object sender, RoutedEventArgs e)
{
Application.Current.Shutdown();
}

And that’s it! Wasn’t that fun? I thought so. For your reference, the entire code sample from the core Windows.xaml.cs file is pasted below.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Xml;
using System.Xml.Linq;

namespace MySharePointData
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
        string strSelectedItem = "";

List<MySPData> lstSPData = new List<MySPData>();

XDocument myXMLDoc = new XDocument();

        private void btnGetData_Click(object sender, RoutedEventArgs e)
        {

            MySharePointData.SPListGetData.Lists proxy = new MySharePointData.SPListGetData.Lists();
            proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
            proxy.Url = "http://stefoxdemo/_vti_bin/Lists.asmx";

            XmlNode myLIstItems = proxy.GetListItems("TR8", null, null, null, null, null, null);
            //Creation
            XElement newRootElement = new XElement("NewData");
            myXMLDoc.Declaration = new XDeclaration("1.0", "utf-8", "true");

foreach (XmlNode outerNode in myLIstItems.ChildNodes)
{

if (outerNode.NodeType.Equals(System.Xml.XmlNodeType.Element))
{

foreach (XmlNode node in outerNode.ChildNodes)
{

if (node.NodeType.Equals(System.Xml.XmlNodeType.Element))
{

                            XmlNode listFieldTitle = node.Attributes.GetNamedItem("ows_Title");
                            XmlNode listFieldProductNum = node.Attributes.GetNamedItem("ows_ProductNum");
                            XmlNode listFieldSales = node.Attributes.GetNamedItem("ows_Sales");

                            string strListFieldTitle = listFieldTitle.InnerText;
                            string strListFieldProductNum = listFieldProductNum.InnerText;
                            string strListFieldSales = listFieldSales.InnerText;

                            XElement xmlData = new XElement("MyData",
                                    new XElement("Title", strListFieldTitle),
                                    new XElement("ProductNum", strListFieldProductNum),
                                    new XElement("Sales", strListFieldSales));

                            newRootElement.Add(xmlData);
                            //tempAll = strListFieldTitle + " " + strListFieldProductNum + " " + strListFieldSales;
                            lstBxProducts.Items.Add(strListFieldTitle);

MySPData clsSPDataInstance = new MySPData();

                            clsSPDataInstance.clsTitle = strListFieldTitle;
                            clsSPDataInstance.clsProductNum = strListFieldProductNum;
                            clsSPDataInstance.clsSales = strListFieldSales;
                            lstSPData.Add(clsSPDataInstance);

                        }
                    }
                }

}

myXMLDoc.Add(newRootElement);
myXMLDoc.Save("c:\\SPData\\MySharePointData.xml");

MessageBox.Show("XML Data Saved to File!");
}

        private void btnExit_Click(object sender, RoutedEventArgs e)
        {
            Application.Current.Shutdown();
        }

        private void lstBxProducts_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            string strTempTitle = "";
            string strTempProductNum = "";
            string strTempSales = "";

strSelectedItem = lstBxProducts.SelectedItem.ToString();

            var lstXMLObject = from lstXML in lstSPData
                               where lstXML.clsTitle == strSelectedItem
                               select new
                               {
                                   strTempTitle = lstXML.clsTitle,
                                   strTempProductNum = lstXML.clsProductNum,
                                   strTempSales = lstXML.clsSales

};

txtBxProductNum.Text = lstXMLObject.First().strTempProductNum;
txtBxSales.Text = lstXMLObject.First().strTempSales;

}
}
}

Happy coding!

Quick Announcement: ODC is being Wrapped into SPC

Steve Fox — Mon, 08 Jun 2009 05:15:00 GMT

Hey gang,

Just a quick announcement, if you attended the Office Developer Conference (ODC) last year you may be wondering what happened to it this year? Well, it's going to be subsumed within the SharePoint Conference (SPC), which is happening October 19th-22nd. This is actually going to be great because that means you'll be able to get all of the latest SharePoint and Office development sessions in one conference--what we call the Twofer deal! More info can be found here: http://blogs.msdn.com/sharepoint/archive/2009/06/01/office-developer-conference-moving-to-sharepoint-conference-2009.aspx.

Cheers,

Steve

Using Media Streaming Services to Integrate Silverlight with SharePoint

Steve Fox — Sat, 28 Mar 2009 20:02:00 GMT

One of the cool things about the Media Streaming Services is that you can circumvent some of the server set-up for SharePoint and still integrate a Silverlight (SL) app into your SharePoint (SP) site. By using the Media Streaming Services, which are free by the way, you can integrate a cool little SL app into your SP site and then simply use the <iframe> code that is auto-generated to integrate the SL app into a Content Editor Web Part.

To complete this integration requires four main steps:

Create the SL app;
Add the SL app to your Media Streaming Services site;
Configure the app and grab the <iframe> code; and
Use the Content Editor Web Part to integrate the SL app with SP.

Let’s do a quick walk through to help get you started.

The Silverlight App

We’ll first assume that you’ve got the SL app created. I created a simple app that uses the Community toolkit to render a simple chart. You can get more information on this here: http://www.codeplex.com/Silverlight. I ensured the correct DLLs were registered in my GAC and then added the appropriate references in my SL app to create a somewhat interesting looking chart. The project contains an object called SharePointData.cs (an oddly named class that represents the items that will be displayed in my chart, which in this app is a set of courses in my bucket of course inventory). Note in the figure below the DataVisualization and Theming DLLs that have been added as references in the project. (I tweaked Tim’s example from his blog-post here.)

The custom class code is as follows:

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.ComponentModel;

namespace BarChart
{
public class SharePointData
{

public class CourseData
{

public string TrnCourse { get; set; }
public int NumCourseSales { get; set; }

}

        public static List<CourseData> loadChartData()
        {
            List<CourseData> courseList = new List<CourseData>();

            courseList.Add(new CourseData() { NumCourseSales = 17, TrnCourse = "VSTS-399" });
            courseList.Add(new CourseData() { NumCourseSales = 39, TrnCourse = "OFC2-214" });
            courseList.Add(new CourseData() { NumCourseSales = 67, TrnCourse = "SQL1-151" });
            courseList.Add(new CourseData() { NumCourseSales = 13, TrnCourse = "ARCH-402" });
            courseList.Add(new CourseData() { NumCourseSales = 53, TrnCourse = "DEV1-164" });
            courseList.Add(new CourseData() { NumCourseSales = 42, TrnCourse = "VSP1-010" });
            courseList.Add(new CourseData() { NumCourseSales = 15, TrnCourse = "SPDEV-302" });
            courseList.Add(new CourseData() { NumCourseSales = 31, TrnCourse = "SPARC-201" });
            courseList.Add(new CourseData() { NumCourseSales = 29, TrnCourse = "SPD1-159" });
            courseList.Add(new CourseData() { NumCourseSales = 44, TrnCourse = "SPD2-203" });
            courseList.Add(new CourseData() { NumCourseSales = 44, TrnCourse = "AZUR-227" });
            courseList.Add(new CourseData() { NumCourseSales = 42, TrnCourse = "OFC3-365" });
            courseList.Add(new CourseData() { NumCourseSales = 32, TrnCourse = "VBA1-102" });
            courseList.Add(new CourseData() { NumCourseSales = 13, TrnCourse = "WEBD-838" });

return courseList;

}

}
}

The XAML code that renders the chart is as follows:

And the code-behind for the SL app is as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Ink;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Windows.Controls.DataVisualization.Charting;
using Microsoft.Windows.Controls.DataVisualization;
using Microsoft.Windows.Controls.Theming;
using System.Collections.ObjectModel;

namespace BarChart
{
public partial class Page : UserControl
{

        List<SharePointData.CourseData> cr = new List<SharePointData.CourseData>();
        public Page()
        {
            InitializeComponent();

            cr = SharePointData.loadChartData();
            ColumnSeries column = MyBarChart.Series[0] as ColumnSeries;
            column.ItemsSource = cr;
        }
    }
}

Note that you could likely remove a number of the Using statements to optimize your code.

With these three elements working together, you can run the application and you will get the following results:

The thing you want to do now is to get this to the Media Streaming Services.

Uploading the XAP File into the Media Streaming Services

After you build your SL app, you’ll want to upload the XAP file into the Media Streaming Services.

To do this, go to http://silverlight.live.com/ and sign in with your Live account. Then click on Manage Applications and click Upload Application. Provide a name for the file you’re going to upload, click Create and then browse to your XAP file (i.e. your SL app) and then upload it to the Streaming Media Services.

Configuring the SL App

You’ll then need to click the Create link to create a manifest for the SL app. For my example, I only filled out a couple of the fields (see below), but you could complete others and even configure things like background images if you wanted.

Click Update when you’re done. You’ll then be presented with a number of different options for embedding the SL app into your web page. I typically use the first one, but you can use any one of these that would match your needs. So, copy the code and we’ll move onto the final step in the process.

Use the Content Editor Web Part to integrate the SL app with SP

Go to your SP site and click Site Actions and Edit Page. Click Add a web part and then select Content Editor Web Part from the gallery.

Once the web part’s been added, click the Open in tool pane link to configure the web part. Click the Source Editor and then paste the <iframe> code into the editor, which should look something like the following (depending on how you’ve configured the SL app).

Click Save, and voila your new whizbang SL app should render via the Streaming Media Services site. You can use the source editor to adjust the height and width if need be, and you can set the Chrome Type to none if you want. I personally like the cleaner look with the standard Content Editor Web Part title on the web part chrome. The end result should be the following:

Pretty cool! I will also mention that this not only works for your SharePoint site on premises (i.e. the SP instance your company hosts), but this also works for SP Online as well—so it’s a very easy way to code custom apps for SP Online. Further, this alleviates the need to do a lot of the web.config changes (so you don’t need direct admin access to the SP server), which is always helpful when you’re trying to develop and deploy cool and funky little apps for your shazammy SP site.

Happy coding all, and I hope this post was useful.

Steve

Silverlight, SharePoint, Services…Oh Yeah!!!

Steve Fox — Sun, 15 Feb 2009 05:05:34 GMT

The last blog post I wrote was on interacting with SharePoint using services. One of the things that I’ve been quite involved in over the past year or so has been Silverlight and SharePoint integration. You will definitely see more of this type of development, so building off of my last post I decided to write a blog on consuming a web service with SharePoint.

That said, this blog post will walk you through how to create a Web service that integrates with the SharePoint object model and then uses that service in a Silverlight application (which we’ll embed within SharePoint). It is an excerpt from a wider Silverlight and SharePoint 1-day training that I’ve been building at work (with the help of Advaiya). It also complements a book Paul Stubbs and I just wrote called “Professional SharePoint 2007 Development using Silverlight 2.” You can check this book out here: http://www.amazon.com/Professional-Microsoft-SharePoint-Development-Silverlight/dp/0470434007/ref=sr_1_1?ie=UTF8&s=books&qid=1234663767&sr=8-1.

Note: I will cover WCF, Siverlight and SharePoint in a future blog post.

Your Environment

Before you begin, make sure you’ve got the following environment set up:

1. Your web.config supports Silverlight. Check out the SIlverlight and SharePoint Blueprint (http://www.codeplex.com/SL4SP) for more information as well as the recent MSDN article on this subject (http://msdn.microsoft.com/en-us/magazine/dd148643.aspx).

2. Windows Server 2003, 2008, Silverlight runtime, Silverlight Tools for VS 2008 SP 1, VS 2008 SP1, and VSeWSS 1.2.

Building the Service

The first thing you need to do is build the Web service. The Web service will be an ASMX-based web service (i.e. ASP.NET). (We will cover WCF-based services and Silverlight later on in the workshop.) To create the service, open Visual Studio 2008. Select File, New Web Site and then select ASP.NET Web Service. Choose the File System as the location and then select the language (e.g. Visual C#) and provide a path for the project. Click OK. Figure 1 provides a screenshot of the New Web Site dialog.

Figure 1: New Web Site Dialog

In Solution Explorer, change the names of the .asmx and .cs service files from the default Service.asmx and Service.cs (in the App_Code folder) to MyFirstSPService.asmx and MyFirstSPService.cs.

Figure 2: Renaming the Service Files

You’ll also need to update the class references and statements in the newly named files. For example, in MyFirstSPService.asmx ensure you have the following code:

<%@ WebService Language="C#" CodeBehind="~/App_Code/MyFirstSPService.cs" Class="MyFirstSPService" %>

And in the MyFirstSPService.cs file, ensure you have the following code:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Services;

[WebService(Namespace = "http://tempuri.org/")]

[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]

// To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.

// [System.Web.Script.Services.ScriptService]

public class MyFirstSPService : System.Web.Services.WebService

{

public MyFirstSPService () {

//Uncomment the following line if using designed components

//InitializeComponent();

}

[WebMethod]

public string HelloWorld() {

return "Hello World";

}

}

To make sure that your solution compiles, hit F5 or select Debug, Start Debugging on the Visual Studio 2008 menu. You may be prompted with the dialog in Figure 3. If you are, click OK.

Figure 3: Debugging Not Enabled

If your solution successfully compiles and debugs, you will be presented with the following debug screen.

Figure 4: Debug Screen

In the debug screen, you will see a link at the top representing the one web method (HelloWorld) that is available within the service. Click the HelloWorld link and then to test the service click the Invoke button—which returns a string with the value: “Hello World.” See Figure 5.

Figure 5: Invoking the Hello World Web Method

Now that you’ve tested the default service that is created for you when you create a Web service, go back to the Visual Studio project and replace the HelloWorld web method code with the following web method:

[WebMethod]

public void useNormalMOSSApi(string SalesSPSite, string productName, string productNumber, string FY08Sales)

{

string strDashListRoot = SalesSPSite;

using (SPSite site = new SPSite(strDashListRoot))

{

using (SPWeb web = site.OpenWeb())

{

web.AllowUnsafeUpdates = true;

SPList list = web.Lists["FY 09 Sales"];

SPListItem Item = list.Items.Add();

Item["Title"] = productName;

Item["ProductNum"] = productNumber;

Item["Sales"] = FY08Sales;

Item.Update();

}

}

}

This code essentially enables you to set the context for a SharePoint web site and then add data to three different columns (Title, ProductNum and Sales) in a list called FY 09 Sales.

When you add this code, you’ll get errors. This is because you need to add a reference to the Microsoft.SharePoint.dll. To do this, right-click the project name, select Add Reference and then select Windows SharePoint Services (as is shown in Figure 6) and click OK.

Figure 6: Add Reference Dialog

Note: In order for this service to work, you’d need to have created a custom list in SharePoint called “FY 09 Sales” with three columns of type Text called “Title,” “ProductNum,” and “Sales.” To do this, go to your SharePoint site and click View All Site Content at the root level site and then click Create. In the Custom Lists category, click Custom List. Make the Name “FY 09 Sales” and add a description to the Description field. When the list is created it will open by default. Click Settings and then select Create Column. Add each of the three aforementioned columns setting the type of information in the column to Single lines of text—see Figure 7.

Figure 7: Setting the Column Type

Getting back to the service, now that you’ve added the reference to the SharePoint DLL, add a using statement at the top of the class as follows:

using Microsoft.SharePoint;

The code errors should go away. The full MyFirstSPService.cs file should look like the following:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Services;

using Microsoft.SharePoint;

[WebService(Namespace = "http://tempuri.org/")]

[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]

// To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.

// [System.Web.Script.Services.ScriptService]

public class MyFirstSPService : System.Web.Services.WebService

{

public MyFirstSPService () {

//Uncomment the following line if using designed components

//InitializeComponent();

}

[WebMethod]

public void useNormalMOSSApi(string SalesSPSite, string productName, string productNumber, string FY08Sales)

{

string strDashListRoot = SalesSPSite;

using (SPSite site = new SPSite(strDashListRoot))

{

using (SPWeb web = site.OpenWeb())

{

web.AllowUnsafeUpdates = true;

SPList list = web.Lists["FY 09 Sales"];

SPListItem Item = list.Items.Add();

Item["Title"] = productName;

Item["ProductNum"] = productNumber;

Item["Sales"] = FY08Sales;

Item.Update();

}

}

}

}

To test this, build the web site solution. Hit F5 and then test out the web method.

Note: You must create the SharePoint list before you can successfully test out the service.

Figure 8: Testing the Service Call

If your service is successful, you should have a result similar to the following in your SharePoint list:

Figure 9: Service Result in SharePoint

Deploying the Service

Now that you’ve built the service, you need to deploy it. We’ll deploy it to IIS 7.0. If you’re using another version of IIS, the general process you’ll need to follow is to 1) Create a web site, 2) map the virtual path to the root web site path of the service, and 3) set permissions for the service.

Open IIS and then expand the Connections until you see the web sites. Right-click Web Sites and select Add Web Site. Give the site a name, for example MyFirstSPServiceIISSite and then map the physical path of the service you just created to the IIS web site. See Figure 10. Assign an unused port.

Note: To test the service out on the local environment, click Test Settings. This will tell you if the service is reachable. If you do not get to successful tests, you’ll need to adjust the Connect as… settings. One way is to explicitly set the calling service with your (that is the local Windows credentials) to make sure the call will succeed. You then also need to go to the Authentication option in the Features view and set Windows Authentication to Enabled. In a production environment, you’ll need to use different settings—potentially having a user (e.g. IIS_User) for your service and enabling ASP.NET Authentication.

Figure 10: Creating the IIS Site

When you‘ve done this, click View, Refresh and then select MyFirstSPServiceIISSite in the Web Sites list and select Content View. You should see something similar to Figure 11. To make sure you’ll be able to

Figure 11: Content View of Web Site in IIS

At this point, you’ll be able to right-click the MyFirstSPService.asmx file and select Browse. Test out the web method again to make sure you have another successful call in the service to the SharePoint site—see Figure 12.

Figure 12: Second Successful Call

While all the service testing at each step in the development process may seem monotonous, it is recommended as a good defensive programming practice. This way, if the service fails you have a better idea of where in the process it failed.

Building the Silverlight and SharePoint Application

Now that you’ve created the service, you can now create the client side application, which is the Silverlight application that will eventually be deployed to SharePoint. Let’s first create the Silverlight application.

Open Visual Studio 2008 and create a new solution, using the Blank Solution template. To do this, click File, New Project, and then select the Visual Studio Solutions and Blank Solution template. Provide a name for your solution and then click OK.

Figure 13: Creating a Blank Solution

Right-click the solution and then select Add ,New Project, and then in the Project Types category select Silverlight. In the Templates category select Silverlight Application and provide a name for your application, for example SPSilverlightClient.

Figure 14: New Silverlight Application

When prompted, just select Automatically generate a test page… as the test environment for the Silverlight application. You do not need the full web site for this solution. Navigate to the Page.xaml file and add the following XAML code to create your Silverlight UI.

<UserControl x:Class="SPSilverlightClient.Page"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Width="750" Height="380">

<Canvas x:Name="LayoutRoot">

<Canvas Width="550" Height="300">

<Path Width="550" Height="300" Canvas.Left="38" Canvas.Top="9" Stretch="Fill"

Data="F1 M 42.336,8.86813L 257.336,8.86813C 259.545,8.86813 261.336,10.659 261.336,12.8681L 261.336,77.8681C 261.336,80.0773 259.545,81.8681 257.336,81.8681L 42.336,81.8681C 40.1269,81.8681 38.336,80.0773 38.336,77.8681L 38.336,12.8681C 38.336,10.659 40.1269,8.86813 42.336,8.86813 Z ">

<Path.Fill>

<LinearGradientBrush StartPoint="0.75,0.7" EndPoint="0.75,-0.01">

<LinearGradientBrush.GradientStops>

<GradientStop Color="Azure" Offset="0"/>

<GradientStop Color="#FFDCDCDC" Offset="0.8"/>

<GradientStop Color="#FFC3C3C3" Offset="1"/>

</LinearGradientBrush.GradientStops>

</LinearGradientBrush>

</Path.Fill>

</Path>

</Canvas>

<TextBlock

Canvas.Left="50"

Canvas.Top="15"

FontFamily="Trebuchet MS"

FontWeight="Bold" FontSize="18"

Text="Sales Information for FY 09"

Foreground="#FFF3F3F3" />

<TextBlock

Canvas.Left="51"

Canvas.Top="16"

FontFamily="Trebuchet MS"

FontWeight="Bold" FontSize="18"

Text="Sales Information for FY 09"

Foreground="#FF666666" />



<TextBlock x:Name="txtBlckSites"

Canvas.Left="50"

Canvas.Top="50"

FontFamily="Trebuchet MS"

FontWeight="Bold" FontSize="12"

Text="Available SharePoint Sites: "

Foreground="#FF666666"/>

<ComboBox x:Name="cmboBoxOfferings"

Canvas.Left="210"

Canvas.Top="50"

Height="20"

Width="290"

DropDownClosed="cmboBoxOfferings_DropDownClosed">

<ComboBoxItem x:Name="optionOne">

<TextBlock x:Name="txtSPDev">

http://stefoxdemo

</TextBlock>

</ComboBoxItem>

<ComboBoxItem x:Name="optionTwo">

<TextBlock x:Name="txtVSDev">

http://sharepoint/sites/spotw

</TextBlock>

</ComboBoxItem>

<ComboBoxItem x:Name="OptionThree">

<TextBlock x:Name="txtSQLSRVDev">

http://sharepoint/sites/sp14

</TextBlock>

</ComboBoxItem>

<ComboBoxItem x:Name="OptionFour">

<TextBlock x:Name="txtAdvSPDev">

http://my/sites/stefox

</TextBlock>

</ComboBoxItem>

<ComboBoxItem x:Name="OptionFive">

<TextBlock x:Name="txtClientDev">

http://sharepoint/sites/signup

</TextBlock>

</ComboBoxItem>

</ComboBox>

<TextBlock

Canvas.Left="50"

Canvas.Top="90"

FontFamily="Trebuchet MS"

FontWeight="Bold" FontSize="12"

Text="Site Description: "

Foreground="#FF666666" />

<TextBlock x:Name="txtSiteDescr"

Canvas.Left="210"

Canvas.Top="90"

FontFamily="Trebuchet MS"

FontWeight="Bold" FontSize="12"

Text="Description Here."

Foreground="Black"

Width="290"

TextWrapping="Wrap"/>

<TextBlock

Canvas.Left="50"

Canvas.Top="130"

FontFamily="Trebuchet MS"

FontWeight="Bold" FontSize="12"

Text="Product Name: "

Foreground="#FF666666"/>

<TextBox x:Name="txtProductName"

Height="25"

Width="200"

Canvas.Left="210"

Canvas.Top="125"/>

<TextBlock

Canvas.Left="50"

Canvas.Top="170"

FontFamily="Trebuchet MS"

FontWeight="Bold" FontSize="12"

Text="Product Number: "

Foreground="#FF666666"/>

<TextBox x:Name="txtProductNum"

Height="25"

Width="200"

Canvas.Left="210"

Canvas.Top="165"/>

<TextBlock

Canvas.Left="50"

Canvas.Top="215"

FontFamily="Trebuchet MS"

FontWeight="Bold" FontSize="12"

Text="FY 09 Sales: "

Foreground="#FF666666"/>

<TextBox x:Name="txtFY08Sales"

Height="25"

Width="200"

Canvas.Left="210"

Canvas.Top="210"/>

<Button x:Name="btnWebServiceCall"

Height="25"

Width="60"

Content="Insert"

Canvas.Left="125"

Canvas.Top="260"

Click="btnWebServiceCall_Click"/>

<Button x:Name="btnFieldsClear"

Height="25"

Width="60"

Content="Clear"

Canvas.Left="215"

Canvas.Top="260"

Click="btnFieldsClear_Click"/>

</Canvas>

</UserControl>

When complete, your Silverlight client UI should similar to Figure 15.

Figure 15: Silverlight Client

Notice that there are a number of key events that are associated with some of the controls in the XAML code. These correspond to code-behind events in the Page.xaml.cs file. Before we jump to the code-behind, add a reference to the service you created earlier. To do this, right click References and select Add Service Reference. To get the service URL, you can go into your IIS view, right-click the ASMX file and select Browse. Copy and paste the URL from the browser to the Address field in the Add Service Reference dialog—see Figure 16.

Figure 16: Adding a Service Reference

With the service added to the Silverlight client application, you can now add the code-behind that maps to the Silverlight UI.

The first thing you’ll need is four class-level variables, which represent the data that we’re going to pass to the web method in our service.

string productName = "";

string productNumber = "";

string FY08Sales = "";

string SalesSPSite = "";

Then, you’ll need to add the other logic, which in the code to follow includes an event from the Insert button in the Silverlight UI and some logic that maps to the Clear button.

The web service call, which is triggered from the button, looks like the following:

private void btnWebServiceCall_Click(object sender, RoutedEventArgs e)

{

productName = txtProductName.Text;

productNumber = txtProductNum.Text;

FY08Sales = txtFY08Sales.Text;

SPSilverlightClient.ASMXUpdateSPList.MyFirstSPServiceSoapClient proxy = new SPSilverlightClient.ASMXUpdateSPList.MyFirstSPServiceSoapClient();

proxy.useNormalMOSSApiCompleted += new EventHandler<System.ComponentModel.AsyncCompletedEventArgs>(proxy_useNormalMOSSApiCompleted);

proxy.useNormalMOSSApiAsync(SalesSPSite, productName, productNumber, FY08Sales);

proxy.CloseAsync();

}

Note that Silverlight service calls are asynchronous, so you need to have a completed event, which in this application looks like the following:

void proxy_useNormalMOSSApiCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)

{

MessageBox.Show("Can you believe it? This stuff actually works!");

}

The code here obviously doesn’t do much other than issue a message to the user when the service call is complete. In production code, you would probably want to verify that there had been an update to the SharePoint list before issuing this type of message.

The btnFieldsClear_Click event, shown below, simply clears the user entries in the Silverlight UI.

private void btnFieldsClear_Click(object sender, RoutedEventArgs e)

{

txtFY08Sales.Text = "";

txtProductName.Text = "";

txtProductNum.Text = "";

}

You may also notice that there is an event that corresponds to the closing of the drop-down box. This is essentially place-holder code, but in reality should grab the text property of the selected item within the combo box and assign that value to SalesSPSite. However, since I only have one site to demo, I hard-coded the variable to always be that site.

private void cmboBoxOfferings_DropDownClosed(object sender, EventArgs e)

{

//Be warned...lazy hard-coded variable data to follow.

if (optionOne.IsSelected == true)

{

txtSiteDescr.Text = "FY 09 Sales Tracking Site";

SalesSPSite = "http://stefoxdemo";

}

else if (optionTwo.IsSelected == true)

{

txtSiteDescr.Text = "SharePoint on the Web Metrics";

SalesSPSite = "http://stefoxdemo";

}

else if (OptionThree.IsEnabled == true)

{

txtSiteDescr.Text = "Wave 14 Reports";

SalesSPSite = "http://stefoxdemo";

}

else if (OptionFour.IsEnabled == true)

{

txtSiteDescr.Text = "Personal Metrics";

SalesSPSite = "http://stefoxdemo";

}

else if (OptionFive.IsEnabled == true)

{

txtSiteDescr.Text = "Signage Reports";

SalesSPSite = "http://stefoxdemo";

};

}

If you were to look at the code-behind in its entirety, this is what it would look like:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

namespace SPSilverlightClient

{

public partial class Page : UserControl

{

string productName = "";

string productNumber = "";

string FY08Sales = "";

string SalesSPSite = "";

public Page()

{

InitializeComponent();

}

private void btnWebServiceCall_Click(object sender, RoutedEventArgs e)

{

productName = txtProductName.Text;

productNumber = txtProductNum.Text;

FY08Sales = txtFY08Sales.Text;

SPSilverlightClient.ASMXUpdateSPList.MyFirstSPServiceSoapClient proxy = new SPSilverlightClient.ASMXUpdateSPList.MyFirstSPServiceSoapClient();

proxy.useNormalMOSSApiCompleted += new EventHandler<System.ComponentModel.AsyncCompletedEventArgs>(proxy_useNormalMOSSApiCompleted);

proxy.useNormalMOSSApiAsync(SalesSPSite, productName, productNumber, FY08Sales);

proxy.CloseAsync();

}

void proxy_useNormalMOSSApiCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)

{

MessageBox.Show("Can you believe it? This stuff actually works!");

}

private void btnFieldsClear_Click(object sender, RoutedEventArgs e)

{

txtFY08Sales.Text = "";

txtProductName.Text = "";

txtProductNum.Text = "";

}

private void cmboBoxOfferings_DropDownClosed(object sender, EventArgs e)

{

//Be warned...lazy hard-coded variable data to follow.

if (optionOne.IsSelected == true)

{

txtSiteDescr.Text = "FY 09 Sales Tracking Site";

SalesSPSite = "http://stefoxdemo";

}

else if (optionTwo.IsSelected == true)

{

txtSiteDescr.Text = "SharePoint on the Web Metrics";

SalesSPSite = "http://stefoxdemo";

}

else if (OptionThree.IsEnabled == true)

{

txtSiteDescr.Text = "Wave 14 Reports";

SalesSPSite = "http://stefoxdemo";

}

else if (OptionFour.IsEnabled == true)

{

txtSiteDescr.Text = "Personal Metrics";

SalesSPSite = "http://stefoxdemo";

}

else if (OptionFive.IsEnabled == true)

{

txtSiteDescr.Text = "Signage Reports";

SalesSPSite = "http://stefoxdemo";

};

}

}

}

At this point, you are now done building the Silverlight UI. Let’s move on to the final part: building the SharePoint web part.

Building the SharePoint Web Part Host Container

The SharePoint web part will serve as the object within SharePoint that will simply put host your Silverlight application. There are a number of ways to do this, of which this is one.

Open the solution file (where you created your Silverlight application) and then right-click the solution and select Add, and New Project. Select the SharePoint project type and then select Web Part. Provide a name for your Web Part project.

Figure 17: Adding SharePoint Web Part

When your project is created, right click References and select Add Reference. Add the System.Web.Extensions DLL and System.Web.Silverlight DLL and click OK. See Figure 18

Figure 18: Adding Silverlight References

In the WebPart1.cs file (I removed and re-added a new Web Part item and called mine MyFirstSPServiceCall), you’ll need to have the following code. This checks for a ScriptManager object and also sets some properties for the Silverlight control we’ll add to the Controls collection.

protected override void OnLoad(EventArgs e)

{

base.OnLoad(e);

ScriptManager sm = ScriptManager.GetCurrent(this.Page);

if (sm == null)

{

sm = new ScriptManager();

Controls.AddAt(0, sm);

}

}

protected override void CreateChildControls()

{

base.CreateChildControls();

System.Web.UI.SilverlightControls.Silverlight ctrl = new System.Web.UI.SilverlightControls.Silverlight();

ctrl.ID = "InsertSPListItem";

ctrl.Source = "http://stefoxdemo/XAPS1/SPListClient.xap";

ctrl.Width = new Unit(650);

ctrl.Height = new Unit(400);

Controls.Add(ctrl);

}

You can edit the XML properties of your web part through the WSP View. For example, the following XML is from the .webpart XML file. You can see I’ve updated the name and description of the web part with something a little more intuitive.

<?xml version="1.0" encoding="utf-8"?>

<webParts>

<webPart xmlns="http://schemas.microsoft.com/WebPart/v3">

<metaData>



<type name="967945ef-8baa-406e-bda3-fe4b836b2f66" />

<importErrorMessage>Cannot import MyFirstSPServiceCall Web Part.</importErrorMessage>

</metaData>

<data>

<properties>

<property name="Title" type="string">My First SharePoint Service Call Web Part</property>

<property name="Description" type="string">A web part that hosts a call into SharePoint to update a list.</property>

</properties>

</data>

</webPart>

</webParts>

Jumping back to the code for the actual web part, the complete code that you’ll need to have in the webpart.cs file (in my case MyFirstSPServiceCall.cs) is as follows:

using System;

using System.Runtime.InteropServices;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

using System.Xml.Serialization;

using Microsoft.SharePoint;

using Microsoft.SharePoint.WebControls;

using Microsoft.SharePoint.WebPartPages;

namespace SPSilverlightSPWP

{

[Guid("967945ef-8baa-406e-bda3-fe4b836b2f66")]

public class MyFirstSPServiceCall : System.Web.UI.WebControls.WebParts.WebPart

{

public MyFirstSPServiceCall()

{

}

protected override void OnLoad(EventArgs e)

{

base.OnLoad(e);

ScriptManager sm = ScriptManager.GetCurrent(this.Page);

if (sm == null)

{

sm = new ScriptManager();

Controls.AddAt(0, sm);

}

}

protected override void CreateChildControls()

{

base.CreateChildControls();

System.Web.UI.SilverlightControls.Silverlight ctrl = new System.Web.UI.SilverlightControls.Silverlight();

ctrl.ID = "InsertSPListItem";

ctrl.Source = "http://stefoxdemo/XAPS1/SPListClient.xap";

ctrl.Width = new Unit(650);

ctrl.Height = new Unit(400);

Controls.Add(ctrl);

}

}

}

At this point, you need to ensure the Debug property in your SharePoint project properties is set to your http://localhost (or the correct server to which you’re deploying the web part), and you can deploy the web part.

If you notice in the source property code of the Silverlight application, it references an absolute URL on a test server. This presupposes two things: 1) you’ve created a document library called XAPS1 and 2) you’ve added the XAP file (the compiled Silverlight application) into that document library. If you have not, then you will simply get a blank, white web part. Also, note that this is not the only way to do this. In Professional SharePoint 2007 Development using Silverlight 2, there are a number of ways to deploy the web part that are discussed.

To deploy the web part, right-click the SharePoint project and select Deploy.

Testing the Web Part

Now that you’ve deployed the web part, you can now open your SharePoint server and add the new Silverlight web part to your SharePoint site. To do this, click Site Actions and Edit Page. Click Add a Web and then select your newly deployed web part from the Web gallery. Once you’ve added the web part, you can now interact with the Silverlight UI within SharePoint that further interacts with your SharePoint list (i.e. that SharePoint object model).

Figure 19: Silverlight Web Part in SharePoint

When you click Insert, a new record will be added to the SharePoint list and a message will be issued, as coded in our Silverlight UI, to the user.

Figure 20: Message Indicating Success

Of course the success message is only one indication. To verify that a new record was indeed added to the FY 09 Sales , navigate to the list and verify the new information on the list.

Figure 21: Successful Addition of Record

For more information on how to integrate Silverlight and SharePoint, check out Professional SharePoint 2007 Development using Silverlight 2 and http://mssharepointdeveloper.com.

Web Services and SharePoint: How do I do it?

Steve Fox — Sun, 08 Feb 2009 08:03:00 GMT

When building an OBA, you’re often going to want to either integrate with the native Web services for SharePoint (when I say SharePoint, in this instance I’m referring to both the WSS and the MOSS services) or you’ll want to create your own custom services. The question often comes up is how? In this post, I’ll show you a couple of different ways of doing this by creating a custom client app that achieves the same thing (i.e., inserts a record into a SharePoint list). Before we get to the client app, though, let’s quickly review a few of the more common ways that we can deploy a service:

ASMX Web service that is deployed into the SharePoint hive (e.g. deployed into the _vti_bin or _layouts folder;
ASMX Web service deployed to its own Web application domain;
WCF service deployed into the _vti_bin or _layouts folder; and
WCF service deployed into its own Web application domain.

When deploying an ASMX service into the _vti_bin, there are a few things that you need to do in order to prepare your service to be supportable by SharePoint. While based on VS 2005, you can apply the same methods for VS 2008 by using the article here: http://msdn.microsoft.com/en-us/library/ms464040.aspx. Most important to remember are:

Add DLL to GAC;
Run Disco tool against ASMX file;
Add the appropriate amendments to the .dsco and .wsdl files (see the aforementioned article);
Rename the x.dsco and x.wsdl files to be xdsco.aspx and xwsdl.aspx;
Copy the .asmx file, xwsdl.aspx and xdisco.aspx files to the _vti_bin folder.

When deploying a service (ASMX or WCF) to its own web app domain, you need to first make sure you create and publish your web service to a folder on your application server and then map that folder to an IIS web site. To do this:

Open IIS;
Create a New Web Site;
Map the Path to the folder where your service is published;
Set Permissions (use either ASP.NET Impersonation or Windows Authentication and set to Enabled); and
Refresh the view of your site.

Now you’ll likely need what is called a client access policy or cross-domain policy file, which are files that are required for cross-domain calls into SharePoint. You may also need to have the files in your published web site root folder as well as having them in your SharePoint site root folder. Note: While you can copy and paste the policy files into your IIS web site, remember that you should use SharePoint Designer to open the SharePoint site and then copy the policy files to the root directory of the site. Here is a snapshot of what the root folder in my Content View of IIS (7.0) looks like:

When deploying a WCF service to SharePoint, you need to remember that you must create a VirtualPathProvider because SharePoint doesn’t support the loading of .svc files. A good summary of how to do this is here: http://blah.winsmarts.com/2008-5-SharePoint_2007_as_a_WCF_host_-_Step_-4,_Write_a_Virtual_Path_Provider.aspx.

If you use the native Web services that ship with SharePoint (e.g. Lists, Excel Services, or BDC), you can simply open up a VS project and add these to your project. To discover the services, click Add a Web Reference and then click the Web services on this local machine (presumably you’ve got SharePoint on that machine), and then all of the SharePoint services will be listed.

In my example, I’ll show you how to call a custom web service (that uses WCF and ASMX deployed to their own IIS web sites) and a native SharePoint web service that does the same thing as the custom code. The custom code in my service that I’m using to insert the record into a SharePoint list called “TR8” is listed as follows (at least this is how it looks for the ASMX service):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
using Microsoft.SharePoint;

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
// To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.
// [System.Web.Script.Services.ScriptService]
public class UpdateSharePointList : System.Web.Services.WebService
{
public UpdateSharePointList () {

        //Uncomment the following line if using designed components
        //InitializeComponent();
    }

    [WebMethod]
    public void useNormalMOSSApi(string SalesSPSite, string productName, string productNumber, string FY08Sales)
    {
        string strDashListRoot = SalesSPSite;

        using (SPSite site = new SPSite(strDashListRoot))
        {
            using (SPWeb web = site.OpenWeb())
            {
                web.AllowUnsafeUpdates = true;

                SPList list = web.Lists["TR8"];
                SPListItem Item = list.Items.Add();
                Item["Title"] = productName;
                Item["ProductNum"] = productNumber;
                Item["Sales"] = FY08Sales;
                Item.Update();
            }
        }

}
}

The core code is similar for the WCF service; however, the major differences are standard WCF/ASMX differences—e.g. uses contracts as opposed to Web method declarations, and so on. After I created the services, I then added them to a VS 2008 project using the Add Service and Add Web Reference functions within VS. Here’s a snapshot of my project, so you can see all of the standard references, WCF reference and ASMX references (both the native SharePoint Lists.asmx reference and the custom ASMX service I built).

Okay, enough on the service side; let’s take a look at the client code.

In this example, I built a simple client UI to test out a couple of different services. The following UI shows the form:

You can see that the form accepts a SharePoint site (selected from a combo-box), three separate user entries from textboxes (product name, product number, and sales), and then another input (type of service to call when executing the insertion of the record into SharePoint) from the other combo-box.

In the code-behind my WinForm app, I’ve first got four key class-level variables that I’ll use to contain the input from the above form:

string productName = "";
string productNumber = "";
string FY08Sales = "";
string SalesSPSite = "";

Then, when the user clicks the Add button (which corresponds to the btnGetSPLists_Click event), the application looks at the Type of Service control entry and then calls a specific method to handle the specific type of service.

private void btnGetSPLists_Click(object sender, EventArgs e)
{
     //Setting the variables to link to specific site
     SalesSPSite = cmboBxSPSite.SelectedItem.ToString();
     productName = txtBxProduct.Text;
     productNumber = txtBxProductNum.Text;
     FY08Sales = txtBoxSales.Text;

     //User can set whether they can call the service or not.
     if (cmbBxService.SelectedItem.ToString() == "Native SharePoint Web Service")
     {
         useSPListWebService(
             SalesSPSite, productName, productNumber, FY08Sales);
     }
     else if (cmbBxService.SelectedItem.ToString() == "Standard SharePoint API")
     {
         useNormalMOSSApi(
             SalesSPSite, productName, productNumber, FY08Sales);
     }
                 else if (cmbBxService.SelectedItem.ToString() == "WCF Service")
     {
         useWCFService(
             SalesSPSite, productName, productNumber, FY08Sales);
     }
     else if (cmbBxService.SelectedItem.ToString() == "ASP.NET Web Service")
     {
         useASMXService(
             SalesSPSite, productName, productNumber, FY08Sales);
     }

}

The conditional code in the btnGetSPLists_Click event sets the class-level variables and then calls one of four different methods depending on what the user has selected.

One of the selections calls the ASMX code (which is the native Lists.asmx web service):

//1. Using the Native SP Web Service.
private void useSPListWebService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
{
// Declare and initialize a variable for the Lists Web Service.
TR8_ListServiceCall.SPListService.Lists listService = new TR8_ListServiceCall.SPListService.Lists();

//Authenticate to the current user.
listService.Credentials = System.Net.CredentialCache.DefaultCredentials;

//Set the Url property of the service for the path to a subsite.
listService.Url = SalesSPSite + "/_vti_bin/Lists.asmx";

      //Get Name attribute values (GUIDs) for list and view.
      System.Xml.XmlNode ndListView = listService.GetListAndView("TR8", "");
      string strListID = ndListView.ChildNodes[0].Attributes["Name"].Value;
      string strViewID = ndListView.ChildNodes[1].Attributes["Name"].Value;

      //Create an XmlDocument object and construct a Batch element
      //and its attributes.
      System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
      System.Xml.XmlElement batchElement = doc.CreateElement("Batch");

//Create a CAML construct to insert data into the field into the TR8 list.
batchElement.InnerXml = "<Method ID='1' Cmd='New'><Field Name='Title'>" + productName + "</Field><Field Name='ProductNum'>" + productNumber + "</Field><Field Name='Sales'>" + FY08Sales + "</Field>" + "</Method>";

      //Call the UpdateListItems method to insert the record into the list.
      XmlNode ndReturn = listService.UpdateListItems(strListID, batchElement);
      MessageBox.Show("Record Added (Via Web Service)");

}

One of the selections calls the normal MOSS API (which is essentially the custom code that runs directly against my SharePoint server):

//2. Using the Normal SP API.
private void useNormalMOSSApi(string SalesSPSite, string productName, string productNumber, string FY08Sales)
{

string strDashListRoot = SalesSPSite;

           using (SPSite site = new SPSite(strDashListRoot))
           {
               using (SPWeb web = site.OpenWeb())
               {
                   web.AllowUnsafeUpdates = true;

                   SPList list = web.Lists["TR8"];
                   SPListItem Item = list.Items.Add();
                   Item["Title"] = productName;
                   Item["ProductNum"] = productNumber;
                   Item["Sales"] = FY08Sales;
                   Item.Update();
                   MessageBox.Show("Record Added (Via API)");
               }
           }

}

One of the selections calls my custom ASMX service:

//3. Using the ASMX Service.
private void useASMXService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
{
    TR8_ListServiceCall.ASMX_WebService.TR8ASPWebService myService = new TR8_ListServiceCall.ASMX_WebService.TR8ASPWebService();
    myService.UseDefaultCredentials = true;
    myService.useNormalMOSSApi(SalesSPSite, productName, productNumber, FY08Sales);
    MessageBox.Show("Record Added (Via ASMX)");
    myService.Dispose();

}

And the last of the selections calls my custom WCF service:

//4. Using the WCF Service.
private void useWCFService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
{
    TR8_ListServiceCall.WCF_SPListService.InsertItemsClient proxy = new TR8_ListServiceCall.WCF_SPListService.InsertItemsClient();
    proxy.useNormalMOSSApi(SalesSPSite, productName, productNumber, FY08Sales);
    MessageBox.Show("Record Added (Via WCF)");
    proxy.Close();

}

Each of these calls does exactly the same thing: inserts a record using the data from the input form into the SharePoint list called “TR8.” Note, though, that there are syntactical differences. For example, for the custom services we are really executing the code inside the custom service so we need the proxy, the default windows credentials, and the calling of the specific web method (useNormalMOSSApi) to add the entries. And of course don’t forget to dispose/close the service to clean up your sessions.

The biggest syntactical difference from the above, though, is the native Lists.asmx web service. Note the use of the CAML construct to create the XML ‘document’ that represents the data we’re inserting into the list. A tip here is if you’re going to use this method, the ‘field’ attribute in the CAML construct is not the column display name. To get the proper attribute, go to your SharePoint site, click List Settings, and then click the column in question. Note at the end of the URL is the field name. In the below figure, you can see ‘Field=Sales’ – this is the correct field attribute to use. (Hopefully, this will save you troubleshooting XML errors.)

So, the only remaining code is that which corresponds to the other buttons, which is fairly self-explanatory.

//Events to handle the clearing of the controls.
private void ctnClear_Click(object sender, EventArgs e)
{
     txtBoxSales.Clear();
     txtBxProduct.Clear();
     txtBxProductNum.Clear();
}

//Event to exit the application.
private void btnExit_Click(object sender, EventArgs e)
{
Application.Exit();
}

When executing the code, what will happen is that you can insert records from the client app via a service that then update the SharePoint list. So, why is this cool? Because you can use the same method described above to interact with many different areas of SharePoint—expanding the breadth of your OBA to include OM calls and data management with SharePoint. Here’s a final view of what the end result of the above code (selecting and executing each of the services in my Type of Service combo-box) looks like:

Note that I’ve added the complete code-behind for my sample app below.

Hope this helps you in your quest!

Steve

Complete Code-Behind for the WinForm App

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.SharePoint;
using System.Collections;
using System.Data.SqlClient;
using System.Xml.Linq;
using System.Xml;
using System.Xml.Serialization;
using Microsoft.SharePoint.SoapServer;
using System.ServiceModel;

namespace TR8_ListServiceCall
{
    public partial class Form1 : Form
    {
        //Class-level variables
       string productName = "";
       string productNumber = "";
       string FY08Sales = "";
       string SalesSPSite = "";

        public Form1()
        {
            InitializeComponent();
        }

        private void btnGetSPLists_Click(object sender, EventArgs e)
        {
            //Setting the variables to link to specific site
            SalesSPSite = cmboBxSPSite.SelectedItem.ToString();
            productName = txtBxProduct.Text;
            productNumber = txtBxProductNum.Text;
            FY08Sales = txtBoxSales.Text;

            //User can set whether they can call the service or not.
            if (cmbBxService.SelectedItem.ToString() == "Native SharePoint Web Service")
            {
                useSPListWebService(
                    SalesSPSite, productName, productNumber, FY08Sales);
            }
            else if (cmbBxService.SelectedItem.ToString() == "Standard SharePoint API")
            {
                useNormalMOSSApi(
                    SalesSPSite, productName, productNumber, FY08Sales);
            }
                        else if (cmbBxService.SelectedItem.ToString() == "WCF Service")
            {
                useWCFService(
                    SalesSPSite, productName, productNumber, FY08Sales);
            }
            else if (cmbBxService.SelectedItem.ToString() == "ASP.NET Web Service")
            {
                useASMXService(
                    SalesSPSite, productName, productNumber, FY08Sales);
            }

}

        //1. Using the Normal SP API.
        private void useNormalMOSSApi(string SalesSPSite, string productName, string productNumber, string FY08Sales)
        {

string strDashListRoot = SalesSPSite;

            using (SPSite site = new SPSite(strDashListRoot))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    web.AllowUnsafeUpdates = true;

                    SPList list = web.Lists["TR8"];
                    SPListItem Item = list.Items.Add();
                    Item["Title"] = productName;
                    Item["ProductNum"] = productNumber;
                    Item["Sales"] = FY08Sales;
                    Item.Update();
                    MessageBox.Show("Record Added (Via API)");
                }
            }

}

        //2. Using the Native SP Web Service.
        private void useSPListWebService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
        {
            // Declare and initialize a variable for the Lists Web Service.
            TR8_ListServiceCall.SPListService.Lists listService = new TR8_ListServiceCall.SPListService.Lists();

//Authenticate to the current user.
listService.Credentials = System.Net.CredentialCache.DefaultCredentials;

//Set the Url property of the service for the path to a subsite.
listService.Url = SalesSPSite + "/_vti_bin/Lists.asmx";

            //Get Name attribute values (GUIDs) for list and view.
            System.Xml.XmlNode ndListView = listService.GetListAndView("TR8", "");
            string strListID = ndListView.ChildNodes[0].Attributes["Name"].Value;
            string strViewID = ndListView.ChildNodes[1].Attributes["Name"].Value;

            //Create an XmlDocument object and construct a Batch element
            //and its attributes.
            System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
            System.Xml.XmlElement batchElement = doc.CreateElement("Batch");

            //Call the UpdateListItems method to insert the record into the list.
            XmlNode ndReturn = listService.UpdateListItems(strListID, batchElement);
            MessageBox.Show("Record Added (Via Web Service)");

}

        //3. Using the ASMX Service.
        private void useASMXService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
        {
            TR8_ListServiceCall.ASMX_WebService.TR8ASPWebService myService = new TR8_ListServiceCall.ASMX_WebService.TR8ASPWebService();
            myService.UseDefaultCredentials = true;
            myService.useNormalMOSSApi(SalesSPSite, productName, productNumber, FY08Sales);
            MessageBox.Show("Record Added (Via ASMX)");
            myService.Dispose();

}

        //4. Using the WCF Service.
        private void useWCFService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
        {
            TR8_ListServiceCall.WCF_SPListService.InsertItemsClient proxy = new TR8_ListServiceCall.WCF_SPListService.InsertItemsClient();
            proxy.useNormalMOSSApi(SalesSPSite, productName, productNumber, FY08Sales);
            MessageBox.Show("Record Added (Via WCF)");
            proxy.Close();

}

        //Events to handle the clearing of the controls.
        private void ctnClear_Click(object sender, EventArgs e)
        {
            txtBoxSales.Clear();
            txtBxProduct.Clear();
            txtBxProductNum.Clear();
        }

        //Event to exit the application.
        private void btnExit_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }
    }
}

Learn how to integrate PeopleSoft, Outlook and MOSS

Steve Fox — Sun, 08 Feb 2009 06:51:09 GMT

Office Business Application (OBA) development is growing in importance thus continues to be an integral part of the Office platform developer story. To that end, we recently completed a new resource that could be used for OBA training specific to PeopleSoft and Office integration. This HOL uses the OBA Starter Kit for PeopleSoft as the demo environment and provides a comprehensive walkthrough on how to a) create web services that wrap around PeopleSoft components (both native and custom), b) consume those services in a custom Outlook client (the design can be extrapolated to other Office custom clients), and c) integrate the service with the MOSS Business Data Catalog.

The new resource, a hands-on lab that is now publicly available, is a great way for you or your customers to get ramped up on how to integrate Office and PeopleSoft.

The OBA Starter Kit for PeopleSoft is available here: http://msdn.microsoft.com/en-us/office/cc442491.aspx

The new OBA PeopleSoft Hands-on Lab is available here: http://www.microsoft.com/isv/oracle/

Enjoy!

Steve

Silverlight RTM and SharePoint Blueprints Ship on Codeplex

Steve Fox — Fri, 09 Jan 2009 05:38:00 GMT

Today, additional SharePoint and Silverlight Blueprints on CodePlex were uploaded to include two more Silverlight RTM samples: custom navigation in SharePoint and the colleague viewer. These blueprints provide samples for you to build and explore using Silverlight as an alternate way to develop and integrate powerful user experiences within SharePoint and add rich Internet application functionality to your SharePoint sites. Included in the overall set of samples are a Hello World sample, a Slider sample, and the recently added Custom Navigation and Colleague Viewer samples added today. You can download the samples along with documentation and screencasts at http://www.codeplex.com/SL4SP.

Over the next few weeks, I'll publish a couple of other blog posts on Silverlight and SharePoint. I think there is tremendous opportunity here for building rich Internet applications that can also be thought of as OBAs. For example, think about skinning an integration with SAP with Silverlight and then dropping it into a SharePoint site. This not brings the LOB system world into SharePoint, but does it in a way that improves the look and feel of the UI as well as providing additional controls that you can build around the UI to, for example, filter on SAP, Dynamics or other LOB system data.

For more resources on how to integrate Silverlight and SharePoint, be sure to visit http://mssharepointdeveloper.com. Keep an eye out on this site over the next few weeks, as we're going publish a new round of content for WCM and MOSS. Some cool SharePoint and Silverlight stuff will be shipping.

Happy coding!

Steve

Announcing SharePoint for the Web Development Series

Steve Fox — Sun, 30 Nov 2008 20:34:00 GMT

For those that are looking for more SharePoint development resources, we'll be launching a series of webcasts starting next week. More information below.

Announcing the SharePoint Products and Technologies for Internet Site Development webcast series. This series shows how to use Microsoft Office SharePoint Server 2007 for your internet site. We will leverage a fictitious site, Adventure Works, to demonstrate how to customize SharePoint to create your internet presence. The series is presented by our Microsoft Most Valued Professionals, experts in the technologies they are presenting on. This material follows up on the labs and webcasts that were introduced on the http://mssharepointdeveloper.com site.

Date	Topic	Presenter
12/2	Getting Started	Todd Baginski
12/4	.COM Branding	Doug Ware
12/9	Custom Fields, Web Parts, and Lists	Todd Bleeker
12/11	FBA Authentication	Todd Bleeker
12/16	Web Interoperability	Eric Shupps
12/18	Search	Rob Bogue
1/6	Content Deployment	Andrew Connell
1/13	Enabling Social Networking	Brendon Schwartz and Matt Ranlett
1/15	Site Customization with Silverlight 2.0	Sahil Malik

SharePoint Connections Deck

Steve Fox — Thu, 13 Nov 2008 20:39:00 GMT

I'm just wrapping up my week here in Las Vegas for SharePoint Connections, and one of the requests I had was to post my decks for those who attended my sessions. I've posted my decks to a public skydrive folder here:

http://cid-40a717fc7fcd7e40.skydrive.live.com/self.aspx/SharePointConnections/Final%7C_Presentations.zip

If you have any issues connecting and retrieving the decks, let me know.

I'll also upload the code samples and some videos that go along with these, but wanted to get these uploaded first. As for the questions we discussed in the sessions, I'll be posting answers to those as well.

Thanks to all of you who attended the sessions and made SharePoint Connections another successful event.

Steve

End-to-End Sales Forecast OBA Released To Web!

Steve Fox — Sat, 25 Oct 2008 05:28:00 GMT

It's been a while, but I wanted to let all you OBA developers out there know of something cool that we recently released, which is the End-to-End (E2E) Sales Forecast OBA. As you know from reading this blog, you know that OBA is an Office Business Application and involves mutltiple technologies within the Office platform. The E2E Sales Forecast OBA is a solution that walks you through a scenario where a salesperson creates and submits a quarterly sales forecast. Using a customized Excel template (built using VS 2008/VSTO), our salesperson has the ability to navigate to the team Sales Forecast portal (SharePoint portal), invoke a custom Excel sales forecast template from the New button (content type mapping to a custom template), load line-of-business sales data into the document (via WPF custom actions pane), generate executive reports for the forecast (via Open XML), and submit the document for approval (through SharePoint workflow). It essentially uses all of the concepts and technologies that I've discussed thus far in this blog--plus a few that I haven't.

In the demo solution (which is available on CodePlex--see link below), the approving manager can interact directly with SharePoint or choose to approve the workflow via a custom Outlook Form Region (built using VS 2008/VSTO). Messaging of the workflow is marshaled by SharePoint, and Open XML enables the solution to parse out the necessary data and attach to workflow and to the custom Outlook from region. This is a great starter solution if you're looking to get your hands on some code, and includes the technologies below:

- SharePoint

- Office Client Ribbon and Action Pane Customizations (VS 2008/VSTO)

- Outlook Custom Form Regions

- Open XML

- Unified Communications (UC)

- SharePoint Workflow

- Windows Presentation Foundation (WPF)

- ++

For the community source-code download and accompanying book, you can check out the following resources:

Sales Forecast Codeplex Source Code Site

http://www.codeplex.com/obasales

Sales Forecast Wrox Book Accompaniment

http://www.wiley.com/WileyCDA/WileyTitle/productCd-0470377313.html

The goal of the book is to walk you through all of the code and you would set up and deploy the sales forecast OBA.

Enjoy!!

Steve

Use Silverlight to Enhance your SharePoint-Based OBAs with the Silverlight Blueprints for SharePoint

Steve Fox — Tue, 19 Aug 2008 18:00:00 GMT

Silverlight Blueprints for SharePoint Released to CodePlex!

Today we released the source code for the Silverlight Blueprints for SharePoint—based on the Silverlight Beta 2 release. The Silverlight Blueprints for SharePoint provide a way for developers to better understand how to integrate Silverlight applications with SharePoint. Silverlight is an incredibly popular technology and with the increase in SharePoint adoption we’re finding an increased call for integrating technologies like Silverlight with SharePoint.

In this release, you’ll find five blueprint samples:

1. Hello World

2. Media Player

3. Slider Control

4. Custom Navigation

5. Colleague Viewer

Included in the release are documentation for each of the samples and the source code (go to the Releases tab of the CodePlex site). Also posted to the site is an FAQ document. In the coming days and week, we’ll publish additional screen-casts and any other supporting documentation we create or that is provided to us through the developer community.

The links to get to the Silverlight Blueprints for SharePoint are:

1. http://www.ssblueprints.net/sharepoint/ --or direct at the CodePlex site

2. http://www.codeplex.com/SL4SP

Enjoy!

Steve