Drived Class must serializable

While a class is marked serializable and later another class extends the same class then by default everything in the parent class will be with derived class too. But it not means that if parent class is serializable then child not need to implement the serializable interface as parent already have, because the implementing of serializable by parent means all the properties of the parent are serializable in parent as well as in child but as child properties are not marked as serializable so we must specify explicitly the child class methods too as serializable or we need to mark child class to implementing serializable.

Disable right click/text selection in web page

In case its required no one can use right click context menu in browser while opening the page to restrict all the operations possible with context menu commands the the following is the command that will do the job 

document.oncontextmenu = function(){return false;}; 

In case its also required to restrict the selection of text as if text will be able to selected then hot keys can copy the contents but disabling selection of text can prohibit the copy. So to disable the selection the following will disable text selection.

document.onselectstart= function() {return false;};  

And if these commands are written in the javascript code block then the specified features will be enforced after complete page is loaded with javascript block.

JavaScript Debugging [Visual Studio]

The various steps to enable java script debugging is as given below:

1. ASP.Net application configuration to enable debugging

Open the ASP.Net application in Visual Studio and open ‘web.config’ that created with application and find the tag ‘compilation’ in the file. The line may look like as below:

If debug=”false” then set it to debug=”true” and resulting will look like as below:

2.    IIS Configuration to support debugging

Start --> Settings --> Control Panel --> Administrative Tools --> Internet Information Services (IIS)
--> Expand Web Sites --> Default Web Site --> right click on your web project required to be debugged and select properties --> click Virtual Directory Tab --> click configuration button --> and in the new opened window click Debugging Tab and ensure that two check boxes labeled 1. “Enable Server Side Script Debugging” 2. and “Enable Client Side Script Debugging” to be checked.

3. Configure Web browser for debugging:

 Open IE and click on menu Tools --> Internet Options --> Advanced Tab --> if ‘Disable Script Debugging (Internet Explorer)’ and Disable Script Debugging (Other)’ check boxes are checked then uncheck those two check boxes and click button OK. (Refer below Screen Shot)

4.    Attaching ASP.Net process to Visual Studio:

If application is opened in VS 2003. Then under Tools menu select attach a process and select aspnet process and attach the process to the application.
If you open the project in VS 2005 or later then it does not require you to explicitly attach the aspnet process. In the JavaScript add a break point where you want to debug and also add a break point in the .vb or .cs code file where the JavaScript function is called.

Now run the application. The application running will break at the break point within the javascript code as required.

Features

The JavaScript debugger presents many standard debugging features. The following list provides a review of some of these features.

• Breakpoints: Breakpoints allow you to stop code execution at specific points within the source code. JavaScript breakpoints work just like C#/VB breakpoints.
  Breakpoints are set/cleared by clicking to the left of the code within the IDE; by using the Debug menu or by using the Breakpoint Context menu available by right-clicking on the code. In addition, you may create conditional breakpoints to allow you to define conditions for the breakpoint, as well as set up a macro to run or a message to print when the breakpoint is triggered.
  Breakpoints are viewable in the Watch window located by default in the lower left of Visual Studio 2008.
• Call Stack: The Call Stack tab in the lower right of Visual Studio 2008 allows you to view what is being called when the ASP.NET page is loaded/running.
• Locals: The Locals tab in the lower left of Visual Studio 2008 allows you to view the values of variables and objects during script execution. Also, you may change the contents of one of the local variables while the page is running.
• Execute code: The Immediate Window tab in the lower right of Visual Studio 2008 allows you to execute JavaScript code on-the-fly during page execution.

The Debug drop-down menu within Visual Studio 2008 provides a Windows submenu that allows you to define what windows to display while debugging. For example: Locals, Watch, Call Stack, and Immediate Window.
The most used feature during debugging is often breakpoints because you can use them to stop code execution and examine the state of variables and objects at that point in the script. Breakpoints provide a number of features (which are available via the Debug drop-down menu during a debugging session) for their use.
Code execution stops at each breakpoint — unless it is a conditional breakpoint whose condition has not been met. Once the code is halted, you may choose to continue one line at a time or until the next breakpoint is encountered.
The debugger is actually enabled via the Debug menu in Visual Studio 2008. You go to Debug | Start to begin a debugging session or press [F5]

Dispose method and Finalize method

Finalize Method: As .net provides a great feature of memory management which handles all kind of allocations and de-allocations automatically and for de-allocating it uses Garbage Collector. So in .NET Garbage collector does almost all clean up activity for your objects. But all the process that can happen for de-allocation is applicable only that are managed by CLR or that are constructed according to the .Net but those object that are not managed by .Net CLR are un-managed codes/objects can not be de-allocated directly by GC So these unmanaged resources (ex: - Windows API created objects, File, Database connection objects, COM objects etc) that are outside of the scope of .NET framework are needed to be cleaned explicitly. For these types of objects .NET framework provides Object.Finalize method which can be overridden for our own code execution within this function and which can be used to clean up code for un-managed resources. This method is used in VB.Net which is called by CLR when Garbage Collector destroys an object. While in C# destructors are there for the same purpose.

Dispose Method: .NET provides “Finalize” method in which we can clean up our resources. But relying on this is not always good. This is because it is only called by the GC and you can't determine when it will be called (even though you can force it to be called, but that's not recommended).So the best is to implement “Idisposable” interface and implement the “Dispose” method where you can put your clean up routines.

But benefit of finalize over Dispose is that finalize is executed itself and not required to be called while Dispose is required to be called. So in case we require to execute dispose itself then we can call it within finalize which is executed by CLR while destroying the object. But in case we define call dispose this way also developer called dispose too at somewhere then call dispose can occur twice that can throw exception or some issue so to avoid call twice we can suppress the call to finalize after dispose by using GC.SuppressFinalize within dispose function some in that case if dispose is not called then it will be executed with finalize while if its called then suppressfinalize call will suppress the call to finalize method. Below is the sample code of the pattern. This is the
best way we do clean our unallocated resources and yes not to forget we do not get the hit
of running the Garbage collector twice in this case.


Note:- It will suppress the finalize method thus avoiding the two trip.

Publish Post

Public Class ClsTesting
Implements IDisposable
Public Overloads Sub Dispose()Implements IDisposable.Dispose
' write ytour clean up code here
GC.SuppressFinalize(Me)
End Sub
Protected Overrides Sub Finalize()
Dispose()
End Sub
End Class

Abstract Class And Interface Class

Interface Class: Its some kind of contract between developer/Class implementation and real world/caller of class object that commits what kind of the provisions will be their that can be accessed from the class implementation and also implementation is bound to provide the implementation of this contract.

Abstract Class: Its also define some kind of contract that a implementing class signs and bound to implement all the abstract functions for which no implementation is provided in the abstract class. So outer world of implementing class have knowledge of all the provisions and availability of functionality that can be called directly from the object of implementer class.

Benefit of Interface over Abstract class: As from the definition of the abstract class question arises that when everything that an Abstract class enforce or provide then why concept of Interface still exists the most well known answer of this question comes while an implementing class comes to the situation when it has to implement more than one kind of contracts to the outer world which makes the requirement of multiple inheritance which is not possible in case of abstract class as an implementer class can not implement more than one abstract class but it can implement more than one Interface.

Benefit of Abstract class Over Interface: Both seems to be related to contract between object calling and class providing implementation of interface. Also in case of existence of interface class an additional benefit it also facilitate with the feature of multiple inheritance then why abstract class exists. Answer to this query comes from abstract class's another feature that says if some of the implementation that is known and predefine also is common and usable in derived classes too then in case of abstract class we can implement this functionality in abstract class itself that will be available with all the derived classes which is not possible with usage interfaces.

If there is any other difference/benefit for these then I request to viewers to add their comments that can be beneficial for other viewers too.

SQL Query: Second Maximum/Second Minimum

Tip to find the first max/min is predefined but what about second. Here is one of the tip for well known table employee

Second maximum salary
Select max(salary) from employees where regid NOT IN
(Select max(salary) from employees)

Second minimum salary
Select min(salary) from employees where regid NOT IN
(Select min(salary) from employees)

Visual Studio 2010 .Net Framework 4.0 Some of the enhavements

Following are some of the Visual Studio 2010 and .NET Framework 4 IDE Enhancements
1. Multi monitor support
2. Multi targeting
3. Parallel Development
4. Side by Side execution
5. Backward compatibility and SqlServer 2008 integration.
6. Add Reference enhancements for developers
7. Windows 7 support for developers
8. Share Point 2010 enhancements
9. Office Business Application Support
10. Cloud Development
11. Document Map Margin and Visual Studio 2010 Tips.

Following are some of the applications we can develop using the .NET Framework 4.0.

* Console Applications
* Windows Forms applications
* Windows Services
* WPF Browser applications
* WPF Applications
* Web Applications
* Web Services, Ajax enabled Web Services
* Dynamic Data entities Web Applications
* Dynamic data LINQ to SQL Web Applications
* Office Applications
* Reporting applications like crystal reports
* Cloud Services using Windows azure tools
* SharePoint projects, Business Data Connectivity model and workflow applications
* Sliverlight applications
* WCF Services, Ajax enabled WCF services
* Workflow console and workflow service applications
* CLR Console applications using VC++
* MFC and win32 applications
* Data Tier Applications and advanced database applications.


Refernce