Server side code executes on the server. For this to occur page has to be submitted or posted back. Events fired by the controls are executed on the server. Client side code executes in the browser of the client without submitting the page.
e.g. In ASP.NET for web controls like asp: button the click event of the button is executed on the server hence the event handler for the same in a part of the code-behind (server-side code). Along the server-side code events one can also attach client side events which are executed in the client�s browser i.e. javascript events.
Thursday, 17 January 2008
Object Oriented Programming
Click Here to View Latest ASP.Net Questions
OOP Features
� Encapsulation � Objects are by nature, encapsulated. That is, only certain portions of their fields and methods are publicly accessible from other classes and one doesn�t really need to know the inner workings of an object in order to use it. Encapsulation has certain benefits. By hiding the inner workings of a class, it makes that class simpler to use because the developer only sees and has access to what is necessary to use the class. Furthermore, the developer cannot accidentally override the data inside that class.
� Inheritance � Often considered the "Holy Grail" of programming inheritance is just as often misused or misunderstood. Inheritance defines a particular ability of classes to inherit the data members and functionality from other more generalized classes. The new or "child" class can than add more specific functionality that is parent does not possess.
� Polymorphism � Polymorphism is even more difficult to understand and explain. Literally meaning "many forms" polymorphism is the ability for related classes to have the methods or functions with the same name and syntax but different implementations.
� Aggregation/Composition � Although these two terms are often used interchangeably, aggregation is more generalized term referring to groups of objects being used to make up another object, much the way a car is made of various parts. Composition is a much more specific form of aggregation where one the pieces can only belong to one whole and outside of that whole, they no longer exist. Usually though, you�ll hear people refer to composition in the more general sense that aggregation defines.
� Interfaces � Perhaps one of the most mysterious features of OOP languages, interfaces have very specific purposes, especially in component development. Classes that inherit interfaces are required to have certain methods, fields and/or properties defined and implemented. This allows related classes to have a consistent manner of using them. For example, all the .NET collection classes inherit from the IEnumerator interface, forcing them to have the methods MoveNext(), Reset() and Current property.
Transactions
Transactions
A transaction is a sequence of operations performed as a single logical unit of work. A logical unit of work must exhibit four properties, called the ACID (Atomicity, Consistency, Isolation, and Durability) properties, to qualify as a transaction:Atomicity
A transaction must be an atomic unit of work; either all of its data modifications are performed, or none of them is performed.
When completed, a transaction must leave all data in a consistent state. In a relational database, all rules must be applied to the transaction's modifications to maintain all data integrity. All internal data structures, such as B-tree indexes or doubly linked lists, must be correct at the end of the transaction.
Modifications made by concurrent transactions must be isolated from the modifications made by any other concurrent transactions. A transaction either sees data in the state it was in before another concurrent transaction modified it, or it sees the data after the second transaction has completed, but it does not see an intermediate state. This is referred to as serializability because it results in the ability to reload the starting data and replay a series of transactions to end up with the data in the same state it was in after the original transactions were performed.
After a transaction has completed, its effects are permanently in place in the system. The modifications persist even in the event of a system failure.
Specifying and Enforcing Transactions
SQL programmers are responsible for starting and ending transactions at points that enforce the logical consistency of the data. The programmer must define the sequence of data modifications that leave the data in a consistent state relative to the organization's business rules. The programmer then includes these modification statements in a single transaction so that Microsoft� SQL Server� can enforce the physical integrity of the transaction.It is the responsibility of an enterprise database system, such as SQL Server, to provide mechanisms ensuring the physical integrity of each transaction. SQL Server provides:
- Locking facilities that preserve transaction isolation.
- Logging facilities that ensure transaction durability. Even if the server hardware, operating system, or SQL Server itself fails, SQL Server uses the transaction logs, upon restart, to automatically roll back any uncompleted transactions to the point of the system failure.
- Transaction management features that enforce transaction atomicity and consistency. After a transaction has started, it must be successfully completed, or SQL Server undoes all of the data modifications made since the transaction started.
Transaction is a procedure the data tranmitted into the database either sucess of failure sate.
It has 2 objectsCOMMIT
ROLLBACK
Strong Naming
The Secrets of Strong Naming
The strength of a strong name lies in the protection that it offers your assemblies. The .NET Framework uses strong names to identify assemblies and to protect them from tampering.
Hashes and Signing
To grasp the way that strong names work, you first need to understand a pair of cryptographic concepts: hashing and digital signatures.Hashing is used to create a unique, compact value for a plaintext message. "Message" is a very broad term here; in terms of assemblies, the message is the assembly itself. The message is used as an input to the hash algorithm (in the case of strong naming, the SHA1 algorithm is used). Figure 1 diagrams the process.
<!--[endif]-->Hashing is a one-way street: you can't decrypt the hash value once it has been computed. However, hashing is very useful for comparing values. If two assemblies produce the same hash value, you can assume that the assemblies are the same. Conversely, if hashing an assembly produces a value that doesn't match a previously-calculated hash, you know that something in the assembly has been changed.
Knowing the hash value for an assembly lets you check that no one has tampered with the assembly. But how do you prevent someone from tampering with the hash value? That's where digital signing comes in. While the mathematics of digital signatures are complex, the concept is fairly simple. A digital signature depends on a pair of related numbers, the public key and the private key. When data is encrypted with the public key, it can only be decrypted with the private key (and vice versa), as shown in Figure 2.
<!--[endif]-->Strong Naming for Assembly Identity
The combination of hashing and digital signing allows .NET to protect your assemblies from tampering. Here's how it works. First, a hash value is created from the assembly. Then, the hash value is encrypted with your private key and placed, along with your public key, in the assembly itself. Figure 3 shows this process schematically.
<!--[endif]-->The CLR validates assemblies at runtime by comparing two sets of hash values. First, the public key is used to decrypt the encoded version of the hash. Second, a new hash is computed from the current contents of the assembly. If the two hashes match, all is well. Figure 4 shows this process.
<!--[endif]-->What happens if an assembly has been tampered with after it was signed? In this case, the new hash value calculated at runtime won't match the stored hash value that was encrypted with your private key. Under those circumstances, the CLR will refuse to load the assembly.
Note that the strong name guarantees the integrity of the assembly, not necessarily its safety! There's nothing to prevent someone from creating a malicious assembly and signing it with a strong name.You can use a strong name to verify that an assembly came from a particular source, and that it wasn't tampered with after it was signed. It's up to you to decide, based on whatever information you choose, whether to trust code from that source.
What's in a (Strong) Name?
In addition to a hash derived from the assembly's contents, the strong name includes three other pieces of information:- The simple text name of the assembly
- The version number of the assembly
- The culture code (if any) of the assembly
This entire information works together to supply a unique identity for each assembly. The CLR uses this information when deciding whether a particular assembly is the one called for by a reference from another assembly. When you set a reference from one assembly to another, the calling assembly stores a representation of the called assembly's public key. At runtime, the CLR can use this to check that the referenced assembly comes from the correct vendor. In addition, the other information in the strong name is used to determine whether a particular assembly fills the binding policy requirements for the reference.
The Mechanics of Strong Naming
Both the .NET Framework SDK and Visual Studio .NET provide tools for assigning strong names. That makes sense, because using Visual Studio .NET to create assemblies is completely optional. Before you can sign anything, you need to create a key pair (consisting of a public key and a private key). Typically, you'll store your key pair in a file with the extension .snk. To do this, you use the strong name tool, sn.exe:
sn -k MyKeyFile.snk
If you're using the command-line compilers (vbc.exe or csc.exe), you can specify the key pair to use in your command line to the assembly linker, al.exe. For example, you might sign MyFile.dll with the key pair in MyKeyFile.snk with this command line:
al /out:MyFile.dll MyFile.netmodule /keyfile:MyKeyFile.snk
If you're using Visual Studio .NET, you'll still generate your key pair at the command line. After generating it, you can include it in your assembly by specifying the AssemblyKeyFile attribute in the assembly information file (AssemblyInfo.vb or AssemblyInfo.cs). In a C# project, for example, you can include a key file and produce a signed assembly with this attribute:
[assembly: AssemblyKeyFile ("..\\..\\MyKeyFile.snk")]
The filename in the AssemblyKeyFile attribute should include the full relative path from the compiled assembly to the key file.
Keeping Secrets with Delay Signing
Protecting your private key is obviously very important; if a nefarious person gets your private key, they can produce assemblies that appear to have been signed by you. Because of this, you may wish to keep your private key a closely-guarded secret, known only to a few people in the company. But then, how can you handle assembly signing? It would be tedious if you were the only person who knew the private key, and you had to sign every build of every assembly produced by every developer in your company.Fortunately, .NET provides a way around this problem: delay signing. With delay signing, you can build and test an assembly knowing only the public key. The private key can be applied later if the assembly is actually shipped to customers. Here is a summary of the delay signing process:
- Extract the public key from the public/private key pair. To extract the public key from a file that is storing the public/private key pair, you can use the strong name tool with a slightly different command line:
sn.exe -p MyKeyFile.snk MyPublicKeyFile.snk
<!--[if !supportLineBreakNewLine]-->
<!--[endif]--> - Distribute the file containing only the public key to all of the developers in the company, and store the file containing both keys securely.
<!--[if !supportLineBreakNewLine]-->
<!--[endif]--> - Include the public key file in your assembly information file, and specify delay signing:
[assembly: AssemblyDelaySign(true)]
[assembly: AssemblyKeyFile("..\\..\\MyPublicKeyFile.snk")]
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
If you're using the assembly linker tool rather than Visual Studio .NET, use the /delaysign command-line switch to indicate delay signing.
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
- Turn off verification for the assembly if you're storing the assembly in the GAC. By default, the GAC verifies the strong name of each assembly. If the assembly is not signed by using the private key, this verification fails. So, for development and testing purposes, you can relax this verification for an assembly by issuing the following command:
sn.exe -Vr MyFile.dll
<!--[if !supportLineBreakNewLine]-->
<!--[endif]--> - At this point, you can use the assembly freely in testing and development.
<!--[if !supportLineBreakNewLine]-->
<!--[endif]--> - When you're ready to deploy a delay-signed assembly, you need to sign it with your private key:
sn.exe -R MyFile.dll MyKeyFile.snk
<!--[if !supportLineBreakNewLine]-->
<!--[endif]--> - Finally, you can instruct the GAC to resume verification for an assembly by issuing the following command:
sn.exe -Vu MyFile.dll
Explian Trigger
A trigger is a database object that is bound to a table. It is a special type of stored procedure that executes automatically when any DML operations are performed.
Microsoft SQL Server 2000 supports two different types of triggers namely INSTEAD OF and AFTER Trigger. Both this trigger is different in the execution.
It supports Multiple after Trigger also. Triggers cannot be created on the temporary tables.
It supports Multiple after Trigger also. Triggers cannot be created on the temporary tables.
After Trigger
After trigger automatically get executed before the transaction get completed or rollback. After trigger created only on tables not in views. This is very useful to maintain the data integrity between the tables.
EXAMPLE
CREATE TRIGGER after trigger
ON department
FOR INSERT AS
Print ('After Tigger is initiated')
GO
BEGIN TRANSACTION
DECLARE @ERR INT
INSERT INTO department(USERNAME, PASSWORD)VALUES('Ram','india
SET @ERR = @@Error
IF @ERR = 0
BEGIN
COMMIT TRANSACTION
PRINT 'COMMIT TRANSACTION'
END
ELSE
BEGIN
ROLLBACK TRANSACTION
PRINT 'ROLLBACK TRANSACTION'
END--End of the program
INSTEAD OF Triggers
This trigger gets executed automatically before the primary key and the foreign key column constraint are checked. Whereas the traditional trigger (After Trigger) get executes automatically after all the check constraints are checked.
Triggers are a powerful tool that can be used to enforce the business integrity or data integrity automatically when the data is modified. Triggers should be used to maintain the data integrity only if you are not capable to enforce the data integrity using CONSTRAINTS, RULES.
2) To check whether the given column present in the table if present display the tables which contains this columns in the database
set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
GO
ALTER procedure [dbo].[sp_Search_Columns](
@column varchar(500)
)
as
Begin
set nocount on
declare @tname varchar(500),
@intNum int
--Create a temporary table to store the table having the columns
create table #Tables1(TableNames varchar(500))
Declare TableNames cursor for
--select all the tables from the database
Select Table_name from INFORMATION_SCHEMA.Tables order by TABLE_NAME
--verify for each table in the database whether the coloumn present or not
open TableNames fetch next from TableNames into @tname
while @@FETCH_STATUS=0
begin
--Check if the table contains the coloumn.
--if the coloumn is present in the
select @intNum=count(*) from information_schema.columns where table_name = @tname and column_name=@column
if(@intNum > 0)
--if the table contains the column then insert that table name in the temp table for further display
insert into #Tables1 values(@tname)
--point the pointer to check for the next table
fetch next from TableNames into @tname
End
close TableNames
--deallocate the curser
deallocate TableNames
--select all the tables which contains the column
select * from #Tables1
end
Out Put of the query :
EXEC sp_Search_Columns 'FirstName'
Tablenames
Account
COBInfo
COBInfo_backup
COBInfoHistory
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
3) How to find the number of days in a month
Create Function NumDaysInMonth (@dtDate datetime) returns intasBeginReturn(Select Day(DateAdd(Month, 1, @dtDate) - Day(DateAdd(Month, 1, @dtDate))))EndGo
MVC (Model View Controller) For ASP.NET
MVC (Model View Controller) For ASP.NET
Historical Background
For those unfamiliar with MVC, MVC stands for Model, View, Controller. The Model is the representation of the thing the user is trying to interact with. It typically holds the data and business rules.
The View pulls information from the Model and renders that information in a way the user will understand.
The Controller interprets actions by the user, usually mouse and keyboard events, and sends the information to the model or the view.
The model knows nothing about the view or the controller other than that they exist. The view and the controller know as much as possible about the model.
The advantage to this type of architecture is that the view and the controller may be changed without affecting the model. For web applications that need to render themselves on various browsers and devices this is an ideal architecture that allows the application to be written originally for a desktop browser and later written for a PDA by changing only the view layer.
<!--[endif]--><!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
Typical UML of MVC
JSP's Model II architecture is an attempt by those working in this environment to coerce MVC into a web based world. In this case the controller can no longer access the view directly, so we end up with the controller sending information to the model and the view always pulling the information out of the model.
<!--[endif]--><!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
UML of MVC on the web
In a Model 2 architecture, a central controller is used which then delegates to other controllers and/or the appropriate resulting view. In terms of physical components of a JSP environment, MVC is typically implemented by posting to a servlet that processes the form information and then forwards to a JSP page to render the resulting page.
This combined with EJB or JavaBeans keeps the view separate from the controller and the model.
<!--[endif]-->This translates rather easily to ASP. The Servlet becomes an ISAPI.DLL, the JSP page becomes an ASP page, and the model becomes ActiveX controls.
<!--[endif]-->Enter ASP.NET
If your only experience with MVC is through Model 2 architecture, the ability to implement MVC architecture in ASP.NET is not immediately apparent. However, ASP.NET not only allows MVC, it encourages it in the way the pattern was originally conceived.
Since the definition of MVC states that the View renders the data from the Model and that the Controller sends user events to the Model, generally from the elements rendered on the view, most could agree that there is a very high natural coupling between the View and the Controller. So, a natural real world implementation of MVC, and indeed what you normally find outside of web applications, is a one to one correspondence between the View and the Controller. However, in a web application, there is a need to not only send data to the model, there is also a need to control which view should render based on the data the model currently contains. A kind of a "View Controller." In some Model 2 implementations, there is a central Controller which we will call the "View Controller." This View Controller delegates form processing to other programming entities and eventually redirects to the appropriate view. JavaBeans in the case of JSP, ActiveX controls in the case of ASP. If you've ever worked with the Struts framework for JSP you are familiar with this model.
Since ASPX pages post back to themselves, we obviously can't use a "View Controller." So, how does one implement the same functionality in .NET? Furthermore, those familiar with Struts will recognize that the ability to loosely couple the views (or controllers) from each other is not available in ASP.NET "out of the box."
The following architecture solves both of these problems.
In a Model 2 architecture using a Central Controller, a delegate pattern is used to control access to the different services, or sub-controllers. You ask for a service and the central controller determines if you should be allowed access to the service and how to implement the service.
In ASP.NET, you generally ask for the service directly. Instead of a service being a sub-controller, it is the main point of entry. What this doesn't offer is a central location for determining if you should have access to the service in the first place, or, any other common processing that should happen in all of the services. However, by having all of your code-behind pages inherit from a common class that is a subclass of System.Web.UI.Page, you can place all of this pre-processing code in the OnLoad() method that you override from the Page class. OnLoad() is call by the framework every time the page is loaded. But before the Page_Load() method is called in your code-behind page. This allows you to verify that the service is allowed and do any redirecting you need to do in one central location, using Server.Transfer(), similar to what a Central Controller would do. I named my View Controller class ViewController.
The second requirement, making the views loosely coupled from each other, requires a bit more work. First, you will need to create an enum in your ViewController class that has an entry that corresponds to each page in your web application. I also added an enum named UNDEFINED. Second, you will need to create a member variable to hold the ID of the page. I initialized mine to UNDEFINED. This gets placed in your ViewController class and is of the type of your enum. Third, you will need to create a property to access this member variable. I've named mine ServiceID. Fourth, create a method in your ViewController named getServicePage() that takes the enum as a parameter and returns a string containing the appropriate aspx file. Finally, in the constructor of each of your code-behind pages, set the ServiceID of the page. Now, anywhere in your code where you are redirecting or linking to an aspx page in your application, you will call the getServicePage() method to retrieve the name of the file to redirect to.
If you've ever refactored your website to the point of renaming web pages, you should immediately see that this will significantly simplify maintenance. If you want to rename an aspx file you now can rename the file and change the lookup in getServicePage and your site should still work. The only problem with this implementation is that there is no good way to enforce it's usage.
<!--[endif]-->Conclusion
With the advent of ASP.NET, many of the hacks we have had in place have been removed. All of the view and controller related code is now in essentially one place instead of two. The defacto standard for writing view based application (MVC) is preserved.
Localization and Culture
Localization and Culture
As the number of Internet users grew worldwide, the need to create software supporting multiple languages was felt intensely because only ten percent of people use English as the primary language. People wanted applications that could communicate with them in their native language. This became simple with the release of the .NET framework.
Locale and .NET culture
Geographically speaking, a locale is a place. In software terms, a �locale� is a collection of information associated with a place. Locale information includes the name and identifier of the spoken language, cultural conventions, etc. A Locale Identifier (LCID) is used to retrieve information about the locale. LCID is a 32-bit unsigned integer value that is divided into four parts. The first two parts identify the language and sub-language (sub-language corresponds to country/region) and the last two parts specify the sorting order for text strings.
The �culture� in .NET refers to the user�s language and region. A culture is identified by language code�region/country code. For example, the French language spoken inFrance France Canada
.NET encapsulates the culture related information in the System.Globalization and System.Resources namespaces. The object of the Globalization. CultureInfo class represents a specific culture. Using the methods of this class, we can obtain the information of the culture that is set for the current thread. The following code snippet shows how to set the culture for the current thread and obtain its name, number format and currency format.
Let�s now see how to localise resources. We will create a localised WinForm application that allows the user to select a language. On clicking a button another form would get displayed in the selected language. This form would contain a textbox where you can type your name. On clicking a button you would be greeted in the selected language. Our form would look as shown below.
<!--[endif]-->
As the number of Internet users grew worldwide, the need to create software supporting multiple languages was felt intensely because only ten percent of people use English as the primary language. People wanted applications that could communicate with them in their native language. This became simple with the release of the .NET framework.
Locale and .NET culture
Geographically speaking, a locale is a place. In software terms, a �locale� is a collection of information associated with a place. Locale information includes the name and identifier of the spoken language, cultural conventions, etc. A Locale Identifier (LCID) is used to retrieve information about the locale. LCID is a 32-bit unsigned integer value that is divided into four parts. The first two parts identify the language and sub-language (sub-language corresponds to country/region) and the last two parts specify the sorting order for text strings.
The �culture� in .NET refers to the user�s language and region. A culture is identified by language code�region/country code. For example, the French language spoken in
.NET encapsulates the culture related information in the System.Globalization and System.Resources namespaces. The object of the Globalization. CultureInfo class represents a specific culture. Using the methods of this class, we can obtain the information of the culture that is set for the current thread. The following code snippet shows how to set the culture for the current thread and obtain its name, number format and currency format.
foreach(CultureInfo c in CultureInfo.GetCultures(CultureTypes.AllCultures)) { Thread.CurrentThread.CurrentCulture = new CultureInfo(c.Name); Console.WriteLine ( "{0}:{1},Num:{2},Dt:{ 3}, Curr:{ 4} ",c.Name, c.EnglishName, (12345).ToString ("n"), (12345.50).ToString ("c"), (DateTime.Now).ToShortDateString()); } The CultureInfo.GetCultures( ) method returns the list of all the supported cultures. CultureTypes is an enum that contains the types of culture�specific, neutral, all cultures and only those cultures that are installed on the system. To set the culture for a thread, firstly we must obtain the reference to that thread. Here, we have obtained the reference by using the CurrentThread property of the Thread class. The two culture values of an application determine what resources are loaded for an application and how information like currency, numbers and dates are formatted. The resources loaded are determined by the UI culture setting, and the formatting options are determined by the culture setting. The Thread class provides two properties�CurrentCulture and CurrentUICulture�to change the respective culture settings. We have used the CurrentCulture property since we needed to set the culture specific formatting options. The Name and EnglishName are properties of the CultureInfo class that give the culture name and its corresponding Language (Country/Region) combination respectively. Of course, we need to use the Globalization and Threading namespaces to run this code.Let�s now see how to localise resources. We will create a localised WinForm application that allows the user to select a language. On clicking a button another form would get displayed in the selected language. This form would contain a textbox where you can type your name. On clicking a button you would be greeted in the selected language. Our form would look as shown below.
<!--[endif]-->Name the radio buttons as reng, rger, rita, and rfre respectively. Name the �Display� button as bdisplay. Add the Click event handler for the �Display� button. Here is the handler:
void bdisplay_Click (object sender, System.EventArgs e) { Thread t = Thread.CurrentThread; if(rfre.Checked) t.CurrentUICulture=new CultureInfo("fr-FR"); if(rger.Checked) t.CurrentUICulture=new CultureInfo("de-DE"); if(rita.Checked) t.CurrentUICulture=new CultureInfo("it-IT"); if(reng.Checked) t.CurrentUICulture=new CultureInfo("en-US"); greetform g=new greetform(); g.ShowDialog(); }Here, we have only checked which radio button the user has selected and set the UI culture accordingly. After this we have displayed another form. We need to add this form to the project. Add controls to this form as shown alongside.
Collections Class
Collections Class in C#
To construct and manipulate a collection of objects, .Net framework has provided us with many classes. ArrayList, BitArray, HashTable, SortedList, Queue and Stack are some of them. They are all included in System.Collections namespace.
ArrayList
The main problem of traditional arrays is that their size is fixed by the number you specify when declaring the array variable: you cannot add items beyond the specified dimension. Another limitation is that you cannot insert an item inside the list. To overcome this, you can create a linked list. Instead of working from scratch, the .NET Framework provides the
ArrayList class.
With the ArrayList class, you can add new items to a list, insert items inside a list, arrange items of a list, check the existence of an item in a list, remove an item from the list, inquire about the list, or destroy the list. These operations are possible through various properties and methods.
Hashtable
The System.Collections namespace provides a Hashtable container. A Hashtable represents a key/value pair in which the key is used for fast lookup.
BitArray
The BitArray class supports a collection of bits which are represented as Booleans. Because it stores bits rather than objects, BitArray has capabilities different from those of the other collections. However it still supports the basic collection underpinning by implementing ICollection and IEnumerable. It also implements ICloneable.
Event-driven programming with WinForm
Event-driven programming with WinForm
Windows applications that we create fall under two major categories�managed and unmanaged. Unmanaged Windows applications can be created using Microsoft Foundation Classes (MFC). Managed applications run under Common Language Runtime (CLR) and are created using .NET Framework Class Library. These applications are called WinForm applications. WinForms (Windows Forms) create graphical user interface (GUI) for Windows applications. A form is a top-level window of an application. It can be a window, a dialog or a multiple document interface (MDI) window.
Creating WinForms has many advantages over creating applications using MFC. In unmanaged Windows-based programs, we need to apply certain styles to the window only when it is created. WinForms eliminate this quirk. If we apply styles that are meant to be applied at creation time, .NET destroys the previous window and creates a new one with new styles.
The .NET Framework Class Library is richer than MFC. Also, the classes remain the same for all the .NET compliant languages. All the classes that are used to create and design a WinForm are encapsulated in System.Windows.Forms namespace. For example, the System.Windows.Forms.Form class is used to create the form, System.Windows.Forms.Button class is used to create a button and so on. To create a GUI, we place components and controls on the form and so, a form acts as a container of components and controls. To create the GUI we drag and drop the controls from Toolbox and change their properties to suit our requirements. When we drag the control on form and change properties, Visual Studio.NET generates suitable code for us. However, only adding controls to create a user interface is not enough. Our application must also respond when the user interacts with the application. A user can interact with the application by moving the mouse, clicking the mouse button, pressing a key, etc. Whenever a user interacts with the GUI, events are generated. Events are notifications sent to the container, which can then respond to it. For example, when we click a button, an event is generated notifying that the user has clicked the button. In response, we can display a message box or do something else. This job is done in methods called �event handlers�. When a particular event is generated, the corresponding event handler gets called to process the event. For calling the event handlers, .NET takes help of events and delegates.
An event in C# is a multicast delegate having a predefined prototype. The prototype is such that every event returns a void and always accepts two parameters. The first parameter is always a reference to an object of System.Object class and the second parameter is always a reference to an object of the System.EventArgs class or a class derived from it. The EventArgs object contains information about the event. The object that raises an event is called an �event raiser� and the object that receives an event is called an �event receiver�. The event raiser class always declares the event and the receiver class must have an event handler to handle that event.
The first parameter collected by the event handler is always a reference to an event raiser object. The addresses of event handlers are stored inside the events (remember that events are actually delegates) and hence they also must have the same signature as the event. This kind of delegate is declared using the keyword event. To understand events, consider the following program.
using System;namespace Sample{ public class mouseeventargs { public int x,y; public mouseeventargs (int x1, int y1) { x = x1; y = y1; } } public delegate void click (object m, mouseeventargs e); public class MyForm { public event click c1; public void mouseclick() { mouseeventargs m = new mouseeventargs (10,20); c1 (this, m); } } class MyForm1:MyForm { public MyForm1() { c1 += new click (button_click); mouseclick(); } public void button_click (object m, mouseeventargs e) { Console.WriteLine (�Mouse Coordinates: � + e.x + � � + e.y) ; Console.WriteLine (�Type is: � + m.GetType().ToString()) ; } static void Main ( string[ ] args ) { MyForm1 f = new MyForm1( ) ; } }} In this program we have declared three classes�mouseeventargs, MyForm and MyForm1 derived from MyForm. The mouseeventargs class corresponds to the EventArgs class. This class contains two int variables x and y and a constructor to initialise them. We have declared a multicast delegate click whose signature is the same as the event handler button_click( ). The MyForm class here is an event raiser class and hence contains an event as a data member called c1 of the type click. It also contains a method called mouseclick( ). In this method we have created an object of the mouseeventargs class. In the statement,
c1 (this, m);
c1 encapsulates the button_click( ) method. this contains the reference of MyForm object (event raiser) and m is a reference of the mouseeventargs object. In the MyForm1 class, we have defined the method button_click( ) (i.e. event handler). When the compiler encounters the statement c1 += new click (button_click), it creates an event object (delegate object) that wraps up button_click( ) method. So whenever the c1 event is raised (or called, as in this program), the method button _click( ) would get executed.
We could call a method even by using a delegate. Then what are events for? Take a look at the following statement.
c1 = new click(button_click);
where, c1 is a delegate reference. This statement has a bug. Here, we are assigning a new delegate object to c1, and so, all the delegates previously added are now lost. Instead of = operator we should have used += operator to add a new delegate object to the delegate list. This would never happen in case of events. This is because we can perform only two operations on events, namely, += and -=. We cannot use = operator with events. As such, events provide a protection layer on delegates. When we use the += and -= operators with delegates, they get converted into a call to Delegate.Combine( ) and Delegate.Remove( ) methods. If we use += and -= operators with events they get converted into a call to add_c1( ) and remove_c1( ) methods. These methods in turn call the Delegate.Combine( ) and Delegate.Remove( ) methods.
WinForms also follow the same mechanism. Only thing is, we don�t need to invoke the event handlers ourselves. They get called automatically when events occur. The compiler adds suitable code such that when an event occurs our event handler would get called. Let us now see what code gets generated when we create a WinForm application and add an event handler.
The minimal code that is required to create a WinForm application is given below:
using System;using System.Windows.Forms;namespace WinFormDemo{ public class Form1 : Form { static void Main () { Application.Run ( new Form1( ) ) ; } }} Here, we have derived a class Form1 from the Form class and passed a reference to its object to the Application.Run( ) method. This method creates the form, displays it on screen and starts a message loop for it. Of course, we don�t need to write this code, Wizard generates it for us. If we add a control to the form, a reference to the class representing the control gets added to the class as a private member. If we add a button the reference to the Button class would get added as shown below.
private System.Windows.Forms.Button button1;
The reference button1 would get initialised in the InitializeComponent( ) method as given below.
this.button1 = new System.Windows.Forms.Button();
On adding a handler for the Click event, the code generated for it looks as given below.
this.button1.Click += new System.EventHandler(this.button1_Click);
The EventHandler is a delegate defined in the System namespace. This statement wraps the EventHandler around the button1_Click( ) method so that when the Click event is fired, button1_Click( ) method would get called. The definition of button1_Click( ) method is shown below.
private void button1_Click (object sender, System.EventArgs e){} The first parameter passed to button1_Click( ) method identifies the object that fired the event (button1 in this case). The second parameter contains additional information about the event.
The objects of every control class fire events. Now you can appreciate how easy it is to handle these events under .NET
Understanding Delegates
Understanding Delegates
A delegate is an important element of C# and is extensively used in every type of .NET application. A delegate is a class whose object (delegate object) can store a set of references to methods. This delegate object is used to invoke the methods. Many developers find delegates complicated. But believe me, it�s a simple concept to understand. In this article we will see how delegates work and in what situations they are used.
Let�s start with a simple program that shows how to declare and use a delegate.
class sample{ delegate void del1(); delegate void del2 (int i); public void fun() { del1 d1 = new del1 (f1); d1(); del2 d2 = new del2 (f2) ; d2 ( 5 ) ; } public void f1() { Console.WriteLine (�Reached in f1�) ; } public void f2 (int i) { Console.WriteLine (�Reached in f2�) ; }} In the sample class we have declared two delegates�del1 and del2. The statement delegate void del1( ) ;
indicates that the delegate del1 is going to encapsulate methods, which takes no parameter and returns void. When this statement is encountered, a class del1 derived from a pre-defined class MultiCastDelegate gets created. Similarly, the statement delegate void del2 ( int i ) ; indicates that the delegate del2 will be used for methods taking one integer and returning a void. This statement would create another class del2 derived from the MultiCastDelegate class. The classes del1 and del2 are called �delegate classes�. To use the delegate class, like any other class, we have to declare its reference. We have declared the reference to delegate class del1 in the fun( ) method through the statement del1 d1 = new del1 ( f1 ) ;
This would create a delegate object d1. To the constructor of the delegate class we have passed the address of the method f1( ). C++ programmers may know that mentioning a method name without parentheses represents its address. The delegate object would now hold an address of the method f1( ). Next, we have called the f1( ) method using the delegate object d1. This is achieved using the statement d1( ) ;
If d1 is an object, how can we use it as if it is a method? Actually, the call d1( ) gets converted into a call to the d1.Invoke( ) method. The Invoke( ) method calls the f1( ) method using its address stored in delegate object. A delegate can contain references to multiple methods. In this case a single call to Invoke( ) calls all the methods.
Similar to d1 we have instantiated another delegate object d2 and stored in it an address of the method f2( ). As the method f2( ) takes an integer as a parameter we pave passed 5 to d2( ). The value 5 would get passed to all the methods whose references are stored in this delegate object. This makes it obvious that the signature of the delegate and that of the methods to be invoked using the delegate must be identical.
If we create an object of sample class and call the fun( ) method both the f1( ) and f2( ) methods would get called through d1 and d2 respectively.
Delegates make possible calling of methods using reference to methods the object oriented way. This avoids using any complex technique like pointers to functions.
Delegates in Inheritance
Suppose there is a base class and a class derived from this class. A method is invoked from a base class method using a delegate. We can initialise this delegate in derived class so that when the method is invoked from the base class it is the derived class�s method that would get called. Here is the program that works similar to this situation.
using System; namespace delegateinherit{ public delegate void del1(); class mybase { public del1 d; public void fun() { d(); } } class der : mybase { public der() { d = new del1 (f1); fun(); d = new del1 (f2); fun(); } public void f1() { Console.WriteLine (�Reached in f1�) ; } public void f2() { Console.WriteLine (�Reached in f2�) ; } } class Class1 { static void Main (string[] args) { der d = new der(); } }} Here, from the fun( ) method of the mybase class we have used the delegate object d to invoke a method. The fun( ) method is called twice from the constructor of the derived class der. Before calling fun( ) method, we have associated the delegate d, first with method f1( ) and then with f2( ). Thus, if we create an object of the der class, first the f1( ) and then f2( ) method get called. We can invoke both the methods in a single call to fun( ) as shown below.
d = new del1 ( f1 ) ;
d += new del1 ( f2 ) ;
fun( ) ;
Where Delegates are useful
In a general WinForm application, a class Form1 gets created, which is derived from the Form class. If we want to handle mouse click messages, we override the OnMouseDown( ) message handler in the Form1 class. When we click the mouse button, control reaches to the OnMouseDown( ) of the derived class i.e Form1 class because of the simple rule of inheritance. But if we click on a push button on the form, the OnMouseDown( ) of the Form1 class does not get called. Because Form1 class is not derived from the class that creates button. In such a situation, delegates prove useful. Calling methods using delegate require only that the signature of methods and that of the delegate should match. It does not require any inheritance chain to call the appropriate method. So, in .NET, all the event handlers are called through delegates, instead of relying on the inheritance chain.
Delegate at work
As said earlier, all the event handlers are called using delegates. We will now see a dummy program to explain how the Paint event handler must be getting called using a delegate.
using System;namespace delegateatwork{ public delegate void PaintHandler(); class Form { public PaintHandler Paint ; public void OnPaint() { Paint(); } } class form1 : Form { public form1() { Paint += new PaintHandler (form1_Paint); OnPaint() ; } public void form1_Paint() { Console.WriteLine (�form1_Paint�); } } class Class1 { static void Main (string[] args) { form1 f = new form1(); } }} We have designed a class Form1 that contains a method called Form1_Paint( ). The Form1 class is derived from the Form class. In the Form class we have declared an object Paint of the delegate class PaintHandler. In
Subscribe to:
Comments (Atom)