DOT NET TIPS AND TRICKS

Convert DATETIME TO TIMESPAN IN C#

2011-11-01T07:51:00.000-07:00

In the previous post, I mentioned how to convert DATETIME to TIMESPAN.

Now if the requirement is to convert DATETIME TO TIMESPAN, we can do that in one line:

DateTime dt="XXX";
TimeSpan TS = new TimeSpan(dt.Now.Ticks);

This will convert the DateTime to TimeSPan.

Varun

Convert TimeSpan To DateTime in c# + One line Code

2011-11-01T04:49:00.000-07:00

We usually fall into the situation where conversion of Timespan to DateTime is required.

Here is how it can be done easily just by casting:

Suppose we have two variables DateTime and Timespan and Timespan one with some value
DateTime dt;
TimeSpan ts="XXX";

We can covnert 'ts' to 'dt' like this:

dt= Convert.ToDateTime(ts.ToString());

Thats it!!!

Hope you have liked the solution.

Varun

Microsoft Access was unable to create the .accde, .mde or .ade file

2010-02-02T20:39:00.000-08:00

Problem

Many times we faces issue that after creating the MDB file, when we try to compile the database to MDE file ,Access gives the following error :

Microsoft Access was unable to create the .accde, .mde or .ade file

On clikcing the button 'Show Help', it shows following error message:

This error is usually associated with compiling a large database into an MDE file. Because of the method used to compile the database, a considerable number of TableID references are created for each table. The Access database engine can only create a maximum of 2048 open TableIDs at one time. Exporting a database as an MDE potentially can exceed this limit if the database has a large number of objects (table, macro, form, report, etc).
There is no accurate method to estimate the number of TableIDs the Access database engine uses during the process of compiling a database as an MDE. However, each VBA module and each form uses one TableID, as a result, if the database has 500 forms, and each form's HasModule property is set to Yes, as many as 1,000 TableIDs are used.

Solution:

The main reason of database not getting compiled to mde is that it failed during comilation. That is , yiu have some code tha failed to compile.

Steps:

1. Press Alt + F11 to display VBA editor.
2. In the menu 'Debug' , you will find 1st menu item as 'Compile AccessDb'.
3. Click that option.
4. If there is no error, the database will get compiled.
5. If durong compilation, any error is encountered, the VBA editor will display that error and you can rectifiy that.
6. Once all errors get rectified, you will be able to compile the database.

Once successfully compiled, try makeing the mde again ans it will definitly make the mde file.

How to reset the autoincrement field in MS Access Table

2009-12-23T01:44:00.000-08:00

How to reset the autoincrement field in MS Access Table

Many times we use autoicrement field in Ms Access table and we have noticed that the value of autoincrement field keeps on increasing ever if we delete all the rows of the table and add new row.
In order to reset the autoincrement field value back to 1, do the following:

1. Delete all the rows from the table.
2. Compact the whole database .

This will automatically reset the autoincrement value back to 1.

Introducing WCF 3.5

2009-12-22T21:30:00.000-08:00

This post is dedicated to WCF and its basics. We will go through various conceptual points of WCF and learn step by step implementation of WCF.
This post will cover few fundamental topics like:
• What is Windows Communication Foundation?
• Advantage of WCF
• What is an endpoint?
• Structure of endpoint or ABC of an end point.
• Explaining Address
• Explaining Binding and type of binding
• How to select proper binding
• Contracts and type of contracts
• Discussing Service Contract in detail।

What is WCF?
WCF stands for Windows Communication Foundation and comes along with Dot net framework 3.0 onwards and as a part of operating system from Vista onwards.
Business process in today’s market depends on various systems based on systems that runs on different platform within or outside an organization. There must be a way , a solution to have a communication between these various systems.
Why to use WCF?
WCF basically is a Microsoft’s solution to develop communication between distributed application। One may think why to use WCF when we already have lot of options to develop distributed application in past. The one line answer is that WCF acts as an unified technology that encapsulates all existing technologies to develop distributed application such as .NET Remoting, ASMX, MSMQ etc.

Apart from that we get lot of option on how to host the WCF service like IIS, or Widows Activated Service (WAS) etc. That we will discuss in later post.
I am eliminating discussion on history of distributed application since distributed application development is such a huge topic that it will divert our objective to learn WCF basics , However, throughout the document, I will map the similarity between existing distributed application solution to WCF।

Endpoint is the part that a service exposes to the outer system. It defines various details of a service hosted. The consumer reads the endpoint to judge the nature, type of the hosted service.
The ABC of WCF Endpoint:

Three basic component of any WCF service is :
“A” is for Address: Where to find the service
“B” is for Binding: How to communicate with the service
“C” is for Contract: What to send to the service or what to expect from the service.

Address:

It defines where on the network messages should be sent so that the endpoint receives them. This is the location to which messages must be sent by the client.

The address for an endpoint is a unique Uniform Resource Locator (URL) that identifies the location of the service. The address should follow the Web Service Addressing (WS-Addressing) standard, which means it might contain the following four parts:

• Scheme: The top-level portion of the address, this is typically “http” followed by a colon.
This is not the same thing as a protocol, even though it commonly uses the same letters as the protocol.
• Machine: Identifies the machine name, which can be a public URL or a local identifier.
• Port: The optional port number, preceded by a colon.
• Path: The path used to locate the service files. Typically, this is just the service name, but the path

Syntax of an address will be: Scheme://Machine[:Port]/Path1/Path2

Examples:

http://localhost:8080/Service1
http://localhost/Service1/SubService
http://www.ServiceHost.com/Service1
net.tcp://localhost:1234/OrderService

WCF supports several protocols, and each has its own particular addressing format.
1. HTTP protocol:
HTTP services can be either self-hosted or hosted on Internet Information Services (IIS). When addressing an HTTP service in a self-hosted scenario, you use the following format:
http://localhost:8080/QuickReturns/Exchange
2. TCP Protocol:
The TCP transport uses the net.tcp: scheme but otherwise follows the same rules as described
for HTTP addresses. Here is an example:
net.tcp://localhost:8080/QuickReturns/Exchange
3. MSMQ:
You can use the Microsoft Message Queue (MSMQ) transport in an asynchronous one-way
(fire-and-forget) or duplex type of messaging pattern and use the MSMQ features of Windows. net.msmq://localhost/private$/QuickReturnSettleTrade
4. Named Pipes:
It is a common way to provide a means to implement inter- or in-process communication.
The Named Pipes transport in WCF supports only local communication and uses the
net.pipes scheme. Port numbers don’t have any meaning with the Named Pipes transport.
This results in the following address format:
net।pipe://localhost/QuickReturns/Exchange

Binding:

A binding defines how you can communicate with the service. It is the primary extension point of the ABCs of WCF. The binding controls the following:

• The transport (HTTP, MSMQ, Named Pipes, TCP)
• The channels (one-way, duplex, request-reply)
• The encoding (XML, binary, MTOM…)
• The supported WS-* protocols (WS-Security, WS-Federation, WS-Reliability, WS-Transactions)

WCF provides a default set of bindings that should cover most of your requirements. If the default bindings don’t cover your requirements, you can build your own binding by extending from CustomBinding.

There are nine preconfigured bindings in WCF. Each of these provides the means for a particular distributed computing need. There are several factors that determine which binding to choose for a specific application, including security, interoperability, reliability, performance, and transaction requirements.

Table below compares the nine preconfigured bindings by showing the common features they support. This table can be used to select a best binding for a particular need.

Below is the process that will help you to select the binding you required for your application:

Contract:

A contract is a description of the messages that are passed to and from service endpoints.

There are three types of contracts in WCF:

• Service contracts : Service contracts describe the functional operations implemented by the service. A service contract maps the class methods of a .NET type to WSDL services, port types, and operations. Operation contracts within service contracts describe the service operations, which are the methods that implement functions of the service.

• Data contracts: Data contracts describe data structures that are used by the service to communicate with clients. A data contract maps CLR types to XML Schema Definitions (XSD) and defines how they are serialized and deserialized. Data contracts describe all the data that is sent to or from service operations.

• Message contracts: Message contracts map CLR types to SOAP messages and describe the format of the SOAP messages and affect the WSDL and XSD definitions of those messages. Message contracts provide precise control over the SOAP headers and bodies.

We will cover each type of binding and contract as we moves ahead with the implantation of WCF service. All theory will really make all of confuse so we need a bit of coding also..

Explaining Service Contract:

NOTE: before going into code, I would like to mention that all class, attributes specified to WCF comes from System.ServiceModel namespace. So import this namespace before going for coding.
A service contract is a collective mechanism by which a service capabilities and requirements are specified for its consumers.
Few points regarding Service Contract:
• A service contract can be applied to a normal dot net class or an interface.
• Service contract attribute is not inherited. That means if you are inheriting a class that has service contract attribute to it, you need to define the attribute to the derived class also. It will not get inherited automatically.
• Best practice is to use service contract attribute to interface.
• Always use namespace and Name parameter when defining a service contract attribute.

Sample Code:

An interface defined as a service contract without any parameter.
[ServiceContract()]
public interface ITaskManagerService
{ …. }
An interface defined as a service contract without any parameter.
[ServiceContract(Name=”ServiceName”,Namespace=”http://schema.application.com/path1”)]
public interface ITaskManagerService
{ …। }

Explaining Operation Conntract:

The OperationContractAttribute, also defined in the System.ServiceModel namespace, can be applied only to methods. It is used to declare the method as belonging to a Service contract.

[ServiceContract(Name=”ServiceName”,Namespace=”http://schema.application.com/path1”)]
public interface ITaskManagerService
{
[OperationContract(IsOneWay = true,name=”Operation1”)]
void ProcessInsertMessage(Message message);
}
So the above piece of code displays a interface defined as a service contract and its method as an operation contract।

In next article, I will discuss Message Exchange Pattern and two other contracts that is Data Contract and Message Contract.

All about Global.asax

2009-11-18T01:50:00.000-08:00

This file is used by the application to hold application-level events, objects, and variables — all of which are accessible application-wide. Active Server Pages developers had something similar with the Global.asa file.

Your ASP.NET applications can have only a single Global.asax file. This file supports a number of items.

When it is created, you are given the following template:

<%@ Application Language="VB" %>
<script runat="server">

Sub Application_Start(ByVal sender As Object, ByVal e As EventArgs)
' Code that runs on application startup
End Sub

Sub Application_End(ByVal sender As Object, ByVal e As EventArgs)
' Code that runs on application shutdown
End Sub

Sub Application_Error(ByVal sender As Object, ByVal e As EventArgs)
' Code that runs when an unhandled error occurs
End Sub

Sub Session_Start(ByVal sender As Object, ByVal e As EventArgs)
' Code that runs when a new session is started
End Sub

Sub Session_End(ByVal sender As Object, ByVal e As EventArgs)
' Code that runs when a session ends.
' Note: The Session_End event is raised only when the sessionstate mode
' is set to InProc in the Web.config file. If session mode is
' set to StateServer
' or SQLServer, the event is not raised.
End Sub

</script>

Just as you can work with page-level events in your .aspx pages, you can work with overall application
events from the Global.asax file.

In addition to the events listed in this code example, the following list
details some of the events you can structure inside this file:

- Application_Start: Called when the application receives its very first request. It is an ideal spot in your application to assign any application-level variables or state that must be maintained across all users.

- Session_Start: Similar to the Application_Start event except that this event is fired when an individual user accesses the application for the first time. For instance, the Application_Start event fires once when the first request comes in, which gets the application going, but the Session_Start is invoked for each end user who requests something from the application for the first time.

- Application_BeginRequest: Although it not listed in the preceding template provided by Visual Studio 2008, the Application_BeginRequest event is triggered before each and every request that comes its way. This means that when a request comes into the server, before this request is processed, the Application_BeginRequest is triggered and dealt with before any processing of the request occurs.

- Application_AuthenticateRequest: Triggered for each request and enables you to set up custom authentications for a request.

- Application_Error: Triggered when an error is thrown anywhere in the application by any user of the application. This is an ideal spot to provide application-wide error handling or an event recording the errors to the server’s event logs.

- Session_End: When running in InProc mode, this event is triggered when an end user leaves the application.

- Application_End: Triggered when the application comes to an end. This is an event that most ASP.NET developers won’t use that often because ASP.NET does such a good job of closing and cleaning up any objects that are left around.

In addition to the global application events that the Global.asax file provides access to, you can also use directives in this file as you can with other ASP.NET pages. The Global.asax file allows for the following directives:

- @Application
- @Assembly
- @Import

These directives perform in the same way when they are used with other ASP.NET page types.

How to place two classes written in different languages in App_Code

2009-11-18T01:35:00.000-08:00

What is App_Code ?

The \App_Code folder is meant to store your classes, .wsdl files, and typed datasets. Any of these items stored in this folder are then automatically available to all the pages within your solution.

Everything placed in the \App_Code folder is compiled into a single assembly. The class files placed within the \App_Code folder are not required to use a specific language. This means that even if all the pages of the solution are written in Visual Basic 2008, the class in the \App_Code folder of the solution can be built in C#.
Here is a small catch...

Because all the classes contained in this folder are built into a single assembly, you cannot have classes of different languages sitting in the root \App_Code folder, as in the following example:

\App_Code
Class1.cs
Class2.vb

Having two classes made up of different languages in the \App_Code folder causes an
error to be thrown. It is impossible for the assigned compiler to work with two different languages.

Therefore, in order to be able to work with multiple languages in your \App_Code folder, you must make some changes to the folder structure and to the web.config file.

The first step is to add two new subfolders to the \App_Code folder
— a \VB folder and a \CS folder.
This gives you the following folder structure:
\App_Code
\VB
\CS

This still will not correctly compile these class files into separate assemblies, at least not until you make some additions to the web.config file.

In the web.config file , change the <compilation>
node so that it is structured as following:

<compilation>
<codeSubDirectories>
<add directoryName="VB"></add>
<add directoryName="CS"></add>
</codeSubDirectories>
</compilation>

Now that this is in place in your web.config file, you can work with each of the classes in your ASP.NET pages. In addition, any C# class placed in the CS folder is now automatically compiled just like any of the classes placed in the VB folder.

NOTE: The name of sub directories are'VB' and 'CS' for this example. You can put any name you wish to.

SharePoint Server 2010 Preliminary System Requirements

2009-11-10T08:32:00.000-08:00

Sharepoint Server 2010 is on its way and it is high time to get ourself familiar with the system requirement of SharePoint Server 2010..

SharePoint Server 2010 will be 64 bit only.
SharePoint Server 2010 requires 64 bit Windows Server 2008 (R2)
SharePoint Server 2010 requires 64 bit SQL Server 2005 or 2008
SharePoint Server 2010 will support only IE7, IE8 and Firefox 3.x on Windows OS.
IE6 will not be supported by SharePoint Server 2010

The reason SharePoint platform is upgrading to 64 bit is to utilize the full power of extra bits while using 64 bit bus.

SharePoint performance and scalability can benefit significantly from 64-bit SQL Server and the throughput increases are significant enough for us to make the difficult decision to only support SharePoint Server 2010 on 64-bit SQL Server 2005 or 2008. It has been our strong recommendation for some time that SharePoint Server 2007 customers take advantage of 64-bit SQL Server due to the inherent performance and scale benefits it can provide.

Look out for the space for more news on SharePoint Server 2010.....

Varun

How to disconnect a map drive using vbscript

2009-09-08T22:13:00.000-07:00

In my previous post, I described how to connect to a network drive.
In this post, I will demonstrate how to disconnect from an existing connected network drive.

Suppose we have a drive Z: that is a network drive connected. Following is the code regarding how ti remove it.

Option Explicit
Dim WshNetwork, ShareName
Set WshNetwork = WScript.CreateObject("WScript.Network")
ShareName = "Z:"
WshNetwork.RemoveNetworkDrive ShareName, true, true
WScript.Quit

We are creating an object of WScript.Network and calling method RemoveNetworkDrive by passing the drive letter.

How to map network drive using VBScript

2009-09-08T22:04:00.000-07:00

Some time it is required to map a network drive using vbscript.
Today I will demonstate how to connet and then disconnect from a network drive.

In order to connect to a network drive, we need following data/information:

1. HomeServer Location: Actual path of the drive. In our example it is
"\\125.99.218.158\Data"

2. Name of the drive you wish to give: Let us say Z:

3. UserId/Password using which we will connect the map drive. If userid is same as logged in user then it is not required.

We will create an object of WScript.Network and call its method MapNetworkDrive

Here is the code:

Option Explicit
Dim strUser, strPassword, strDriveLetter, strHomeServer, strProfile
Dim objNetwork
Set objNetwork = CreateObject("WScript.Network")

strDriveLetter = "Z:"
strHomeServer = "\\125.99.218.158\Data"
strProfile = "False" ' Mapping (not) stored in user Profile
strUser = "USERID"
strPassword = "PASSWORD"

objNetwork.MapNetworkDrive strDriveLetter,strHomeServer,strProfile,strUser,strPassword

WScript.Quit

So the above code is creating an object of Wscript.Network and calling method MapNetworkDrive by passwing parameters like drive letter, hom server, userid and password.
There is one more parameter that is strProfile. If set true, it will store the drive info in user profile and it will connect automatically next time when user logs in.

2009-07-29T08:50:00.001-07:00

How to send mail using CDO in VBScript

2009-07-21T05:42:00.000-07:00

Today we will see how to send mail using CDO in VBScript. The same code can be used in ASP, VB also with small modification.

STEP 1: Define the constants:

Const cdoSendUsingMethod="http://schemas.microsoft.com/cdo/configuration/sendusing"
Const cdoSendUsingPort = 2
Const cdoSMTPServer ="http://schemas.microsoft.com/cdo/configuration/smtpserver"
Const cdoSMTPServerPort ="http://schemas.microsoft.com/cdo/configuration/smtpserverport"
Const cdoSMTPConnectionTimeout ="http://schemas.microsoft.com/cdo/configuration/smtpconnectiontimeout"
Const cdoSMTPAuthenticate = "http://schemas.microsoft.com/cdo/configuration/smtpauthenticate"
Const cdoBasic = 1
Const cdoSendUserName="http://schemas.microsoft.com/cdo/configuration/sendusername"
Const cdoSendPassword ="http://schemas.microsoft.com/cdo/configuration/sendpassword"
Const CdoReferenceTypeName = 1

STEP 2: Declare variables

Dim objConfig ' As CDO.Configuration
Dim objMessage ' As CDO.Message
Dim Fields ' As ADODB.Fields
Dim HtmlBody

STEP 3: Get a handle on the config object and it's fields

' Get a handle on the config object and it's fields
Set objConfig = CreateObject("CDO.Configuration")
Set Fields = objConfig.Fields

' Set config fields we care about
With Fields
.Item(cdoSendUsingMethod) = cdoSendUsingPort
.Item(cdoSMTPServer) = <SMTP-SERVER-NAME>
.Item(cdoSMTPServerPort) = <PORT-NUMBER>
.Item(cdoSMTPConnectionTimeout) = 10
.Item(cdoSMTPAuthenticate) = cdoBasic
.Item(cdoSendUsingMethod ) = 2
.Update
End With

STEP 4: Create instance CDO.Messsage object

Set objMessage = CreateObject("CDO.Message")

STEP 5: Add image to the mail body

Add this step only if you have an image to add to the body
Set objBP = objMessage.AddRelatedBodyPart("C:\Users\Varun.Sharma\Shell\1.jpg", "1.jpg", CdoReferenceTypeName)
objBP.Fields.Item("urn:schemas:mailheader:Content-ID") = "<1.jpg>"
objBP.Fields.Update

For description of step 5, visit: How to add image to mail body using CDO

STEP 6: assign the properties of CDO.Message object

Set objMessage.Configuration = objConfig

STEP 7: Build the HTML Body

Always prepare your html body before hand. That will help your code look better

HtmlBody="<img src=1.jpg><br>"
HtmlBody=HtmlBody & " Sending mail using CDO"

STEP 8: Set the CDO.Message mail properties

With objMessage
.To = To-Address
.Cc = CC-Address
.From = From-Address
.Subject = "SMTP Relay Test"
.HtmlBody=HtmlBody
.Send
End With

STEP 9: Release the CDO instances

Set Fields = Nothing
Set objMessage = Nothing
Set objConfig = Nothing

FULL CODE:

Const cdoSendUsingMethod ="http://schemas.microsoft.com/cdo/configuration/sendusing"
Const cdoSendUsingPort = 2
Const cdoSMTPServer ="http://schemas.microsoft.com/cdo/configuration/smtpserver"
Const cdoSMTPServerPort ="http://schemas.microsoft.com/cdo/configuration/smtpserverport"
Const cdoSMTPConnectionTimeout ="http://schemas.microsoft.com/cdo/configuration/smtpconnectiontimeout"
Const cdoSMTPAuthenticate ="http://schemas.microsoft.com/cdo/configuration/smtpauthenticate"
Const cdoBasic = 1
Const cdoSendUserName ="http://schemas.microsoft.com/cdo/configuration/sendusername"
Const cdoSendPassword ="http://schemas.microsoft.com/cdo/configuration/sendpassword"
Const CdoReferenceTypeName = 1

Dim objConfig ' As CDO.Configuration
Dim objMessage ' As CDO.Message
Dim Fields ' As ADODB.Fields
Dim HtmlBody

' Get a handle on the config object and it's fields
Set objConfig = CreateObject("CDO.Configuration")
Set Fields = objConfig.Fields

' Set config fields we care about
With Fields
.Item(cdoSendUsingMethod) = cdoSendUsingPort
.Item(cdoSMTPServer) = SMTP-SERVER-NAME
.Item(cdoSMTPServerPort) = PORT-NUMBER
.Item(cdoSMTPConnectionTimeout) = 10
.Item(cdoSMTPAuthenticate) = cdoBasic
.Item(cdoSendUsingMethod ) = 2
.Update
End With

Set objMessage = CreateObject("CDO.Message")

Set objBP = objMessage.AddRelatedBodyPart(PHYSICAL-PATH-OF-IMAGE, "1.jpg", CdoReferenceTypeName)
objBP.Fields.Item("urn:schemas:mailheader:Content-ID") = "<1.jpg>"
objBP.Fields.Update

Set objMessage.Configuration = objConfig
HtmlBody="<img src=1.jpg><br>"
HtmlBody=HtmlBody & "Testing the mail"

With objMessage
.To = TO-ADDRESS
.Cc = CC-ADDRESS
.From = FROM-ADDRESS
.Subject = "SMTP Relay Test"
'.TextBody = "SMTP Relay Test Sent @ " & Now()
.HtmlBody=HtmlBody
.Send
End With

Set Fields = Nothing
Set objMessage = Nothing
Set objConfig = Nothing

How to add image to mail body using CDO

2009-07-21T05:35:00.000-07:00

Many times we face situation like, we need to send image in the html body of the mail that too using CDO.

Suppose we have an image at local server from where MailSend Code will get fire, here is the code:

Add this line of code to your CDO code to send image as a mail body:

Set objMessage = CreateObject("CDO.Message")
Set objBP = objMessage.AddRelatedBodyPart("C:\Users\Varun.Sharma\Shell\1.jpg", "1.jpg", CdoReferenceTypeName)
objBP.Fields.Item("urn:schemas:mailheader:Content-ID") = "<1.jpg>"
objBP.Fields.Update

Here, in AddRelatedBodyPart,
argument 1 is : physical location of image
argument 2 is : identifier of the image (any name)
argument 3 is : To tell CDO to send the image as well

In next line, just put image identifer to the right hand side.

When sending mail refer the image in html body like this:

mail.HtmlBody="<img src=1.jpg" >

For full code of sending mail using CDO, check the following link:
How to send mail using cdo in vbscript

Learning UML with C#

2009-07-05T22:21:00.000-07:00

UML is a simple diagramming style that was developed from work done by Grady Booch, James Rumbaugh, and Ivar Jacobson, which resulted in a merging of ideas into a single specification and, eventually, a standard.

Here , We will see how to map a class and its relation in UML.

Basic UML diagrams consist of boxes representing classes. Let’s consider
the following class (which has very little actual function).

Basic Class :

public class Person {
private string name;
private int age;
//-----
public Person(string nm, int ag) {
name = nm;
age = ag;
}
public string makeJob() {
return "hired";
}
public int getAge() {
return age;
}
public void splitNames() {
}
}

We can represent this class in UML, as shown in Figure

The top part of the box contains the class name and package name (if any).
The second compartment lists the class’s variables, and the bottom compartment lists its methods. The symbols in front of the names indicate that member's visibility, where "+" means public, "-" means private, and "#" means protected. Static methods are shown underlined.

Abstract methods may be shown in italics or in an “{abstract}” label.

UML does not require that you show all of the attributes of a class, and it
is usual only to show the ones of interest to the discussion at hand.

Inheritance:

Now, we will look into inheritance and how to implement it in UML.

Let’s consider a version of Person that has public, protected, and private variables and methods, and an Emplo yee class derived from it.

public abstract class Person {
protected string name;
private int age;
//-----
public Person(string nm, int ag) {
name = nm;
age = ag;
}
public string makeJob() {
return "hired";
}
public int getAge() {
return age;
}
public void splitNames() {
}
public abstract string getJob(); //must override
}

We now derive the Employee class from it, and fill in some code for the getJob method.

public class Employee : Person {
public Employee(string nm, int ag):base(nm, ag){
}
public override string getJob() {
return "Worker";
}
}

You represent inheritance using a solid line and a hollow triangular arrow.
For the simple Employee class that is a subclass of Person, we represent this in UML, as shown in Figure

Note that the name of the Employee class is not in italics because it is now a concrete class and because it includes a concrete method for the formerly abstract getJob method.

OOPS Part II -- Pillars of OOPS -- Inheritance, Polymorphism, Encapsulation

2009-06-19T01:56:00.000-07:00

Part I --> OOPS Part I -- OOPS Part I -- Understanding the Object Oriented Programming

All object-based languages must contend with three core principals of object-oriented programming, often called the "pillars of object-oriented programming (OOP)":

• Encapsulation: How does this language hide an object’s internal implementation details and preserve data integrity?
• Inheritance: How does this language promote code reuse?
• Polymorphism: How does this language let you treat related objects in a similar way?

The Role of Encapsulation

The first pillar of OOP is called encapsulation. This trait boils down to the language’s ability to hide unnecessary implementation details from the object user.

For example, assume you are using a class named DatabaseReader, which has two primary methods: Open() and Close():

// This type encapsulates the details of opening and closing a database.
DatabaseReader dbReader = new DatabaseReader();
dbReader.Open(@"C:\MyCars.mdf");
// Do something with data file and close the file.
dbReader.Close();

The fictitious DatabaseReader class encapsulates the inner details of locating, loading, manipulating, and closing the data file. Object users love encapsulation, as this pillar of OOP keeps programming tasks simpler. There is no need to worry about the numerous lines of code that are working behind the scenes to carry out the work of the DatabaseReader class. All you do is create an instance and send the appropriate messages

Closely related to the notion of encapsulating programming logic is the idea of data hiding. Ideally, an object’s state data should be specified using the private (or possibly protected) keyword. In this way, the outside world must ask politely in order to change or obtain the underlying value. This is a good thing, as publicly declared data points can easily become corrupted (hopefully by accident rather than intent!). You will formally examine this aspect of encapsulation in just a bit.

The Role of Inheritance

The next pillar of OOP, inheritance, boils down to the language’s ability to allow you to build new class definitions based on existing class definitions.

In essence, inheritance allows you to extend the behavior of a base (or parent) class by inheriting core functionality into the derived subclass (also called a child class).

Figure below shows a simple example. You can read the diagram in Figure as "A Hexagon is-a Shape that is-an Object."

When you have classes related by this form of inheritance, you establish "is-a" relationships between types. The "is-a" relationship is termed classical inheritance.

Here, you can assume that Shape defines some number of members that are common to all
descendents. Given that the Hexagon class extends Shape, it inherits the core functionality defined by Shape and Object, as well as defines additional hexagon-related details of its own (whatever those may be).

There is another form of code reuse in the world of OOP: the containment/delegation model
(also known as the “has-a” relationship or aggregation). This form of reuse is not used to establish parent/child relationships. Rather, the “has-a” relationship allows one class to define a member variable of another class and expose its functionality (if required) to the object user indirectly.

For example, assume you are again modeling an automobile. You might want to express the
idea that a car “has-a” radio. It would be illogical to attempt to derive the Car class from a Radio, or vice versa (a Car “is-a” Radio? I think not!). Rather, you have two independent classes working together, where the Car class creates and exposes the Radio’s functionality:

class Radio
{
public void Power(bool turnOn)
{
Console.WriteLine("Radio on: {0}", turnOn);
}
}
class Car
{
// Car 'has-a' Radio
private Radio myRadio = new Radio();
public void TurnOnRadio(bool onOff)
{
// Delegate call to inner object.
myRadio.Power(onOff);
}
}
Notice that the object user has no clue that the Car class is making use of an inner Radio object.
static void Main(string[] args)
{
// Call is forwarded to Radio internally.
Car viper = new Car();
viper.TurnOnRadio(false);
}

Difference Between Inherating a class and instantiating a class

When you inherit a class, you get the superclass attributes and methods that you can use without instantiating a superclass object. You can only use those which are public or protected.
If you instantiate them, you make an object and upon that object you call methods defined in the object's class.

When you inherit a class, base class from which a class is derived does not have state, behaviour or identity where as if you create an instance of a class, the base class sets it's identity, state, behaviour.

When you create an instance of an object, you can access the method of the class by using dot operator (.) but if you inherit a class, you can not access base class method by using dot operator.

Use Inheritance when you are sure that you need to extend few methods of the base class or need to add some more methods to it otherwise just create the instance of the class.

The Role of Polymorphism

The final pillar of OOP is polymorphism. This trait captures a language’s ability to treat related objects in a similar manner. Specifically, this tenant of an object-oriented language allows a base class to define a set of members (formally termed the polymorphic interface) that are available to all descendents. A class’s polymorphic interface is constructed using any number of virtual or abstract members.

In a nutshell, a virtual member is a member in a base class that defines a default implementation that may be changed (or more formally speaking, overridden) by a derived class. In contrast, an abstract method is a member in a base class that does not provide a default implementation, but does provide a signature. When a class derives from a base class defining an abstract method, it must be overridden by a derived type. In either case, when derived types override the members defined by a base class, they are essentially redefining how they respond to the same request.

To preview polymorphism, let’s provide some details behind the shapes hierarchy shown in
Figure. Assume that the Shape class has defined a virtual method named Draw() that takes no parameters. Given the fact that every shape needs to render itself in a unique manner, subclasses (such as Hexagon and Circle) are free to override this method to their own liking.

Once a polymorphic interface has been designed, you can begin to make various assumptions
in your code. For example, given that Hexagon and Circle derive from a common parent (Shape), an array of Shape types could contain anything deriving from this base class. Furthermore, given that Shape defines a polymorphic interface to all derived types (the Draw() method in this example), we can assume each member in the array has this functionality. Consider the following Main() method, which instructs an array of Shape-derived types to render themselves using the Draw() method:

class Program
{
static void Main(string[] args)
{
Shape[] myShapes = new Shape[3];
myShapes[0] = new Hexagon();
myShapes[1] = new Circle();
myShapes[2] = new Hexagon();
foreach (Shape s in myShapes)
{
s.Draw();
}Console.ReadLine();
}
}

This wraps up our brisk overview of the pillars of OOP. Now that you have the theory in your mind, the remainder of this chapter explores further details of how encapsulation is handled under C#. The next chapter will tackle the details of inheritance and polymorphism.

OOPS Part I -- Understanding the Object Oriented Programming

2009-06-18T22:57:00.000-07:00

This chapter is a basic introduction to object-oriented programming. It introduces you to some of the basic concepts and terms you need to know as you get a handle on the specific details of how object-oriented programming works.

What Is Object-Oriented Programming?

The term object-oriented programming means many different things. But at its heart, object-oriented programming is a type of computer programming based on the premise that all programs are essentially computer-based simulations of real-world objects or abstract concepts.

For example: Flight-simulator programs attempt to mimic the behavior of real airplanes. Some do an amazingly good job; military and commercial pilots train on them.

Understanding Objects

Objects-both in the real world and in the world of programming-are entities that have certain basic characteristics. The following sections describe some of the more important of these characteristics: identity, type, state, and behavior.

Objects have identity

Every object in an object-oriented program has an identity. In other words, every occurrence of a particular type of object-called an instance-can be distinguished from every other occurrence of the same type of object, as well as from objects of other types.

Objects have type

Object-oriented programming lets you assign names to the different kind of objects in a program. Types are defined by classes. So when you create an object from a type, you're saying that the object is of the type specified by the class. For example, the following statement creates an object of type Invoice:

Invoice i = new Invoice();

In this case, the identity of this object (that is, its address in memory) is assigned to the variable i, which the compiler knows can hold references to objects of type Invoice.

Objects have state

The type of an object determines what attributes the object has. Thus, all objects of a particular type have the same attributes. However, they don't necessarily have the same values for those attributes.
The combination of the values for all the attributes of an object is called the object's state. Unlike its identity, an object's state can and usually does change over its lifetime.

Here are a few more interesting details about object state:

Some of the attributes of an object are publicly known, but others can be private. The private attributes may be vital to the internal operation of the object, but no one outside of the object knows they exist. They're like your private thoughts: They affect what you say and do, but nobody knows them but you.
The state of an object is represented by class variables, which are called fields. A public field is a field that's declared with the public keyword so the variable can be visible to the outside world.

Objects have behaviour

Another characteristic of objects is that they have behavior, which means they can do things. Like state, the specific behavior of an object depends on its type. But unlike state, the behavior isn't different for each instance of a type.

Another way to say that objects have behavior is to say they provide services that can be used by other objects. The behavior of an object is provided by its methods.

OOPS Part II -- Pillars of OOPS -- Inheritance, Polymorphism, Encapsulation

Interview Experience with PWC

2009-06-18T22:09:00.000-07:00

Recently I gave an interview with PWC.. Though not selected, I would like to share my experience with you all. Here are the list of questions asked in Round I:

01. Tell me about your education background, work profile.
02. Is dot net object oriented?
Here I said 'YES'..so next question

Lets start with OOPS
------OOPS------------
03. What is an abstract class?
04. What is an interface?
05. What is the difference between abstract class and an interface?
06. When to use what (abstract/interface)?
07. Give practical scenario regarding usage.
08. What is the relation between virtual and override keyword?
09. What is Polymorphism?
10. What is method overloading and method overriding?
11. What is singleton class?
12. When to use singleton class?
13. Any class in dot net framework that is an example of singleton class?
14. What is inheritance?
-------------------------

------SHAREPOINT-------------
You have worked on SharePoint also....YES
SharePoint coding or just Out-Of-Box? ... Coding

15. What is a web part?
16. Advantage of web part?
17. How to deploy a web part..step by step
18. What is the command line utility used in SharePoint?
19. How you can implement List Item listener?
20. Scenario: You need to check before inserting an item to list that whether the EmpID( field) is unique or not? How will you implement?
21. How will you deploy a feature?
-------------------------

-------Database-----------
22. What is an index?
23. How many types of index are there?
24. How many index I can have on a table? Any max limit?
25. What is difference between a primary key and unique key?
26. What are constraints?
27. Name any constraint?
28. Scenario: Table: EMPID, EMPDEPT, SALARY. You need to restrict that one can insert a row where salary is less than 5000. How will you implement that?
29. What is trigger and of how many types?
30. Have you worked on cursors?..I said no..that's why no further questions
---------------------------

--------DOT NET-----------
31. What are attributes in dot net?
32. Can we define user defined attributes?..IF yes then How?
33. How web service communicates between two non-compatible platforms?
34. Can web service preserve state? How?
35. What is singleton web service?
36. When we add a class file, what remains the default assess modifier?
37. Difference between protected internal, protected ?
38. What is MVC?
39. How will you relate MVC with 3-tier architecture?
--------------------------

-------Process Oriented----------
40. Can you name and explain any design pattern with example
41. Have you ever used any defect analysis?
42. What type of proceed flow you use?
43. Have you ever designed design document?
44. What are the main parts of a design document?
45. What tool you used in order to draw class diagrams?
46. Any idea regarding UML?

Structure of Sharepoint Site and Navigation

2009-06-14T22:10:00.000-07:00

SharePoint sites are always part of a site collection, which has a single parent or top - level site .

The top - level site can have any number of child sites, grandchildren, and so on, and each site will have one or more pages in a page library .

The site structure is therefore based on pages(the leaf nodes, which are viewable by end users) and sites (the containers, each of which has at least one default page to display).

How to get Data from Active Directory using C#

2009-06-11T20:59:00.000-07:00

Today, I am going to discuss how to fetch data from active directory and how to store it into a clas..

We can access LDAP or AD by using two class: DirectoryEntry and DirectorySearcher

Step 1:

Add reference to System.DirectoryServices amd import it in the code by entering using System.DirectoryServices;

Step 2:

We need the AD Location, AD Userid and AD Password in order to read data from it.

We store these values in web.config:
<appSettings>
<add key="GaadLocation" value="LDAP://XXXXX:XXX"/>
<add key="GaadUserName" value="XXXXXX"/>
<add key="GaadPassword" value="XXXXXX"/>
</appSettings>

Step 3:

In order to store the data fetched from AD, we created a class and defined some properties.

public class ADContact
{
public string UniqueId {get; set; }
public string LastName { get; set; }
public string DepartmentNumber { get; set; }
public string EmployeeType { get; set; }
public string TelephoneNumber { get; set; }
public string FirstName { get; set; }
public string UserStatus { get; set; }
public string Mail { get; set; }
public string Mobile { get; set; }
public string Title {get; set; }
}

Step 4: Create a method that will return a datatable so that we can iterate through the result.

public List GetADContacts(string SirName, string GivenName, string UniqueId)
{}

Step 5:

Within the method, create a SearchResultCollection object , a datatable, and list of AD properties to access:

SearchResultCollection results = null;
List GaadData = new List();

string ADLocation, ADUserId, ADUserPassword = string.Empty;
#region List of AD Properties
string[] properties = new string[]
{
"modifyTimestamp",
"uid",
"sn",
"departmentNumber",
"facsimileTelephoneNumber",
"givenName",
"mail"
};
#endregion

Step 6:
Declare a try-catch block and within try- write the following code:

try {

string strfilter = string.Empty;

//Get AD Settings from web.config
ADLocation = ConfigurationManager.AppSettings["ADLocation"];
ADUserId = ConfigurationManager.AppSettings["ADUserName"];
ADUserPassword = ConfigurationManager.AppSettings["ADPassword"];

//Create an instance of DirectoryEntry by passing the setting valies)
DirectoryEntry root = new DirectoryEntry(ADLocation, ADUserId, ADUserPassword, AuthenticationTypes.FastBind);

//Create the filter string : we need to search the Ad for people matching the search criteria. Here we are passing three parameters: SirName, GivenName, Uid. If any field is blank, we are putting * there. that is to get all values

strfilter = String.Format(
"(&(&(sn={0})(givenname={1})(uid={2})))",
String.IsNullOrEmpty(SirName) ? "*" : SirName + "*",
String.IsNullOrEmpty(GivenName) ? "*" : GivenName + "*",
String.IsNullOrEmpty(UniqueId) ? "*" : UniqueId + "*");

if (strfilter != "")
{
DirectorySearcher searcher = new DirectorySearcher(root, strfilter, properties);
searcher.Asynchronous = true;
searcher.SearchScope = SearchScope.Subtree;
results = searcher.FindAll();
}
foreach (SearchResult result in results)
{
ADContact contact = new ADContact();

if (result.Properties["uid"].Count > 0)
contact.UniqueId= Convert.ToString(result.Properties["uid"][0]);

if (result.Properties["title"].Count > 0)
contact.Title = Convert.ToString(result.Properties["title"][0]);

if (result.Properties["sn"].Count > 0)
contact.LastName = Convert.ToString(result.Properties["sn"][0]);

if (result.Properties["givenName"].Count > 0)
contact.FirstName = Convert.ToString(result.Properties["givenName"][0]);

if (result.Properties["facsimileTelephoneNumber"].Count > 0)
contact.TelephoneNumber = Convert.ToString(result.Properties["facsimileTelephoneNumber"][0]);

if (result.Properties["mobile"].Count > 0)
contact.Mobile = Convert.ToString(result.Properties["mobile"][0]);

if (result.Properties["mail"].Count > 0)
contact.Mail = Convert.ToString(result.Properties["mail"][0]);

ADData.Add(contact);
}
return ADData;
}
catch (Exception ex)
{
throw ex;
}

New Features of dot Net 3.5 Framework

2009-06-09T21:34:00.000-07:00

Dot net framework 3.5 is built on dot net 2.0 runtime library with addition of few dlls like: System.Core.dll, System.XML.LINQ.dll, System.AjaxExtension.dll etc..

Mainly enhancements are done with related to LINQ and Entitiy Model. Here are few enhancements listed:

1. Automatic Properties :

If you remember, prior to framework 3.5, we used to declare property within a class like this:

class Class1 {

privtae string _CustomerName;
public string CustomerName
{
get { return _CustomerName; }
set { _CustomerName = value; }
}
}

Now, we will see how to implement the same code in dot net 3.5:

class Class1 {
public string CustomerName {get; set;}
}

2. Object Initializers :

Another new feature coming with .NET 3.5, C# 3 and VB 9 is object initialization. Object Initializers allow you to pass in named values for each of the public properties that will then be used to initialize the object.

Suppose we have a class called School and few fields, we used to initialization the class like this:

School school1=new School();
school1.Name="ABC";
school1.Address="DEF";

Now the problem is that if we need to initialize different fields based on logic, we need to create different constructors based on our logic. Here comes the use of Object Initializers.

Object Initializers allow you to pass in any named public property to the constructor of the class. This is a great feature as it removes the need to create multiple overloaded constructors using different parameter lists to achieve the same goal.

So, from framework 3.5 onwards, we will use:

School school1=new School {
Name="ABC";
Address="DEF";
};

3. Collection Initializers :

Like Object Initializers, the new Collection Initializers allow you to create a collection and initialize it with a series of objects in a single statement. The following statement demonstrates how the syntax is very similar to that of the Object Initializers. Initializing a List is accomplished by passing the instances of the Customer objects wrapped inside of curly braces.

Getting this feature as part of framwork, we don not need to declare the collection first and then add items to it.

List SchoolList = new List
{
new School {ID = 101, SchoolName = "School1"},
new School {ID = 102, SchoolName = "School2"},
new School {ID = 103, SchoolName = "School3"}
};

4. Extension Method

Extension methods are a new feature that allows you to enhance an existing class by adding a new method to it without modifying the actual code for the class. This is especially useful when using LINQ because several extension methods are available in writing LINQ query expressions.

For more details on extension method, check "What is Enxtension Method "

Extension Methods are very useful when you cannot add a method to the class itself, as in the case of creating a Cube method on the int class. Just because you can use a tool, does not mean you should use a tool.

5. Anonymous Types

When you create an Anonymous Type you need to declare a variable to refer to the object. Since you do not know what type you will be getting (since it is a new and anonymous type), you can declare the variable with the var keyword. This technique is called using an Implicitly Typed Variable.

Chek more details on "All about Anonymous Types

Steps in Compliation in ASP.NET

2009-06-09T05:07:00.000-07:00

We all know the term compilation in Asp.Net. But do you know what is the order of compilation in an asp.net project. Do you know which folder in the application structure gets compiled first and which when get compiled last?

Here is the compilation life cycle of an Asp.Net project in the order they get compiled.

App_GlobalResources: First of all the global resources are compiled and the resource assembly is built. All the assembly's in the bin folder are linked to this assembly.

App_WebResources: Next the web resource folder will be compiled. This will create all the proxy types for the web services. The web reference created is then linked to the resource assembly (if it exists.).

Profile properties (defined in the Web.config file): If we have defined the profile properties in the web.config file than an assembly will be generated for the profile objects.

App_Code: Next all the files in the App_Code folder will be compiled. All code assemblies and the profile assembly are linked to the resources and Web references assemblies if any.

Global.asax: Next the Application object is compiled and then it is linked with all other previously generated assembly's.

Once the top-level items are compiled, the compilation of folder, pages and other items start as and when needed. Here is a list of how this process continues?

App_LocalResources: If the folder containing the requested item contains an App_LocalResources folder, the contents of the local resources folder are compiled and linked to the global resources assembly.

Individual Web pages (.aspx files),
User Controls (.ascx files),
HTTP handlers (.ashx files),

HTTP modules (.asmx files): Next these files are compiled.

Themes, master pages, other source files are compiled when referenced page is compiled.

What's the difference between encapsulation and abstraction?

2009-06-08T07:44:00.000-07:00

Encapsulation protects abstractions. Encapsulation is the bodyguard; abstraction is the VIP.

Encapsulation provides the explicit boundary between an object's abstract interface (its abstraction) and its internal implementation details. Encapsulation puts the implementation details "in a capsule." Encapsulation tells users which features are stable, permanent services of the object and which features are implementation details that are subject to change without notice.

Encapsulation helps the developers of an abstraction: it provides the freedom to implement the abstraction in any way consistent with the interface. (Encapsulation tells developers exactly what users can and cannot access.) Encapsulation also helps the users of an abstraction: it provides protection by preventing dependence on volatile implementation details.

Abstraction provides business value; encapsulation "protects" these abstractions. If a developer provides a good abstraction, users won't be tempted to peek at the object's internal mechanisms. Encapsulation is simply a safety feature that reminds users not to stray over the line inadvertently.

What is an abstraction ?

2009-06-08T07:43:00.000-07:00

An abstraction is a simplified view of an object in the user's own vocabulary.

In OO ,an abstraction is the simplest interface to an object that provides all the features and services the intended users expect.

An abstraction tells users everything they need to know about an object but nothing else. It is the well-defined, unambiguously specified interface. For example, on a vending machine, the abstraction is formed by the buttons and their meanings; users don't have to know about levers, internal counters, or other parts that are needed for the machine to operate. Furthermore the vending machine's price list implies a legally binding promise to users: if users put in the right amount of money, the machine promises to dispense the desired item.

The key to a good abstraction is deep knowledge of the problem domain. A good abstraction allows users to use an object in a relatively safe and predictable manner. It reduces the learning curve by providing a simple interface described in terms of the user's own vocabulary.

A good abstraction separates specification from implementation. It doesn't expose too much nor does it hide features that users need to know about. If an abstraction is good, users aren't tempted to peek at the object's implementation. The net result is simpler, more stable user code.

How to use RunWithElevatedPrivileges in Sharepoint

2009-06-07T10:03:00.000-07:00

The SPSecurity class provides a static method named RunWithElevatedPrivileges that enables code to execute as system code running under the identity of SHAREPOINT\system. This allows code to run in an escalated security context to perform actions as the system.

This method should be used with care and should not expose direct access to system resources, but rather should be used when you need to perform actions on behalf of the system. The method is simple. You can either create a delegate to a public void method or simply write code within an inline delegate.

The signature looks like the following:

SPSecurity.RunWithElevatedPrivileges(delegate()
{
// Code runs as the "SharePoint\system" user
});

Note that :
Code running with the escalated privilege should use a new SPSite object for code running as the system and use the SPContext.Current property to access the actual calling user’s identity.

To modify WSS content under the System credentials, you need to create a new SPSite site collection that generates a new security context for objects referenced from the site, as in the following example. You cannot switch the security context of the SPSite once it has been created, but must instead create a new SPSite reference to switch user contexts. The following code uses the system credentials to add a list item using the profile data of the current Web user:

SPSecurity.RunWithElevatedPrivileges(
delegate() {
using (SPSite site = new SPSite(web.Site.ID)) {
using (SPWeb web2 = site.OpenWeb()) {
SPList theList = web2.Lists["visitors"];
SPListItem record = theList.Items.Add();
record["User"] = SPContext.Current.Web.CurrentUser;
record.Update();
}
}
);

How to add a SPGroup to a Site Collection- Sharepoint

2009-06-07T10:01:00.001-07:00

Groups cannot directly be added to a site-they must be added to the site collection.
If you try to add a group to the site’s Groups collection, you get an exception stating, “You cannot add a group directly to the Groups collection. You can add a group to the SiteGroups collection.”

This situation occurs because the SPGroup is always created at the Site Collection level and assigned to the site. The following code is valid and adds the LitwareSecurityGroup to the site collection groups.

// Adds a new group to the site collection groups:
site.SiteGroups.Add("LitwareSecurityGroup", site.CurrentUser,site.CurrentUser, "A group to manage Litware Security");

However, this still does not associate the group with our site, nor would it be useful within the site without any permissions. To add the group to the site, create a new SPRoleAssignment by associating an SPRoleDefinition with the SPGroup, and then add that role assignment to the site, as in the following code sample:

SPGroup secGroup = site.SiteGroups["LitwareSecurityGroup"];
SPRoleAssignment roleAssignment = new SPRoleAssignment(secGroup);
SPRoleDefinition roleDefinition = site.RoleDefinitions["Full Control"];
roleAssignment.RoleDefinitionBindings.Add(roleDefinition);
site.RoleAssignments.Add(roleAssignment);

How to get list of SPGroups in Sharepoint Site Collection

2009-06-07T09:48:00.000-07:00

Sharepoint Gropus (or SPGroups) are never created in the context of the site-they are always created in the context of the site collection and assigned to a site.

We can get list of groups of a site by suing site.Groups

SPSite siteCollection = new SPSite("http://localhost/litware/sales/");
SPWeb site = siteCollection.OpenWeb();

foreach(SPGroup group in site.Groups){
Console.WriteLine(group.Name);
}

Using Extension Method

2009-05-28T22:23:00.000-07:00

Why Extension Method ?

Many time we need a requirement where we need to add a new method to a class. Addition of new method is very easy if we have the class code but what if we don't have the source code of that class? We just have the dll..

One option is to inherit the existing class and add the new method or modify any existing method. The problem with this option is that it may not be possible every time due to OO Principles.

Here comes the concept of Extension Method

How to Use Extension Method

Here is a step by step tutorial on how to use extension method.

Suppose the case is that, we need to have a method called 'Next' and 'Previous' that will give us the next and previous number of the given number.

We will do it by using Extension method.

Step 1: Create a new Console application:
Step 2: Add a new class Item and name it 'Ext.cs'.
Step 3: Renamen the namespace of that class to System.
Step 4: Add the followign code:

public static class Ext
{
public static int Next(this int A)
{
return A + 1;
}
public static int Previous(this int A)
{
return A - 1;
}

}

The class will look like this:

Few things to explain:

1. Namespace has been renamed to 'System' since almost all C# source files have a using System; declaration, this extension method is effectively going to be available globally

2. An extension method must be static and public, must be declared inside a static class, and must have the keyword this before the first parameter type, which is the type that the method extends. Extension methods are public because they can be (and normally are) called from outside the class where they are declared.

Step 5: How to use an Extension Method:

We have created a public , static method using namespace System. Now the question is how to use it.
In step 1 , we have created a console application, so in the Main method of Program.cs, write this:

int a=10;
Console.WriteLine("Number after {0} is {1}", a, a.Next());
Console.WriteLine("Number after {0} is {1}", a, a.Previous());
Console.ReadLine();

You will notice here, as soon you type 'a' and press ., static mehtods declared in the Ext.cs will appears in intellisence and with a new symbol that marks it as extension.

Step 6: Build the application and press F5:

The output window will show the desired result:

Summary

Although this is not a big revolution, one advantage could be Microsoft IntelliSense support, which could show all extension methods accessible to a given identifier. However, the result type of the extension method might be the extended type itself. In this case, we can extend a type with many methods, all working on the same data. LINQ very frequently uses extension methods in this way.

The most common use of extension methods is to define them in static classes in specific namespaces, importing them into the calling code by specifying one or more using directives in the module.

What is difference between dataset and datareader ?

2009-05-27T03:42:00.000-07:00

Following are some major differences between dataset and datareader :-

√ DataReader provides forward-only and read-only access to data, while the
DataSet object can hold more than one table (in other words more than one
rowset) from the same data source as well as the relationships between them.

√ Dataset is a disconnected architecture while datareader is connected
architecture.

√ Dataset can persist contents while datareader can not persist contents, they
are forward only.

Overview of ADO.NET architecture

2009-05-27T03:39:00.000-07:00

The most important section in ADO.NET architecture is “Data Provider”. Data Provider
provides access to datasource (SQL SERVER, ACCESS, ORACLE).In short it provides
object to achieve functionalities like opening and closing connection, retrieve data and update data. In the below figure you can see the four main sections of a data provider :-

Connection.
Command object (This is the responsible object to use stored procedures)
Data Adapter (This object acts as a bridge between datastore and dataset).
Data Adapter (This object acts as a bridge between datastore and dataset).

Dataset object represents disconnected and cached data. If you see the diagram it is not in direct connection with the data store (SQL SERVER, ORACLE etc) rather it talks
with Data adapter, who is responsible for filling the dataset. Dataset can have one or more Datatable and relations.

Introduction to ASP.NET MVC

2009-05-27T03:13:00.000-07:00

In this session we’ll take a look at WebForms and how its request pipeline is structured, and then introduce the MVC pattern, and how it is implemented into the ASP.NET MVC framework.

We’ll then discuss how WebForms and MVC differ from each other.
Then we’ll look into the default conventions and project structure of an MVC application.

Web Forms

In WebForms today you start out with an ASPX page.
Within the page you can have any number of user controls, custom controls, and server controls.
In addition, a page can have a master page, which can in turn have any number of controls itself.
When you introduce model data, due to the level of abstraction needed by WebForms, any of the components used can access to data.
The page, the master page, and any of their individual controls contain logic that both retreives model data and contains it view representation.

This is model that has made WebForms so successful and useful for web developers.

WebForms uses a pattern called page controller.
When a request comes into ASP.NET, the request is served by a specific ASPX page. Hence, the page itself serves as the controller, or face of the object that handles the request.

What is MVC ?

MVC or Model-View-Controller is an architectural pattern that separates model access from presentation logic.
It adds specific responsibility to individual portions of the application.
The model represents your business objects, that both houses your data, and contains business logic.
The controller is responsible for interacting with the model, and then passing that data down to the view.
The view’s sole responsibility is acting as a representation of the model data it is given by the controller.

ASP.NET MVC
So now let’s see how a typical ASP.NET MVC application contrasts to the way a WebForms application looked.

Notice that we still have our ASPX page, which in turn can leverage user controls, custom controls, and server controls. Nothing difference there.
The page can be associated with a master page, which can in turn have its own set of user controls, custom controls, and server controls. So far this is still the same as WebForms.
We re-introduce the model data, which is where the contrast between WebForms and MVC gets clearer.
With WebForms, any of the controls, or page, or master page was directly interacting with the model. We introduce the controller into the picture, which will now be the orchestrator between the model and the views.

Here, instead of the pages and controls directly accessing the model, the controller is strictly doing that. Once it gets the model data it is responsible for passing the data to the page, or view.

The main tenets of ASP.NET MVC are…
Alternative
ASP.NET MVC builds on top of ASP.NET, it doesn’t replace it. It is simply meant to serve as an alternative approach to developing web applications using ASP.NET.

Testable
While WebForms can be tested, it isn’t the most trivial task. ASP.NET MVC was built with testing in minding, so practicing TDD, or just simply writing unit tests, is a simple task with MVC.

Extensible
MVC follows the convention over configuration principle. At the same time, it isn’t meant to constrain developers by its conventions. MVC is built on an extensible framework that virtually every component can be easily replaced with your own logic.

Routable
ASP.NET MVC uses ASP.NET Routing to associate URL patterns with controller actions. This means that your MVC applications will naturally be search-engine optimized, since every controller action that corresponds to an HTTP GET can get be easily discovered.

Now’s let’s briefly discuss the differences between WebForms and ASP.NET MVC.
While MVC is built on top of ASP.NET, it doesn’t have…
Postbacks
View state or control state
Server-side form
Page/control lifecycle
The page/control lifecycle is still present if you’re using WebForms as your view engine, but even then, you most likely won’t be using it.

Example of ASP.NET MVC

Here we see an example of the default project structure of an ASP.NET MVC application.

Because ASP.NET MVC comes packaged with a set of default conventions, it’s important to understand those conventions, and even better how you can override them if you want.
Here we see the controllers, placed in the Controllers folder. You actually don’t have to place your controllers in this folder, but it is created for you by default, and is considered a pretty standard place for them.
The ASP.NET MVC project templates places a folder called Models in your project that can be used to contain your model classes. This is only one option for model placement, and shouldn’t be seen as guidance that this is the “right way” to do it. Your model classes are in no way coupled to their placement, so you can put them in a different folder, or even in another project if you want.

Views in an ASP.NET MVC application are by default located in the Views folder. Within the Views folder, there are two options to place your views:
Either underneath the Shared folder, which are views that are meant to be used by multiple controllers. These are typically user controls or master pages.
Or underneath a folder named after the Controller they are associated to. These are views that are specific to controllers.

This is the default convention, but it can be changed if you want. We’ll go into customizing this in the next session.

The route definitions that map URL patterns to your controllers are declared within your application’s Global.asax file. This way they can be created upon Application Start.

LINQ Architecture and Components

2009-05-27T03:08:00.000-07:00

LINQ is currently integrated directly into the native syntax for both C# 3.0 and VB 9.0 – which are included with Visual Studio 2008

Other languages may also support Language Integrated Query syntax in the future.
There are many flavors of LINQ which we describe by the type of data it operates over. As you can see here, LINQ may operate over Objects, SQL, Datasets, and XML.

These are the four flavors of LINQ that we are shipping with the .NET Framework 3.5

LINQ to Objects
SQL-like queries for any .NET collection (or anything that implements Ienumerable)
The LINQ to Objects API supports queries over any .NET collection, such as arrays and generic lists.

This API is defined in the System.Linq namespaces inside System.Core.dll
LINQ to objects is enabled by including the System.Linq namespace.
Manipulating collections of objects, which can be related to each other to form a hierary or a graph. From a certain point of view, LINQ to Objects is the default implementation used by a LINQ query.

LINQ to SQL
Query enabled data access framework

LINQ to XML
Query enabled, smaller, faster XML DOM

The important thing to remember is that the querying syntax used in LINQ is consistent regardless of the type of data you’re working with.

FAQ

Will there be support for Oracle with LINQ to SQL?

There is no provider model for DLINQ. In order for a third party provider to support DLINQ, they would need to produce an entire API that mirrors DLINQ that covers everything from query generation to examining attributes on classes to providing a designer to interact with the database schema. Because there's a lower bar for enhancing a provider to support the Entity Framework (primarily just query generation), Oracle is only planning to support the Entity Framework.

Introducing LINQ

2009-05-27T03:06:00.001-07:00

Orcas significantly improves the way developers handle data.
Traditionally developers have manipulated data differently depending on where the data resides and how the user connects to it.

With the introduction of Language Integrated Query developers can now deal with data using a consistent programmatic approach and perform data access with new data design surfaces.

LINQ aimes to reduce the complexity for developers and help boost their productivity through a set of extensions to the C# and Visual Basic programming languages as well as the Microsoft .NET Framework, which provides integrated querying for objects, databases, and XML data.

Using LINQ, developers will be able to write queries natively in C# or Visual Basic without having to use specialized languages, such as Structured Query Language (SQL) and Xpath.

With Visual Studio “Orcas”, you can work with data in the way that you want. You can create entire collections of objects from a database backend if you like. You can interact with data as rows or columns – whatever makes sense to your application.
Language Integrated Query or “LINQ” will dramatically change the way we work with and program against data. By creating a common querying language in LINQ, we’ve freed you, the developer to focus on things that matter most to you. LINQ will provide you the ease of use you’ve come to expect with Visual Studio offering both IntelliSense and Autocompletion right in the IDE.

Language Integrated Query provides native querying syntax in C# and VB.Net. This frees the developer from having to master independent data programmability technologies (e.g. Xpath, Xquery, T/SQL) and instead offers the developer a consistent way to query data.

The best part is that the LINQ code you write is consistent whether your data store is a SQL Server, contained in a ADO.NET DataSet, an XML document, an EDM you create or even objects you create in memory.

With Orcas, we have taken a more general approach and are adding general purpose query facilities to the .NET Framework that apply to all sources of information, not just relational or XML data.

This facility is called .NET Language Integrated Query (LINQ).
With Orcas and ADO.NET 3.5, LINQ is an inherent part of the C# and VB.Net languages offering both IntelliSense and Autocompletion.

LINQ provides developers with a consistent query language which they in turn may use on various types of data. Be it Objects, XML, Datasets, SQL Server (or other databases with ADO.NET providers) and Entities. Any data that may be placed into a .NET collection of type IEnumerable can be queried by LINQ.

If you’ve written T/SQL in the past then LINQ will offer you familiar constructs for projections, restrictions, sorting and grouping such as Select, Where, GroupBy, and OrderBy.

You can also adapt the query operators to your liking by using extension methods which can override their default behavior.

.Net Framework and VS Roadmap

2009-05-27T03:01:00.000-07:00

.NET Framework 3.0

First, if we travel back in time to November of 2006, Microsoft released the .NET Framework 3.0.

.NET Framework 3.0 was installed by default with Windows Vista, however, it was also available as a installable component for Windows XP SP2 and Windows Server 2003.

Visual Studio Extensions

When we released the .NET Framework 3.0, we also released a couple of extensions for Visual Studio.

The first extensions, called the Visual Studio 2005 Extensions for Windows Workflow Foundation, provided templates and design-time support for creating workflows within Visual Studio. It is worth noting that this was a complete and fully supported set of extensions.

The second extensions were the Visual Studio Extensions for the Windows Communication Foundation and Windows Presentation Foundation November CTP.

These extensions simply provided project and item templates for building WCF services and WPF applications.

ASP.NET Ajax

Shortly after the release of the .NET Framework 3.0, Microsoft also released the ASP.NET AJAX 1.0 extensions.
These extensions are designed to enable web developers to build dynamic applications with ASP.NET 2.0.

Visual Studio 2008 and .NET Framework 3.5

It’s important to understand these out-of-band releases as we look at Visual Studio 2008 and the .NET Framework 3.5. Visual Studio 2008 and the .NET Framework 3.5 include enhanced versions of the technologies that have been released out-of-band, such as AJAX and design time support for WF, WPF, and WCF applications.
At this point in time the beta 2 release of Visual Studio 2008 and the .NET Framework 3.5 are available.

It is also worth mentioning that there is a go-live license available with the .NET Framework 3.5. So you can deploy applications into production using this license. To be clear, there is a difference between licensed and supported. The .NET Framework 3.5 will not be supported until it is officially released.
Visual Studio 2008 and the .NET Framework 3.5 are scheduled to be released at the end of 2007 and they will launch with Windows Server 2008 and SQL Server 2008 on Februrary 27th.

Beyond the release of Visual Studio 2008 and the .NET Framework 3.5
After the release of these technologies, there will be an update to the .NET Framework that will be released with SQL Server 2008. This update will add support for the ADO.NET Entity Framework, which will enable flexible data access to a variety of data stores.

Finally, next year we plan to release a major update to Visual Studio Team System and Team Foundation Server codenamed “Rosario”.

What is .Net Framework 3.5 ?

2009-05-27T02:58:00.000-07:00

Do you or any of your customers suffer from…version confusion? I’m referring to .NET Framework versioning confusion.I know that I have frequently been asked by customers questions like:

So what is the .NET Framework 3.5?

There is a fair amount of confusion about the different versions of the .NET Framework. It’s important that we spend a few minutes to clarify any confusion that might exist in this room.

Let’s walk through this diagram:

.NET Framework 3.5

The .NET Framework 3.5 is an incremental release of the .NET Framework. It provides several new enhancements including LINQ, ASP.NET 3.5, the CLR Add-in framework and several others.

The .NET Framework 3.5 builds upon the previous versions of the framework, namely the .NET Framework 2.0 and 3.0. More specifically, you can think of it as though the .NET Framework 3.5 has a dependency on the .NET Framework 3.0 with SP1 and 2.0 with SP1.

.NET Framework 3.0

The .NET Framework 3.0, which was formerly known as WinFx, introduced several key new technologies including:

Windows Presentation Foundation – provides the ability to build rich, interactive client applications
Windows Communication Foundation – provides a common programming model for building services and connecting applications
Windows Workflow Foundation – provides the ability to define declarative, long-running workflows
Windows CardSpace – provides a safer and more secure alternative to username and password authentication within web sites and rich client applications

.NET Framework 2.0

Finally, the .NET Framework 2.0, which was initially released in 2005 provides the common language runtime and base class libraries that are used by the .NET Framework 3.0 and 3.5 components.

So how will developers get the .NET Framework 3.5?

The .NET Framework 3.5 will be available as an optional update through Windows Update, as a bootstrapper installation, and as a full package.

With all of these packages, your machine will be examined during the installation and the .NET Framework 2.0 with SP1, 3.0 with SP1, and the new 3.5 assemblies will be installed.

The setup for the .NET Framework 3.5 will only install the necessary bits. So if the .NET Framework 2.0 or 3.0 is already installed, then only the service packs and the 3.5 bits will be added.

Creating a WebService in ASP.NET , C#

2009-05-23T01:22:00.001-07:00

This post deals with the basic theory of the web service.

What is a Web Service?

Web Services can convert your applications into Web-applications.

•Web services are application components
•Web services communicate using open protocols
•Web services are self-contained and self-describing
•Web services can be discovered using UDDI
•Web services can be used by other applications
•XML is the basis for Web services

How Does it Work?
The basic Web services platform is XML + HTTP.

XML provides a language which can be used between different platforms and programming languages and still express complex messages and functions.

The HTTP protocol is the most used Internet protocol.

Creating and consuming web service is done in 3 broader steps:

A. Create a Web Service class and method
B. Add Web-Reference to the project
C. Consume the created web service in the ASP.NET code.

A. Create a Web Service class and method

Step 1: Creating Web Project

Open Visual Studio and create a new Web Site. Name it whatever you want. Here, it is named WSDemo.

Step 2: Adding New Item

A new web project will open with a default.aspx and aspx.cs file. Right Click on project and click 'Add New Item'.

This will open the 'Add New Item' Dialoge box. Select template 'Web Service' and name it WS.asmx.

You will notice that two new files has been added: WS.aspx and WS.cs under App_Code

Adding a web service file will add WS.asmx file. If you open the WS.cs file, you will notice lot of pre-coded lines there.

A class must inherit System.Web.Services.WebService in order to behave like a web service.

Also, a HelloWorld method is added by default. The normal method can be converted to a webmethod by adding the following line on top of that method:

[WebMethod]

Step 3: Adding Custom Code:

My objective is to write a webmethod that will accept two parameters and return the sum of those two numbers. So, I removed the HelloWorld method and added my own Add Method.

[WebMethod]
public int Add(inta, int b)
{
return a+b;
}

At this point, your webservice clas is ready.

In order to test whether web service is created successfully or not, build the website and right click the WS.asmx and click 'View in Browser'. This action will open the webservice in browser and display the webmethod as a link.

Clicking on the WebMethod will ask for the input parameters that we defined (a, b) and submitting the form will show the result in a xml file.

B. Add Web-Reference to the project

Now when the web service has been developed, we need to add the web reference to the project. In order to do so , follow these steps:

Step 1: Click Add WebReference

Right click the project and select 'Add Web Reference'

Step 2: Browse for the web service

This action will open the 'Add Web Reference' wizard. It will ask use rto select the location where the web service is their. Since for our purpose, web service is in the solution, click 'Web Service in the solution'

Step 3: Selecting the web service:

Select the web service 'WS'. This will check the webservice 'WS' and list out all the WebMethods. During this process, you will see a progress bar liek this:

Step 4: Defining namespace and adding the reference:

After the internal process, wizard will list out the webmethods found in that webservice. If you chek the image below, there are few things to notice:

i. URL : That is the url fo the webservice. You can access the webservice WS directly from browser also.

ii. Webmethod Name: 'Add' is the name of our web method.

iii. Web Reference Name: This will be the namespace of the webservice.You can change it to your desired name. For demo purpose, I have kept it the default 'localhost'.

Clicking 'Add Reference' will add the web reference to the project and add the following files:

Here 'localhost' is the namespace. There are discovery file and WSDL file. I will explain the file types in next post..

This means web-reference has been added.

C. Consume the created web service in the ASP.NET code.

Now after creating and adding reference, we need to consume the web service.

Step 1: Modify the ASP.NET page:

In the default.aspx, add the following code:

<form id="form1" runat="server">
<div>
Enter value 1:<asp:TextBox ID="A" runat="server"/>
Enter value 2:<asp:TextBox ID="B" runat="server"/>
<asp:Button id="btnSubmit" runat="server" Text="Add" onclick="btnSubmit_Click" />
<hr />
Sub Result: <asp:Label id="lbl" runat="server"/>
</div>
</form>

Now we need to access the webservice from code. That we do by referring the namespace 'localhost'.

In the btnSubit Click event , add the following code:

localhost.WebService AddService=new localhost.WebService();
lbl.Text=AddService.Add(Int32.Parse(A.Text),Int32.Parse(B.Text)).ToString();

Finally, build the website and run the application, default.aspx will open .Enter two values and click 'Add'.
The result will be shown in the label.

Please feel free to contact me if you have any query..

Difference between .Dwp and .Webpart

2009-05-21T00:05:00.000-07:00

In the development of webpart, we have encountered two types of files.

1. .Dwp and 2. .Webpart.

As you may know, they are both files used for describing where the code is for a web part.

The difference is .dwp was the file extension used in version 2 of SharePoint and .webpart is a new extension used in version 3.

Inside the files, the schemas are different and it is indicated as such by the version number on the xmlns attribute.

The main difference is that all properties passed to the web part are specified with a property element and a name attribute in version 3. Version 2 uses different element names for everything.

Various properties of PeopleEditor:

2009-05-20T22:43:00.000-07:00

Various properties of PeopleEditor:

The PeopleEditor control has a number of properties that allow you to configure it. In the next section, we will discuss the properties that we think are most important.

The PlaceButtonsUnderEntityEditor property decides the location of the Names and Browse buttons of the people picker. If you set it to true, the buttons are placed at the bottom right corner of the account name text box, otherwise to the right of it.

The AllowEmpty property lets you define if the user is required to fill in a value in the people picker.

The SelectionSet property allows you to define the set of users and groups the people picker can choose from. This set can consist of users, Active Directory distribution lists, Active Directory security groups, and SharePoint groups.
The MultiSelect property lets you define if a user is allowed to specify multiple user accounts. The next code fragment shows how to add a people picker to a web part and how to configure it:

objEditor = new PeopleEditor();
objEditor.AutoPostBack = true;
objEditor.PlaceButtonsUnderEntityEditor = true;
objEditor.ID = "pplEditor";
objEditor.AllowEmpty = false;
objEditor.SelectionSet = "User,SecGroup,SPGroup";
objEditor.MultiSelect = false;
Controls.Add(objEditor);
You can retrieve the values selected in the people picker by looping through the ResolvedEntities collection of the PeopleEditor object.

How to get all the values of PeopleEditor in Sharepoint

2009-05-20T21:24:00.000-07:00

If we need to acess oll the values in the PeopleEditor control, we can iterate through the entities present in PeopleEditor:

Suppose we have a PeopleEditor control PE1 so the code will be :

ArrayList entities = PE1.ResolvedEntities;
foreach (object entity in entities)
{
PickerEntity pickerEntity = (PickerEntity)entity;
string accountName = pickerEntity.Key;
string displayName = pickerEntity.DisplayText;
// pickerEntity.EntityDate[] has other values like first name, last name, etc you might be interested in.
}

How to check if PeopleEditor is blank ?

2009-05-20T21:18:00.000-07:00

Sometimes, we need to check whether Sharepoint PeopleEditor is blank or not. We can do that very easily by accessing Length property of that control.

Suppose we have a PeopleEditor control with Id PE1 then check for the lenght like this:

Int32 intLength = PE1.CommaSeparatedAccounts.Length;

Then put your own business logic as :

if (intLength == 0)
{.... }

How to set current user in the PeopleEditor via Code

2009-05-20T21:12:00.000-07:00

The following code sample will set the currently logged on user to a PeopleEditor:

using (SPWeb web = SPContext.Current.Web)
{
SPUser user = web.CurrentUser;
PickerEntity entity = new PickerEntity();
entity.Key = user.LoginName.ToString();
System.Collections.ArrayList entityArrayList = new System.Collections.ArrayList();
entityArrayList.Add(entity);
PeopleEditorControl.UpdateEntities(entityArrayList);
}

How to check whether a List is a Document Library?

2009-05-20T02:03:00.000-07:00

Many times, we face a situation where we iterate through list collection. Now if we need to check whether a list is a SPDocumentLibrary or not, we can check it in very simple manner:

Suppose we need to display list of document libraries present in a site in a dropdown control named 'lstTargetLibrary', we will iterate through list collection and check for List type:

SPWeb site = SPContext.Current.Web;
foreach (SPList list in site.Lists) {
if (list is SPDocumentLibrary && !list.Hidden) {
SPDocumentLibrary docLib = (SPDocumentLibrary)list;

lstTargetLibrary.Items.Add(
new ListItem(docLib.Title, docLib.ID.ToString()));
}
}

How to Upload a File to a SharePoint Site from a Local Folder

2009-05-20T01:34:00.000-07:00

This code sample will show how to upload a file from your local pc to Sharepoint site using object mode:

1. Create a project and import namespaces :

using System.IO;
using Microsoft.SharePoint;

2. The UploadFile funtion code:

public void UploadFile(string srcUrl, string destUrl)
{
if (! File.Exists(srcUrl))
{
throw new ArgumentException(String.Format("{0} does not exist",
srcUrl), "srcUrl");
}

SPWeb site = new SPSite(destUrl).OpenWeb();

FileStream fStream = File.OpenRead(srcUrl);
byte[] contents = new byte[fStream.Length];
fStream.Read(contents, 0, (int)fStream.Length);
fStream.Close();

EnsureParentFolder(site, destUrl);
site.Files.Add(destUrl, contents);
}

The UploadFile method accepts two parameters. The srcUrl parameter specifies the path of the source location in the file system of the local computer, and the destUrl parameter specifies the absolute URL of the destination. A System.IO.FileStream object is used to read the source file into a byte array for use with the Add method of the SPFileCollection class.

To upload a file from a local folder on the same server that is running Windows SharePoint Services, you can use a System.IO.FileStream object instead. In this case, add a using directive for the System.IO namespace, in addition to directives for System and Microsoft.SharePoint. The following example uses the Click event handler to call an UploadFile method, which in turn calls the previously described EnsureParentFolder method.

How to delete a List from Sharepoint ?

2009-05-20T01:33:00.001-07:00

This small code snippets will demonstrate how to delete a SPList from a sharepoint site.

To delete a list, you must specify the GUID of the list as the parameter for the Delete method. Use the ID property of the SPList class to find the GUID.

SPWeb mySite = SPContext.Current.Web;
SPListCollection lists = mySite.Lists;

SPList list = lists[ListName];
System.Guid listGuid = list.ID;

lists.Delete(listGuid);

Difference between Update and SystemUpdate in Sharepoint

2009-05-19T05:20:00.000-07:00

We all know that whenever we add a list item or do some modification, we update the list. Here we have two options:

1. List.Update() and 2. List.SystemUpdate()

The main difference betwwen two is that,

List.Update() creates automatically new version of list item as Update method is called.

List.SystemUpdate() avoids SharePoint 2007 to change modified date and modifier fields. Argument false tells that no new versions are expected.

SystemUpdate takes an boolean argument that set whether new version need to be created or not.

Example using SystemUpdate() :

SPList list = web.Lists["myList"];
SPListItem item = list.Items[0];
item["myField"] = "my value";

item.SystemUpdate(false);
list.Update();

Microsoft Office Sharepoint Authentication Explained

2009-05-19T02:01:00.000-07:00

In order for people to use a MOSS web application, the web application must validate the person’s identity. This process is known as authentication. MOSS is not a directory service and the actual authentication process is handled by IIS, not MOSS.

However, MOSS is responsible for authorization to MOSS sites and content after a user successfully authenticates. Authentication happens like this: A user points their browser at a MOSS site and IIS performs the user validation using the authentication method that is configured for the environment.

If the user authentication is successful, then MOSS renders the web pages based on the access level of the user. If authentication fails, the user is denied access to the MOSS site. Authentication methods determine which type of identity directory can be used and how users are authenticated by IIS. MOSS supports three methods of authentication: Windows, ASP.NET Forms, and Web Single Sign-On.

Windows Authentication is the most common authentication type used in MOSS intranet deployments because it uses Active Directory to validate users. When Windows Authentication is configured, IIS uses the Windows authentication protocol that is configured in IIS. NTLM, Kerberos, certificates, basic, and digest protocols are supported. When Windows authentication is configured, the security policies which are applied to the user accounts are configured within Active Directory. For example, account expiration policies, password complexity policies, and password history policies are all defined in Active Directory and not in MOSS. When a user attempts to authenticate to a MOSS web application using Windows authentication, IIS validates the user against NTFS and Active Directory, and once the validation occurs the user is authenticated and the access levels of that user are then applied by MOSS.

Anonymous access is considered to be a Windows authentication method because it associates unknown users with an anonymous user account (IUSR_MACHINENAME). Anonymous access is commonly used in internet Web sites and in situations where web site users will not have their own user accounts. Since exposing content to unknown users is risky, this configuration is disabled by default. In order to configure anonymous access to a MOSS web application, anonymous access must be enabled in IIS, enabled in the MOSS web application, and the anonymous user account must be provisioned throughout the MOSS Web application. Even when anonymous access is configured, there are still several limitations compared to a Windows user. By default, anonymous users are only allowed to read, and they are unable to edit, update, or delete content. Additionally, anonymous users are not able to utilize personalization features such as Microsoft Office integration, check-in/check-out and email alerts. The ASP.NET Forms authentication method is commonly used in situations where a custom authentication provider is required. In other words, where a custom LDAP, SQL Server, or other type of identity repository will be storing user account information. This is common in extranet environments, such as partner collaboration sites, where it is not practical to create Active Directory user accounts for users or a different type of directory is required.

The Web Single Sign-On authentication method is used in environments that have federated identity systems or single sign-on systems configured. In this type of environment, an independent identity management system integrates user identities across heterogeneous directories and provides the user validation for IIS. Some examples of identity management systems with single sign-on capability include Microsoft Identity Information Server with Active Directory Federation Services, Oracle Identity Management with Single Sign-On and Web Access Control, Sun Microsystems Java System Identity Manager, and Netegrity SiteMinder.

Large enterprises often implement federated identity models to ease the administration of user provisioning and de-provisioning for systems that span across companies. Single Sign-On systems are used to consolidate user accounts across heterogeneous systems, allowing the end user to authenticate to systems with one set of credentials, rather than to use a different set of credentials for each unique system. In MOSS, it is possible to configure web applications to use a combination of authentication methods. This provides a great deal of flexibility because it makes it possible to serve a web application to different user bases which have different identity requirements. For example, an organization may have a Project Collaboration Web site that is used by employees and partners.

For security and compliance reasons, it is necessary to store employee user accounts in Active Directory and partner user accounts in a SQL Server database. In this case, MOSS can be configured to use Windows authentication and ASP.NET Forms authentication. This is achieved by defining various zones and associated authentication methods to the zones. In the example above, an intranet zone would be configured with Windows authentication and an extranet zone would be configured with ASP.NET Forms authentication.

MOSS Object Model : Sharepoint

2009-05-19T02:00:00.000-07:00

Detailed MOSS Object Model

How to cretae a new SPlist instance using the WSS object model

2009-05-18T21:11:00.000-07:00

The following code provides the code to create a list instance. Before creating the list, the code checks to make sure a list of the same title doesn’t already exist. You will notice that the code enumerates through the lists within the current site, checking each list to see if there is a matching title. If a list with a matching title does not exist, the code in this application then creates a new instance of the Announcements list type and adds a link to the Quick Launch menu for easy access.

using System;
using Microsoft.SharePoint;

class Program {
static void Main() {
using (SPSite site = new SPSite("http://localhost")) {
using (SPWeb web = site.OpenWeb()) {
string listName = "Litware News";
SPList list = null;
foreach (SPList currentList in web.Lists) {
if (currentList.Title.Equals(listName,
StringComparison.InvariantCultureIgnoreCase)) {
list = currentList;
break;
}
}

if (list == null) {
Guid listID = web.Lists.Add(listName,
"List for big news items",
SPListTemplateType.Announcements);
list = web.Lists[listID];
list.OnQuickLaunch = true;
list.Update();
}
}
}
}
}

The code shows how to create a SPLit of announcements. We can create any List type:

Document library
Used for collaborating on documents with support for versioning, check-in and check-out, and workflow. Includes support for deep integration with Microsoft Office.

Form library
Used to store XML documents and forms for use with Microsoft Office InfoPath.

Wiki page library
Used for collaborative Web pages based on wiki pages, which are dynamically generated and collaboratively edited Web pages.

Picture library
A specialized document library enhanced for use with pictures. Includes support for slide shows, thumbnails, and simple editing through Microsoft Office Picture Manager.

Announcements
Used for simple sharing of timely news with support for expiration.

Contacts
A list for tracking people and contact information, with support for integration into Microsoft Office Outlook and other WSS-compatible contacts applications.

Discussions
A simple list for threaded discussions with support for approval and managing discussion threads.

Links
A list for managing hyperlinks.

Calendar
A list for tracking upcoming events and deadlines. Includes support for integration and synchronization with Office Outlook.

Tasks
A list of activity-based items that can integrate with workflow.

Project tasks
An enhanced tasks list with support for Gannt chart rendering and integration with Microsoft Office Project.

Issue tracking
A list for tracking issues and resolution, with support for prioritization.

Custom list
An empty list definition for extending with custom columns, or created using Microsoft Office Excel spreadsheets.

what is Windows Workflow Foundation ?

2009-05-18T02:31:00.000-07:00

The workflow functionality in Windows SharePoint Services 3.0 is built on the Windows Workflow Foundation (WF), a Microsoft Windows platform component that provides a programming infrastructure and tools for development and execution of workflow-based applications. WF simplifies the process of asynchronous programming to create stateful, long-running, and persistent workflow applications. The WF run-time engine manages workflow execution and allows workflows to remain active for long periods of time and to survive restarting the computer. Run-time services offer functionality such as transactions and persistence to manage errors gracefully and correctly.

The WF run-time engine provides the services that every workflow application needs, such as sequencing, state management, tracking capabilities, and transaction support. The WF run-time engine serves as a state machine responsible for loading and unloading workflows, as well as managing the current state of any workflows that are running. WF allows any application process or service container to run workflows by hosting WF — that is, loading WF within its process.

Windows SharePoint Services hosts the WF run-time engine. In place of the pluggable services that are included with WF, Windows SharePoint Services provides custom implementations of the following services for the engine: transaction, persistence, notifications, roles, tracking, and messaging. Developers can then create workflow solutions that run within Windows SharePoint Services.

Figure 1 shows the workflow architecture in Windows SharePoint Services. Windows SharePoint Services hosts the WF run-time engine within its process, and provides custom implementations of the necessary services. The functionality of the WF run-time engine, as well as the hosting functionality Windows SharePoint Services provides, is exposed through the Windows SharePoint Services object model.

Figure 1. Workflow architecture in Windows SharePoint Services 3.0

Foundation book on sharepoint 2007

2009-05-16T23:52:00.001-07:00

There are two major books for begineers :

1. Inside WSS 3.0 and 2. Inside MOSS 2007 from Mirosoft Press.

These two books will give a strong foundation to the new bie in sharepoint

How to get distinct value from CAML query

2009-05-14T06:01:00.000-07:00

Many times, we face a challenge to get unique rows froma CAML query. The main problem is that CAML does not have any feature to get the distinct rows in one go.

Way Around:

We all know that CAML query returns SPListItemCollection and we can convert the outcome to data table also.
We can convert the resultant datatable to dataview and again convert the dataview to datatable by using ToTable and arguments :
Distinct = true
and column name

So..
suppose we have SPWeb object as 'web' so

DataTable DT= web.GetSiteData(qry);
DataView v = new DataView(tbl);
return v.ToTable(true, "Type");

This code snippets returns the distinct rows by comparing column name "Type".

How to check whether SPList exists in Sharepoint?

2009-04-27T22:27:00.000-07:00

Sometimes we require to check whether SPList exists or not. There is no direct method to check for it. Instead we have to use try-catch block to catch the exception and to determine the list existence:

The code is:

using (SPSite ospSite = new SPSite("http://<servername>:<portname>"))
{
using (SPWeb ospWeb = ospSite.OpenWeb())
{
try
{
SPList ospList = ospWeb.Lists["ListName"];
if (ospList != null)
return true;
}
catch(Exception ex)
{
return false;
}
}
}

This code block creates an instance of SPList object. If ospList object is not null that is list is there so it returns true.
If list does not exists, an exception will be raised and false will be returned from catch block

Using SPPropertybag to save value

2009-04-21T22:38:00.000-07:00

Hi,
this small code snippet will explain how to store value to Sharepoint proerty bag and how to fetch it.

How to save value to SPProperty Bag
Here we will create an instanceof SPPropertyBag and try to add a key 'BlogImage' to the bag:

SPPropertyBag spProperties = SPContext.Current.Web.Properties;
if (spProperties.ContainsKey("BlogImage")) spProperties.Remove("BlogImage");
spProperties.Add("BlogImage", path);
spProperties.Update();
SPContext.Current.Web.Update();

NOTE: Updating SPPropertybag and SPWeb is important.

How to get value from SPProperty Bag

SPPropertyBag spProperties = ospWeb.Properties;
string blogImageValue=string.Empty;
if (spProperties["BlogImage"] != null && spProperties["BlogImage"] != "")
{
blogImageValue= spProperties["BlogImage"].Trim();
}

How to set People Picker value in Sharepoint

2009-04-15T23:16:00.000-07:00

We all are aware of peoplepicker control.
Today we will discuss how to set its value from code and how to retrieve it.

Suppose we have a peoplepicker control named: pplowner

Setting Value to PeoplePicker from code:

pplOwner.CommaSeparatedAccounts = "EUNET\USERNAME";

If you wish to put the current logged in user name in peoplepicker, you can use:

pplOwner.CommaSeparatedAccounts =SPContext.Current.Web.CurrentUser.LoginName;

Fetching Value of PeoplePicker from code:

if (pplOwner.Accounts.Count > 0)
string userid= pplOwner.Accounts[0].ToString();

You can also iterate the usernames in peoplepicker as;

for (int i=0; i<pplowner.Accounts.Count;i++)
Console.Writeline( pplOwner.Accounts[i].ToString);

How to get current login SPUSer in sharepoint

2009-04-15T23:06:00.001-07:00

Many times we require to get the logged in user in sharepoint.
We can easily get the SPUser object of the current logged in user:

SPUser user=SPContext.Current.Web.CurrentUser;

This will give the current logged in user. Now you can get user's email, groupName, Name from various properties like:
user.LoginName, user.Email etc

How to open SPSite, SPWeb in ASP.NET

2009-04-15T22:16:00.000-07:00

This small article will describe , how to open SPSite and SPWeb from asp.net application and how to dispose it properly.

Since we are required to open a sharepoint object, so we need to refer Microsoft.Sharepoint.dll.
The location of the dll is:
Program Files\Common Files\Microsoft Shared\web server extensions\12\ISAPI

Step 1. : Refer the above dll and add the namespace:
using Microsoft.Sharepoint; //C# code written

Step 2:
SPSite is an object to create an instance of a Sharepoint Site
SPWeb is an object to create an instance of a Sharepoint Web.

using (SPSite ospSite=new SPSite ("http://servername:portname"))
{
using (SPWeb ospWeb=ospSite.openWeb())
{
//At this point you can perform any operation on ospWeb and ospSite.
}
}

Here, I have used using to open an instance of SPSite/SPWeb object because this automatically dispose the object as the scope ends.
You don't required to close and dispose it again.
For more detials, check the following link:

http://firstblogofvarun.blogspot.com/2009/03/disposing-spweb-and-spsite-objects.html

ASP.NET from Scratch - Code Behind - Part III

2009-04-10T00:16:00.000-07:00

While our first example was fine, we unfortunately broke one of the coding principles of ASP.NET: To separate markup and code..

As you noticed, we added a scripting block (using <% %>), where we wrote a line of C# code to use the label. While this is just fine for a small and simple example like this, we would soon get a real mess with a bunch of C# code within an even bigger amount of HTML code.

If you throw in some JavaScript and some CSS as well, it will soon become very chaotic to edit. That's why MS introduced CodeBehind, a technique which allows you to completely separate markup (HTML, CSS etc.) and code (C#, VB.NET etc.). So let's remove the script block (from <% to %>) and save the file.

As we talked about earlier, VWD added a file called Default.aspx.cs. If you can't see it in the Solution Explorer, then click the little plus sign left of the Default.aspx file. Open this file. Now, if you haven't worked with .NET or another non-web programming language before, it might look a bit scary at this point. It looks nothing like HTML. However, I will try to explain the different parts of the content, and soon you will hopefully see that CodeBehind is a great tool to get a better overview of your work.

Here is a complete listing of the file as it looks right now:

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{

}
}

For now, the top part is rather irrelevant to us. It's a list of namespaces being included with the using keyword, for usage in the file. Since this is an ASP.NET tutorial and not a dedicated C# tutorial, I won't explain this in depth out here. I will post a separate post for this topic.

Next, we have the class. Classes are a part of the concept of Object Oriented programming, which has become very popular, especially with languages like Java and C#. OO is a very complex subject, which also won't be explained within this tutorial.
The name of this class is "_Default", and the : (colon) tells us that this class inherits from the Page class in the System.Web.UI namespace. This means that our page can already do a bunch of things, without any programming, because it inherits methods and properties from another class.

All ASP.NET pages inherits from the Page class, or another class which inherits from the Page class.

The only method within this class is the Page_Load, which is called everytime the page is loaded. Let's use that to our advantage, and set the ext from this method. We can use the exact same line of code as before, but of course without the script block tags. Add the line of code between the { and } characters:

HelloWorldLabel.Text = "Hello, world!";

That's it. Run the project (F6), and have a look. The page looks exactly like before, but we have just used CodeBehind for the first time. But this example is starting to get a bit old, so in the next chapter, we will look into something a bit more interesting.

ASP.NET From Scratch - 1st Program - Part II

2009-04-10T00:08:00.000-07:00

With MS Visual Web Developer installed, we're ready to create our first ASP.NET website. In VWD, this is very easy. Open the File menu and select "New Web Site". You will be presented with the following dialog:

You need to select "ASP.NET Web Site", if it's not already selected. You should also name your new site. This is done by entering a name in the Location box. This text box is probably already filled for you, with the last part being something like "Website1". You can choose to accept this, as well as the location of the project, or you can enter a new one, like I did. I have created a folder, "My Websites", and within this folder, I would like to create the new project with the name of "FirstWebSite". For now, this is less important, but later on you might wish to gather all your projects in a specific folder.

This tutorial will focus on the C# language. Once again, no knowledge of this is required, so if you already know another .NET language, you will get to learn some C# with this tutorial as well. Select C# in the Language dropdown. Now, click the Ok button to create this new website.

VWD will create a very basic website for you, consisting only of a Default.aspx file (and it's partner, the Default.aspx.cs file) and an App_Data folder. I will explain this later, but for now, just accept the fact that they are there. We will only use the Default.aspx for this first example. Move on to the next chapter, for the obligatory "Hello, world!" example.

Hello World Program

In almost every programming tutorial you will find the classic "Hello, world!" example, and who am I to break such a fine tradition? Let me show you how you can say hello to the world from ASP.NET. Open the Default.aspx (if it's not already opened) by doubleclicking it in the Solution Explorer. It already contains a bunch of (X)HTML markup, as well as some stuff you probably won't recognize, like the Page directive in the top, or the runat attribute on the form tag. This will all be explained later, but for now, we want to see some working code.

First of all, we will add a Label control to the page.
A Label control is some what simple, since it's just used to hold a piece of text. Add the following piece of HTML-looking code somewhere between the set of <form> tags:

<asp:Label runat="server" id="HelloWorldLabel"></asp:Label>

Secondly, add this script block somewhere on the page, preferably below the Page directive in the top:

<%
HelloWorldLabel.Text = "Hello, world!";
%>

If you haven't worked with ASP.NET before, I'm sure there's a bunch of things that you're wondering about now, but as I said, this is all about seeing some results right now.
To see the page in action, use Debug -> Start Without Debugging, or simply press F6. VWD will now compile your project, and launch the page you're working on in your default browser. The page will simply have a piece of text which says "Hello, world!" - congratulations, you have just created your first ASP.NET website!

Here is the complete listing:

<%
HelloWorldLabel.Text = "Hello, world!";
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Untitled Page</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Label runat="server" id="HelloWorldLabel"></asp:Label>
</div>
</form>
</body>
</html>

ASP.NET From Scratch - Introduction - Part I

2009-04-10T00:03:00.000-07:00

Welcome to this ASP.NET tutorial. According to Microsoft, "ASP.NET is a technology for building powerful, dynamic Web applications and is part of the .NET Framework". This tutorial will teach you ASP.NET from scratch, and no knowledge of any kind of server side scripting is required. Basic HTML and CSS knowledge is preferable. Having worked with Classic ASP or PHP won't give you much of an advantage, since ASP.NET is a whole new way of doing things.

.NET is language independent, which means you can use any .NET supported language to make .NET applications. The most common languages for writing ASP.NET applications are C# and VB.NET. While VB.NET is directly based VB (Visual Basic), C# was introduced together with the .NET framework, and is therefore a some what new language. Some people call C# "the .NET language", but according to Microsoft, you can do all the same things, no matter if you're using C# or VB.NET. The 2 languages are not that different, and if you have used one of them, you will have no problems at all learning the other. In this tutorial we will use C#.

One of the main differences between ASP.NET and Classic ASP/PHP is the fact that ASP.NET is compiled, while Classic ASP is always interpreted. PHP can be compiled by using commercial products, but usually it's interpreted as well.

This tutorial will use the free Visual Web Developer 2005 IDE from Microsoft. Despite what some people think, ASP.NET can be used without an IDE. It would be perfectly possible to write ASP.NET code in Notepad, and use the commandline compiler included with the .NET framework. Some people might actually prefer this "back to basics" way of doing things, but I believe that ASP.NET is best programmed with a decent IDE. You can use an IDE from another vendor, and you will still be able to follow most of this tutorial. We will use VWD 2005 since it's free, quick to install and easy to use. Besides, using a good IDE will make a lot of things faster in the long run.

Now, you can read more about VWD 2005 on this page:
http://msdn.microsoft.com/vstudio/express/vwd/ and download it from this page:

Download

. The initial download is very small, because the installation is based on which components you already have and which will have to be downloaded. Just execute the file, and you will be guided through the installation. Once installed, start up the application, and proceed to the next chapter.

How Google Interpret your query

2009-04-09T23:54:00.000-07:00

This article describes how Google treats your search terms.

All Search Terms Count

Google returns only pages that match all your search terms.

For example a search for PR PLAN 2009 find pages containing the words “PR” and “PLAN” and “2009”.

This means Google adds implicit AND to the search query terms.

NOTE: Google sometimes returns pages that does not contains your query terms because Google returns pages in which your query terms are included in the link text to another page or place on the page.

Google also searches the metadata values set for a page (if any) with the query terms and if match found, the page is returned in search result.

Search Terms Match Exactly

Google returns pages that match your search terms exactly.

That means that Google simply matches string of characters together by putting and in between. It does not look for synonyms of words.

If you search for …	Google won't find …
cheap	inexpensive
tv	television
effects	influences
children	kids

Stop Words

Some common words such as ‘the’, ‘a’, ‘an’, ‘on’, ‘where’, ‘this’, ‘is’, ‘when’ generally don’t add meaning to a search and are called Stop Words.

These words are omitted while performing the search.

For example if you search for ‘What to do for a student visa’, Google searches for terms ‘to’, ‘do’, ‘student’ and ‘visa’ ignoring ‘What’, ‘for’ , ‘a’.

Terms in Order
Google gives higher priority to pages that have the terms in the same order as in your query.

Consequently, you should enter search terms in the order in which you would expect to find them on the pages you're seeking. A search for [Microsoft latest technologies] gives priority to pages about Microsoft’s Latest Technologies.

Not Case-Sensitive

Google is not case-sensitive. It shows both upper- and lowercase results.
Ignoring case distinctions increases the number of results Google finds. A search for “Times Square” finds pages containing “Times Square”, “times square” or “TIMES Square”

Characters Ignored
Google ignores some punctuation and special characters, including

! ? , . ; [ ] @ / # < > .

For example Dr. Watson returns the same values as Dr Watson

Apostrophes

A term with an apostrophe doesn’t match the term without an apostrophe.

For example, ‘we’er’ matches “we’er” but not “were” and vice versa.

Quoted Phrases

To search for a phrase, a proper name, or a set of words in a specific order, put them in double quotes.

A query with terms in quotes finds pages containing the exact quoted phrase.

For example, search term “White House” finds pages containing the phrase “White House” exactly.

NOTE: If you put stop words in between double quotes, Google will search for the phrase including those stop words.

How to use resource file in Sharepoint

2009-03-23T22:17:00.000-07:00

Today I will tell you how to use resource file in sharepoint.

Resource file is stored in location '12/Resources' directory.

If you don't know where this '12' folder exists , then the full path is:

C:\Program Files\Common Files\Microsoft Shared\web server extensions\12

There you will see a folder named 'Rescources'.

Suppose we have a resource file named CustomResource.resx with a key/value pair as :

userName : TestUser

Now, if we need to access the value of key userName from resource file from our application, we need to do:

string srcName = SPUtility.GetLocalizedString(
"$Resources:CustomResource,userName", "CustomResource", 1033);

You can also use the above code like this also:

string srcName = SPUtility.GetLocalizedString(
"$Resources:userName", "CustomResource", 1033);

Varun Sharma

Sometimes, I set breakpoints and attach to the process but Visual Studio skips loading the symbols if I’m debugging a deployed assembly to the GAC and

2009-03-18T23:59:00.001-07:00

Easy, Open Tools -> Options -> Debugging.

You’ll find an option labeled Enable Just My Code (Managed Only) as shown in the figure which is checked by default. Uncheck this option to be able to debug the assemblies located in the GAC. There is a common myth among .NET developers in general and especially SharePoint ones, that in order to debug assemblies that have been deployed to the GAC, you need to copy the debug symbols (PDB File) to the GAC as well. This was true in the early days of .NET but this is no longer true.

When I try to attach the debugger to the W3WP.exe process to debug, I always see multiple instances of it. Which one should I attach to?

2009-03-18T23:57:00.000-07:00

Ok, this is easy too. Just follow the following steps.

Open the command prompt window, run IISAPP to get a list of the current instances of W3WP.exe.

Note the PID of the instance that corresponds to your web application.

Now return to VS, select Debug -> Attach to process and attach to the W3wp.exe instance with an ID equivalent to the PID you got in step 2 -> click Attach.

Now you can trace through the code and find the error causes easily.

But the question still remains, why sometimes are they more than one w3wp.exe instance? This is because the SharePoint Administration Site Collection and the SSP Administration site always have their own Application pools for error isolation purposes.

How to get detailed error message in Sharepoint site

2009-03-18T23:50:00.000-07:00

SharePoint uses a user friendly (Yellow & Blue) error page to show that a problem occurred. Yeah, they call it the user friendly page, but we, as developers, call it the Annoying Page. The first time I wrote SharePoint code, I received a screen like the one shown in the figure below:

This error page points out that an assembly has thrown an unhandled System.Exception. Sometimes, the user-friendly error page will specify the nature of the error if the code that threw the exception used something more specific than System.Exception or if it included a message in the Exception class constructor.

We need to get a more detailed Error Message than the annoying “Unexpected error has occurred “. This can be achieved by doing three modifications to the Web.Config file from the virtual directory containing your SharePoint application. These modifications are listed in the next table.

Tag
customErrors Mode :Off or Remote only
SafeMode CallStack : True
SafeMode AllowPageLevelTrace: True

No Custom Errors shows the full error to every client, every time. This is typically used Development environment, since there are no clients using it.

I recommend using the Debug Config feature to automate this process. This is just a feature that when you activate on a web application, it automatically tweaks the Web.Config of the specified web application across the farm.

.NET NameValueCollection DataTypes

2009-03-17T02:14:00.000-07:00

A NameValueCollection is similar to a .NET Hash Table in that it can store items in key/value pairs and allows you to retrieve items by specifying either the Key or index. In fact, NameValueCollections use the hash table and hash table algorithms for their underlying data structures.

Unlike a hash table that can store any type of object as its key or value, NameValueCollections can only store string values. However, a NameValueCollection can store multiple strings values for each key. Because NameValueCollections use the hash table algorithms, they are slower performance wise than hash tables.

A NameValueCollection also has methods to return a collection of all keys, all values, add and remove items and to get an enumerator so you can enumerate through the collection.

How to change default button of ASP.NET Page

2009-03-13T05:01:00.000-07:00

ASP.Net 2.0 has a new feature of setting default button of a asp.net page.
Now you can set initial focus on your form and also set a default button (for when pressing enter) by setting 2 attributes on your form tag:

defaultbutton="Button1" defaultfocus="TextBox1"

This will add JavaScript to set focus on TextBox1 and set the Button1 as the default button for when a user presses enter on the web form.

This is very neat, but when using master pages you don't have access to the form tag. As of any property, you can also set it at the code behind, but you need a little trick. Since ASP.NET uses javascript to set the focus and the default button, you have to specify the client id of the controls, rather than the server ids:

Page.Form.DefaultButton = Button1.UniqueID;
Page.Form.DefaultFocus = TextBox1.ClientID;

Happy Programming!!

How to get SPUser name from User Id

2009-03-12T22:17:00.001-07:00

Sometimes we get uniques user id from sharepoint but the requirement is for name.

This can be done in one simple line:

using (SPSite site=new SPSite(siteurl))
{
using (SPWeb web=site.OpenWeb())
{
string userName= web.AllUsers.GetByID(Convert.ToInt32(userid)).Name;
}
}

Line number 5 actually gets the user name by searching all users in the 'web' scope by searching userId.

Disposing SPWeb and SPSite objects

2009-03-11T22:26:00.000-07:00

What happens if a SPWeb object is not disposed?

Each SPWeb and SPSite object holds a reference to a SPRequest object which holds a reference to a SharePoint COM object that is responsible to communicate with the backend SQL server.

Disposing a SPWeb object will not actually remove the SPWeb object from memory (actually the .NET framework does not allow to remove any object from memory in a deterministic way) but it will call a method of the SPWeb object which causes the COM object to close the connection to the SQL server and to release its allocated memory.

That means the connection to the backend SQL server will remain open from the moment the SPRequest object has been created till the SPWeb object is disposed.
After the dispose only the small managed SPWeb and SPRequest objects remain in memory which do not create a big memory overhead. They are removed by the dot net framework through garbage collection later as with any other managed object as soon as no references to the object exist any more.

In case that the SPWeb object is not disposed when it is no longer used, then the connection to the SQL server will stay open and the memory allocated by the COM object will stay in memory as the COM object has not been asked to close the connection and to release the memory.

Each connection to the database requires a tcp port for the communication. Per default only 5000-1023 = 3977 ports are available. Which means on a single machine per default you cannot have more than 3977 open connections to other applications. Be aware that this is the number for all processes. Not just a single application pool.

So beside the fact that not disposing SPWeb and SPSite will lead to a higher memory consumption which finally can lead to out of memory exceptions the machine might also run out of TCP ports which would lead to lots of other problems - potentially also in other applications on the same server.

When should SPWeb and SPSite objects be disposed?

You should dispose a SPWeb or SPSite object after the last access to a child object of this object. Be aware that a sub site (SPWeb) is not a child object. But (e.g.) a list or a folder or list item is a child object for this scenario.

When should I dispose SPSite.RootWeb?

When SPSite.RootWeb is first accessed it creates an SPWeb object using SPSite.OpenWeb and stores a reference in an internal variable. Further accesses to SPSite.RootWeb are then satisfied by returning a reference to the earlier created object. In case the RootWeb object has been disposed it will create a new one using OpenWeb as for the initial access.

That means we have a single SPWeb object per SPSite object even if we access SPSite.RootWeb multiple times. Creating a SPWeb object is an expensive operation as it requires the instantiation of a COM object, a database communication to download the info about the SPWeb object and so on. That means disposing the RootWeb object after every single access to it can affect the performance of the site - especially if you have many different places in your project that do the same for the same SPSite object. So ensure to dispose the RootWeb object only after the last access to it in your code whereever the logic of the code allows to determine this.
Also please do not dispose the RootWeb property of SPContext.Current.Site. This object is used in many different places in SharePoint and you should not dispose it. It will automatically be cleaned up when the request finishes.

-----------------------------------------------------------------------
Dispose of objects which do not belong to the method?

In general SPSite and SPWeb objects should be disposed in the same method they get allocated. That's the best method to ensure that no disposed can be missed and to ensure that a dispose does not occur for an object that will be used later.
I have seen several cases where custom code disposed SPWeb and SPSite objects incorrectly.

A very common scenario is the following:
...

using (SPSite mySite = SPContext.Current.Site)
{
...
}
...
Using "using" statements is a very nice method to ensure that at the end the object being used gets properly disposed. The problem in the code above is that SPContext.Current.Site and SPContext.Current.Web are not allowed to be disposed! Using successfully hides the dispose statement here. "Using" allows a nice structuring of the code so users often use it without thinking about the side effects.

If you plan to use a using statement with SPContext you need to code it like this:
...
using (SPSite mySite = new SPSite(SPContext.Current.Site.ID))
{
...
}
...
This method will ensure that a new independent SPSite object is created which you then can dispose without side effects on other code using the SPSite object bound to the current SPContext object.
-----------------------------------------------------------------------
Another common error is to dispose an SPSite or SPWeb object in a event receiver:

public override void ItemCheckingOut(SPItemEventProperties properties)
{
...
// incorrect dispose of SPWeb
using (SPWeb web = properties.ListItem.Web)
{
}
...
// incorrect dispose of SPSite
using (SPWeb site = properties.ListItem.Web.Site)
{
}
...
}
After executing our code other event receivers will receive an object where the underlaying SPWeb and/or SPSite object has been disposed. This can lead to exceptions.

-----------------------------------------------------------------------
// Do not do this. Dispose() is automatically called on SPWeb.
using( SPWeb web = SPControl.GetContextWeb(HttpContext.Current)) { ... }
SPContext objects are managed by the SharePoint framework and should not be explicitly disposed in your code. This is true also for the SPSite and SPWeb objects returned by SPContext.Site, SPContext.Current.Site, SPContext.Web, and SPContext.Current.Web.
You must be cautious and aware of what the runtime is doing whenever you combine SharePoint object model calls on the same line. Leaks arising from this scenario are among the hardest to find.

How to customization status of a file, removing any customization

2009-03-09T23:06:00.000-07:00

Hi ,

This post deals with checking the customization status of any sharepoint file and if file is found to be customized then to remove its customiztion and reverting back to template file.

using System;
using Microsoft.SharePoint;
namespace CustomizationCheck {
class Program {
static void Main (string[] args) {
using (SPSite siteCollection = new SPSite("http://sitename")) {
using (SPWeb site = siteCollection.RootWeb) {
SPFile file = site.GetFile("default.aspx");
// if file is customized, revert to underlying template file
if (file.CustomizedPageStatus == SPCustomizedPageStatus.Customized)
file.RevertContentStream();
} // SPWeb using statement
} // SPSite using statement
} // method “Main”
}
}

How to stop ItemUpdate fire from ItemListener

2009-03-04T03:56:00.000-08:00

Many tile it happens that we update an item and call custom Item added event listener.

Now suppose , if we have to update some item of list in the event listner so the update event will get fire again from the listener and it will be a never endin g loop..

In order to solve that, there is a one line solution...

In the ItemUpdated event,

put the following code:

this.DisableEventFire();

then update the list and again enable the same

this.EnableventFire();

This will solve the issue.

How to set Item Level Permission in to Sharepoint List

2009-03-03T20:41:00.000-08:00

Hi,

Today I will discuss how to revoke Item level permission and how to grant Item Level permission on a sharepoint list to a user.

Before discussing the code, I would like to tell you something about some properties used in the code:

SPList.RoleAssignments Property :
Gets the collection of role assignments for the list.
Namespace: Microsoft.SharePoint
Assembly: Microsoft.SharePoint (in microsoft.sharepoint.dll)

SPRoleAssignment.RoleDefinitionBindings Property : Gets the collection of role definition bindings for the role assignment.
Namespace: Microsoft.SharePoint
Assembly: Microsoft.SharePoint (in microsoft.sharepoint.dll)

SPPrincipal Class :
Represents a user or group that can be assigned permissions in Windows SharePoint Services to control security.
Namespace: Microsoft.SharePoint
Assembly: Microsoft.SharePoint (in microsoft.sharepoint.dll)

I have written a function that will take the following parameters:

1. string Site url
2. string Library name
3. string Old user name (format : <domainname>\<username>
4. string new user name (format : <domainname>\<username>

My whole intension of function is to revoke permission of the item from old user and assign it to new user. You may or may not require the new user parameter if you are only revoking access.

public static void SetItemPermission(string SitePath, string LibName, string OldUser, string NewUser)
{

SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (SPSite WebApp = new SPSite(SitePath))
{
using (SPWeb Site = WebApp.OpenWeb())
{
SPList list = Site.Lists[LibName];
SPQuery newSPQuery = new SPQuery();
newSPQuery.Query = "<where><contains><fieldref name="\">" +
"<value type="\">" + OldUser + "</value>" + "</contains></where>";
try{
SPListItemCollection listItemCol = list.GetItems(newSPQuery);
if (listItemCol.Count > 0)
{
SPUser user = null, _newUser = null;
SPRoleAssignment role = null;
foreach (SPListItem item in listItemCol)
{
user = Site.Users[OldUser];
SPPrincipal principal = (SPPrincipal)user;
item.RoleAssignments.Remove(principal);
role = new SPRoleAssignment(NewUser, "", "", "");
role.RoleDefinitionBindings.Add(Site.RoleDefinitions["Contribute"]);
item.RoleAssignments.Add(role);
}
item.SystemUpdate(false);
}
}}catch(Exception ex){}
}
}
});

}
#endregion

How to access SharePoint User Profile from C# code

2009-02-25T20:53:00.000-08:00

Hi All,

We all know sharepoint user profile stores users information. Sometimes we use out of box features to update these profile values like mysite stc but many times we come across the situation where we need to access uer profile from code, update the properties and save the profile.

In this post, I will tell you the step by step way to access user profile and to access/update the property field.

Step 1: Refer the following dlls in the code:

using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;
using Microsoft.Office.Server;
using Microsoft.Office.Server.UserProfiles;

Step 2: Create the instance of SPSite object:

using (SPSite ospSite=new SPSite("http://servername:portname")
{}

where http://servername:portname is your sharepoint application url.
Here we have used using to create the instance of SPSite since 'using' automatically disposes the object when the block gets finished.

Withing 'using' block , add the following codes:

Step 3: Create the instance of servercontext object:

ServerContext ospServerContext = ServerContext.GetContext(ospSite);

Step 4: Create the instance of userporfile object propertycollection object:

UserProfileManager ospUserProfileManager = new UserProfileManager(ospServerContext);
UserProfile ospUserProfile = ospUserProfileManager.GetUserProfile(UniqueId);
Microsoft.Office.Server.UserProfiles.PropertyCollection propColl = ospUserProfile.ProfileManager.PropertiesWithSection;

here uniqueid is the id by which each profile is recognized individually. Eacn user profile has a uniqueId many ny 5-2-1 id if it is an AD account or GUID.

Step 5: Check whether the USerprofile object is null or not

if (ospUserProfile != null && propColl != null)
{}

Step 6: Iterate thorugh all the proerties in property collection:

foreach (Property prop in propColl)
{}

In the for loop you can get the property name and value like this:

To get property name: prop.Name
To get property value: ospUserProfile[prop.Name].Value

To set a value to a proerty : ospUserProfile[prop.Name].Value ="SOME VALUE";

To save the user profile after updation: ospUserProfile.Commit();

This will get the userporfile of a user and update the profile.

The whole code is as follows:

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Data.SqlClient;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;
using Microsoft.Office.Server;
using System.IO;
using System.Data;
using Microsoft.Office.Server.UserProfiles;

namespace Program1
{

public static void Main(string args[])
{
using (SPSite ospSite = new SPSite(webApp))
{
try
{
ServerContext ospServerContext = ServerContext.GetContext(ospSite);
UserProfileManager ospUserProfileManager = new UserProfileManager(ospServerContext);
UserProfile ospUserProfile = ospUserProfileManager.GetUserProfile(uniqueId);
Microsoft.Office.Server.UserProfiles.PropertyCollection propColl = ospUserProfile.ProfileManager.PropertiesWithSection;

if (ospUserProfile != null && propColl != null)
{
foreach (Property prop in propColl)
{
Console.WriteLine("property Name : " + prop.Name);
Console.WriteLine("proerpty Value : " + ospUserProfile[prop.Name].Value);

//If updation is required
ospUserProfile[prop.Name].Value="SOME VALUE";

}
ospUserProfile.Commit();
}
}
catch(Exception ex){
Console.WriteLine(ex.Message);
}
}
}
}

How to get old index value of dropdown when index change occures

2009-02-23T23:25:00.000-08:00

Many times user faces this situation: A dropdown with some values. User selected a value and SelectdIndexChanged event fires.
In the code block, one can get the current index value of dropdown but what if old value is required. that is value before selecting the new index.

The simple solution is to use viewstate to hold the old value:

Suppose we have a dropdown 'dropdown1' with some item values.

Steps:
1.In code behind, we defined a public property IndexVal that store and fetch dropdown index value from a viewstate variable:

public int IndexVal {
get
{
return Convert.ToInt32(ViewState["OldSelectedIndex"]);
}
set {
ViewState["OldSelectedIndex"] = DropDownList1.SelectedIndex;
}
}

2. When the page loads for 1st time, set the viewstate value to dropdown index value

if (!IsPostBack)
IndexVal = DropDownList1.SelectedIndex;

3. When SelectedIndexChanged event fires, we can get the old index value from viewstate and new index value from the dropdown itself.
Then set the viewstate with new value.

protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs e)
{
int oldValue IndexVal;
int newValue DropDownList1.SelectedIndex;
IndexVal = DropDownList1.SelectedIndex;
}

Varun Sharma

Javascript call from Master page and content Page -Part I

2009-02-21T00:36:00.000-08:00

Create a JavaScript function on the fly and call the JavaScript function in the MasterPage Page_Load() event
C#
protected void Page_Load(object sender, EventArgs e)
{
string someScript = "";
someScript = "";
Page.ClientScript.RegisterStartupScript(this.GetType(), "onload", someScript);
}
VB.NET
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
Dim someScript As String = ""
someScript = ""
Page.ClientScript.RegisterStartupScript(Me.GetType(), "onload", someScript)
End Sub

The Page.ClientScript.RegisterStartupScript() allows you to emit client-side script blocks from code behind. More info can be found over here http://msdn.microsoft.com/en-us/library/system.web.ui.clientscriptmanager.registerstartupscript.aspx

Using Lambard Expression

2009-02-10T21:41:00.000-08:00

Lambda Expressions are based on functional calculus—Lambda Calculus—from the 1930s, and Lambda Expressions exist in other languages.Think of Lambda Expressions as brief inline functions whose concise nature is an ideal fit for LINQ.

Lambda Expressions are written with a left side, the => symbol, and a right side, as in(x,y) => x + y;.
The left side represents the input arguments and the right side is theexpression to be evaluated.

For example(x,y) => x + y;is read x and y goes to—or as I read it gosinta—the function x + y.

Implicit in the expression is the return result of x + y.

The input argument or arguments can be inferred and generated by the compiler, called implicit arguments, or expressed explicitly by you.
The preceding Lambda Expression can also be rewritten as(int x, int y) => x + y;

class Program{

static void Main(string[] args) {

Func<int, int, int> add = (int x, int y) => x + y; Console.WriteLine(add(3, 4)); Console.ReadLine(); }}[/code]
You can begin exploring how Lamba Expressions support LINQ queries by seeing howLambda Expressions are used in extension methods such as Select, Where, orOrderBy.
Using Select<T> with Lambda Expressions
Check the following example:[code] var numbers = new int[]{1,2,3,4,5,6}; foreach(var result in numbers.Select(n => n)) Console.WriteLine(result);[/code]
Here we are executing the SELECT * behavior of SQL queries by initializing the Select extension method with n => n. n => n means that n is the input and you want to return n.
Using Where<T> with Lambda Expressions
The Where extension method is employed in scenarios where you would use conditional logic to filter the elements returned in a resultset. Like Select, Where returns an IEnumerable, where T is defined by the type of the result from the Lambda Expression.
[code] var words = new string[]{"Drop", "Dead", "Fred"}; IEnumerable<string> hasDAndE = words.Where(s => s.Contains('D') && s.Contains('e')); foreach(string s in hasDAndE) Console.WriteLine(s);[/code]
Using OrderBy<T> with Lambda Expressions
OrderBy is the extension method that supports sorting. OrderBy accepts a Func genericdelegate. The Func argument can be expressed with a literal Lambda Expression.
[code]
var numbers = new int[] {1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };IEnumerable<int> ordered = numbers.OrderBy(n=>n); foreach(var num in ordered) Console.WriteLine(num);[/code]

Using Conversion Types

2009-02-10T21:11:00.000-08:00

A very common task is converting data from one form to another.
The new version of .NET has conversion operators ToArray, OfType, Cast, AsEnumerable, ToList, ToDictionary, and ToLookup. We will discuss each one by one:

ToArray : Arrays are fast but not very convenient. It is tedious to write array management code when collections like List make managing data easier.The main reason, dot net framework supprots ToArray because many legacy code and API supprots uses ToArray till now.
OfType : The conversion operator OfType returns an IEnumerable collection of only the types defined by the parameter T. For example, initializing a list of objects where some are integers, you can quickly extract just the integers
var numbers = new object[]{1, "two", null, "3", 4};
foreach(var anInt in numbers.OfType())
Console.WriteLine(anInt);
Cast: To receive an exception if elements of the source type cannot be converted to the target type, use the Cast conversion operator.
AsEnumerable : Many types implement IEnumerable.AsEnumerable Forces an Object That Implements IEnumerable to Use theBehaviors of the IEnumerable Interface.
ToList: The ToList conversion operator forces an immediate query evaluation and stores the results in a List.
ToDictionary:A dictionary is a collection of name and value pairs. ToDictionary converts anIEnumerable object—such as is returned from a LINQ query—into anIDictionary object.
ToLookup:ToLookup converts an IEnumerable to a Lookup type. Lookup is like a dictionary, but where a Dictionary uses a single key value, Lookup maps keys to a collection of values. Lookups have no public constructor and are immutable. You cannot add or remove elements or keys after they are created.

Summary:
Compound type initialization makes it easier to initialize arrays and lists and is an essential capability for initializing anonymous types. Conversion operators take some of the tedium out of converting between convenient types and other types. More important, this chapter demonstrates the classic onion layering of complexity in .NET that makes it possible to do a lot of work with relatively few lines of code.

Introduction to LINQ - Part 2 - Anonymous types

2009-02-10T04:32:00.000-08:00

Before jumping right into the LINQ asnd its implementation, I would like to introduce some new features of dot net framwork 3.0/3.5 that were incorporated to support LINQ.

In this article, we will discuss Anonymous types

First thing about Anonymous types is that it uses the keyword var. The var introduced with .NET 3.5 indicates an anonymous types. A developer who has worked in VB6, may say that var was there in VB6 also. So what's the difference?

Anonymous types defined with var are not similar to VB variant. So what is var?
The var keyword signals the compiler to emit a strong type based on the value of the operator on the right side.

A simple anonymous type begines with a var keyword, the assignment operator and a not null initial value.

var title="Tutorial on LINQ";

here the data type of var will be set based on the data type of the right hand side. So the datatype of title will be string.

As you will notice that I have mentioned that we need to assigna 'not null initial value'.

Anonymous types must always have an initial assignment and it can’t be nullbecause the type is inferred and fixed to the initializer.

Summary
Anonymous types are strong typeswhere the compiler does the work of figuring out the actual type and writing the classimplementation, if the anonymous type is a composite type.

Introduction to LINQ - Part 1

2009-02-10T03:50:00.000-08:00

Microsoft dot net framework 3.0 introduced new feature named LINQ.

What is LINQ :
Language Integrated Query (LINQ) is a methodology that simplifies and unifies the implementation of any kind of data access.

Why LINQ:

The main objective behind LINQ was to address the concept related problems and technical difficulties encountered when using databases with .NET programming languages.

The two main intention of introducing LINQ were:

provide a solution for the problem of object-relational mapping
simplify the interaction between objects and data sources

LINQ eventually evolved into a general-purpose language-integrated querying toolset. This toolset can be used to access data coming from in-memory objects (LINQ to Objects), databases (LINQ to SQL), XMLdocuments (LINQ to XML), a file-system, or any other source.

Advantage of LINQ

Developers can use LINQ with any data source.

They can express efficient query behavior in their programming language of choice, optionally transform/shape data query results into whatever format they want, and then easily manipulate the results.

LINQ-enabled languages can provide full type-safety and compile-time checking of query expressions, and development tools can provide full intellisense, debugging, and rich refactoring support when writing LINQ code.LINQ supports a very rich extensibility model that facilitates the creation of ery efficient domain-specific operators for data sources.

Interview with Wipro

2008-01-04T05:46:00.001-08:00

1. Difference between dot net framework 1.1 and 2.0

2. Difference between datagrid and gridview

3. ADO.NET architecture

4. How garbage collection works

5. Level of GC

6. Which class to use for xml manipulation

7. Diff between XML reader and XML Document class

8. How to jump to particular node without traversing

Interview with IBM

2007-11-13T01:15:00.000-08:00

these are the questions asked in IBM interview...

Rate yourself in ASP and ASP.NET
Rate yourself in VB
What is Activex Object?
How many types of ActiveX objects are there?
What is diff between ActiveX DLL and ActiveX EXE?
When to use ActiveX DLL and when to use ActiveX EXE?
What is COM+?
How you can use COM in .NET?
What is assembly?
What are different parts of assembly?
How many types of assemblies are there?
What is singleton assembly?
What is Satellite assembly and how to create it?
What is the difference bewteen datareader and dataadapter?
What is Dataset? Explain..
How to establish a conn to a database?
How to fetch data using datareader and sqldataadapter?
What are various autentication mode in IIS?
What is difference between authentication and authorisation?
Explain authentication process.. what changes is required in web.config?
How to impliment exception handling in ASP.NET?
How to handle application error/exception in ASP?
What is GAC?
Why GAC is required?
What is Normalization?
Explain different types of Normalization Form with examples.
What is trigger?
Explain difference between AFTER and INSTEAD OF triggers.
What is transaction?
Explain ACID property of trancation.
Write the code of how to implemnt trancation in ASP.NET.
How many types of joins are there?
Write a query to show cross join?
Explain the concepts of OOPS?
Diff between interface and abstract class?
Use of sealed keyword?
How to hide data member and function member of base class?
Explain inheritance.
What is ADO?
What is cursor type and lock type?
How many cursor types are there and what are the uses of each one of them?
How will you delcare user defined data types in javascript?