ASP.NET

Following are the Page life cycyle events of an ASP.NET application: -

- Page request.
- Start.
- Page initialization.
- Load .
- Validation.
- Postback event handling.
- Rendering.
- Unload.

See related links for details about each stage.

. However storing the session state InProc has its own share of limitations. Some of these are

- With each app domain restart Session state is lost

- Process restart will result in loss of Session state data

- If considerable amount of data are stored in Session state, memory consumption for the process may increase to the point of experiencing issues due to high memory. Therefore, the amount of data being stored in Session state and the time frame during which these data need to be stored should be limited as much as possible.

- In case one wants to implement InProc Session state in a web farm scenario ensure we have sticky sessions enabled for the web farm as it involves storing of the session data among processes hosted on multiple servers.

Base class can access members functions of derived class if they were declared as 'virtual' in base class and have same prototype. For this type of access, a pointer to base class is required.

class Parent

{

//data members and constructor here

virtual void Func1()

{

cout<<"hello from Parent\n";

}

};

class Child : public Parent

{

//data members and constructor here

void Func1()

{

cout<<"Hello from Child\n";

}

},

int main()

{

Parent *pParent;

pParent = new Parent();

pParent->Func1();

pParent = new Child();

pParent->Func1();

..

..

..

}

OutPut:

Hello from Parent

Hello from Child

The pointer to base class must be initialized to some instance of the derived class, before accessing its member function.

The above is specific to C++. In Java, a base (parent) class can access any methods (but not Class variables) of a subclass ONLY if that subclass overrides the method declared in the parent class.

Thus:

public Parent {

// class variables

private int i;

// class methods

public int myMethod () {

return i;

}

}

public Child {

// class variables

private float k;

// class method

// overrides Parent

public int myMethod () {

return (int) k;

}

// overload Parent

public int myMethod (float j) {

return (int) (j * k);

}

}

Thus, for:

Parent p = new Parent();

Child c = new Child();

Parent n = (Parent) c;

// assume we assign i = 10 in 'p', and k = 5.0 in 'c'

These work fine:

p.myMethod() returns 10

c.myMethod() returns 5

n.myMethod() returns 5

c.myMethod(4.0) returns 20

These don't, and throw a methodNotFound error:

p.myMethod(4.0)

n.myMethod(4.0)

The error is thrown because the Parent definition does not include a method with a signature that takes a floating point value as an argument. This happens even in the case of 'n', which, while actually an object of type Child, is being treated as an object of type Parent in this context, so only the Parent signatures are valid.

Note the above only applies to instantiated objects, so the Class definition of the Parent can make no references of any kind to that of a subclass's definition. In the above example, class Parent could never refer to variable k of subclass Child in any way, nor could it refer to the overridden method.

Multiple inheritance, as the name 'multiple' suggests, is one where more than one(multiple) super class is inherited by one sub-class. It can be represented as:

A B C

\ | /

D

On the other hand, in case of multilevel inheritance; the superclass is inherited by a sub-class which is in turn inherited by another class leading to the different level. It can be represented as:

A

|

B

|

C

However in asp, multiple inheritance is not supported.