Introduction

In many cases, we need to use some data string throughout
the application, database connection string is the best
example of it. Instead of writing the connection string
wherever we are creating a connection, its good practice
(and easy to maintain too) to store it into web.config file
and get it at desired place.

Places to store data into Web.Config file

There are two places where we can store data into our
web.config file. These are appSettings and
connectionStrings. Following is the code snippet from the
web.config file where we can store data and retrieve at
later point of time.

<configuration>

<appSettings>

<add key="ConnStr" value="Data
Source=.\SQLEXPRESS;AttachDbFilename=C:\MyData\App_Data\Database.mdf;Integrated
Security=True;User Instance=True"/>

</appSettings>

<connectionStrings>

<add name="ConnStr" connectionString="Data
Source=.\SQLEXPRESS;AttachDbFilename=C:\MyData\App_Data\Database.mdf;Integrated
Security=True;User Instance=True"/>

</connectionStrings>

</configuration>

 

Here appSettings is meant for any data string that can be
stored while connectionString is meant for storing the
database connection strings only.

 
How to Get data from Web.Config

Getting data from web.config file is simple. If you want to
get data from appSettings tag then you need to write
following code

string connStr =
System.Configuration.ConfigurationManager.AppSettings["ConnStr"].ToString();

To get data from web.config file stored under
connectionStrings tag, you need to write following code

string connStr =
System.Configuration.ConfigurationManager.ConnectionStrings["ConnStr"].ToString();

 
Getting connectionStrings value into .aspx page

If for some reason you want to access the string stored in
connectionStrings tag into .aspx page (You may need this
while using SqlDataSource control), you need to write
following code (Notice the code in the pink color <%$
ConnectionStrings:ConnStr %>).

<asp:SqlDataSource ID="SqlDataSource1" runat="server"
ConnectionString='<%$ ConnectionStrings:ConnStr %>'

SelectCommand="Select * FROM SampleForTutorials ORDER BY
[Name]" DataSourceMode="DataSet">

</asp:SqlDataSource>

 
Conclusion

Web.Config file is the best place to store small and simple
string that can be used throught the application. Using
System.Configuration.ConfigurationManager class that exists
in System.Configuration namespace, we can retrive them
wherever we need.

 both section are used for describing database strings and
values .This is used throughout our project if we using web
applications. 

when we want to implement multiple inheritance in c# then 
we use these keyword.inteface means purly abstract class

Interface is Implements but never create instant of object

When u create an interface then u can delclare with Public 
Key word.Like

Public Interface WorkOrder
{
  //Decleare Method here.
}

When a form is submitted in classic ASP, all form values are
cleared. Suppose you have submitted a form with a lot of
information and the server comes back with an error. You
will have to go back to the form and correct the
information. You click the back button, and what
happens.......ALL form values are CLEARED, and you will have
to start all over again! The site did not maintain your
ViewState.

When a form is submitted in ASP .NET, the form reappears in
the browser window together with all form values. How come?
This is because ASP .NET maintains your ViewState. The
ViewState indicates the status of the page when submitted to
the server. The status is defined through a hidden field
placed on each page with a <form runat="server"> control.
The source could look something like this:

<form name="_ctl0" method="post" action="page.aspx" id="_ctl0">
<input type="hidden" name="__VIEWSTATE"
value="dDwtNTI0ODU5MDE1Ozs+ZBCF2ryjMpeVgUrY2eTj79HNl4Q=" />

.....some code

</form>

View State is nothing but to store peace of information 
in the form of hidden field

Yes. It is Possible For Whole Page is Saved In View State

static variables can access using this keyword. and the 
normal variables can access the static variables using 
class.variable_name.

readonly variables are can be initilized at compile time
but we can assign values to readonly varialble at once 
through functions or constructors

but in case of constant variables once assign a value we 
can't change value and must assign value to constant 
variables at the time of declarition

I am adding another point to the above answer.

as the constant variable is constant over the class,that 
means,all the objects created for that class have the same 
value.
but in case of readonly variables,we can assign different 
values in the different instances of the class it contains.

readonly is compile time constant.
constant is runtime constant.

constatnt field is used to initialize at the declaration of 
the field.
readonly field is used at the declaration or constructor of 
the field.

if the AutoEventWireup="true" propety in dropdown when 
index changed automatically post back to the server.

if the AutoEventWireup="true" propety in dropdown when 
index changed will not  post back to the server.

When you set the value of the AutoEventWireup attribute to 
false, you must manually hook up events to event handlers. 
such as Page_Load() etc.

When you set the value of the AutoEventWireup attribute to 
true, the ASP.NET page framework can automatically raise 
events.
such as Page_Load() etc.

Sorry in the above example is small mistake 


if the AutoEventWireup="true" propety in dropdown when 
index changed automatically post back to the server.

if the AutoEventWireup="false" propety in dropdown when 
index changed will not  post back to the server.

I guess what you mean is AutoPostBack="true" in which the 
index change of a drop down box will be posted back to 
server.
Please correct me if I am wrong.

To know the difference between autoEventWireup="true" and 
autoEventWireup="false" please refer the below link:

http://support.microsoft.com/kb/324151

Regards,
Meganadha Reddy K.

When you set the value of the AutoEventWireup attribute to 
false, you must manually hook up events to event handlers. 

When you set the value of the AutoEventWireup attribute to 
true, the ASP.NET page framework can automatically raise 
events.

The default value for AutoEventWireup is true for a C# web 
form, and false for a VB.NET web form. The IDE adds the 
default values to the @ Page directive for a new web form. 
The difference in defaults is partly because VB.NET has a 
mechanism for defining an event handler and subscribing to 
an event in one graceful motion (the Handles keyword). 


Protected Sub Page_Load(ByVal sender As Object, _
                        ByVal e As System.EventArgs) _
                        Handles Me.Load
    ' ...

End Sub


An easy way to generate the above code is to use the drop 
down controls that sit just above the editor. Note: C# 
doesn t make the dropdown list of events available when 
editing a code-beside file, but the dropdown is available 
when writing in-line code. 

There is no equivalent to the Handles keyword in C# 
(anonymous event handlers are arguably close, but just not 
the same). When AutoEventWireup is true, all we need to do 
is follow the method naming convention of 
Page_EventToHandle. The ASP.NET runtime will automatically 
find and fire the method for the appropriate event. 


protected void Page_Load(object sender, EventArgs e)
{

}


Once Again, In Reverse
If we switch to AutoEventWireup= true  for a VB.NET web 
form, we can use the magic Page_EventName approach. The 
only change to the earlier VB.NET code would be to drop the 
Handles clause, and the events fire correctly. 

If we switch to AutoEventWireup= false  for a C# web form, 
there is a little extra work to do. Somewhere we need to 
explicitly wire up events. Here is one approach. 


public partial class _Default : Page
{
   public _Default() // ctor
   {
      Load += new EventHandler(Page_Load);
      PreInit += new EventHandler(Page_PreInit);         
   }

    protected void Page_Load(object sender, EventArgs e)
    {
       // ...
    }

   protected void Page_PreInit(object sender, EventArgs e)
   {
      // ...
   }
}

First of all the above answer that default value for auto
eventwireup=true is false bcoz the default value of
autoeventwireup=false in c#

A false value indicates that you must explicitly write a
code to bind events related to a page ,such as the load
event of a page

and true value indicates that events will be generated
automatically

here is the proper valid answer
AutoEventWireup attribute
AutoEventWireup is a Boolean attribute that indicates
whether events of a Web Forms page are autowired.The default
value for AutoEventWireup is TRUE.

In Visual Basic .NET or in Visual Basic 2005, the designer
performs this binding using the Handles keyword in the
declaration of the event-handler method.
Private Sub Page_Load(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles MyBase.Load

The ASP.NET page framework supports an alternative mechanism
that uses the AutoEventWireup attribute of a Web Forms page
to automatically associate page events and event-handler
methods. If the AutoEventWireup attribute of the @ Page
directive is set to TRUE (or if it is not specified because
its default value is TRUE), the ASP.NET page framework
automatically calls page event-handler methods.

For example, the Page_Init and Page_Load event-handler
methods are explicitly called by the ASP.NET page framework,
without using the Handles keyword or an explicit event delegate.

Conclusion
When you explicitly set AutoEventWireup to TRUE, Visual
Studio .NET or Visual Studio 2005, by default, generates
code to bind events to their event-handler methods. At the
same time, the ASP.NET page framework automatically calls
the event-handler methods based on their predefined names.

Dont read all the those things simply understand

actually AutoEventWireup is written in page directive like 
this 

<%@ Page Language="C#" AutoEventWireup="true" 
CodeFile="Default2.aspx.cs" Inherits="Default2" %>

by default it is "true", that means all the events that are 
automatically rises when page is loading


if AutoeventWireUp=false then we have to manually write 
events and delegates  like this




 public _Default() // ctor
   {
      Load += new EventHandler(Page_Load);
      PreInit += new EventHandler(Page_PreInit);         
   }

    protected void Page_Load(object sender, EventArgs e)
    {
       // ...
    }

   protected void Page_PreInit(object sender, EventArgs e)
   {
      // ...
   }

You can call in header section with following code.
<script src="myJavaScript.js" 
type="text/javascript"></script>

Assuming the following directory structure:

~/Sample/project.html
~/Check/verify.js

to use the javascript file in project.html insert the below 
code between the <head> and </head>:

<script src="../Check/verify.js" type="text/javascript">
</script>

make the adodc connection with database from its property
connection string & connect datagrid with adodc & write the code


  adodc_.recordsource = "select * from table name"
  datagrid.refresh
  adodc.refresh

make sure that dropdownlist is there in the webform

Even i tried with that even it's saying the same error.

though u have the control in the web form some times is
shows like that onle,
the solutions is u better delete the control and add it
again u will get it

if (!IsPostBack)
        {
            ArrayList books=new ArrayList();
            books.Add("gone with the wind");
            books.Add("rahulsriramprakash");
            books.Add("vishal");
            dropdowndisplay.DataSource = books;
            dropdowndisplay.DataBind();
        }

page_render(): Outputs content of a page to a provided
HtmlTextWriter object and stores tracing information about
the control if tracing is enabled.

page_prerender(): Occurs when a page is about to render its
content
page_unload():occurs when a page is unloaded from memory
page_loadcomplete():Raises the load event
page_preinit():raises the init event

set of rules for programmers to write set of instructions 
to program. there are few famous in-use practices available 
like singleton and design patterns have their own 
advantages and disadvantages.

Creational, Structural and behavioral patterns are the .net
design patters.

In this method we dont have standard design document which 
describes the business objects and business 
interfaces.Based on the requirements codes are written 
without refering any high level design documents.