Why does VS.NET use codebehind?

[Graham Allwood]

I'm reading the Essential ASP.NET book by Fritz onion and he says that when
VS.NET creates a new .aspx page for you is uses the codebehind attribute on
the Page directive rather than the src attribute. From what I understand the
src attrib is standard ASP.NET but the codebehind attribute is only
understood by VS.NET. Doesn't this make the pages (source code) less
portable? Is there any reason for this?


Hope someone can help.

Graham

 

[Saravana]

In Web Forms that use code-behind files, the @ Page directive (or @ Control
in user control files) contains attributes that specify the relationship of
the .aspx file and its code-behind file. These attribute are:

a.. Codebehind In Visual Studio, this attribute references the name of a
file that contains the class for the page. For example, if you create a Web
Forms page in Visual Studio called WebForm1, the Codebehind attribute will
point to WebForm1.aspx.vb or WebForm1.aspx.cs. This attribute is used only
by the Visual Studio Web Forms Designer. It tells the designer where to find
the page class so that the designer can create an instance of it for you to
work with. The attribute is not used at run time.
b.. Inherits Identifies the class from which the page derives. In Visual
Studio, this points to a class in the project assembly (.dll), as shown in
the diagram above.
The code-behind model illustrated above is the model used by Visual Studio.
The ASP.NET Framework supports a slightly different code-behind model for
Web Forms pages. In the ASP.NET code-behind model, the visual elements are
in an .aspx file and the code is in a separate code-only file, as in Visual
Studio. However, there is no project, and the code is not pre-compiled.
Instead, the code in the .vb or .cs file is compiled at run time, when the
page is first requested by a user.

The inheritance model works as illustrated above, with the difference that
the Web Forms class (WebForm1 class in the diagram) is not part of a project
assembly. Instead, each page is a separate assembly. There is no difference
in how your code runs in the two models.

In the ASP.NET code-behind model, there is no Codebehind page attribute,
since that attribute is unique to Visual Studio. To tie the .aspx file to
its corresponding code, the page directive contains a Src attribute, which
references the file containing the source code for the file.

The Src attribute is not supported in Visual Studio. If you import a Web
Forms page into Visual Studio that contains the Src attribute, the designer
will raise an error.



For more details refer this link

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vbcon/html/
vbconWebFormsCodeModel.asp

 

[Kevin Spencer]

Your understanding is not entirely correct. The "Src" attribute is only used
when the CodeBehind page is NOT compiled, and the CodeBehind code is in a
separate file than the Page Template. It can't be used when the CodeBehind
page is compiled into a DLL, or the source code is in the same file as the
Page Template. It is similar in this respect to the "src" attribute of a
JavaScript which uses an external .js file. The "CodeBehind" attribute is
used by Visual Studio to identify the file being used during development, as
there may not BE a "Src" attribute (because the codebehind is compiled, or
because the CodeBehind may be in the same file as the Page Template). As for
making the source code "less portable," what is that supposed to mean?

--
HTH,

Kevin Spencer
Microsoft MVP
..Net Developer
http://www.takempis.com
Big things are made up of
lots of little things.