Steve Fox's OBA Ramblings : Web service

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!

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();
        }
    }
}

Create Your First OBA: Part 5

Steve Fox — Tue, 12 Aug 2008 23:29:00 GMT

Hey gang,

It's been a while since I've posted, but I've been on the road. I attended TechEd 2008 (USA), our internal field conference TechReady 7, and then travelled to South Africa to TechEd 2008 (S. Africa). Now, I'm back in Seattle--albeit a little jet-lagged. Over the past few weeks, I've continued to give talks on OBA, but have been doing a lot more SharePoint lately--especially Silverlight and SharePoint (I'll put some blog posts up about this in the near future).

In the past, I've been doing a lot of writing in my blogs, so for this blog I put together a short screen-cast to go along with the blog. Essentially, in this blog I'm going to show you how you can create a Business Data Catalog (BDC) web part in SharePoint using the Business Data Catalog Definition Editor. Specifically, the web part will actually implement a couple of web methods from a Web service. I get this question a lot, so I really wanted to make this a part of the OBA series. (Plus, the BDC is one of the more common objects that SharePoint developers use.) This is part 5 of the Create Your First OBA series (Customizing SharePoint (BDC)):

1.       Creating the VSTO document-level solution (i.e. the custom document);
2.       Deploying the VSTO document-level solution;
3.       Integrating the VSTO with SharePoint content type;
4.       Associating SharePoint workflow with VSTO document-level solution;
5.       Customizing SharePoint (BDC);
6.       Customizing SharePoint (Excel Services).

Before you get started, a couple of notes on your environment. You can download the MOSS 2007 SDK from here: http://www.microsoft.com/downloads/details.aspx?familyid=6D94E307-67D9-41AC-B2D6-0074D6286FA9&displaylang=en. The SDK contains the BDC Definition Editor, which you will use to create the application definition file (ADF)--a metadata representation of the data source that you're connecting to with the BDC web part. I also used VS 2008 to create my Web service, which I deployed to my local Win 2003 Server which was also running MOSS (Enterprise edition). The BDC is available in the MOSS Enterprise Edition, so if you're looking to use the BDC you'll need to make sure you have this MOSS SKU installed.

Okay, so below I've added a Silverlight video player with the WMV screencast embedded in it:

If you have any problems with this, you can also get the WMV directly here: http://silverlight.services.live.com/75885/How%20to%20Create%20a%20BDC%20Web%20Part%20that%20Consumes%20a%20Web%20Method/video.wmv.

Have a great day!

Steve