Pages

Thursday, December 1, 2011

missing font or text in itunes

After updating my Itunes, I don't see any text there. All blank buttons, checkbox etc.. its all weird, even I cant see menu options like file, edit, view etc..I am tired of re installing itunes.
Later I downloaded/run registry file which is related to fonts. Now my itunes came back with everything. Here you can find the file to download and run >>>>  Click Here  <<<<






Suggestions are always welcome..!  Without signing also you can send your comments.

Wednesday, October 26, 2011

What is Informatica?

Informatica is Engine driven ETL tool, from Informatica Corporation, mostly used in Data Integration and Data warehouse enviornment. It is supported on different environments ( UNIX, WINDOWS, MAINFRAME etc).

Informatica Corporation products are:

  • Informatica Power Center
  • Informatica on demand
  • Informatica B2B Data Exchange
  • Informatica Data Quality
  • Informatica Data Explorer
Informatica Power Center is a single, unified enterprise data integration platform for accessing, discovering, and integrating data from virtually any business system, in any format, and delivering that data throughout the enterprise at any speed.

Key PowerCenter Client Tools:

  • Designer Tools
  • Workflow Manager
  • Workflow Monitor
  • Repository Manager
  • Administrator Console

Client to Server communication flow looks something like this:

  • The PowerCenter client sends a request to Repository Server.
  • The Repository Server verifies the connectivity information of the target database
  • The Repository Server starts a Repository agent Process
  • The Repository Server uses a Repository agent process to communicate with the Repository.
  • The PowerCenter Server process communicates with the repository to run scheduled workflows. When a workflow is run manually the Power Center Server uses the instructions configured in the mapping (stored in the Repository) to read , transform and write data.


Individual tools will be explored later...

Wednesday, July 27, 2011

How can I select and delete all my unread emails in gmail?

1) type is:unread in the search feild.
2) check All
3) Click on "Select all conversations that match this search"
4) Delete it






Please wait for few minutes. If it doesn't redirect properly please logout from the account and try to relogin.
And you are all set !


Note: This can apply for read, unread, chat, starred also.




Suggestions are always welcome...! Without signing also you can send your comments.



Friday, July 22, 2011

How to change multiple file extensions at once


If all files are located in one directory, I mean without any sub directories. Then its very simple.
Open a command window, enter into your directory and type  ren *.pdf *.tif 
this will change all files with extension .pdf to .tif. 
                                                         or
You can create a txt file copy ren *.pdf *.tif and save it into your directory where the files are located. Change the file extension .txt to .cmd and run it.  Done !

If you have a folder with different file of types (eg jpg/bmp/gif/ico/tga) and want to change ALL files to One type (eg png) then type:
ren *.* *.png
NB – All files in folder WILL change to .png!!
                                                   *****************************

Tool: If you have a directory full of files that need to be changed from .PNG to .JPG, it’s going to take forever to do this using the method above. That’s where you need a freeware application that can batch change file extensions for you.
Extension Renamer is a simple to use, freeware program that I have tested and contains no spyware, etc. Once you install it, it’s a piece of cake to change file extensions!
file extension changer
First, click Select Directory and choose the directory that contains all of the files that you want to modify. You have the option of including subdirectories also. Then you search for files with particular file extensions that you want to change. The *.* means that it will change ALL files to the new extension.
You can type in your the extension you want to change, such as .TXT in the From box along with an asterisk (*) or question mark (?) to help filter down the files. Click Search and the files that will be changed show up in the left box. Once you are satisfied, go ahead and click GO! Now all of your files will have their extensions renamed.


Suggestions are always welcome...! Without signing also you can send your comments.

Monday, July 18, 2011

Sharepoint Fundas

Creating the Web Part

This procedure demonstrates how to create an ASP.NET Web Part to wrap the user control.
To create the ASP.NET Web Part
  1. In Visual Studio, point to New on the File menu, and then click Project.
  2. In the Project types pane, click WSPBuilder. In the Templates pane, click WSPBuilder Project. In the Name box, type MyWebPart, and then click OK.
  3. Right-click the MyWebPart project, point to Add, and then click New Item…
  4. In the Categories pane, click WSPBuilder. In the Templates pane, click Web Part Feature. In the Name box, type MyWebPart, and then click OK.
  5. In the Feature Settings dialog, type My Web Part for the TitleA web part built using WSPBuilder for the Description and set the Scope to be Web. Click OK.
  6. Open the elements.xml file and edit the values for the Group and QuickAddGroups properties. The following code shows the corrected values:
  7. <Property Name="Group" Value="My Group"></Property>
    <Property Name="QuickAddGroups" Value="My Group" />
    
  8. Right-click on the MyWebPart soluction, then select Build Solution. Note the PublicKeyToken for the compiled assembly.
  9. Optional: Add the following property to the Properties block in the MyWebPart.webpartfile to prevent users from closing the web part once it is on a page:
  10. <property name="AllowClose" type="boolean">False</property>

Adding ASP.NET Project Types to the WSPBuilder Project

This procedure demonstrates how to add the ASP.NET web application templates to a WSPBuilder project. This is required to permit the use of the ASP.NET User Control within the WSPBuilder project.
To add the ASP.NET templates
  1. In Visual Studio, right-click on the MyWebPart project and select Unload Project.
  2. Right-click on the MyWebPart project again and select Edit MyWebPart.csproj. Locate the ProjectTypeGuids element and add the ASP.NET web application project type guid{349C5851-65DF-11DA-9384-00065B846F21}. The following code shows the corrected element:
  3. <ProjectTypeGuids>{349C5851-65DF-11DA-9384-00065B846F21};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
  4. Save and then close the MyWebPart.csproj file.
  5. Right-click on the MyWebPart project and select Reload Project.
  6. Right-click on the MyWebPart project and select Properties On the Application tab, change the Target Framework to be .NET Framework 3.5. Save the changes.

Creating the ASP.NET User Control

This procedure demonstrates how to create an ASP.NET user control that uses SharePoint.
To create the ASP.NET user control
  1. In Visual Studio, right-click the TEMPLATE folder, select Add then click New Folder. Name the folder CONTROLTEMPLATES.
  2. Right-click the CONTROLTEMPLATES folder, select Add then click New Folder. Name the folder MyWebPart
  3. Right-click the MyWebPart folder, select Add then click New Item.
  4. In the Categories pane, click Web. In the Templates pane, click Web User Control. Name the control MyWebUserControl.ascx, and then click Add.
  5. Delete the CodeBehind attribute in the MyWebUserControl.ascx file. Replace theInherits attribute with MyWebPart.MyWebUserControl, MyWebPart, Version=1.0.0.0, Culture=neutral, PublicKeyToken=[your PublicKeyToken]. The following code shows the corrected file:
  6. <%@ Control Language="C#" AutoEventWireup="true" Inherits="MyWebPart.MyWebUserControl, MyWebPart, Version=1.0.0.0, Culture=neutral, PublicKeyToken=9410bf5b454f3bbd" %>
  7. Open the MyWebUserControl.ascx file in the designer view. Click the Toolbox, and then add a Label using a drag-and-drop operation. Switch to the code view and rename the IDproperty to be MyLabel.
  8. Open the MyWebUserControl.ascx.cs file and the MyWebUserControl.ascx.designer.cs file. Change the namespace to MyWebPart in both files.
  9. Open the MyWebUserControl.ascx.cs file. Add a public string property namedDisplayText to the MyWebUserControl class. The following code demonstrates this:
  10. public string DisplayText { get; set; }
  11. Add the following code to the Page_Load method. This will display the value of the DisplayText property using the MyLabel control.
  12. protected void Page_Load(object sender, EventArgs e)
    {
        MyLabel.Text = DisplayText;
    }

Wrapping the User Control and Connecting the Properties

This procedure demonstrates how to wrap the user control inside the web part and connect the properties between SharePoint, the web wart and the user control.
To wrap the user control and connect the properties
  1. Open the MyWebPart.cs file.
  2. Edit the attributes of the MyProperty property. The code below shows the changes:
  3. [Personalizable(PersonalizationScope.Shared)]
    [WebBrowsable(true)]
    [System.ComponentModel.Category("Custom")]
    [WebDisplayName("MyProperty")]
    [WebDescription("Message to be displayed within Web Part")]
    
  4. Within the CreateChildControls() method, delete the single line of code under the // Your code here... comment. Enter code to load the MyWebUserControl, assign the value of MyProperty to the DisplayText property of the control and then add the control to the web part’s Controls collection. The code below demonstrates how to do this:
  5. // Your code here...
    MyWebUserControl myControl =
       (MyWebUserControl)Page.LoadControl("~/_controltemplates/MyWebPart/MyWebUserControl.ascx");
    myControl.DisplayText = MyProperty;
    this.Controls.Add(myControl);
    
  6. Right-click on the MyWebPart solution and select Rebuild Solution.
The completed solution structure is shown below:
SolutionStructure

Deploying the Web Part and Testing Functionality

This procedure demonstrates how to deploy the web part and the user control, and how to test their functionality. This procedure assumes that there is a local instance of SharePoint to deploy to.
To deploy the web part
  1. Right-click on the MyWebPart project, select WSPBuilder and then Build WSP. Follow the progress of the build in the Output window and wait for the process to complete.
  2. Right-click on the MyWebPart project, select WSPBuilder and then Deploy. Follow the progress of the build in the Output window and wait for the process to complete.
  3. Browse to the local SharePoint site.
  4. In the Site Actions drop-down box, click Site Settings. On the Site Settings page, click on the Site features link.
  5. Click on the Activate button next to the My Web Part feature.
  6. Click on the link to the default home page for the SharePoint site.
  7. In the Site Actions drop-down box, click Edit Page.
  8. Click Add a Web Part in one of the Web Part zones on the page, click the My Web PartWeb Part (located in the My Group section), and then click Add.
  9. Click Exit Edit Mode. You should now see the default “Hello SharePoint” message.
  10. To change the text displayed, click the drop-down box on the Web Part, and then clickModify Shared Web Part.
  11. Expand the Custom group, enter the new display message in the My Property box, and then click Apply.
  12. Click Exit Edit Mode. You should now see the new message.

Thanks to : WordPress.com

 Suggestions are always welcome...! Without signing also you can send your comments.

Sharepoint webparts

How Web Parts Work

In ASP.NET terminology, a server control is a software component that runs on the Web server as part of one or more ASP.NET Web pages. This provides a way of breaking complex Web pages into manageable pieces, and of using the same component in multiple pages. There are two kinds of ASP.NET server controls: user and custom.
  • User Controls   These controls consist of two parts:
    • A file that has an .ascx file name extension, and that contains sample HTML.
    • The program code that executes on the Web server. This code, plus the code for all other ASP.NET pages and user controls in the same application, is usually compiled into a single DLL that resides in the application's bin folder. However, it can also reside in source form, within the .ascx file.
    Most developers find user controls fairly easy to create. This is because the developer (or even a Web designer) can use a visual designer to create the sample HTML, and because programming a user control is very much like programming an ordinary ASP.NET page.
    User controls, however, can be difficult to deploy widely. When a change occurs, someone must:
    1. Identify each Web site that uses the control.
    2. Install the new .ascx and source code files in each Web site.
    3. Recompile all the source code in each Web site.
    4. Copy the revised .ascx file and the recompiled code to each production Web site.
    If Web Parts were user controls, deploying a new Web Part (or upgrading one) would require recompiling and reinstalling the program code for every SharePoint site that uses the Web Part. That's why Web Parts aren't user controls.
  • Custom Controls   These controls consist entirely of program code. There's no HTML template like the .ascx file for a user control, and consequently no way of using a WYSIWYG editor to design its HTML. A programmer must write code that emits each scrap of HTML that the control needs in order to display output.The advantage of custom controls lies in deployment. Each custom control (or, if you choose, each logical group of custom controls) has its own DLL, and at your option you can install this once per physical server or once per virtual Web server. This is the model that Web Parts use. All Web Parts are, in fact, ASP.NET custom controls.
In practice, laying out page elements with no WYSIWYG editor and writing program code that emits HTML aren't the grueling tasks you might expect. The reason is that the output of most Web Parts is fairly simple. Many page elements—such as the top navigation bar, the page banner, any toolbars, and any link areas—are part of the Web Part Page or of other Web Parts. Any Web Parts you create need only display their specific data, and they inherit styles from the site's theme.
Windows SharePoint Services provides a base class for creating Web Parts, namely Microsoft.SharePoint.WebPartPages.WebPart. This class provides a base upon which you can write any type of Web Part you like. To inherit from this class (that is, to use it as a base), you code the following statement in the source code for your Web Part:

class WebPart1 : Microsoft.SharePoint.WebPartPages.WebPart 
{
// Your custom code goes here. 
}

In addition, virtually all Web Parts override two methods in the WebPart class:
  • CreateChildControls   The WebPart class calls this method to create child server controls that the Web Part will later convert to HTML.
  • RenderWebPart   The WebPart class calls this method to render (that is, create) the HTML that the Web Part will display.
Note   If you've ever written ASP.NET custom controls that aren't Web Parts, you're probably accustomed to overriding the Render method rather than the RenderWebPart method. In a Web Part, however, the Render method creates only the chrome (the Web Part's title bar and border, for example). The RenderWebPart method creates the HTML that appears in the body of the Web Part.
The reason for overriding (that is, superseding) these methods is that the versions in the WebPart class essentially do nothing. Overriding them means that at the proper time, the WebPart class will call custom methods you provide rather than its own do-nothing methods. Adding these two overrides to the previous code gives the Web Part this structure:

class WebPart1 : Microsoft.SharePoint.WebPartPages.WebPart 
{ 
//  Global declarations go here.
protected override void CreateChildControls ()
    {
//      Code to create a list of Web or HTML server 
//      controls goes here
    }
protected override void RenderWebPart(HtmlTextWriter output) 
    {
//      Code to render the list of Web or HTML server 
//      controls goes here
    }
}

For more information about overriding the CreateChildControls method, see Adding Layout Controls and Content.
For more information about overriding the RenderWebPart method, see Writing Web Part Output.
If you've written conventional ASP.NET pages or ASP.NET user controls, you probably made extensive use of the Page_Load event. A similar event occurs for custom controls, but most Web Parts never bother detecting it. There are at least two reasons for this:
  • Page_Load normally fires when ASP.NET finishes loading the page's server controls into memory. In a Web Part, however, ASP.NET doesn't load the server controls; your own CreateChildControls method does that. So, you may as well put your code in the CreateChildControls method, or call it from within that method.
  • Within a Page_Load event handler, programmers normally use the IsPostBack property to differentiate between the initial display of a page and a subsequent submission. But in the case of Web Parts, a postback also occurs when a team member uses a browser to add, remove, or reconfigure any Web Part on the page.This makes sense if you stop and think about it. There are many times—such as when you use a browser to add a Web Part to a page—when a round trip to the server clearly occurs. However, these aren't normal form submissions, and you shouldn't process any data that form fields might contain.
So, if you're not going to use Page_Load to initialize the display, and you're not going to use it for form submissions, you're probably not going to use it much at all.
As in conventional ASP.NET pages, most Web server controls have onServerClick or onServerChange events that can trigger event handlers in a Web Part. This is the normal way of detecting actual form submissions.
For more information about using onServerClick and onServerChange events in a Web Part, see Using the ASP.NET Event Model.

Starting a New Web Part Project

Before starting to create your first Web Part, you need to have Windows SharePoint Services up and running, and any version of Visual Studio .NET installed on the computer you plan to use for coding and compiling.
With those items in place, you're ready to install the Web Part templates For Visual Studio .NET. This is something you need to do only once. Here's the procedure:
  1. If you're not going to run Visual Studio on the SharePoint server, copy the Microsoft.SharePoint.dll file from the server to the Visual Studio machine. By default, this file resides at:C:\Program Files\Common Files\Microsoft Shared\web server extensions\60\ISAPI
    You can copy this file to any folder you like on the Visual Studio machine; just remember its location and don't delete it by accident.
  2. On the machine where Visual Studio is installed, browse http://www.microsoft.com/technet/downloads/sharepnt.mspx.
  3. When the Downloads for SharePoint Products and Technologies page appears, click the hyperlink titled SharePoint Products And Technologies Templates: Web Part Templates For Visual Studio .NET.
  4. When the Download Details page appears, click the Download button and save the resulting file (WebPartTemplatesforVSNetSample2.exe) to a temporary location.
  5. Run the file you downloaded in step 4. When the WinZip Self-Extractor dialog box appears, choose a folder for the unzipped setup files and then clickUnzip.
  6. Open the folder you specified in step 5 and run the setup.exe program.
  7. Click Next on the opening page of the setup wizard, and then I Agree and Next on the License Agreement page.
  8. On the third wizard page, select the check box for each set of templates you want to install. The choices are Visual C and Visual Basic .NET. The examples in this book are all in C, but feel free to install both.
  9. If the wizard page shown in Figure 19-1 appears, enter the folder location where you saved the Microsoft.SharePoint.dll file you copied in step 1.
  10. Click Next and Finish to perform the installation.
If you install the Web Part Templates for Visual Studio .NET on a machine not running Windows SharePoint Services, you'll need to supply a local copy of Microsoft.SharePoint.dll and provide its location on this wizard page
Figure 19-1. If you install the Web Part Templates for Visual Studio .NET on a machine not running Windows SharePoint Services, you'll need to supply a local copy of Microsoft.SharePoint.dll and provide its location on this wizard page.
To actually start programming a Web Part, proceed as follows.
  1. Start Visual Studio, choose New from the File menu, and then choose Project.
  2. When the New Project dialog box shown in Figure 19-2 appears, apply the following settings and then click OK:
    • Project Types   Select either Visual Basic Projects or Visual C Projects. This presumes, of course, that you installed the corresponding templates in the previous procedure. The examples in this book are all in C.
    • Templates   Choose Web Part Library.
    • Name   Specify the name of the Visual Studio project. By default, this will also be the name of the DLL that deploys your Web Part. Visual Studio will also create a solution having this name.
    • Location   Specify a folder where the Visual Studio project and solution will reside.
    The Web Part library template initializes a project for creating Web Parts
    Figure 19-2. The Web Part library template initializes a project for creating Web Parts.
  3. Visual Studio will create the new project and open the class file for a Web Part named WebPart1. Figure 19-3 illustrates this result.This new Web Part project is ready to receive custom code
    Figure 19-3. This new Web Part project is ready to receive custom code.
  4. Unless you want your Web Part to be named WebPart1:
    1. Choose Find And Replace from the Edit menu, and then choose Replace.
    2. When the Replace dialog box appears, set Find What to WebPart1Replace With to the name you want, and then click Replace All.
    3. Click the close box in the Replace dialog box, and then in the WebPart1.cs file. When Visual Studio prompts Save Changes To The Following Items?, click Yes.
    4. Right-click the WebPart1.cs file in Solution Explorer, choose Rename from the shortcut menu, and change the file name base to the name you assigned in step 4.2.
      Tip   If the Solution Explorer window isn't visible, press CTRL+ALT+L or choose Solution Explorer from the View menu.

Writing Web Part Output

For an ordinary ASP.NET page or user control, the first step after creating a new file is to design the HTML. This is also true for ASP.NET custom controls (and consequently for Web Parts) but, because there's no text file that contains "raw" HTML, you need to approach this task differently.
As you no doubt recall, every Web Part that creates output contains a method declaration like this:

protected override void RenderWebPart(HtmlTextWriter output)
{
}

ASP.NET runs this function automatically after all initialization functions, event handlers, and child functions have finished—in short, when all other processing is complete. To actually emit HTML, you have a choice of two approaches:
  • You can call the Write method of the HtmlTextWriter object named output. (Note that the RenderWebPart method receives a pointer to this object as an argument.) For example, to write a paragraph that displays the value of a variable named strMsg, you would code:

    output.Write("<p>" + SPEncode.HtmlEncode(strMsg) + "</p>");
    
    SPEncode.HtmlEncode is a method that converts reserved HTML characters to character entity references. For example, it converts < to &lt; and > to &gt;.
  • You can call the RenderChildren method, specifying the HtmlTextWriter object named output as a parameter. Here's an example:

    RenderChildren(output);
    
To understand the RenderChildren method, you should know that every ASP.NET page, user control, and custom control has a Controls collection. This collection contains an object for each element the page or control will display. When you're working with ASP.NET pages or user controls, ASP.NET loads the Controlscollection from the .aspx or .ascx file as follows:
  • Each tag you code runat="server" creates a corresponding object in the Controls collection.
  • Any content that appears between tags coded runat="server" appears in the Controls collection as a single System.Web.UI.LiteralControl object.
Because custom controls (and therefore Web Parts) have no .aspx or .ascx file, the Controls collection is initially empty. You can, however, write program code that adds any controls you want to the Controls collection. Here's an example:

HtmlGenericControl prgMsg;             // Declare variable. 
prgMsg = new HtmlGenericControl("p");  // Create object. 
prgMsg.InnerText = strMsg;             // Set value inside <p>
                                       // and </p>. 
Controls.Add(prgMsg);                  // Add to Controls 
                                       // collection.
A single call to the RenderChildren method will then tell each control, in order, to emit its HTML. If you use code such as the above to create five paragraph controls, RenderChildren would write five sets of <p> and </p> tags, each with the content you assigned.
The choice between using output.Write and RenderChildren is entirely yours. The output.Write method is easier to see and understand. Loading up the Controlscollection and calling RenderChildren is more abstract, but it helps modularize your program and it guards against invalid HTML.
Although there's nothing wrong with output.Write, the examples in this book will use the RenderChildren method exclusively.

Adding Layout Controls and Content

ASP.NET provides two sets of objects you can add to a Controls collection. They are:
  • System.Web.UI.HtmlControls   These controls correspond very closely to standard HTML elements. For a complete list, see System.Web.UI.HtmlControls.To use these controls, the source code for your Web Part should contain this statement:

    using System.Web.UI.HtmlControls;
    
    Otherwise, you'll need to type the entire namespace every time you refer to one of its class names.
  • System.Web.UI.WebControls   Controls in this group are either:
    • Enhanced versions of HTML server controls. Unlike the HtmlSelect control, for example, the ListBox Web server control can trigger immediate postbacks.
    • Entirely new elements, such as a calendar, an ad rotator, and the ubiquitous DataGrid control.
    For a list of these controls, see System.Web.UI.WebControls.
    To use these controls, the source code for your Web Part should contain this statement:

    using System.Web.UI.WebControls;
    
The preceding section already showed some example code for creating a paragraph tag and adding text to it. Here it is again.

HtmlGenericControl prgMsg;
prgMsg = new HtmlGenericControl("p");
prgMsg.InnerText = strMsg;
Controls.Add(prgMsg);
In fact, however, not all this code is likely to appear together in one block. The second and fourth statements must appear within the CreateChildControls method, as shown below:

protected override void CreateChildControls ()
   {
prgMsg = new HtmlGenericControl("p");
Controls.Add(prgMsg);     
   }

The second statement, however, could easily reside in the method that determines the value of the strMsg variable. Here's an example:

HtmlGenericControl prgMsg; 
 
public void MsgLoad(object sender, EventArgs e) 
{ 
    string strMsg; 
    strMsg = "Help! I'm a prisoner in a Web Part!"; 
    EnsureChildControls(); 
    prgMsg.InnerText = strMsg; 
} 
protected override void CreateChildControls () 
{ 
    prgMsg = new HtmlGenericControl("p"); 
    prgMsg.Load += new EventHandler(MsgLoad); 
    Controls.Add(prgMsg); 
}

In this code:
  • The statement on line 13 establishes MsgLoad as an onLoad event handler for the prgMsg object. This means that the MsgLoad method on line 3 will run as soon as the prgMsg object finishes loading.
  • The EnsureChildControls method on line 7 ensures that the CreateChildControls method has finished executing. If not, it waits for that method to complete. This avoids the embarrassing moments that occur when a method tries to manipulate an object that CreateChildControls hasn't created yet.
  • The assignment statement on line 8 stores a value into the paragraph control created on line 12.
  • The declaration of the prgMsg variable appears on line 1, which is outside both the MsgLoad method and the CreateChildControls method. This makes theprgMsg available within both of those methods.
This, by the way, plus the Web Part templates for Visual Studio .NET, is just about all the code you need to write an elementary Web Part. A Visual Studio project using this code appears in the \WebParts\proseware folder of the companion CD, and a screen shot appears in Figure 19-4.
This is a very simple Web Part, and it required very little code
Figure 19-4. This is a very simple Web Part, and it required very little code.

Manipulating SharePoint Objects

Windows SharePoint Services provides a rich collection of objects for working with sites, lists, permissions, and other administrative objects. All these objects reside within a namespace named, logically enough, SharePoint. Its major classes include:
  • SharePoint.SPSite   Represents a SharePoint site collection. Its properties and methods provide access to the collection's subsites, templates, cross-site groups, and so forth.Remember: an SPSite object doesn't represent a site. Its properties and methods pertain to an entire site collection, and not to any one Web site.
  • SharePoint SPWeb   Represents an individual SharePoint site: either a top-level Web site or a subsite. It provides access to all of the site's lists, files, folders, Web Parts, and other objects.
  • SharePoint.SPList   Represents a SharePoint list. The term list, in this context, is very broad. It includes not only generic lists, but also surveys, discussion boards, document libraries, picture libraries, and form libraries.
For a complete listing and description of the objects in the SharePoint namespace, see Microsoft.SharePoint Namespace.
The statement below creates an SPWeb object named spwCurr that describes the current SharePoint Web site. In other words, it describes the site that contains the page that displayed the Web Part.

SPWeb spwCurr = SPControl.GetContextWeb(Context);

The next statement creates an SPSite object named spsColl that describes the site collection that contains the current site.

SPSite spsColl = SPControl.GetContextSite(Context);

Once you have these objects, you can retrieve more information about the site or its collection by using their properties and methods. For example, after you create an SPWeb object named spwCurr as described above:
  • spwCurr.CurrentUser.LoginName   Returns the current team member's login name, such as interlacken\karen.M
  • spwCurr.CurrentUser.Name   Returns the current team member's personal name, such as Karen Archer.
  • spwCurr.Name   Gets or sets the name of the current site.
  • spwCurr.Lists   Returns a collection of SPList objects, one for each list in the site.
  • spwCurr.Delete()   Deletes the current site.
In most cases, if a property is editable, your code can simply store a value into it. Editable, in this sense, means that Windows SharePoint Services permits direct updates to a field, and that the current user has permission to perform the operation.
To enumerate a collection, code a foreach loop like the one below:

(SPList splCurr in spwCurr.Lists) {
// splCurr will point to a different list during each iteration 
}

In addition, you can index into lists using either numbers or names. The following statement, for example, creates an SPList object named splNrTwo that points to the second list in the spwCurr.Lists collection:

SPList splNrTwo = spwCurr.Lists[1];

And this statement creates an SPList object that points to a Shared Documents library:

SPList splSharedDocs = spwCurr.Lists["Shared Documents"];

To add objects to and remove them from SharePoint collections, you use Add and Delete methods, just as you do with most other .NET collections. The following statement, for example, creates a new Contacts list named Swamp Dwellers. The second parameter supplies the list description:

spwCurr.Lists.Add("Swamp Dwellers",
"Ducks, Frogs, Gators, and other creepy critters", 
SPListTemplateType.Contacts);

Using the ASP.NET Event Model

Web Parts experience the same lifecycle events as ordinary Web pages: InitLoad, Data-BindingPreRender, and Unload. To capture these, add a method like the following to the class for your Web Part:

Protected override void OnLoad(EventArgs e) 
{
// Your code goes here
base.OnLoad(e); 
}

This example illustrates the code for the Load event. To capture other life cycle events, change the word Load—in two places—to InitDataBindingPreRender, orUnload.
To capture button clicks, drop-down menu changes, and other form events, you must create the control, add an event hander to it, and then code the event handler. The following code, for example, creates a DropDownList control, adds an event handler named Priority_Change for the SelectedIndexChanged event, and then forces the form to autosubmit whenever the team member changes the current selection.

lstPriority = new DropDownList();
lstPriority.SelectedIndexChanged
    += new EventHandler(Priority_Change);
lstPriority.AutoPostBack = true;

Note the += operator in the second statement. This appends the new event handler without discarding any others for the same event. The code for the event handler itself appears below.

private void Priority_Change(object sender, EventArgs e) 
{
// Your code goes here. 
}

A Visual Studio project illustrating these techniques appears in the WebParts\tailspintoys folder of the companion CD, and a screen shot appears in Figure 19-5.
This Web Part traces and displays its lifecycle steps. The current display reflects four submissions
Figure 19-5. This Web Part traces and displays its lifecycle steps. The current display reflects four submissions.
This figure illustrates four executions of the Web Part Page, and therefore of the Web Part.
  • The Load and PreRender event handlers display simple messages, and fire for each execution.
  • The following code creates the drop-down list:

    lstPriority = new DropDownList();
    lstPriority.SelectedIndexChanged
        += new EventHandler(Priority_Change);
    lstPriority.AutoPostBack = true;
    
    
    And this code populates the list items:

    (lstPriority.Items.Count < 1) 
    {
        lstPriority.Items.Add(new ListItem("High","1"));
        lstPriority.Items.Add(new ListItem("Medium","2"));
        lstPriority.Items.Add(new ListItem("Low","3"));
        litMsgs.Text += "<br>"
           + DateTime.Now.ToLongTimeString()
           + " Priority List Loaded."; 
    }
    
    
    The message Priority List Loaded appears only once in Figure 19-5 because the ASP.NET ViewState mechanism persists the items (and the current selection) from one execution to another.
    The messages Priority Is Now 2 and Priority Is Now 3 appear because the team member changed the selection in the drop-down list box, and this caused an autopostback.
  • The message Submit Button Clicked appears because the team member clicked the Submit button. The following code creates this button and specifies aClick event handler named Submit_Click.

    btnSubmit = new Button();
    btnSubmit.Text = "Submit";
    btnSubmit.Click += new EventHandler (Submit_Click);
    
    
    Here's the code for the event handler:

    Private void Submit_Click(object sender, EventArgs e) 
    {
        EnsureChildControls();
        litMsgs.Text += "<br>"
              + DateTime.Now.ToLongTimeString()
              + " Submit Button Clicked."; 
    }
    
    
As in all ASP.NET pages, a single HTML form surrounds the content of each Web Part Page. Therefore, you needn't ever (and shouldn't ever) add your own <form> tags or HtmlForm objects to a Web Part. The Web Part Page will provide these.
When a Web Part Page displays several Web Parts, they all execute every time the Web page makes a round trip to the server. For example, your Web Part will execute:
  • Every time the team member clicks the browser's Refresh button.
  • Every time the team member clicks a Submit button or otherwise creates a postback from another Web Part.
  • Every time the team members use browser-based design features such as:
    • Switching from shared view to personal view.
    • Entering, using, or exiting browser-based Design mode.
    • Displaying the Add Web Parts task pane.
    • Scrolling through multiple pages in a Web Part gallery.
    • Modifying a Web Part.
As a result, any event handlers in your Web Part that book orders, adjust account balances, or perform any other kinds of updates should only react to events that come from elements that you know reside in your Web Part, and not to general, page-wide events like Page_Load.

Exposing Custom Properties

Many Web Parts expose properties that team members can change through the Modify Web Part task pane in the browser, or through the Web Part Propertiesdialog box in Microsoft Office FrontPage. The Text property in Figure 19-6 provides an example. Windows SharePoint Services calls these custom properties.
The input field titled Text is a SharePoint custom property. Windows SharePoint Services does most of the work in displaying and saving such values
Figure 19-6. The input field titled Text is a SharePoint custom property. Windows SharePoint Services does most of the work in displaying and saving such values.
The code that appears below creates a custom property named Text. You put this inside the class definition for your Web Part, but not inside any method. The Web Part templates for Visual Studio .NET provide a version of this code in every new Web Part class file.

private const string defaultText = "";
private string text = defaultText;  
[Browsable(true),
    Category("Miscellaneous"),
    DefaultValue(defaultText),
    WebPartStorage(Storage.Personal),
    FriendlyName("Text"),
    Description("Text Property")]
public string Text 
{
    get { return text; }
    set { text = value; } 
}

The first two lines define a default value and a class-wide variable for the custom property value. The last five lines are a very ordinary property definition. The middle six lines, within square brackets, actually define the custom property as it will appear in the Web Part's property pane. Table 19-1 lists and describes all the available properties.
Table 19-1. Custom property attributes
AttributePurpose
BrowsableA value of false stops the custom property from appearing in the Web Part's property sheet The default is true. Setting theWebPartStorage attribute to Storage.None has the same effect.
CategoryThe section title where the custom property will appear on the property sheet. If you leave this attribute empty or set it to Default, Appearance, Layout, or Advanced, the custom property will appear in the Miscellaneous section.
DescriptionThe tool tip text that appears if a team member hovers the mouse pointer over the custom property's input control.
DefaultValueThe custom property's default value.
FriendlyNameAttributeThe caption or title that identifies the custom property. If you leave this empty, the program name for the property will appear.
ReadOnlyA value of true makes the custom property read-only in the property sheet. The default is false.
WebPartStorageThe view modes for which Windows SharePoint Services will display and save custom property values. The permissible values are:
  • Storage.Shared   Only when configuring the Web Part's shared view.
  • Storage.Personal   When configuring either the shared or personal view.
  • Storage.None   Never.
HtmlDesignerAttributeAssociates a property builder (that is, a custom Web page or module) with the property. This overrides the normal input format in Web page designers such as FrontPage.
You can define as many of these custom properties as you need. Windows SharePoint Services takes care of displaying them, and of saving the configured values as part of the Web Part definition for that page (or, in the case of personal views, for that team member). The type of input control depends on the data type of the custom property. For example, a string property will get a text box, and a Boolean property will get a check box.
Of course, it's your responsibility to write code that makes use of the custom property, once received.
If you need the capability of rejecting a custom property, choose one of these approaches:
  • Raise an exception in the property's set method. This approach is simple and normally works as you want in both the SharePoint browser interface and in FrontPage. Instead of closing, the property sheet will display the error message from your exception.If, however, your exception occurs when the Web Part's property sheet isn't visible, then the whole page may fail. This can occur, for example, when another control tries to set the property pragmatically.
  • Use a Web Part Tool Part, as the next section describes.

Using Web Part Tool Parts

If the default user interface that Windows SharePoint Services provides for custom properties doesn't meet your needs, Web Part Tool Parts may provide an answer.
Basically, a Web Part Tool Part is a class that displays and processes an HTML user interface for one or more custom properties. To use Web Part Tool Parts, the Web Part class file must override the GetToolParts method with code like this:

public override ToolPart[] GetToolParts() 
{
    ToolPart[] toolparts = new ToolPart[3];
    toolparts[0] = new CustomPropertyToolPart();
    toolparts[1] = new WebPartToolPart();
    toolparts[2] = new WebPartLibrary2.ToolPart1();
    return toolparts; 
}

Notice that this override returns an array of ToolPart objects.
  • The first is a standard CustomPropertyToolPart object, which displays any custom properties just as the previous section described. If you overrideGetToolParts and omit this entry, no controls for custom properties will appear.
  • The second is a WebPartToolPart object, which displays the standard Appearance, Layouts, and Advanced sections of the Web Part's property pane. If you omit this entry, these sections won't appear.
  • The third (and each subsequent) is a custom class that you develop separately in the same project, and that inherits theMicrosoft.SharePoint.WebPartPages.ToolPart class.
Any ToolPart classes you write must override four methods: ApplyChangesSyncChangesCancelChanges, and RenderToolPart.
For more information about writing classes that override the ToolPart class, and about using Web Part tool tips in general, see Creating a Web Part with a Custom Tool Part.

Providing a Design Time HTML Provider

If you open a Web Part Page in FrontPage, any custom Web Parts you develop are likely to appear with the following message in place of a WYSIWYG display:
The preview for this Web Part is not available.
This is because FrontPage Design view doesn't actually run any Web Parts it displays: instead, it calls a method called GetDesignTimeHtml and displays the resulting HTML. If your Web Part doesn't override this method, the message shown above appears.
The GetDesignTimeHtml method is part of an interface named IDesignTimeHtmlProvider. Here, then, are the steps necessary for your Web Part to appear graphically in an editor like FrontPage.
  • To signify that your Web Part class supports the IDesignTimeHtmlProvider interface, append a comma and the interface name to the class declaration. For example, change:

    public class SimpleWebPart : 
       Microsoft.SharePoint.WebPartPages.WebPart  
    {}
    
    
    to:

    public class SimpleWebPart : 
       Microsoft.SharePoint.WebPartPages.WebPart,
       IDesignTimeHtmlProvider 
    {}
    
    
  • Add a public method such as the following to your class:

    public string GetDesignTimeHtml() 
    {
    return "<p>Any HTML</p>";
    }
    
    
Of course, the GetDesignTimeHtml method can return any HTML you want. You might arrange, for example, for a common method to format actual data in theRenderWebPart method, and sample data in the GetDesignTimeHtml method.
For more information about using the IDesignTimeHtmlProvider interface, see "Implement the IDesignTimeHtmlProvider Interface in Your Web Part to Ensure Correct Rendering in FrontPage" in Best Practices for Developing Web Parts for SharePoint Products and Technologies.

Assigning a Strong Name

Strong naming is a technique whereby Visual Studio uses a private key to digitally sign any assemblies (for example, any DLLs) it creates. It also stamps those assemblies with a public key that can validate the signature. This guards against any unauthorized versions of a program (such as a Web Part). If the given public key fails to validate the digital signature, or if the assembly contains an unexpected public key, Windows SharePoint Services will refuse to run the module. Instead, you get a message like the following:
A Web Part or Web Form Control on this Web Part Page cannot be displayed or imported because it is not registered on this site as safe.
As you'll learn in the next section, there are two ways of deploying Web Parts: one that requires a strong name and one that recommends one. Here is the procedure for giving a Web Part assembly a strong name:
  1. Identify the folder that contains your Visual Studio Web Part project. The following is a typical path, where <user>is your windows logon ID and <project> is the name of your Visual Studio project.

    C:\Documents and Settings\<user>\My Documents\Visual Studio 
    Projects\<project>
    
  2. On the machine running Visual Studio, open a command prompt.
  3. Change to the directory containing the sn.exe file. This is usually one of the following:

    C:\Program Files\Microsoft Visual Studio .NET\FrameworkSDK\Bin\
    C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\Bin\
    
  4. Create a key pair file by running the following command:

    sn.exe –k "<path>\<project>.snk"
    
    where <path> is the path to your Visual Studio project (from step 1) and <project> is the name of your Visual Studio project.
  5. Open your Visual Studio project, and then choose Add Existing Item from the File menu.
  6. When the Add Existing Item dialog box appears, find and select the file you created in step 4, and then click Open.
  7. In Video Studio, open the AssemblyInfo.cs file for your project.
  8. Scroll to the bottom of the file, and change the line

    [assembly: AssemblyKeyFile("")]
    
    to:

    [assembly: AssemblyKeyFile("..\\..\\<project>.snk")]
    
    where <project> is the name of your Visual Studio project.
    As usual in C literals, a single backslash is an escape character. For example, \n means new line, not a backslash followed by an n. To get a backslash in the literal's value, you have to code two backslashes.
    The path ..\..\ is necessary because the strong name key file resides two directory levels closer to the root than the DLL file Visual Studio creates when it builds your project.
  9. Scroll about halfway up the AssemblyInfo.cs file and look for a line like:

    [assembly: AssemblyVersion("1.0.0.0")]
    
    If this line contains any asterisks, replace them with digits. This will avoid creating a new version number every time you compile the Web Part.
  10. Choose Rebuild Solution from the Build menu. This (and every subsequent build) will create a strongly named assembly.
Tip   Whenever the name, version number, or digital signature of a Web Part changes, you have to reinstall the Web Part on each SharePoint server that uses it, and reconfigure each Web Part page that uses it. as a result, most programmers avoid changing these properties.

Deploying Custom Web Parts

To deploy or upgrade a Web Part, you must first compile it in Visual Studio. Then, you must copy the resulting assembly (that is, the resulting .dll file) into one of two locations:
  • The SharePoint server's Global Assembly Cache (GAC)   This makes the Web Part available to all virtual servers on the same computer, with maximum privileges. However, the assembly must have a strong name. (You must have compiled it with a key pair file.)To install a Web Part this way, drag its .dll file into the C:\Windows\Assembly folder, where C:\Windows is the server's system folder.
  • The bin folder of one or more virtual servers   This makes the Web Part available only on those virtual servers where you install it. Assemblies you install this way don't need strong names, but strongly naming your assemblies is always a good idea.Unfortunately, at least through windows SharePoint Services Service Pack 1, this method doesn't work properly on computers running more than one SharePoint content server.
There are three ways to install Web Parts into the bin folder of a virtual server.
  • Install the Web Part manually.   To do this:
    1. Create your own .dwp file.
    2. Copy this .dwp file into the wpcatalog folder at the virtual server's physical root.
    3. Copy the Web Part's .dll into the bin folder at the virtual server's physical root.
    4. Update the <SafeControls> section of the virtual server's web.config file.
  • Create and install a Web Part Package.   To take this approach, create a Windows CAB file (with a .wpp file name extension) that contains:
    • A mainfest.xml file describing each file you need to install.
    • Each file you need to install.
  • Then, run the following command to install the package:

    stsadm.exe –o addwppack –filename <filename> –globalinstall -force
    
    where <filename> is the name of the .cab file.
  • Use the InstallAssemblies tool.   This tool examines your .dll file, creates the required .dwp file and Web Part Package, and then runs stsadm.exe –o addwppack, all from a graphical interface. In almost every case, this is the easiest, most accurate, and overall best approach.
To install the InstallAssemblies tool, copy the \utils\Web Part Toolkit\ folder on the companion CD to a C:\Program Files\Web Part Toolkit\ folder on your SharePoint server. Then, to run the tool, launch C:\Program Files\Web Part Toolkit\InstallAssemblies\InstallAssemblies.exe.
After you install a Web Part to either the global assembly cache or a virtual server's bin folder, you can usually install new versions simply by dragging the .dll file into the same folder as its predecessor. However, this won't work if you've changed the file's name, version number, or strong key signature.
Unless you manually installed a .dwp file in the virtual server's wpcatalog folder, New Web Parts don't appear automatically in the Web Part gallery of any site collection. To make them appear, a site collection administrator will need to add them.
For instructions on adding a Web Part to a Web Part gallery, refer to "Managing the Web Part Gallery" in Chapter 17.
If you added your Web Part to the bin folder of one or more virtual servers, and running it produces a security failure, you may need to locate the following tag in the server's web.config file:

<trust level="WSS_Minimal" originUrl="" />
and change WSS_Minimal to WSS_Medium or Full. Keep in mind, however, that this grants increased privileges to all Web Parts run from the virtual server's bin folder.
To configure a trust level that grants privileges to a specific assembly, see "To Give Access To An Assembly" in Microsoft Windows SharePoint Services and Code Access Security.
After you install or update a Web Part assembly or a .dwp file, and after you modify the config.sys file, the change may not take effect until after you stop and restart the Internet Information Services (IIS) server. To do this, open a command prompt on the server and run the iisreset command.
For more information on deploying Web Parts, see Packaging and Deploying Web Parts for Microsoft Windows SharePoint Services.
For additional guidance in creating Web Parts, try browsing these resources:

Thanks to : Microsoft.com
Suggestions are always welcome...! Without signing also you can send your comments.