Metadata navigation > new SharePoint Server 2010 feature that enables users to dynamically filter lists

Metadata navigation is a new SharePoint Server 2010 feature that enables users to dynamically filter lists so they can find what they need. Metadata navigation enables users to select filter options, and it handles performing the query in the most efficient manner possible. Metadata navigation consists of two parts. One part is a set of navigation controls that let a user filter a list that has navigation hierarchies and key filters. The second part is a mechanism for rearranging and retrying queries.

Metadata navigation has retry and fallback logic that attempts to perform queries efficiently by using indexes. If a query will return too many results, the query falls back and returns a subset of the results for better performance. If no appropriate query can be made, fallback occurs and the filters are performed on a limited set of results. Metadata navigation automatically creates indexes. Together retry, fallback, and index management make metadata navigation a very important part of working effectively with large lists. There are two kinds of filtering mechanisms: navigation hierarchies and key filters.

Navigation hierarchies use a tree control to navigate hierarchies of folders, content types, choice fields, or managed metadata term sets. This enables users to use a tree control to pivot on a metadata hierarchy, much as how they navigate folders. When users select an item in a hierarchy for a managed metadata column, all items that match the specified term or any of its descendant child terms are displayed. This is called descendant inclusion, and it can be used on fields that are tied to a managed metadata term set. Users can select the item again to filter on only that particular term and not include the descendant child terms. All metadata navigation queries are recursive and display results from all the folders in the list.

Key filters can be configured to perform additional filtering of results within the hierarchy. For example, you can add the Modified By column as a key filter and then type a user name to obtain results where Modified By matches the entered user. For more information, see Metadata navigation and filtering (http://go.microsoft.com/fwlink/?LinkId=219154). The following figure shows an example of metadata navigation hierarchies and key filters.

 

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

First step at sharepoint2010 Client object model

information from : http://msdn.microsoft.com/en-us/library/ee857094(office.14).aspx#Y4347

my first small step

To build the application

1. Start Microsoft Visual Studio 2010.

2. On the File menu, point to New, and then click Project.

3. In the New Project dialog box, in the Recent Template pane, expand Visual C#, and then click Windows.

4. To the right of the Recent Template pane, click Console Application.

5. By default, Visual Studio creates a project that targets .NET Framework 4, but you must target .NET Framework 3.5. From the list at the upper part of the File Open dialog box, select .NET Framework 3.5.

6. In the Name box, type the name that you want to use for your project, such as FirstClientApiApplication.

7. In the Location box, type the location where you want to place the project.

   Figure 2. Creating a solution in the New Project dialog box
   

8. Click OK to create the solution.

To add references to the Microsoft.SharePoint.Client assembly and Microsoft.SharePoint.Client.Runtime assembly

1. The classes that you use in a client object model application are located in Microsoft.SharePoint.Client.dll and Microsoft.SharePoint.Client.Runtime.dll. As I mentioned, before you add the references, you must copy those assemblies from the server that runs SharePoint Foundation to the client development computer.

2. On the Project menu, click Add Reference to open the Add Reference dialog box.

3. Select the Browse tab, navigate to the location where you put the Microsoft.SharePoint.Client.dll and Microsoft.SharePoint.Client.Runtime.dll. Select both DLLs, and then click OK as shown in Figure 3.

   Figure 3. Adding references to the assemblies
   

To add the sample code to the solution

1. In Visual Studio, replace the contents of the Program.cs source file with the following code.

   using System;
   using Microsoft.SharePoint.Client;
   
   class DisplayWebTitle
   {
       static void Main()
       {
           ClientContext clientContext = new ClientContext("http://intranet.contoso.com");
           Web site = clientContext.Web;
           clientContext.Load(site);
           clientContext.ExecuteQuery();
           Console.WriteLine("Title: {0}", site.Title);
       }
   }
   

2. Replace the URL in the ClientContext constructor with the URL to the SharePoint site. Build and run the solution. The example prints the title of the site.

Just as with the SharePoint Foundation server object model, you create a context for the SharePoint site that you want to access. You can then retrieve a reference to the site from the context.

The call to the ExecuteQuery method causes the SharePoint Foundation 2010 managed client object model to send the request to the server. There is no network traffic until the application calls the ExecuteQuerymethod.

An important point to make about this example is that the call to the Load method does not actually load anything. Instead, it informs the client object model that when the application calls the ExecuteQuery method, you want to load the property values of the siteCollection object.

This is the model that all interactions with the server take:

1. You inform the SharePoint Foundation 2010 managed client object model about the operations that you want to take. This includes accessing the values of properties of objects (for example, objects of the Listclass, ListItem class, and Web class), CAML queries that you want to run, and objects such as ListItem objects that you want to insert, update or delete.
2. Then you call the ExecuteQuery method. No network traffic occurs until you call the ExecuteQuery method. Until that point, your application is only registering its requests.

As you can see from this example, at its simplest, you first set up a query, and then you execute the queries. This causes the client object model to send traffic to the server and receive a response from it. This next section reviews the model in detail and shows why it is designed the way it is, and finally, how you can build applications by using the model.

The days don't have access to SharePoint server

After change the Role from System Engineer to Web design advisor (Content Management ) , no more privilege  to log in server to run STSADM and so on ... :(

ha ha, sometime even site collection admin privilege also don't have ....ask me how to do make mine work automated?  Look like is the time to start on Using the SharePoint 2010 Managed Client Object Model

Blog about this area:

http://blogs.msdn.com/b/ericwhite/archive/2009/11/20/using-the-sharepoint-2010-managed-client-object-model.aspx

http://msdn.microsoft.com/en-us/library/ee857094(office.14).aspx

 

is time to start learn how to edit coding!! ha ha :P this is good start from me to start involve in sharepoint developer area.

Dream target : create migration tools...ha ha..