What's the difference between stateful and stateless?

Question

The books and documentation on the MVC just heap on using the Stateful and Stateless terms. To be honest, i am just unable to grab the idea of it, what the books are talking about. They don't give an example to understand any of the either state, rather than just telling that HTTP is stateless and with ASP.NET MVC microsoft is going along with it. Am I missing some fundamental knowledge, as i can't understand what is stateful and why is stateful and same goes for stateless.

A simple and short example that talks about a control like button or textbox can be simplify the understanding i suppose.

Answer 1

Stateless means that HTTP doesn't have built in support for states; e.g. you can't store if a user has logged in or done something else.

The most common solution is to use sessions to overcome that problem. This means that you have to be able to include a session identifier in each response or request. This is either done by creating a session cookie or by including the session identifier in all links.

WebForms tries to make all that transparent (using ViewState) while MVC forces you to handle it manually.

In your example you mentioned Buttons and TextBoxes. The easiest way to let them maintaining their state is simply to stop posting back the entire page. MVC got excellent support for ajax (through jQuery) and I suggest that you use ajax if you just want to do something on the current page.

Answer 2

Stateless - There's no memory (state) that's maintained by the program

Stateful - The program has a memory (state)

To illustrate the concept of state I'll define a function which is stateful and one which is stateless

Stateless

//The state is derived by what is passed into the function

function int addOne(int number)
{
    return number + 1;
}

Stateful

//The state is maintained by the function

private int _number = 0; //initially zero 

function int addOne()
{
    _number++;
    return _number;
}

As others have said http is inherently stateless. So state must be built into your applications.

Imagine a request over the web where you have a client browser communicating to a server process. To maintain state over the stateless http protocol the browser will send typically send a session identifier to the server on each request. For each request the server will be like "ah, its this guy". State information can then be looked up in server side memory or in a database based on this session id.

In a purely stateless environment you wouldn't need this session id. Each request would contain all the information the server would need to process. But many applications need to maintain state to keep track of whether or not a session is authenticated to view certain content or to keep track of what a user is doing. You wouldn't want to send user credentials over the wire for each request.

Answer 3

stateless means there is no memory of the past. Every transaction is performed as if it were being done for the very first time.

statefull means that there is memory of the past. Previous transactions are remembered and may affect the current transaction.

Answer 4

In my simple opinion the difference between ASP.NET (stateful) and ASP.NET-MVC (stateless) can be isolated to the fact that the first provides server-side controls and the other do not.

It is worth noting that the ASP.NET web forms approach is geared towards transitioning old VB and VC++ programmers who are used in the event model driven model to have a good quick way of learning web programming following the same event model paradigm, like you click a button and voila you trigger an event! All you need to do now is write your code in the event handler. Because of that ASP.NET needed to have concepts like view state and postbacks to monitor the state of the server side controls each round trip.

ASP.NET-MVC, however, does not use server-side controls so it doesn't have to maintain state. The MVC model separates the problem domain into the three partitions so that data is delivered to the client in a streamlined manner.

In summary, the server-side controls are what makes them different in as far as being stateful and stateless.

Answer 5

Addition to @coder exact answer.

The idea of state is to remember previous data.
For example, you have a list control on the server with values "A,B,C" and "A" is selected. The list goes to the client browser. You select "B". And post back to the server. How would you know that the value is changed?

• ASP.NET
  Microsoft uses term ViewState in ASP.NET. There is a huge misunderstanding among developers about it.
  ViewState holds all initial state of the list in <input type="hidden" value="base64 encoded" />: values "A,B,C" and mark "A is selected".
  Then with post back browser sends ViewState and "B is selected" to the server. ASP.NET restores initial state of the list and applies new "B" selection. This was done to lure WinForms developers (mentioned by @Ronald). On the web server you can subscribe to list changes listObject.Changed += OnChanged.

• ASP.NET MVC
  The problem with ViewState is the size. For years .NET developers forced to transfer kilobytes of useless information, like states of 20 controls for every roundtrip.
  The new approach is to send only new and small "B" value.
  Or if you want to track the change from "A" to "B" then implement it by your own. Using javascript and sending "Was A, Now B". Or save and retrieve state by ID in SQL Server.

• ASP.NET MVC and ASP.NET implements state for Authentication and Cashing. So it is not correct to say that ASP.NET MVC fully stateless.
• Memory mentioned in the answers means "remembering", not computer memory. State can be implemented by storing data in File system, SQL server or Computer Memory.

Answer 6

A stateful operation modifies or requires some state of the system, and a stateless operation does not.

Example of a stateful textbox would be a previously edited comment on StackExchange - the textbox needs to display your previous comment and know the post-thread it was involved with to accept and process your input.

A generic email comment form with a mailto: tag would be a stateless textbox - it accepts your input and tosses it to your workstation's mail application without retaining any information.