The MS Sharepoint Blog

In our last blog of this series Walkthrough of creating a SharePoint 2010 external list using Visual Studio 2010 Beta, we introduced how to create a simple “Hello world” external list in SharePoint 2010 Beta using Business Data Connectivity Designer in Visual Studio 2010 Beta.

In this blog, we will show you how to pull data from an external database into an external list and enable Create, Read, Update and Delete (CRUD) functions to the external list.

First of all, you need to have SharePoint 2010 Public Beta and Visual Studio 2010 installed on your machine in order to complete this walkthrough. We’ll use “Northwind” database as external data source, so if you do not have an existing “Northwind” database available, we’ll walk you through to create a local database using SQL Server Express first (SQL Server Express comes with Visual Studio installation by default, in case you don’t yet have it, download it here).

At the end of this post, we will complete with a BDC model project which has a “Customer” entity connects to “Customer” table in “Northwind” database, and have CRUD operations enabled. The finished project can also be downloaded from here.

Prepare the data source

If you already have a “Northwind” database, you can skip this section. Otherwise, please download SharePoint2010_BDCSamples.zip from here and extract the SQL script file CreateSampleNorthwindDB.sql.

Open Visual Studio. Go to View->Server Explorer. Right click Data Connections in Server Explorer, and select Create New SQL Server Database.

1. In the prompt dialog, type “localhost\sqlexpress” in Server Name text box, and give the new database name “SampleNorthwind”.

* If you're using the SQL Express that comes with SharePoint Server, please replace “localhost\sqlexpress" with "localhost\sharepoint”.

2. Start a Command Prompt. Go to Start->Run, type “Cmd” in the text box and click OK.

3. In the Command Prompt, type in following command and press enter:

sqlcmd -S localhost\sqlexpress -d samplenorthwind -i <Path of CreateSampleNorthwindDB.sql file>

Create BDC Project

Create a new C# BDC Model project and rename it “BdcSampleCSharp”. VB code snippets will also be provided, so you can create VB BDC Model project if you want. In this walkthrough, we will use C# project as an example. (Check this blog for how to create a BDC project)

Connect to external data source

To use the SampleNorthWind database, we add a LINQ to SQL model to the project:

1. On the Project menu, click Add New Item, in the prompt Add New Item dialog select Data in the Installed Templates pane, in the Templates pane select LINQ to SQL Classes, in the Name box, type “Customer”, and then click Add.

2. In the Server Explorer, go to Data Connections->[hostname]\sqlexpress.SampleNorthWind.dbo->Tables->Customers, drag the Customers table and drop it on the Customer.dbml design surface.

3. Add a new class file and rename it “CustomerDataContext.cs”. Replace the code of the class with the following code snippet.

Note: We made the connection string a constant in the code only for demo purpose, if you’re using your own database, modify the connection string as needed. In our future post we will introduce how to set the connection string in a custom property on LobSystemInstance inside the BDC model and read the value through IContextProperty interface at runtime.

C#:

public partial class CustomerDataContext { private const string ConnectionString = @"Data Source=localhost\SQLEXPRESS;Initial Catalog=SampleNorthwind;Integrated Security=True;Pooling=False"; public CustomerDataContext() : base(ConnectionString, mappingSource) { OnCreated(); } } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

VB:

Partial Public Class CustomerDataContext Private Const ConnectionString As String = "Data Source=localhost\SQLEXPRESS;Initial Catalog=SampleNorthwind;Integrated Security=True;Pooling=False" Public Sub New() MyBase.New(ConnectionString, mappingSource) OnCreated() End Sub End Class .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

Design BDC Model

1. On the design surface, delete entity Entity1 which is created by default. On the View menu, click on Toolbox if it is not shown. Create a new entity by drag and drop the Entity icon from Toolbox onto design surface (see the screenshot below). In the Properties Browser, change the value of Entity’s Name property to “Customer”.

2. Create a new Identifier CustomerID on entity Customer. To do so, on the design surface, right click the entity, click Add->Identifier. A new identifier appears on the entity, and then rename it to “CustomerID”.

3. Create a Specific Finder method for the entity. To do so, on the design surface, select entity Customer, you could find a <Add a Method> command in the Method Details Window. If the Method Details Window is not opened, you can find it in menu View->Other Windows->BDC Method Details. From the <Add a Method> drop-down list, select Create Specific Finder Method:

A method named ReadItem appears on entity Customer. In the Method Details Window, you will find that the method takes a In parameter and a Return parameter. In the next step we will define TypeDescriptors associated with these parameters.

4. Add TypeDescriptors for the return parameter Customer. The edit need to be done in BDC Explorer. You can find it by going to View->Other Windows->BDC Explorer.

a) In the Method Details Window, click <Edit> command in the drop down control from TypeDescriptor Customer as depicted below. After the click the BDC Explorer will get focused on the TypeDescriptor Customer.

b) In BDC Explorer right click the focused TypeDescriptor Customer and select Add Type Descriptor:

A new TypeDescriptor is created under TypeDescriptor Customer. In the Properties Browser, rename it to “CustomerID”. Next you need to set the Identifier property to “CustomerID” to tell the BCS runtime which identifier this TypeDescriptor represents. Here is a screenshot of Properties Browser after this step:

c) Continue to add following TypeDescriptors under Customer by repeating the operation described above: Address, City, CompanyName, ContactName, Country, Fax, Phone, PostalCode and Region, for each TypeDescriptor, you need to change its Type Name to make sure they match the type defined in the LINQ to SQL model. In this example, all the TypeDesriptors have a type of System.String which is the default one so we do not need to change them. After this step, we get the following TypeDescriptors in BDC Explorer:

d) Next we need to define the actual type of the TypeDescriptor Customer. Click TypeDescriptor Customer in BDC Explorer. You will find in the Properties Browser the value of Type Name property is System.String by default, we need to change it to “BdcSampleCSharp.Customer, BdcModel1” which is a LobSystem qualified type name. This specifies the actual the data type of the data structure that is represented by this TypeDescriptor Customer.

5. Create the other types of methods by the same way described in step 6. After this step we will have five methods in the entity Customer: ReadItem, ReadList, Create, Update and Delete. If you check the ReadList method in Method Details Window, the TypeDescriptors of the return parameter have already been defined with the same structure as we just built above. This is because when creating a new method, BDC designer will search the possible TypeDescriptors defined in the other methods of this entity and copy them to the newly created methods. This saves the developers so much time to define them repetitively.

Add code behind to access external data source

Now it’s time to add code to implement the CRUD functions. In Solution Explorer, find and open CustomerService.cs, and then replace the implementation with the following code snippet:

C#:

public static Customer ReadItem(string customerID) { CustomerDataContext context = new CustomerDataContext(); Customer cust = context.Customers.Single(c => c.CustomerID == customerID); return cust; } public static IEnumerable<Customer> ReadList() { CustomerDataContext context = new CustomerDataContext(); IEnumerable<Customer> custList = context.Customers; return custList; } public static Customer Create(Customer newCustomer) { CustomerDataContext context = new CustomerDataContext(); context.Customers.InsertOnSubmit(newCustomer); context.SubmitChanges(); Customer cust = context.Customers.Single(c => c.CustomerID == newCustomer.CustomerID); return cust; } public static void Delete(string customerID) { CustomerDataContext context = new CustomerDataContext(); Customer cust = context.Customers.Single(c => c.CustomerID == customerID); context.Customers.DeleteOnSubmit(cust); context.SubmitChanges(); } public static void Update(Customer customer, string customerID) { CustomerDataContext context = new CustomerDataContext(); Customer cust = context.Customers.Single(c => c.CustomerID == customer.CustomerID); cust.CustomerID = customer.CustomerID; cust.Address = customer.Address; cust.City = customer.City; cust.CompanyName = customer.CompanyName; cust.ContactName = customer.ContactName; cust.ContactTitle = customer.ContactTitle; cust.Country = customer.Country; cust.Fax = customer.Fax; cust.Phone = customer.Phone; cust.PostalCode =customer.PostalCode; cust.Region = customer.Region; context.SubmitChanges(); } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

VB:

Public Shared Function ReadItem(ByVal customerID As String) As Customer Dim context As New CustomerDataContext Dim cust = (From c In context.Customers _ Where c.CustomerID = customerID _ Select c).Single() Return cust End Function Public Shared Function ReadList() As IEnumerable(Of Customer) Dim context As New CustomerDataContext Return context.Customers End Function Public Shared Function Create(ByVal newCustomer As Customer) As Customer Dim context As New CustomerDataContext context.Customers.InsertOnSubmit(newCustomer) context.SubmitChanges() Dim cust = (From c In context.Customers _ Where c.CustomerID = newCustomer.CustomerID _ Select c).Single() Return cust End Function Public Shared Sub Delete(ByVal customerID As String) Dim context As New CustomerDataContext Dim cust = (From c In context.Customers _ Where c.CustomerID = customerID _ Select c).Single() context.Customers.DeleteOnSubmit(cust) context.SubmitChanges() End Sub Public Shared Sub Update(ByVal customer As Customer, ByVal customerID As String) Dim context As New CustomerDataContext Dim cust = (From c In context.Customers _ Where c.CustomerID = customer.CustomerID _ Select c).Single() cust.Address = customer.Address cust.City = customer.City cust.CompanyName = customer.CompanyName cust.ContactName = customer.ContactName cust.ContactTitle = customer.ContactTitle cust.Country = customer.Country cust.Fax = customer.Fax cust.Phone = customer.Phone cust.PostalCode = customer.PostalCode cust.Region = customer.Region context.SubmitChanges() End Sub .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

Create an external list to test out the BDC Model!

Now we are done! Let’s deploy the solution and create an external list to test it out (Check this blog to see how to create an external list). After the list is created, you will see the following page appears when you click on the list name:

All the data are pulled out to SharePoint successfully, now you can create, delete or edit customer records.

To create a new Customer, find the List Tools->Items->New Item button on the ribbon shown in the following screenshot:

Click on the button, New Item dialog will pop out as below:

Fill in the dialog and click Save, you will find the item created in the list right away.

To edit or delete the item, just click the down arrow at the right side of CustomerID, all the operations you need are there.

SharePoint web dialogs bring an exciting new UI feature: they can auto-size to the content of a hosted page. Auto-sizing works by examining the contents of your page during page load, and setting the size of the dialog accordingly. Unfortunately, this feature can be speed bump on the road to master page customization. This post will describe the master page customization process necessary to keep dialog auto-sizing working with your master pages.

 

The most important thing to note is that the auto-sizing feature is aware of whether the ribbon is fixed at the top of the screen. It is important to know whether your master page has the ribbon fixed at the top of the screen or not in order to customize it to work well with auto-sizing. A ribbon fixed on top of the screen looks like this, with the page content below the ribbon scrollable separately from the ribbon itself:

 

If the ribbon is fixed at the top of the screen, be sure the following statements about your master page are true:

• The ribbon is inside an element with ID "s4-ribbonrow".
• The remaining page content is inside an element with ID "s4-workspace".
• The element with ID "s4-workspace" is scrollable.
• The <body> element is not scrollable.

If the ribbon is not fixed at the top of the screen, be sure the following statements about your master page are true:

• There is no element on the page with ID "s4-ribbonrow".
• The <body> element is scrollable.

The auto-sizing process happens when the hosted page loads. If your master page or any individual pages use dynamic HTML to change the size, position, or amount of content on the page after page load, you may need to re-invoke the auto-sizing process after the dynamic content update in order to obtain a correctly-sized dialog. From within a hosted page, call

window.frameElement.autoSize();

to invoke the auto-sizing process. During initial page load, the dialog is hidden and a loading dialog is shown (see below). However, after the page has loaded, re-invoking the auto-sizing process will continue to show the existing dialog while changing its size.

 

 

If your master page uses a table-based layout, or a variable-width layout, the auto-sizing process may be unable to determine the correct size. In that case, you can try to set a minimum or fixed width on an element in the page in order to help the auto-sizing process.

Zach Nation

Software Developer on SharePoint Foundation

Hi all.  This is Greg Chan, Program Manager on the SharePoint team, for the third part in this List View series. In this post I’m excited to have one of the key architects of the new XSLT List View Web Part (XLV) talk more about its architecture.  Here is what he has to say:

Hi! I’m Eric Andeen, a developer on the SharePoint team. I’m going to describe in a little more detail how the XSLT List View Web Part (XLV) works, and how that affects people building and using SharePoint sites.

List View XML and minimal markup

As Greg mentioned in Part I, the XLV is the new list view technology in SharePoint 2010, replacing the List View Web Part (LVWP). Since the XLV is the replacement for the LVWP, it needs to do all the same things, as well as adding new capabilities. The best place to start this discussion is with some of the things that haven’t changed.

The markup required to specify a LVWP is pretty simple – we need to know which list the LVWP is displaying, and we need to know about the view. The list can be identified by name, URL or guid identifier, but the view is a little more complex, and is specified in XML. This is an example of the ViewXML of the default view of an announcements list:

<View Name="{F5D7FCD1-BEFE-42b5-9339-4F4F3C6A38FE}" DefaultView="TRUE" DisplayName="All Items" Url="/Lists/Announcements/AllItems.aspx">

  <Query>

    <OrderBy>

      <FieldRef Name="Modified" Ascending="FALSE"/>

    </OrderBy>

  </Query>

  <ViewFields>

    <FieldRef Name="Attachments"/>

    <FieldRef Name="LinkTitle"/>

    <FieldRef Name="Modified"/>

    <FieldRef Name="Number"/>

  </ViewFields>

  <RowLimit Paged="TRUE">30</RowLimit>

</View>

 

The primary use of the ViewXML is to generate the SPDataSource that gets the data, but it is also used in the xsl transform to turn the raw xml data returned into presentable HTML, as we will see below. The part of the ViewXML that’s most important to this discussion is the <ViewFields> tag – it tells SharePoint which fields are in the view.

Schema Independent XSL

The XLV is now the default list view technology in SharePoint, and that means it has to scale as well as the LVWP. The only way that’s possible is for the XLV to render any uncustomized, out of the box view using a single XSLT. An uncustomized XLV has no <xsl> property at all – SharePoint supplies the same shared XSLT that is used to render every other XLV. The XSLT responsible for this lives on your server at http://<myserver>/_layouts/xsl/main.xsl – go ahead and open it up and look at it, as well as the xsl:import files vwstyles.xsl and fldtypes.xsl that do most of the work.

Before we discuss how the XLV’s schema independent XSLT works, it’s worth considering how typical, schema dependent XSLT like that used in the DataFormWebPart works. In order to render a tabular view of rows and columns, any technology, XSLT included, needs to iterate through the rows, and in each row, it needs to iterate through the columns, rendering each part appropriately. The XML we’re transforming looks like this:

<Rows>

  <Row @Field1="Hello" @Field2="World!" @Field3=""      />

  <Row @Field1="Some"  @Field2="More"   @Field3="Data"  />

  <Row @Field1="Yet"   @Field2="More"   @Field3="Data"  />

</Rows>

 

The interesting portion of a typical XSLT for this XML looks like this:

<xsl:for-each select="$Rows">

  <tr>

    <td>

      <xsl:value-of select="@Field1"/>

    </td>

    <td>

      <xsl:value-of select="@Field2"/>

    </td>

    <td>

      <xsl:value-of select="@Field3"/>

    </td>

  </tr>

</xsl:for-each>

The output HTML is a 3x3 table:

Hello

World!

 

Some

More

Data

Yet

More

Data

This XSLT is schema dependent because it iterates through the list of columns by naming each one explicitly. Using this XSLT, the schema of the rendered list is fixed; it’s not possible to change the set of fields without changing the XSLT.

The schema independent XSLT that the XLV uses iterates through the rows pretty much the same way as the example above, but it iterates through the columns quite differently. When the XLV renders the list, the XML passed in to the transformation engine includes not just the data in the <Rows> collection; it also includes the ViewXML shown above, enhanced with additional schema information. There are several instances of the field iterator in the XSLT to accommodate different view styles, but they all look something like this:

<xsl:for-each select="ViewFields/FieldRef">

  <xsl:apply-templates mode="PrintField" select=".">

    <xsl:with-param name="thisNode" select="$thisNode"/>

  </xsl:apply-templates>

</xsl:for-each>

The “ViewFields" referenced in the <xsl:for-each> is the <ViewFields> tag in the enhanced ViewXML markup, and the $thisNode variable refers to the current row in the Rows collection. The XSLT also contains a set of templates for rendering the fields. A simplified version of those field templates would look like this:

<xsl:template match="FieldRef" mode="PrintField">

  <xsl:param name="thisNode" select="."/>

  <td>

    <xsl:apply-templates match="FieldRef" mode="PrintValue">

      <xsl:with-param name="thisNode" select="$thisNode"/>

    </xsl:apply-templates>

  </td>

</xsl:template>

 

<xsl:template match="FieldRef" mode="PrintValue>"

  <xsl:param name="thisNode" select="."/>

  <xsl:value-of select="$thisNode/@*[name()=current()/@Name]"/>

</xsl:template>

 

The first template outputs the <td> tag and then calls the next template to output the actual value. The second template is where things get interesting. In the schema dependent example above, the values were all named explicitly – @Field1, etc. We can’t do that in the schema independent XSLT, so instead, we use the FieldRef node in the ViewFields markup to get the appropriate attribute from the row. $thisNode is the row of data we’re looking at, and the current XSLT context (.) is the FieldRef node for the field we’re rendering. So the value of the funky xpath expression above – $thisNode/@*[name()=current()/@Name] – is the value of the attribute in the Row tag for the current field – exactly what we want. $thisNode is the row of data we're looking it; @* is the xpath attribute axis, and [name()=current()/@Name] selects the one attribute whose name matches the @Name attribute of the current context – the FieldRef node.

The actual XSLT for the XLV has to do more than just render simple values inside unadorned <td> tags – it has to render field headers, list item menus on title fields, proper CSS classes on <td> and other tags, etc. It also has to render some field types (hyperlink, person, etc.) differently from simple text fields. All this is done through the same basic mechanism as in the simplified version above – the fields iterator calls a template to render the field, which in turn calls into a series of other templates. Some of the simpler differences make use of <xsl:apply-templates> to select the right template – the template that renders date fields has a match="FieldRef[@Type='DateTime']" instead of just match="FieldRef", for example. More complex checks make use of <xsl:if> and <xsl:choose> along with <xsl:call-template> to call the right template.

XLV Model

The following diagram sums up the process which turns list data and XSLT into the view you see when you browse to a SharePoint page. The data comes from an SPDataSource control, but unlike the DataFormWebPart, the SPDataSource control is dynamically generated from the ViewXML in the diagram below. The SPDataSource control produces an XML rowset containing the list data. The ViewXML gets enhanced with list schema information and added to the XML rowset containing the data. The XSLT is compiled into an XslCompiledTransform – and since we always use the same XSLT, it's only compiled once per web server. The XML rowset, with both the data and the enhanced ViewXML, is passed into the XslCompiledTransform, and the HTML output goes into the page stream and onto the screen of your browser.

Modifying the View

One of the benefits of this approach is that we can now change the set of fields in the view, and the XSLT will still render them properly. Want to add Field4 to the data? No problem – just add it to the ViewXML. Want to change Field1 from a simple text field to a person field? No problem – just change the field definition in SharePoint, and the enhanced ViewXML markup has the new type, so the field will render properly as the new type.

What if we want to make more complex changes to the XSLT – things like conditional formatting? It's possible to do so in SharePoint designer, generally without losing the advantages of the schema independent XSLT. We'll cover that in depth in the next post in this series.

Performance

Although the ability to modify the view without changing the XSLT is a very nice benefit of the schema independent XSLT, it's not the most important one. The primary benefit, and the one that allows the XLV to become the default view technology, is performance and scalability. The SharePoint server loads one copy of the XSLT into memory and reuses it for every uncustomized XLV it renders, which allows the server to render many views very quickly. And the lack of a large <xsl> property on uncustomized views means that each view takes only a small amount of space in the content database, which allows a site collection to contain a large number of lists and views without space issues.

A lot of people have asked me how to create a button which enables if and only if a single item is selected. This isn’t something we have out of the box, but the code to get this functionality is pretty simple. I’m going to assume that you’re generally familiar with SharePoint, CustomActions, and customizing the Ribbon – if that’s not the case, you’d probably be better off researching those things before delving into this.

Basically, the enabling behavior all boils down to the following few lines of code:

EnabledScript="javascript:function singleEnable() {
  var items =
    SP.ListOperation.Selection.getSelectedItems();
  var ci = CountDictionary(items);
  return (ci == 1);
}
singleEnable();"

What this does is query to get the dictionary of selected items, and if the size of the dictionary is 1 it returns true (enable), otherwise it will return false (disable). Technically, I should have used Script on Demand to call into the SP.* namespace, but since I’m calling this from the Ribbon I have a high confidence that SP.js has been loaded already.

With nothing selected:

With one item selected:

Clicking the button:

And with more than one item selected:

You could also change this to enable only if no items were selected, or if any number of items were selected. The way to make those kinds of changes should be relatively self-explanatory.

The full CustomAction code for a sample Ribbon button which enables when one item is selected is at the end of this post. The code assumes the following:

1. You want to add this button to the New group on the Documents tab. If you want to add the button to another location, you should change the Location attribute of the CommandUIDefinition element (as well as change any appropriate attributes in the Button element, such as Id and Sequence, to match the new location).
2. You have an icon image at LAYOUTS/SharePointProject1/DemoButton.jpg. If that’s not the case, you should either put an icon at that location or change the Image32x32 attribute to a valid icon path.

CustomAction code:

<CustomAction
  Id="EnableSingleSelectButton"
  Location="CommandUI.Ribbon" >
  <CommandUIExtension>
    <CommandUIDefinitions>
      <CommandUIDefinition
  Location="Ribbon.Documents.New.Controls._children">
  <Button Id="Ribbon.Documents.New.EnableSingleSelectButton"
          Alt="Button enabled on single selection"
          Sequence="35"
          LabelText="Single Select"
  Image32by32="/_layouts/SharePointProject1/DemoButton.png"
          Command="SingleSelectButton"
          TemplateAlias="o1" />
      </CommandUIDefinition>
    </CommandUIDefinitions>
    <CommandUIHandlers>
      <CommandUIHandler
          Command="SingleSelectButton"
          CommandAction="javascript:alert('There is only one thing selected!');"
          EnabledScript="javascript:function singleEnable()
          {
            var items = SP.ListOperation.Selection.getSelectedItems();
            var ci = CountDictionary(items);
            return (ci == 1);
          }
          singleEnable();" />
    </CommandUIHandlers>
  </CommandUIExtension>
</CustomAction>

December 2009 Cumulative Updates are available for download for Microsoft Office SharePoint Server 2007 and Windows SharePoint Services 3.0. Cumulative Updates will now always be available at the Update Center

For additional download information and detailed descriptions of the December 2009 Cumulative Update visit the Updates Resource Center for SharePoint Products and Technologies at http://technet.microsoft.com/en-us/office/sharepointserver/bb735839.aspx.

Additional Resources

Update Center for Microsoft Office, Office Servers, and Related Products

We've seen some confusion in the newsgroups and elsewhere on the versions and editions of Windows that SharePoint 2010 will run on. This post is meant to clarify some of the most common questions we have seen.

SharePoint 2010 will support only 64-bit (x64) versions of Windows Server 2008 SP2 and Windows Server 2008 R2.  SharePoint will not install at all on 32 bit Windows, or any earlier version of Windows  such as Windows Server 2000 or Windows Server 2003.

SharePoint is not supported on 'Server Core' installations of Windows Server 2008 and R2. The Server Core installations of Windows server do not contain some of the components required for SharePoint to be configured or run.

To make developing for SharePoint 2010 easier, it is possible to install SharePoint on 64-bit versions of Windows Vista SP2  and Windows 7. Note that running production environments on these OSes are not supported and it will not be possible to upgrade deployments running on client versions of Windows to future versions of SharePoint.  Instructions on installing SharePoint 2010 on client versions of Windows are a bit more involved and we recommend reading the instructions at http://msdn.microsoft.com/en-us/library/ee554869(office.14).aspx.

 

Windows version/edition (64 bit only)

SharePoint 2010 support

Windows Server 2008 R2 Foundation

No

Windows Server 2008 R2 Standard

Yes

Windows Server 2008 R2 Enterprise

Yes

Windows Server 2008 R2 Datacenter

Yes

Windows Web Server 2008 R2

No

Windows HPC Server 2008

No

Windows Server 2008 R2 for Itanium-based systems

No

Windows Server 2008 Standard

Yes

Windows Server 2008 Enterprise

Yes

Windows Server 2008 Datacenter

Yes

Windows Web Server 2008

No

Windows Storage Server 2008

No

Windows Small Business Server 2008

Yes*

Windows Essential Business Server 2008

Yes*

Windows Server 2008 for Itanium-based systems

No

Windows Server 2008 Foundation

No

Windows Vista

Developer-only**

Windows 7

Developer-only**

* Small and Essential Business Server editions of Windows install SharePoint as an optional component.

** Support for specific editions of Windows 7/Vista are yet to be finalized, but are likely to be 'Business'/'Professional' editions and above.

 

The list above is meant for informational purposes only. The official list of system requirements for SharePoint 2010 is located at http://technet.microsoft.com/en-us/library/cc262485(office.14).aspx and includes additional details on prerequisites and other optional components.

 

Umesh Unnikrishnan

Program Manager, SharePoint

Management Packs allow users to monitor SharePoint 2010 with System Center Operations Manager. SharePoint Foundation Management Pack and SharePoint Server 2010 Management Pack enables monitoring of SharePoint Foundation 2010, SharePoint Server 2010, Search Server 2010 (These is separate management pack for FAST search), Project Server 2010 and Office Web Apps. Once management pack is imported to System Center console, based on console configuration it automatically discovers what SharePoint bits or servers are installed in the environment that is being monitored and start monitoring those components.

These 2010 management packs will be released to System Center Operations manager catalog and will also be released to web along with SharePoint 2010 RTM.

Out of box experience

SharePoint Management Packs monitors all prominent services, Shared Services, SharePoint Health Analyzer rules, Web Applications and SharePoint Servers. In SharePoint 2010 you can use it to monitor both physical (servers and services running on those servers) and logical (Shared Services, Web Application etc.) of SharePoint. You can monitor multiple farms, and even fix some issues automatically by running out of box tasks. You can also write your own tasks using System Center Wizard or Windows PowerShell script to enable this self-healing.

Primary takeaway of SharePoint 2010 MP is depth and breadth of monitoring and rapid detection and resolution. Here’re the improvements compared with the previous product.

 

Management Packs for Windows SharePoint Services 3.0 and Microsoft Office SharePoint Server 2007

Management Packs for SharePoint 2010

Change

Discoveries

5

16

↑300%

Classes

10

133

↑1293%

Monitors

28

240

↑300%

Rules

235

107

↓45%

Reports

27

9

↓33%

SPHA Rules

NA

100+

↑100%

TechNet KAs

NA

~150

↑100%

These numbers illustrate significant improvements over 2007 management pack. 1200% and 300% change in number of classes and discovery represents improvement in depth and breadth of monitoring. Change in number of monitors indicates improvement in granularity of monitoring that enables quick isolation of issues. Detailed knowledge articles represent rapid diagnosis and resolution. Did you also notice knowledge articles are on TechNet, which means we will be able to improve these articles based on your feedback even after release!

In 2007 you can just monitor, one farm with multiple servers and some services. Diagram view below reflects a typical 2007 monitoring. Anything that is crossed was not available in 2007 management pack and remaining had limited depth of one additional level.

 

In 2010 you can monitor multiple farms, multiple servers, services, shared services, SharePoint Health Analyzer rules (Which saves you a trip to central admin which also means that System Center Operation Manager console is your one stop shop for all monitoring requirements) and web applications.

Server Monitoring

Service Monitoring

 

Share Service Monitoring

SharePoint Health Analyzer monitoring (One stop shop for both native and external monitoring)

Web Application Monitoring

Download Management Pack Beta for SharePoint 2010

SharePoint Foundation 2010: http://www.microsoft.com/downloads/details.aspx?FamilyId=43d5ee9a-b9a6-441d-a35e-8a7b9b15e20c

SharePoint Server 2010: http://www.microsoft.com/downloads/details.aspx?FamilyId=c8a9d749-b7a8-412a-b2db-f3e464ed3fcf

Hi!   I'm Jason Morrill, another Program Manager on the SharePoint team.   I wanted to write a bit about what it feels like to use SharePoint lists with the new user experience.   If you've got a SharePoint site sitting around, I'd encourage you to open it in another window and follow along as I talk about things.
Let's start by just browsing to a document library with no content.

 

The first thing you'll notice is that we've moved some of the navigation and menus around.   The stuff right in the middle (Site Name > Document Library > All Documents) is your current location.   You can click on the Site Name to get back home, and you can click on the view name (All Documents) to switch to another view.   Above the title, you see there's a black row - this is where you go to access all your commands. I’ll talk more about that later.   Below the title, you see the list view items.   Right now there are no items, so let's fix that.  

To add an item to this library, you can click on the Add document button in the view. That button will always be available at the end of the current page, if you want to quickly add documents to this library. When you click it, you’ll notice that instead of navigating the entire page, we just put up a dialog asking you where you want to upload. This makes it faster to load and also easier to understand what’s going on. For this post, I actually want to upload multiple files – so go ahead and click on Upload Multiple Files. You’ll see something like this:

You can drag files onto the blue rectangle to add them to your upload list, or you can click on Browse for files instead to find the files in a windows dialog. Once you’ve picked them, click Ok and they will start uploading. When the page refreshes, you’ll see lot of items in the view. If you hover over one, you’ll notice that the row gets highlighted:

You can click on the dropdown arrow in the middle of the row to see a menu of commands for this document. However, you can also click anywhere else on the row (well, anywhere that’s not a link) to select the document. This will automatically open a menu of all the available commands for the selected document:

This menu is where you can find all the commands in SharePoint. Sometimes, it will open automatically (like when you select an item). But, if you want to open it manually, you can always click on one of the tab names. Once it is open, you can look through the various available tabs by clicking on their names. The names generally describe the thing the command affects, so if you click on Library you are looking at commands you can perform on the Document Library. Commands on the Documents tab are relevant to the currently selected document or documents.

When the ribbon opened, you might have noticed that it covered up the page title. We did that to save space, but if you ever want to get back to the page title, you can just click on Browse:

Changing ribbon tabs won’t change what items you have selected, so it’s always safe to click around looking for the command you want.

Now, go ahead and click back on the Documents tab and look through the available commands. You’ll notice that you can do all the familiar SharePoint actions from here. Go ahead and click on Edit Properties, and you’ll see the form pop up in another dialog. You can make whatever changes you want, click Save and we’ll drop you right back on the same page again, quick and easy.

In addition to just selecting one item, you can select multiple items. To do that, just click on the check box that appears on the left of each row when you hover over it:

Not all commands work on multiple items, and you’ll notice that the ribbon has greyed out commands that can’t be used. This multiple selection makes it easy to delete, check in and check out many files at once.

Once you’ve added enough items, the view will start to page. This means that you’ll need to click on the next page arrow at the bottom of the view to see more of what’s in the list:

You can control the number of items shown on each page from the Modify View page, which can be accessed from the Library tab (just to the right of the Documents tab we were looking at earlier):

In addition to modifying the current view, the Library tab also allows you to switch views and use the datasheet. You can also create new columns, connect the lists to client applications – like Excel, Windows Explorer or SharePoint Workspaces – and customize the list’s forms, workflows or other settings.

By looking through those commands, there’s obviously a lot more that can be done with SharePoint lists. But, with what I’ve shown above, you should be able to get around your lists and libraries with relative ease. Good luck!

In order to upgrade to SharePoint Foundation 2010 or SharePoint Server 2010, you must first be running Windows SharePoint Services 3.0 at SP2 or Microsoft Office SharePoint Server 2007 at SP2, respectively. For customers running prior versions of SharePoint, including Windows SharePoint Services 2.0 and SharePoint Portal Server 2003, this means that you must first upgrade to Windows SharePoint Services 3.0 SP2 or Microsoft Office SharePoint Server 2007 SP2 prior to upgrading to 2010 versions. Windows SharePoint Server 3.0 with SP2 is available as a free download, and trial versions of Microsoft Office SharePoint Server 2007 are available and supported for use in this upgrade/migration process:

SP2 Slipstream Downloads and Trial Versions

Windows SharePoint Services 3.0 (32-bit) with SP2

http://www.microsoft.com/downloads/details.aspx?FamilyId=EF93E453-75F1-45DF-8C6F-4565E8549C2A

Windows SharePoint Services 3.0 (64-bit) with SP2

http://www.microsoft.com/downloads/details.aspx?familyid=9FB41E51-CB03-4B47-B89A-396786492CBA

Microsoft Office SharePoint Server 2007 Trial Version (32-bit) with SP2

http://www.microsoft.com/downloads/details.aspx?FamilyId=2E6E5A9C-EBF6-4F7F-8467-F4DE6BD6B831

Microsoft Office SharePoint Server 2007 Trial Version (64-bit) with SP2

http://www.microsoft.com/downloads/details.aspx?familyid=3015FDE4-85F6-4CBC-812D-55701FBFB563

Please note that the trial product versions are licensed for 180 days of use from the date of installation.

Upgrade Method

This upgrade process should be done using the Database Migration approach documented in the following links:

Windows SharePoint Services and Microsoft Office SharePoint Server 2007

Determine upgrade approach (Office SharePoint Server)

http://technet.microsoft.com/en-us/library/cc263447.aspx

Determine upgrade approach [Windows SharePoint Services]

http://technet.microsoft.com/en-us/library/cc287821.aspx

SharePoint Foundation 2010 and SharePoint Server 2010 (pre-release documentation)

Determine upgrade approach (SharePoint Server 2010)

http://technet.microsoft.com/en-us/library/cc263447(office.14).aspx

Determine upgrade approach (SharePoint Foundation 2010)

http://technet.microsoft.com/en-us/library/cc287821(office.14).aspx

Note that this method is referred to as “Database attach upgrade” in pre-release documentation

Please note that there are manual steps involved in this upgrade path in order to maintain some configuration information, as documented in the links above.

Example Upgrade Sequence

The upgrade documentation above should be referenced for full detail and information, but the following illustrates an example of an upgrade sequence for moving from Office SharePoint Server 2007 to SharePoint Server 2010.

1. Prepare Farms

a. Set up a small, temporary farm running Office SharePoint Server 2007

b. Set up full SharePoint 2010 farm and verify that it is configured and running correctly

2. Upgrade content from 2003 to 2007

a. Detach the content databases from the 2003 farm and take the 2003 farm offline

b. Attach the content databases to the 2007 farm and upgrade them

c. Verify the content has upgraded and that the 2007 farm is working correctly

3. Upgrade content from 2003 to 2007

a. Detach the content databases from the 2007 farm

b. Attach the content databases to the SharePoint Server 2010 farm and upgrade them in parallel

c. Verify the content has upgraded to SharePoint 2010 and is working correctly

4. Start serving requests on the SharePoint Server 2010 farm

Again, this is just an example for illustration: for full detail, including all steps and important considerations, please review the existing and pre-release documentation linked above.

Additional Information and Notes

Please note that SharePoint Server 2010 Beta cannot be upgraded to the final release version (RTM). Any use of these steps or guidelines with any pre-release version of SharePoint 2010 should be for testing/evaluation only.

This upgrade path will necessarily mean a move from 32-bit OS architecture to 64-bit OS architecture. Windows SharePoint Services 2.0 and SharePoint Portal Server 2003 were supported only on 32-bit operating systems, as opposed to SharePoint Foundation 2010 and SharePoint Server 2010, which are supported only on 64-bit operating systems.

The database platform selected for Microsoft Office SharePoint Server 2007 or Windows SharePoint Services 3.0 should be consistent with the planned platform for Microsoft SharePoint Server 2010 or Microsoft SharePoint Foundation 2010. For example, if SQL Server 2008 will serve as the database software for the Microsoft Office SharePoint Server 2007 or Windows SharePoint Services 3.0 trial versions you should maintain that version for Microsoft SharePoint Server 2010 or Microsoft SharePoint Foundation 2010 to avoid downgrade support limitations such as SQL Server 2008 to SQL Server 2005. For additional information on SQL Server 2008 downgrade rights see:

SQL Server 2008 Licensing Frequently Asked Questions

http://www.microsoft.com/sqlserver/2008/en/us/licensing-faq.aspx

In November, we posted guidance to help setup User Profile Synchronization for those evaluating SharePoint 2010 public beta.  In order for the sync to work, the SharePoint WFE farm admin account or UPA admin account must have “Replicated Directory Changes” permissions in Active Directory.  To help the SharePoint admins that are not Active Directory admins, here is a step-by-step walk-thru to complete this task on Windows Server 2008 R2.  Finally, the User Profile Service administration content on TechNet has been updated based upon feedback from the public beta release.

1. Open Active Directory Users and Groups with local machine Administrator permissions.
   
   
2. Right click the domain and select Delegation Control.
   
   
3. Click Next on the Delegation Control Wizard welcome page.
   
   
4. On the Users or Groups page, add the domain\account of your SharePoint farm admin account and click Next.
    
   
5. On the Tasks to delegate page, select “Create a custom task to delegate” and click Next.
   
   
6. On the Active Directory Object Type page, keep the default options and click Next.
   
   
7. On the Permissions page, check the “Replicating Directory Changes” and click Next.
   
   
8. Click Finish to complete the Delegation of Control Wizard.
    
   

There are a bunch of SharePoint features in Visual Studio 2010 Beta. You may have already heard about them from reading the blog Short Overview of SharePoint Features in Visual Studio 2010 or by other means. Today I want to introduce one of them, Business Data Connectivity (BDC) designer, which is available in the project template Business Data Connectivity Model. If BDC is new to you, here is a short description. BDC is one of two most important architectural components of Microsoft Business Connectivity Services (BCS) which enables users to read and write data from external systems—through Web and Windows Communication Foundation (WCF) services, databases, and Microsoft .NET Framework assemblies—from within Microsoft SharePoint 2010 and Microsoft Office 2010 applications. This MSDN webpage Business Data Connectivity (BDC) Service has a more descriptive version.

Visual Studio 2010 helps a SharePoint developer to develop, debug and deploy .NET assemblies as external data sources to SharePoint. In the following paragraphs, I will walkthrough with you how to create your first SharePoint external list using Visual Studio 2010. In order to make this walkthrough work on your machine, you need to install SharePoint 2010 Public Beta* and Visual Studio 2010 Beta2#.

*: Please read Setting Up the Development Environment for SharePoint Server before the installation. If you are using SharePoint Foundation 2010 you will need to create a Feature Event Receiver to enable the import of BDC models. How to create a Feature Event Receiver will be covered in a future blog post.

#: Please make sure Microsoft SharePoint Development Tools component is selected when installing. It is chosen by default if you choose Full installation.

Let’s start the journey.

1. Create a new BDC Model project. (Main menu: File -> New -> Project…). In the left column of the New Project dialog, you are able to find node 2010 under tree view Visual C# -> SharePoint. Similarly you can find same node under Visual Basic -> SharePoint. In the middle column of the dialog, you should be able to see Business Data Connectivity Model listed as one of the project templates. See the screenshot as follows. Here I am creating BDC Model project in Visual C#. You are able to do the same things in Visual Basic.

2. After clicking [OK] button in the New Project dialog, the SharePoint Customization Wizard dialog will be displayed. In this dialog you can customize the local site you want to target and trust level for the SharePoint solution. Since a BDC model is deployed to a farm, a collection of one or more SharePoint servers and one or more SQL servers, only “Deploy as a farm solution” option is enabled. Here is the screenshot of the dialog.

3. When you click [Finish] button in the SharePoint Customization Wizard dialog, the BDC Model project will be created. There are four main UI panes that help you manage the BDC model visually. They are the BDC Designer Surface, BDC Method Details Pane, BDC Explorer, and Properties Browser.

a. The BDC Designer Surface allows editing entities, identifiers, methods, and associations between entities. And you can do that either from toolbox or context menus.

b. The BDC Method Details pane, where its name is already self-explanatory, lets you edit everything related to a method, from the method itself, its parameters to its parameters’ type descriptors, from method instances to filter descriptors, etc.

c. BDC Explorer lists and organizes metadata objects in the BDC model in a tree view. It lets you to browse and search metadata objects in a graphical way and allows you to copy/cut/paste type descriptors between different parameters or type descriptors.

d. Properties Browser gives you a familiar way of editing components and attributes of BDC Models. We use it to supplement the functions offered by the other three panes and list all the attributes for a particular metadata object for editing. Here is a typical layout of a BDC Model project as described above.

4. If you notice, there is already a default entity generated for you when the project is created. This default entity also has an identifier and two methods ReadItem and ReadList created. One is a Finder method that is to return a collection of data. The other is a Specific Finder method that is to return a specific entry based on the input parameter(s).

5. Now let’s deploy to the SharePoint server. You can either click the deploy menu item in main menu (Build -> Deploy Solution), or in the context menu of the project or the solution. In the output you will see several activities happening including packaging, solution retraction/addition, deployment, etc.

6. Let’s open the target site and see if our model has been successfully deployed. Open the target site with any browser supported by SharePoint, like Internet Explorer 8. Create an external list based on the model we just deployed. Here are the steps to create an external list in case you are new to it.

a. In main menu: Click Site Actions -> More Options…

b. On the Create dialog, select External List, click [Create] button in the right column

c. On the next external list create form, type a name for the list. Check ‘Yes’ to display the list on the Quick Launch for easy access. Then click to select the model we just deployed in the External Content Type Picker form. Click [Create] on the external list create form. Now the Hello World list is displayed.

In the main menu under List Tools -> Items, you may find only “View Item” option is enabled. Guess why? Yes, it is because the default entity only has a Finder method to view the entire list and a Specific Finder method to view a specific item. In our next blog in this series, we will show you how to add more functions like Add, Update and Delete to the list as well as pull data from external data sources.

Several beta language packs for SharePoint Foundation 2010 Beta and SharePoint Server 2010 Beta are now available through the Download Center.  Installing one or more language pack will allow you to evaluate the new Multi User Interface (MUI) features of SharePoint 2010.

The following language packs are available:

• German
• English
• Spanish
• French
• Japanese
• Russian
• Chinese (simplified)

SharePoint Foundation 2010 Language Packs

http://www.microsoft.com/downloads/details.aspx?FamilyID=0956787e-210d-4d78-9e4e-a9cdef0e8495&displayLang=en

SharePoint Server 2010 Language Packs

http://www.microsoft.com/downloads/details.aspx?FamilyId=a0c7c05d-8fca-4391-bc70-b62c9af91123&displaylang=en

Please follow the instructions on the download page to install language packs. For further reading, please refer to TechNet articles: Deploy language packs (SharePoint Foundation 2010) and Deploy language packs (SharePoint Server 2010).

Jie Li

Technical Product Manager, SharePoint

Hello.  This is Greg Chan, a Program Manager on the SharePoint team.  I am excited to kick-off a new blog series that will cover a wide spectrum of topics related to the new List View in SharePoint 2010. 

What is a List View again?

Put simply, a List View is a view for displaying SharePoint list data.  The concept of List View has been around since SharePoint v2.  While there are other technologies being used for visualizing list data in different scenarios (e.g. Content Query Web Part), List View remains the default component for displaying list data in SharePoint 2010.

List Views can be spotted everywhere in SharePoint.  They are used to display information such as your announcements, tasks and calendar schedules.

Examples of List Views

 

What’s the big change with List Views in 2010?

In 2010, we are introducing a component called the XSLT List View Web Part (XLV) that serves as the new default technology for displaying list data.  This honor used to belong to the List View Web Part (LVWP), which was the default from SharePoint v2 to 2007.  (Note: LVWPs are still supported in SharePoint 2010, but just not as widely used as the new XLV.) 

The new XLV brings a ton of improvements to the SharePoint platform.  This blog series aim to cover most of these areas. 

What are the key benefits to the new List Views (XLV)?

Replacing the default technology for List Views required fundamental changes to the SharePoint platform.  So why did we do it?  Let me call out the high level benefits of the XLV compared against LVWP from 2007:

• More Designer Friendly
  • Rich customization support through SharePoint Designer (SPD) while preserving browser UI experience
    • In SharePoint 2007, two of the main web parts for displaying list data were LVWP and the DataFormWebPart (DFWP).  Both had their own advantages and disadvantages.  The LVWPs were fully integrated into the browser with in-browser editing support, but lacked rich customization experience as they were not fully customizable inside SharePoint Designer 2007.  The DFWPs had a much richer customization story as they were fully editable inside SharePoint Designer, but lacked the in-browser editing capabilities that LVWPs had.  With the new XLV, SharePoint combined the best aspects of these two technologies and now allow you to richly customize your XLVs in SPD and also provide the in-browser editing experience.  It is important to note that XLV will preserve both SPD customizations and in-browser modifications, and not blow any of that away.
  • Extensible and shareable custom styles
    • A custom view style that you designed in SPD can now be easily shared with other designers across your site collection. 
  • Popular designer features such as Conditional Formatting.
    • Similar to the Conditional Formatting feature in Excel, designer can now set conditions on when to format items in a list view (e.g. KPIs.)
• More Developer Friendly
  • Uses standards-based XSLT instead of CAML
    • Much better documentation of XSLT than CAML.  (http://www.w3.org/TR/xslt)
  • Easily extensible
    • Developers no longer have to include large blobs of CAML to define views in their List definitions.  Take advantage of shared XSLT used to define out-of-box views and only define custom XSL for the sections you want.
• More End-User Friendly
  • Enhanced user experience including Ribbon UI and new multi-selection model.
    • Bulk editing and deletion are now supported.
  • Inline editing support
    • Edit fields in your list view without being directed to another page or dialog.
• More Robust Ways to Access Data
  • Display enterprise data through Business Connectivity Services (BCS)
    • End users can now interact with business data similar to how they interact with regular SharePoint list data. 
  • Cross-web list views displaying data from another web
  • Display list data joined from different lists

What’s coming up in the blog series?

Many people from different teams in the SharePoint family contributed to the new List View in SharePoint 2010.  In this blog series, you’ll get a chance to hear from some of those area experts covering key List View topics.

Here are the topics that will be covered:

• Introduction to the new List View  (you are reading it! J)
• List View – New User Experience
• List View Architecture
• List View Customization
• External Lists
• Conditional Formatting
• How to Share Your Custom List View Styles
• How to Create Custom Fields for the new List View
• Related Item View
• How to Create Views Displaying Cross-Web and Joined List Data

The order in which these topics will be published may change.  We may also add or modify topics on this list.  If there is any areas regarding List Views that you’d like to learn about and isn’t on this list, feel free to suggest them here. 

Thanks for reading.  I hope everyone is excited about the new List Views.  Stayed tuned for more!

If you will be installing the SharePoint Server 2010 Public Beta on Microsoft Windows Server 2008 R2 or Microsoft Windows 7, then you will need to download and install an update from http://connect.microsoft.com/VisualStudio/Downloads/DownloadDetails.aspx?DownloadID=23806  to resolve an issue that occurs in Microsoft SharePoint Server 2010 when provisioning Service Applications or when accessing pages that make service calls.  Without the hotfix, these operations will result in an error "System.Configuration.ConfigurationErrorsException: Unrecognized attribute 'allowInsecureTransport'. Note that attribute names are case-sensitive. (C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\WebClients\<Service Area>\client.config line <Line Number>)".  <?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

 

If you have already installed Microsoft SharePoint Server 2010 on a server running Microsoft Windows Server 2008 R2 or Microsoft Windows 7, Microsoft SharePoint Server 2010 does not need to be reinstalled when the update becomes available; however, Service Applications that have been successfully provisioned without the update installed may need to be removed and re-provisioned once the update has been successfully applied.

The Update Center for Microsoft Office, Office Servers, and Related Products went live today, which will enable customers to find an up-to-date list of all of our Service Pack, Public Update, and Cumulative Update releases in one location. While the SharePoint team blog has posted Cumulative Update package information in the past, this will be available on the Update Center moving forward.

A few Update Center highlights:

• Latest Updates Table
• See the latest updates for your version of Office
• List of all releases in a year
• Find information about past releases
• RSS Feed
• Subscribe to our feed and get updated as new releases become available

The TechNet content about this topic has been updated to incorporate the information in this blog.  Please refer to it if you need guidance on setting up user profile synching in SharePoint Server 2010 Beta.

http://technet.microsoft.com/en-us/library/ee721049(office.14).aspx

Thanks!

Dave Pae
SharePoint TPM

[Note: Windows Server 2008 R2/Windows 7 WCF hotfix is now available and this post has been updated.] 

Before we get into the deep details, I want to share a high-level checklist to setup User Profile syncing on Windows Server 2008.  Once the WCF hotfix for Windows Server 2008 R2 is available, this guidance will work on R2.  This checklist is for beta only - we plan to improve how this works by RTM. 

- Check that your system meets minimum requirements: http://technet.microsoft.com/en-us/library/cc262485(office.14).aspx
- Start with a clean OS install
- Check that the WCF hotfix is installed
           Windows Server 2008 WCF hotfix http://go.microsoft.com/fwlink/?linkID=160770
           Windows Server 2008 R2/Windows 7 WCF hotfix http://connect.microsoft.com/VisualStudio/Downloads/DownloadDetails.aspx?DownloadID=23806
- Check that you have done a "Complete" install of SharePoint Server 2010
- Check that the setup/farm admin account has "Replicating directory changes" in your test domain
- Use the farm configuration wizard to setup all the service applications and successfully create a site collection
- Check that statistics (i.e. Number of User Profiles, etc.) appear on the User Profile Service Application page
- Start the User Profile Synchronization Service and status changes to "Started" - this can take some time and this will configure and start the Forefront Identity services for you (do not try to manually set the logon credentials and start the service)
- Setup an Active Directory Connection
- Start a full Profile import 

Now onto the full details to setup the User Profile synching...

When using SharePoint 2010 Beta, if you need to synchronize bulk users and groups with AD or LDAP, you’d likely be using the user profile synchronization functionality in SharePoint. This functionality is the backbone to turning the profile store into a ‘person’ store with interesting information from AD/LDAP or BDC sources, including hierarchy and group information that can be used to drive functionality such as audiences or hierarchy driven business processes.

We’ve done an overhaul of this feature in 2010, which is also leading to some growing pains for us through the Beta. We’ve a set of steps that you can follow to successfully bring users and groups into the profile store, and despite the fun and temptation of playing, we highly recommend you follow these steps.

For brevity, I am going to list the steps for AD only. In place of reading these steps as you go along, please give this a full read and then follow the steps. Note that quite a few of these steps are because of known issues in the Beta and we are working towards fixing them for RTM.

Prepping for Provisioning the User Profile Synchronization Service

1. After provisioning the User Profile Service Application, ensure that the service is running by going to the Manage Services on Server page in central admin, and if the User Profile service does not show as started, click start on User Profile Service. Do not try to start the User Profile “Synchronization” Service at this time (it’s listed right underneath the User Profile Service).

2. Permissions (for the account you are logged in as, when provisioning or configuring the user profile synchronization service)

a. In order to run the User Profile Synchronization service, you must be a farm admin. Running the user profile synchronization service requires a farm topology decision (where to run it and when), which is a farm admin operation across the SharePoint services platform.

b. Ensure that the farm admin running the farm timer job (typically the account you specified during install unless explicitly changed after install) is a local admin on the box where you are going to run the sync service.

c. This account should also be added to the user profile administrators with full control privileges.

d. While rare, please ensure that this account is not excluded by policy from being able to logon-locally on the machine where sync will be provisioned and run.

Provisioning the User Profile Synchronization Service

3. Now, start the User Profile Synchronization Service, by going to the Manage Services on Server page in central admin and clicking start on the User Profile “Synchronization” service. When you hit start, service will ask you to associate a User Profile Service Application with it, select the User Profile Service Application you created earlier and hit OK.

4. Wait a few minutes to allow for provisioning, verify that the User Profile Synchronization Service shows Started on the Manage Services on Server page, and then check the following items on the  machine where the sync service is running

a. Run services.msc and check if the windows services “Forefront Identity Manager Synchronization Service” and “Forefront Identity Manager Service” are running. Do not start them here manually.

b. Check the folder %Programfiles%\Microsoft Office Servers \14.0\Synchronization Service\MaData to see if there are two subfolders \ILMMA and \MOSS-XYZ (where XYZ is the name of your user profile service application). These folders will be empty at this time.

5. Issue an IISReset on the machine where user profile sync service was provisioned.

Prepping for Connection Creation

6. Before you proceed with creating connections to bring data in, it’s good to pause and spec out what containers you’d be selecting for your connection, where the users are, where the groups are etc. It’s important to get the connections right, before kicking-off sync. We highly recommend that you spec one connection per forest and do not create multiple connections to the same forest.

7. In order to be able to sync with AD, you need to have an account that can be used to call AD and identify what has changed since a given time (in other words, an account that is capable of reading the AD change log). This right is called “Replicate Directory Changes” in AD lingo. This right does not allow for writing or modification of AD objects. You’d need this account name and password when you create a connection. This account can be the same or different than the farm or UPA admin account. Please do not proceed without having an account with these rights, even if you don’t plan to do incremental synchronization. This AD right is required for both full and incremental sync.

Creating a Connection

8. To create a connection with your AD source, you must logon locally on the central admin box. User the Configure Synchronization Connections link in the user profile service central admin page for connection creation.

9. Majority of the items on the connection creation page are intuitive. Specify the fully qualified domain name for the forest, and specify the DC. Ensure that both the forest and the DC are directly reachable from the machine where you provisioned the user profile sync service.

10. You’d likely leave the Authentication provider type to “Windows Auth”.

11. Right below the authentication provider fields, you’d see the account name and password fields for the AD account you procured in step 7.

12. Select Populate Containers and carefully chose the right containers for your connection. For example, find out which containers have the users, if you don’t want to bring in anything else. We have some trouble with this control in IE8, so press F12, and select IE7 in the dev tools window that pops up.

13. If you had additional connections to create, create them all now.

Configure Users or Users and Groups

14. Based on the numbers of users and groups in your system, it can take much longer to sync users and groups, then syncing users only. So to get you started, we’ve provided for a Users-only option under Configure Synchronization Settings link. Select Users-only for the first full run.

Additional Settings

15. We don’t cover the details in this blog, but you can setup additional property mappings and filters at this time, if absolutely needed. If you can live without filtering out data or mapping specific custom properties, it might be best to proceed without them.

Running Sync

16. At this point, you can go to Start Profile Synchronization, select Start Full Synchronization and click ok. Depending upon the number of objects, the first full sync can take many hours to complete. We expect the performance to improve with RTM but after the first full sync, the incremental syncs should be much faster.

What to Expect Next

17. We have bunch of kinks to work out in the status that you see on the right side of the user profile service admin page. For example, if you see the number in the status going down, that means the sync run has just moved from one stage of synchronization to another and are now showing the number for that stage. We are also working on a tool to let you stop a bad run, but in the meantime, it’s not recommended that you stop a sync run brute force. This can get you in a tough state that requires special database-level steps to recover from.

18. If you are running sync for the first time, and you already have the User profile service live, for example users can use their MySites and Profiles, they might see changing organization charts as users come in and managers get attached. This should all clear up once the sync run is complete.

19. Along with the user number shown in the status, you can also search for a known profile or accounts that start with a known domain name in Manage User Profiles page. Note that you are going to not see any users listed here, but they are there, you just have to search for them.

Running Incremental Sync

20. Once the full sync step is complete, you can flip the “Users only” setting to “Users and Groups” and run an incremental sync (or schedule an incremental job).

Today we are announcing the general availability of the public beta of Office 2010, SharePoint Server 2010, Visio 2010, Project 2010 and Office Web Apps for our customers and partners. Millions of people can download the beta at http://www.microsoft.com/2010. 

Office Mobile 2010 has also reached the public beta milestone and is now available on the Windows Mobile Marketplace for Windows Mobile 6.5 phones.

As part of the beta, we are unveiling several new capabilities, including:

• The Outlook Social Connector, a new feature which brings communications history, business and social networking feeds into the Outlook experience.
  • At beta, the Outlook Social Connector will support SharePoint social networking and support Windows Live at launch.
  • We are also announcing that LinkedIn will be the first social networking site to provide a connector for the Outlook Social Connector.
  • We are also releasing the Outlook Social Connector SDK for developers to build connectors to third party social networks.
• Technology and design advancements including deeper integration between Office 2010 and Office Web Apps, improved navigation, visual design and icon updates, a new Office logo and increased performance and stability.

We’re also announcing our plan to deliver Duet Enterprise for Microsoft SharePoint and SAP which will expand the long standing Duet partnership. The joint solution from SAP and Microsoft will enable interoperability between SAP applications and SharePoint 2010 and provide complete flexibility and extensibility to compose solutions that blend the worlds of process and collaboration. Duet Enterprise is built on top of the new Business Connectivity Services in SharePoint 2010. The solution is planned to be released in the second half of calendar year 2010.

SharePoint Public Beta Resources

• General information about SharePoint 2010: http://sharepoint2010.microsoft.com/Pages/default.aspx
• Resources for Developers on MSDN: http://www.mssharepointdeveloper.com
• Resources for IT Pros on TechNet: http://www.mssharepointitpro.com
• Have a SharePoint 2010 question? Ask it in the SharePoint 2010 forums

Where can I download SharePoint 2010 public beta?
You can download SharePoint and Office 2010 public beta from http://www.microsoft.com/2010

Is the SharePoint public beta supported?
The SharePoint public beta is not supported. However, we recommend looking at our resources listed above and asking questions in the SharePoint 2010 forums.

When is the final release of SharePoint and Office 2010?
We are planning to release SharePoint and Office 2010 in the first half of calendar year 2010.

Will there be a migration path from SharePoint public beta to final release?
We do not plan to support a SharePoint 2010 public beta to release bits migration path. The SharePoint 2010 public beta should be used for evaluation and feedback purposes only.

If I’m on SharePoint 2007, how do I get ready for SharePoint 2010?
Take a look here for getting ready guidance.

Is there a downloadable SharePoint 2010 VHD?
We plan to make a VHD available for download sometime in the future. We will announce its availability on our team blog.

How do I get trained on SharePoint 2010?
Please review the Getting Started page, the  IT Professional learning guide , the Developer learning guide , and the End User resources to ramp up on SharePoint 2010.

The Microsoft SharePoint Designer Team Blog kicked off a blog series today that will cover a wide spectrum of topics related to the new List View in SharePoint 2010. Today’s topic, as Part 1 of the series, covered Introduction to the new List View.

The other topics that will be covered in the series are:

• List View – New User Experience
• List View Architecture
• List View Customization
• External Lists
• Conditional Formatting
• How to Share Your Custom List View Styles
• How to Create Custom Fields for the new List View
• Related Item View
• How to Create Views Displaying Cross-Web and Joined List Data