How to setup variations in MOSS 2007

What are MOSS Language Packs?
MOSS Language packs enable site owners and site collection administrators to create SharePoint sites and site collections in multiple languages without requiring separate installations of Microsoft Office SharePoint Server 2007. You install language packs, which contain language-specific site templates, on your front-end Web servers. When an administrator creates a site or a site collection based on a language-specific site template, the text that appears on the site or the site collection is displayed in the site template's language. Language Packs are typically used in multinational deployments where a single server farm supports people in different locations or in situations where sites and Web pages must be duplicated in one or more languages. Application of a Language Pack will not change the language of the installed Office server product SKU. 

 

What’s the difference between WSS Language Packs and MOSS language Packs?

• WSS Language Packs are for WSS stand-alone installations and enable the creation of SharePoint sites in different languages; multiple language packs can be installed on the same server.
• MOSS Language Packs are for MOSS, MOSS for Search, Forms Server, and Project Server installations and enable the creation of SharePoint sites in different languages; multiple language packs can be installed on the same server.  

What’s the difference between a MOSS Language Pack and a fully localized version of MOSS?
Microsoft’s 2007 Office server products are localized into languages in two different ways: 1) fully translated SKUs and 2) Language Packs. A language-specific SKU delivers the respective Office server product localized into a given language. A Language Pack may be applied to an installed Office server product to create sites or site collections in other languages. Application of a Language Pack will not change the language of the installed Office server product SKU, or the language of the admin feature

 

A small note before we start with: Site variations can only be used if you have created a site using one of the Publishing templates, or if you have activated the Publishing feature for your site.

Prepare Operating System for multi-lingual changes:-

1) Install additional language files on Windows Server 2003

• On your front-end Web server, click Start, point to Settings and then Control Panel, and then click Regional and Language Options.
• In the Regional and Language Options dialog box, on the Languages tab, in the Supplemental Language Support section, select both of the following checkboxes:
• Install files for complex script and right-to-left languages
• Install files for East Asian languages
• Click OK in the dialog box that alerts you that additional disk space is required for the files.  

• Click OK to install the additional language files.
• When prompted, insert your Windows Server 2003 product disc or provide the location of your Windows Server 2003 installation files. When prompted to restart your computer, click Yes.  

2) Install additional language files on Windows Server 2008

• Download the Windows Server 2008 Language Packs (x86 / x64) from http://www.microsoft.com/downloads/details.aspx?FamilyID=E9F6F200-CFAF-4516-8E96-E4D4750397FF&displaylang=en; It will download Language Pack as .IMG file
• Extract the .IMG file using WinRAR or UltraISO to a folder, you should see a folder by name “langpacks” within extracted folder
• Do the following for each front-end Web server -
• On your front-end Web server, click Start, point to Settings and then Control Panel, and then click Regional and Language Options.

• In the Regional and Language Options dialog box, on the Keyboards and Languages tab, in the Display Language section, click Install/Uninstall languages.

• In the Install or Uninstall Languages dialog box, click Install languages.

• On the Select the Languages to Install page click Browse folder to navigate to where you extracted; point it to the “langpacks” folder > Click Select Folder
• 
  
  
  
  
  
    
• Select the language to install from the list of available languages
• Select all the languages that you want to install, and then click Next.
• Accept the terms, and then click Next.
• Click Install.

Prepare SharePoint for multi-lingual changes:- 

 

WSS Language Pack Go to http://www.microsoft.com/downloads/details.aspx?FamilyID=36ee1bf0-652c-4e38-b247-f29b3eefa04&DisplayLang=en and Change Language to French  Website language will now change to French
click on download
MOSS Language Pack Go to http://www.microsoft.com/downloads/details.aspx?familyid=2447426b-8689-4768-bff0-cbb511599a45&displaylang=en and Change Language to French Website language will now change to French
click on download

• Save SharePointLanguagePack.exe and ServerLanguagePack.img to a folder on WFE
• Extract ServerLanguagePack.img using WinRAR or UltraISO
• Install SharePointLanguagePack.exe for WSS > Don’t run PSCONFIG now
• From extracted location run Setup.exe for MOSS
• Run PSCONFIG and ensure its successful > IISRESET
• Browse to MOSS site where you want to configure variations > Go to Site Settings > Variations
• 
  
  
  
  
  

   
• Specify the variation home (if same site then put a "/")
• Choose the following settings
• Automatically create site and page variations
• Recreate a new target page when the source page is republished.
• Update Web Part changes to target pages when variation source page update is propagated.
• Reference existing resources
• Go to Site Settings Variation Labels  New Label  Provide values as below screenshot > OK
  
  
  

   
  
  
   (Now we are making a label for default language site (English in our case) and hence it will be the source variation)

Click on New Label again > Create another variation label using different language (French in our case)

 

 

• Click on button
• You will see the variations are being created

• Ensure
  
   
• Now the site is available in English and French and any new pages will be created in French as well

 More Info: 

• Administer Variations - http://technet.microsoft.com/en-us/library/cc770241.aspx
• Deploy Language packs - http://technet.microsoft.com/en-us/library/cc262108.aspx

Programatically Add audiences and audience rules

Adding audiences and audiences rules programatically using SharePoint Object code


SPSecurity.RunWithElevatedPrivileges(delegate()
{
try
{
String siteUrl = args[0];
using (SPSite site = new SPSite(siteUrl))
{
ServerContext context = ServerContext.GetContextsite);
AudienceManager audManager = new AudienceManager(context);
AudienceCollection ac = audManager.Audiences;
Audience audNew1 = null;
Audience audNew2 = null;
string sNewAudience1 = "New Audience 1";
string sAudience1Description = "Description for New Audience 1";
string sNewAudience2 = "New Audience 2";
string sAudience2Description = "Description for New Audience 2";
try
{ //Create the audience for New Audience 1
audNew1 = ac.Create(sNewAudience1 , sAudience1Description);
ArrayList AudRules = new ArrayList();
AudienceRuleComponent rule1 = new AudienceRuleComponent
("", "=", "");
AudRules.Add(rule1);
AudienceRuleComponent rule2 = new AudienceRuleComponent("", "=", "");
AudRules.Add(rule2);
AudienceRuleComponent rule3 = new AudienceRuleComponent("", "=", "");
AudRules.Add(rule3);
AudienceRuleComponent rule4 = new AudienceRuleComponent("", "=", "");
AudRules.Add(rule4);
audNew1.AudienceRules = AudRules;
audNew1.Commit();
Console.WriteLine("New Audiences 1 added successfully");
//Create the audience for New Audience 1

audNew2 = ac.Create(sNewAudience2, sAudience2Description);
AudRules.Clear();
AudienceRuleComponent rule5 = new AudienceRuleComponent("", "=", "");
AudRules.Add(rule5);
AudienceRuleComponent rule6 = new AudienceRuleComponent("", "=", "");
AudRules.Add(rule6);
AudienceRuleComponent rule7 = new AudienceRuleComponent("", "=", "");
AudRules.Add(rule7);
audNew2.AudienceRules = AudRules;
audNew2.Commit();
Console.WriteLine("New Audiences 2 added successfully");
}
catch (AudienceDuplicateNameException e)
{
Console.WriteLine(e.ToString());
Console.Read();
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
Console.Read();
}
});

SharePoint Architecture

SharePoint Architecture
Both ASP.NET and WSS rely on IIS 6.0 to supply the underlying listening mechanism to process incoming HTTP requests and supply a management infrastructure for launching and running worker processes on the Web server.An IIS Web site provides an entry point into the IIS Web server infrastructure. Each IIS Web site is configured to listen for and process incoming HTTP requests that meet certain criteria.For example, an IIS Web site can be configured to handle requests coming in over a specific IP address or port number or can be routed to the Web server by using a specific host header,such as http://Extranet.Litwareinc.com.IIS automatically creates and configures an IIS Web site named Default Web Site that listens for HTTP requests coming in over port 80 on any of the IP addresses supported on the local Web server.Each IIS Web site is configured to map to a root directory, which is a physical directory on the file system of the hosting Web server. For example, standard configuration for IIS maps the Default Web Site to a root directory located at C:\Inetpub\wwwroot. In the most straightforward routing scenarios, IIS maps incoming HTTP requests to physical files inside the root directory.For example, IIS will respond to a request for http://www.Litwareinc.com/page1.htm by simply loading the contents of the file located at c:\Inetpub\wwwroot\page1.htm into memory and streaming it back to the client.A virtual directory is an entity that defines a child URL space nested within the URL space of its parent IIS Web site. Like an IIS Web site, a virtual directory is configured with a root directory on the file system of the hosting Web server.Note that IIS tracks configuration information about its IIS Web sites and virtual directories in a repository known as the IIS metabase. The IIS metabase lives on the file system of each front-end Web server running IIS. For example, when you create and configure an IIS Web site using the IIS administration utility, IIS tracks these changes by writing entries to the local IIS metabase.

ISAPI Extensions and ISAPI Filters

In the most straightforward routing scenarios, IIS simply maps an incoming request to a physical file within the root directory of an IIS Web site or virtual directory. However, IIS also supports the Internet Server Application Programming Interface (ISAPI) programming model, which provides the opportunity for more sophisticated routing scenarios. In particular, the ISAPI programming model allows you to configure an IIS Web site or virtual directory so that incoming requests trigger the execution of custom code on the Web server.The ISAPI programming model consists of two primary component types: ISAPI extensions and ISAPI filters.

An ISAPI extension is a component DLL that plays the role of an endpoint for an incoming request. The fundamental concept is that IIS can map incoming requests to a set of endpoints that trigger the execution of code within an ISAPI extension DLL. An ISAPI extension DLL must be installed on the Web server and configured at the level of either an IIS Web site or virtual directory. Configuration commonly involves associating specific file extensions with the ISAPI extensions by using an IIS application map.

While an ISAPI extension serves as an endpoint, an ISAPI filter plays the role of an interceptor(interrupt/stop).An ISAPI filter is installed and configured at the level of the IIS Web site. Once installed, an ISAPI filter intercepts all incoming requests targeting that IIS Web site. The fundamental concept is that an ISAPI filter can provide pre-processing and post-processing for each and every incoming request. ISAPI filters are typically created to provide low-level functionality for an IIS Web site, such as custom authentication and request logging.

Application Pools and the IIS Worker ProcessIIS

provides a flexible infrastructure for managing worker processes by using application pools. An application pool is a configurable entity that allows you to control how IIS maps IIS Web sites and virtual directories to instances of the IIS worker process. Note that instances of the IIS worker process are launched using an executable named w3wp.exe as shown in the below picture

The routing architecture of IIS is controlled by a kernel-level device driver named http.sys.This device driver listens for incoming HTTP requests and uses information in the IIS metabase to route them to whatever instance of w3wp.exe is associated with the target application pool. If http.sys determines that the target application pool doesn’t have a running instance of w3wp.exe, it launches a new instance on demand to process the request.Every application pool has an important setting known as the application pool identity. The application pool identity is configured with a specific Windows user account that is either a local account on the Web server or a domain account within an Active Directory directory service domain. When http.sys launches a new instance of w3wp.exe for a specific application pool,it uses the application pool identity to initialize a Windows security token that serves as the process token.

ASP.NET 2.0 Framework

The ASP.NET Framework is implemented as an ISAPI extension named aspnet_isapi.dll. The basic configuration for ASP.NET involves registering application maps for common ASP.NET file extensions including .aspx, .ascx, .ashx, and .asmx at the level of an IIS Web site or virtual directory. When IIS sees an incoming request targeting a file with one of these extensions, it forwards the request to aspnet_isapi.dll, which effectively passes control over to the ASP.NET Framework.Once the ASP.NET page parser builds the source file for an .aspx page, it can then compile it into a DLL. This compilation occurs automatically the first time the .aspx file is requested.Once the ASP.NET runtime has compiled an .aspx file into a DLL, that copy of the DLL can be used for all subsequent requests that target the same .aspx file. However, the ASP.NET runtime monitors the datetime stamp on the .aspx file and retriggers the compilation process to rebuild the DLL if it sees that the associated .aspx file has been updated.A page that links to a master page is known as a content page.

HTTP Request Pipeline the below figure displays a picture of the HTTP Request Pipeline and its three replaceable component types: HttpHandler, HttpApplication, and HttpModule. As requests come in, they are queued up and assigned to a worker thread that then processes the request by interacting with each of these component types.

The ultimate destination of any request is the endpoint, which is modeled in the HTTPRequest Pipeline by using an HttpHandler class, which implements the IHttpHandlerinterface. As a developer, you can create a custom HttpHandler component and plug it into the HTTP Request Pipeline by adding configuration elements to the web.config file.The HTTP Request Pipeline places an HttpApplication component in front of the HttpHandler.

On an application-wide basis, incoming requests are always routed through the HttpApplication before they reach the target HttpHandler, thus giving the HttpApplication the ability to preprocess any request no matter which HttpHandler it is being routed to. This preprocessing stage is handled through a series of events that are defined inside the HttpApplication class such as BeginRequest, AuthenticateRequest, and AuthorizeRequest.However, you can replace this standard component by creating a file named global.asax and placing it in the root directory of the hosting ASP.NET application. For example, you can create a global.asax that looks like the following:

protected void Application_AuthenticateRequest(object sender, EventArgs e) {

// your code goes here for request authentication}

protected void Application_AuthorizeRequest(object sender, EventArgs e) {

// your code goes here for request authorization}

The third replaceable component type in the HTTP Request Pipeline is the HttpModule. The HttpModule is similar to the HttpApplication component in that it is designed to handle events defined by the HttpApplication class and is processed before control is passed to any HttpHandler classes. For example, you can create a custom HttpModule component to handle request-level events such as BeginRequest, AuthenticateRequest, and AuthorizeRequest. As with the HttpHandler, an HttpModule class is defined with an interface. You can create a class that implements the IHttpModule interface and plug it into the HTTP Request Pipeline by adding configuration elements to the web.config file.Whereas custom HttpApplication components can be defined as simple text files with an.asax extension, custom HttpModule components are always compiled as classes withinassembly DLLs. To add a custom HttpModule component into the HTTP Request Pipeline,you then add entries into a web.config file.

HttpModule components can be configured at the machine level. In fact, the ASP.NETFramework ships with several different HttpModule components that are automaticallyconfigured at the machine level to provide ASP.NET functionality for things such as Windows authentication, Forms authentication, and output caching.

The final component that we want to discuss with respect to the HTTP Request Pipeline is HttpContext. As ASP.NET initializes a request to send to the HTTP Request Pipeline, it creates an object from the HttpContext class and initializes it with important contextual information.The Object contains such as Request, User, and Response.HttpContext currentContext = HttpContext.Current;string incomingUrl = currentContext.Request.Url;string currentUser = currentContext.User.Identity.Name;currentContext.Response.Write("Hello world");

WSS Integration with ASP.NET

WSS integrates with ASP.NET at the level of the IIS Web site. Each IIS Web site in which you intend to host WSS sites must go through a one-time transformation process in which it is configured to become what WSS terminology refers to as a Web application. This transformation process involves adding IIS metabase entries and a WSS-specific web.config file to the root directory of the hosting IIS Web site. Once the transformation is completed, WSS extends the routing architecture of IIS and ASP.NET to properly route all incoming requests through the WSS runtime.

Creating a Web application requires a significant number of changes to the file system and the IIS metabase on each front-end Web server. In a Web farm environment, these changes are automatically mirrored across each front-end Web server in the farm by the WSS runtime.

Once a Web application is created, it is no longer necessary to touch the file system or IIS metabase of the front-end Web server when creating, updating, and deleting sites or site collections. The WSS architecture makes it possible to provision new sites and site collections simply by adding entries to the configuration database and a content database. It is this aspect of the WSS architecture that gives it significant management and provisioning advantagesover ASP.NET.

Web Applications

Two primary ways exist to create a Web application by using either the WSS Central Administration Application or the stsadm.exe command-line utility. First, you can create a Web application by converting an existing IIS Web site. Alternatively, you can create a new Web application from scratch and let WSS create the new IIS Web site for you behind the scenes. In either case, WSS configures the resulting IIS Web site by adding an IIS application map and creating several virtual directories. WSS also copies a global.asax file and web.config file to the root directory of the hosting IIS Web site.WSS must add an IIS application map to each Web application to ensure that each and every incoming request is initially routed to the ASP.NET runtime. Remember that the default configuration for ASP.NET only registers application maps for requests with well-known ASP.NET file extensions such as .aspx, ascx, .ashx, and .asmx. Therefore, WSS configures the hosting IIS Web site with a wildcard application map to route all incoming requests to aspnet_isapi.dll, including those requests with non-ASP.NET extensions such as .doc, .docx, and .pdf.

Because every request targeting a Web application is routed through aspnet_isapi.dll, the request gets fully initialized with ASP.NET context. Furthermore, its processing behavior can be controlled by using a custom HttpApplication object and adding configuration elements to the web.config file. The WSS team uses standard ASP.NET techniques to extend the HTTP Request Pipeline by using several custom components, as shown in the below figure

First, you can see that WSS configures each Web application with a custom HttpApplication object by using the SPHttpApplication class. Note that this class is deployed in the WSS system assembly Microsoft.SharePoint.dll. WSS integrates this custom application class by creating a custom global.asax file at the root of the Web application that inherits from SPHttpApplication.

You can see that the standard WSS web.config file configures SPRequestModule so that it is the first HttpModule to respond to application-level events in the HTTP Request Pipeline of ASP.NET. If you examine the web.config file for a WSS Web application, you will see that WSS adds back in several of the standard HttpModule components from the ASP.NET Framework that deal with things such as output caching and various types of authentication.

SPVirtualPathProvider

One of the strengths of WSS over ASP.NET is its ability to provision and customize pageswithin a site without having to make any changes to the local file system of the front-end Webserver. This capability of WSS to provision and customize pages is made possible by storingcustomized versions of .aspx files and .master files inside the content database and retrievingthem on demand when they are needed to process an incoming page request.

when the same page is requested, WSS must retrieve the contents of this customized page definition from the content database and pass it along to the ASP.NET runtime for parsing. We will now explain the architectural details that make this possible.

ASP.NET 2.0 introduced a new pluggable component type known as a virtual path provider. The idea behind a virtual path provider is that it abstracts the details of where page files are stored away from the ASP.NET runtime. By creating a custom virtual path provider, a developer can write a custom component that retrieves ASP.NET file types, such as .aspx and .master files, from a remote location, such as a Microsoft SQL Server database. Once a virtual path provider retrieves the contents of an .aspx page, it can pass it along to the ASP.NET runtime for parsing.

SPVirtualPathProvider is able to retrieve an ASP.NET page file from the content database, such as default.aspx, and then pass it along to the ASP.NET page parser. The SPVirtualPathProvider class works together with another class named the SPPageParserFilter to supply processing instructions to the ASP.NET page parser. For example, the SPPageParserFilter component controls whether the ASP.NET page parser compiles the ASP.NET page into an assembly DLL or whether it processes the page in a no-compile mode that is introduced with ASP.NET 2.0.

Imagine that you have just created 100 new WSS sites from the Blank Site template. If none of these sites requires a customized version of its home page (default.aspx), would it still make sense to copy the exact same page definition file into the content database 100 times? The answer to this question is obviously no. Fortunately, pages within a WSS site such as default.aspx are based on page templates that live on the file system of the front-end Web server. Page templates are used to provision page instances within the context of a site, such as the page that is accessible through a specific URL like http://litwareinc.com/default.aspx.

When a page instance is initially provisioned from a page template, WSS doesn’t need to store a copy of it in the content database because WSS can load the page template from the file system of the Web server and use it to process any request for an uncustomized page instance.

Therefore, you can say that page ghosting describes the act of processing a request for an uncustomized page instance by using a page template loaded into memory from the file system of the front-end Web server.

Page ghosting is valuable because it eliminates the need to transfer the contents of a page definition file from the SQL Server computer with the content database to the front-end Web server computer. Page ghosting also makes it possible to process the home pages for thousands of different sites by using a single page template that is compiled into an assembly DLL and loaded into memory in the IIS worker process just once per Web application. Both of these optimizations are key factors in the scalability of WSS in high-traffic environments running thousands or tens of thousands of sites.

Customized pages are sometimes referred to as unghosted pages
SPVirtualPathProvider that determines whether the page being requested has beencustomized. The SPVirtualPathProvider makes the decision whether to process a page as a ghosted or an unghosted page.The new architecture introduced in WSS 3.0, which includes the SPVirtualPathProvider and the ASP.Net page parser, should be seen as one of the more significant architectural enhancements over WSS 2.0.
When WSS converts an IIS Web site into a Web application, it creates several virtual directories. These virtual directories, including the _controltemplates directory, the _layouts directory, the _vti_bin directory, and the _wpresources directory, are used by various aspects of the WSS runtime. The _wpresources virtual directory provides a repository for resource files that are deployed along with Web Parts.
Application pages are served up from the _layouts directory.

New features announced for SharePoint 2010

Development environment and tools
Traditionally, the path to your first SharePoint hello world-web part is littered with technical obstacles in the shape of tedious installation problems, Windows Server 2003 blues, virtual server nightmares etc. No more. Now you just need your laptop to develop SharePoint applications.
The box
SharePoint developers no longer need to run a Windows 2003 Server. In fact, SharePoint and the development tools can now be installed directly on Windows 7 or Vista (service pack 1). Either versions of SharePoint can be used, i.e. SharePoint Foundation (formerly WSS) or SharePoint Server.
The operating system must be 64 bit since SharePoint 2010 only runs in a 64 bit environment.
SharePoint on a desktop operating system is just for developers and not for running a production environment.

Visual Studio 2010
Many of SharePoint 2010’s new features can be accessed from inside Visual Studio 2010. Also, quite a few third-party add-ons may not be needed anymore as the functionality is now covered by Visual Studio.
Highlights:
· Built-in designers for:
o Web parts
o BCS (formerly BDC)
o Workflows
· Package and deploy SharePoint projects
· Generate WSPs
· View SharePoint sites in server explorer
· Integration to Team Foundation Server
· Support for SharePoint sandboxed solutions
· WSPs from SharePoint Designer can be imported (including workflows)
· Build workflow steps for SharePoint Designer
· SharePoint Business Connectivity Services support
· New events projects templates

General improvents

Developer dashboard
A developer dashboard can be displayed automatically at the bottom of every page. The DD displays valuable information about how the page is generated, for instance:
· Timing and duration of events
· Database queries (even the ones SharePoint does in the background)
The DD is activated with the follow stsadm command:
stsadm –o setproperty –pn developer-dashboard –pv ondemand

Coding
Coding for SharePoint just got slightly easier due to the many improvements in .NET framework 4.0 and SharePoint 2010.
Below is a rundown of some of the new features:
· LINQ for SharePoint
· After-synchronous events
· New event types:
o Site-scoped events
o Web creation events
· Workflow improvements:
o Initiation and association forms in Visual Studio
o New design user interface for workflows in SharePoint Designer
o Use Visio 2010 to design workflows
· SharePoint UI can now be saved as a template
· WSP is now the unified developer format – works in site collections and machine

Improvements to lists
In SharePoint 2007, lists can cause any developer headaches. Hopefully, the new list architecture in SharePoint 2010 will solve this. Below is an overview of some of the improvements:
· Validation with Excel-like Formula – forms can be validated using simple syntax
· Lookup to multiple columns
· Lookup fields have true relations which ensure proper deletion (transaction-style)
· List index auto-creation
· Scalability and performance vastly improved:
o Lists and folders can now contain a million elements
o Document libraries can contain 10 million documents
· List query throttling
· Lists views no longer based on CAML but XSL-T. Queries still use CAML

Ribbon and Dialog framework
The ribbon we know (and some love) from Microsoft Office is now used in SharePoint 2010.
Some of the highlights:
· Custom actions can be embedded in the ribbon
· The ribbon is context sensitive
· The SharePoint out-of-the-box forms are replaceable
· New web dialog functionality:
o A dialog floats on top of the SharePoint page and is used to get input from the user
o Fully programmable

Silverlight 3
Silverlight plays an important part in SharePoint 2010 and is used in many of the improved UI elements. From a developer’s point of view, these are the highlights:
· Built-it and customisable media player web part
· List and site creation from within Silverlight
· Office web applications run in Silverlight
· Client object model – call SharePoint APIs from within Silverlight
New features in 2010
User interface
· Ribbon-based contextual menus, much like in Office 2007
· Live preview of font changes etc.
· Broad use of AJAX to minimise number of page refreshes
· More seamless integration of web-based and desktop clients
· All Office documents can now be viewed and edited in a rich web version of the desktop client
Accessibility
· Cross-browser compatibility
· XHTML and WCAG compatible output
Collaboration
· Completely revamped wiki
o Improved editing tool
o Dramatically improved image upload and handling
· Richer blogs
· Improvements to the calendar lists
· Web-based, OneNote-like functionality
Organisation
· Tagging, social tagging
· Rating of documents
· Bookmarks
MySite and Social Computing
· Smart profiles
· Activity feed – overview of a user’s recent activity
· Browse colleagues
· Locate experts within the organisation
· Tag cloud of a person’s recent activities
· Note board – i.e. a tagwall
Content Management
· Improved scalability – lists and folders can now contain a million elements. Document libraries can contain 10 million documents
· Digital Asset Management
· Consistent content type across all servers in a farm
· Streaming of video placed in document libraries
· Improved governance possibilities
Search
· Choice between standard SharePoint search and FAST Search
· Wild card searching – used of asterisks
· Improved people search – rich info on the search results page
· Live preview of documents, slides etc right on the search results page
Business intelligence
· Excel Services – including SQL Server PowerPivot
· PerformancePoint Services – advanced BI dashboards
· Visio Services and Chart web part
· Business Connectivity Services – the new name for Business Data Catalog (BDC)
SharePoint Workspace (the new name for Groove)
· Improved offline content
· Improved mobile access to content
IT infrastructure
· 64-bit only!
· SharePoint Foundation is the new name for WSS
· Online/cloud version of SharePoint is a focus point for Microsoft
· PowerShell Admin
o Fully scriptable admin of SharePoint
o Around 500 PowerShell commandlets will be shipped with 2010
o Admin SharePoint from PowerShell running on Windows 7
o Whatif command to preview impact of commands
· New Central Administration
o Problems and solutions page with overview of current problems on the farm, and possible solutions
· Throttling
o Control how many resources specific lists, sites etc. may use
· Monitoring, Analytics
o Usage analysis database will be customisable
· Improved Upgrade and Availability
o Visual Upgrade enables individual users to choose when to upgrade a site

Meanings of variables in the context menu's script

Meanings of variables in the context menu's script

If you are building a web part that displays context menus for list items - just like the context menus that SharePoint builds out of the box, you need to know the meaning of the attributes that you need to add to the table that holds the item. I couldn't find any documentation or referance to it on the internet, so I decided to publish the results of my diggings.
If you look at the source html of the built-in web part,you will see that every item with a context menu looks like this:


<table height="100%" cellspacing="0" class="ms-unselectedtitle" onmouseover="OnItem(this)" id="1"
ctxname="ctx1"
url="/Documents/Sample%20Document.docx"
dref="Documents"
perm="0x7fffffffffffffff"
type=""
ext="docx"
icon="icdocx.gifMicrosoft Office WordSharePoint.OpenDocuments"
otype="0"
couid=""
sred=""
cout="0"
hcd=""
csrc=""
ms="0"
ctype="Document"
cid="0x0101006121B9A5B6A75F49AD8620D335B47E62"
uis="1024"
surl="">


The question is asked - what do those attribute mean? what is "cout" and what is "otype"? what values are expected there?
After some research, here is my dictionary:
ctxname: Name of the context object on the page that holds the context for the list that you are connecting to.
url: link to the document (can be either relative or absolute.
dref:File Directory Referance - the relative folder path the item\document is in. For example if I have a document library called "documents" with the url "http://portal/documents", the items in the root folder will have "documents" as the dref value, while items in a folder called "test" will have "documents\test".
perm: has to do with permissions, but I didn't figure out how it works yet.
type: Seems not to be used for items - but to create menu seperators or different kind of menus.
ext: The document extension. For example "doc", "docx", "ppt" and so on.
icon: This seems to control the "edit" menu item. Here you specify the icon that will be displayed next to the "edit in..." menu item, the text that will appear as the name of the application (edit in Microsoft Word) and the script that will be used to edit the item (I have no idea what possible values can be used here). All of this seperated by the "" character.
otype: Current Item FSObj Type. This seems to have something to do with the check in-check out menus, that will not be displayed if this is 1, but I could not figure out what is the logic here.
COUId: Current Item Checked Out User Id. (ID of the user in the web site the item is from)
sred: Server File Redirect. Allows you to specify a URL that will be used instead of the file's url when the link is clicked or when a menu option is used. For example, if you put a link to another document, all menu actions will be redirected to that document instead.
cout: Current Item Checkedout To Local. If the item is checked out to a local (offline) folder and not to the database. 0 for false, 1 for true.
hcd: Controls if a menu item to navigate to the "/_layouts/updatecopies.aspx" will be added. I am guessing this has to do with records management (update copies of the document when it was changed).
csrc: Copy source link. If the item is a copy of an item in a records management site, this holds the link to the source, and adds the menu item for going to the source file (Go to source).
ms: Current Item Moderation Status. Also has to do with if its checked out or not, and if its draft or not.
ctype: The type of the item. I could not find where that is used.
cid: Content Type ID. The ID of the content type for the item. also seems to be used for list menus to determine the content type to create when a user clicks on the new item menu.
uis: Current Item UI String. Seems to hold the version number, where the major version is a multiplication of 512, and the minor version is the reminder (the script gets the minor version number by doing "%512"). For example, a value of 512 is version 1.0 while 513 is version 1.1 and 1024 is version 2. Does this mean we have a version limit of 511 minor versions in sharepoint? According to the "introduction to versioning", this is only the default and the administrator can change this. This sounds fishy considering the "512" limit is hard coded in the javascript.
surl: Source Url. This dictates where the page will go back to after a menu item is clicked.

An Architectural Introduction to Web Parts and ASP.NET

An Architectural Introduction to Web Parts and ASP.NET

Web Part Framework The Web Part Framework is the basis for extensibility in Windows SharePoint Services. It allows developers to write custom components that plug into the SharePoint infrastructure by encapsulating web services and enterprise data as Web Parts. Windows SharePoint Services as a whole is based heavily on .NET technologies: · ASP.NET instead of ISAPI for base page execution · CLR based server object model for programmatic access to SharePoint data · XML Web services-based access of SharePoint data from remote machines In keeping with this investment in .NET technologies, the Web Parts Framework is also based entirely on ASP.NET: · Web Part pages are ASP.NET pages. ·

Web Parts are ASP.NET custom controls. The fundamental notion in the Web Part Framework is that of a Web Part Page. A Web Part Page is essentially a scalable version of the Digital Dashboard. It is a container of Web Parts. A Web Part Page uses Windows SharePoint Services to store per-user views of the page, which enables powerful customizations on a user-by-user basis.

What Are Web Parts?
Web Parts are customizable plug and play components that empower information workers to create personalized user interfaces by simply dragging and dropping them onto a web page. Web parts allow customization at both design time and at run time. In fact, Web Parts blur the distinction between design time and run time: ·
Web page authors use FrontPage 2003 to work with Web Parts by dragging and dropping them to a Web Part Page, and then customizing them using the developer enabled properties. In this sense, Web Parts are similar to design time controls. · Web Parts also enable web page authors to use the browser as their authoring platform. Windows SharePoint Services provides a browser-based interface to design a SharePoint based site. ·

The end user can customize a Web Part Page at run time by modifying the properties of each individual web part. The page author can designate which web parts can be customized or not by grouping them into “zones” and setting the appropriate properties on the zone using FrontPage 2003. From the point of view of a developer, a web part is simply a specialized ASP.NET server control. To create a new Web Part, you create an ASP.NET custom control. However, unlike standard ASP.NET controls, which developers add to Web form pages at design time, Web Parts are intended to be added to Web Part Pages either by authors at design time, or by users at run time. Note: Developers can also use Web Parts in “regular” ASP.NET pages, but in doing so, the developer loses the advantages of integration with Windows SharePoint Services.

Web Parts and Windows SharePoint Services Web Parts rely heavily on Windows SharePoint Services to support: ·
Creation of new sites and new pages ·
Management of the user roster for a site ·
Storage of Web Part customizations, including shared and personal property settings · Administration of site backups and storage limits ·
A scalable architecture that can handle thousands of sites and millions of users ·
Assignment of users to customizable site groups In turn, SharePoint Products and Technologies rely on Web Parts to provide configurable and extensible user interfaces.

Composition of a Web Part A Web Part is composed of the following entities: · The Web Part description file (.dwp) is a portable container of default and personalized property values for the Web Part. · The Web Part assembly file (.dll) contains the logic and code for the Web Part, and is installed on the server running Windows SharePoint Services. · Resource files that support the Web Part; these are also stored on the server. ·

Tables in the Windows SharePoint Services database are used to store current values of the Web Part properties. Windows SharePoint Services has been designed from the ground-up to be a powerful collaborative platform. It is possible and indeed commonplace for your web site to contain multiple instances of the same Web Part. Each instance would conceivably have a different set of properties. Regardless of the number of instances of the Web Part, there is only one Web Part assembly file. Any instance-specific customizations are stored in the .dwp file and there exist as many .dwp files for a Web Part as there are instances of that part.

c# yield return

c# yield return

One interesting new feature of the C# 2.0 is the "yield" keyword. Basically it is used to iterate through objects returned by a method. It creates a state engine in IL so you can create methods that retain their state and dont have to go through the pain of maintaining state in your code.

The yield keyword signals to the compiler that the method in which it appears is an iterator block. The compiler generates a class to implement the behavior that is expressed in the iterator block. In the iterator block, the yield keyword is used together with the return keyword to provide a value to the enumerator object. This is the value that is returned, for example, in each loop of a foreach statement. The yield keyword is also used with break to signal the end of iteration. For more information about iterators, see Iterators (C# Programming Guide). The following example shows the two forms of the yield statement.

The below example helps you better understand:

public class List
{
//using System.Collections;
public static IEnumerable Power(int number, int exponent)
{
int counter = 0;
int result = 1;
while (counter++ < exponent)
{
result = result * number;
yield return result;
}
}
static void Main()
{
// Display powers of 2 up to the exponent 8:
foreach (int i in Power(2, 8))
{
Console.Write("{0} ", i);
}
}
}
/*
Output:
2 4 8 16 32 64 128 256
*/

issues with People Picker

Recently I installed MOSS SP2 in one of my servers and there after my people picker stopped resolving the entries.

After a deep analysis i found the issue and solved it.

The App Pool account associated with all the MOSS Web Application including SharePoint Central Administration 3.0 is using a local account within the same box. Now this account is being used by ASPNETMembershipServices to resolve the entries which is failing.


As a workaround i changed the App Pool account to a network service account and it started working.

I followed the steps as I already mentioed in my previous post http://sharepointstuff4u.blogspot.com/2009/10/how-to-change-app-pool-account-of-moss.html

To change App Pool account of SharePoint Central Administration 3.0 Web Application I used STSADM command "UPDATEFARMCREDENTIALS" by passing the credential values.

Working with Large SharePoint Database files

The main source of the problem is that when most folks install SharePoint they don’t realize that it creates the databases and sets them to Full Recovery Mode.
What this means is the database log (.ldf) file never gets shrunk.
Mainly this is so that if something happens to the database they you have a full history of all of the transactions that have taken place. Let’s see what we can do about this.

First open up your file explorer on your database server or whatever server your database files are located on and look at the size of the database .mdf and .ldf files. If you have a default install of SQL Server you can find these files under C:\Program Files\Microsoft SQL Server\MSSQL.1\MSSQL\Data. Usually if you find that the .ldf files are in the high MB or GB you definitely need to continue with this article. If not at least check to verify that you have database backups and/or maintenance plans in place

The below approach applies for Sql Server 2005

STEP 1: Backup all the SharePoint Databases If you are going to do anything with the databases it is always a great idea to do a Full backup on each database

STEP 2: Change the Recovery Mode of the database this is a fairly easy thing to do. You log in to SQL Server and navigate your way to each one of the databases you want to take care of. The following screen shot is of the database properties dialog.

Just right click the database and select “Properties”. Open Sql Server Management Studio à Under your Server Name Node Expand Databases Nodeà Select the Database you want to shrink à right click and select Properties which opens a new popup window with properties à Click options on the left tab and select “Simple” instead of “Full” for Recovery Model as shown below The red outlined section is the recovery model setting. Currently it is set to FULL. The other selection “Simple” is the selection we need to use. So select “Simple” and click OK.

STEP 3: Shrink that excessive log file!!! So the database that I am currently using as an example the log file is nearly 2 GB (actually it is 1.795GB). To shrink the database log file, right click the database and select “Tasks”, then select “Shrink”, then select “Files”. You will get this dialog:

The database file type is what we are after. We want to switch it to “Log”. Notice the red highlight. Look at the log file size and the available free space. You have the ability to recapture nearly 89% of the space that is currently allocated. Make sure that the shrink action is set to release unused space and click OK. Now your log file should shrink to only the needed space and it should end up around a few hundred KB.
The important take away here is that when you set up SharePoint you need to be sure that you are actively maintaining your system or be sure that you have the proper processes in place for the database.

-------------------------------------------------------------------------------------------------

Alternately you can follow the beow approach:

You might run into a scenario on your SharePoint development box where the WSS_Content_log file grows to be quite large. If you’re limited on hard drive space and need to know how to truncate and shrink this log file, follow the directions below. For my particular installation, I had WSS 3.0 and SSEE installed with all the defaults.
Before we begin, you may want to take a bit of time to learn about Recovery Models, Truncating and Shrinking.
Let’s start. Open Microsoft SQL Server Management Studio Express. If you don’t have that tool installed, you can get it free from Microsoft. Expand Databases. Right click on the WSS_Content database, go to Properties, Options, and change Recovery model: to Simple. Click OK.
Click New Query. Once the blank page opens up, make sure the WSS_Content database is selected.
Run the following command first. This will truncate the log file. We must do this step first before we can shrink the file.

BACKUP LOG WSS_Content WITH TRUNCATE_ONLY
The next step will actually shrink the log file and recover our disk space. You can use the command below to confirm the name of the file we’ll be shrinking.

SELECT * FROM sys.sysfiles
The name column will give us the information for the last command – the name of the log file itself. In this case, it’s WSS_Content_log:

DBCC SHRINKFILE(WSS_Content_log, 1)
That should do it. I had a 4 gig content db and a 26 gig log file. All of the above took about 5 minutes or so.

How to change the App Pool account of the MOSS web applications.

How to change the App Pool account of the MOSS web applications.
Go to SharePoint Central Administration 3.0 -->
Opertations tab -->
Under Security Configuration select "Service Accounts" -->
For Credential Management select the radio button option Web application pool-->
in the Web Service drop down select Windows SharePoint Services Web Application-->
Under Application Pool drop down select the web application you want to change the Application Pool account-->
Now From the available options specify the parameters of your choice-->
Click "OK"

Then restart IIS as mentioed below:
To restart the application pool, either open IIS and recycle the application pool, or open a command prompt and type iisreset -noforce. Open your SharePoint site in a browser to confirm that the change was successful. This change will be automatically propagated to all web front-ends.

MOSS Web services Proxy classes

Some times it may so happen that you will not be able to add Web reference to the built in MOSS Web Services because of problems with adding the web reference, may be due to some web reference errors. Don't worry there is an alternative….

Since the functionality exposed by MOSS Web Services is consistent across, select any of the instance where MOSS is installed, create a proxy class using WSDL utility and change the target Url to your local server where you would like to refer.

Once the proxy class is generated within the default constructor change the target url as below:
this.Url = "http://Servername:portnumber/_vti_bin/lists.asmx";

Start with your regular object model to work with SharePoint Web Services and you are done……

Querying a SharePoint list with JavaScript

I came across an interesting article to Query SharePoint list Items using JavaScript which I want to share with you. JavaScript uses the built in web services of MOSS and makes HTTP Request to the web service to retrieve the list items.

Use the below script functions:

function QueryListEx(listGuid, fields, where, orderBy, rowLimit, extractRows)
{ var a = new ActiveXObject("Microsoft.XMLHTTP");
if(a == null) return null;
a.Open("POST", GetRootUrl() + "_vti_bin/DspSts.asmx", false);
a.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
a.setRequestHeader("SOAPAction", "http://schemas.microsoft.com/sharepoint/dsp/queryRequest");
var d = '' + "" +" " +" " +" 1.0" +" " +" " +" " +" " + "" + "http://schemas.microsoft.com/sharepoint/dsp\">" +" " +" " +" " + fields + "" +" " + where + "" +" " + orderBy + "" +" " +" " +" " + "" + "";

a.Send(d);
if (a.status != 200)
return null;
else
{
if (extractRows)
return a.responseXML.selectNodes('//Row');
else
return a.responseXML;
}
}

function GetRootUrl()
{
var pathparts = document.location.pathname.split('/');
var url = 'https://' + document.location.hostname + '/' + pathparts[1] + '/';
return url;
}


function GetList(listName)
{
var a = new ActiveXObject("Microsoft.XMLHTTP");
if(a == null) return null;
a.Open("POST", GetRootUrl() + "_vti_bin/Lists.asmx", false);
a.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
a.setRequestHeader("SOAPAction", "http://schemas.microsoft.com/sharepoint/soap/GetList");
var d = "" + "" + "" + "http://schemas.microsoft.com/sharepoint/soap/\">" + "" + listName + "" + "" + "" + "";

a.Send(d);
if (a.status != 200)
return null;
else
return a.responseXML;
}

function GetListGuid(fullName)
{
var res = GetList(fullName);
if (res != null)
return res.selectSingleNode("//List").getAttribute("ID");
else
return null;
}

Calling QueryListEx to obtain results is a pretty easy process. A number of parameters are required:

listGuid	The internal guid of the list to be queried (see below).
fields	An XML string containing a list of fields to be returned by the query. The resultant fields will be represented in the output XML.
where	A query expression used to filter the rows from the list and create the result set. The following expression returns all records in the list where the field with the internal name of ID is equal to 1. 1
orderBy	An XML fragement representing one or more fields to order the results by. Pass in an empty string to use the default sort order. The following example sorts by the Surname and Forename fields.
rowLimit	Set to a positive integer to limit the size of the result set. It is always wise to restrict row sets to prevent potential performance problems or timeouts.
extractRows	Set this to true to automatically extract the results into an array of XML nodes. If set to false the entire XML DOM of the result will be returned.

Silverlight Web part with MOSS

Here you go with the information/process about Silverlight and MOSS integration.

Silverlight & MOSS Integration

Part 1 (Silverlight project DLL to be copied into this ClientBin Directory)
1. Create ClientBin Directory under this folder (C:\Inetpub\wwwroot\wss\VirtualDirectories\80) Default web app

2. Open IIS Manager and locate the ClientBin Directory Created in step 1

3. Choose the property window of CilentBin

4. Change the Execute Permissions to Scripts Only

Part 2
1. Create a Project in Expression Blend

2. Build and Test the project.

3. Copy the DLL (created under ClientBin directory of the Silverlight project) into the Sharepoint application ClientBin Directory (C:\Inetpub\wwwroot\wss\VirtualDirectories\80)

Part 3
1. Upload the XAML file to sharepoint application

SiteAction ->View All Site content
· Option 1
Create -> Document Library
Type SilverlightPages (any name) into Name Textbox and click create button
Upload the XAML file into the Silverlightpages folder
· Option 2
Click on pages
Upload the XAML file into the Pages folder

2. Publish and Approve the file (if needed)
Add the following code into your sharepoint page or custom master page
Option 1

// you can specify id

Option 2

// you can specify id

You can create function as a seprate (JS) file and upload into proper location
For example createsilverlghtobjects.js
function createsilverlightmenu()
{
Sys.Silverlight.createObjectEx({
source: "MasterPageTop.xaml", // Specify your xaml file
parentElement: document.getElementById("SilverLightTopPanel"), // specify your Div element ID
id: "SilverlightControl",
properties: {
width: "1024",
height: "60",
version: "0.95",
enableHtmlAccess: true
},
events: {}
});
}

Copy this (createsilverlghtobjects.js) file into C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\LAYOUTS\1033 (Sharepoint sever)

3. You have to copy the silverlight.js file (from Microsoft ) into C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\LAYOUTS\1033 (Sharepoint sever)

4. You have to specify the file location into your master page (Add the blow code into your custom master page (inside head tag)









You are done!!!!! :)

Working with bulk list items

Working with bulk list items

SPWeb.ProcessBatchData Method

Processes the specified batch string of commands for sending multiple requests to the server per transaction.

using (SPWeb oWebsite = SPContext.Current.Site.OpenWeb("Website_URL"))
{
SPList oList = oWebsite.Lists["Announcements"];
System.Guid guid = oList.ID;
string strGuid = guid.ToString();

string strPost = "" +
"" +
"" + strGuid + "" +
"New" +
"Save" +
"" +
"New Manager" +
"" +
"Congratulations to Mary for her promotion!" +
"" +
"2003-09-14T00:00:00Z" +
"" +
"" +
"" + strGuid + "" +
"New" +
"Save" +
"" +
"New Technical Consultant" +
"" +
"Welcome to the team, John!" +
"" +
"2007-10-15T00:00:00Z" +
"" +
"";

string strProcessBatch = oWebsite.ProcessBatchData(strPost);
}

SharePoint 2010

What's new in SharePoint 2010?

Overview:

New User Interface including the new Ribbon: A streamlined new user interface including the ribbon is an intutive and contextual web user interface that makes users more effective, reduces training, provides better performance and lowers cost.

Web Edit: Web Edit allows users to easily customize a site, making it possible to respond more quickly than ever to changes in your dynamic business environment.

Silverlight Web Part: The Silverlight Web parts lets you quickly and securely integrate Silverlight applications and rich media into your site taking the user experience to another level.

Rich Theming: Combined with Web Edit, rich theming allows you to skin your SharePoint site using your favourite office client themes. Change the colors and fonts to customize the site to turn your "SharePoint" site into "your" site.

Multiple Browser Support: Experience the richness of SharePoint across multiple browsers. By supporting Internet Explorer, Firefox, and Safari, SharePoint allows the broadest reach for connecting people together and allows them to work in new and dynamic ways.

Visio Services: Visio Services lets you share data linked diagrams in real time with a high fidelity and interactive experience so that everyone can access consistent and upto date information, even those who don't have Visio.

SharePoint Designer: SharePoint Designer comes with a new UI, enhanced modeling capabilities and improved workflow capabilities that makes collaboration between designers and developers more seamless while allowing team creativity and productivity.

Business Connectivity Services (the evolution of Business Data Catalog): Business Connectivity Services (BCS) allows you to connect to Line-of-Business applications, Web Services and Databases and surface your data in a user friendly way enabling users to interact and update it easily in the web and in the office client.

SharePoint Workflow: SharePoint workflow (formerly named Groove) is a rich client for SharePoint that lets you take your SharePoint Lists and Libraries offline including the ability to update content and sync it back in when You're re-connected.

Rich Media Support: Regardless of type of media, SharePoint and Office are ready to help you work with that media easily.Weather its SharePoint's support for Silverlight and rich media services or Powerpoint's new inline video editing capabilities , your information and presentations will come to life in new and dynamic ways.


For IT Professionals

Streamlined Central Administration: You will find a revamped and streamlined administration experience in SharePoint 2010. Everything is at your finger tips within Central Administration to help you get your job done, including the addition of Ribbon to make configuring and managing your server farm even quicker and easier.

SharePoint Best Practices Analyzer: The SharePoint best practices Analyzer built into SharePoint 2010 provides an extensible rules based engine that monitors farm health, and can automatically fix many common configuration and performance issues right out-of-the-box. Through a "Problems and Solutions page" in Central Administration, you can quickly find and fix potential issues acrossall of the servers in your farm, or just let the SharePoint best practices Analyzer do it for you.

Usage Reporting and Logging: The new unified logging database in 2010 is the central repositry for your SharePoint farm to log usage and health data to. The database schema will be fully documented to give you the power and flexibility of writing your own reports in addition to the ones we provide. You'll also be able to log your own events and tracing data through a new logging Object model into the database. Your insight into server usage and performance just became a whole lot easier.

Large List Resource Throttling: ResourceThrottling for large lists gives you granular control over the server performance impact of lists and libraries that contain several thousand to millions of items while automatically educating users on how to manage large lists effectively and efficiently.

Unattached Content Database Recovery: The new Unattached Content Database Recovery feature allows you to temporarily mount an unattached content database and browse content, back up a site collection or export sites and lists all through the Central Administration UI , and with out the requirement of a recovery farm.

Visual Upgrade: Visual Upgrade give you the option to upgrade SharePoint Server 2007 to SharePoint 2010 without impacting or changing the UI in existing sites.The upgraded site intially looks and behaves just like it did in SharePoint Server2007 but you're able to flip between the SharePoint Server 2007 layout and site features and the new SharePoint 2010 layout and site features. This gives you all of the new platform capabilities of SharePoint 2010 with the flexibility of choosing when you upgrade site's look and feel.

For Developer

Visual Studio 2010 SharePoint Tools: Visual Studio 2010 includes new tools for creating, packaging and debugging SharePoint solutions. Visual Studio includes a new designer for building Web Parts visually and easily, a new designer for building Business Connectivity Services Entities (formerly known BDC Entities), designers for creating SharePoint solutions, features and more. It has alos integrated support for Visual Studio Team Foundation Server including source code control and team build capabilities.

Language Integrated Query (LINQ) for SharePoint: LINQ for SharePoint provides and implementation of LINQ for SharePoint 2010 applications. It offers SharePoint developers strongly typed access to data in SharePoint lists, the ability to use the rich LINQ syntax and list joins and projections.

Developer Dashboard: The developer dashboard can be enabled on any SharePoint page for development and debugging purposes. It helps developers write better code by providing diagnostic information including detailed page request information such as timing, names and resources for all stored procedure called, memory used, the authenticated user, the number of SRRequest objects, any asserts and critical events and timings for web part events for the page rendering.

Business Connectivity Services (the evolution of Business Data Catalog): Business Connectivity Services (BCS) provides read/write access to external data from a line of Business System, Web Services, database or other external data directly, both online and offline, and rich BDC tools in SharePoint Designer 2010 and Visual Studio 2010.

Client Object Model (OM): The client object model (OM) is a new programming interface SharePoint 2010 where code run's on a user's client machine against a local object model and interact with data on SharePoint server. Client OM methods can be called from JavaScript, .Net code or Silverlight code and makes building rich client applications for easy.

Silverlight Web Part: SharePoint 2010 includes a Silverlight Web part which site owners can include Silverlight applications in their SharePoint site. The Silverlight application runs on the user's client and can utilize the SharePoint client OM to make calls to get data from SharePoint server.