இவற்றிற்கான களஞ்சியம் 'ASP/ ASP.NET' வகை

Jun 25 2006


.NET vs J2EE

Filed under ASP/ ASP.NET

இவை இரண்டுமே ஒரு விடையத்தில் பொதுவானவை. இரண்டுமே programming language அல்ல. ஆனால் இரண்டுமே programming பண்ணுவதற்கு தேவையான விதிமுறைகளைக் கொண்டவை. அதாவது ஒரு framework என்று சொல்வார்கள். தூணைக் கட்ட முன் கம்பிப் பிணைப்பை வைப்பார்களே அதே போல் தான்.

சரி அந்த கம்பிப் பிணைப்பை வைத்த பின் cement போடுவது போல் தான் இந்த framework இக்குள் எழுதப்படும் programming language. இவ் விதிகள் யாவும் ஒரு மென்பொருளை உருவாக்குவதற்கு உதவும்.சில பொது விதிகளை உருவாக்கி, மேலதிக உதவி மென்பொருள் கோப்புக்களையும் உருவாக்கி, இப்படியான மேலதிக உதவி மென்பொருள் கோப்புகளை எப்படி பாவிக்க வேண்டும் என்று விதிகளை உருவாக்கி, எப்படி பெயரிட வேண்டும் என்று விதிகள் இட்டு, எப்படி மென்பொருள்களுக்கிடையே தகவல் பரிமாறப்பட வேண்டும் என்று வரையறுத்து மேலும் இவ்வாறான பல விதிமுறைகளுடன் ஒட்டுமொத்த விதிமுறைகளே இந்த frameword. இப்படியான விதிமுறைகள் தான் தற்போதைய நவீன மென்பொருள் தயாரிப்பிற்கும், பிறகு அதைப் பேணிப் பாதுகாத்து மேலும் பல செயற்பாடுகளை சேர்பதற்கும், பிழைகளை திருத்திக் கொள்வதற்கும் இலகுவாக வழி வகுக்கின்றன.

J2EE தனது programming language ஆக JAVA ஐ உபயோகிக்க வேண்டுகிறது. JAVA அதற்கே உரிய plateform independent சலுகை உடையது. அதாவது எந்த கணினி தளத்திலும் [OS] JAVA மென்பொருட்கள் வேலைசெய்யக் கூடியவை. JAVA வில் மென்பொருள் செய்து அதை compile பண்ணினால் அது நீங்கள் எழுதிய code அத்தனையையும் அந்த கணினிக்கு ஏற்றவாறு மாற்றுவதில்லை. மாறாக, கணினிக்கு சற்று மேல் தர மொழிக்கு மாற்றும் [assembly code]. JAVA இதை தனக்கு மட்டும் விளங்கிக் கொள்ள ஏற்பவாரு எழுதும் [bytecode]. இதை நீங்கள், கணினி தள [OS] முக்கியத்துவம் இன்றி, எந்த கணினியிலும் ஏற்றி மென்பொருளை இயக்கலாம். JAVA மென்பொருளை எந்த ஒரு கணினியிலும் வேலை செய்ய வைக்க அந்தக் கணினியில் JIT [Just In Time] Compiler மட்டுமே இருந்தால் போதுமானது. JAVA தனது சக படைப்புக்களான JAVA beans, JAVA servlets, JAVA applets என்று எல்லாவற்றையும் ஒருங்கிணைக்கிறது இந்த J2EE மூலம்.

J2EE என்பது ஒரு மிகப் பெரிய அளவில் செய்யப்படும் மென்பொருளுக்கு ஏற்ப விதிகள். ஒரு சிறிய அளவிலான மென்பொருளென்றால் J2SE என்ற விதிகளையும், அதையே ஒரு செல்பேசியிற்கு செய்வதென்றால் J2ME என்ற விதிகளையும் பின்பற்ற வேண்டும் என்று ஒரு கோட்பாடு விதித்திருக்கிறார்கள்.

Microsoft, எப்போதுமே எதையும் முதலில் செய்தது கிடையாது. சந்தையில் எது நன்றாக விற்பனை ஆகிறது என்று ஆற அமர பார்த்துவிட்டு அதை தானும் செய்து வெளியிடுவார்கள். Internet Explorer [Netscape இற்குப் பின்பு], Windows NT [Novell இற்குப் பின்பு] என்று பலதைச் சொல்லலாம்.

இந்த வகையில், J2EE இன் வெற்றிக்குப் பின் தனது தாயாரிப்பான .NET ஐ வெளியிட்டுள்ளது. காப்பி அடித்தாலும், அவர்களுக்கே உரிய பாணியில், மேலும் அதற்கு மெருகேற்றி தங்கள் கணினித் தளங்களிலும் தங்கள் மென்பொருள்களிலும் மட்டுமே வேலை செய்யக் கூடியதாக செய்திருக்கிறார்கள். அவர்கள் கணினித் தளமே உலமெங்கும் அதி கூடிய அளவில் பாவிப்பதால், இவர்களுக்கு இது ஒரு பின்னடைவே அல்ல. உண்மையைச் சொல்லப் போனால், இதனால், அவர்களின் தயாரிப்புகளே மேலும் விற்பனையாகும்.

இந்த .NET உம் JAVA வின், நேரடியாக கணினிக்குத் தேவையான programming code இல் மாற்றாமல் ஒரு இடைப்பட்ட மொழிக்கு மாற்றுகிறது. இவர்கள் இதை bytecode என்று பெயரிடாமல் “Intermediate Language” [IL] என்று பெயரிட்டுள்ளார்கள்.

இந்த .NET இல் programming பண்ணுவதற்கு அவர்கள் ஒரு மென்பொருள் வெளியிட்டு இருக்கிறார்கள் [Visual Studio .NET]. இதில் தானாகவே குறுகிய செயற்பாட்டிற்கு தேவையாக programming code ஐ தாயாரித்துத் தரும். இதனால் நீங்கள் உங்களது நேரத்தை மிச்சப் படுத்தலாம். இந்த Visual Studio .NET இல் தானாக தயாரிக்கப் படும் JavaScript codes, Internet Explorer இல் மட்டுமே வேலை செய்ய வல்லவை. இந்த .NET framework ஐ Windows கணினித் தளங்களிலேயே ஏற்றிக் கொள்லலாம். அதாவது, .NET இல் செய்யப்படும் மென்பொருட்கள் யாவும் Windows தளங்களிலேயே இயங்கும் [Microsoft வேறு கணினித் தளங்களுக்கும் .NET கொண்டு வரப்படும் என்று சொல்லி இருக்கிறார்கள்].

.NET விசேடம் என்னவென்றால், நீங்கள் .NET framework இல் VB இல் தான் coding பண்ண வேண்டும் என்றில்லை. C++, C#, J#, COBOL, FORTRAN, PYTHON என்று ஒரு கணினி மொழிப் பட்டாளத்திலேயே நீங்கள் எழுதலாம். அதுவும் பல மொழிகளைக் கொண்டு ஒரு மென்பொருள் தயாரிக்கக் கூடிய வல்லமை .NET கொண்டுள்ளது. அதாவது நீங்கள் ஒரு பகுதி மென்பொருளை [module] C++ எழுத உங்கள் நண்பர் மற்றய பகுதியை COBOL இல் எழுதி மென்பொருளைத் தயாரிக்கலாம். அப்போ, இப்போது அரிதாகி வரும் COBOL, FORTRAN, மொழி வல்லுனர்கள் .NET ஆ JAVA ஆ என்னும் போது .NET ஐயே தேர்ந்தெடுக்க வாய்ப்புகள் அதிகம்.

இன்னொறு விசேடம் என்னவென்றால், Microsfot C# என்னும் கணினி மொழியை வெளியிட்டுள்ளது. இந்த மொழியை உருவாக்க, உலகத்திலுள்ள ஏனைய கணினி மொழி வல்லுனர்களின் ஆலோசனை எடுக்கப்பட்டதாம். எல்லா மொழியின் சங்கமமே C# என்று கூறப்படுகிறது. C++ இன் செயற் திறன், C++ இன் pointer அகற்றப்பட்டு விட்டது, JAVA இன் garbage collector, VB இன் easy to create visualization என்று அடுக்கிக் கொண்டே போகலாம். அதனால் VB, C++ ஐப் போல் செயற் திறன் அற்றது என்று சொல்பவர்களுக்கு இனி C# பதிலாக சொல்வார்கள்.

இவை போன்ற மிகவும் user friendly features மற்றும் Microsoft இன் கணினி ஆதிக்கத் திறன் என்பவற்றால், .NET முதலிடம் பிடிக்கும் என்று நான் நம்புகிறேன். அதற்காக J2EE அழிந்து போகுமென்றில்லை. அதுவும் ஒரு புறத்தில் இருக்கும். இதனால் C#.NET மற்றும் VB.NET படித்தல், அது சம்பந்தமாக வேலை பார்த்தல் மிக நன்று என்று நினைக்கிறேன்.

 

.Net் சம்பந்தமான வேறோர் இடுகை
.net பிறந்த கதை

_____
CAPital

No responses yet

Jun 21 2006


My Notes – ASP.NET

Filed under ASP/ ASP.NET

?

Every Web page in .NET

extends System.Web.UI.Page class

==

IL is short for Intermediate Language

Another term for IL is Managed Code. This intermediate or managed code is generated by the JIT compiler. JIT is short for Just in Time compiler.

The C#, VB.NET, Cobol.NET, and all other compilers that support the .NET Framework generate IL when compiling a set of code. To get an idea of what IL looks like, start up ILDASM by opening a Visual Studio .NET Command Prompt (Start -> All Programs -> Microsoft Visual Studio .NET -> Visual Studio .NET Tools -> Visual Studio .NET Command Prompt) and type ILDASM. The ILDASM tool is an IL Disassembler for the .NET framework which is installed as part of the .NET SDK. To view the IL for any .NET component on your system go to File -> Open and select a .NET assembly.

How to write ILAsm

http://www.codeproject.com/dotnet/ilassembly.asp

==

The GAC (aka Global Assembly Cache) is the central repository for assemblies installed on a Windows machine. It provides a uniform, versioned and safe access of assemblies by their strong assembly name. C:\WINDOWS\assembly

DataReader

You can use the ADO.NET DataReader to retrieve a read-only, forward-only stream of data from a database. Results are returned as the query executes, and are stored in the network buffer on the client until you request them using the Read method of the DataReader. Using the DataReader can increase application performance both by retrieving data as soon as it is available, rather than waiting for the entire results of the query to be returned, and (by default) storing only one row at a time in memory, reducing system overhead.

Note that while a DataReader is open, the Connection is in use exclusively by that DataReader. You will not be able to execute any commands for the Connection, including creating another DataReader, until the original DataReader is closed.

Output parameters or return values are only available through the DataReader once the connection is closed.

==DataAdapter

Adapters are used to exchange data between a data source and a dataset.

  • To retrieve rows into a dataset, use the Fill method on a data adapter object. When you invoke the Fill method, it transmits an SQL SELECT statement to the data store.

? To transmit a dataset table of the dataset to the data store, use the adapter’s Update method. When you invoke the method, it executes whatever SQL INSERT, UPDATE or DELETE statements are needed, depending on whether the affected record is new, changed, or deleted.

==

DataView

A data view is an object that acts as a layer on top of the data table, providing a filtered and sorted view of the table’s contents. A data view is similar to a view in a database, in that it is not a copy of the data. Instead, it is simply a different way of seeing the data in a table.

==

DataGrid

The DataGrid Web server control displays data in a tabular layout. By default, the DataGrid displays data in read-only mode, but the DataGrid is also capable of automatically displaying the data in editable controls at run-time. The DataGrid control can also create the Select, Edit, Update, and Cancel buttons and programming structure. Additionally, the DataGrid supports paging, though you may also use the custom navigation features of the control to improve performance by controlling the amount of data sent to the client browser.

DataSet

Datasets store data in a disconnected cache. The structure of a dataset is similar to that of a relational database; it exposes a hierarchical object model of tables, rows, and columns. In addition, it contains constraints and relationships defined for the dataset.

You can populate a dataset in a variety of ways:

  • Call the Fill method of a data adaptery.

  • Manually populate tables in the dataset by creating DataRow objects and adding them to the table’s Rows collection. (You can only do this at run time; you cannot set the Rows collection at design time.)

  • Read an XML document or stream into the dataset. For more information, see the ReadXml method.

  • Merge (copy) the contents of another dataset. This scenario can be useful if your application gets datasets from different sources (different XML Web services, for example), but needs to consolidate them into a single dataset. For more information, see the DataSet.Merge method.

==

ViewState

Before ASP.NET, restoring the values back into the form fields across multiple postbacks was entirely the responsibility of the page developer, who had to pick them out, one-by-one, from the HTTP form, and push them back into the fields. Happily, ASP.NET does this trick automatically, thus eliminating both a lot of grunt work and a lot of code for forms. But that’s not ViewState.

ViewState is the mechanism ASP.NET uses to keep track of server control state values that don’t otherwise post back as part of the HTTP form. For example, the text shown by a Label control is saved in ViewState by default. As a developer, you can bind data or programmatically set the Label just once when the page first loads, and on subsequent postbacks, the label text will be repopulated automatically from ViewState. So in addition to less grunt work and less code, the benefit of ViewState is often fewer trips to the database.

It’s a hidden form field managed by the ASP.NET page framework. When ASP.NET executes a page, the ViewState values from the page and all of the controls are collected and formatted into a single encoded string, and then assigned to the value attribute of the hidden form field (specifically, <input type=hidden>).

– You must have a server-side form tag (<form runat=server>) in your ASPX page if you want to use ViewState.

– In cases where the page does not post back, you can eliminate ViewState from a page by omitting the server side <form> tag.

Not very good for:

Large amounts of data.Secure data that is not already displayed in the UI

Objects not readily serialized into ViewState, for example, DataSet.

Disabling ViewState

Per control (on tag)

<asp:datagrid EnableViewState="false" ? />

Per page (in directive)

<%@ Page EnableViewState="False" ? %>

Per application (in web.config)

<Pages EnableViewState="false" ? />

Trace.Write()

==

Rich output caching. ASP.NET output caching can dramatically improve the performance and scalability of your application. When output caching is enabled on a page, ASP.NET executes the page just once, and saves the result in memory in addition to sending it to the user. When another user requests the same page, ASP.NET serves the cached result from memory without re-executing the page. Output caching is configurable, and can be used to cache individual regions or an entire page.

==

Web-Farm Session State.

ASP.NET session state lets you share session data user-specific state values across all machines in your Web farm. Now a user can hit different servers in the web farm over multiple requests and still have full access to her session. And since business components created with the .NET Framework are free-threaded, you no longer need to worry about thread affinity.

===

Managed code is compiled for the .NET run-time environment. It runs in the Common Language Runtime (CLR), which is the heart of the .NET Framework. The CLR provides services such as security, memory management, and cross-language integration. (3) Managed applications written to take advantage of the features of the CLR perform more efficiently and safely, and take better advantage of developers? existing expertise in languages that support the .NET Framework.

There can be no memory leaks in 100% managed code.

Another significant advantage of using managed code is that the CLR provides automatic lifetime management of components and modules. Lifetime control includes:

  • Garbage collection, which frees and compacts memory.

  • Scalability features, such as thread pooling and the ability to use a non-persistent connection with a dataset.

  • Support for side-by-side versions.

Managed code does not have direct access to memory, machine registers, or pointers.

CLR

Common Language Runtime 


Figure 1: .NET Architecture
 

The CLR as a development platform

The CLR is a development platform. Like any platform, it provides a runtime, defines functionality in some libraries, and supports a set of programming languages.

 

 The job of the CLR is to watch over your code, taking care of its needs and wants. In fact, code that takes advantage of the CLR is said to be “managed code”, because the runtime is taking care of it, making sure that it has everything it needs and ensuring that it doesn’t do anything it’s not supposed to. “Unmanaged code” is the code that either doesn’t know about or doesn’t want to use the runtime.

===

if a method input parameter is declared as accepting a 4-byte value, the common language runtime will detect and trap attempts to access the parameter as an 8-byte value. Type safety also means that execution flow will only transfer to known method entry points. There is no way to construct an arbitrary reference to a memory location and cause code at that location to begin execution

Unmanaged code includes all code written before the .NET Framework was introduced?this includes code written to use COM, native Win32, and Visual Basic 6. Because it does not run inside the .NET environment, unmanaged code cannot make use of any .NET managed facilities.

==

All .NET compilers produce metadata about the types defined in the modules they produce. This metadata is packaged along with the module (modules in turn are packaged together in assemblies), and can be accessed by a mechanism called reflection. The System.Reflection namespace contains classes that can be used to interrogate the types for a module/assembly.

Using reflection to access .NET metadata is very similar to using ITypeLib/ITypeInfo to access type library data in COM, and it is used for similar purposes – e.g. determining data type sizes for marshaling data across context/process/machine boundaries.

Reflection can also be used to dynamically invoke methods (see System.Type.InvokeMember), or even create types dynamically at run-time (see System.Reflection.Emit.TypeBuilder).

==

Code Access Security

CAS is the part of the .NET security model that determines whether or not code is allowed to run, and what resources it can use when it is running. For example, it is CAS that will prevent a .NET web applet from formatting your hard disk.

C# supports constructor chaining

class Person
    {
        public Person( string name, int age ) { ... }
        public Person( string name ) : this( name, 0 ) {}
        public Person() : this( "", 0 ) {}
    }

===

User Control vs Custom Control [Composite Control]

The main difference between user controls and composite controls is that user controls are persisted as .ascx text files, whereas composite controls are compiled and persisted in assemblies.

A user control (ex. TextBox, ComboBox, ListBox, simple HTML elements) could simply be an extension of the functionality of an existing server control(s) (such as an image control that can be rotated or a calendar control that stores the date in a text box, DataGrid, DataSet, DataView, DataAdapter). Or, it could consist of several elements that work and interact together to get a job done (such as several controls grouped together that gather information about a user’s previous work experience).

An ASP.NET control (sometimes called a server control) is a server-side component that is shipped with .NET Framework. A server control is a compiled DLL file and cannot be edited. It can, however, be manipulated through its public properties at design-time or runtime. It is possible to build a custom server control (sometimes called a custom control or composite control).

==

all .NET event handlers are expected to accept two parameters.The first parameter (Sender) is a reference to the object that raised the event. You might think this is redundant because we’ve already decided that this handler will be associated with events from the Navigate button;however, as we shall see in Chapter 4, you can define event handling routines to be associated with multiple controls, and so the Sender parameter provides an easy way to identify which of these controls has raised the event.The second parameter (E) is a reference to an object that provides additional information about the event. In the case of a click event there’s no useful additional information, but for events such as ItemClick (ina ListBox) or ItemCommand (in a DataGrid) the E parameter includes details of which item or row has been selected or activated.

Typed versus Untyped Datasets

Datasets can be typed or untyped. A typed dataset is a dataset that is first derived from the base DataSet class and then uses information in an XML Schema file (an .xsd file) to generate a new class. Information from the schema (tables, columns, and so on) is generated and compiled into this new dataset class as a set of first-class objects and properties.

Note For more information about dataset schemas, see XML Schemas and Data.

Because a typed DataSet class inherits from the base DataSet class, the typed class assumes all of the functionality of the DataSet class and can be used with methods that take an instance of a DataSet class as a parameter

An untyped dataset, in contrast, has no corresponding built-in schema. As in a typed dataset, an untyped dataset contains tables, columns, and so on ? but those are exposed only as collections. (However, after manually creating the tables and other data elements in an untyped dataset, you can export the dataset’s structure as a schema using the dataset’s WriteXmlSchema method.)

You can use either type of dataset in your applications. However, Visual Studio has more tool support for typed datasets, and they make programming with the dataset easier and less error-prone.

=========

SERVER controls vs CLIENT controls.. ASP.NET

http://www.informit.com/articles/article.asp?p=173412&rl=1

=========

CMS

Software that provides a method of managing your website is commonly called a CMS or “Content Management System”. Many blogging software programs are considered a specific type of CMS.

=========

Delegates

 Microsoft gives this rather cryptic description:
A delegate is a reference type that refers to a Shared method of a type or to an instance method of an object. The closest equivalent of a delegate in other languages is a function pointer, but whereas a function pointer can only reference Shared functions, a delegate can reference both Shared and instance methods.

It means that a delegate is basically just a fancy function pointer like in C++. (you can also think of it like a callback) And a function pointer is just a reference to a function, it lets some other code, call your function without needing to know where your function is actually located.

A delegate is very much like a C/C++ ‘function pointer‘ or a ‘typedef that represents the address of a function’. In C/C++, the address of a function is just a memory address. The C/C++ function pointer holds only the address of a function. This address doesn’t carry any additional information, such as the number of parameters expected by the function, types of parameters it takes etc. In fact, this all makes a function pointer type unsafe. Traditionally, calling a function by its address depends on the language supporting the function pointers. And function pointers are inherently dangerous.Delegates add a safety to the idea of traditional function pointers. The .NET framework has added the bonus of providing a type-safe mechanism called delegates. They follow a Trust-But-Verify model, with automatic verification of the signature by the compiler. Unlike function pointers however, delegates are object-oriented, type-safe, and secured. In short, a delegate is a data structure that refers to a static method or to an object instance, and an instance method of that object. When the delegate references an instance method, it stores not only a reference to the method entry point, but also a reference to the object instance for which to invoke the method. Delegates are more efficient than interfaces as the method pointer is calculated (if virtual) when the delegate is first assigned, rather than each time it is invoked.

No responses yet

« புதிய இடுகைகள்

அடடா » தவறு

Sorry, you are not allowed to access this page.