1. Describe the role of inetinfo.exe, aspnet_isapi.dll and aspnet_wp.exe in the page loading process.
   inetinfo.exe is theMicrosoft IIS server running, handling ASP.NET requests among other things.When an ASP.NET request is received (usually a file with .aspx extension), the ISAPI filter aspnet_isapi.dll takes care of it by passing the request tothe actual worker process aspnet_wp.exe.
2. What’s the difference between Response.Write() andResponse.Output.Write()?
   Response.Output.Write() allows you to write formatted output.
3. What methods are fired during the page load?
   Init() – when the page is instantiated
   Load() – when the page is loaded into server memory
   PreRender() – the brief moment before the page is displayed to the user as HTML
   Unload() – when page finishes loading.
4. When during the page processing cycle is ViewState available?
   After the Init() and before the Page_Load(), or OnLoad() for a control.
5. What namespace does the Web page belong in the .NET Framework class hierarchy?
   System.Web.UI.Page
6. Where do you store the information about the user’s locale?
   System.Web.UI.Page.Culture
7. What’s the difference between Codebehind=”MyCode.aspx.cs” andSrc=”MyCode.aspx.cs”?
   CodeBehind is relevant to Visual Studio.NET only.
8. What’s a bubbled event?
   When you have a complex control, like DataGrid, writing an event processing routine for each object (cell, button, row, etc.) is quite tedious. The controls can bubble up their eventhandlers, allowing the main DataGrid event handler to take care of its constituents.
9. Suppose you want a certain ASP.NET function executed on MouseOver for a certain button.  Where do you add an event handler?
   Add an OnMouseOver attribute to the button.  Example: btnSubmit.Attributes.Add(“onmouseover”,”someClientCodeHere();”);
10. What data types do the RangeValidator control support?
    Integer, String, and Date.
11. Explain the differences between Server-side and Client-side code?
    Server-side code executes on the server.  Client-side code executes in the client’s browser.
12. What type of code (server or client) is found in a Code-Behind class?
    The answer is server-side code since code-behind is executed on the server.  However, during the code-behind’s execution on the server, it can render client-side code such as JavaScript to be processed in the clients browser.  But just to be clear, code-behind executes on the server, thus making it server-side code.
13. Should user input data validation occur server-side or client-side?  Why?
    All user input data validation should occur on the server at a minimum.  Additionally, client-side validation can be performed where deemed appropriate and feasable to provide a richer, more responsive experience for the user.
14. What is the difference between Server.Transfer and Response.Redirect?  Why would I choose one over the other?
    Server.Transfer transfers page processing from one page directly to the next page without making a round-trip back to the client’s browser.  This provides a faster response with a little less overhead on the server.  Server.Transfer does not update the clients url history list or current url.  Response.Redirect is used to redirect the user’s browser to another page or site.  This performas a trip back to the client where the client’s browser is redirected to the new page.  The user’s browser history list is updated to reflect the new address.
15. Can you explain the difference between an ADO.NET Dataset and an ADO Recordset?
    Valid answers are:
    ·  A DataSet can represent an entire relational database in memory, complete with tables, relations, and views.
    ·  A DataSet is designed to work without any continuing connection to the original data source.
    ·  Data in a DataSet is bulk-loaded, rather than being loaded on demand.
    ·  There’s no concept of cursor types in a DataSet.
    ·  DataSets have no current record pointer You can use For Each loops to move through the data.
    ·  You can store many edits in a DataSet, and write them to the original data source in a single operation.
    ·  Though the DataSet is universal, other objects in ADO.NET come in different versions for different data sources.
16. What is the Global.asax used for?
    The Global.asax (including the Global.asax.cs file) is used to implement application and session level events.
17. What are the Application_Start and Session_Start subroutines used for?
    This is where you can set the specific variables for the Application and Session objects.
18. Can you explain what inheritance is and an example of when you might use it?
    When you want to inherit (use the functionality of) another class.  Example: With a base class named Employee, a Manager class could be derived from the Employee base class.
19. Whats an assembly?
    Assemblies are the building blocks of the .NET framework. Overview of assemblies from MSDN
20. Describe the difference between inline and code behind.
    Inline code written along side the html in a page. Code-behind is code written in a separate file and referenced by the .aspx page.
21. Explain what a diffgram is, and a good use for one?
    The DiffGram is one of the two XML formats that you can use to render DataSet object contents to XML.  A good use is reading database data to an XML file to be sent to a Web Service.
22. Whats MSIL, and why should my developers need an appreciation of it if at all?
    MSIL is the Microsoft Intermediate Language. All .NET compatible languages will get converted to MSIL.  MSIL also allows the .NET Framework to JIT compile the assembly on the installed computer.
23. Which method do you invoke on the DataAdapter control to load your generated dataset with data?
    The Fill() method.
24. Can you edit data in the Repeater control?
    No, it just reads the information from its data source.
25. Which template must you provide, in order to display data in a Repeater control?
    ItemTemplate.
26. How can you provide an alternating color scheme in a Repeater control?
    Use the AlternatingItemTemplate.
27. What property must you set, and what method must you call in your code, in order to bind the data from a data source to the Repeater control?
    You must set the DataSource property and call the DataBind method.
28. What base class do all Web Forms inherit from?
    The Page class.
29. Name two properties common in every validation control?
    ControlToValidate property and Text property.
30. Which property on a Combo Box do you set with a column name, prior to setting the DataSource, to display data in the combo box?
    DataTextField property.
31. Which control would you use if you needed to make sure the values in two different controls matched?
    CompareValidator control.
32. How many classes can a single .NET DLL contain?
    It can contain many classes.

Web Service Questions

1. What is the transport protocol you use to call a Web service?
   SOAP (Simple Object Access Protocol) is the preferred protocol.
2. True or False: A Web service can only be written in .NET?
   False
   
3. What does WSDL stand for?
   Web Services Description Language.
4. Where on the Internet would you look for Web services?
   http://www.uddi.org
5. True or False: To test a Web service you must create a Windows application or Web application to consume this service?
   False, the web service comes with a test page and it provides HTTP-GET method to test.

State Management Questions

1. What is ViewState?
   ViewState allows the state of objects (serializable) to be stored in a hidden field on the page.  ViewState is transported to the client and back to the server, and is not stored on the server or any other external source.  ViewState is used to retain the state of server-side objects between postabacks.
2. What is the lifespan for items stored in ViewState?
   Item stored in ViewState exist for the life of the current page.  This includes postbacks (to the same page).
3. What does the “EnableViewState” property do?  Why would I want it on or off?
   It allows the page to save the users input on a form across postbacks.  It saves the server-side values for a given control into ViewState, which is stored as a hidden value on the page before sending the page to the clients browser.  When the page is posted back to the server the server control is recreated with the state stored in viewstate.
4. What are the different types of Session state management options available with ASP.NET?
   ASP.NET provides In-Process and Out-of-Process state management.  In-Process stores the session in memory on the web server.  This requires the “sticky-server” (or no load-balancing) so that the user is always reconnected to the same web server.  Out-of-Process Session state management stores data in an external data source.  The external data source may be either a SQL Server or a State Server service.  Out-of-Process state management requires that all objects stored in session are serializable.

How would you retrieve the last inserted value in SQL Server?

@@IDENTITY is used to retrieve the last-inserted identity value in Sql Server.

What is the difference between a.Equals(b) and a == b?

a == b is used to compare the references of two objects

a.Equals(b) is used to compare two objects

Difference Between CONST & READONLY

what is the difference between user control an custom control? advantages/disadvantages?

Web user controls Vs Web custom controls
Easier to create Vs Harder to create
Limited support for consumers who use a visual design tool Vs Full visual design tool support for consumers
A separate copy of the control is required in each application Vs Only a single copy of the control is required, in the global assembly cache
Cannot be added to the Toolbox in Visual Studio Vs Can be added to the Toolbox in Visual Studio
Good for static layout Vs Good for dynamic layout

What is CLR?
CLR(Common Language Runtime) is the main resource of .Net Framework. it is collection of services like garbage collector, exception handler, jit compilers etc. with the CLR cross language integration is possible.

What is Delegate and what is it used for ?

http://searchvb.techtarget.com/vsnetTip/1,293823,sid8_gci916799_tax293034,00.html

Delegate is kind of like a pointer to a function in C++ or like an event handler in Java

You can use it to “multicast” which means running multiple functions in different instances of object already created.

This is useful when you want your objects to “register” to an event raised by another object.

The way it works is the object you are registered to listen to recieves the delegate of the function it is supposed to run in your object, the delegate is then run from it. (if you switch the word delegate for pointer, this would be much simpler)

What does the “EnableViewState” property do? Why would I want it on or off?

EnableViewState stores the current state of the page and the objects in it like text boxes, buttons, tables etc. So this helps not losing the state between the round trips between client and server. But this is a very expensive on browser. It delays rendering on the browser, so you should enable it only for the important fields/objects

What is the difference between Server.Transfer and Response.Redirect? Why would I choose one over the other?

Server.Transfer transfers the current context of the page to the next page and also avoids double roundtrips. Where as Response.Redirect could only pass querystring and also requires roundtrip.

How is .NET able to support multiple languages? –

A language should comply with the Common Language Runtime standard to become a .NET language. In .NET, code is compiled to Microsoft Intermediate Language (MSIL for short). This is called as Managed Code. This Managed code is run in .NET environment. So after compilation to this IL the language is not a barrier. A code can call or use a function written in another language.

Describe the difference between inline and code behind – which is best in a loosely coupled solution
Inline style is mixing the server side code and client side code (HTML and javascript) on the same page and run it. Where as codebehind is seperating the server side in a different page (enabling developers/coders to work) and leaving the client side code to do the presentation only (so designers would work on it). Inline code would be simplest way of approach because it doesn’t require any pre-compilation. But it is not good in many ways, i. You mix the presentation and server side code together so whenever there is a change it would be tough to maintain. ii. The event processing would be a night mare in inline code. iii. Since the codebehind needs to be compile in advance, it would be faster unline inline, which is interpreted per call basis. In a loosely couple situation, code-behind would be the best way to approach. Because it provides better performance.

Explain Assemblies?

Assembly is a single deployable unit that contains information about the implementation of classes, structures and interfaces. it also stores the information about itself called metadata and includes name and verison of the assembly, security information, information about the dependencies and the list of files that constitute the assembly.

Assembly also contains namespaces. In the .Net Framework, applications are deployed in the form of assemblies.

In what order do the events of an ASPX page execute. As a developer is it important to undertsand these events?

This is the order of Page events
i. Page_Init
ii.Page_LoadViewState
iii. Page_LoadPostData
iv. Page_Load
v. Page_RaisePostDataChanged
vi. Page_RaisePostBackEvent
vii. Page_PreRender
viii. Page_SaveViewState
ix. Page_Render
x. Page_Dispose
xii. Page_Error (this is caused whenever there is an exception at the page level).

Out of all the Page_Load is the one where your code gets loaded and your magic should be written. page_init occurs only once, i.e. when the page is initially created.

What base class do all Web Forms inherit from?

System.Web.UI.Page

what is shadowing ?
Overloading allows a subclass to add a new variation of a method. As long as the new variation has a different method signature, it can have the same name as an existing method on the base class. Shadowing, on the other hand, entirely replaces all variations of the method from the base class, leaving the subclass with only a single version of the method—the one we created through shadowing. Shadowing does not extend an interface, but rather replaces existing methods.

Overriding allows a subclass to alter or replace an existing method with the permission of the base class designer. Shadowing can be done without the permission of the base class designer, which is a risky proposition and one that requires extensive testing because the base class was never designed with such a thing in mind.

Also, as we discussed earlier, overriding uses virtual methods so the implementation of the method that is invoked is based on the data type of the underlying object, not the data type of the variable we’re using. When a method is shadowed it is not virtual, and it is the data type of the variable that dictates the implementation of the method that will be used. The data type of the underlying object is ignored.

Describe the difference between a Thread and a Process?

A thread is a path of execution that run on CPU, a proccess is a collection of threads that share the same virtual memory. A process have at least one thread of execution, and a thread always run in a process context.

“Process is unit of allocation while Thread is unit of execution. Each process has one or more threads. Each thread belong to one process”

What is strong-typing versus weak-typing? Which is preferred? Why?

Strong type is checking the types of variables as soon as possible, usually at compile time. While weak typing is delaying checking the types of the system as late as possible, usually to run-time. Which is preferred depends on what you want. For scripts & quick stuff you’ll usually want weak typing, because you want to write as much less (is this a correct way to use Ensligh?) code as possible. In big programs, strong typing can reduce errors at compile time.

What are PDBs? Where must they be located for debugging to work?

To debug precompiled components such as business objects and code-behind modules, you need to generate debug symbols. To do this, compile the components with the debug flags by using either Visual Studio .NET or a command line compiler such as Csc.exe (for Microsoft Visual C# .NET) or Vbc.exe (for Microsoft Visual Visual Basic .NET).

A program database (PDB) file holds debugging and project state information that allows incremental linking of a Debug configuration of your program.

The linker creates project.PDB, which contains debug information for the project’s EXE file. The project.PDB contains full debug information, including function prototypes, not just the type information found in VCx0.PDB. Both PDB files allow incremental updates.

What is FullTrust? Do GAC’ed assemblies have FullTrust?

Your code is allowed to do anything in the framework, meaning that all (.Net) permissions are granted. The GAC has FullTrust because it’s on the local HD, and that has FullTrust by default, you can change that using caspol

What is the difference between Debug.Write and Trace.Write? When should each be used?

The Debug.Write call won’t be compiled when the DEBUG symbol is not defined (when doing a release build). Trace.Write calls will be compiled. Debug.Write is for information you want only in debug builds, Trace.Write is for when you want it in release build as well. And in any case, you should use something like log4net because that is both faster and better

Debug.Write & Trace.write – both works in Debug mode, while in Release Mode,Trace.write only will work

What is the difference between a Debug and Release build? Is there a significant speed difference? Why or why not?

Debug build contain debug symbols and can be debugged while release build doesn’t contain debug symbols, doesn’t have [Contional(”DEBUG”)] methods calls compiled, can’t be debugged (easily, that is), less checking, etc. There should be a speed difference, because of disabling debug methods, reducing code size etc but that is not a guarantee (at least not a significant one)

Contrast the use of an abstract base class against an interface?

In the interface all methods must be abstract, in the abstract class some methods can be concrete. In the interface no accessibility modifiers are allowed, which is ok in abstract classes

What is boxing?

Boxing is an implicit conversion of a value type to the type object
int i = 123; // A value type
Object box = i // Boxing
Unboxing is an explicit conversion from the type object to a value type
int i = 123; // A value type
object box = i; // Boxing
int j = (int)box; // Unboxing

Is string a value type or a reference type?

String is Reference Type.
Value type – bool, byte, chat, decimal, double, enum , float, int, long, sbyte, short,strut, uint, ulong, ushort
Value types are stored in the Stack
Reference type – class, delegate, interface, object, string
Reference types are stored in the Heap

What is an interface and what is an abstract class? Please, expand by examples of using both. Explain why

1)In a interface class, all methods are abstract without implementation where as in an abstract class some methods we can define concrete. In interface, no accessibility modifiers are allowed. An abstract class may have accessibility modifiers. Interface and abstract class are basically a set of rules which u have to follow in case u r using them(inheriting them).

Abstract classes are closely related to interfaces. They are classes that cannot be instantiated, and are frequently either partially implemented, or not at all implemented. One key difference between abstract classes and interfaces is that a class may implement an unlimited number of interfaces, but may inherit from only one abstract (or any other kind of) class. A class that is derived from an abstract class may still implement interfaces. Abstract classes are useful when creating components because they allow you specify an invariant level of functionality in some methods, but leave the implementation of other methods until a specific implementation of that class is needed. They also version well, because if additional functionality is needed in derived classes, it can be added to the base class without breaking code.

1. How does output caching work in ASP.NET?
   Output caching is a powerful technique that increases request/response throughput by caching the content generated from dynamic pages. Output caching is enabled by default, but output from any given response is not cached unless explicit action is taken to make the response cacheable.

To make a response eligible for output caching, it must have a valid expiration/validation policy and public cache visibility. This can be done using either the low-level OutputCache API or the high-level @ OutputCache directive. When output caching is enabled, an output cache entry is created on the first GET request to the page. Subsequent GET or HEAD requests are served from the output cache entry until the cached request expires.

The output cache also supports variations of cached GET or POST name/value pairs.

The output cache respects the expiration and validation policies for pages. If a page is in the output cache and has been marked with an expiration policy that indicates that the page expires 60 minutes from the time it is cached, the page is removed from the output cache after 60 minutes. If another request is received after that time, the page code is executed and the page can be cached again. This type of expiration policy is called absolute expiration – a page is valid until a certain time.

1. What is serialization, how it works in .NET?

Serialization is when you persist the state of an object to a storage medium so an exact copy can be re-created at a later stage.

Serialization is used to save session state in ASP.NET.
Serialization is to copy objects to the Clipboard in Windows Forms
Serialization is used by remoting to pass objects by value from one application domain to another

What should one do to make class serializable?

To make a class serializable is to mark it with the Serializable attribute as follows.

[Serializable]
public class MyObject {
public int n1 = 0;
public int n2 = 0;
public String str = null;
}

What exactly is being serialized when you perform serialization?
The object’s state (values)

What is Viewstate?
A server control’s view state is the accumulation of all its property values. In order to preserve these values across HTTP requests, ASP.NET server controls use this property, which is an instance of the StateBag class, to store the property values.

Can any object be stored in a Viewstate?
An object that either is serializable or has a TypeConverter defined for it can be persisted in ViewState

What should you do to store an object in a Viewstate?
Do serialization of convert the object to string

Explain how Viewstate is being formed and how it’s stored on client.

The type of ViewState is System.Web.UI.StateBag, which is a dictionary that stores name/value pairs. ViewState is persisted to a string variable by the ASP.NET page framework and sent to the client and back as a hidden variable. Upon postback, the page framework parses the input string from the hidden variable and populates the ViewState property of each control. If a control uses ViewState for property data instead of a private field, that property automatically will be persisted across round trips to the client. (If a property is not persisted in ViewState, it is good practice to return its default value on postback.)

What do you know about ADO.NET’s objects and methods?

ADO.NET provides consistent access to data sources such as Microsoft SQL Server, as well as data sources exposed through OLE DB and XML.

Data-sharing consumer applications can use ADO.NET to connect to these different data sources and retrieve, manipulate, and update data.

ADO.NET provides first-class support for the disconnected, n-tier programming environment for which many new applications are written.

Explain DataSet.AcceptChanges and DataAdapter.Update methods?

DataAdapter.Update method Calls the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the DataSet.

DataSet.AcceptChanges method Commits all the changes made to this row since the last time AcceptChanges was called.

What are different methods of session maintenance in ASP.NET?

3 types:

In-process storage.
Session State Service.
Microsoft SQL Server.

In-Process Storage
The default location for session state storage is in the ASP.NET process itself.

Session State Service
As an alternative to using in-process storage for session state, ASP.NET provides the ASP.NET State Service. The State Service gives you an out-of-process alternative for storing session state that is not tied quite so closely to ASP.NET’s own process.

To use the State Service, you need to edit the sessionState element in your ASP.NET application’s web.config file:

You’ll also need to start the ASP.NET State Service on the computer that you specified in the stateConnectionString attribute. The .NET Framework installs this service, but by default it’s set to manual startup. If you’re going to depend on it for storing session state, you’ll want to change that to automatic startup by using the Services MMC plug-in in the Administrative Tools group.

If you make these changes, and then repeat the previous set of steps, you’ll see slightly different behavior: session state persists even if you recycle the ASP.NET process.

There are two main advantages to using the State Service. First, it is not running in the same process as ASP.NET, so a crash of ASP.NET will not destroy session information. Second, the stateConnectionString that’s used to locate the State Service includes the TCP/IP address of the service, which need not be running on the same computer as ASP.NET. This allows you to share state information across a web garden (multiple processors on the same computer) or even across a web farm (multiple servers running the application). With the default in-process storage, you can’t share state information between multiple instances of your application.

The major disadvantage of using the State Service is that it’s an external process, rather than part of ASP.NET. That means that reading and writing session state is slower than it would be if you kept the state in-process. And, of course, it’s one more process that you need to manage. As an example of the extra effort that this can entail, there is a bug in the initial release of the State Service that allows a determined attacker to crash the ASP.NET process remotely. If you’re using the State Service to store session state, you should install the patch from Microsoft Security Bulletin MS02-66, or install SP2 for the .NET Framework.

Microsoft SQL Server
The final choice for storing state information is to save it in a Microsoft SQL Server database. To use SQL Server for storing session state, you need to perform several setup steps:

Run the InstallSqlState.sql script on the Microsoft SQL Server where you intend to store session state. This script will create the necessary database and database objects. The .NET Framework installs this script in the same folder as its compilers and other tools–for example, C:\WINNT\Microsoft.NET\Framework\v1.0.3705 on a Windows 2000 computer with the 1.0 version of the Framework.
Edit the sessionState element in the web.config file for your ASP.NET application as follows:

Supply the server name, user name, and password for a SQL Server account that has access to the session state database in the sqlConnectionString attribute.
Like the State Service, SQL Server lets you share session state among the processors in a web garden or the servers in a web farm. But you also get the additional benefit of persistent storage. Even if the computer hosting SQL Server crashes and is restarted, the session state information will still be present in the database, and will be available as soon as the database is running again. That’s because SQL Server, being an industrial-strength database, is designed to log its operations and protect your data at (almost) all costs. If you’re willing to invest in SQL Server clustering, you can keep the session state data available transparently to ASP.NET even if the primary SQL Server computer crashes.

Like the State Service, SQL Server is slower than keeping session state in process. You also need to pay additional licensing fees to use SQL Server for session state in a production application. And, of course, you need to worry about SQL Server-specific threats such as the “Slammer” worm.

// yyyy/mm/dd pattern
^/d{4}(/)[0-9][1-9](/)[0-3][0-9]$

// mm/dd/yyyy format bt fails after entering exceed values for mm,dd
\d{1,2}/\d{1,2}/\d{2,4}

//for mm/dd/yyyy
(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20)\d\d\

//Working mm/dd/yyyy
((0[1-9]|[1-9])|1[012])/((0[1-9]|[1-9])|[12][0-9]|3[01])/(19|20)[0-9]{2}

// checks all validations for date

^((0?[13578]|10|12)(-|\/)(([1-9])|(0[1-9])|([12])([0-9]?)|(3[01]?))(-|\/)((19)([2-9])(\d{1})|(20)([01])(\d{1})|([8901])(\d{1}))|(0?[2469]|11)(-|\/)(([1-9])|(0[1-9])|([12])([0-9]?)|(3[0]?))(-|\/)((19)([2-9])(\d{1})|(20)([01])(\d{1})|([8901])(\d{1})))$

Step 1: In the page load in code behind file add an attribute to the treeview as:

If(!isPostBack)

{

TreeView1.Attributes.Add(“onclick”,”OnTreeClick(event)”);

}

Step 2: Put the below script in the head section of your .aspx page:

<script type=”text/javascript”>

function OnTreeClick(evt)

{

var src = window.event != window.undefined ? window.event.srcElement : evt.target;

var isChkBoxClick = (src.tagName.toLowerCase() == “input” && src.type == “checkbox”);

if(isChkBoxClick)

{

var parentTable = GetParentByTagName(“table”, src);

var nxtSibling = parentTable.nextSibling;

if(nxtSibling && nxtSibling.nodeType == 1)//check if nxt sibling is not null & is an element node

{

if(nxtSibling.tagName.toLowerCase() == “div”) //if node has children

{

//check or uncheck children at all levels

CheckUncheckChildren(parentTable.nextSibling, src.checked);

}

}

//check or uncheck parents at all levels

CheckUncheckParents(src, src.checked);

}

}

function CheckUncheckChildren(childContainer, check)

{

var childChkBoxes = childContainer.getElementsByTagName(“input”);

var childChkBoxCount = childChkBoxes.length;

for(var i = 0; i<childChkBoxCount; i++)

{

childChkBoxes[i].checked = check;

}

}

function CheckUncheckParents(srcChild, check)

{

var parentDiv = GetParentByTagName(“div”, srcChild);

var parentNodeTable = parentDiv.previousSibling;

if(parentNodeTable)

{

var checkUncheckSwitch;

if(check) //checkbox checked

{

var isAllSiblingsChecked = AreAllSiblingsChecked(srcChild);

if(isAllSiblingsChecked)

checkUncheckSwitch = true;

else

return; //do not need to check parent if any child is not checked

}

else //checkbox unchecked

{

checkUncheckSwitch = false;

}

var inpElemsInParentTable = parentNodeTable.getElementsByTagName(“input”);

if(inpElemsInParentTable.length > 0)

{

var parentNodeChkBox = inpElemsInParentTable[0];

parentNodeChkBox.checked = checkUncheckSwitch;

//do the same recursively

CheckUncheckParents(parentNodeChkBox, checkUncheckSwitch);

}

}

}

function AreAllSiblingsChecked(chkBox)

{

var parentDiv = GetParentByTagName(“div”, chkBox);

var childCount = parentDiv.childNodes.length;

for(var i=0; i<childCount; i++)

{

if(parentDiv.childNodes[i].nodeType == 1) //check if the child node is an element node

{

if(parentDiv.childNodes[i].tagName.toLowerCase() == “table”)

{

var prevChkBox = parentDiv.childNodes[i].getElementsByTagName(“input”)[0];

//if any of sibling nodes are not checked, return false

if(!prevChkBox.checked)

{

return false;

}

}

}

}

return true;

}

//utility function to get the container of an element by tagname

function GetParentByTagName(parentTagName, childElementObj)

{

var parent = childElementObj.parentNode;

while(parent.tagName.toLowerCase() != parentTagName.toLowerCase())

{

parent = parent.parentNode;

}

return parent;

}

</script>

//
//

RSS stands for “Really Simple Syndication”. It is a way to easily distribute a list of headlines, update notices, and sometimes content to a wide number of people. It is used by computer programs that organize those headlines and notices for easy reading.

Most people are interested in many websites whose content changes on an unpredictable schedule. Examples of such websites are news sites, community and religious organization information pages, product information pages, medical websites, and weblogs. Repeatedly checking each website to see if there is any new content can be very tedious.

Email notification of changes was an early solution to this problem. Unfortunately, when you receive email notifications from multiple websites they are usually disorganized and can get overwhelming, and are often mistaken for spam.

RSS is a better way to be notified of new and changed content. Notifications of changes to multiple websites are handled easily, and the results are presented to you well organized and distinct from email.

RSS works by having the website author maintain a list of notifications on their website in a standard way. This list of notifications is called an “RSS Feed“. People who are interested in finding out the latest headlines or changes can check this list. Special computer programs called “RSS aggregators” have been developed that automatically access the RSS feeds of websites you care about on your behalf and organize the results for you. (RSS feeds and aggregators are also sometimes called “RSS Channels” and “RSS Readers“.)

Producing an RSS feed is very simple and hundreds of thousands of websites now provide this feature, including major news organizations like the New York Times, the BBC, and Reuters, as well as many weblogs.

RSS provides very basic information to do its notification. It is made up of a list of items presented in order from newest to oldest. Each item usually consists of a simple title describing the item along with a more complete description and a link to a web page with the actual information being described. Sometimes this description is the full information you want to read (such as the content of a weblog post) and sometimes it is just a summary.

For example, the RSS information for headlines on a local news website could contain the following information:

Item 1:
Title:	Sidewalk contract awarded
Description:	The city awarded the sidewalk contract to Smith Associates. This hotly contested deal is worth $1.2 million.
Link:	http://www.gardencitynews.com/contractawards/sidewalk.htm
Item 2:
Title:	Governor to visit
Description:	The governor is scheduled to visit the city on July 1st. This is the first visit since the election two years ago. The mayor is planning a big reception.
Link:	http://www.gardencitynews.com/news/2004/06/gov-visit.htm

The RSS information is placed into a single file on a website in a manner similar to normal web pages. However, the information is coded in the XML computer language for use by a program (the RSS aggregator) and not by a person like a normal web page.

Think of an RSS aggregator as just a web browser for RSS content. RSS aggregators automatically check a series of RSS feeds for new items on an ongoing basis, making it is possible to keep track of changes to multiple websites without needing to tediously read and re-read each of the websites yourself. They detect the additions and present them all together to you in a compact and useful manner. If the title and description of an item are of interest, the link can be used to quickly bring the related web page up for reading.

Here is a screen shot of an RSS aggregator in action. On the left is a list of the RSS feeds being monitored, along with an indication of the number of unread items in each feed in parenthesis. On the right are the details of the most recent items in a selected RSS feed (in this case, the New York Times).

There are many RSS aggregators available. Some are accessed through a browser, some are integrated into email programs, and some run as a standalone application on your personal computer.

It is getting more and more common for websites to have RSS feeds. They usually indicate the existence of the feed on the home page or main news page with a link to “RSS”, or sometimes by displaying an orange button with the letters “XML” or “RSS”. RSS feeds are also often found via a “Syndicate This” link. Text “RSS” links sometimes (there are lots of variations) point to a web page explaining the nature of the RSS feeds provided and how to find them. The buttons are often linked directly to the RSS feed file itself.

Once you know the URL of an RSS feed, you can provide that address to an RSS aggregator program and have the aggregator monitor the feed for you. Many RSS aggregators come preconfigured with a list to choose from of RSS feed URLs for popular news websites.

Unless you are maintaining a website or want to create your own RSS feed for some other purpose, how the RSS feed is produced should not be of concern and you may skip this section.

The special XML-format file that makes up an RSS feed is usually created in one of a variety of ways.

Most large news websites and most weblogs are maintained using special “content management” programs. Authors add their stories and postings to the website by interacting with those programs and then use the program’s “publish” facility to create the HTML files that make up the website. Those programs often also can update the RSS feed XML file at the same time, adding an item referring to the new story or post, and removing less recent items. Blog creation tools like Blogger, LiveJournal, Movable Type, and Radio automatically create feeds.

Websites that are produced in a more custom manner, such as with Macromedia Dreamweaver or a simple text editor, usually do not automatically create RSS feeds. Authors of such websites either maintain the XML files by hand, just as they do the website itself, or use a tool such as Software Garden, Inc.’s ListGarden program to maintain it. There are also services that periodically read requested websites themselves and try to automatically determine changes (this is most reliable for websites with a somewhat regular news-like format), or that let you create RSS feed XML files that are hosted by that service provider.

Here is a diagram showing how the websites, the RSS feed XML files, and your personal computer are connected:

The diagram shows a web browser being used to read first Web Site 1 over the Internet and then Web Site 2. It also shows the RSS feed XML files for both websites being monitored simultaneously by an RSS Feed Aggregator.

In addition to notifying you about news headlines and changes to websites, RSS can be used for many other purposes. There does not even have to be a web page associated with the items listed — sometimes all the information you need may be in the titles and descriptions themselves.

Some commonly mentioned uses are:

• Notification of the arrival of new products in a store
• Listing and notifying you of newsletter issues, including email newsletters
• Weather and other alerts of changing conditions
• Notification of additions of new items to a database, or new members to a group

One RSS aggregator is all that you need to read all of the RSS feeds, be they headlines, alerts, changes, or other notifications. RSS is shaping up to be a very popular and useful means for communicating.

//
//

Creating and maintaining a Web application can be a complex task. DotNetNuke does an exceptional job of hiding this complexity. Its detailed on-line help, open source samples, and sensible defaults assist developers and administrators in installing, administrating, and using the Web Application Framework. Extensibility pervades all aspects of the core architecture, providing nearly unlimited opportunities to extend the base application.

Perhaps the greatest strength of DotNetNuke is the community that has grown around the project. Both developers and users participate in DotNetNuke’s active discussion forums, where they share tips, announce new developments, help new users, share resources, and debate new ideas. DotNetNuke’s low barrier on entry, flexibility, and ease of use helps bring powerful Web application technology within the reach of those with limited technical and financial resources. DotNetNuke is an excellent example of how and why the open source model works.

The Future
The DotNetNuke project has been restructured recently to separate the modules from the core application. This separation allows the modules to form their own open source project teams that can manage the functionality and provide enhancements on their own release cycle. This should result in more frequent release schedules, better community support, and more innovative features.

Microsoft has recently launched their new ASP.NET 2.0 platform on November 7, 2005. One of DotNetNuke’s traditional strengths has been its ability to “bring the power to the people” – showcasing cutting-edge technology in an open format that is easy to understand and leverage in real-world environments. Our current plans are to release a new version of DotNetNuke for ASP.NET 2.0 in conjunction with Microsoft’s platform launch.

//
//

Every Web site needs to have the ability to customize its appearance, a term often referred to as “skinning.” The level of customization depends on the needs of the individual client, but in general, any restrictions on creative freedom may be considered to be serious deficiencies in the eyes of the Web design community. Some Web Application Frameworks limit you to static layouts, others claim to have customization through cascading style sheets (or themes). The optimal skinning architecture abstracts the Web application details from the Web designer, thereby allowing them to replicate the visual appeal of a static Web site in a fully functional Web site.

Perhaps the most powerful feature in DotNetNuke is its flexible skinning engine. The base architecture evolved from a realization that the needs of Web developers are much different from those of Web designers. Web developers are comfortable with Integrated Development Environments (IDE), which generally have powerful debuggers and syntax validators but extremely limited design features. Conversely, Web designers are proficent in a wide array of creative applications that provide expert design features, but extremely limited programming support. In order to actively engage the Web design community, DotNetNuke provides an architecture that provides the cleanest abstraction of these two philosophies and maximum flexibility for Web design elements.

With a constant focus on simplicity, a DotNetNuke skin is developed as a standard HTML document (a classic Web page). Each area in the Web page that requires interaction with the underlying Web application is specified as a token (i.e., [MENU], [LOGIN], [REGISTER], etc.). Once the skin is fully designed, it is then packaged as a standard ZIP file which allows for maximum portability. The ZIP file contains the HTML document, its related graphical images, styles sheets, and other related resources. When the skin package is deployed into a DotNetNuke application, the HTML document is parsed and an ASP.NET User Control (*.ascx) is created. This User Control represents the compiled version of the skin that integrates seamlessly with the underlying Web Application Framework. Skins can be applied to a site at run time by administrators using the Skins option in the admin menu.

Moving beyond Web design customization, there is also an extensibility requirement in terms of Web site functionality. As mentioned earlier, DotNetNuke has a concept of mini-applications known as modules. Modules are not simply “dashboard” components that display relatively static information in the Web browser. Rather, they can include an unlimited number of interactive user interfaces and views, empowering developers to create highly functional and intuitive Web site components. Modules are created as standard ASP.NET user controls that can then be packaged, distributed, and deployed directly into the run-time environment. The module architecture is based on the classic Model-View-Controller (MVC) pattern that has become ubiquitous with enterprise Web application development on all platforms.

In terms of module availability, DotNetNuke provides a variety of highly functional modules, including Announcements, Events, Forums, and Blogs, which are managed in an official capacity by the open source contributor community. In addition, there are hundreds of third-party modules available, both free and commercial, which can be acquired from various resellers and resource sites. This active ecosystem is one of the primary reasons for DotNetNuke’s exponential growth and sustained momentum.

DotNetNuke’s world-wide popularity could also be attributed to the fact that it is has powerful localization architecture. Similar to the plug-in model for skins and modules, each language pack is a single ZIP file wrapping a series of resource (RESX) files that contain the localized values for all static text in the application. Switching languages is done easily through the admin menu option for Languages. DotNetNuke takes flexibility a step further by making it possible for an administrator to customize the localized text to suit their specific needs. For example, if you want to change the word “Log In” to “Sign In,” it can be changed in the associated resource file. The terms in the language pack can all be edited directly in the administrator area of the Web site.

//
//

After you create the page, you will see a WYSIWYG representation of the page in your browser that contains a number of empty content regions. Since you are logged in as the administrator, you will be able to add content modules to the page by selecting the appropriate options from the controls in the center of the control panel and selecting the Add Module icon.

Once a module has been added to a page, you will need to add some content for the module. Hovering your cursor over the drop-down arrow icon next to the module title will display a pop-up module actions menu. This menu contains a variety of options that you can use to manage module content. To add new content to a module, select the top item in the list (Edit Text in the case of the HTML/Text module). This will display an edit-user interface that is specific to the module.

//
//

A Web Application Framework is a robust software library used as the basis for building advanced Web applications. A Web Application Framework typically contains a well-defined architecture and an abstract set of reusable components that are specifically designed to simplify development, enforce consistency, increase productivity, and improve application quality. Typical features include modular architecture, membership management, security and role management, site organization and navigation, error and event logging, data access and caching, search and syndication, and extensibility at every level. Frameworks are used in corporations, public sector, private sector, small businesses, nonprofit organizations, and even individual Web sites.

Although the concept has always been relevant, Web Application Frameworks have just come back into favor in recent years. This is likely a result of the ever-pervasive basic business philosophy emphasizing a reduction in the Total Cost of Ownership and increase in the Return On Investment. Web Application Frameworks can provide big wins in both of these categories because they allow developers to focus on the high-level business processes while leveraging a rock-solid application foundation.

DotNetNuke is a Web Application Framework that provides a highly extensible development environment, based on published standards and proven design patterns. Since Web Application Frameworks are generic by nature, they can be used as the underpinnings for any number of powerful Web applications. From Community Portals to high volume E-Commerce shopping malls, from Content Management Systems (CMS) to Customer Relationship Management Systems (CRM), the DotNetNuke Web Application Framework provides the fundamental services to build highly functional and scalable Web applications. To back up this claim, the DotNetNuke Web Application Framework is distributed as part of a fully functional CMS – the DotNetNuke Enterprise Portal.

A single DotNetNuke installation can host an unlimited number of portal Web sites, each with its own distinct URL. Each Web site is managed by one or more administrators. Portals can contain a variety of content, including announcements, events, discussion forums, links, images, surveys, galleries, directories, shopping carts, and many other features, all comparable to those available in proprietary content management systems.

DotNetNuke is developed on the powerful Microsoft .NET platform – Windows server, IIS, SQL Server 2000, and ASP.NET (VB and C#). Part of DotNetNuke’s attraction is it can run on almost any database server, as long as someone has created the necessary provider (third-party providers include Oracle and mySQL). The flexible technical requirements make it possible to install and evaluate DotNetNuke on almost any computer. Its primary deployment scenario is to shared Web servers managed by Web hosting providers. However, it can also be deployed to dedicated Web servers and Intranets, where the administrator has much more control of the environment.

DotNetNuke is offered under a nonrestrictive BSD License, a standard open source license that allows for full usage in both commercial and noncommercial environments. The BSD, well-documented ASP.NET source code, an active developer community, and a modular architecture make it possible to customize DotNetNuke and leverage it as a mature Web Application Framework. For end users, all DotNetNuke requires is a Web browser and an Internet connection.

DotNetNuke provides the ability to manage content at a granular level. Essentially this means that a virtual page in DotNetNuke is simply a generic container that contains various content regions. Management of each type of content region is exposed through mini-applications referred to as Modules. Modules provide expert features for the display, configuration, and administration of specific types of content. For example, there are simple modules such as the Text/HTML module, which are designed to manage the display and administration of basic content information. There are also powerful modules such as the Forums module, which is designed to manage a full-featured community discussion forum. A page can contain an unlimited number of content modules, and a content module can be exposed on an unlimited number of Web site pages. This model is superior to other Web Application Frameworks that limit you to hard-linking content information directly to a single site page or that only allow a single type of content to be managed on a page.

The DotNetNuke name comes from a long history of open source content management systems that have adopted “nuke” as part of their project identity (the original credit belongs to Francisco Burzi, the creator of PHP-Nuke).

Installation and Configuration
At the time of this writing, the latest stable release of DotNetNuke is version 3.1.1, which was released on August 11, 2005. This release is compatible with the ASP.NET 1.1 platform. If you are interested in experimenting with the latest features, you can also check the downloads area on the www.dotnetnuke.com Web site for newer builds.

Installing DotNetNuke on a Microsoft Windows Server system (2000 or 2003) is straightforward and well documented. After unpacking the downloaded ZIP package, place all files and folders into your Web server’s root directory. Create an SQL Server 2000 database and user account. DotNetNuke stores some files, such as user-uploaded images, in a special home directory for each portal. This directory should have write access enabled or else you are not going to be able to take advantage of all of the application features.

The default IIS settings on most Web servers should be adequate. DotNetNuke does not require session support, nor does it require custom mappings for specific file types or error codes. By default, the DotNetNuke application runs in a medium-trust Code Access Security configuration, which provides some critical security safeguards, especially for Web hosting providers.

A single file, web.config, stores the basic configuration settings, such as the database connection information, encryption keys, and provider configuration. Make a copy of the release.config file provided by DotNetNuke, name it web.config, and edit it using your favorite text editor. This thoughtful arrangement is especially useful when you upgrade DotNetNuke. DotNetNuke’s release.config is upgraded, but your original web.config, which contains settings specific to your installation, is left untouched. The only value that typically needs to be modified on a new installation is the SiteSqlServer connection string in the AppSettings node. On an upgrade, it is also critical that you preserve your localized MachineValidationKey and MachineDecryptionKey values.

Next, visit the main page of your DotNetNuk Web site with a Web browser. From this point on, DotNetNuke handles its own installation and configuration, setting up the database, modules, and skins automatically. The default settings should work to get you started, and you always can customize them later. A Web site is created based on the values stored in the default template, which includes both an Administrator and Host user account. Since these accounts are common across all DotNetNuke installations, it is critical that you change the default passwords fot these accounts immediately upon successful installation.

Once DotNetNuke is installed, almost all regular administrative activities can be carried out using a Web browser. When logged in as the administrator, an admin menu appears as the right-most node in the hierarchical menu control . In addition, a control panel is displayed at the top of the browser window that allows the administrator to manage various aspects of the DotNetNuke site using a Web browser.

The Site Settings option controls the basic operation of the DotNetNuke site. In most cases, the default settings for most administrative functions should work fine. The Pages option allows you manage all of the virtual pages in your site. Security Roles and User Accounts enable you to manage the membership