That’s output caching in a nutshell! To implement output caching, simply add the <% @OutputCache %> directive to the top of your page like so:

duration is the number of seconds for which the rendered markup remains in the cache. paramList is a list of parameters whose values vary the cache. For example, if the page that displays employees displays just those employees in a particular department as determined by a querystring parameter, then we want to vary the cache by this parameter. To be more precise, imagine that our employee page displays a particular department’s employees when visited like ShowEmployees.aspx?DepartmentID=departmentID. If the cache is not varied by any parameter then when a user visits ShowEmployees.aspx?DepartmentID=Sales, the employees in the sales department will be returned and that markup will be cached. If within that cache duration a user visits ShowEmployees.aspx?DepartmentID=IT, they will still see the cached sales staff rather than the IT staff.

To fix this, we simply need to instruct the output cache engine to vary its cache by the DepartmentID parameter:

To vary by all parameters, use an asterisk (*); to vary by no parameters, use “None”.

A web farm is a multi-server scenario. So we may have a server in each state of US. If the load on one server is in excess then the other servers step in to bear the brunt.
How they bear it is based on various models.
1. RoundRobin. (All servers share load equally)
2. NLB (economical)
3. HLB (expensive but can scale up to 8192 servers)
4. Hybrid (of 2 and 3).
5. CLB (Component load balancer).

How to implement webfarms in .Net:

Go to web.config and
Here for mode = you have 4 options.
a) Say mode=inproc (non web farm but fast when you have very few customers).
b) Say mode=StateServer (for webfarm)
c) Say mode=SqlServer (for webfarm)
Whether to use option b or c depends on situation. StateServer is faster but SqlServer is more reliable and used for mission critical applications.

Web Garden

A web garden is a multi-processor setup. i.e., a single server (not like the multi server above).

How to use webgardens in .Net:
Go to web.config and
Change the false to true. You have one more attribute that is related to webgarden in the same tag called cpuMask.

Every assembly, whether static or dynamic, contains a collection of data that describes how the elements in the assembly relate to each other. The assembly manifest contains this assembly metadata. An assembly manifest contains all the metadata needed to specify the assembly’s version requirements and security identity, and all metadata needed to define the scope of the assembly and resolve references to resources and classes. The assembly manifest can be stored in either a PE (Portable Executable) file (an .exe or .dll) with Microsoft intermediate language (MSIL) code or in a standalone PE file that contains only assembly manifest information.

The following illustration shows the different ways the manifest can be stored.

Types of assemblies

Assembly Manifest Contents

The following table shows the information contained in the assembly manifest. The first four items — the assembly name, version number, culture, and strong name information.

Assembly name A text string specifying the assembly’s name.

Version number A major and minor version number, and a revision and build number. The common language runtime uses these numbers to enforce version policy.

Culture Information on the culture or language the assembly supports. This information should be used only to designate an assembly as a satellite assembly containing culture- or language-specific information. (An assembly with culture information is automatically assumed to be a satellite assembly.)

Strong name information The public key from the publisher if the assembly has been given a strong name.

Serialization is used to save session state in ASP.NET.

Serialization is to copy objects to the Clipboard in Windows Forms.

Serialization is used by remoting to pass objects by value from one application domain to another.

GAC – Global Assembly Cache

HD – High Definition

Caspol – Code Access Security Policy Tool

GLOBAL ASSEMBLY CATCHE

Each computer where the common language runtime is installed has a machine-wide code cache called the global assembly cache. The global assembly cache stores assemblies specifically designated to be shared by several applications on the computer.

Caspol

The Code Access Security Policy tool (Caspol)  enables users and administrators to modify security policy for the machine policy level, the user policy level, and the enterprise policy level.

what is mean by runtime?

A runtime is a component, which a computer must have in order to execute programs written in a particular programming language.The runtime of a language provides the basic features, needed by the programs written in that language to execute successfully.

For example, to execute a program written in Visual C#, the machine executing program must have Visual C# runtime installed in it. This requirement of different runtimes for different programming languages made the task of the programmer very tough. The developer could not share the code written in different programming languages.

The .NET CLR offers the solution to this providing a single runtime environment for multiple languages.

Problem

This project creates a Eventhandler in .net to fire on sharepoint site when we create a wiki page on the site. That Eventhanlder has to create two folders on that site with the name of the page
1.under shared documents
2.under Images (if exists) ..picture library.

Requirements:

Development Machine Requirements
1. Windows Server 2003 OS
2. WSS 3.0 or MOSS.
3. Dotnet installed on the system VS2005 or above The Downloadable version comes for VS2008
Client Side Requirements
1. Dotnet Framework 2.0 or above in which the application is made
2. WSS3.0 or MOSS

Solution
Now lets start developing the application
1. Create a class library project from VS 2005/2008 with the name “WikiEventHanlder”. You can even use any name of your choice I am using this for my example.
2. Rename the class as “WikiEvent.cs” .
3. Add sharepoint refernce to the project (Microsoft.Sharepoint)
4. Add following code to .”WikiEvent.cs”. in this we inherit the class with “IListEventSink” class

Coding

using System;
using System.IO;
using System.Xml;
using System.Xml.XPath;
using System.Configuration;
using System.Security.Principal;
using System.Runtime.InteropServices;
using Microsoft.SharePoint;

namespace WikiEventHanlder
{
///
/// Summary description for Class1.
///

public class WikiEvent: IListEventSink
{
#region IListEventSink Members

public void OnEvent(SPListEvent listEvent)
{
//Open the current context site
SPWeb myWeb = listEvent.Site.OpenWeb();
//Get  the target Event hanlder source name as file name
SPFile fileItem = myWeb.GetFile(listEvent.UrlAfter);

//get the folder structure of the source
SPFolder folderItem = myWeb.GetFolder(listEvent.UrlAfter);

//assign a delimiter to get the target url to add the folders
string delimiter = “/”;
//get the collection atleast 10 of folder names under the parent folder of the source of the event i.e wiki pages library
string[] subFolder = folderItem.ParentFolder.Url.Split(delimiter.ToCharArray(), 10);
//get all folders of the site
SPFolderCollection folders= myWeb.Folders;
SPFolder targetfolder=null,targetFolder1=null;
//Get the page name of the created page
string pageName = fileItem.Name;
//remove .aspx from the name
int index=pageName.IndexOf(“.aspx”);
pageName = pageName.Remove(index, 5);
pageName = pageName.Trim();

//traverse to Shared documents folder
foreach (SPFolder folder in folders)
{
if (folder.Name == “Shared Documents”)
{
targetfolder = folder;
break;
}
}
//traverse to Images folder
foreach (SPFolder folder in folders)
{
if (folder.Name == “Images1″)
{
targetFolder1 = folder;
break;
}
}
//create the folders under them
switch(listEvent.Type.ToString())
{
case “Update”:
if (subFolder.Length < 2)
{
create_folders(listEvent, myWeb, targetfolder, pageName);
create_folders(listEvent, myWeb, targetFolder1, pageName);
}
break;

default:       break;
}
}

#endregion
/* creates the folder for the
* list Event on the current myWeb and under folderItem with name pageName*/
private void create_folders(SPListEvent listEvent,
SPWeb myWeb,
SPFolder folderItem ,
string pageName)
{
SPFolder tempFolder=folderItem.SubFolders.Add(pageName);
}
}
}

5. Strong name the project by going to project properties->signing
6. Compile the project .
7. Add the dll to GAC.
* By dragging and dropping the dll to C:\WINDOWS\assembly
(or)
* using the command at Visual studio command prompt
GACUTIL.exe /i [path]/WikiEventHanlder.dll /f .
8. Go to Sharepoint Central Adminsitration(start->settings->control panel->adminstrative tools) and
* goto Application Management > Web Application General Settings
* select the site collection you require and godown to Backward- Compatible Event Handlerssection and make it “on”
* Refer figure1 and Figure2 for help.
9. Browse to your site and goto the WikiPage site.
10. Goto the Page library named as “Wiki Pages”,click on Settings then move to Document Library settings
in that goto Advanced settings section and move to Backward-Compatible Event Handler section .
11. In this page add details of the assembly inthe assembly name text box as

WikiEventHanlder,Version=1.0.0.0,Culture=neutral,PublicKeyToken=5b283fb82a61470c

In the above line take the public key token value from GAC by right clicking on the assembly or dll(browse to C:\WINDOWS\assembly for the dll)

12. In the class name box enter,

WikiEventHanlder.WikiEvent

Refer figure3 for the above steps 11,12

13. click on OK button,if your assembly has any errors then error will be given otherwise you will be moved to the settings page back.
14. Now goto the Wiki Pages and create a page with any name(lets say samplePage) this will automatically creates one folder under Shared Documents with name “samplePage” another under Images(if exists) with same name as “samplePage”.
15. Goto Shared Documents, Images and check the folders created.

Attachments

figure 1

figure 2

figure 3

The result of applying a regular expression to a string is either to return a substring, or to return a new string representing a modification of some part of the original string.

EX:

One,Two,Three Liberty Associates, Inc.

you can return any or all of its substrings (e.g.,Liberty  or One ), or modified versions of its substrings (e.g., LIBeRtY  or OnE ).

A regular expression consists of two types of characters:

1.Literals

2. Metacharacters.

A literal is just a character you wish to match in the target string. A metacharacter is a special symbol which acts as a command to the regular expression parser.

Using Regex

The Base Class Library namespace System.Text.RegularExpressions  is the home to all the .NET Framework objects associated with regular expressions. The central class for regular expression support is  Regex , which represents an immutable, compiled regular expression.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace regular
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = “one, two three welcome india”;
            Regex r = new Regex(” |, “);            
           
          foreach (string a in r.Split(s))
             {
                 Console.WriteLine(a);      

             }
            Console.ReadLine();
        }
    }
}

Output: 

one

two

three

welcome

india

Using Regex Match Collections

Two additional classes in the .NET RegularExpressions  namespace allow you to search a string repeatedly, and to return the results in a collection. The collection returned is of type MatchCollection , which consists of zero or more Match  objects. 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace regular
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = “This is a test sample”;
            Regex r = new Regex(@”(\S+)\s”);

            MatchCollection m = r.Matches(s);

           foreach (Match theMatch in m)

            {

                Console.WriteLine(theMatch);    

             }
            Console.ReadLine();
        }
    }
Explanation:

The string \S  finds nonwhitespace, and the plus sign indicates one or more. The string \s  (note lowercase) indicates whitespace. Thus, together, this string looks for any nonwhitespace characters followed by whitespace. 

Output:

This

is

a

test

The output shows that the first four words were found. The final word was not found because it is not followed by a space. If you insert a space after the word string  and before the closing quote marks, this program will find that word as well. 

Using Regex Groups

The Group  class allows you to create groups of matches based on regular expression syntax, and represents the results from a single grouping expression. 
A grouping expression names a group and provides a regular expression; any substring matching the regular expression will be added to the group.

For example, to create an ip  group you might  write: 
@”(?<ip>(\d|\.)+)\s”   

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace regular
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = “04:03:37 123.0.0.0 sivasrec.com “;

            Regex r = new Regex(@”(?<time>(\d|\:)+)\s” + @”(?<ip>(\d|\.)+)\s” + @”(?<site>\S+)”);

            MatchCollection m = r.Matches(s);
            foreach (Match theMatch in m)

            {
                if (theMatch.Length != 0)
                {
                    Console.WriteLine(“\ntheMatch: {0}” , theMatch.ToString()); 

                    Console.WriteLine(“time: {0}”, theMatch.Groups["time" ]); 

                    Console.WriteLine(“ip: {0}”, theMatch.Groups["ip" ]); 

                    Console.WriteLine(“site: {0}”, theMatch.Groups["site" ]);

                 }

            }             
            Console.ReadLine();
        }
    }
} 

Explanation:

(?<time>
The parentheses create a group. Everything between the opening parenthesis (just before the question mark) and the closing parenthesis (in this case, after the +  sign) is a single unnamed group. 

(@”(?<time>(\d|\:)+)
The string  ?<time>  names that group  time  and the group is associated with the matching text, the  regular expression (\d|\:)+)\s” . This regular expression can be interpreted as “one or more digits  or colons followed by a space.” 

Output: 

the match : 04:03:37 123.0.0.0 sivasrec.com

time: 04:03:37

ip : 123.0.0.0

site : sivasrec.com

If you want to quickly access the value of an HTML input give it an id to make your life a lot easier. This small script below will check to see if there is any text in the text field “myText”. The argument that getElementById requires is the id of the HTML element you wish to utilize.

<html>
<head>
<script type=”text/javascript”>
function ad()
{
var m=document.getElementById(“my”);
if(m.value!=”")
{
alert(“enter:”+m.value)
}
else
{
alert(“type value”)
}
}
</script>
</head>

<body>
<input type=”text” id=”my”/>
<input type=”button” onclick=”ad()” value=”enter”/>
</body>
</html>

document.getElementById returned a reference to our HTML element myText. We stored this reference into a variable, myTextField, and then used the value property that all input elements have to use to grab the value the user enters.

There are other ways to accomplish what the above script does, but this is definitely a straight-forward and browser-compatible approach.

Things to Remember About getElementById

When using the getElementById function, you need to remember a few things to ensure that everything goes smoothly. You always need to remember that getElementById is a method (or function) of the document object. This means you can only access it by using document.getElementById.

Also, be sure that you set your HTML elements’ id attributes if you want to be able to use this function. Without an id, you’ll be dead in the water.

If you want to access the text within a non-input HTML element, then you are going to have to use the innerHTML property instead of value. The next lesson goes into more detail about the uses of innerHTML.

Output

Click On enter button

Enter value in text box

The Navigator object contains information about the visitor’s browser name, version, and more.

The Navigator Object

The JavaScript Navigator object contains all information about the visitor’s browser. We are going to look at two properties of the Navigator object:

* appName – holds the name of the browser
* appVersion – holds, among other things, the version of the browser

<html>
<head>
<script type=”text/javascript”>
var name=navigator.appName;
var id=navigator.appVersion;
var v=parseFloat(id);
document.write(“browser:”+name);
document.write(“<br/>”);
document.write(“ver:”+v);
</script>
</head>
</html>

The variable browser in the example above holds the name of the browser, i.e. “Netscape” or “Microsoft Internet Explorer”.

The appVersion property in the example above returns a string that contains much more information than just the version number, but for now we are only interested in the version number. To pull the version number out of the string we are using a function called parseFloat(), which pulls the first thing that looks like a decimal number out of a string and returns it.

IMPORTANT! The version number is WRONG in IE 5.0 or later! Microsoft starts the appVersion string with the number 4.0. in IE 5.0 and IE 6.0!!! Why did they do that??? However, JavaScript is the same in IE6, IE5 and IE4, so for most scripts it is ok.

Output

browser: Netscape
ver: 5.0