I always forget the exact order in which events fire. So i found the following when i googled and wanna share it with you all :)

Page.Init + Control.Init for every control on the Web Form
The first stage in the page life cycle is initialization. After the page's control tree is populated with all the statically declared controls in the .aspx source the Init event is fired. First, the Init event for the Page object occurs, then Init event occurs for each control on the Page. Viewstate information is not available at this stage.

Page.LoadViewState
After initialization, ASP.NET loads the view state for the page. ViewState contains the state of the controls the last time the page was processed on the server.

Page.ProcessPostData
Post Data gets read from the request and control values are applied to control initalized in stage 1.

Page.Load + Control.Load for each control on the Page
If this is the first time the page is being processed (Page.IsPostback property), initial data binding is performed here.

"Change" events are fired for controls
(TextChanged, SelectedIndexChanged, and similar) The current value (from Post Data) is compared to the original value located in the ViewState. If there is a difference "Changed" events are raised.

Server-side events are fired for any validation controls
Button.Click + Button.Command
The Click and Command events are fired for the button that caused the postback

Page.PreRender + Control.PreRender

Page.SaveViewState
New values for all the controls are saved to the view state for another round-trip to the server.

Page.Render

Todd wrote a nice article about showing styles when moving your cursor around. A lot of people asked him how to alter elements of WSS WebPart Pages. He gives a good walk-through and some code. Thanks Todd :)

http://mindsharpblogs.com/todd/archive/2005/10/25/798.aspx

The SPWebCollection returned by the member SPWeb.Webs is a not sorted list of SPWeb objects. So i wrote a class which makes it possible to return a sorted list of SPWeb objects based on the property of a SPWeb. It is basically very simple and uses some standard .NET interfaces for enumerating and comparing.

public class SPSortedWebCollection : IEnumerable, IEnumerator
{
   private ArrayList list = new ArrayList();
   private int index = -1;
   private string property = "";

The constructor of the class needs a name of the property and the original collection of SPWeb objects returned by for example the SPWeb.Webs member. It adds the SPWeb objects and initializes the class.

   public SPSortedWebCollection(SPWebCollection webs, string property)
   {
      this.property = property;

      foreach(SPWeb child in webs)
      {
         Add(child);
      }

      Reset();
   }

This method can be used to add some additional SPWeb objects. Don't forget to call the Reset() member for resetting and sorting the collection again.

Inside the class another class is found which stores the SPWeb objects. It uses the IComparable interface for comparing itself against another instance of SPSortedWeb. The Sort member of the ArrayList automatically uses the CompareTo member of the interface when sorting the list.

   protected class SPSortedWeb : IComparable
   {
      private SPWeb web = null;
      private string property = "";

      public SPSortedWeb(SPWeb web, string property)
      {
         this.web = web;
         this.property = property;
      }

      public SPWeb Web
      {
         get
         {
            return web;
         }
      }

      public int CompareTo(object obj)
      {
         SPSortedWeb sw = obj as SPSortedWeb;

         string val = SharePointHelper.GetPropertyCode(web, property);
         string compareToVal = SharePointHelper.GetPropertyCode(sw.Web, property);

         return val.CompareTo(compareToVal);
      }
   }

Finally the class is given some methods for enumerating through the list. You can use easily the foreach(...) loop to retrieve the SPWeb objects.

   public IEnumerator GetEnumerator()
   {
      return this;
   }

   public void Reset()
   {
      list.Sort();
      index = -1;
   }

   public object Current
   {
      get
      {
         SPSortedWeb sw = (index < 0 || index >= list.Count) ? null : list[index] as SPSortedWeb;
    
         return sw != null ? sw.Web : null;
      }
   }

   public bool MoveNext()
   {
      index++;

      return index < list.Count;
   }
}

For retrieving the property of a SPWeb object the following class is used:

public class SharePointHelper
{  
    public static string GetPropertyCode(SPWeb web, string property)
   {
      if (web.Properties.ContainsKey(property))
      {
         return web.Properties[property];
      }

      return "";
   }
}

To use the class the following example gives you some idea of how it works:

SPSortedWebCollection col = new SPSortedWebCollection(currentWeb.Webs, "Number");

foreach(SPWeb child in col)
{
...
}

Modonovan posted an article which explains how to use the IRuntimeFilter to hide or show WebParts in the Portal. as stated in the article:

"By implementing IRuntimeFilter you are essentially creating a rule or a set of rules that determine if a web part should be displayed or not. For example:

• SharePoint Portal Server (SPS) uses a IRuntimeFilter for audiences. A user will setup the audiences that are allowed to see a web part (using the advanced section in the web part’s toolpane), then when a user visits the web page the filter runs and determines if the web part should be shown or not. If a virtual server is extended with SPS then the Microsoft.SharePoint.Portal.Audience.AudienceManager filter is installed by default.
  
• You could create a custom IRuntimeFilter that determines if a web part should be displayed based on the WSS role the user is a member of. This is what the sample code in this document does
  
• You could create a custom IRuntimeFilter that determines if a web part should be displayed based on any arbitrary property or rule(s) that you come up with."

I often use some kind of check in my code behind to find out which roles the current user has and then based on the information i show or hide the WebPart. This solution presented by Modonovan is far better. :) Thanks!!

http://blogs.msdn.com/modonovan/archive/2005/07/07/436394.aspx

Mart Muller did a great post about adding a reply programmatically to a discussion board. Just like my last post about programmatically adding history to an issue in an issue list also this is not described clearly in the documentation of SharePoint. The following code is used:

SPListItem newItem = discussionList.Items.Add();
newItem["Title"] = "Title of item";
newItem["Body"] = "Body Text";
newItem["ThreadID"] = [ThreadID of original thread];
newItem["Ordering"] = [Ordering of original thread] + DateTime.Now.ToString("yyyyMMddhhmmss");
newItem.Update();

Mart's article:

http://blogs.tamtam.nl/mart/SharePointTipAdding
ADiscussionReplyItemInAThreadProgramatically.aspx

Article about adding history to an issue in an issue list:

http://net.bloggix.com/PermaLink,guid,aa4c6b98-2039-432b-af80-b8baf901fdf2.aspx

If you create a WebPart containing a multiline TextBox, the TextBox does not size automatically with the width of the WebPart. Requesting the Width of the WebPart is not an option because its not yet in the clients browser. So the following example shows a way of sizing the TextBox to 100% in the WebPart. tbRemark is a TextBox with the TextMode set to TextBoxMode.MultiLine.

protected override void RenderWebPart(HtmlTextWriter output)
{
   output.WriteLine("<style>.StyleRemark { width:100%;height:100; }</style>");

   output.WriteLine("<TABLE id=\"Table1\" cellSpacing=\"1\" cellPadding=\"1\" width=\"100%\" border=\"0\">");
   output.WriteLine("<TR><TD>");

   tbRemark.Text = Remark;
   tbRemark.CssClass = "StyleRemark";
   tbRemark.RenderControl(output);

   output.WriteLine("</TD></TR>");
   output.WriteLine("</TABLE>");
}

Paul Brenk has posted some usefull code which shows us how to deserialize a string containing XML to an object using a StringReader and a XmlTextReader object. It also shows us how it handles a XML-array using serialization attributes.

http://blogs.tamtam.nl/paulb/DeserializingAnXmlstringAndXmlArrays.aspx

Microsoft has a nice collection of controls bundled into a package called "IE Web Controls". Except for the fact that they are fully unsupported some controls are very handy.

I have used the TreeView in a custom WebPart and had some difficulty setting the styles. It seems you have to set the styles DefaultStyle, HoverStyle and SelectedStyle. The DefaultStyle is used when no action takes place, the HoverStyle is set when you hover with your mouse over an item and the SelectedStyle is the style of a selected item. Here are two examples of setting the style in a TreeView.

<mytree:treeview runat="server" 
    ID="tvwResources" 
   defaultStyle="font-family:Verdana,Arial,Sans-serif;color:#000000;font-size:11px;" 
   hoverStyle="font-family:Verdana,Arial,Sans-serif;color:#000000;font-size:11px;" 
   selectedStyle="font-family:Verdana,Arial,Sans-serif;color:#000000;font-size:11px;>
</mytree:treeview>

Or programmatically

mytree.DefaultStyle["font-family"] = "Verdana,Arial,Sans-serif";
mytree.DefaultStyle["color"] = "#000000";
mytree.DefaultStyle["font-size"] = "11px";

mytree.HoverStyle["font-family"] = "Verdana,Arial,Sans-serif";
mytree.HoverStyle["color"] = "#000000";
mytree.HoverStyle["font-size"] = "11px";

mytree.SelectedStyle["font-family"] = "Verdana,Arial,Sans-serif";
mytree.SelectedStyle["color"] = "#000000";
mytree.SelectedStyle["font-size"] = "11px";

One of my collegea likes to have pop quizes about C# programming snippets. A question he gave us yesterday was the following: If you have two classes class A and class B implementing the same interface and class A is derived from class B and you would cast an instance of class A to the interface and call a method on that interface, which method is called. The one of class A or class B? It is actually very simple. Lets have a look at the code:

public interface I
{
   string someFunc();
}

public class B : I
{
   public string someFunc()
   {
      return "someFunc in class B";
   }
}

public class A : B, I
{
   public string someFunc()
   {
      return "someFunc in class A";
   }
}

Then we need some code to initiate this:

A someClassA = new A();
I someInterface = (someInterface)someClassA;
Response.Write(I.someFunc());

When you try to compile it you will get no errors but looking at your code you will notice that a line is placed under the someFunc() method of class A telling you that this method is hiding the method with the same name in class B. This answers already the question. :) The method of class A is called and the string "someFunc in class A" is returned.

To get rid of the nasty line and message you only have to change the line of code from public string someFunc() to public new string someFunc() in class A.

At the blog #region /* mads's thoughts */ an important article is found called "COM objects need tight leash". It gives an example of increasing memory usage when working with the SharePoint object model and th Office interop components.

In that case it seems that the Garbage Collector was cleaning up the managed references which were wrappers around COM objects and these COM objects were not cleaned up.

I have had a similair problem in the past writing wrapper classes in C# around C++ unmanaged code. The unmanaged code was not cleaned up by the garbage collector ofcourse and you had to do that yourself.

In one of the portals we removed the "Site settings" link from the page to prevent users clicking on it. For some additional users which have administrator rights we created a WebPart containing links to the most needed functionality. This custom WebPart contains a direct link to the settings of the current page, a direct link to the settings of users of the current page and a link to delete the current page and its children.

First define a linkbutton in your WebPart derived class. This button is used for deleting the site and its children.

   btnDeleteSite = new LinkButton();
   btnDeleteSite.ID = "btnDeleteSite" ;
   btnDeleteSite.Text = "Delete this site" ;
   btnDeleteSite.Click += new EventHandler(btnDeleteSite_Click);
   Controls.Add(btnDeleteSite);

protected override void RenderWebPart(HtmlTextWriter output)
{
   output.WriteLine( "<table width=100% cellpadding=\"0\" " + 
                     "cellspacing=\"0\" border=\"0\" " +
                    " style=\"margin-top: 3px;margin-left: " + 
                     "3px;margin-right: 3px;\">" );

   output.WriteLine( "<tr><td>" );
   output.WriteLine( "Make your choice:" );
   output.WriteLine( "<br><br>" );
   output.WriteLine( "</td></tr>" );

   output.WriteLine( "<tr><td class=\"ms-addnew\" style=\"padding-bottom: " + 
                     "3px\" colspan=\"2\"> " + 
                    "<img src=\"/_layouts/images/rect.gif\" alt=\"\">&nbsp;" );

   output.WriteLine( "<a href='_layouts/" + 
                    System.Threading.Thread.CurrentThread.CurrentUICulture.LCID +  
                     "/settings.aspx'>Site settings</a>" );

   output.WriteLine( "<br><br></td><tr>" );

   output.WriteLine( "<tr><td class=\"ms-addnew\" style=\"padding-bottom: 3px\" " + 
                    "colspan=\"2\"> " +
                    "<img src=\"/_layouts/images/rect.gif\" alt=\"\">&nbsp;" );

   output.WriteLine( "<a href='_layouts/" + 
                     System.Threading.Thread.CurrentThread.CurrentUICulture.LCID + 
                     "/user.aspx'>User settings</a>" );

   output.WriteLine( "<br><br></td></tr>" );

   output.WriteLine( "<tr><td class=\"ms-addnew\" style=\"padding-bottom: " + 
                    "3px\" colspan=\"2\"> " + 
                    "<img src=\"/_layouts/images/rect.gif\" alt=\"\">&nbsp;" );

   btnDeleteSite.RenderControl(output);

   output.WriteLine( "<br><br></td><tr>" );
   output.WriteLine( "</table>" );
}

This is the member called when the delete button is pressed. It deletes the site and its children by calling the member DeleteSite and then redirects to the page of its parent.

There are some methods used in the example for which no code is deliverd. I will give a short explanation per method and their return values. The property SLACode is actually a Site property keeping the name of the SLA of the customer. Each customer has its own site in the SharePoint Portal.

The method GetSliceDefCollection returns a SliceDefCollection collection class containing different slices of values used by the QueryAllKPIData to retrieve the correct slice from the cubicle. The slices represent Shared Dimensions in SQL Analysis Server. An example could be something like this:

I have posted the method RenderWebPart and have put some comment between the code to explain what i'm doing. You need to reference the MSScoreCardWebParts assembly and at the top of the code the namespaces Microsoft.BusinessIntelligence.Scorecard and Microsoft.BusinessIntelligence.Scorecard.Data.

protected override void RenderWebPart(HtmlTextWriter output)
{
    bool header = true ;

First we retrieve the instance to the IScorecardManager interface. Through this interface a lot of methods can be used to get data from the cubicle to define and/or calculate KPI values.

         output.Write( "There are no SLA's defined." );
          return ;
      }

We render a table to the client with some styles defined in SharePoint and start looping through the found SLA's.

      output.WriteLine( "<table class=\"ms-summarycustombody\" width=100% cellpadding=\"2\" cellspacing=\"2\" border=\"0\" style=\"margin-top: 3px;margin-left: 3px;margin-right: 3px;\">" );

      while (reader.Read()) 
       {
          string SLACode = reader[ "sla_code" ].ToString();

         KpiValueRoot root = null ;

The method GetSliceDefCollection returns a SliceDefCollection representing a slice in the cubicle. Based on the ScorecardID and the collection the data is queried for determining the KPI values. The ScorecardID can be retrieved from the BusinessScorecard database. The method QueryAllKPIData uses the defined KPI's in the "Scorecard Development Site" to retrieve per KPI the value.

In this case we defined several KPI's for the management parts named Sys,Prj,ASM,WRK,CON and TST. For each of them the data is retrieved from the cubicle and represented as a value as specified in the properties of the KPI. (see "Scorecard Development Site").

         try
          {
            root = mgr.QueryAllKpiData(MyConfiguration.ScorecardID, GetSliceDefCollection(SLACode));
         }
          catch (Exception)
         {
          }

The first time in the loop we check if already an header is rendered to the client. The header contains all short names of the management parts for which KPI's are defined.

         if (header)
         {
            output.WriteLine( "<tr>" );
            output.WriteLine( "<td Class=\"ms-vb\"><b>SLA</b></td>" );

            if (root != null )
            {
                for ( int index = 0; index < root.Children.Count; index++)
               {
                  output.WriteLine( "<td Class=\"ms-vb\" align=center><b>" );
                  output.WriteLine(GetShortManagementName(index + 1));
                  output.WriteLine( "</b></td>" );
               }
            }

            output.WriteLine( "</tr>" );

            header = false ;
         }

         output.WriteLine( "<tr>" );
         output.WriteLine( "<td Class=\"ms-vb\">" );

         string Url = SLACode + "/default.aspx" ;

         output.WriteLine( "<a href='" + Url + "'>" + Unit + ":" + SLACode + "</a>" );

         if (root == null )
         {
            output.WriteLine( "(No SLA's found for this month)" );
         }

         output.WriteLine( "</td>" );

         if (root != null )
         {

The returned KPIValueRoot contains the KPIValue objects as its children. We loop through the children and based on the values in the KPIValue object we show the status image. As an alternating text the normalized band value is shown. The KPIValue object contains a property called InBand which can be used as an index for the status image found in the_layouts/../Scorecard/Images folder.

             foreach (KpiValue val in root.Children)
            {
               output.WriteLine( "<td Class=\"ms-vb\" align=center>" );

               Image img = new Image();
               img.AlternateText = val.NormalizedBandValue.ToString() + "%" ;
               img.ImageUrl = "_layouts/" + 
                   System.Threading.Thread.CurrentThread.CurrentUICulture.LCID.ToString() + 
                    "/Scorecard/Images/Indicator5DefaultBand" + val.InBand + ".gif" ;

               Controls.Add(img);
               img.RenderControl(output);

               output.WriteLine( "</td>" );
            }
         }

         output.WriteLine( "</tr>" );
      }

      output.WriteLine( "</table>" );
   }
    catch (Exception)
   {
   }
    finally
    {
      reader.Close();
   }
}

public class ImageFolderViewer : System.Web.UI.UserControl
{
    int horizontalImageCount = 4;
   int imageWidth = 120;
   int imageHeight = 80;

   ...
}

In the Page_Load of the class we call the GenerateImageView method to generate the images in the view.

private void Page_Load( object sender, System.EventArgs e)
{
   GenerateImageView();
}

The following property is used to set or get the number of horizontal images per row.

public int HorizontalImageCount
{
    get
    {
       return horizontalImageCount;
    }
    set
    {
      horizontalImageCount = value ;
   }
}

These properties are used for remembering the current folder and the original folder and are kept in the ViewState. The original folder is the first folder set to the control. We use the original folder to define when i link is displayed for moving a folder up.  

private string OriginalFolder
{
    get
    {
       return ViewState[ "originalFolder" ] != null ? ViewState[ "originalFolder" ].ToString() : "" ;
   }
    set
    {
      ViewState[ "originalFolder" ] = value ;
   }
}

public string Folder
{
    get
    {
       return ViewState[ "folder" ] != null ? ViewState[ "folder" ].ToString() : "" ;
   }
    set
    {
      // store the original folder in the viewstate
       if (OriginalFolder == "" )
      {
         OriginalFolder = value ;
      }

      ViewState[ "folder" ] = value ;
   }
}

The GenerateImageView is the engine of the class and generates all the images and subfolders. A seperate method GenerateDirectoryLink is used for generating the link and its argument per subfolder.

private void GenerateImageView()
{
    string imagePath = System.Web.HttpContext.Current.Server.MapPath(Folder);

   // check if the folder exists
   if (!Directory.Exists(imagePath))
   {
       return ;
   }

   TableCell cell = new TableCell();
   row.Controls.Add(cell);
   cell.ColumnSpan = HorizontalImageCount;

   LinkButton btn = new LinkButton();
   btn.Text = text;
   btn.CommandArgument = argument;
   btn.Click += new EventHandler(FolderButton_Click);
    cell.Controls.Add(btn);
}

When a link of a subfolder or "One folder up" is pressed an event is fired. The Folder property is set to the new folder and the view is generated again. 

private void FolderButton_Click( object sender, EventArgs e)
{
   LinkButton btn = sender as LinkButton;

   Folder = btn.CommandArgument;

   GenerateImageView();
}

Another problem is that if the images are large it will take some time to place them in the view. There are several solutions for this problem.

• You could create a thumbnail per image and refer the Image class to the thumbnail instead. The thumbnail is only generated once. So it will only be slow the first time
• Use a third-party tool like ASPJPeg which does the resizing for you.

Ofcourse there are more solutions but i thought that these two would be nice to tell about.

At Rob Howard's blog we can read that CodeSmith 3.0 has been released since Monday May 16th. I agree with him that using code generation tools can save enormous time and prevents common mistakes by writing the same code over and over again.

"Code generation tools represent one of the most interesting areas where a tremendous amount of innovation opportunity still exists for improving the software development process. By automating the process of creating framework, database access, or other common/repeated code patters developers can save time, companies can save money, and users of the end product will get better solutions. Why? Instead of spending hours repeating the same logic flows, data access layers, or implementation frameworks just write it once as a CodeSmith template. That's right -- using .NET code you can write a template for how you want your code to be generated. It's still your code with your formatting your comments and your style -- CodeSmith just helps you write it faster. In fact, you could say it's like hiring your own personal army of developers!"

You can download a free 30 day trial version.

http://weblogs.asp.net/rhoward/archive/2005/05/17/407197.aspx

Adam Machanic has posted a month ago an article about SqlDataReader performance tips. One about using an indexer with the ordinal position, a second one about avoiding the Get<datatype> methods and a third about opening and closing the reader.

Especially the last one is something we all sometimes forget. Thanks to Adam for these tips! :)

Tip 1: Use an indexer with the ordinal position:

Instead of:

          
            while
(reader.read()) object x = reader.GetValue("ColX");
          
        

or

          
            while
(reader.read()) object x = reader["ColX"];
          
        

do:

          
            int
ColX = reader.GetOrdinal("ColX"); while (reader.read()) object x = reader[ColX];
          
        

Tip 2: Avoid the Get<datatype> (e.g. GetInt32) methods at all costs, and use static casts instead of converts:

Bad:

          
            int
x = reader.GetInt32(ColX);
          
        

Better:

          
            int
x = Convert.ToInt32(reader[ColX]);
          
        

Best:

          
            int
x = (int)reader[ColX];
          
        

For maximal performance return the SQL Server equivalent of whatever datatype you'll be casting to (so that you can avoid the Convert methods.) And avoid NULLs so that you don't have to check for DBNull on the client.

Tip 3: "open late and close early"

Finally, just like in classic ADO, when using a SqlDataReader, "open late and close early" is the way to go. Open your connection at the last possible moment and close it as soon as you're done reading the data -- this will maximize connection pool availability.

you can find all the tips also at his blog by following this link:

http://sqljunkies.com/WebLog/amachanic/archive/2005/04/06/10462.aspx

Passing a null value to an int is not possible. The int type is mapped to the System.Int32 structure type and is not capable of storing a null value. Only integer values can be stored in there.

There are two ways which i know of how to solve this problem. The first method is using an object in stead of the int type. For example:

object val = 200;

if (val != null)
{
   return (int)val;
}

In this way you can set the val variable to a null value or an integer value. In case of an integer value you unbox the value to retrieve the integer value.

A second method is using the SqlInt32 type found in namespace System.Data.SqlTypes which is a SQL type. This type supports nullable values. For example:

SqlInt32 val = SqlInt32.Null;

or

SqlInt32 val = 200;

This is a very simple example how to transform a Webform.aspx file to a wizard. It contains two buttons and works even when the back and next button of the browser are used.

We keep the current page stored in the ViewState. The method ShowPage() should contain the functionality to show the contents of a wizard page. You could use a PlaceHolder per wizard page and show/hides these PlaceHolders.

   ShowPage();
}

private void ShowPage()
{
   lblPage.Text = CurrentPage.ToString();
}

private void InitializeComponent()
{ 
   this.btnPrev.Click += new System.EventHandler(this.btnPrev_Click);
   this.btnNext.Click += new System.EventHandler(this.btnNext_Click);
   this.Load += new System.EventHandler(this.Page_Load);
}

private int CurrentPage
{
    get
   {
      object page = ViewState["CurrentPage"];

      if (page == null)
      {
         ViewState["CurrentPage"] = 0;
      }

      return Convert.ToInt32(ViewState["CurrentPage"]);
   }
    set
   {
      ViewState["CurrentPage"] = value;
   }
}

private void btnPrev_Click(object sender, System.EventArgs e)
{
   CurrentPage--;
   ShowPage();
}

private void btnNext_Click(object sender, System.EventArgs e)
{
   CurrentPage++;
   ShowPage();
}
}

If you want to use functionality like SPControl.GetContextWeb(Context).Lists and your trust level is set to WSS_Minimum the code will throw an System.Security.Exception telling you that:

Request for the permission of type Microsoft.SharePoint.Security.SharePointPermission, Microsoft.SharePoint.Security, Version=11.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c failed

This means that the code is partial trusted. Normally if you install your assembly in the GAC it runs with "Full" trust. Microsoft recommends that you install your web part assemblies in the BIN directory for a more secure deployment. Therefor the code becomes partial trusted and some functionality is prohibited by the CAS (Code Access Security) and the trust level set in the web.config.

You could set your trust level to "Full" with the risk that everything is open but that is not a good solution. Maybe in your development environment but not at the customer. There is another solution! :)

 Make a copy of the wss_minimaltrust.config file and rename that file to wss_customtrust.config. The file can be found in the folder:

<drive>:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\60\config

Make the following changes in this xml file. These changes will increase the permission level for your web parts.

<SecurityClasses> 
   ...
   <SecurityClass Name="SharePointPermission" 
      Description="Microsoft.SharePoint.Security.SharePointPermission,  
       Microsoft.SharePoint.Security, 
      Version=11.0.0.0, 
       Culture=neutral, 
      PublicKeyToken=71e9bce111e9429c"
   />
</SecurityClasses>

<PermissionSet class="NamedPermissionSet" version="1" Name ="ASP.Net">
   ...
   <IPermission class="SharePointPermission" 
      version="1" 
      ObjectModel="True"
   />
</PermissionSet>

In the web.config file of your SharePoint website you will find a tag called <securityPolicy> and add the following line:

Finally we have to set the trust level in the web.config file changing the xml to

More information about WSS Code Access Security can be found at Microsoft by the following link. The article describes the method i explained above and give some extra tips about trust levels, custom policy files and more.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/odc_SP2003_ta/html/sharepoint_wsscodeaccesssecurity.asp

Todd Bleeker wrote an article in SharePoint Advisor Magazine about "Secure SharePoint Code Using Credential-less impersonation". He Describes a very cool method using the App Pool identity to complete tasks where the authenticated user doesn't have permissions for.

His code example for the RevertToAppPool class is as follow:

using System.Security.Principal;

namespace Mindsharp.Utilities
{
  public class RevertToAppPool
  {
    private WindowsImpersonationContext ctx = null;

    //Revert to the original application pool security context
    //We only want to do this if we are not already running as the system
    public void UseAppPoolIdentity()
    {
      try
      {
        if (!WindowsIdentity.GetCurrent().IsSystem)
        {
          ctx = WindowsIdentity.Impersonate(System.IntPtr.Zero);
        }
      }
      catch{}
    }

    //Return to impersonating the authenticated user
    //Anonymous users are impersonated as IUSR_machinename, by default
    public void ReturnToImpersonatingCurrentUser()
    {
      try
      {
        if(ctx != null)
        {
          ctx.Undo();
        }
      }
      catch{}
    }
  }
}

The code example for the RenderWebPart is as follow:

protected override void RenderWebPart(HtmlTextWriter output)
{
  try
  {
    output.Write("before:" + WindowsIdentity.GetCurrent().Name + "<BR>");
    Mindsharp.Utilities.RevertToAppPool reverter =
      new Mindsharp.Utilities.RevertToAppPool();

    reverter.UseAppPoolIdentity();
    output.Write("reverted:" + WindowsIdentity.GetCurrent().Name
      + "<BR>");

    reverter.ReturnToImpersonatingCurrentUser();
    output.Write("after:" + WindowsIdentity.GetCurrent().Name + "<BR>");

    EnsureChildControls();
    RenderChildren(output);
  }
  catch(Exception ex)
  {
    output.Write("<H1>" + ex.Message + "</H1>");
  }
}

For more information goto the article:

http://mindsharpblogs.com/todd/archive/2005/05/03/467.aspx

When you create a property in your WebPart and give it some extra attributes it will appear as a control when you modify your WebPart. The following code is an example:

[Browsable(true),
Category("Customer"),
DefaultValue(0),
WebPartStorage(Storage.Shared),
FriendlyName("Customer ID"),
Description("Fill in the customer ID")]
public int CustomerID
{
   get
   {
      return customerID;
   }
   set
   {
      customerID = value;
   }
}

This example creates a category named "Customer" with one field. the FriendlyName(..) is used as description for the field and the Description(..) is used as tooltip text. When no value is set the DefaultValue(..) is used as default value. In this case the field contains a zero.

When you use properties you only have a few possibilities. Checkboxes are used for booleans, Text fields are used for doubles, int, strings, etc and a dropdownlist is used for enumerations.

So why not create your own ToolPart with default and/or your own controls? It is even not that difficult. :)

I'm working on a BirthdayWebPart which needs some functionality to select through a dropdown box the contact list. But only enumerations are shown using a dropdown list. So we have to write our own ToolPart.

First we create a new class derived from the class Microsoft.SharePoint.WebPartPages.ToolPart. You could do this by hand or use the wizard in Visual Studio.

public BirthDayToolPart : Microsoft.SharePoint.WebPartPages.ToolPart
{
   private DropDownList ddlList = null;

   public BirthDayToolPart()
   {
      ...
   }

   public override void ApplyChanges()
   {   
      ...
   }

   protected override void RenderToolPart(HtmlTextWriter output)
   {
      ...
   }      
}

We will create and initialise the DropDownList in the constructor of the class. The DropDownList is filled with the list of available ContactLists.

public BirthDayToolPart()
{
   ddlList = new DropDownList();
   ddlList.ID = "ddlContactListName";
   Controls.Add(ddlList);

   SPWeb currentWeb = SPControl.GetContextWeb(Context);
   foreach(SPList list in currentWeb.Lists)
   {
      if (list.BaseTemplate == SPListTemplate.Contacts)
      {
         ddlList.Items.Add(new ListItem(list.Title, list.Title));   
      }
   }
}

Now we have to render the DropDownList to the client by overloading the RenderToolPart. We first retrieve the selected web part. Because this ToolPart belongs to the BirthDayWebPart we can cast it to this class. The property ContactListName of the BirthDayWebPart is used for getting the currently selected ContactList. The code is as follow:

protected override void RenderToolPart(HtmlTextWriter output)
{
   BirthDayWebPart webPart = ParentToolPane.SelectedWebPart as BirthDayWebPart;

   ddlList.SelectedValue = webPart.ContactListName;
   ddlList.RenderControl(output);

   // render other controls and/or write html to the client
   ...
}

Last but certainly not lease we override the ApplyChanges for storing the data back into the BirthDayWebPart. Here we set the ContactListName by using the property of the BirthDayWebPart class.

public override void ApplyChanges()
{
   BirthDayWebPart webPart = ParentToolPane.SelectedWebPart as BirthDayWebPart;

   webPart.ContactListName = Page.Request.Form[ddlList.ClientID];

   // store content of other controls
   ...
}

The next step is telling the BirthDayWebPart to use the ToolPart. We override the member GetToolParts() in the BirthDayWebPart as follow:

public override ToolPart[] GetToolParts()
{
   ToolPart[] toolParts = new ToolPart[3];

   toolParts[0] = new CustomPropertyToolPart();
   toolParts[1] = new WebPartToolPart();
   toolParts[2] = new BirthDayToolPart();

   return toolParts;
}

The CustomPropertyToolPart represents the default ToolPart that is displayed in the tool pane for a web part that implements one or more custom properties. Like for example a field containing the number of days to look forward.

The WebPartToolPart class represents a ToolPart that can be used to show or modify web part base properties. Like the minimize and title properties.

The third ToolPart is our own created BirthDayToolPart.

I'm always surprised that SharePoint developers do not often use more web part menus instead of adding ToolParts. The user doesn't have to go into edit mode which makes it more user-friendly.

This article decribes a method for adding an item to the menu of the web part. The menu of a web part can be found in the upper right corner.

In your web part you have to override the following member:

public class MyWebPart : Microsoft.SharePoint.WebPartPages.WebPart
{

 public override void CreateWebPartMenu()
 {
  base.CreateWebPartMenu();

  ...
 }
}

Inside this member you can do almost anything you want. If your web part is derived from a web part which already contains some menu items and you want to keep those just call its base member before adding or changing anything to the menu. I will describe some examples of what is possible with the menus of a web part.

The web part menu is accessible by the member WebPartMenu of the WebPart class. This member contains again a member called MenuItems which hold all the menu items of the menu in a MenuItemCollection. Each MenuItem contains again a member MenuItems which hold its children in a MenuItemCollection, and so on.

The class MenuItemCollection has some nifty methods:

IndexOf(myMenuItem) will return the index of the MenuItem myMenuItem.

ItemFromID(myItemID) will return the MenuItem having the ID myItemID.

There are two members for adding menu items to the collection. The first is adding the menu item at the end of the collection. This means that the menu item will appear at the bottom of the menu. The second way is inserting the menu item at a specified index. This index could be retrieved using the member IndexOf(..)

It is also possible to replace an existing menu item by another one using the method Replace(existingMenuItem, myNewMenuItem).

Adding menu items is very easily and there are some different options. It is possible to add server side or client side events to the menu item. Below some examples:

MenuItems.Add(new MenuItem("Click me", "ClickMeId", new EventHandler(OnClickMe));

public void OnClickMe(object sender, EventArg e)
{
...
}

This will add the menu item with label "Click me" and a server side event handler. When the menu item is clicked a postback is generated and the event handler is called.

MenuItems.Add(new MenuItem("Click me", "javascript:alert('You clicked me!');", "ClickMeId"));

This will add the menu item with label "Click me" and a client side event handler. When the menu item is clicked it will show a client side generated message box.

Also the menu items has some nice features like BeginSection which gets or sets whether to create or delete a separator line above the menu item. You can show, hide, check, uncheck, enable or disable menu items.

When a menu item had children in its MenuItems collection it will automatically appear as a popup menu item.

I expect that there are a lot of people who already wrote some knowlegde article about this. But it never hurts to explain it again. When you use Response.Transmitfile for transmitting a file to the client it gets the name of the current aspx file.

So how do you set the default name of the file which is downloaded to the client? It is actually very easy. The following code downloads a word file "rapport.doc" to the client:

string pathFileName = @"c:\documents\rapport.doc";
string fileName = System.IO.Path.GetFileName(pathFileName);

Response.ContentType = "application/msword";
Response.AddHeader("Content-Disposition", "attachment; filename=" + fileName);
Response.TransmitFile(pathFileName);

I like to use singletons in my applications, especially when i don't want to initialise a class all the time when i need it. The idea behind a singleton class is to get an instance by calling a static member method and not be able to instantiate the class yourself. In that way there will only be one instance of the class during the run of the application. This is accomplished by making the constructor protected. Normally a singleton class is used in a windows application as follow:

class SomeClass
{
   private static SomeClass instance = null;

   protected SomeClass()
   {
   }

   public static SomeClass Instance
   {
      get
      {
         if (instance == null)
         {
            instance = new SomeClass();
         }

         return instance;
      }
   }
}

When you want to use the same trick in an ASP.NET application it will not work, because everytime the class is destroyed when the content of your page is rendered to the client. But even singletons are usefull in ASP.NET applications and there is a solution by using for example the session state. The following code shows you how:

class SomeClass
{
   protected SomeClass()
   {
   }

   public static SomeClass Instance
   {
      get
      {
         object instance = System.Web.HttpContext.Current.Session["SomeClassInstance"];

         if (instance == null)
         {
            instance = System.Web.HttpContext.Current.Session["SomeClassInstance"] = new SomeClass();
         }

         return instance as SomeClass;
      }
   }
}

As you can see it just stores the instance in a session state. You could even store the instance in the application state if there is need for. It could be helpfull for your ASP.NET application. :)

I like to write all my code in C# and therefore i sometimes have to rewrite some examples written in VB.NET. This website is a quick reference guide to highlight some key syntactical differences between VB.NET and C#. Thanks to Tom Shelton, Fergus Cooney and others.

http://www.harding.edu/USER/fmccown/WWW/vbnet_csharp_comparison.html