DotNetLogics

httpwebrequest example and httpwebresponse example

2011-10-21T11:53:00.000-07:00

Introduction

I will explain about the usage of HttpWebRequest and HttpWebResponse in this article. As you all probably know or heard about this class before. HttpWebRequest and HttpWebResponse class is inside the System.NET namespace, and this two classes is designed to communicate by using the Http Protocol

You can use this two classes to make requests to other Web Pages via HTTP and parse the resulting text to extract data. This is what we know as screen scraping.

In ASP world, you normally need to rely on third party components called ASPTear to grab the contents from other site. But now with the help of HttpWebRequest and HttpWebResponse, you can do that easily without have to invoke third party components.

Using HttpWebRequest and HttpWebResponse

In the code below, I provide very basic sample code on how to use HttpWebRequest and HttpWebResponse. In the first example I will list out the code on how to do screen scraping and the second example would be doing HttpPost data to another website

1. Sample Code on Grabbing Contents (Screen Scraping)
C#

protected void Page_Load(object sender,EventArgs e) {
Uri uri = new Uri("http://localhost/default.aspx");

if(uri.Scheme = Uri.UriSchemeHttp){

HttpWebRequest request = HttpWebRequest.Create(uri);
request.Method = WebRequestMethods.Http.Get;
HttpWebResponse response = request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());

string  tmp = reader.ReadToEnd();
response.Close();
Response.Write(tmp);
}
}

VB.NET

Protected Sub Page_Load(ByVal sender as Object,ByVal e as System.EventArgs)
Dim uri as New Uri("http://localhost/default.aspx")

If(uri.Scheme == uri.UriSchemeHttp) Then
Dim request as HttpWebRequest = HttpWebRequest.Create(uri)
request.Method = WebRequestMethods.Http.Get
Dim response As HttpWebResponse = request.GetResponse()
Dim reader As New StreamReader(response.GetResponseStream())
Dim tmp As String = reader.ReadToEnd()
response.Close()
Response.Write(tmp)
End If
End Sub


Sample Code on how to Post Data to remote Web Page using HttpWebRequest

C# 

protected void Page_Load(object sender,EventArgs e) {
Uri uri = new Uri("http://localhost/default.aspx");
string data = "field-keywords=ASP.NET 2.0";
if (uri.Scheme == Uri.UriSchemeHttp)
{
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(uri);
request.Method = WebRequestMethods.Http.Post;
request.ContentLength = data.Length;
request.ContentType = "application/x-www-form-urlencoded";
StreamWriter writer = new StreamWriter(request.GetRequestStream());
writer.Write(data);
writer.Close();
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string tmp = reader.ReadToEnd();
response.Close();
Response.Write(tmp);
}
}

VB.NET 

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
Dim uri As New Uri("http://localhost/default.aspx")
Dim data As String = "field-keywords=ASP.NET 2.0"
If uri.Scheme = uri.UriSchemeHttp Then
Dim request As HttpWebRequest = HttpWebRequest.Create(uri)
request.Method = WebRequestMethods.Http.Post
request.ContentLength = data.Length
request.ContentType = "application/x-www-form-urlencoded"
Dim writer As New StreamWriter(request.GetRequestStream)
writer.Write(data)
writer.Close()
Dim oResponse As HttpWebResponse = request.GetResponse()
Dim reader As New StreamReader(oResponse.GetResponseStream())
Dim tmp As String = reader.ReadToEnd()
oResponse.Close()
Response.Write(tmp)
End If
End Sub


Conclusion
Based on  the sample code 
above, you can see that it is quite simple to do Http Post and Http Get 
to remote Website by using two built in class HttpWebRequest and 
HttpWebResponse. There is another set of classes called FtpWebRequest 

and FtpWebResponse that allow you to do ftp post and get to remote ftp Server.

Remoting in .net

2011-10-16T06:02:00.000-07:00

.NET remoting supports accessing your objects by using HTTP,TCP and IPC channels. Similar with Web Services, .NET remoting also support calling your objects via HTTP protocol. However Web Services provide platform independence and you also get loose coupling between your client server objects which means that easier to deal with versioning issues.

Unlike Web Services, .NET remoting requires both of your client and server objects running on the same .NET Framework version. and it has a tight coupling between client and server because the same object types are shared.
Confuse about which one to choose?. Since this article is about .NET Remoting, I will list down why you should choose .NET remoting for your apps over the Web Services.
1. If you develop application only for internal use and not for public use.
2. If you require faster performance with less overhead.
3. If you transfer large data between your client and server application.
4. Web Services is running on Http protocol and you know that http protocol can go timeout if the
processing time is more than 20 minutes. Although you can override this.
5. If you need to access your objects using protocol other than HTTP or HTTPS.
6. If you need richer object oriented model for your client server apps.

Remote Objects, Clients and Servers.

In this example below, we will try to write very basic .NET Remoting technology comprising of RemoteObjects, Clients and Servers application.
RemoteObjects is the objects being shared by Client and Server application which can be invoked using protocols that you define. .NET remoting support object invocation via HTTP,TCP and IPC protocols.

Developing .NET remoting application consists of 3 steps.
1. Developing the RemoteObjects (consists of method that you like to invoke on the remote server)
2. Developing the Server Application. (listens on certain port and certain protocol)
3. Developing Client Application. (you can use this apps to invoke server objects where the server
application is running)

Developing the Remote Objects.

Open Visual Studio, and Create New Class Library.
Add References to System.Runtime.Remoting.
Create a new Class Called RemoteObjects.cs. Please note that the Remoteobjects must be derived from System.MarshalByRefObject class.

public class RemoteObjects : System.MarshalByRefObject
{
public RemoteObjects()
{
}
public void StopIIS()
{
ExecuteProcess(@"net", "stop w3svc");
}
public void StartIIS()
{
ExecuteProcess(@"net", "start w3svc");
}
private void ExecuteProcess(string ProcessFileName, string ProcessArguments)
{
string Result = "";
Process myProcess = new Process();try
{
myProcess.StartInfo.FileName = ProcessFileName;
myProcess.StartInfo.Arguments = ProcessArguments;
myProcess.StartInfo.UseShellExecute = false;
myProcess.StartInfo.CreateNoWindow = true;
myProcess.StartInfo.RedirectStandardOutput = true;
myProcess.StartInfo.RedirectStandardError = true;
myProcess.Start();
Result = myProcess.StandardError.ReadToEnd();
myProcess.WaitForExit(20000);if (!myProcess.HasExited)
{
myProcess.Kill();
}
}
catch (Exception ex)
{
EventLog.WriteEntry("Remoting", ex.ToString());
}
finally
{
myProcess.Close();
}
}
}

From the code above, you can see that we create few methods inside the 
Remoting objects that we can use to invoke Start IIS or Stop IIS on 
remote Server. This is particularly useful if you like to have some sort
 of utility that allow you to do IIS reset without have to login to the 
server.

Developing the Remote Server application.

For
 the Server, we will be creating a Console application called Server.cs.
 If you are planning to launch the .NET remoting application on the real
 production server, then I would recommend you to write it in Windows 
Service rather than on Console application. But for simplicity of this 
example, we will write it in Console.

Open Visual Studio, and 
Create New Console Applications. Reference System.Runtime.Remoting and 
reference your RemoteObjects Class library as we created above

using System;using System.Collections.Generic;

using System.Text;

using System.Runtime.Remoting;

using System.Runtime.Remoting.Channels;

using System.Runtime.Remoting.Channels.Tcp;

namespace Server
{
class Program
{
static void Main(string[] args)
{
TcpServerChannel channel = new TcpServerChannel(8500);
ChannelServices.RegisterChannel(channel, false);
RemotingConfiguration.RegisterWellKnownServiceType
(typeof(RemoteObjects.RemoteObjects), "Remoting Server", WellKnownObjectMode.Singleton);
Console.WriteLine("Remoting Server is Listening on TCP Port 8500.\nPlease Press Enter For Exit");
Console.ReadLine();
}
}
}

From the code above, you can see that we are creating a Server application that listening on TCP Port 8500.And you will notice that the RemoteObjects is being referenced by the Server application and the RemoteObjects has been registered to be exposed as objects which can be called by your client application.

In the example above, the remote object type is registered using WellKnownObjectMode.Singleton. There are two types available for WellKnownObjectMode.
1. Singleton.
Only one instance per Server. Every objects call will be referencing to the same objects.

2. SingleCall
Create new instance for every objects call.

Developing the Remoting Client Application

For the Client application,we will be developing as a Windows Form application.
Create New Project, and Choose Windows Application as the Template.
Don't Forget to reference the RemotingObjects Library and System.Runtime.RemotingDrag two button in your Windows Forms and named it btnStartIIS and btnStopIIS.

Paste the code below for the button Event Handler.

private void btnStartIIS_Click(object sender, EventArgs e)
{
TcpClientChannel chan = new TcpClientChannel();
RemoteObjects.RemoteObjects objRemote = (RemoteObjects.RemoteObjects)Activator.GetObject
(typeof(RemoteObjects.RemoteObjects), "tcp://localhost:8500/Remoting Server");if (objRemote == null)
{
MessageBox.Show("Could not Locate Server");
}
objRemote.StartIIS();
}
private void btnStopIIS_Click(object sender, EventArgs e)
{
TcpClientChannel chan = new TcpClientChannel();
RemoteObjects.RemoteObjects objRemote = (RemoteObjects.RemoteObjects)Activator.GetObject
(typeof(RemoteObjects.RemoteObjects), "tcp://localhost:8500/Remoting Server");if (objRemote == null)
{
MessageBox.Show("Could not Locate Server");
}
objRemote.StopIIS();
}
}

To start demonstrating the Remoting application, we will be running
both the server and client application on your localhost machine.

First,
you need to start the Server Application. Once you run the Server
application, your apps should be listened on TCP port 8500.

Next,
fire up your Client application and try to press button Stop IIS. Wait
for a while and then check for your IIS status in your service manager.
Your Worldwideweb server should be stopped.

If for some reason it
is not working, please make sure no application is running on port 8500
and you have IIS server installed on your XP machine.

Running the Remoting Application in Remote Server

If
you wish to run the Remoting application that you just developed on
remote server, then you need to change your Client Application code a
bit. You just need to change the tcp://localhost to tcp://yourserverip.

After that fire up the server apps on your remote server and fire up the client apps on your local server.

Conclusion
As
you can see from the example above, .NET remoting is quite easy to be
implemented and you can have your .NET Server application listened on
TCP, HTTP or IPC Protocol. .NET Framework already has all the
implementation for all that three protocol. The above example only
discusses about TCP Protocol, however to change it to HTTP protocol and
IPC protocol should be quite easy. You just need to use HTTPServerChannel or IPCServerChannel on your Server application and then Use HttpClientChannel or IPCClientChannel on your Client application


Remoting - Interview Questions
What is .NET Remoting?
.NET Remoting allows objects to interact with one another across application domains.


What are the 2 message encoding formats supported by .NET Remoting and when do you choose one over the other?

Message Encoding Formats:
1. Binary encoding.
2. XML encoding.


Applications can use binary encoding where performance is critical, or XML encoding where interoperability with other remoting frameworks is essential.


What are the two types of .NET remote objects?

1. Client-activated objects - Client-activated objects are under the control of a lease-based lifetime manager that ensures that the object is garbage collected when its lease expires.

2. Server-activated objects - In the case of server-activated objects, developers have a choice of selecting either a "single call" or "singleton" model. The lifetime of singletons are also controlled by lease-based lifetime.


What is considered as Remote Object?
Any object outside the application domain of the calling appication is considered remote object, even if the objects are executing on the same machine.

Can you treat every object as a remote object?
Objects that cannot be serialized cannot be passed to a different application domain and are therefore nonremotable.

What are the ways in which an object can be serialized?
1. Mark your class with serializable attribute.
2. Make your class implement ISerializable interface.


How can you change an object into a remote object?
Any object can be changed into a remote object by deriving it from MarshalByRefObject.


What happens when a client activates a remote object?
When a client activates a remote object, it receives a proxy to the remote object. All operations on this proxy are appropriately indirected to enable the remoting infrastructure to intercept and forward the calls appropriately.


What are proxy objects and what is the use of these proxy objects?
Proxy objects are created when a client activates a remote object. The proxy object acts as a representative of the remote object and ensures that all calls made on the proxy are forwarded to the correct remote object instance.

c sharp syntax

2011-08-22T02:39:00.000-07:00

Statement	Example
Local variable declaration	static void Main() { int a; int b = 2, c = 3; a = 1; Console.WriteLine(a + b + c); }
Local constant declaration	static void Main() { const float pi = 3.1415927f; const int r = 25; Console.WriteLine(pi * r * r); }
Expression statement	static void Main() { int i; i = 123; // Expression statement Console.WriteLine(i); // Expression statement i++; // Expression statement Console.WriteLine(i); // Expression statement }
if statement	static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("No arguments"); } else { Console.WriteLine("One or more arguments"); } }

switch statement	static void Main(string[] args) { int n = args.Length; switch (n) { case 0: Console.WriteLine("No arguments"); break; case 1: Console.WriteLine("One argument"); break; default: Console.WriteLine("{0} arguments", n); break; } } }
while statement	static void Main(string[] args) { int i = 0; while (i < args.Length) { Console.WriteLine(args[i]); i++; } }
do statement	static void Main() { string s; do { s = Console.ReadLine(); if (s != null) Console.WriteLine(s); } while (s != null); }
for statement	static void Main(string[] args) { for (int i = 0; i < args.Length; i++) { Console.WriteLine(args[i]); } }
foreach statement	static void Main(string[] args) { foreach (string s in args) { Console.WriteLine(s); } }
break statement	static void Main() { while (true) { string s = Console.ReadLine(); if (s == null) break; Console.WriteLine(s); } }
continue statement	static void Main(string[] args) { for (int i = 0; i < args.Length; i++) { if (args[i].StartsWith("/")) continue; Console.WriteLine(args[i]); } }

goto statement	static void Main(string[] args) { int i = 0; goto check; loop: Console.WriteLine(args[i++]); check: if (i < args.Length) goto loop; }
return statement	static int Add(int a, int b) { return a + b; } static void Main() { Console.WriteLine(Add(1, 2)); return; }
yield statement	static IEnumerable<int> Range(int from, int to) { for (int i = from; i < to; i++) { yield return i; } yield break; } static void Main() { foreach (int x in Range(-10,10)) { Console.WriteLine(x); } }
throw and try statements	static double Divide(double x, double y) { if (y == 0) throw new DivideByZeroException(); return x / y; } static void Main(string[] args) { try { if (args.Length != 2) { throw new Exception("Two numbers required"); } double x = double.Parse(args[0]); double y = double.Parse(args[1]); Console.WriteLine(Divide(x, y)); } catch (Exception e) { Console.WriteLine(e.Message); } finally { Console.WriteLine(“Good bye!”); } }
checked andunchecked statements	static void Main() { int i = int.MaxValue; checked { Console.WriteLine(i + 1); // Exception } unchecked { Console.WriteLine(i + 1); // Overflow } }

lock statement	class Account { decimal balance; public void Withdraw(decimal amount) { lock (this) { if (amount > balance) { throw new Exception("Insufficient funds"); } balance -= amount; } } }
using statement	static void Main() { using (TextWriter w = File.CreateText("test.txt")) { w.WriteLine("Line one"); w.WriteLine("Line two"); w.WriteLine("Line three"); } }

c# (c sharp) in depth

2011-08-19T12:17:00.000-07:00

C# (pronounced “See Sharp”) is a simple, modern, object-oriented, and type-safe programming language. C# has its roots in the C family of languages and will be immediately familiar to C, C++, and Java programmers. C# is standardized by ECMA International as the ECMA-334 standard and by ISO/IEC as the ISO/IEC 23270 standard. Microsoft’s C# compiler for the .NET Framework is a conforming implementation of both of these standards.

C# is an object-oriented language, but C# further includes support for component-oriented programming. Contemporary software design increasingly relies on software components in the form of self-contained and self-describing packages of functionality. Key to such components is that they present a programming model with properties, methods, and events; they have attributes that provide declarative information about the component; and they incorporate their own documentation. C# provides language constructs to directly support these concepts, making C# a very natural language in which to create and use software components.

Several C# features aid in the construction of robust and durable applications: Garbage collection automatically reclaims memory occupied by unused objects; exception handling provides a structured and extensible approach to error detection and recovery; and the type-safe design of the language makes it impossible to read from uninitialized variables, to index arrays beyond their bounds, or to perform unchecked type casts.

C# has a unified type system. All C# types, including primitive types such as int and double, inherit from a single root object type. Thus, all types share a set of common operations, and values of any type can be stored, transported, and operated upon in a consistent manner. Furthermore, C# supports both user-defined reference types and value types, allowing dynamic allocation of objects as well as in-line storage of lightweight structures.

To ensure that C# programs and libraries can evolve over time in a compatible manner, much emphasis has been placed on versioning in C#’s design. Many programming languages pay little attention to this issue, and, as a result, programs written in those languages break more often than necessary when newer versions of dependent libraries are introduced. Aspects of C#’s design that were directly influenced by versioning considerations include the separate virtual and override modifiers, the rules for method overload resolution, and support for explicit interface member declarations.

Program structure

The key organizational concepts in C# are programs, namespaces, types, members, and assemblies. C# programs consist of one or more source files. Programs declare types, which contain members and can be organized into namespaces. Classes and interfaces are examples of types. Fields, methods, properties, and events are examples of members. When C# programs are compiled, they are physically packaged into assemblies. Assemblies typically have the file extension .exe or .dll, depending on whether they implement applications or libraries.

The example

using System;

namespace Acme.Collections
{
public class Stack
{
Entry top;

public void Push(object data) {
top = new Entry(top, data);
}

public object Pop() {
if (top == null) throw new InvalidOperationException();
object result = top.data;
top = top.next;
return result;
}

class Entry
{
public Entry next;
public object data;

public Entry(Entry next, object data) {
this.next = next;
this.data = data;
}
}
}
}

declares a class named Stack in a namespace called Acme.Collections. The fully qualified name of this class is Acme.Collections.Stack. The class contains several members: a field named top, two methods named Push and Pop, and a nested class named Entry. The Entry class further contains three members: a field named next, a field named data, and a constructor. Assuming that the source code of the example is stored in the file acme.cs, the command line

csc /t:library acme.cs

compiles the example as a library (code without a Main entry point) and produces an assembly named acme.dll.

Assemblies contain executable code in the form of Intermediate Language (IL) instructions, and symbolic information in the form of metadata. Before it is executed, the IL code in an assembly is automatically converted to processor-specific code by the Just-In-Time (JIT) compiler of .NET Common Language Runtime.

Because an assembly is a self-describing unit of functionality containing both code and metadata, there is no need for #include directives and header files in C#. The public types and members contained in a particular assembly are made available in a C# program simply by referencing that assembly when compiling the program. For example, this program uses the Acme.Collections.Stack class from the acme.dll assembly:

using System;
using Acme.Collections;

class Test
{
static void Main() {
Stack s = new Stack();
s.Push(1);
s.Push(10);
s.Push(100);
Console.WriteLine(s.Pop());
Console.WriteLine(s.Pop());
Console.WriteLine(s.Pop());
}
}

If the program is stored in the file test.cs, when test.cs is compiled, the acme.dll assembly can be referenced using the compiler’s /r option:

csc /r:acme.dll test.cs

This creates an executable assembly named test.exe, which, when run, produces the output:

100
10
1

C# permits the source text of a program to be stored in several source files. When a multi-file C# program is compiled, all of the source files are processed together, and the source files can freely reference each other—conceptually, it is as if all the source files were concatenated into one large file before being processed. Forward declarations are never needed in C# because, with very few exceptions, declaration order is insignificant. C# does not limit a source file to declaring only one public type nor does it require the name of the source file to match a type declared in the source file.

Types and variables

There are two kinds of types in C#: value types and reference types. Variables of value types directly contain their data whereas variables of reference types store references to their data, the latter being known as objects. With reference types, it is possible for two variables to reference the same object and thus possible for operations on one variable to affect the object referenced by the other variable. With value types, the variables each have their own copy of the data, and it is not possible for operations on one to affect the other (except in the case of ref and out parameter variables).

C#’s value types are further divided into simple types, enum types, struct types, and nullable types, and C#’s reference types are further divided into class types,interface types, array types, and delegate types.

The following table provides an overview of C#’s type system.

Category		Description
Value types	Simple types	Signed integral: sbyte, short, int, long
		Unsigned integral: byte, ushort, uint, ulong
		Unicode characters: char
		IEEE floating point: float, double
		High-precision decimal: decimal
		Boolean: bool
	Enum types	User-defined types of the form enum E {...}
	Struct types	User-defined types of the form struct S {...}
	Nullable types	Extensions of all other value types with a null value
Reference types	Class types	Ultimate base class of all other types: object
		Unicode strings: string
		User-defined types of the form class C {...}
	Interface types	User-defined types of the form interface I {...}
	Array types	Single- and multi-dimensional, for example, int[] andint[,]
	Delegate types	User-defined types of the form e.g. delegate int D(...)

The eight integral types provide support for 8-bit, 16-bit, 32-bit, and 64-bit values in signed or unsigned form.

The two floating point types, float and double, are represented using the 32-bit single-precision and 64-bit double-precision IEEE 754 formats.

The decimal type is a 128-bit data type suitable for financial and monetary calculations.

C#’s bool type is used to represent boolean values—values that are either true or false.

Character and string processing in C# uses Unicode encoding. The char type represents a UTF-16 code unit, and the string type represents a sequence of UTF-16 code units.

The following table summarizes C#’s numeric types.

Category	Bits	Type	Range/Precision
Signed integral	8	sbyte	–128...127
	16	short	–32,768...32,767
	32	int	–2,147,483,648...2,147,483,647
	64	long	–9,223,372,036,854,775,808...9,223,372,036,854,775,807
Unsigned integral	8	byte	0...255
	16	ushort	0...65,535
	32	uint	0...4,294,967,295
	64	ulong	0...18,446,744,073,709,551,615
Floating point	32	float	1.5 × 10⁻⁴⁵ to 3.4 × 10³⁸, 7-digit precision
Floating point	64	double	5.0 × 10⁻³²⁴ to 1.7 × 10³⁰⁸, 15-digit precision
Decimal	128	decimal	1.0 × 10⁻²⁸ to 7.9 × 10²⁸, 28-digit precision

C# programs use type declarations to create new types. A type declaration specifies the name and the members of the new type. Five of C#’s categories of types are user-definable: class types, struct types, interface types, enum types, and delegate types.

A class type defines a data structure that contains data members (fields) and function members (methods, properties, and others). Class types support single inheritance and polymorphism, mechanisms whereby derived classes can extend and specialize base classes.

A struct type is similar to a class type in that it represents a structure with data members and function members. However, unlike classes, structs are value types and do not require heap allocation. Struct types do not support user-specified inheritance, and all struct types implicitly inherit from type object.

An interface type defines a contract as a named set of public function members. A class or struct that implements an interface must provide implementations of the interface’s function members. An interface may inherit from multiple base interfaces, and a class or struct may implement multiple interfaces.

A delegate type represents references to methods with a particular parameter list and return type. Delegates make it possible to treat methods as entities that can be assigned to variables and passed as parameters. Delegates are similar to the concept of function pointers found in some other languages, but unlike function pointers, delegates are object-oriented and type-safe.

Class, struct, interface and delegate types all support generics, whereby they can be parameterized with other types.

An enum type is a distinct type with named constants. Every enum type has an underlying type, which must be one of the eight integral types. The set of values of an enum type is the same as the set of values of the underlying type.

C# supports single- and multi-dimensional arrays of any type. Unlike the types listed above, array types do not have to be declared before they can be used. Instead, array types are constructed by following a type name with square brackets. For example, int[] is a single-dimensional array of int, int[,] is a two-dimensional array of int, and int[][] is a single-dimensional array of single-dimensional arrays of int.

Nullable types also do not have to be declared before they can be used. For each non-nullable value type T there is a corresponding nullable type T?, which can hold an additional value null. For instance, int? is a type that can hold any 32 bit integer or the value null.

C#’s type system is unified such that a value of any type can be treated as an object. Every type in C# directly or indirectly derives from the object class type, andobject is the ultimate base class of all types. Values of reference types are treated as objects simply by viewing the values as type object. Values of value types are treated as objects by performing boxing and unboxing operations. In the following example, an int value is converted to object and back again to int.

using System;

class Test
{
   static void Main() {
      int i = 123;
      object o = i;        // Boxing
      int j = (int)o;      // Unboxing
   }
}

When a value of a value type is converted to type object, an object instance, also called a “box,” is allocated to hold the value, and the value is copied into that box. Conversely, when an object reference is cast to a value type, a check is made that the referenced object is a box of the correct value type, and, if the check succeeds, the value in the box is copied out.

C#’s unified type system effectively means that value types can become objects “on demand.” Because of the unification, general-purpose libraries that use typeobject can be used with both reference types and value types.

There are several kinds of variables in C#, including fields, array elements, local variables, and parameters. Variables represent storage locations, and every variable has a type that determines what values can be stored in the variable, as shown by the following table.

Type of Variable	Possible Contents
Non-nullable value type	A value of that exact type
Nullable value type	A null value or a value of that exact type
object	A null reference, a reference to an object of any reference type, or a reference to a boxed value of any value type
Class type	A null reference, a reference to an instance of that class type, or a reference to an instance of a class derived from that class type
Interface type	A null reference, a reference to an instance of a class type that implements that interface type, or a reference to a boxed value of a value type that implements that interface type
Array type	A null reference, a reference to an instance of that array type, or a reference to an instance of a compatible array type
Delegate type	A null reference or a reference to an instance of that delegate type

Creating Thread

2011-08-17T20:13:00.000-07:00

creating a thread is dotNet delegate-classes. Let me explain in few words what is a
delegate class. The delegate is a wrapper around a code construct in the dotNet. The code
construct could be an object instance, an instance method or a static method. Delegates
are used when you want to pass one of the three code constructs as a parameter to
another method.
When creating a new thread you have to use the ThreadStart delegate class to wrap the
instance method that will be executed in the newly created thread. The instance method
must return void and must not have any parameters.
void ThreadStart()
To create a new thread, first create a new ThreadStart object, passing the instance method
of the thread procedure in the constructor. The new delegate object is then passed to the
constructor of the Thread.
Thread thread = new Thread(
new ThreadStart(obj.ThreadStart));
You’ve now created a new thread, but the thread is not yet started. To start the thread,
you call the Thread.Start instance method.
thread.Start();

using System;
using System.Threading;
namespace ConsoleApplication1
{
class Class1
{
static void PrintHelloFromThreadName()
{
Console.WriteLine("Hello, from thread {0}",
Thread.CurrentThread.Name); // {0}
}
public void ThreadStart()
{
PrintHelloFromThreadName();
}
static void Main(string[] args)
{
Thread.CurrentThread.Name = "Main thread";
Class1 obj = new Class1();
Thread thread = new Thread(
new ThreadStart(obj.ThreadStart));
thread.Name = "My thread";
thread.Start();
PrintHelloFromThreadName();
}
}
}

What's the programmers must knowledge on ..

2011-08-14T14:26:00.000-07:00

It is for beginners
As of my knowledge i am saying
From Basic on words

1.what is ip address and ports?

IP address is for to communicate to system (0.0.0.0 to 255.255.255.255)ipv4
Port is for to communicate to particular appliction(0 to 65535 )
well-known ports: 0–1023
Registered ports: 1024–49151
Dynamic, private or ephemeral ports: 49152–65535
These two are called socket(ipaddress+Prots)

2.What is operating system how it is communicate to our program

Operating system is also a program written by programmers like us
It is communicate to HARDWARE And SOFTWARE(Our Programs like media players,office,notepad)
These communication via PORTs
it is silly but it is important OS only know 0 and 1's
So we cant do like that programs it is very default
Number of researchers and scientists developed languages like (c,c++,c#,java etc.)
These languages to communicate to OS via Compilers,Interpreters,CLR,JVM

From Here On Words Our Work starts.....

Ok lets come to our Dotnet technology

3.What is oops?
My answer is entirely different but you must have patience to understand.....
It is silly question but in real word we are working on that only(OOPs programming )

Think it our program communicate with system (that means our programming code is running on RAM, and Performance wise with Processor CORE2 DUO, I3 , I4 etc) These are also impotent on MULTI-THREADING programming to communicate different cores

ok comes under oops

Object-oriented programming: refers to a way
of building applications using instantiated types(memory blocks ie objects ). These memory blocks easy find and modify and then lot of work ,we can play with objects
so this concept introduced
Then our programmers follows one architecture to maintain how programs are
efficiency later they are introduced
class- sealed class , abstract class
interfaces
methods , constructors
properties

All managed languages in the .NET Framework, such as Visual Basic and C#, provide full support for object-oriented programming including encapsulation, inheritance, and polymorphism.

A class is a data structure that may contain data members (constants and fields), function members (methods, properties, events, indexers, operators, instance constructors, destructors and static constructors), and nested types. Class types support inheritance, a mechanism whereby a derived class can extend and specialize a base class

Encapsulation means that a group of related properties, methods, and other members are treated as a single unit or object.

Inheritance describes the ability to create new classes based on an existing class.

Polymorphism means that you can have multiple classes that can be used interchangeably, even though each class implements the same properties or methods in different ways.

This section describes the following concepts:

Classes and Objects
- Class Members
  
  Properties and Fields
  Methods
  Constructors
  Destructors
  Events
  Nested Classes
- Access Modifiers and Access Levels
- Instantiating Classes
- Static (Shared) Classes and Members
- Anonymous Types
Inheritance
- Overriding Members
Interfaces
Generics
Delegates

The terms class and object are sometimes used interchangeably, but in fact, classes describe the type of objects, while objects are usable instancesof classes. So, the act of creating an object is called instantiation. Using the blueprint analogy, a class is a blueprint, and an object is a building made from that blueprint.

class Child
{
    private int age;
    private string name;

    // Default constructor:
    public Child()
    {
        name = "N/A";
    }

    // Constructor:
    public Child(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // Printing method:
    public void PrintChild()
    {
        Console.WriteLine("{0}, {1} years old.", name, age);
    }
}

class StringTest
{
    static void Main()
    {
        // Create objects by using the new operator:
        Child child1 = new Child("Craig", 11);
        Child child2 = new Child("Sally", 10);

        // Create an object using the default constructor:
        Child child3 = new Child();

        // Display results:
        Console.Write("Child #1: ");
        child1.PrintChild();
        Console.Write("Child #2: ");
        child2.PrintChild();
        Console.Write("Child #3: ");
        child3.PrintChild();
    }
}

/* Output:
    Child #1: Craig, 11 years old.
    Child #2: Sally, 10 years old.
    Child #3: N/A, 0 years old.
*/

namespace ProgrammingGuide
    {
        // Class definition.
        public class MyCustomClass
        {
            // Class members:
            // Property.
            public int Number { get; set; }

            // Method.
            public int Multiply(int num)
            {
                return num * Number;
            }

            // Instance Constructor.
            public MyCustomClass()
            {
                Number = 0;
            }
        }
        // Another class definition. This one contains
        // the Main method, the entry point for the program.
        class Program
        {
            static void Main(string[] args)
            {
                // Create an object of type MyCustomClass.
                MyCustomClass myClass = new MyCustomClass();

                // Set the value of a public property.
                myClass.Number = 27;

                // Call a public method.
                int result = myClass.Multiply(4);
            }
        }
    }

How to create Window Services

2011-08-13T08:46:00.000-07:00

This Program for beginners
If You are understand i will give small project to you yar..

Use:It Provide Availability
It is Long Running Program it is running through window operating system
MSDN DEFINITION:
enable you to create long-running executable applications that run in their own Windows sessions. These services can be automatically started when the computer boots, can be paused and restarted, and do not show any user interface. These features make services ideal for use on a server or whenever you need long-running functionality that does not interfere with other users who are working on the same computer. You can also run services in the security context of a specific user account that is different from the logged-on user or the default computer account. For more information about services and Windows sessions
visual studio>File>NewProject>Window services.

click and add addinstaller

In this way the properties of service installer1
Service name :WindowLogWriteProcessor
Display Name : Your Name It will be display on services.msc
Description :purpose
Start Type :Manual,Automatic
This for When System Is booted it is automatically started Or manually You want to start,
-----------------------------------------------------------
In This same Way Properties of serviceProcessInstaller1
Account: Local System //For authentication

See 2nd screen Then Click Switch To Code View

Code

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;

namespace WindowsService2
{
public partial class Service1 : ServiceBase
{

public Service1()
{
InitializeComponent();
}

protected override void OnStart(string[] args)
{
EventLog.WriteEntry("service started successfully my own Program");

}

protected override void OnStop()
{
EventLog.WriteEntry("service stoped successfully my own Program");

}
}
}

build your program and then check
your project folder>bin>debug(Or) Release>givenname.exe like WindowsService2.exe

it is ok

Then

start >all programs >visual studio command tools>command prompt

then

write >installutil -i drivepath-----

Ex:installutil F:\WindowsService2\bin\debug\windowsService2.exe

then enter

Then Enter service created successfully
this statement :The transacted install has completed.
then run >services.msc
window displayed

mycomputer >rightclick>then click manage >
click winodws logs>applicatin>
then click on information service1
see window like

Mail send using gmail in asp.net

2011-08-13T06:26:00.000-07:00

using System.Net.Mail;
//for smtp protocol provide asp.net framework in this namespace

private void SendMail_Click(object sender, EventArgs e)
{
//prepare our mail message

MailMessage StrMail = new MailMessage();
StrMail.To.Add("receivers@gmail.com");
StrMail.To.Add("receivers@yahoo.com");
StrMail.From = new MailAddress("YourUserName@gmail.com");
StrMail.Subject = "Email using Gmail";
string Body = "send mail from asp.net prog...";

StrMail.Body = Body;
StrMail.IsBodyHtml = true;
SmtpClient smtp = new SmtpClient();
smtp.Host = "smtp.gmail.com";//google api or use other api providers aslo
smtp.Port = 587;
//smtp.EnableSsl = true; it is secure purpose
smtp.Credentials = new System.Net.NetworkCredential
("YourUserName@gmail.com", "YourGmailPassword"); //your gamil id and password or other api userid and password
smtp.EnableSsl = true;
smtp.Send(StrMail);

}