inherited from. Yes. If the type is not sealed, itmay function as a base to other types. What is the default parameter passing behavior? Variables are passed by value (i.e., a copy of the variable is passed into the called function). For value types, the object iscopied-by-value. For reference types, the reference is copied-by-value. Can this type overrideSystem.Object.Finalize()? No. Value types are never placed onto the heap and therefore do not need to be finalized. Yes, indirectly. Can I define constructors forthis type? Yes, but the defaultconstructor is reserved (i.e.,your custom constructors must all have arguments). But of course! When do variables of this typedie? When they fall out of the defining scope When the object is garbagecollected.
]]> http://prsujoy.wordpress.com/2010/08/16/value-types-and-reference-types/feed/ 0 P.R.Sujoy http://prsujoy.wordpress.com/2010/08/14/partial-keyword-in-c/ http://prsujoy.wordpress.com/2010/08/14/partial-keyword-in-c/#comments Sat, 14 Aug 2010 09:03:11 +0000 prsujoy http://prsujoy.wordpress.com/?p=158 ]]> C# 2.0 introduces the concept of partial type definitions for classes, structs, and interfaces, as a means to break types in a program into multiple pieces to be stored in different source files for easier maintenance and development. In short, it allows a single class to be defined in more than one file within the same namespace.

It is possible to split the definition of a class or a struct, or an interface over two or more source files. Each source file contains a section of the class definition, and all parts are combined when the application is compiled. It enables easier maintenance and development of code.There are several situations when splitting a class definition is desirable:

* When working on large projects, spreading a class over separate files allows multiple programmers to work on it simultaneously.
* When working with automatically generated source, code can be added to the class without having to recreate the source file. Visual Studio uses this approach when creating Windows Forms, Web Service wrapper code, and so on. You can create code that uses these classes without having to edit the file created by Visual Studio.
* To split a class definition, use the partial keyword modifier, as shown below:

public partial class A
{
  private int x;
  private int y;
  public A(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
}
public partial class A
{
 public void Print()
 {
  System.Console.WriteLine("Values: {0},{1}", x, y);
 }
}

In the above example, the fields and the constructor of the class, A, are declared in one partial class definition, while the member, Print, is declared in another partial class definition.

Using the partial keyword indicates that other parts of the class, struct, or interface can be defined within the same namespace

for more details

function Button1_onclick() {
var t_Value = '<%=m_Conn%>';
 alert(t_Value);
 }

http://www.asp.net/ajax/videos/how-do-i-aspnet-ajax-enable-an-existing-web-service

click the following link for more detail:

http://forums.asp.net/t/1258933.aspx

Encapsulation is the concept of grouping of data members and member functions. Basically, Encapsulation is a process of binding or wrapping the data and the codes that operates on the data into a single entity. This keeps the data safe from outside interface and misuse. One way to think about encapsulation is as a protective wrapper that prevents code and data from being arbitrarily accessed by other code defined outside the wrapper.

String declared = "Intern pool";
String built    = new StringBuilder().Append("Intern ")
   .Append("pool").ToString();
String interned = String.Intern(built);
Console.WriteLine ((Object)built==(Object)declared);    // different references
Console.WriteLine ((Object)interned==(Object)declared); // same reference

Performance considerations

When trying to reduce the total memory allocated by your application, remember that interning has two unfortunate side effects. Firstly, the memory allocated for interned String objects is unlikely to be released until the CLR terminates: the CLR’s references to interned String objects may persist after your application or application domain terminates. Secondly, to intern a string, a string must first be created. Thus, despite the fact that the memory will eventually be garbage collected, the memory used by the String object will still be allocated.

In brief, when a field is declared as volatile compilers  doesn’t reorders the instruction.

for Ex: The following code sets the value stored in foo to 0. It then starts to poll that value repeatedly until it changes to 255.

static int foo;
void bar(void)
{
  foo = 0;
  while (foo != 255) ;
}

An optimizing compiler will notice that no other code can possibly change the value stored in foo, and will assume that it will remain equal to 0 at all times. The compiler will therefore replace the function body with an infinite loop similar to this:

void bar_optimized(void)
{
    foo = 0;
    while (true) ;
}

However, foo might represent a location that can be changed by other elements of the computer system at any time, such as a hardware register of a device connected to the CPU. The above code would never detect such a change; without the volatile keyword, the compiler assumes that the current program is the only part of the system that could change the value (which is by far the most common situation).
To prevent the compiler from optimizing code as above, the volatile keyword is used.

static volatile int foo;
void bar (void)
{
foo = 0;
while (foo != 255);
}

for more detail just click on the below link:

http://msdn.microsoft.com/en-us/library/Aa645755