Ravi Pahuja - Share your experiences

Object are passed by reference

2011-08-10T21:03:00.003+05:30

Passing values in c# is really misunderstood by many people.

Let's understand this concept by few examples:

StringBuilder first = new StringBuilder();

StringBuilder second = first;

first.Append ("hello");

first = null;

Console.WriteLine (second);

Output: Hello

When we assign reference to second of first, we are acutally assigning the object reference contact by first. So when we set first to null, now first is not refering to any object, however second is still referening to that object.

Now

void Foo (StringBuilder x)

{

    x = null;

}



...



StringBuilder y = new StringBuilder();

y.Append ("hello");

Foo (y);

Console.WriteLine (y==null);
 Output: False

Interesting right!

 
Actually when we are passing object by reference, we are not passing the actual

reference to first object, instead we are just passing hte values.

The value of a reference type variable is the reference - if two reference type

variables refer to the same object, then changes to the data in that object will

be seen via both variables.

Reference types stored on Head and value types on Stack

2011-08-10T20:09:00.000+05:30

We usually think that reference types are stored on the Head, right. Yes we are right.

But we do think that value types are stored on Stack and here we are always not right.

Only local variables are stored in the stack, so what's this local variables? Local variables declared within methods and method parameters live on stack. So when on heap? If they are declared within the class. Value types lives on wherever they are declared. So if they are created in reference type ex, class they would be stored on heap, and if declared locally ex. within method then stack.

Are Structs really lightweight classes?

2011-08-10T19:45:00.000+05:30

We usually have very common myth about "Struts" that they are simple and should be used as data transfer types and they are lighter in terms of performance as they do not require garbage collection.

But that is not fact in all cases.

We should be careful while choosing between struct or reference type.

It could more better to pass few bytes of data as reference rather than copying all the data, example passing Hashtable instance. Just imagine if Hashtable is values type, passing whole hashtable instead of the reference.

C# Notes

2011-07-23T08:14:00.001+05:30

C# important notes:

1. Delegates provide a way of giving a level of indirection, so that instead of specifying behavior directly, it can be in some way "contained" in an object, which can be used like any other object, where one available option is to execute the encapsulated behavior.

A delegate type is a single-method interface , and a delegate instance is an object implementing that interface.

Delegates are typically used when the code that wants to execute the actions doesn't know the details of what the action should be.

Four things need to happen:

■ The delegate type needs to be declared.
■ There must be a method containing the code to execute.
■ A delegate instance must be created.
■ The delegate instance must be invoked.

Delegate Type :
A delegate type is effectively just a list of parameter types and a return type. It specifies what kind of action can be represented by instances of the type. For instance, consider a delegate type declared like this:

delegate void StringProcessor (string input);

The code says that if we want to create an instance of StringProcessor, we’re going to need a method with one parameter (a string) and a void return type (the method doesn’t return anything). It’s important to understand that StringProcessor really is a type. It has methods, you can create instances of it, pass around references to instances, the whole works.

In .NET, delegate instances always refer to methods.

void PrintInteger (int x)

An instance of that delegate type, specifying that this method be executed when the delegate instance is invoked. Action of the delegate instance.

StringProcessor proc1, proc2;
proc1 = new StringProcessor(StaticMethods.PrintString);

InstanceMethods instance = new InstanceMethods();
proc2 = new StringProcessor(instance.PrintString);

Example 1:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Delegates_28July2011_7PM
{

    //1. Declare delegate type.
    delegate void StringProcessor(string input);

    class Person
    {
        public string Name { get; private set; }

        public Person(string name)
        {
            Name = name;
        }

        //2. Declare compatible INSTANCE method.
        public void Say(string message)
        {
            Console.WriteLine("{0} says: {1}", Name, message);
        }
    }

    class Background
    {
        //2. Declare compatible STATIC method.
        public static void Not(String Note)
        {
            Console.WriteLine("{0}", Note);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person objPerson1 = new Person("Ram");

            Person objPerson2 = new Person("Shyam");

            //3. Creates three delegate instance
            StringProcessor ramVoice, shyamVoice, background;
            ramVoice = new StringProcessor(objPerson1.Say);
            shyamVoice = new StringProcessor(objPerson2.Say);
            background = new StringProcessor(Background.Not);

            //4. Invokes delegates instance.
            ramVoice("Namaskar");
            shyamVoice("Skhaa");
            background("This is really sweet");

            Console.ReadLine();

        }
    }
}

Transaction Rollback

2011-07-20T18:36:00.003+05:30

USE master;

ALTER DATABASE AdventureWorks

SET SINGLE_USER

WITH ROLLBACK IMMEDIATE;

ALTER DATABASE AdventureWorks

SET MULTI_USER;

Running above script will give following result.

Nonqualified transactions are being rolled back. Estimated rollback completion: 100%.

HTML 5

2011-01-20T15:45:00.000+05:30

HTML 5 is really sexy.... and I am dam sure that it's going to change the way we see the websites...

Rough Timeline of Web Technologies

1991 HTML
1994 HTML 2
1996 CSS 1 + JavaScript
1997 HTML 4
1998 CSS 2
2000 XHTML 1
2002 Tableless Web Design (remember we started using div instead of tables...)
2005 AJAX (no postback..page flickering gone)

and its HTML 5...I have started learning it and will continue to publish the things, I learn with HTML 5

Interesting thing about HTML 5 is it's HTML5 = HTML + CSS + JS

Best Practices for C# Application Development

2010-10-19T20:41:00.002+05:30

Decide between Value Types and Reference Types

Whenever you need to create a type, first ask yourself a question “What you want and Why you want?”. If you could answer your question, you can decide between the type you want to use. If you want to store your data, use value types and when you want to create an instance of your type by defining the behavior, use reference types. Value types are not Polymorphic whereas, the Reference types can be. Value types are most efficient in terms of memory utilization over reference types and produces less help fragmentation & garbage. If you want to pass values to a method implementation, decide what you want to do and based upon your requirement, decide between value types and reference types. Use of reference type variables actually change the original value but use of value type will create a copy of the original variable and pass across the method. Thus, protects your original value from accidental changes. Lets see them in real example. In the below code, we are passing the variable “i” as value type and in the method implementation incrementing it by 10. As it was passed by value, you will see the original value “5” as output of the program code.

static void Main(string[] args)
{
int i = 5;
SetValues(i);

System.Console.WriteLine("Currently i = " + i); // will print "Currently i = 5"
}

static void SetValues(int x)
{
x += 10;
}

In the below code as we are sending “i” as a reference, it will change the original value of “i” inside the method and hence you will see 15 as the output in the screen.

static void Main(string[] args)
{
int i = 5;
SetValues(ref i);

System.Console.WriteLine("Currently i = " + i); // will print "Currently i = 15"
}

static void SetValues(ref int x)
{
x += 10;
}

Prefer Runtime Constants over Compile time Constants

Runtime constants are always preferred than the Compile time constants. Here you may ask what is runtime constant and what is compile time constant. Runtime constants are those which are evaluated at the runtime and declared with the keyword “readonly”. Other side, compile time constants are static, evaluated at the time of compilation and declared with the keyword “const”.

public readonly string CONFIG_FILE_NAME = "web.config"; // runtime constant
public const string CONFIG_FILE_NAME = "web.config"; // compile time constant

So, what is the need to prefer readonly over const variables? Compile time constants (const) must be initialized at the time of declaration and can’t be change later. Also, they are limited to only numbers and strings. The IL replaces the const variable with the value of it over the whole code and thus it is a bit faster. Whereas, the Runtime constants (readonly) are initialized in the constructor and can be change at different initialization time. The IL references the readonly variable and not the original value. So, when you have some critical situation, use const to make the code run faster. When you need a reliable code, always prefer readonly variables.

Prefer “is” and “as” operators while casting

It is better to use “is” and “as” operator while casting. Instead of Explicit casting, use the Implicit casting. Let me describe you with the example of a code.

// this line may throw Exception if it is unable to downcast from Person to Employee
var employee = (Employee) person;

In the above code, suppose your person is a Customer type and when you are converting it to Employee type, it will throw Exception and it that case, you have to handle it using try{} catch{} block. Let’s convert the same using “is” and “as” operators. See the below code:

// check if the person is Employee type
if(person is Employee)
{
// convert person to Employee type
employee = person as Employee;
}

// check if the person is Customer type
else if(person is Customer)
{
// convert person to Customer type
customer = person as Customer;
}

In the above code you can see that, in the second line I am checking whether the person is a Employee type. If it is of type Employee, it will go into the block. Else if it is a Customer type, will go to the block at line 12. Now, convert it with the “as” operator, as shown in the line 5. Here, if it is unable to convert, will return as null but will not throw any exception. So, in the next line you can check whether the converted value is null. Based on that, you can do what you want.

Always prefer the foreach(…) loop

Rethrow exception and InnerException property in .NET

In the example below, we have re-thrown exception with only a friendly message in the constructor method.

private void DivideOperation()
{
try
{
int x = 5;
int y = 0;
int result = x/y;
}
catch (Exception ex)
{
throw new DivideByZeroException(“Invalid operands were given.”);
}
}

This is, of course, not a good practice to do exception handling. So to preserve the details of the original exception, we have to pass the exception object as a second parameter in addition to friendly message as:

private void DivideOperation()
{
try
{
int x = 5;
int y = 0;
int result = x/y;
}
catch (Exception ex)
{
throw new DivideByZeroException(“Invalid operands were given.”, ex);
}
}

TSQL Search in text in stored procedure

2010-09-24T20:53:00.000+05:30

SELECT Distinct SO.Name
FROM sysobjects SO (NOLOCK)
INNER JOIN syscomments SC (NOLOCK) on SO.Id = SC.ID
AND SO.Type = 'P'
AND SC.Text LIKE '%SuspendS21%'
ORDER BY SO.Name

XML based log file.

2010-08-20T18:11:00.000+05:30

XML file defines the structure:

<messagelog>
<msgn>
    <msg> message </msg>
    <mdtls> message details </mdtls>
    <mtype> message type </mtype>
    <sname> Service Name</sname>
    <dt> datetime </dt>
    </msgn>
</messagelog>

Code file:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;

namespace FXA_LogFile
{
        ///

/// This class is used to log the message across the application in XML file.
///

        public class LogHandler
        {
            ///

/// This is used to identify the message type in the xml file.
///

            enum MessageType
            {
                Error=1,
                Warning=2,
                Inforamation=3
            }

            ///

/// This method is used to record the message of error type
///

            ///
Short error message
            /// Error message description
            /// Name of service.
            public static void LogErrorMessage(string errorMessage, string errorDetails, string serviceName)
            {
                WriteMessageToXMLFile(errorMessage, errorDetails, MessageType.Error, serviceName);
            }

            ///

/// This method is used to record the message of warning type
///

            /// Short warning message.
            /// Warning message description.
            /// Name of service.
            public static void LogWarningMessage(string warningMessage, string warningDetails, string serviceName)
            {
                WriteMessageToXMLFile(warningMessage, warningDetails, MessageType.Warning, serviceName);
            }

            ///

/// This method is used to record the message of information type
///

            /// Short information message.
            /// Information message description.
            /// Name of service.
            public static void LogInformationMessage(string informationMessage, string informationDetails, string serviceName)
            {
                WriteMessageToXMLFile(informationMessage, informationDetails, MessageType.Inforamation, serviceName);
            }

            ///

/// This method append the message in the xml file.
///

            /// Short message.
            /// Message description.
            /// Type of message.
            /// Name of service.
            private static void WriteMessageToXMLFile(string message, string messageDetails, MessageType varMessageType, string serviceName)
            {
                XmlDocument doc = new XmlDocument();
                string xmlPath = @"FXA_Logfile.xml";
                doc.Load(@xmlPath);
                XmlNode newXMLNode, oldXMLNode;
                oldXMLNode = doc.ChildNodes[1].ChildNodes[0];
                newXMLNode = oldXMLNode.CloneNode(true);
                newXMLNode.ChildNodes[0].InnerText = DateTime.Now.ToString();
                newXMLNode.ChildNodes[1].InnerText = message;
                newXMLNode.ChildNodes[2].InnerText = messageDetails;
                newXMLNode.ChildNodes[3].InnerText = varMessageType.ToString();
                newXMLNode.ChildNodes[4].InnerText = serviceName;
                doc.ChildNodes[1].AppendChild(newXMLNode);
                doc.Save(@xmlPath);
                doc.RemoveAll();
            }
        }
}

Best Practice SQL Server

2010-03-04T11:39:00.001+05:30

Please understand the logical query processing of a query, so that you can write better queries:

SELECT h.*,hp.HomePhotosID,hp.HasColorPhoto
FROM Home h
LEFT join HomePhotos hp
ON h.HomeID = hp.HomeID
AND h.Taxes = -555

logical query processing :

FROM (incl joins)
ON
OUTER
WHERE
GROUP BY
HAVING
SELECT
ORDER BY
TOP

CLR Integration

The benefits of integrating the CLR with SQL Server include:

1. The T-SQL statements that you execute actually run on the server end. But at times when you want to distribute the load between the client and server, you could go with the managed code. So using managed code you could perform critical logic operations in client side so that the server could be busy only with data intensive operations.

2. The fact that SQL Server provides you extended stored procedures to avail certain system related functions from your T-SQL code, but at the same time you may have to compromise with the integrity of the server. When it comes to managed code, it provides type safety, effective memory management and better synchronization of services which is integrated tightly with the CLR and, hence, the SQL Server 2005. So this means that integrating CLR with SQL Server provides a scalable and safer means for accomplishing tasks which are tougher or almost impossible using T-SQL.

3. .NET Framework provides a rich support for handling XML based operations from managed code; although realizing the fact the SQL Server supports XML based operations, you could perform such operations using .NET with little effort when compared to using T-SQL scripts.

4. Nested transactions in T-SQL have limitations when dealing with look back connections, whereas this could be better achieved using managed code by setting the attribute "enlist=false" in the connection string.

5. When working T-SQL you may not be able to fetch rows which form the middle of the operation from a result set until the execution gets finished. This is termed as pipelining of results which could be achieved with CLR integration.

If you could check your database configuration you could notice that the CLR Integration is turned off by default. Enabling or disabling of CLR integration could be done by setting the "clr enabled" option to 1 or 0. Once the CLE integration is disabled, all the executing CLR procedures are unloaded across all application domains. To turn it on you need to use the following.

Use Row versioning-based isolation levels

Row Level Versioning help in situations where an applications lot of insert and update operations on the data and at the same time a bunch of reports are accessing in parallel. It could also prove beneficial if your server is experiencing relatively high deadlocks. Also for systems performing mathematical computation, they require accurate precision and RLV gives a greater amount of accuracy for such kind of operations.

Error handling

use Try...Catch

BEGIN
    TRY
    BEGIN TRANSACTION
    …..
    --perform insert update and delete statements
    …..
    …..
    COMMIT TRANSACTION
END TRY
BEGIN
--Start
    CATCH
    ROLLBACK TRANSACTION
    PRINT ERROR_NUMBER()
    PRINT ERROR_SEVERITY()
    PRINT ERROR_STATE()
    PRINT ERROR_PROCEDURE()
    PRINT ERROR_LINE()
    PRINT ERROR_MESSAGE()
--End
END CATCH

Best Practices to handle Queries

Stored procedures help improve the performance since they are precompiled.
Avoid using like and notlike operatiors
Avoid using function in where clause.
Insead of CURSOR'S use temporary table with While.
Select only those rows or columns that are needed in the result set

Index

Create indexes on columns which are used in WHERE condition and ORDER BY, GROUP BY and DISTINCT clauses.
Indexes which are not used may cause extra overhead, so remove them if not in use.

Best practices in using Stored Procedures
Do not use prefix in your stored procedures, i.e., do not prefix them with sp_. Microsoft ships system procedures which are prefixed with sp_. So if you prefix your procedures with sp_, SQL Server will first search in the master database for the procedure and then in your application database.
If you do not want your client application to check the rows affected for an operation, then it is advisable to use SET NOCOUNT ON in your stored procedures.

INamingContainer Unique Name

2010-01-25T12:03:00.000+05:30

The Web page is a naming container for the controls that are added to it. A naming container defines a unique namespace for control names. Within a naming container, every control must be uniquely identifiable.

How can multiple GridView controls be added to a Web page, and then, when their child controls are created, each has its own unique ID property? This is because the GridView control is a naming container.

The naming container for a given child control is a control above it (parent or higher) in the hierarchy that implements the INamingContainer interface. A server control implements this interface to create a unique namespace for populating the UniqueID property values of its child server controls. The UniqueID property contains the fully qualified name of the control. The difference between this property and the ID property is that the UniqueID property is generated automatically by the NamingContainer and contains the NamingContainer information.

What is Dynamic Web Site Compilation ?

2010-01-25T10:19:00.001+05:30

Dynamic Compilation refers to the delayed compilation of Web pages that takes place until the user requests the Web page.

With dynamic compilation, the Web site doesn’t produce a deployable executable assembly as its output when it is built in Visual Studio 2005. Instead, each page is compiled when it is requested. The compiled page has a dependency on the source file’s timestamp. If the source code is changed, the page is recompiled the next time it is requested.

In ASP.NET 2.0, because each Web page produces its own DLL, Visual Studio 2005 allows you to select a programming language for each Web page.

Benefits:

The entire application does not need to be recompiled every time a change is made to a single page or component, which is especially great news to developers of large Web sites. Remember that each page is recompiled as needed based on the timestamp of the source code files.

Pages that contain compile errors do not prevent other pages in the Web site from running. This means that you can test Web sites that contain pages still in development.

ASP.NET Page Structure

2010-01-25T10:17:00.001+05:30

The typical Web page is composed of three sections: page directives, code, and page layout.

Page Directives This section is used to set up the environment, specifying how the page should be processed. For example, this is where you can import namespaces and load assemblies.

Code This section contains code to handle events from the page or its controls. Code can be placed in a

solution file (.sln) and a hidden solution user options file (.suo)

2010-01-25T10:09:00.001+05:30

The solution file is a text file that contains information such as the following:

■ A list of the projects that are to be loaded into Visual Studio 2005

■ A list of project dependencies

■ Microsoft Visual SourceSafe information

■ A list of add-ins that are available

The solution user options file is a binary file that contains various user settings related to the Integrated Development Environment (IDE), such as the following:

■ The task list

■ Debugger break points and watch window settings

■ Visual Studio window locations

Partial Classes

2010-01-21T15:23:00.001+05:30

allow a class to be split over multiple source files and have no effect on the intermediate code produced by the compiler.

The following are other points to keep in mind:

• Structs can use the partial modifier, but enumerations can’t.

• Assemblies form the boundaries of classes, and a partial class can’t span multiple assemblies.

• If one file marks a class as partial, all other declarations of the class must also use thepartial modifier.

• It’s legal for each partial class to add features to the class as long as they aren’t mutually exclusive.

C# 1:
Read only properties.
Weakly typed collections

C#2 :
Private property "setters".
Strongly typed collections

c# 3:
Automatically implemented properties
Enhanced collection and object intialization.

Constants and ReadOnly

2010-01-21T12:26:00.000+05:30

Because of the restriction on constant types being knowable at compile time, const can’t be
used in many situations.

The readonly modifier is designed for exactly that situation. By applying readonly, you can
set the value in the constructor or in an initializer, but you can’t modify it later.

ref and out

2010-01-21T11:05:00.000+05:30

They are usually used, when we needs to return more than one value from function.

Out parameters are like ref parameters except that an uninitialized variable can be passed to them and the call is made with out rather than ref

Assembly One line defination

2010-01-21T10:51:00.002+05:30

Metadata

• The name of the object
• The names of all the fields of the object and their types
• The names of all member functions, including parameter types and names

Runtime code can query the metadata—in a process called reflection—to find out what objects are available and what functions and fields are present on the class.

Manifest

Each assembly contains a manifest that enumerates the files contained in the assembly, controls what types and resources are exposed outside the assembly, and maps references from those types and resources to the files that contain the types and resources. The manifest also lists the other assemblies that an assembly depends upon.

Assemblies are self-contained; enough information exists in the assembly for it to be self-describing.

When defining an assembly, the assembly can be contained in a single file, or it can be split amongst several files. Using several files will enable a scenario where sections of the assembly are downloaded only as needed.

mscorlib.dll - which contains the core functions for the CLR

Enums - Enumerators declare a set of related constants—such as the colors that a control can take in a clear and type-safe manner.

Delegates are a type-safe, object-oriented implementation of function pointers and are used in many situations where a component needs to call back to the component that’s using it. They’re used most heavily as the basis for events, which allow a delegate to easily be registered for an event.

ILDASM can open an assembly, show all the types in the assembly, show what methods are defined for those types, and show the IL that was generated for that method.

checked/unchecked The checked and unchecked statements control whether exceptions are thrown if conversions or expressions overflow.

as

The as operator is similar to the is operator, but instead of just determining whether an object is a specific type or interface, it also performs the explicit conversion to that type. If the object can’t be converted to that type, the operator returns null. Using as is more efficient than the is operator, since the as operator needs to check the type of the object only once

OOPS

2010-01-21T10:10:00.006+05:30

Object:

An object is merely a collection of related information and functionality.

Inheritance

First, inheritance is an example of what’s known in object-oriented design as an “is-a” relationship.

Composition

Composition gives us a 'part-of' relationship.
Within composition, the lifetime of the part (Engine) is managed by the whole (Car), in other words, when Car is destroyed, Engine is destroyed along with it.

Aggregation

Aggregation gives us a 'has-a' relationship. Within aggregation, the lifetime of the part is not managed by the whole.

Polymorphism

An abstract class, which is a class that defines the functions a derived class must implement and that sometimes provides functions that are useful to both classes.

Abstract functions are automatically virtual functions, which allow the programmer to use polymorphism to make their code simpler. When there’s a virtual function, the programmer can pass around a reference to the abstract class rather than the derived class, and the compiler will write code to call the appropriate version of the function at runtime.

Polymorphism and virtual functions are used in many places in the .NET runtime system. For example, the base object object has a virtual function called ToString() that’s used to convert an object into a string representation of the object. If you call the ToString() function on an object that doesn’t have its own version of ToString(), the version of the ToString() function that’s part of the object class will be called, which simply returns the name of the
class. If you overload—write your own version of—the ToString() function, that one will be called instead, and you can do something more meaningful, such as writing out the name of the employee contained in the employee object.

Encapsulation

Overloading

Sometimes it may be useful to have two functions that do the same thing but take different parameters. This is especially common for constructors, when there may be several ways to create a new instance.

Virtual

Virtual means that when a call to a member function is made, the compiler should look at the real type of the object (not just the type of the reference) and call the appropriate function based on that type.

Sealed classes prevent a class from being used as a base class. They’re primarily useful to prevent unintended derivation.A sealed method lets a class override a virtual function and prevents a derived class from
overriding that same function.

Static Constructor will be called before the first instance of an object is created. It’s useful to do setup work that needs to be done only once.

exception handling in .net

2010-01-20T12:31:00.002+05:30

If the method does not do what it is supposed to do, it should throw an exception to notify it

Exception handling versus returning error codes

When using error code, we must usually find a way to also return whatever the method is supposed to return. That either makes us change the signature and use (out) parameters or (worse) embed the error code and the returned type into another class/structure.
Another reason, and probably most important one, is that whenever we call a method that returns an error code, we must test it otherwise, we may let the code execute in an unstable state and eventually, propagate the error to upper layers of the application. On the other hand, if we throw an exception, it should be either explicitly caught or the application will simply terminate. This makes the code more robust since even if we forget to catch an exception, we will notice it while testing which is not the case if we use error codes and forget to check returned codes.
An exception contains much more information than an error code. It contains the exact location of the encountered issue and it should contain, in the message, the exact reason of failure and, for well designed exceptions, how to fix the problem. We no longer need to document each error code and manage error codes duplications. The exception contains all the information developers need to know.
If we want an error to propagate to upper callers in the stack, we just let the exception unhandled and it will be propagated to upper layers. Whereas using codes, we must test for the code, return it and do this for all the callers of the method at all levels.
Exceptions can be instrumented and monitored using standard applications in Windows.
When debugging, we can set the debugger to start when a certain type of exception is thrown.

There are many “generic” exception types that can be used in different scenarios:

ArgumentInvalidException, ArgumentNullException and ArgumentOutOfRangeException
InvalidOperationException

If we consider these exceptions, we figure out that they may cover many cases of invalid arguments or, for the latest, an operation that we attempt to execute on an object in an invalid state for instance.

There are other exceptions that we should avoid using such as those thrown by the CLR (OutOfMemoryException, StackOverflowException and alike). Only the CLR should be able to throw these types.

Tester-Doer Pattern

Try-Parse Pattern

The Try Parse pattern consists in exposing a method and an exception safe version of the same method so that other programmers will be able to call it without paying attention to the exception. In .NET framework such pattern is used for the DateTime.Parse method. In fact, there is another version of this method called DateTime.TryParse which returns a boolean indicating whether the method succeeded or not and an OUT parameter that contains the resulting DateTime object in case it is successfull.

We should always avoid a Try-Catch-Finalize block with an empty Catch section. This will only hide potential issues. However, having a catch section that just rethrows the same exception can only be useful if the finalize section does something otherwise, we better remove the try-catch block at all.

Rethrowing and wrapping

When rethrowing the same exception, we better use ‘throw’ (without arguments) otherwise, we will loose stack information.
When wrapping an exception, it might be a good idea to include the original exception as the inner exception (to keep some information about the original context).
Consider wrapping exceptions to give more details about the context. For instance, a caching component (that does file caching) may have a FileNotFoundException thrown when it tries to access a cache file. However, for its users, that might not have enough information to understand the exception. In this case, we should wrap it in a CacheFileNotFoundException (custom type) that contains information on the query we have done to the caching component for instance.

When it finds a try block, it then looks for associated catch blocks. If it finds catch blocks, it picks the best one and executes the code within the catch block.

When an exception occurs, the proper catch block is determined by matching the type of the exception to the name of the exception mentioned. catch blocks always must be listed from most specific to least specific.

Reference : click here

NUnit

2010-01-20T09:35:00.000+05:30

Unit testing is validation and verification methodology where the developers test the individual units of source code.

1. Add reference dll " C:\Program Files\NUnit 2.5.2\bin\net-2.0\framework\nunit.framework.dll ".
2. include namespace using NUnit.Framework;

TestFixture: This is an attribute used to define on test class.

Test: This is attribute for method, used to define in the test class, this method actually contains the test logic.

Assert: This is an command, used to check if the expected output and the results return match

.net application memory leak

2010-01-20T08:34:00.001+05:30

Memory leaks grow slowly and after sometime they bring down the server by consuming huge chunks of memory. Maximum time people reboot the system, make it work temporarily but after some time again your server is down.

Task Manager - Can this detect memory leak ?

Task manager shows working set memory and not the actual memory used, ok so what does that mean. This memory is the allocated memory and not the used memory. Adding further some memory from the working set can be shared by other processes / application.

Using private bytes performance counters to detect memory leak

Private bytes are those memory areas which are not shared by other application.

Below are the steps we need to follow to track private bytes in an application using performance counters:-

Start you application which has memory leak and keep it running.
Click start à Goto run and type ‘perfmon’.
Delete all the current performance counters by selecting the counter and deleting the same by hitting the delete button.
Right click à select ‘Add counters’ à select ‘process’ from performance object.
From the counter list select ‘Private bytes’.
From the instance list select the application which you want to test memory leak for.

If you application shows a steady increase in private bytes value that means we have a memory leak issue here.

3 step process to investigate memory leak

What: - We will first try to investigate what is the type of memory leak, is it a managed memory leak or an unmanaged memory leak.
How: - What is really causing the memory leak. Is it the connection object, some kind of file who handle is not closed etc?
Where: - Which function / routine or logic is causing the memory leak.

.NET application have two types of memory managed memory and unmanaged memory. Managed memory is controlled by garbage collection while unmanaged memory is outside of garbage collectors boundary.

Private bytes are the total memory consumed by the application. Bytes in all heaps are the memory consumed by the managed code.

Un Managed memory + Bytes in all helps = private bytes

If the private bytes increase and bytes in all heaps remain constant that means it’s an unmanaged memory leak.
If the bytes in all heaps increase linearly that means it’s a managed memory leak.

Finalizers are responsible only for their own resources, while Dispose() also deals with referenced resources.

GC.SuppressFinalize() so that the garbage collector won’t bother to finalize this object.

AJAX application optimization tool

2010-01-19T14:30:00.002+05:30

Doloto- click to know more

Disable Back Button

2010-01-19T12:23:00.000+05:30

Force the previous page to expire. This solution isn't about disabling the Back button but selecting pages that you don't want the user to return to. When you force a page to expire then, when the user hits the Back button and returns to the page, the browser is forced to go back to the server to retrieve the page -- this gives your server-side code a chance to run.

This directive, added to a page in Source view, will do the job on most browsers:

‹%@ OutputCache location="none" Duration="1" VaryByParam="none" %›

You also do it from code by calling the SetCacheability method:

Reponse.Cache.SetCacheability(HttpCacheability.NoCache)

for more read this

Request Object Paths

2010-01-19T11:29:00.004+05:30

Here's a list of the Path related properties on the Request object (and the Page object). Assume a path like http://www.west-wind.com/webstore/admin/paths.aspx for the paths below where webstore is the name of the virtual.

Request Property	Description and Value
ApplicationPath	Returns the web root-relative logical path to the virtual root of this app. /webstore/
PhysicalApplicationPath	Returns local file system path of the virtual root for this app. c:\inetpub\wwwroot\webstore
PhysicalPath	Returns the local file system path to the current script or path. c:\inetpub\wwwroot\webstore\admin\paths.aspx
Path FilePath CurrentExecutionFilePath	All of these return the full root relative logical path to the script page including path and scriptname. CurrentExcecutionFilePath will return the ‘current’ request path after a Transfer/Execute call while FilePath will always return the original request’s path. /webstore/admin/paths.aspx
AppRelativeCurrentExecutionFilePath	Returns an ASP.NET root relative virtual path to the script or path for the current request. If in a Transfer/Execute call the transferred Path is returned. ~/admin/paths.aspx
PathInfo	Returns any extra path following the script name. If no extra path is provided returns the root-relative path (returns text in red below). string.Empty if no PathInfo is available. /webstore/admin/paths.aspx/ExtraPathInfo
RawUrl	Returns the full root relative relative URL including querystring and extra path as a string. /webstore/admin/paths.aspx?sku=wwhelp40
Url	Returns a fully qualified URL including querystring and extra path. Note this is a Uri instance rather than string. http://www.west-wind.com/webstore/admin/paths.aspx?sku=wwhelp40
UrlReferrer	The fully qualified URL of the page that sent the request. This is also a Uri instance and this value is null if the page was directly accessed by typing into the address bar or using an HttpClient. Based Referrer client Http header. http://www.west-wind.com/webstore/default.aspx?Info
Control. TemplateSourceDirectory	Returns the logical path to the folder of the page, master or user control on which it is called. This is useful if you need to know the path only to a Page or control from within the control. For non-file controls this returns the Page path. /webstore/admin/

For more details click on blog title...

Routing - .net

2010-01-19T10:24:00.003+05:30

Routing is a technique which enables us to use a descriptive, search engine and human friendly URL’s for ASP.Net application to access a resource.

namespace: System.Web.Routing - .Netframework 3.5 SP1

Initially, the ASP.Net routing engine is packed with the new ASP.Net MVC framework.

In order to provide routing in asp.net application, we need to first define routes and routing handler.

What is a Route?

A route is a format or pattern of URL we define for application. The route can have placeholders and constant values. The place holders will be replaced with the values that we supply in the URL during processing.

For example,

{controller}/{action}/{Category} -- /products/list/cars or /product/list/phones

Articles/{action}/{Category} -- /Articles/list/jQuery, /Articles/edit/jQuery

A Route is processed and resolved to a virtual path by a route handler. Once we defined our routes, we need to define our route hander to handle the request that follows the route pattern.

What is a RouteHandler?

A RouteHandler is an object that returns the instance of the actual ASP.NET page or HTTP Handler to complete the processing for the URL requested. A RouteHandler class should inherit the System.Web.Routing.IRouteHandler interface and implement GetHttpHandler() method.

Few example where to use typed dataset

2009-07-22T18:10:00.001+05:30

Below are some example where you can use typed dataset:

•The typed dataset isn't restricted to a table or even multiple tables. It can handle an XML file or even a text file by using a DataAdapter rather than a TableAdapter.
•You can create a typed dataset that allows you to update several related tables simultaneously from a single user form.
•You can display and use calculated values, even a value based on a column within the same record.
•The typed dataset simplifies your job because it's a reusable object. Drag it onto a form and it waits for you to determine the bound object instead of providing a default object.
•You can use multiple typed datasets on a form to handle related data, such as customers and orders.

(I found these on Devexpress)

set blinking cursor in textbox

2009-07-21T15:06:00.004+05:30

This is really very simple.
Use focus() and select() method.

like ::

document.getElementById(txtBox).focus();
document.getElementById(txtBox).select();

hide/show column or hidden value in grid using client side code for ASP.NET

2009-07-07T19:41:00.001+05:30

We all follow one problem with grid control that we need some value from one column but we do not want to display that value to user and this lead us to lots of problem.

The very easy solution to this problem is user css property display:none in style.

This is very easy to use and still we can get the control in javascript and get value.
Example

add label in templatecolumn :

asp:label id="lableid" runat="server" style=" style="display: none"

and now using itedatabound event attach your javascript and sent clientid of you label control in that. Now you can use the value in your lable control.

Difference between Response.Redirect and Server.Transfer

2008-04-22T14:12:00.002+05:30

This question was asked by a client "Difference between Response.Redirect and Server.Transfer"

I thought oh! so simple question is this and as obvious my answer was

Response.Redirect have a extra round trip to browser and Server.Transfer does not have a extra trip (As had gone through this difference a lots of time in the web and whenever I found on the same I found the answer as provided above)

Now I am bowled
Where would you use which one ?????

Offfff I never thought of this...........

So I have given a wrong answer... and result you must be sure about the Result.....

So I decided to get the bottom of this and found one more interesting thing::

Response.Redirect :: User is redirected to new URL and you needs to pass the values in query string but not the page state.
Server.Transfer :: You can pass the state of page to another page but use is not aware of transfer to new URL as in the address bar URL remains the same, so he can not add to bookmark. This means that things like relative links / image paths may not work if you transfer to a page from a different directory.

God Help

2008-04-22T14:02:00.003+05:30

Hi!!

I have left my previous organization and joined a new CMMI 5 organization. No project has been allocated so far. This is very boring the initial days in a new company.

No Project
No Contacts
No Mails
No Messenger
No Software’s are installed on the machine. Really very boring but I have found a solution for good time pass. Let’s read some book and then blog ;)
Tomorrow onwards I will bring some book and will make sure no more boring days.
Let’s read something interesting.............

Offfffff the days are really bad. My PC motherboard was not working properly, so I send this for replacement. No chance at home also.

Really this is hard to live without a machine installed VS.NET

Good please save and provide me a machine with VS.NET (No more virtual labs... please god ;)

VS 2005 - The breakpoint will not currently be hit. No symbols loaded for this document.

2007-09-04T18:37:00.000+05:30

Today something strange happen while just coding in ASP.NET with VS.NET 2005. Everything was just working fine, suddenly I got the error message :

" VS 2005 - The breakpoint will not currently be hit. No symbols loaded for this document. "

I was not able to debug the code in .cs files. I tried to find out the solution on the net with searching for " VS 2005 - The breakpoint will not currently be hit. No symbols loaded for this document. " in search engine. But no help. But I was sure here is some problem with the build process. Finally one thing I found one thing that this stores the some files at
"C:\Documents and Settings\UserId or Name\Local Settings\Application Data".

I deleted all the files in folder "Application Data"(exception few which I was not able to delete).
Then this was the step I must have performed in step 1. Yes this was all done and I was able to debug my application.

2007-07-06T15:44:00.000+05:30

Questionnaire on SharePoint

Question 1 : What you understand by WSS ?

Answer 1 : WSS stand for Windows SharePoint Server and is freely available as a Windows 2003 server component. This is a collaboration tool that help people to stay connected across organization and geographic boundaries.

WSS helps teams stay connected and productive by providing easy access to the people, documents, and information they need to make more informed decisions and get the job done.WSS provides a foundation platform for building Web-based business application that can flex and scale easily to meet the changing and growing needs of your business.

Some of the feature of WSS:

Provide a single workspace for teams to coordinate schedules, organize documents, and participate in discussions—within the organization and over the internet.
Simplify the creation and navigation of workspaces with the improved user interface and site creation tools in Windows SharePoint Services 3.0 that provide easy-to-use templates, professional-looking site themes, and the ability to rearrange site navigation from within the browser.
Increase the security of business information with enhanced administrative controls that decrease cost and complexity associated with site provisioning, management, support, operations, and backup and restore.
Manage business documents more easily with enhanced document library support and a common repository for document storage.
Use the Windows SharePoint Services platform to build rich, flexible, and scalable Web-based applications and Internet sites specific to the needs of your organization.

By: Ravi Pahuja ( 05-June-2007 )

Question 2 : What you understand by MOSS?

Answer 2 : MOSS stands for the Microsoft Office SharePoint Server. This is a new program which is part of the 2007 Microsoft Office System and this was designed to upgrade the WSS. Office SharePoint Server offers enhanced and additional feature that are unavailable on a Windows SharePoint Services site.

By: Ravi Pahuja ( 05-June-2007 )

Question 3 : A brief history of SharePoint?

Answer 3 :

Year 2001 :

SharePoint Team Services (STS) which ran on Windows 2000 Server and was in effect Windows SharePoint Services version 1.
SharePoint Portal Server 2001 - a portal based collaboration and document management tool developed on top of the Microsoft Exchange Server database.

Year 2003 :

Windows SharePoint Services (WSS version 2) - which ran on Windows Server 2003, a free Windows server component that provides collaboration and intranet services. WSS v2 is based on the .Net 1.1 Framework. Support for the .Net 2.0 Framework was added in Service Pack 2.
Microsoft Office SharePoint Portal Server 2003 (SPS) - a portal based collaboration and document management that extends Windows SharePoint Services v2.

Year 2006/7 :

Windows SharePoint Services 3.0 (WSS 3.0) is freely available as a Windows 2003 server component. WSS 3.0 was based on the ASP.NET 2.0 and required .NET Framework 3.0.
Microsoft Office SharePoint Server 2007 (MOSS) - The next iteration of Microsoft Office SharePoint Portal Server 2003 (SPS). Includes the functionality previously included in Microsoft Office SharePoint Portal Server 2003 (SPS 2003) and Microsoft Content Management Server 2002 (MCMS 2002) plus new components like Infopath Form Services and Excel Calculation Server. MOSS is based on WSS 3.0.

By: Ravi Pahuja ( 05-June-2007 )

Question 4 : What we can achieve using SharePoint?

Answer 4 : Three major task which we can achieve using SharePoint is listed below:

Collaborate on Projects
Share and Manage Information
Personal Customization

1.) Collaborate on Projects: We can use this as a collaborate tool for any kind of project. Site users share a common place made up of document libraries, lists and web parts on one or more tasks, projects or documents. Team member can work together on all these items. Windows® SharePoint™ Services lets you create a central location where coworkers, partners, and customers can share issues, contacts, announcements, Web links, and calendars. Team members can easily create workspaces for meeting discussions, surveys, documents, task lists, and other collaboration needs that increase their productivity.

Document Workspaces : Using Web parts, lists, and document libraries, a Document Workspace creates an environment centered on one or more tasks, projects, or documents. Team members can work together on a document (either the Document Workspace copy or their own copy) and periodically update copies that have been saved to the Document Workspace site.
Meeting Workspace : A Meeting Workspace site is the most productive approach to workgroup collaboration. Similar to a Document Workspace site, it allows team members to manage meetings and documents by using Web parts, lists, and document libraries.
Using Microsoft Outlook 2003, you can send meeting notices and invitations to team members. This will automatically create a Meeting Workspace, or you can create a Meeting Workspace in your SharePoint site by using a browser. You can include a hyperlink to the Workspace site where invitees can obtain additional information. You can also create a Meeting Workspace site for recurring meetings so team members can track the progress of ongoing tasks or projects.
Create Sites and Workspaces : Your team members can create a site or workspace for collaboration on Web pages, lists, and document libraries, or they can create a site to manage a new team or project, collaborate on documents, or prepare for meetings.
Enabling "Self-Service Site Creation" allows users to create their own top-level site, which eliminates the need for administrators to create one on demand. Users can click a link on the home page and enter information on the signup screen. Windows SharePoint Services will then create the new site with the user as the owner and administrator. For example, sales and marketing managers can create a site to manage all their sales- and marketing-related activities.
Discussion Boards : Discussion boards provide a forum for topics that interest your team. For example, you can create a discussion board that allows team members to propose and discuss activities. Each discussion board has icons for starting, sorting, filtering, switching views, or changing designs. Another feature (Web Discussion) allows users to attach comments to a specific SharePoint page or document.
Team Surveys : Surveys allow you to poll team members and obtain feedback from anyone with access to the site. You can configure a survey so that users can respond to items such as meetings, vendor service, or product releases, and you can also display the results graphically.
Automatic Notifications and Alerts : SharePoint uses e-mail alerts to notify users of important events and changes to lists, items, libraries, and other parts of the site. For example, users can choose to receive an e-mail alert when a document published in a specific library is modified or deleted, or they can elect to receive immediate, daily, or weekly alerts for content included in the portal site index.

2. )Share and Manage Information: Windows® SharePoint™ Services lets you create a central location where coworkers, partners, and customers can share issues, contacts, announcements, Web links, and calendars. Team members can easily create workspaces for meeting discussions, surveys, documents, task lists, and other collaboration needs that increase their productivity.

Lists and Spreadsheets : SharePoint sites include built-in lists for sharing information, tasks, contacts, and announcements. Users can also create custom lists for unique information. With the help of a compatible Windows program (such as Microsoft Office Professional 2003), Windows SharePoint Services will import in columnar form spreadsheet data that team members can directly edit, sort, filter, add to, or delete. To import data from a spreadsheet, you must have a compatible spreadsheet program such as Microsoft Office Excel 2003 or Internet Explorer 5
Document and Forms Libraries: Users can browse a library to share documents with team members. Document libraries support features such as sub-folders, file versioning, and check-in/check-out. Using a compatible XML editor (such as Microsoft Office InfoPath), you can create a form library for your XML-based business reports or purchase orders.
Task, Event, Contact, and Announcement Lists : Using an event list, you can post information about important dates or copy/link events to a compatible calendar program such as Microsoft Office Outlook 2003.You can use an announcement list to post news, status, and other information, and you can set an expiration date for the announcement.You can use a task list to assign a task to a team member, specify its priority and due date, and indicate its status and progress. Users can view individual tasks assigned to them or tasks assigned to other team members.With a contact list, you can allow team members to have access to a telephone number, e-mail address, or street address of clients, partners, and vendors. You can copy contact information in the address book to or from a contact list. This requires a compatible address book program such as Microsoft Office Outlook® 2003 or Microsoft Internet Explorer 4.0.
Picture Libraries : You can store photos and graphics in picture libraries that allow users to view images as thumbnails, filmstrips, or standard files. A picture library allows you to create a repository of corporate and product logos and images in order to standardize corporate images and simplify the daily operations of team members.

3.)Personal View Customization : A SharePoint Page (for example, a site's home page) consists of Web Parts and can appear in either shared or personal view. In shared view edited by an administrator or users with specific permission rights, all users see the same page and same changes.
In personal view, only the user making changes to Web Parts can view them; for example, if a user changes the height and width of one Web Part, closes another, adds a third, and deletes a fourth, the changes apply only to their view of the page.

2007-06-21T14:32:00.000+05:30

Hi,

I have been learning the computers since around 10 years.

What learning since around 10 years ? Yes 10 years !! As I learn everyday something new so I say I am still learning. I have working on dotnet platform these days and will discuss that only with you most of the times. I have created a free site also at

http:\dotnetextract.googlepages.com

I started with the VB and ASP. I have working on desktop application with VB oh! yes once I created a COM component also with C++ and some time I have worked on ASP also but these days I am working on dotnet platform.

I thing Microsoft realized that he has to survive then he has to beat Java in this own game and then dotnet comes. Beat Java with java !! Quite interesting.

Oh! yes he beat Linux too. Sorry :) but as per my knowledge he beat why I am saying this is because most of the desktop user use windows on their machine and we developer make application to end user to use. Because men love to see beautiful ...... same a user want a beautiful desktop and that is what Microsoft provided.

Have you remember pre Windows 95 days offffffff I was really too difficult to work with a PC. Then come 95,98,me, xp cool men life comes a long way and now stylish too Vista.

I love Microsoft. Whats about you?