.Net simplified

Difference Between Response.Redirect Server.Transfes And CrossPagePostBack

2011-07-17T03:43:00.000-07:00

This Is what i found the difference between The following type of redirection in .net
For us to understand Lets us take Two Pages As our Example

1st page:Demo.aspx
2nd page:Demo1.aspx

The Default Page is the Demo.aspx and this wud help us to redirect to another Page That is Demo1.aspx

	Response.Redirect	Server.Transfer	CrossPagePostBack
URL	The Url of the Page Changes Eg:Demo1.aspx	Does Not Change	Changes
Previous Page Values	Cannot Get Previous Page Values Accept Using Url Rewriting	You Can Get Previous PageValues by using Find Control Method in the response Class	You Can Get Previous PageValues by using Find Control Method in the response Class
Server Side	Is a server side redirection	Is a server side redirection	Is a Client side redirection
Round Trip	Is a Roundtrip	Is Not a Round trip	Is Not a Round trip

What are Extension Methods

2011-06-11T00:02:00.000-07:00

Extension methods allows you to add new functionality for existing data types Without modifying the code of the type itself This allows you to create new methods for a class which you have no access or those classes which are sealed and you cant inherit.Extension Methods were introduced in C# 3.0 .
In order to create a extension method you need to create a static class with a static method and use the this keyword .
eg:
public static class ExtensionMethod
{

public static void OutputToConsole(this string s)
    {
        Console.WriteLine(s);
    }

}
so now its use
string s ="Extension mEthod";

s.OutputToConsole();

so now you see string does not have any method called OutputToConsole but when you specify the this keyword all the string varibles will be able to access this function

So now a thing which .net uses is Extension Methods Along with Generics In Linqu
this is what it does

eg:
public static class ExtensionMethod
{

public static void OutputToConsole<T>(this T s)
    {
        Console.WriteLine(s.toString());
    }

}
now this function is accessible to all types
so now its use
string s ="Extension mEthod";
s.OutputToConsole();
int i=1;
i.OutputToConsole();
Plz give your Comments

What are Generics

2011-06-05T03:46:00.000-07:00

This Feature was introduced In C# 2.0
So What is a Collection?
A collection Sometimes Called as Container is an object That Groups multiple Elements into a single unit
So Why use collections
Ans:Collections Reduces Programming Efforts as it helps provides you with useful data structure and algorithms

Consider an example of a stack and the two methods of push and pop in .net in C# 1.1 it provided you a stack of an object type as object is the base class in C# you were able to put any thing into the stack See the Example Below:

public class Stack
{
   object[] Items; 
   public void Push(object item)
   {...}
   public object Pop()
   {...}
}

Stack stack = new Stack();
stack.Push("One");
stack.Push("Two");
string number = (string)stack.Pop();

The problem here was that in case of value types you need to box it to object type 
and then again unbox it

boxing and unboxing had a performance issue but not only that
Consider the below example :

Stack stack = new Stack();
stack.Push("One");
stack.Push("Two");
int number = (string)stack.Pop(); //This will throw a runtime exception

To overcome this problem there was a solution to create a Specific type Stack

For eg:IntStack to store int and String stack to store string and so on

But the problem here was that if i had to change the algorithm or if there were any 
error in the algorithm i had to make this 
change in all the Class files which would be tedious and  repetitive work 
So Generics Were introduced

Generics allows you to define type-safe classes without compromising type safety, performance, or productivity.

for example consider the example given below

public class Stack<T>
{
   T[] Items; 
   public void Push(T item)
   {...}
   public T Pop()
   {...}
}
Stack<int> stack = new Stack<int>();
stack.Push(1);
stack.Push(2);
int number = stack.Pop();
so now when you are creating a stack you need to specify the type both when declaring the variable and when instantiating it:  
Stack<int> stack = new Stack<int>();
so in the above example the generic T is replaced with the type specific data type
and also you can reuse the code for any other type and if you need to change the algo 
you had to now change in at just one place
MUlTIPLE GENERIC LIST

class Node<K,T>
{
   public K Key;
   public T Item;
   public Node<K,T> NextNode;
   public Node()
   {
      Key      = default(K);
      Item     = defualt(T);
      NextNode = null;
   }
   public Node(K key,T item,Node<K,T> nextNode)
   {
      Key      = key;
      Item     = item;
      NextNode = nextNode;
   }
}

public class LinkedList<K,T>
{
   Node<K,T> Head;
   public LinkedList()
   {
      m_Head = new Node<K,T>();
   }
   public void AddHead(K key,T item)
   {
      Node<K,T> newNode = new Node<K,T>(key,item,Head.NextNode);
      Head.NextNode = newNode;
   }
}
LinkedList<int,string> list = new LinkedList<int,string>();
list.AddHead(123,"AAA");

But now if you consider generics There is still a constrain

as in generics the type is defined at compile time so if i have to do some manipulation 
over it it used to provide me an error
see the below example 

T Find(K key)
{
   Node<K,T> current = m_Head;
   while(current.NextNode != null)
   {
      if(current.Key == key) //Will not compile
         break;
      else
         
         current = current.NextNode;
   }
   return current.Item; 
}

because ti does not know weather the type specified by the client supports the equals
operator
now in order to solve this problem 
you had to specify it like this

public class LinkedList<K,T> where K : IComparable
{
   T Find(K key)
   {
      Node<K,T> current = m_Head;
      while(current.NextNode != null)
      {
         if(current.Key.CompareTo(key) == 0)
            
            break;
         else      
            
            current = current.NextNode;
      }
      return current.Item; 
   }
  
}

just as a class can be of generic you can also create a method as generic consider the 
example below

public class MyClass<T>
{
   public void MyMethod<X>(X x)
   {...}
}

MyClass obj = new MyClass();
obj.MyMethod<int>(3);
So this is all about generics 

Please put in you Comments

What does "?" mean in .net

2011-05-07T08:28:00.000-07:00

I as a developer always used to think how to assign null values to a value type datatype
so i tried this

and i got an error as you can see above

then i came accross "?" in .net allows you to create a data type with null as a value to it you can see the demo here

the has value checks if the value is not null
so then what does "??" mean
the demo below will show it to you

"??" means that when you have null values to a particular value type data type it will check if it is null and if it is true then it will assign the right hand side value to it so in my case "i" is now 2.

Please give your comments

Why does it show a warning?

2011-04-29T08:35:00.001-07:00

Actually when you create a object o and when when you create z as string as both of these classes are of refrence type when you declare it in such a manner both point to the same memory location cauz its value is the same
so it gives you this warning even though it will give you the proper output
but now see the diffrence

Now in this case it does not show any warning thinking y cauz z is a new varible created n the .net code does not know that the value in z+y would make the same as o so it does not give a warning

Thanks
Steven Pinto
pls share your thoughts on this

Welcom All

2011-04-29T08:10:00.001-07:00

Would like to welcome all my frnds to this blog where you can learn more about the .net technology