Its's Me Sandeep

Understanding the Dynamic Keyword in C# 4

2011-12-24T07:47:00.000-08:00

Understanding the Dynamic Keyword in C# 4

The dynamic keyword and the Dynamic Language Runtime (DLR) are major new features in C# 4 and the Microsoft .NET Framework 4. These features generated a lot of interest when announced—along with a lot of questions. There were a number of answers as well, but they’re now spread throughout documentation and on various technical blogs and articles. So people continue asking the same questions again and again on forums and at conferences.

This article provides a general overview of the new dynamic features in C# 4 and also delves into some more in-depth information about how they work with other language and framework features, such as reflection or implicitly typed variables. Given there’s a lot of information available already, I’ll sometimes reuse classic examples with links to the original sources. I’ll also provide plenty of links for further reading.

What Is Dynamic?

Programming languages are sometimes divided into statically typed and dynamically typed languages. C# and Java are often considered examples of statically typed languages, while Python, Ruby and JavaScript are examples of dynamically typed languages.

Generally speaking, dynamic languages don’t perform compile-time type checks and identify the type of objects at run time only. This approach has its pros and cons: Often the code is much faster and easier to write, but at the same time you don’t get compiler errors and have to use unit testing and other techniques to ensure the correct behavior of your application.

Originally, C# was created as a purely static language, but with C# 4, dynamic elements have been added to improve interoperability with dynamic languages and frameworks. The C# team considered several design options, but finally settled on adding a new keyword to support these features: dynamic.

The dynamic keyword acts as a static type declaration in the C# type system. This way C# got the dynamic features and at the same time remained a statically typed language. Why and how this decision was made is explained in the presentation “Dynamic Binding in C# 4” by Mads Torgersen at PDC09 (microsoftpdc.com/2009/FT31). Among other things, it was decided that dynamic objects should be first-class citizens of the C# language, so there’s no option to switch dynamic features on or off, and nothing similar to the Option Strict On/Off in Visual Basic was added to C#.

When you use the dynamic keyword you tell the compiler to turn off compile-time checking. There are plenty of examples on the Web and in the MSDN documentation (msdn.microsoft.com/library/dd264736) on how to use this keyword. A common example looks like this:

1.           dynamic d = "test";

2.           Console.WriteLine(d.GetType());

3.           // Prints "System.String".

4.

5.           d = 100;

6.           Console.WriteLine(d.GetType());

7.           // Prints "System.Int32".

As you can see, it’s possible to assign objects of different types to a variable declared as dynamic. The code compiles and the type of object is identified at run time. However, this code compiles as well, but throws an exception at run time:

1.           dynamic d = "test";

2.

3.           // The following line throws an exception at run time.

4.           d++;

The reason is the same: The compiler doesn’t know the runtime type of the object and therefore can’t tell you that the increment operation is not supported in this case.

Absence of compile-time type checking leads to the absence of IntelliSense as well. Because the C# compiler doesn’t know the type of the object, it can’t enumerate its properties and methods. This problem might be solved with additional type inference, as is done in the IronPython tools for Visual Studio, but for now C# doesn’t provide it.

However, in many scenarios that might benefit from the dynamic features, IntelliSense wasn’t available anyway because the code used string literals. This issue is discussed in more detail later in this article.

Dynamic, Object or Var?

So what’s the real difference between dynamic, object and var, and when should you use them? Here are short definitions of each keyword and some examples.

The object –keyword represents the System.Object type, which is the root type in the C# class hierarchy. This keyword is often used when there’s no way to identify the object type at compile time, which often happens in various interoperability scenarios.

You need to use explicit casts to convert a variable declared as object to a specific type:

1.           object objExample = 10;

2.           Console.WriteLine(objExample.GetType());

This obviously prints System.Int32. However, the static type is System.Object, so you need an explicit cast here:

1.           objExample = (int)objExample + 10;

You can assign values of different types because they all inherit from System.Object:

1.           objExample = "test";

The var keyword, since C# 3.0, is used for implicitly typed local variables and for anonymous types. This keyword is often used with LINQ. When a variable is declared by using the var keyword, the variable’s type is inferred from the initialization string at compile time. The type of the variable can’t be changed at run time. If the compiler can’t infer the type, it produces a compilation error:

1.           var varExample = 10;

2.           Console.WriteLine(varExample.GetType());

This prints System.Int32, and it’s the same as the static type.

In the following example, no cast is required because varExample’s static typed is System.Int32:

1.           varExample = varExample + 10;

This line doesn’t compile because you can only assign integers to varExample:

1.           varExample = "test";

he dynamic keyword, introduced in C# 4, makes certain scenarios that traditionally relied on the object keyword easier to write and maintain. In fact, the dynamic type uses the System.Object type under the hood, but unlike object it doesn’t require explicit cast operations at compile time, because it identifies the type at run time only:

1.           dynamic dynamicExample = 10;

2.           Console.WriteLine(dynamicExample.GetType());

This prints System.Int32.

In the following line, no cast is required, because the type is identified at run time only:

dynamicExample = dynamicExample + 10;

You can assign values of different types to dynamicExample:

dynamicExample = "test";

There’s a detailed blog post about differences between the object and dynamic keywords on the C# FAQ blog (bit.ly/c95hpl).

What sometimes causes confusion is that all of these keywords can be used together—they’re not mutually exclusive. For example, let’s take a look at this code:

1.           dynamic dynamicObject = new Object();

2.           var anotherObject = dynamicObject;

What’s the type of anotherObject? The answer is: dynamic. Remember that dynamic is in fact a static type in the C# type system, so the compiler infers this type for the anotherObject. It’s important to understand that the var keyword is just an instruction for the compiler to infer the type from the variable’s initialization expression; var is not a type.

The Dynamic Language Runtime

When you hear the term “dynamic” in regard to the C# language, it usually refers to one of two concepts: the dynamic keyword in C# 4 or the DLR. Although these two concepts are related, it’s important to understand the difference as well.

The DLR serves two main goals. First, it enables interoperation between dynamic languages and the .NET Framework. Second, it brings dynamic behavior to C# and Visual Basic.

The DLR was created based on lessons learned while building IronPython (ironpython.net), which was the first dynamic language implemented on the .NET Framework. While working on IronPython, the team found out that they could reuse their implementation for more than one language, so they created a common underlying platform for .NET dynamic languages. Like IronPython, the DLR became an open source project and its source code is now available at dlr.codeplex.com.

Later the DLR was also included in the .NET Framework 4 to support dynamic features in C# and Visual Basic. If you only need the dynamic keyword in C# 4, you can simply use the .NET Framework and in most cases it will handle all interactions with the DLR on its own. But if you want to implement or port a new dynamic language to .NET, you may benefit from the extra helper classes in the open source project, which has more features and services for language implementers.

Using Dynamic in a Statically Typed Language

It’s not expected that everybody should use dynamic whenever  possible instead of the static type declarations. Compile-time checking is a powerful instrument and the more benefits you can get from it, the better. And once again, dynamic objects in C# do not support IntelliSense, which might have a certain impact on overall productivity.

At the same time, there are scenarios that were hard to implement in C# prior to the dynamic keyword and the DLR. In most cases they used System.Object type and explicit casting and couldn’t get much benefit from compile-time checking and IntelliSense anyway. Here are some examples.

The most notorious scenario is when you have to use the object keyword for interoperability with other languages or frameworks. Usually you have to rely on reflection to get the type of the object and to access its properties and methods. The syntax is sometimes hard to read and consequently the code is hard to maintain. Using dynamic here might be much easier and more convenient than reflection.

Anders Hejlsberg gave a great example at PDC08 (channel9.msdn.com/pdc2008/TL16) that looks like this:

1.           object calc = GetCalculator();

2.           Type calcType = calc.GetType();

3.           object res = calcType.InvokeMember(

4.             "Add", BindingFlags.InvokeMethod,

5.             null, new object[] { 10, 20 });

6.           int sum = Convert.ToInt32(res);

The function returns a calculator, but the system doesn’t know the exact type of this calculator object at compile time. The only thing the code relies on is that this object should have the Add method. Note that you don’t get IntelliSense for this method because you supply its name as a string literal.

With the dynamic keyword, this code looks as simple as this one:

1.           dynamic calc = GetCalculator();

2.           int sum = calc.Add(10, 20);

The assumptions are the same: There’s some object with an unknown type that we expect to have the Add method. And similar to the previous example, you don’t get IntelliSense for this method. But the syntax is much easier to read and use and looks similar to calling a typical .NET method.

Dynamic Method Bags

Another example where dynamic can help is creating dynamic method bags, which are objects that can add and remove properties and methods at run time.

The .NET Framework 4 has a new namespace: System.Dynamic. This namespace is in fact a part of the DLR. The System.Dynamic.ExpandoObject and System.Expando.DynamicObject classes in combination with the new dynamic keyword can help you to create dynamic structures and hierarchies in a clear and easy-to-read way.

For example, here’s how you can add a property and a method by using the ExpandoObject class:

1.           dynamic expando = new ExpandoObject();

2.           expando.SampleProperty =

3.             "This property was added at run time";

4.           expando.SampleMethod = (Action)(

5.             () => Console.WriteLine(expando.SampleProperty));

6.           expando.SampleMethod();

For more in-depth scenarios, be sure to take a look at the MSDN documentation for the ExpandoObject and DynamicObject classes. Also, it’s worth reading through the articles ”Dynamic Method Bags” by Bill Wagner (msdn.microsoft.com/library/ee658247) and “Dynamic in C# 4.0: Introducing the ExpandoObject” on the C# FAQ blog (bit.ly/amRYRw).

Identifying Dynamic Objects

How can you distinguish dynamic objects from other objects? One easy way is to use built-in IDE features. You can either hover the mouse cursor over the object to see its declaration type or check whether IntelliSense is available (see Figure 2).

Figure 2 Dynamic Object in Visual Studio

At run time, however, things get more complicated. You can’t check whether the variable was declared by the dynamic keyword—the runtime type of the dynamic object is the type of the value it stores and you can’t get its static type declaration. It’s the same as if you declare your variable as object: At run time you can only get a type of the value that the variable holds; you can’t tell whether this variable was originally declared as object.

What you can identify at run time is whether an object is coming from the DLR. It might be important because objects of types like ExpandoObject and DynamicObject can change their behavior at run time—for example, add and delete properties and methods.

Also, you can’t use standard reflection methods to get information about such objects. If you add a property to an instance of the ExpandoObject class, you can’t get this property from reflection:

1.           dynamic expando = new ExpandoObject();

2.           expando.SampleProperty = "This property was added at run time";

3.           PropertyInfo dynamicProperty =

4.             expando.GetType().GetProperty("SampleProperty");

5.           // dynamicProperty is null.

The good thing is that, in the .NET Framework 4, all objects that can dynamically add and remove members must implement one particular interface: System.Dynamic.IDynamicMetaObjectProvider. Both DynamicObject and ExpandoObject classes implement this interface, as well. However, this doesn’t mean that any object declared by using the dynamic keyword implements this interface:

1.           dynamic expando = new ExpandoObject();

2.           Console.WriteLine(expando is IDynamicMetaObjectProvider);

3.           // True

4.

5.           dynamic test = "test";

6.           Console.WriteLine(test is IDynamicMetaObjectProvider);

7.           // False

So, if you’re using dynamic along with reflection, remember that reflection won’t work for dynamically added properties and methods, and it might be a good idea to check whether the object you’re reflecting on implements the IDynamicMetaObjectProvider interface.

Dynamic and COM Interop

The COM interop scenario that the C# team specifically targeted in the C# 4 release was programming against Microsoft Office applications, such as Word and Excel. The intent was to make this task as easy and natural in C# as it always was in Visual Basic. This is also a part of the Visual Basic and C# co-evolution strategy, where both languages aim at feature parity and borrow the best and most productive solutions from one another.

If you’re interested in the details, read “C# and VB coevolution” on Scott Wiltamuth’s Visual Studio blog (bit.ly/bFUpxG).

Figure 3 shows the C# 4 code that adds a value to the first cell in the Excel worksheet and then applies the AutoFit method to the first column. The comments under each line show equivalents from C# 3.0 and earlier.

Figure 3 Scripting Excel with C#

1.           // Add this line to the beginning of the file:

2.           // using Excel = Microsoft.Office.Interop.Excel;

3.

4.           var excelApp = new Excel.Application();

5.

6.           excelApp.Workbooks.Add();

7.           // excelApp.Workbooks.Add(Type.Missing);

8.

9.           excelApp.Visible = true;

10.

11.       Excel.Range targetRange = excelApp.Range["A1"];

12.       // Excel.Range targetRange = excelApp.get_Range("A1", Type.Missing);

13.

14.       targetRange.Value = "Name";

15.       // targetRange.set_Value(Type.Missing, "Name");

16.

17.       targetRange.Columns[1].AutoFit();

18.       // ((Excel.Range)targetRange.Columns[1, Type.Missing]).AutoFit();

The interesting thing about this example is that you can’t see the dynamic keyword anywhere in the code. In fact, it’s used in just one line here:

1.           targetRange.Columns[1].AutoFit();

2.           // ((Excel.Range)targetRange.Columns[1, Type.Missing]).AutoFit();

In the C# 3.0 version, targetRange.Columns[1, Type.Missing] returns object, and that’s why the casting to Excel.Range is necessary. But in C# 4 and Visual Studio 2010 such calls are silently converted into dynamic ones. So, the type of the targetRange.Columns[1] in C# 4 is actually dynamic.

Another highlight is that the COM interop improvements in C# 4 are not just about dynamic. In all other lines better syntax is achieved because of other new features such as indexed properties and named and optional parameters. You can find a good overview of these new features in the MSDN Magazine article “New C# Features in the .NET Framework 4” by Chris Burrows (msdn.microsoft.com/magazine/ff796223).

Where Can I Get More Information?

Hopefully this article covered most of the questions you might have about the dynamic keyword in C# 4, but I’m sure it didn’t cover everything. If you have comments, questions or suggestions, drop by dlr.codeplex.com/discussions and ask away. Someone may have already asked about the issue, or you can create a new discussion. We have an active community and welcome new members.

Source :- MSDN

Hari and Manas Performing Live after few pegs of BPS black

2011-08-04T01:24:00.000-07:00

Typed and untyped dataset

2011-07-11T10:01:00.001-07:00

The nature of a DataSet requires that it is either typed or untyped. By definition a typed DataSet is any DataSet that is derived from the base DataSet class that applies the information contained in the XSD to generate a typed class. Information from the schema that contains the tables, columns, and rows is generated and compiled into a new DataSet derived from the XSD and this promotes the DataSet to a first class object in the .NET Framework. The process of inheriting the typed DataSet from the base DataSet class means that the typed class assumes all functionality of the DataSet class and can be used with methods that take an instance of the DataSet class as a parameter. This is the opposite of the untyped DataSet that has no corresponding schema and is exposed only as a collection.

What is the difference between authentication and authorization ?

2011-07-11T09:56:00.001-07:00

An authentication system is how you identify yourself to 
the computer. The goal behind an authentication system is 
to verify that the user is actually who they say they are. 
There are many ways of authenticating a user.Like
Password based authentication 
Device based authentication 
Biometric Authentication 

Authorization 
Once the system knows who the user is through 
authentication, authorization is how the system decides 
what the user can do.
A good example of this is using group permissions or the 
difference between a normal user and the superuser on a 
unix system.

What is the difference between tcp and http?

2011-07-11T09:52:00.001-07:00

They are different layers in the network model; TCP is on the transport layer - it provides an error free connection, HTTP is on the application layer and runs on top of TCP to provide hypertext services.

Web pages both on the server end and your own end are written in hypertext markup language (HTML). When your computer asks a remote computer to send you a COPY of its webpage, you establish a connection with that remote computer using an agreed protocol called TCP/IP. As I understand it, the IP part connects the IP addresses together and then the TCP part establishes a sort of virtual connection between the two. Hypertext TRANSFER protocol (HTTP) is the agreed way (protocol) in which the remote computer copies its own data, packages it up and sends it down the virtual tube created by the TCP connection, and onwards to your own computer, at which time the (now) downloaded webpage is reassembled in your web browser from the data packets. I'm not sure whether to describe the TCP as a hose-pipe and the HTTP as the water flowing in it but for newbies like me, this explanation might help get closer to the right concept.

session manegment in ASP.NET

2011-07-11T09:45:00.000-07:00

Hypertext Transfer Protocol (HTTP) is stateless: a client computer running a web browser must establish a new Transmission Control Protocol (TCP) network connection to the web server with each new HTTP GET or POST request. The web server, therefore, cannot rely on an established TCP network connection for longer than a single HTTP GET or POST operation. Session management is the technique used by the web developer to make the stateless HTTP protocol support session state. For example, once a user has authenticated oneself to the web server, his/her next HTTP request (GET or POST) should not cause the web server to ask him/her for him/her account and password again.

The session information is stored on the web server using the session identifier (session ID) generated as a result of the first (sometimes the first authenticated) request from the end user running a web browser. The "storage" of session IDs and the associated session data (user name, account number, etc.) on the web server is accomplished using a variety of techniques including, but not limited to: local memory, flat files, and databases.

In situations where multiple web servers must share knowledge of session state (as is typical in a cluster environment) session information must be shared between the cluster nodes that are running web server software. Methods for sharing session state between nodes in a cluster include: multicasting session information to member nodes (JGroups for one example of this technique), sharing session information with a partner node using distributed shared memory or memory virtualization, sharing session information between nodes using network sockets, storing session information on a shared file system such as the network file system or the global file system, or storing the session information outside the cluster in a database.

HTTP, the underlying transport of the Web, is a memory-less protocol. Every time a client requests an application, HTTP has no idea of the caller's identity—it simply forwards the request to the Web server. To allow for a level of continuity in a Web-based application, you must use the technologies discussed in this article, which allow both JSP and Microsoft® ASP.NET applications to retain state in between client requests.

Both JSP and ASP.NET use the concept of sessions and Session objects to store data unique to a particular client while that client is connected to a Web application. For example, when a user logs on to a Web application, her login name, password, and other pertinent information might be stored in a Session variable and maintained during her visit to the site so that it can be accessed when needed. When a session begins, the requesting browser is given unique piece of information, or "ticket," that is presented by the browser on subsequent visits to identify the user. The Web application can then, for example, customize the settings for that user when she visits, since it can find her personal preferences using the information stored in the Session object referenced by the ticket.

The stateless nature of HTTP makes the inclusion of a mechanism to save application state between user requests a must, the server must be able to identify the same user across multiple requests. Classic ASP included a Session object that accomplished this, but unfortunately, that implementation has two main weaknesses.

First, the 120-bit session ID used to identify the session is always stored as a cookie on the browser. So, if the security policy of a user's employer disallows cookies, the Session object cannot be populated.

Second, the data associated with the session and accessed through the session ID is stored on the Web server that processed the initial request and started the session. As a result, the session data can't be shared in a web farm scenario where multiple web servers are processing requests from multiple clients. Although programmatic techniques, and system software such as the Windows 2000 clustering services and Application Center 2000, can be configured to force a client to access the same web server for each request (referred to as sticky IP), the overhead and possible imbalance that this situation creates reduces scalability.

The ASP.NET session implementation addresses both of these weaknesses by allowing for "cookieless" sessions and off-server storage of session data. The ASP.NET session state module is configured declaratively in the Web.config file like so:

In this case, the mode attribute is set to InProc (the default) to indicate that the session state is stored in memory by ASP.NET and that cookies will not be used to pass the session ID. Instead, the session ID is inserted into the query string for a page's URL. For example, using InProc mode, after a session is established, a call to a hypothetical ASP.NET page would look something like the following:

http://my.website.com/(55mfgh55vgblurtywsityvjq)/education.aspx

The long alphanumeric string in parentheses is the session ID. The ASP.NET engine extracts the session ID from the query string and can then associate the user request with the appropriate session. In this way, cookies are not required, nor are hidden form fields. So, pages without forms can still participate in the session.

As with ASP before it, session state management in ASP.NET requires overhead. So, if a particular page will not be accessing the Session object, developers can set the EnableSessionState attribute of the Page directive for that page to False. If a particular page will be accessing the Session object and not altering the value of the session, then set the EnableSessionState attribute of the Page directive for that page to Readonly. Session state can be disabled for an entire site by setting the mode attribute of the sessionState element to Off in the Web.config.

ASP.NET offers three session management solutions. They are:

InProcess,
StateServer (outProcess),
SQLServer (database based)

I am going to explain in detail about the new session management options with ASP.NET, especially SQLSEVER and STATESERVER.

InProc

This is same as the conventional ASP session management. Session is stored in memory on the web server.

StateServer session management

A second option, accomplished by setting the mode attribute to StateServer, is storing session data in a separate in-memory cache controlled by a Windows service running on a separate machine. The state service, called the ASP.NET State Service (aspnet_state.exe), is configured by the stateConnectionString attribute in the Web.config file. It specifies the service's server and the port it monitors:

In this case, the state service is running on a machine called myserver on port 42424, which is the default. At the server, the port can be changed by editing the Port value in the HKLM\SYSTEM\CurrentControlSet\Services\aspnet_state registry key. Obviously, using the state service has the advantages of process isolation and sharability across a web farm. However, if the state service is stopped, all session data is lost. In other words, the state service does not persistently store the data as SQL Server does; it simply holds it in memory.

Session management with SQL Server

ASP.NET also allows you to store session data on a database server by changing the mode attribute to SqlServer. In this case, ASP.NET attempts to store session data on the SQL Server specified by a sqlConnectionString attribute that would contain the data source and security credentials necessary to log on to the server. To configure the SQL Server with the appropriate database objects, an administrator would also need to create the ASPState database by running the InstallState.sql script found in the WinDir\Microsoft.Net\Framework\Version folder (where WinDir is the name of your server's Windows folder and Version is the installation folder for the appropriate version of the .NET Framework you're using).

Once the SQL Server is configured, the application code should run identically to the InProc mode. But keep in mind that since the data is not stored in local memory, objects stored in session state will need to be serialized and deserialized for transport across the network to and from the database server, which will affect performance. By storing session state in the database, you're effectively trading performance for scalability and reliability.

Pros and cons of the three session management solutions in brief

InProc - stored in memory on web server
This is the default setting.
- Pros: least overhead, fastest performance
- Cons: breaks web clusters, restarting IIS loses sessions
StateServer - managed by a remote service (aspnet_state)
HTTP protocol over TCP port.
- Pros: reasonably fast, works with clusters
- Cons: clear text, no authentication, overflows...
SQLServer - stored in SQL Server DB tables
Uses normal ODBC connection.
- Pros: reliable, scalable
- Cons: relatively slow, much overhead

Can interface have constructor

2011-07-04T08:03:00.000-07:00

An interface can be a member of a namespace or a class. An interface contains only the signatures of methods, delegates or events. The implementation of the methods is done in the class that implements the interface. it means in c sharp we can't have constructor in interface but other language like c++ support static constructor in interface. An interface can inherit from one or more base interfaces.

When a base type list contains a base class and interfaces, the base class must come first in the list.

How to add concrete method in interface with extenssion methods

2011-07-04T07:45:00.001-07:00

using System;

namespace ExtenssionMethodWithInterface

{

interface ITestInterface

{

void Print();

}

static class ExtenssionClass

{

public static void Print2(this ITestInterface obj)

{

Console.WriteLine("this massage is from interface");

}

class TestClass :ITestInterface

{

public void Print()

{

Console.WriteLine("this massage is from Class which implements interface");

}

class MainClass

{

public static void Main (string[] args)

{

TestClass obj = new TestClass();

obj.Print();

obj.Print2();

}

Default Access Modifiers

2011-06-27T05:14:00.001-07:00

Depending on the context in which a member declaration takes place, only certain types of declared accessibility are permitted. Furthermore, when a member declaration does not include any access modifiers, the context in which the declaration takes place determines the default declared accessibility.

· Namespaces implicitly have public declared accessibility. No access modifiers are allowed on namespace declarations.

· Types declared in compilation units or namespaces can have public or internal declared accessibility and default to internal declared accessibility.

· Class members can have any of the five kinds of declared accessibility and default to private declared accessibility. (Note that a type declared as a member of a class can have any of the five kinds of declared accessibility, whereas a type declared as a member of a namespace can have only public or internal declared accessibility.)

· Struct members can have public, internal, or private declared accessibility and default to private declared accessibility because structs are implicitly sealed. Struct members introduced in a struct (that is, not inherited by that struct) cannot have protected or protected internal declared accessibility. (Note that a type declared as a member of a struct can have public, internal, or private declared accessibility, whereas a type declared as a member of a namespace can have only public or internal declared accessibility.)

· Interface members implicitly have public declared accessibility. No access modifiers are allowed on interface member declarations.

· Enumeration members implicitly have public declared accessibility. No access modifiers are allowed on enumeration member declarations.

Access modifiers in C Sharp .NET

2011-06-27T03:34:00.000-07:00

1. Access modifiers are keywords added to the class, struct, or member declaration to specify access restrictions.

2. Classes and structs that are not nested within other classes or structs can be either public or internal.

3. A type declared as public is accessible by any other type.

4. A type declared as internal is only accessible by types within the same assembly or derive type of containing type.

5. If we declare any type in a class or structure its private by default.

6. Class or struct members can be declared with one of five types of access. They can be public or internal, like the classes and structs themselves. A class member can be declared as protected using the protected keyword, meaning that only derived types using the class as a base can access the member. By combining the protected and internal keywords, a class member can be marked protected internal — only derived types or types within the same assembly can access that member. Finally, a class or struct member can be declared as private with the private keyword, indicating that only the class or struct declaring the member is allowed access to that member.

7. Interface members are always public, and no access modifiers can be applied.

8. Namespaces and enumeration members are always public, and no access modifiers can be applied.

9. Delegates have internal access by default.

10. Any types declared within a namespace or at the top level of a compilation unit (for example, not within a namespace, class, or struct) are internal by default, but can be made public.

11. Namespace elements cannot be explicitly declared as private, protected, or protected internal.

Basic Notes about Interface, Abstract Class and Abstract Keyword

2011-06-22T11:10:00.000-07:00

Some points to remeber about abstact class and interface

Interface:-

1. An interface can inherits from muiltiple interfaces.

2. An interface contains only the signatures of methods, delegates, events, indexers or propeties.

3. We can't give explicit access modifier of any of the members of interface by default all the members of interface are public.

4. if a class implements an interface it has to implement all the methods which are defined in interface.

5. An interface can be a member of a namespace or a class.

6. if you don't know the implementation of any of the method of you type you should use interface.

7. When a base type list contains a base class and interfaces, the base class must come first in the list.

Abstract Class

1. A Abstract Class Can't be a sealed class becaue it ment to be an base class if you try to make it sealed it will give Compile time error.

2. Use the abstract modifier in a class declaration to indicate that a class is intended only to be a base class of other classes.

3. An abstract class cannot be instantiated.

4. An abstract class may contain abstract methods and accessors and concrete methods.

5. An abstract class can have all the concrete methods.

6. if a method is marked as abstract then we have to make its class as abstract class.

7. its possbile to make an abstract class by inheriting an other abstract class

Abstract Keywords

1. The abstract modifier can be used with classes, methods, properties, indexers, and events.

2. Use the abstract modifier in a class declaration to indicate that a class is intended only to be a base class of other classes.

3. Use the abstract modifier in a method or property declaration to indicate that the method or property does not contain implementation.

4. An abstract class cannot be instantiated.

5. An abstract class may contain abstract methods and accessors.

6. It is not possible to modify an abstract class with the sealed modifier, which means that the class cannot be inherited.

7. A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors.

8. An abstract method is implicitly a virtual method.

9. Abstract method declarations are only permitted in abstract classes.

10. Because an abstract method declaration provides no actual implementation, there is no method body; the method declaration simply ends with a semicolon and there are no braces ({ }) following the signature. For example: public abstract void MyMethod();

11. The implementation is provided by an overriding method, which is a member of a non-abstract class.

12. It is an error to use the static or virtual modifiers in an abstract method declaration.

13. Abstract properties behave like abstract methods, except for the differences in declaration and invocation syntax.

14. It is an error to use the abstract modifier on a static property.

15. An abstract inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

16. An abstract class must provide implementation for all interface members.

17. An abstract class that implements an interface might map the interface methods onto abstract methods. For example:

interface I

{

void M();

}

abstract class C: I

{

public abstract void M();

}

Explicit Interface Implementation

2011-06-22T10:40:00.000-07:00

If a class implements two interfaces that contain a member with the same signature, then implementing that member on the class will cause both interfaces to use that member as their implementation. For example:

interface IControl
{
    void Paint();
}
interface ISurface
{
    void Paint();
}
class SampleClass : IControl, ISurface
{
    // Both ISurface.Paint and IControl.Paint call this method.
    public void Paint()
    {
    }
}

If the two interface members do not perform the same function, however, this can lead to an incorrect implementation of one or both of the interfaces. It is possible to implement an interface member explicitly—creating a class member that is only called through the interface, and is specific to that interface. This is accomplished by naming the class member with the name of the interface and a period. For example:

public class SampleClass : IControl, ISurface
{
    void IControl.Paint()
    {
        System.Console.WriteLine("IControl.Paint");
    }
    void ISurface.Paint()
    {
        System.Console.WriteLine("ISurface.Paint");
    }
}

The class member IControl.Paint is only available through the IControl interface, and ISurface.Paint is only available through ISurface. Both method implementations are separate, and neither is available directly on the class. For example:

SampleClass obj = new SampleClass();
//obj.Paint();  // Compiler error.

IControl c = (IControl)obj;
c.Paint();  // Calls IControl.Paint on SampleClass.

ISurface s = (ISurface)obj;
s.Paint(); // Calls ISurface.Paint on SampleClass.

Explicit implementation is also used to resolve cases where two interfaces each declare different members of the same name such as a property and a method:

interface ILeft
{
    int P { get;}
}
interface IRight
{
    int P();
}

To implement both interfaces, a class has to use explicit implementation either for the property P, or the method P, or both, to avoid a compiler error. For example:

class Middle : ILeft, IRight
{
    public int P() { return 0; }
    int ILeft.P { get { return 0; } }
}

Difference between a Delegate and Event

2011-06-22T09:41:00.000-07:00

what is the difference between a delegate and event. We can do the same thing with both a delegate and an event. There only seems to be a syntactical difference between the two.Here is the difference between a delegate and an event.

Delegate:

public class Del

{

public delegate void ExampleDelegate(int num1,string str1);

public ExampleDelegate DeleageteCallback;

}

Event:

public class Eve

{

public delegate void ExampleEvent(int num1,string str2);

public event ExampleEvent EventCallback;

}

So syntax wise there is only one difference that we have to use the event keyword with the event.

So the question comes why do we have a keyword when the same work can be done without using it. But there is a reason for the existence of the keyword event. Lets take an example how would a client work with this class

Del V = new Del();

V.DeleageteCallback +=new

Del.ExampleDelegate (this.Delegate);

Here we are adding a new target to the invocation list of the delegate. The same code will work with the other class also without any problem

Eve V = new Eve();

V.EventCallback + =new

Eve.ExampleEvent(this.Delegate);

But consider a case where by instead of adding a new target to the invocation list of the delegate if I simply set a delegate to a new delegate (The difference is with the + sign being not there).

Del V = new Del();

V.DeleageteCallback =new

Del.ExampleDelegate (this.Delegate);

This code will work fine here but the same will not work with an event.

So what it means is that if we use the event keyword no client class can set it to null. This is very important. Multiple clients can use the same delegate. After multiple client have added a function to listen to the callback of the delegate. But now one of the client sets the delegate to null or uses the = sign to add a new call back. This means that the previous invocation list will not be used any more. Hence all the previous client will not get any of the callback even if they have registered for the call back.

Hence we can say that the even keyword adds a layer of protection on the instance of the delegate. The protection prevents any client to reset the delegate invocation list. They can only add or remove the target from the invocation list.

Show Page in java Script Pop up Window

2011-06-21T05:19:00.001-07:00

private void ShowPopup()

{

Page.ClientScript.RegisterStartupScript(this.GetType(), "confirmation", "window.open('Message.aspx','windowname2', 'width=200, height=77, directories=no, location=no, menubar=no, resizable=no, scrollbars=0, status=no, toolbar=no');", true);

}

How to Load Assambly in Memory using Reflection

2011-06-20T22:23:00.000-07:00

using System;

using System.Collections.Generic;

using System.Text;

using System.Reflection;

namespace Assamblly

{

class Program

{

static void Main(string[] args)

{

Assembly objAssembly = Assembly.LoadFrom(@"C:\Windows\Microsoft.NET\Framework\v2.0.50727\mscorlib.dll");

foreach (Type objType in objAssembly.GetTypes())

{

Console.WriteLine(objType.ToString());

}

How to C# Socket programming

2011-06-17T05:03:00.000-07:00

C# simplifies the network programming through its namespaces like System.Net and System.Net.Sockets . A Socket is an End-Point of To and From (Bidirectional) communication link between two programs (Server Program and Client Program ) running on the same network . We need two programs for communicating a socket application in C#. A Server Socket Program ( Server ) and a Client Socket Program ( Client ) . C# Server Socket Program: A C# Server Socket Program running on a computer has a socket that bound to a Port Number on the same computer and listening to the client's incoming requests.

C# Client Socket Program: A C# Client Socket Program have to know the IP Address ( Hostname ) of the computer that the C# Server Socket Program resides and the Port Number assign for listening for client's request .

Once the connection is established between Server and Client , they can communicate (read or write ) through their own sockets.

There are two types of communication protocol uses for Socket Programming in C# , they are TCP/IP ( Transmission Control Protocol/Internet protocol ) Communication and UDP/IP ( User Datagram Protocol/Internet protocol ) Communication .

In the following section we are going to communicate a C# Server Socket Program and C# Client Socket Program using TCP/IP Communication Protocol.

Code for Client Program

using System;

using System.Windows.Forms;

using System.Net.Sockets;

using System.Text;

namespace WindowsApplication1

    public partial class Form1 : Form

        System.Net.Sockets.TcpClient clientSocket = new System.Net.Sockets.TcpClient();

        public Form1()

           InitializeComponent();

        private void Form1_Load(object sender, EventArgs e)

            msg("Client Started");

            clientSocket.Connect("127.0.0.1", 8888);

            label1.Text = "Client Socket Program - Server Connected ...";

        private void button1_Click(object sender, EventArgs e)

            NetworkStream serverStream = clientSocket.GetStream();

            byte[] outStream = System.Text.Encoding.ASCII.GetBytes("Message from Client$");

            serverStream.Write(outStream, 0, outStream.Length);

            serverStream.Flush();

            byte[] inStream = new byte[10025];

            serverStream.Read(inStream, 0, (int)clientSocket.ReceiveBufferSize);

            string returndata = System.Text.Encoding.ASCII.GetString(inStream);

            msg("Data from Server : " + returndata);

        public void msg(string mesg)

            textBox1.Text = textBox1.Text + Environment.NewLine + " >> " + mesg;

Code for Server Program

using System;

using System.Net.Sockets;

using System.Text;

namespace ConsoleApplication1

    class Program

        static void Main(string[] args)

            TcpListener serverSocket = new TcpListener(8888);

            int requestCount = 0;

            TcpClient clientSocket = default(TcpClient);

            serverSocket.Start();

            Console.WriteLine(" >> Server Started");

            clientSocket = serverSocket.AcceptTcpClient();

            Console.WriteLine(" >> Accept connection from client");

            requestCount = 0;

            while ((true))

try

                    requestCount = requestCount + 1;

                    NetworkStream networkStream = clientSocket.GetStream();

                    byte[] bytesFrom = new byte[10025];

                    networkStream.Read(bytesFrom, 0, (int)clientSocket.ReceiveBufferSize);

                    string dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom);

                    dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$"));

                    Console.WriteLine(" >> Data from client - " + dataFromClient);

                    string serverResponse = "Server response " + Convert.ToString(requestCount);

                    Byte[] sendBytes = Encoding.ASCII.GetBytes(serverResponse);

                    networkStream.Write(sendBytes, 0, sendBytes.Length);

                    networkStream.Flush();

                    Console.WriteLine(" >> " + serverResponse);

                catch (Exception ex)

                    Console.WriteLine(ex.ToString());

            clientSocket.Close();

            serverSocket.Stop();

            Console.WriteLine(" >> exit");

            Console.ReadLine();

The above picture shows a Server and Client communication interfaces in C#.

C# Server Socket Program:

The Server Socket Program is done through a C# Console based application . Here the Server is listening for the Client's request , and when the C# Server gets a request from Client socket , the Server sends a response to the Client . Click the following link to see in detail of a C# Server Socket Program.

C# Client Socket Program:

The C# Client Socket Program is a windows based application . When the C# Client program execute , it will establish a connection to the C# Server program and send request to the Server , at the same time it also receive the response from C# Server . Click the following link to see in detail of C# Client Socket Program.

How to run this program ?

The C# Socket Program has two sections.

1. C# Server Socket Program

2. C# Client Socket Program

When you finish coding and build the Server and Client program , First you have to start C# Server Socket Program from DOS prompt , then you will get a message "Server Started" in your DOS screen, where the server program is running .

Next step is to start C# Client Socket Program in the same computer or other computers on the same network . When you start the client program , it will establish a connection to the Server and get a message in client screen " Client Started " , at the same time you can see a message in the Server screen "Accept connection from client" .

Now your C# Server Socket Program and C# Client Socket Program is get connected and communicated . If you want to communicate the Server and Client again , click the button in the client program , then you can see new messages in the Server and Client programs displayed.

How to find number of occurence of a word in a string

2011-06-16T08:49:00.000-07:00

Here is the code with we can find number of occurrence of a word in a string, it can be use if you want to find number of occurrence of a word in a text file just convert the inner text of text file to string and then zooom :)

using System;

using System.Text.RegularExpressions;

namespace StringExp

{

class MainClass

{

public static void Main (string[] args)

{

string s5 = "Sandeep Kumar Narware is Sandeep Kumar Narware";

string patern = "Sandeep";

Console.WriteLine(Regex.Matches(s5, patern).Count);

}

Search Strings Using Regular Expressions

2011-06-16T08:34:00.002-07:00

The System.Text.RegularExpressions.Regex class can be used to search strings. These searches can range in complexity from very simple to making full use of regular expressions. The following are two examples of string searching by using the Regex class.

The following code is a console application that performs a simple case-insensitive search of the strings in an array. The static method Regex.IsMatch performs the search given the string to search and a string that contains the search pattern. In this case, a third argument is used to indicate that case should be ignored.

class TestRegularExpressions
{
    static void Main()
    {
        string[] sentences = 
        {
            "C# code",
            "Chapter 2: Writing Code",
            "Unicode",
            "no match here"
        };

        string sPattern = "code";

        foreach (string s in sentences)
        {
            System.Console.Write("{0,24}", s);

            if (System.Text.RegularExpressions.Regex.IsMatch(s, sPattern, System.Text.RegularExpressions.RegexOptions.IgnoreCase))
            {
                System.Console.WriteLine("  (match for '{0}' found)", sPattern);
            }
            else
            {
                System.Console.WriteLine();
            }
        }

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();

    }
}
/* Output:
           C# code  (match for 'code' found)
           Chapter 2: Writing Code  (match for 'code' found)
           Unicode  (match for 'code' found)
           no match here
*/

The following code is a console application that uses regular expressions to validate the format of each string in an array. The validation requires that each string take the form of a telephone number in which three groups of digits are separated by dashes, the first two groups contain three digits, and the third group contains four digits. This is done by using the regular expression ^\\d{3}-\\d{3}-\\d{4}$.

class TestRegularExpressionValidation
{
    static void Main()
    {
        string[] numbers = 
        {
            "123-555-0190", 
            "444-234-22450", 
            "690-555-0178", 
            "146-893-232",
            "146-555-0122",
            "4007-555-0111", 
            "407-555-0111", 
            "407-2-5555", 
        };

        string sPattern = "^\\d{3}-\\d{3}-\\d{4}$";

        foreach (string s in numbers)
        {
            System.Console.Write("{0,14}", s);

            if (System.Text.RegularExpressions.Regex.IsMatch(s, sPattern))
            {
                System.Console.WriteLine(" - valid");
            }
            else
            {
                System.Console.WriteLine(" - invalid");
            }
        }

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
      123-555-0190 - valid
     444-234-22450 - invalid
      690-555-0178 - valid
       146-893-232 - invalid
      146-555-0122 - valid
     4007-555-0111 - invalid
      407-555-0111 - valid
        407-2-5555 - invalid
*/

String in C Sharp

2011-06-16T08:34:00.000-07:00

A string is an object of type String whose value is text. Internally, the text is stored as a sequential read-only collection of Char objects. There is no null-terminating character at the end of a C# string; therefore a C# string can contain any number of embedded null characters ('\0'). The Length property of a string represents the number of Char objects it contains, not the number of Unicode characters. To access the individual Unicode code points in a string, use the StringInfo object.

You can declare and initialize strings in various ways, as shown in the following example:

// Declare without initializing.

string message1;

// Initialize to null.

string message2 = null;

// Initialize as an empty string.

// Use the Empty constant instead of the literal "".

string message3 = System.String.Empty;

//Initialize with a regular string literal.

string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";

// Initialize with a verbatim string literal.

string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";

// Use System.String if you prefer.

System.String greeting = "Hello World!";

// In local variables (i.e. within a method body)

// you can use implicit typing.

var temp = "I'm still a strongly-typed System.String!";

// Use a const string to prevent 'message4' from

// being used to store another string value.

const string message4 = "You can't get rid of me!";

// Use the String constructor only when creating

// a string from a char*, char[], or sbyte*. See

// System.String documentation for details.

char[] letters = { 'A', 'B', 'C' };

string alphabet = new string(letters);

Note that you do not use the new operator to create a string object except when initializing the string with an array of chars.

Initialize a string with the Empty constant value to create a new String object whose string is of zero length. The string literal representation of a zero-length string is "". By initializing strings with the Empty value instead of null, you can reduce the chances of a NullReferenceException occurring. Use the static IsNullOrEmpty(String) method to verify the value of a string before you try to access it.

String objects are immutable: they cannot be changed after they have been created. All of the String methods and C# operators that appear to modify a string actually return the results in a new string object. In the following example, when the contents of s1 and s2 are concatenated to form a single string, the two original strings are unmodified. The += operator creates a new string that contains the combined contents. That new object is assigned to the variable s1, and the original object that was assigned to s1 is released for garbage collection because no other variable holds a reference to it.

string s1 = "A string is more ";

string s2 = "than the sum of its chars.";

// Concatenate s1 and s2. This actually creates a new

// string object and stores it in s1, releasing the

// reference to the original object.

s1 += s2;

System.Console.WriteLine(s1);

// Output: A string is more than the sum of its chars.

Because a string "modification" is actually a new string creation, you must use caution when you create references to strings. If you create a reference to a string, and then "modify" the original string, the reference will continue to point to the original object instead of the new object that was created when the string was modified. The following code illustrates this behavior:

string s1 = "Hello ";

string s2 = s1;

s1 += "World";

System.Console.WriteLine(s2);

//Output: Hello

Use regular string literals when you must embed escape characters provided by C#, as shown in the following example:

string columns = "Column 1\tColumn 2\tColumn 3";

//Output: Column 1 Column 2 Column 3

string rows = "Row 1\r\nRow 2\r\nRow 3";

/* Output:

Row 1

Row 2

Row 3

string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";

//Output: "The Æolean Harp", by Samuel Taylor Coleridge

Use verbatim strings for convenience and better readability when the string text contains backslash characters, for example in file paths. Because verbatim strings preserve new line characters as part of the string text, they can be used to initialize multiline strings. Use double quotation marks to embed a quotation mark inside a verbatim string. The following example shows some common uses for verbatim strings:

string filePath = @"C:\Users\scoleridge\Documents\";

//Output: C:\Users\scoleridge\Documents\

string text = @"My pensive SARA ! thy soft cheek reclined

Thus on mine arm, most soothing sweet it is

To sit beside our Cot,...";

/* Output:

My pensive SARA ! thy soft cheek reclined

Thus on mine arm, most soothing sweet it is

To sit beside our Cot,...

string quote = @"Her name was ""Sara.""";

//Output: Her name was "Sara."

Escape sequence

Character name

Unicode encoding

Single quote

0x0027

Double quote

0x0022

Backslash

0x005C

Null

0x0000

Alert

0x0007

Backspace

0x0008

Form feed

0x000C

New line

0x000A

Carriage return

0x000D

Horizontal tab

0x0009

Unicode escape sequence for surrogate pairs.

\Unnnnnnnn

Unicode escape sequence

\u0041 = "A"

Vertical tab

0x000B

Unicode escape sequence similar to "\u" except with variable length.

\x0041 = "A"

Note :- At compile time, verbatim strings are converted to ordinary strings with all the same escape sequences. Therefore, if you view a verbatim string in the debugger watch window, you will see the escape characters that were added by the compiler, not the verbatim version from your source code. For example, the verbatim string @"C:\files.txt" will appear in the watch window as "C:\\files.txt".

A format string is a string whose contents can be determined dynamically at runtime. You create a format string by using the static Format method and embedding placeholders in braces that will be replaced by other values at runtime. The following example uses a format string to output the result of each iteration of a loop:

class FormatString

{

static void Main()

{

// Get user input.

System.Console.WriteLine("Enter a number");

string input = System.Console.ReadLine();

// Convert the input string to an int.

int j;

System.Int32.TryParse(input, out j);

// Write a different string each iteration.

string s;

for (int i = 0; i < 10; i++)

{

// A simple format string with no alignment formatting.

s = System.String.Format("{0} times {1} = {2}", i, j, (i * j));

System.Console.WriteLine(s);

}

//Keep the console window open in debug mode.

System.Console.ReadKey();

}

One overload of the WriteLine method takes a format string as a parameter. Therefore, you can just embed a format string literal without an explicit call to the method. However, if you use the WriteLine method to display debug output in the Visual Studio Output window, you have to explicitly call the Format method because WriteLine only accepts a string, not a format string.

A substring is any sequence of characters that is contained in a string. Use the Substring method to create a new string from a part of the original string. You can search for one or more occurrences of a substring by using the IndexOf method. Use the Replace method to replace all occurrences of a specified substring with a new string. Like the Substring method, Replace actually returns a new string and does not modify the original string.

string s3 = "Visual C# Express";

System.Console.WriteLine(s3.Substring(7, 2));

// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));

// Output: "Visual Basic Express"

// Index values are zero-based

int index = s3.IndexOf("C");

// index = 7

You can use array notation with an index value to acquire read-only access to individual characters, as in the following example:

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)

{

System.Console.Write(s5[i]);

}

An empty string is an instance of a System.String object that contains zero characters. Empty strings are used often in various programming scenarios to represent a blank text field. You can call methods on empty strings because they are valid System.String objects. Empty strings are initialized as follows:

string s = String.Empty;

By contrast, a null string does not refer to an instance of a System.String object and any attempt to call a method on a null string causes a NullReferenceException. However, you can use null strings in concatenation and comparison operations with other strings. The following examples illustrate some cases in which a reference to a null string does and does not cause an exception to be thrown:

static void Main()

{

string str = "hello";

string nullStr = null;

string emptyStr = String.Empty;

string tempStr = str + nullStr;

// The following line displays "hello."

Console.WriteLine(tempStr);

bool b = (emptyStr == nullStr);

// The following line displays False.

Console.WriteLine(b);

// The following line creates a new empty string.

string newStr = emptyStr + nullStr;

// Null strings and empty strings behave differently. The following

// two lines display 0.

Console.WriteLine(emptyStr.Length);

Console.WriteLine(newStr.Length);

// The following line raises a NullReferenceException.

//Console.WriteLine(nullStr.Length);

// The null character can be displayed and counted, like other chars.

string s1 = "\x0" + "abc";

string s2 = "abc" + "\x0";

// The following line displays "* abc*".

Console.WriteLine("*" + s1 + "*");

// The following line displays "abc *".

Console.WriteLine("*" + s2 + "*");

// The following line displays 4.

Console.WriteLine(s2.Length);

}

String operations in .NET are highly optimized and in most cases do not significantly impact performance. However, in some scenarios such as tight loops that are executing many hundreds or thousands of times, string operations can affect performance. The StringBuilder class creates a string buffer that offers better performance if your program performs many string manipulations. The StringBuilder string also enables you to reassign individual characters, something the built-in string data type does not support. This code, for example, changes the content of a string without creating a new string:

System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");

sb[0] = 'C';

System.Console.WriteLine(sb.ToString());

System.Console.ReadLine();

//Outputs Cat: the ideal pet

Because the String type implements IEnumerable, you can use the extension methods defined in the Enumerable class on strings. To avoid visual clutter, these methods are excluded from IntelliSense for the String type, but they are available nevertheless. You can also use LINQ query expressions on strings

Source :- MSDN

How to Override = Operator In C Sharp

2011-06-13T09:14:00.000-07:00

We can't override = Operator in C sharp but there are work around of it here are some examples given

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using NameSpace2;

namespace NameSpace2

{

public class ArtStudent

{

public string Name;

public int age;

public ArtStudent(string name, int age)

{

this.age = age;

this.Name = name;

}

namespace NameSpace1

{

class Student

{

public string Name;

public int age;

public Student(ArtStudent objArtStudent)

{

this.Name = objArtStudent.Name;

this.age = objArtStudent.age;

}

public static implicit operator Student(ArtStudent objArtStudent)

{

return new Student(objArtStudent);

}

class Program

{

static void Main(string[] args)

{

ArtStudent obj = new ArtStudent("Sandeep", 26);

Student objStudent = new Student(obj);

Console.WriteLine(objStudent.Name);

Console.WriteLine(objStudent.age);

Console.ReadLine();

Student objStudent2 = obj;

Console.WriteLine(objStudent2.Name);

Console.WriteLine(objStudent2.age);

Console.ReadLine();

}

Iterators

2011-06-11T00:10:00.001-07:00

terators are a new feature in C# 2.0. An iterator is a method, get accessor or operator that enables you to support foreach iteration in a class or struct without having to implement the entire IEnumerable interface. Instead, you provide just an iterator, which simply traverses the data structures in your class. When the compiler detects your iterator, it will automatically generate the Current, MoveNext and Dispose methods of the IEnumerable or IEnumerable interface.

Iterators Overview

· An iterator is a section of code that returns an ordered sequence of values of the same type.

· An iterator can be used as the body of a method, an operator, or a get accessor.

· The iterator code uses the yield return statement to return each element in turn. yield break ends the iteration. For more information,

· Multiple iterators can be implemented on a class. Each iterator must have a unique name just like any class member, and can be invoked by client code in a foreach statement as follows: foreach(int x in SampleClass.Iterator2){}

· The return type of an iterator must be IEnumerable, IEnumerator, IEnumerable, or IEnumerator.

The yield keyword is used to specify the value, or values, returned. When the yield return statement is reached, the current location is stored. Execution is restarted from this location the next time the iterator is called.

Iterators are especially useful with collection classes, providing an easy way to iterate non-trivial data structures such as binary trees.

In this example, the class DaysOfTheWeek is a simple collection class that stores the days of the week as strings. After each iteration of a foreach loop, the next string in the collection is returned.

public class DaysOfTheWeek : System.Collections.IEnumerable

    string[] m_Days = { "Sun", "Mon", "Tue", "Wed", "Thr", "Fri", "Sat" };

    public System.Collections.IEnumerator GetEnumerator()

        for (int i = 0; i < m_Days.Length; i++)

            yield return m_Days[i];

class TestDaysOfTheWeek

    static void Main()

        // Create an instance of the collection class

        DaysOfTheWeek week = new DaysOfTheWeek();

        // Iterate with foreach

        foreach (string day in week)

            System.Console.Write(day + " ");

Out put :- Sun Mon Tue Wed Thr Fri Sat

Source :- MSDN

How to Convert List of Object to XML

2011-06-10T02:28:00.001-07:00

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

using System.Xml.Serialization;

using System.IO;

using System.Xml;

namespace ConvertObjectToXml

{

public class Student

{

int _RoleNumber;

string _Name;

int _Age;

public int RoleNumber

{

get { return _RoleNumber; }

set { _RoleNumber = value; }

}

public string Name

{

get { return _Name; }

set { _Name = value; }

}

public int Age

{

get { return _Age; }

set { _Age = value; }

}

public Student()

{

}

public Student(int roleNumber, string name, int age)

{

this._Age = age;

this._Name = name;

this._RoleNumber = roleNumber;

}

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

private void btnExportToXML_Click(object sender, EventArgs e)

{

            List listOfStudents = new List();
            listOfStudents.Add(new Student(100, "Sandeep Kumar", 26));
            listOfStudents.Add(new Student(101, "Amit Kumar", 26));
            listOfStudents.Add(new Student(102, "Abhishek Kumar", 26));

            string str = ObjectToXml(listOfStudents);

            XmlDocument doc = new XmlDocument();
            doc.InnerXml = str;
            doc.Save(@"E:\XML TEST\xmlfile.xml");

        }

        public string ObjectToXml(object objectToConvert)
        {
            MemoryStream stream = null;
            TextWriter writer = null;
            try
            {
                stream = new MemoryStream();
                writer = new StreamWriter(stream, Encoding.Unicode);

                XmlSerializer serializer = new XmlSerializer(objectToConvert.GetType());
                serializer.Serialize(writer, objectToConvert);
                int count = (int)stream.Length;

                byte[] arr = new byte[count];
                stream.Seek(0, SeekOrigin.Begin);

                stream.Read(arr, 0, count);
                UnicodeEncoding utf = new UnicodeEncoding();

                return utf.GetString(arr).Trim();
            }
            catch
            {
                return string.Empty;
            }
            finally
            {
                if (stream != null) stream.Close();
                if (writer != null) writer.Close();
            }
        }

    }
}

How to Convert Object to XML

2011-06-09T02:07:00.000-07:00

Here is my class

public class Student

{

int _RoleNumber;

string _Name;

int _Age;

public int RoleNumber

{

get { return _RoleNumber; }

set { _RoleNumber = value; }

}

public string Name

{

get { return _Name; }

set { _Name = value; }

}

public int Age

{

get { return _Age; }

set { _Age = value; }

}

public Student()

{

}

public Student(int roleNumber, string name, int age)

{

this._Age = age;

this._Name = name;

this._RoleNumber = roleNumber;

}

Here the method which can be use to convert object to xml

public string ObjectToXml(object objectToConvert)

{

MemoryStream stream = null;

TextWriter writer = null;

try

{

stream = new MemoryStream();

writer = new StreamWriter(stream, Encoding.Unicode);

XmlSerializer serializer = new XmlSerializer(objectToConvert.GetType());

serializer.Serialize(writer, objectToConvert);

int count = (int)stream.Length;

byte[] arr = new byte[count];

stream.Seek(0, SeekOrigin.Begin);

stream.Read(arr, 0, count);

UnicodeEncoding utf = new UnicodeEncoding();

return utf.GetString(arr).Trim();

}

catch

{

return string.Empty;

}

finally

{

if (stream != null) stream.Close();

if (writer != null) writer.Close();

}

Choosing the Best Linux Distro for You

2011-06-07T08:35:00.000-07:00

There are over three hundred Linux distributions that you can choose from. The choices can be overwhelming. There is no agreement as to what is the best linux distro. We know that Linux Ubuntu is the most popular on the desktop and Red Hat Enterprise Linux is the most popular in enterprise settings. But popularity does not equal best fit.

1. For newbies:
If you are new to Linux, I suggest you use Linux Mint or PCLinux. These are the most user friendly distributions.

Linux Mint	PCLinuxOS

2. Everyday Linux
If you are looking for a distro that is going to be around a while and is relatively easy to use, then I suggest Fedora or Ubuntu. Fedora is based by Red Hat and Ubuntu is backed by Canonical.

Linux Ubuntu	Fedora

3. Light and fast If you have an older system Puppy Linux is the choice for you. It is an amazing distribution for older machines.

Puppy Linux

4. Server
CentOS is simply an unbranded and free version of Red Hat Enterprise Linux. Debian is also an excellent choice, being well known for its stability.

CentOS	Debian

5. Music Production This is the most popular music and recording solution out there.

Ubuntu Studio
6. Multimedia If you are interested in turning your computer into a multimedia station, this is the distro for you. The learning curve is a little high, but worth it.
Mythbuntu
7. Power User: If you really want to learn Linux, then Gentoo or Slackware is the way to go. Slackware just happens to be the oldest Linux distribution still in active development.
Gentoo	Slackware
8. Netbooks If you are think of using Linux on a netbook, EasyPeasy or Jolicloud are both good choices.
Joli OS	EasyPeasy
9. KDE Desktop
For those who like the KDE desktop enviroment OpenSUSE or Kubuntu are probably the best.

OpenSUSE	Kubuntu
10. Kids If you have kids the best option for them is Edubuntu

Edubuntu

So what is the best linux distro? It depends on your needs and what you are looking for.

Playing with Array

2011-06-06T08:13:00.000-07:00

How To Find an Element in Arry

using System;

namespace ArrayExamples

{

class MainClass

{

static int[] myArray = new int[]{10,20,220,330,40,56,60,20,3} ;

public static void Main (string[] args)

{

int foundIndex = Array.IndexOf(myArray,290);

if(foundIndex > 0 )

{

Console.WriteLine("Element Found @ " + foundIndex.ToString());

}

else

{

Console.WriteLine("Element Not Found");

}

How To Find occurrence of an Element in Array

using System;

namespace ArrayExamples

{

class MainClass

{

static int[] myArray = new int[]{10,20,220,10,40,10,20,20,3} ;

public static void Main (string[] args)

{

Array.Sort(myArray);

int foundIndex = Array.IndexOf(myArray,3);

int foundLastIndex = Array.LastIndexOf(myArray,3);

if(foundIndex >= 0 )

{

Console.WriteLine("Element Found and Occurence of Elment =" + Convert.ToString(foundLastIndex - foundIndex + 1));

}

else

{

Console.WriteLine("Element Not Found");

}

How to Sort an Array

int[] myArray = new int[]{10,20,220,10,40,10,20,20,3} ;

Array.Sort(myArray);

How to Reverse and Array

int[] myArray = new int[]{10,20,220,10,40,10,20,20,3} ;

Array.Reverse(myArray);

How to Find minimum Value in an Array

int[] myArray = new int[]{10,20,220,10,40,10,20,20,3} ;

Array.Sort(myArray);

int Result = myArray[0];

How to Find maximum Value in an Array

int[] myArray = new int[]{10,20,220,10,40,10,20,20,3} ;

Array.Sort(myArray);

Array.Reverse(myArray);

int Result = myArray[0];