jairox'z

Where is the Surface Area Configuration tool in SQL Server 2008

2011-10-09T01:43:00.001-07:00

ProblemI just installed a new instance of SQL Server 2008 and I can't find the Surface Area Configuration tool that I used to use in SQL Server 2005. How can I manage the Database Engine features in SQL Server 2008?

SolutionMicrosoft has removed the Surface Area Configuration tool that was shipped in SQL Server 2005. The Services and Connections that were once managed in Surface Area Configuration tool should now be managed using the SQL Server Configuration Manager. So how do you manage the Database Engine features? You can now manage the Surface Area Configuration for the Database Engine using Policy Based Management. A new Surface Area Configuration Facet in SQL Server Management Studio exposes the properties necessary to make required changes.

First, right-click on the instance name that you would like to configure in SQL Server Management Studio and select "Facets" from the context menu as shown below.

This will display the View Facets dialog box that will provide you with a drop down of all the available facets that can be configured for the instance.

Select "Surface Area Configuration" from the Facet drop down to display the properties exposed by that facet. Make the appropriate changes and select OK to apply them to the server.

One interesting feature is the ability to make the appropriate changes for your organization and export them to create a policy using the "Export Current State as Policy..." button. This allows you to configure this once and use this policy throughout your enterprise.

Next Steps

Although you can use the Surface Area Configuration Facet to manually implement the changes on each individual server, you should review some other articles on Policy Based Management. Once you see the power of using Policy Based Management with a Central Management Server, I think you will be pleasantly surprised by these new changes in SQL Server 2008.

Review tips on Policy Based Management.
- http://www.mssqltips.com/sqlservertip/1492/using-policy-based-management-in-sql-server-2008/
- http://www.mssqltips.com/sqlservertip/1493/evaluate-and-implement-policies-in-multiple-sql-server-instances/
Review Policy Based Management in Books Online.
- http://msdn.microsoft.com/en-us/library/bb510667.aspx
Review using Policy Based Management with Central Management Servers to ease administration across database servers.
- http://msdn.microsoft.com/en-us/library/bb895144.aspx

Get list of the stored procedure from database

2011-10-09T01:41:00.000-07:00

get list of the stored procedure which contains a

31MAR

Get list of the stored procedure which contains a text ‘RAISERROR’

SELECT ROUTINE_NAME, ROUTINE_DEFINITION FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_DEFINITION LIKE‘%RAISERROR%’ AND SPECIFIC_NAME like ‘%api%’

You can get other important information using Information_schema, run the following query and get the stuff of your interest

SELECT* FROM INFORMATION_SCHEMA.ROUTINES

A Study of Delegates

2011-09-20T03:37:00.000-07:00

Introduction

Many of us already have some idea of delegates. But let's go deep inside and examine how the CLR/runtime and the compiler interprets the delegates, and what happens when you declare and manipulate delegates.

A delegate is a reference type, thus it does not hold the actual value, rather it holds the address of an object residing somewhere in the heap. To make the understanding of delegates simple, compilers represent the delegates in a different way than how it is interpreted by the CLR/runtime. We will first study how the compiler exposes delegates, and then we will jump into some ground realities of delegates from the CLR/runtime perspective.

Delegates and .NET Compilers

To make life simpler, most .NET compilers symbolize delegates as pointers to a function, just like the function pointers we have in C++. Thus, in C#, you declare delegates as follows:

public delegate void MyDelegate (int someParam, string anotherParam);

From a C# compiler perspective, MyDelagate is a delegate that could hold the address of a function that has the similar signature.

The ability of holding the address of a function makes delegates ideal for:

Callback functionality
Event modeling
Having more than one implementation against a method

Though the C# compiler exposes delegates as reference types, you could not instantiate the delegate by using thenew operator; rather delegates could be instantiated by:

Providing the name of the method to the delegate. These types of delegates are known as "Named Delegates".

void DoSomething(int someParam, string anotherParam)
{
    //Method implementation

}

MyDelegate del = DoSomething;
//del is a Named Delegate holding 

//the address of function DoSomething.

Providing the implementation of the method to the delegate. These type of delegates are known as "Anonymous Delegates".
```
del = delegate(int someParam, string anotherParam)
      { //Method implementation };
```

Invoking of named or anonymous delegates is same as calling the function:

Del (29, "some value");

Named Delegates

Named delegates could hold the address of instance methods as well as the address of static methods. If the return type of a method is inheriting from the return type defined in the delegate, then the delegate is known as aCovariance Delegate. If the parameters of the methods are the base types of the parameters defined in the delegate, then the delegate is known as a Contravariance Delegate.

public delegate ICollection MyDelegate (int someParam, 
                                 string anotherParam); 

IList DoSomething()
{
    //Method implementation

}

MyDelegate del = DoSomething;

//As IList is child of ICollection thus, 

//Del is covariance delegate.

public delegate ICollection MyDelegate (IList param);

IList DoSomething(ICollection param)
{
    //Method implementation

}

MyDelegate del = DoSomething;

//As IList is child of ICollection thus, 

//Del is contravariance delegate.

Anonymous Delegates

If an anonymous delegate is referring to some local variables, then the life of that variable would be extended to the life of that delegate.

public delegate void MyDelegate (int someParam, string anotherParam); 

MyDelegate del
void DoSomething()
{
    int n;
    del = delegate(int someParam, string anotherParam)
    { 
        n++;
    }    
}
//In above example life of local variable n 

//would be same as life of anonymous delegate del.

Delegates and the CLR/Runtime

.NET compilers have made our life easy in handling delegates. In reality, there is neither any concept of pointers to a function nor any significance to the word "delegate" in the CLR/runtime. Rather, the CLR provides an abstract classSystem.Delegate that holds the reference of a static method or class instance and the instance method of that class. The System.Delegate has two properties.

Target: Holds the reference of an instance on which the current delegate invokes the instance method. If the method is a static method, this property holds a null value.
Method: Holds the instance of the MethodInfo class for the method represented by the delegate.

The delegate also exposes the DynamicInvoke function to call the method represented by the Method property. This function takes an array of objects that are the arguments to pass to the target method. If the target method does not take any arguments, the parameter to the DynamicInvoke function would be null.

The CLR also exposes an abstract class System.MultiCastDelegate that inherits from System.Delegate.System.MultiCastDelegate maintains a list, called the Invocation List, of a delegate object. When a multicast delegate is invoked, all the delegates in the invocation list are called synchronously. TheSystem.MultiCastDelegate exposes the Combine method to add delegates to the invocation list.

When you define a delegate in C#, a new class with the name of the delegate inheriting fromSystem.MultiCastDelegate is created by the C# compiler.

public delegate ICollection MyDelegate (IList param);

The above statement causes a a new class to be added in your assembly by the C# compiler.

public class MyDelegate : System.MultiCastDelegate

You can view this class by opening your assembly using the Ildasm utility.

When you assign a method to a delegate, an instance of the compiler generated class is created with the Targetand Method as parameter to this class. In case the method is static, null is passed to the argument, Target.

As compiler generated classes are inheriting from System.MultiCastDelegate, thus delegate could hold the addresses of more than one method. C# exposes a simple method to add a method in the invocation list of underlying multiCast delegate object.

MyDelegate del;
del += DoSomething;
del += DoAnotherThing;

Internally, the C# compiler is calls the Combine method of the compiler-generated delegate class to add the methods to the invocation list.

When you invoke a delegate, C# internally calls the DynamicInvoke method of the compiler generated class. The compiler generated class also exposes methods to invoke the target methods asynchronously.

A delegate is known as an Open Instance Delegate if the Target is also provided at the time of invocation.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Understanding Covariance and Contravariance in .NET 4.0

2011-09-20T03:32:00.000-07:00

A couple of years back, while working on a project, we got a compilation exception related to Generics.

Let A base class BaseVO and classes deriving from BaseVO. For example, “FlightVO : BaseVO”.My idealistic assumption was that since: “FlightVO” inherits from BaseVO, and since BaseVO b = new FlightVO() is valid as per inheritance, then:

“List lstBaseVO = new List() would also be valid.”

But duh !!! Instead, I get a compilation exception that says:

Argument ’1′: cannot convert from 
  ‘System.Collections.Generic.List’ 
  to ‘System.Collections.Generic.List’

Since I was so sure about my assumption being right, I posted it on the MSDN forum just to confirm that it was a “bug” :-) in Generics. Thread in MSDN forum: http://social.msdn.microsoft.com/Forums/bg-BG/netfxbcl/thread/e4863bda-3f24-4a28-af55-230baaff5e7b.

Those were the .NET 3.0 days and one of the MVP moderators gave a pretty good explanation as to why my assumption was wrong. Here’s his explanation:

“List and List are distinct types, you can’t convert List toList. If it were possible, you could pass a List to a method acceptingList and that method could add an object of type Base to the list, which violates the promise that the original list only contains objects of type Derived”.

I assume someone in the CLR team might have found my assumption quite viable and it got shape in .NET 4.0 as“Covariance and Contravariance in Generics” .

So the above case is a valid example where “Covariance in Generics” can be used.

However, if we compile List lstBaseVO = new List() in .NET 4.0, it would still give the same compilation error for the very explanation given by our MVP friend. In order to make it covariant compliant, our modified piece of code would look like:

Collapse | Copy Code

IEnumerable< BaseVO > lstBaseVO = new List< FlightVO >();

The above statement is valid because, in .NET 4.0, List : IEnumerable where type ‘T’ is marked as covariant.

Here’s a quick summarization about variance in Generics.

What are the programming constructs where covariance and contravariance are applicable? Variant type parameters are restricted to generic interfaces and generic delegate types thereby ensuring type safety.
In what scenarios would we want to use variance in Generics? Let's look at a code snippet.

So, covariance and contravariance of generic type parameters enable us to use constructed generic types [A] whose type arguments [Athlete] are more derived (covariance) or less derived (contravariance) than the type argument [Person] of a target constructed type [ISample].

Covariance seems very natural because it behaves like polymorphism, whereas Contravariance seems counterintuitive. One thing that we need to be clear about is that both Covariance and Contravariance both adhere to the thumb rule of “Inheritance” which says,

“A derived class instance can be assigned to a base class variable”

Now, let’s look at a Contravariance example.

Line 2 of code snippet might make you feel that the thumb rule of inheritance is being violated. I.e., the derived class variable d is being assigned an instance of the Base class.

However, that isn’t the case. Let’s understand each line of the code snippet.

In general, a covariant type parameter can be used as the return type of a generic delegate/interface, and contravariant type parameters can be used as input parameter types.

A brief summary of facts about variance in the common language runtime:

A generic interface or generic delegate type can have both covariant and contravariant type parameters.
Variance applies only to reference types; if you specify a value type for a variant type parameter, that type parameter is invariant for the resulting constructed type.
How do we define variant generic interfaces and delegates?

Starting with the .NET Framework 4, Visual Basic and C# have keywords that enable you to mark the generic type parameters of interfaces and delegates as covariant or contravariant.

A covariant type parameter is marked with the out keyword. You cannot use a covariant type parameter as a generic type constraint for interface methods. E.g., T Display(); is an invalid statement.
A contravariant type parameter is marked with the in keyword. You can use a contravariant type parameter as a generic type constraint for an interface method.

Thank you.

Your Azure Web Role and Full IIS – Culture Changes

2011-09-20T03:06:00.001-07:00

On Azure SDK v1.3 onwards, your web role can enjoy the benefits full IIS capabilities. It means that your application has now fully controlled by IIS 7.x. Prior to v1.3, your web role was hosted on “Hosted Web Core” (HWC – hmmm, another acronym), a feature introduced in IIS 7.0. HWC can be seen as a raw IIS without having IIS monitoring and administrative features. Hence, you can have your own IIS for a specific web application. It runs in a different process (WaWebHost.exe) and has a dedicated single application pool. So, the mental model of your web role application would be:

An Azure web role consists of two logical parts in the assembly, one is RoleEntryPoint implementation and another one is your actual web application. Your typical Azure web role has:

Web role lifecycle code (RoleEntry – OnStart, OnRun and OnStop) and Service model (csdef and cscfg)
Web application code and web configuration (web.config)

In HWC, both Web role and web application logical artifacts are resided in a single process (WaWebHost.exe) as shown in figure 1. In the new full IIS capability feature, web role artifacts are loaded into a process calledWaIISHost.exe. The web application code as usual is in w3wp.exe. This is shown in figure 2.

This creates some culture changes in the approach we previously did. I have experimented only on DevFabric and am yet to test on Azure. Probably, I’ll update later. The changes are:

Process with different accounts. WaIISHost and w3wp are now running in two different account privileges. Generally, WaIISHost runs in higher privilege and this would cause some code in your web application which was previously enjoyed this high privilege benefit. For example, you can create or access an machine level environment variable from your web application in HWC mode. In Full IIS, this makes exception.
Global Configuration Setting Publisher. In HWC, it is enough to initialize global configuration setting publisher once in RoleEntryPoint.OnStart(). However, now in two different processes, you have to again set the publisher either in your framework start up or Application_Start(), otherwise it throws an exception with message “SetConfigurationSettingPublisher needs to be called beforeFromConfigurationSetting can be used”. Instead of being held up with two different initializations,CloudStorageAccount.Parse() is quite simple and elegant. It just want the connection string detail as a string which can be provided by RoleEnvironment.GetConfigurationSettingValue(…). This is safer too.
Application_End will not be encountered. In full IIS, Application_End() will never be called when you stop the debugging like you normally did in HWC.
Static variables in RoleEntryPoint are not accessible from your web application. Since these two applications are running in two different processes, sharing objects through static variable is not possible in Full IIS. Instead, try to use machine level environment variable or local resource.

License

This article, along with any associated source code and files, is licensed under The Creative Commons Attribution-ShareAlike 2.5 License

C# & SQLite – System.Data.SQLite

2011-09-20T02:57:00.001-07:00

Building an VS2010 project using an SQLite embedded database.. Project codename &quotContact&qout; I’ll be demostrating how to insert, edit and delete records from the database First of all you’ll have to aquire a few files and install a few necessary software packets. SQLite ADO.Net pro

Building an VS2010 project using an SQLite embedded database
Project codename &quotContact&qout;
I’ll be demostrating how to insert, edit and delete records from the database

First of all you’ll have to aquire a few files and install a few necessary software packets.

SQLite ADO.Net provider http://sqlite.phxsoftware.com
SQLite Administrator http://sqliteadmin.orbmu2k.de

SQLite Admin Tool

This tool I chose the Full install and I’m pleased with the result.

SQLite ADO.Net Provider

This tool I installed in a C:\Temp file and I choze not to register the DLL files. Why because I just needed to include the main DLL in my project.

First we create a SQLite dB named "Contact.3db" using the SQLite Admin tool. I added a table "Contact" with a few fields and inserted a few records of data to play with.

CREATE TABLE [Contact] (
[contact_id] INTEGER  PRIMARY KEY AUTOINCREMENT NOT NULL,
[FirstName] vARCHAR(50)  NULL,
[LastName] vARCHAR(50)  NULL)

Next I created a VS2010 project named "Contact" and added a few folders and files

Add a folder[Database] and insert an existing Item "Contact.3db"
Change the property "Copy to Output Directory" -> "Copy Always"

Next I added the ecential SQLite DLL to my project.
System.Data.SQLite.dll -> change the property "Copy to Output Directory" -> "Copy Always"
SQLite.Interop.dll -> change the property "Copy to Output Directory" -> "Copy Always"

Remark: Both files [ System.Data.SQLite.dll , SQLite.Interop.dll ] must be included just under the root project "Contact".
Contact
-> System.Data.SQLite.dll -> SQLite.Interop.dll

Next I added a Folder named "Classes" and created to classes to handel all dB transactions..
dBFunctions.cs and dBHelper.cs

Next I added a Folder named "Forms" and created a few forms to handel Interaction / Interface
ContactList.cs , BaseContact.cs , NewContact.cs , EditContact.cs , DeleteContact.cs

And this includes my files within my project.

You can download the source code here

How to clear a TextBox value in a single click in C# .NET

2011-09-20T00:05:00.001-07:00

protected void Button2_Click(object sender, EventArgs e)
{
    ClearInputs(Page.Controls);
}
void ClearInputs(ControlCollection ctrls)
{
    foreach (Control ctrl in ctrls)
    {
        if (ctrl is TextBox)
            ((TextBox)ctrl).Text = string.Empty;
        ClearInputs(ctrl.Controls);
    }
}

Sending HTML e-mail with embedded images

2011-09-16T00:47:00.000-07:00

I've seen a couple posts on this before but they all seem to miss out a critical piece of code that without, causes the images to be embedded but they do not display correctly in some e-mail clients (such as Outlook 2003/2007). The following code will make it work across a number of clients I've tested it with and I've also thrown in a basic way to have a plain text e-mail attached as well in case the client does not support HTML.

Disclaimer: I've chosen to use the media type of JPEG, it's not ideal but it's something I threw together to get the main point across. You should really get the file extension and use a switch statement for the different media types.

public static void SendMessageWithEmbeddedImages()
{
  string htmlMessage = @"<html>

                         <body>
                         <img src='cid:EmbeddedContent_1' />
                         </body>
                         </html>";
  SmtpClient client = new SmtpClient("mail.server.com");
  MailMessage msg = new MailMessage("noreply@deventerprise.net",
                                    "someone@deventerprise.net");
  // Create the HTML view

  AlternateView htmlView = AlternateView.CreateAlternateViewFromString(
                                               htmlMessage,
                                               Encoding.UTF8,
                                               MediaTypeNames.Text.Html);
  // Create a plain text message for client that don't support HTML
  AlternateView plainView = AlternateView.CreateAlternateViewFromString(
                                              Regex.Replace(htmlMessage,
                                                            "<[^>]+?>",
                                                            string.Empty),
                                              Encoding.UTF8,
                                              MediaTypeNames.Text.Plain);
  string mediaType = MediaTypeNames.Image.Jpeg;
  LinkedResource img = new LinkedResource(@"C:\Images\MyImage.jpg", mediaType);
  // Make sure you set all these values!!!

  img.ContentId = "EmbeddedContent_1";
  img.ContentType.MediaType = mediaType;
  img.TransferEncoding = TransferEncoding.Base64;
  img.ContentType.Name = img.ContentId;
  img.ContentLink = new Uri("cid:" + img.ContentId);
  htmlView.LinkedResources.Add(img);
  //////////////////////////////////////////////////////////////
  msg.AlternateViews.Add(plainView);
  msg.AlternateViews.Add(htmlView);
  msg.IsBodyHtml = true;
  msg.Subject = "Some subject";
  client.Send(msg);
}

I couldn't find this information anywhere but I tried setting a whole bunch of things until the images displayed correctly, hope this helps someone with the same issues.

Expect to see this feature in my Command Line E-mailer application so that sending HTML e-mails appear the way you designed them locally when they arrive at the recipient.

Android applications in C# using Visual Studio

2011-09-16T00:31:00.000-07:00

Getting Started

To get everything installed read this guide. Then you can read about the API and architecture to get a better understanding about how it all gels together. Pretty much everything you need including signing up for the newsletter can be found by going directly to www.monodroid.net.
Once you have everything installed it’s pretty easy to get going. The beauty about diving in using a language you are familiar with, means you can get used to the Android SDK without having any knowledge of Java or even C++ (for more advanced features). MonoDroid wraps up all the calls using standard .NET constructs through a JNI bridge, plus, you get all of the power of the standard .NET API’s which work in Linux/Android.

Hello Android

Following the tradition of “Hello World”, let’s jump right in and write an Android application.

Make sure that you have everything installed, this guide couldn’t have made it easier.
Create a new Project in Visual Studio:
MonoDroid does most of the heavy lifting for you. If you’re familiar with Android projects in Eclipse you should have any problems with the structure. Android uses layout and string resource files (the right way) for the UI. Activities are like UI controllers, all the info you need is on the Android Developers website.
Just run the application to check everything is working correctly, if you don’t have a device attached or an emulator running then now is the time to create one:

If you don’t see anything then just click “Start emulator image”:
Once again MonoDroid holds your hand by signing the package and also installing the Mono runtime if it’s not already available.
WARNING: If you are running an emulator then this will take a while, if you have a monster PC that does it in seconds then I hate you.
Unlock the phone/emulator and click the button:
That’s it! There is a lot of documentation on writing Android applications. Java isn't that far off in syntax to C# so it will be easy to pick up sample code all over the place.

Download sample code

More Information

The best place to start is the MonoDroid API design documentation. Do yourself a favour and browse the classes in the Android namespace. Make sure you check Android.Provider which gives you access to things like Contacts, Settings, Calls Logs etc. through static classes.
This Justin guy slicked the domain www.mono-droid.com in July 2010 already so this isn’t new, just widely available now and free for the time being. There is a lot of useful information on installing and developing here. He’s got videos too, everyone loves videos.

Interview Questions and Answer on .Net,C#,ASP.NET,SQL Server

2011-09-15T07:15:00.000-07:00

Interview Questions and Answer on .Net,C#,ASP.NET,SQL Server

All .NET training videos and explanation are not just theory and one liners. They are in depth videos with source code and explanation and finally taking out the actual meat which you need to speak before the interviewer to impress him.
We do not just provide videos and leave the developers on their own.Online support via live meeting from Microsoft MVP's takes this product to a greater height.
We understand no one can see 500 videos at one go. We organize regularC# training on various topics so that your learning curve is reduced to a great extent.
Around 500 videos covering right from .NET, CSharp Interview Questions and Answers. You are either a fresher /senior architect /project manager this solution is for every level.
Full DVD delivered to your doorsteps( only for USA , India and Canada).
Mock interviews, Mock interviews , Mock interviews and Mock interviews makes this solution and perfect package for your job search. These mock interviews are conducted by our specialist to evaluate how much you are prepared and ready.
Superb one liner interview answer cheat sheet to make you revise in a day.
Videos are not just theory and talks , its Step by Step demonstration with actual code and fundamentals.
Money back if you are not satisfied with our videos and support.

Summary of Topics Covered in .Net Training

We understand that working on a project is one thing but clearing interviews needs a change of mind set and this solution is especially meant for the same. From the same aspect we have divided our interview videos are divided in 5 essential categories :-

Basic .NET, ASP.NET, OOPS and SQL Server. Interview questions and answers
New technologies WCF, WPF, Silverlight , LINQ, Azure, EF and 4.0. Interview questions and answers
Design pattern, UML, Architecture, Estimation, Project management, VSTS. Interview questions and answers
Complete Invoicing project end to end. Interview questions and answers
Server products (Sharepoint 2007 questions and answer videos). Interview questions and answers
Best practices and SQL performance tuning. Interview questions and answers

Details of the above .Net Training Topics

Below is our detail video list of the above main .Net Training topics. All .net training videos go in-depth with source code and then explaining you the one liner which you need to speak in the interview.

Basic .NET, ASP.NET, OOPS and SQL Server Interview questions and answers.

What is IL code, CLR, CTS, GAC & GC?
How can we do Assembly versioning?
can you explain how ASP.NET application life cycle and page life cycle events fire?
What is the problem with Functional Programming?
Can you define OOP and the 4 principles of OOP?
What are Classes and Objects?
What is Inheritance?
What is Polymorphism, overloading, overriding and virtual?
Can you explain encapsulation and abstraction?
What is an abstract class?
Define Interface & What is the diff. between abstract & interface?
What problem does Delegate Solve ?
What is a Multicast delegate ?
What are events and what's the difference between delegates and events?
How can we make Asynchronous method calls using delegates ?
What is a stack, Heap, Value types and Reference types ?
What is boxing and unboxing ?
Can you explain ASP.NET application and Page life cycle ?
What is Authentication, Authorization, Principal & Identity objects?
How can we do Inproc and outProc session management ?
How can we windows , forms and passport authentication and authorization in ASP.NET ?
In a parent child relationship which constructor fires first ?

MVC ASP.NET Q & A series

How to create a simple "Hello World" using ASP.NET MVC template? - Lab 1
How to pass data from controller to views? - Lab 2
Can we see a simple sample of model using MVC template? - Lab 3
How can we create simple input screens using MVC template? - Lab 4
How can we create MVC views faster and make them strong typed by using HTML helper? - Lab 5
Can we see how easy it is do unit testing for MVC application? - Lab 6
What is MVC routing? - Lab 7
How can we set default values & validate MVC routes? - Lab 8
How we can define actions & navigate from one page to other page? - Lab 9

WCF, WPF, Silverlight, LINQ, Azure and EF 4.0 interview question and answers

What is SOA, Services and Messages ?
What is the difference between Service and Component?
What are basic steps to create a WCF service ?
What are endpoints, address, contracts and bindings?
What are various ways of hosting WCF service?
What is the difference of hosting a WCF service on IIS and Self hosting?
What is the difference between BasicHttpBinding and WsHttpBinding?
How can we do debugging and tracing in WCF?
Can you explain transactions in WCF (theory)?
How can we self host WCF service ?
What are the different ways of implementing WCF Security?
How can we implement SSL security on WCF(Transport Security)?
How can we implement transport security plus message security in WCF ?
How can we do WCF instancing ?
How Can we do WCF Concurency and throttling?
Can you explain the architecture of Silverlight ?
What are the basic things needed to make a silverlight application ?
How can we do transformations in SilverLight ?
Can you explain animation fundamentals in SilverLight?
What are the different layout methodologies in SilverLight?
Can you explain one way , two way and one time bindings?
How can we consume WCF service in SilverLight?
How can we connect databases using SilverLight?
What is LINQ and can you explain same with example?
Can you explain a simple example of LINQ to SQL?
How can we define relationships using LINQ to SQL?
How can we optimize LINQ relationships queries using ‘DataLoadOptions’?
Can we see a simple example of how we can do CRUD using LINQ to SQL?
How can we call a stored procedure using LINQ?
What is the need of WPF when we had GDI, GDI+ and DirectX?
Can you explain how we can make a simple WPF application?
Can you explain the three rendering modes i.e. Tier 0 , Tier 1 and Tier 2?
Can you explain the Architecture of WPF?
What is Azure?
Can you explain Azure Costing?
Can we see a simple Azure sample program?
What are the different steps to create a simple Worker application?
Can we understand Blobs in steps, Tables & Queues ?
Can we see a simple example for Azure tables?
What is Package and One click deploy(Deployment Part - 1) ?
What is Web.config transformation (Deployment Part-2)?
What is MEF and how can we implement the same?
How is MEF different from DIIOC?
Can you show us a simple implementation of MEF in Silverlight ?

Design pattern, Estimation, VSTS, Project management interview questions and answers

Design Pattern Training / Interview Questions and Answers

Introduction
Factory Design Pattern
Abstract Factory Design Pattern
Builder Design Pattern
Prototype Design Pattern
Singleton Design Pattern
Adapter Design Pattern
Bridge Design Pattern
Composite Design Pattern
Decorator Design Pattern
Facade Design Pattern
Flyweight Design Pattern
Proxy Design Pattern
Mediator Design Pattern
Memento Design Pattern
Interpreter Design Pattern
Iterator Design Pattern
COR Design Pattern
Command Design Pattren
State Design Pattern
Strategy Design Pattern
Observer Design Pattern
Template Design Pattern
Visitor Design Pattern
Dependency IOC Design pattern
MVC , MVP , DI IOC and MVVM Training / Interview Questions and Answers

UML Training / Interview Questions and Answers

Introduction
Use Case Diagrams
Class Digrams
Object Diagrams
Sequence Digrams
Collaboration Diagrams
Activity Diagram
State chart Diagrams
Component Diagrams
Deployment Diagrams
Stereo Types Diagrams
Package Diagram and UML Project Flow.

Function points Training / Interview Questions and Answers

Introduction
Application Boundary
EI Fundamentals
EO Fundamentals
EQ Fundamentals
EIF
Fundamentals
ILF Fundamentals
GSC Fundamentals
Productivity Factor
Costing and a complete estimation of customer screen using function points.
FXCOP and Stylecop Training / Interview Questions and Answers

VSTS Training / Interview Questions and Answers

VSTS questions and answer videos
What is Unit Testing & can we see an example of the same?
How can we write data driven test using NUNIT & VS Test?
Can we see simple example of a unit test for database operation?
How can we do automated testing using Visual Studio Test?
How can we do Load Testing using VSTS test?
Can you explain database unit testing?
How can we do test coverage using VSTS system?
How can we do manual Testing using VSTS?
What is Ordered Test in VSTS test?

Enterprise Application Blocks Training

Introduction
Validation Application Block
Logging Application Block
Exception error Handling
Data Application Block
Caching Application Block
Security Application Block
Policy Injection Application Block and
Unity Application Block

Complete .NET invoicing project end to end

Introduction to .NET Projects
Different levels of Programming
Necessary Tools
What should we learn ?
The IIS
Making UI using .net IDE
Database, The SQL Server
Connecting ASP.net with Database
Loading the Data Grid
Update and Delete
Validations
Issue with the Code
Two Tier Architecture
Three Tier Architecture
Database Normalization
Session and State Management
Using Enterprise Application Block
Aggregation and Composition
Implementing Interfaces and Factory
Inheritance relationship
Abstract Class Implementation

Share point interview Training / Interview Questions and Answers videos

What is SharePoint, WSS and MOSS?
How does WSS actually work?
What is Site and SiteCollection?
What is the use of SQL server in SharePoint & use of Virtual path provider?
What is Ghosting and UnGhosting in SharePoint?
How can we create a site in SharePoint?
How can we Customize a SharePoint Site?
What kind of readymade functional modules exists collaboration?
Can you display a simple Custom Page in SharePoint?
How can we implement behind code ASPX pages in SharePoint?
What is the concept of features in SharePoint?
I want a feature to be only displayed to admin?
How do we debug SharePoint error’s?
Why customized pages are parsed using no-compile mode?
Can you explain WSS model?
How can we use custom controls in SharePoint?
How can we display ASCX control in SharePoint pages?
What are Web Parts?
How can we deploy a simple Webpart in SharePoint?
How can we achieve customization and personalization using WebParts?
How can we create custom editor for WebPart?
SharePoint is about centralizing documents, how similar is to the windows folder?
What are custom fields and content types?
Can you explain SharePoint Workflows?
What is a three-state Workflow in SharePoint?
How can we create sharepoint workflow using sharepoint designer?

.NET best practices and SQL Server Training / Interview Questions and Answers

Basics :- Query plan, Logical operators and Logical reads
Point 1 :- Unique keys improve table scan performance.
Point 2 :- Choose Table scan for small & Seek scan for large records
Point 3 :- Use Covering index to reduce RID (Row Identifier) lookup
Point4:- Keep index size as small as possible.
Point5:- use numeric as compared to text data type.
Point6:- use indexed view for aggregated SQL Queries
Finding high memory consuming functions
Improve garbage collector performance using finalize/dispose pattern
How to use performance counters to gather performance data

What is URL Routing?

2011-09-14T12:40:00.000-07:00

What is URL Routing?

URL routing was a capability we first introduced with ASP.NET 3.5 SP1, and which is already used within ASP.NET MVC applications to expose clean, SEO-friendly “web 2.0” URLs. URL routinglets you configure an application to accept request URLs that do not map to physical files. Instead, you can use routing to define URLs that are semantically meaningful to users and that can help with search-engine optimization (SEO).

Mapping URLs using ASP.NET MVC

The URL Routing engine introduced with ASP.NET 3.5 SP1 provides a powerful way to handle incoming URLs. Typically you write code as part of application startup to register/map URLs that match a specific URL format to code handlers.

Below is an example of how you can use ASP.NET MVC today to map the /products/software URL to a controller class called “Products” that has an action method named “Browse”:

The first “products-browse” parameter to the MapRoute() helper method above is a friendly name for the route. The second “products/{category}” parameter is the URL filter that matches the/products/software URL – and which treats the second segment of the URL as a parameter value called “category”. This parameter will then be passed to the ProductsController’s Browse() action method to process.

Mapping URLs using ASP.NET Web Forms

ASP.NET 4.0 now allows you to also use the URL Routing engine to map URLs to ASP.NET Web Forms pages as well as ASP.NET MVC Controllers.

Below is an example of how you can use the new MapPageRoute() helper method in ASP.NET 4.0 to map the /products/software URL to a “Products.aspx” page that lives immediately under the application root directory:

The first two parameters to the MapPageRoute() helper are the same as in MapRoute(). The first parameter provides a friendly name for the route, and the second specifies the URL format to match. The third parameter, though, points to a Products.aspx page to handle the URL instead of a controller class. You can optionally specify additional parameters to MapPageRoute() that take advantage of features like “route constraints” and provide “default values for parameters” just like you can with ASP.NET MVC based route registrations.

Within the Products.aspx page you can then write code like below that uses the new Page.RouteData property in ASP.NET 4.0 to retrieve the “category” parameter value mapped using the/products/{category} URL filter, and then databind the category products to display them:

In addition to programmatically accessing incoming route parameters using code like above, you can also take advantage of the new declarative control with any ASP.NET DataSource control to declaratively bind a value from a route as well. For example, below we are using a statement to bind the select statement’s @category parameter from the /products/{category} parameter in the URL route:

Retrieving URLs within an ASP.NET Web Form

The URL routing engine in ASP.NET can be used to both map incoming URLs to code handlers, as well as be used to programmatically generate outgoing URLs using the same mapping registration logic.

For example, above when we mapped the /products/{category} URL we gave it a “friendly name” of “products-browse”. This allows us to now also use the new Page.GetRouteUrl() helper method to lookup the route within the URL routing system, optionally specify parameters to it, and then retrieve an actual URL that it maps back to. For example, the below code would retrieve a URL value of “/products/software”:

You can access the above helper method within either your code-behind file or within your .aspx markup.

There is also now a Response.RedirectToRoute() set of methods that you can use to redirect users to a route (regardless of whether it is a MVC or Web Forms handled one) and optionally pass parameters to it.

Handling PostBack Scenarios

URL Routing with ASP.NET 4.0 fully supports postback scenarios. The

ASP.NET TreeView Sort

2011-09-14T00:38:00.000-07:00

Easy way to sort nodes in a TreeView using a recursive function.

A few days ago, I needed to sort the nodes of a tree view. The solutions that I found over the Internet did not please me, so I decided to write my own. This solution is a simple recursive function that sorts tree nodes in an alphabetic order.

Create your tree view and add your nodes:

TreeView mytree = new TreeView();
//add your nodes here

Then simply call the sort function with the main node as the argument:

sort(node);

Here is the recursive function:

private void sort(TreeNode node)
{
    foreach (TreeNode n in node.ChildNodes)
        sort(n);
    try

    {
        TreeNode temp = null;
        List<TreeNode> childs = new List<TreeNode>();
        while(node.ChildNodes.Count>0)
        {
            foreach (TreeNode n in node.ChildNodes)
                if (temp == null || n.Text[0] < temp.Text[0])
                    temp = n;
            node.ChildNodes.Remove(temp);
            childs.Add(temp);
            temp = null;
        }
        node.ChildNodes.Clear();
        foreach (TreeNode a in childs)
            node.ChildNodes.Add(a);
    }
    catch { }
}

7 Page Jump Methods in ASP.NET

2011-09-13T22:19:00.001-07:00

Introduction

In the technology of Web development, we have many different methods for page jump. We can use methods provided by ASP.NET built-in objects achieve page jump. We can according to ASP.NET provided server control and HTML control achieve page jump. And we can also use javascript to program formula achieve page jump. Here we will discuss 7 methods for page jump in ASP.NET.

Page Jump Methods

1、 Make use of HTML tags

<a href=”test.aspx”>test page

This example is very simple. Just use href property of tag to formulate the url of jump page to achieve jump.

2、 HyperLink Control

This the most normal method:

ASP.NET server control NavigateUrl property specify the destination of Url address.
NavigateUrl can be modified by code in server. This is different with
Because of HyperLink has no event, we need set NavigateUrl in server.
Example code:

<asp:hyperlink id="”hyperlink”" runat="”server”" navigateurl="”test.aspx”">ok</asp:hyperlink >

3、Response.Redirect()

Process: Send an Http response to client and inform client jump to a new page. Then, send jump request to server from client.
After page jump, all information stored in inside control lost. When A jumped to B, page B can’t visit information submitted by page A.
Use this method to jump page the Url information in browser address will be changed.
Use Session Cookies Application object to deliver data between pages.
Redirect happens at client and will involve twice contact with Web server: request for original page, request for redirect new page

This method is not fast because it has 2 postback. But it can jump to any page, no limitation from pages. And at the same time, it can’t pass the login protect.

example code:

Now we add a Button control and program code in relevant cs file.

Collapse | Copy Code

protected void Button1_Click1(object sender, EventArgs e)
{
Response.Redirect("http://www.e-iceblue.com");
}

4、Server.Transfer()

Achieve page jump and at the same time exchange control
During page jump process, information stored by Request Session will not change. And it’s available to use the information in the page before jump.
After page jump. Url in browser address will not change
The redirect request of this method is processed in server. Browser doesn’t know happened a jump.

Fast speed! Only need 1 postback but have t under the same site because it’s a method from server. In addition, it can pass login protection.

example code:

Collapse | Copy Code

protected void Button1_Click(object sender, EventArgs e)
{
Server.Transfer("Server2.aspx");
}

Note: the path is virtual path which means it can formulate in page from the same category but can’t formulate unconditional address.

5、 Server.Execute()

This method allows the present page execute another page in server.
After execute page, back to original page and send Server.Execute() position.
This is similar with a function cite against page. The requested page can use original page information and consult string assemble.
Set EnableViewStateMac property as False
example code

Collapse | Copy Code

protected void Button1_Click(object sender, EventArgs e)
{
Server.Execute("Server2.aspx");
}

Note: only virtual path here

6、Javascript achieve page jump

We can make use of javascript in page program formula to achieve page jump

Collapse | Copy Code

<script type="text/javascript" language="javascript">
// directly jump page 
window.location.href = 'hello.html';
// definite time to jump page
setTimeout("javascript:location.href='hello.html'", 5000);

7、Respone.Write()

In the Write method incoming javascript to achieve page jump.

Collapse | Copy Code

Respose.Write( "

Encrypting all the Stored Procedures of a Database

2011-08-16T03:26:00.000-07:00

If you ever decide that you need to protect your SQL Stored Procedures, and thought encrypting was a good idea, BE VERY CAREFUL!!!

Encrypting Database stored procedures SHOULD NOT be done without having backup files or some sort of Source Control for the stored procedures. The reason I say this is because, once they are encrypted, there is no turning around. (Yes, there are third party tools that will decrypt your code, but Why go through that trouble.)

This trick is something I developed because my company needed to host the application on a different server, and we were concerned about our code being compromised. So, to deliver the database, we decided to encrypt all out stored procedures. Having over a hundred procedures written, I didn't want to open each procedure and paste 'WITH ENCRYPTION' in each and every stored procedure. (For those of you who do not know how to encrypt, refer How Do I Protect My Stored Procedure Code[^]). So I decided to make my own little C# application that did the same.

This application is a console application made using Visual Studio 2005 and SQL server 2005. The input parameters are database name, Server address, database username and password. Once you are able to provide these details, you are ready to have all your stored procedures encrypted.

I have put the code of my application here as is. For this code to work, you will need to add an "Microsft.SQlserver.SMO" refrence to the application, so that the classes such as "Database" and "StoredProcedure" are accessible.

BEFORE YOU DO THIS, TAKE A BACKUP!!!!!!!

//Connect to the local, default instance of SQL Server. 
string DB = "";
ServerConnection objServerCOnnection = new ServerConnection();
objServerCOnnection.LoginSecure = false;
Console.WriteLine("Enter name or IP Address of the Database Server.");            
objServerCOnnection.ServerInstance = Console.ReadLine();
Console.WriteLine("Enter name of the Database");
DB = Console.ReadLine();
Console.WriteLine("Enter user id");
objServerCOnnection.Login = Console.ReadLine();
Console.WriteLine("Enter Password");
objServerCOnnection.Password = Console.ReadLine();
Console.WriteLine(" ");
Server srv = new Server();

try // Check to see if server connection details are ok.
{
   srv = new Server(objServerCOnnection);
   if (srv == null)
   {
      Console.WriteLine("Server details entered are wrong,"

         + " Please restart the application");
      Console.ReadLine();
      System.Environment.Exit(System.Environment.ExitCode);
   }
}
catch
{
   Console.WriteLine("Server details entered are wrong,"
      + " Please restart the application");
   Console.ReadLine();
   System.Environment.Exit(System.Environment.ExitCode);
}
Database db = new Database();

try // Check to see if database exists.
{
   db = srv.Databases[DB];
   if (db == null)
   {
      Console.WriteLine("Database does not exist on the current server,"
         + " Please restart the application");
      Console.ReadLine();
      System.Environment.Exit(System.Environment.ExitCode);
   }
}

catch
{
   Console.WriteLine("Database does not exist on the current server,"
      + " Please restart the application");
   Console.ReadLine();
   System.Environment.Exit(System.Environment.ExitCode);
}
string allSP = "";
                

for (int i = 0; i < db.StoredProcedures.Count; i++)
{
   //Define a StoredProcedure object variable by supplying the parent database 
   //and name arguments in the constructor. 
   StoredProcedure sp;
   sp = new StoredProcedure();
   sp = db.StoredProcedures[i];
   if (!sp.IsSystemObject)// Exclude System stored procedures

   {
      if (!sp.IsEncrypted) // Exclude already encrypted stored procedures
      {
         string text = "";// = sp.TextBody;

         sp.TextMode = false;
         sp.IsEncrypted = true;
         sp.TextMode = true;
         sp.Alter();
 
         Console.WriteLine(sp.Name); // display name of the encrypted SP.                        
         sp = null;
         text = null;
      }
   }
}

The Biggest Changes in C++11

2011-08-15T12:20:00.000-07:00

The Biggest Changes in C++11 (and Why You Should Care)

It’s been 13 years since the first iteration of the C++ language. Danny Kalev, a former member of the C++ standards committee, explains how the programming language has been improved and how it can help you write better code.

Bjarne Stroustrup, the creator of C++, said recently that C++11 “feels like a new language — the pieces just fit together better.” Indeed, core C++11 has changed significantly. It now supports lambda expressions, automatic type deduction of objects, uniform initialization syntax, delegating constructors, deleted and defaulted function declarations, nullptr, and most importantly, rvalue references — a feature that augurs a paradigm shift in how one conceives and handles objects. And that’s just a sample.

The C++11 Standard Library was also revamped with new algorithms, new container classes, atomic operations, type traits, regular expressions, new smart pointers, async() facility, and of course a multithreading library.

A complete list of the new core and library features of C++11 is available here.

After the approval of the C++ standard in 1998, two committee members prophesied that the next C++ standard would “certainly” include a built-in garbage collector (GC), and that it probably wouldn’t support multithreading because of the technical complexities involved in defining a portable threading model. Thirteen years later, the new C++ standard, C++11, is almost complete. Guess what? It lacks a GC but it does include a state-of–the-art threading library.

In this article I explain the biggest changes in the language, and why they are such a big deal. As you’ll see, threading libraries are not the only change. The new standard builds on the decades of expertise and makes C++ even more relevant. As Rogers Cadenhead points out, “That’s pretty amazing for something as old as disco, Pet Rocks, and Olympic swimmers with chest hair.”

First, let’s look at some of the prominent C++11 core-language features.

Lambda Expressions

A lambda expression lets you define functions locally, at the place of the call, thereby eliminating much of the tedium and security risks that function objects incur. A lambda expression has the form:

[capture](parameters)->return-type {body}

The [] construct inside a function call’s argument list indicates the beginning of a lambda expression. Let’s see a lambda example.

Suppose you want to count how many uppercase letters a string contains. Using for_each() to traverses a char array, the following lambda expression determines whether each letter is in uppercase. For every uppercase letter it finds, the lambda expression increments Uppercase, a variable defined outside the lambda expression:

int main()
{
   char s[]="Hello World!";
   int Uppercase = 0; //modified by the lambda
   for_each(s, s+sizeof(s), [&Uppercase] (char c) {
    if (isupper(c))
     Uppercase++;
    });
 cout<< Uppercase<<" uppercase letters in: "<< s<It’s as if you defined a function whose body is placed inside another function call. The ampersand in [&Uppercase] means that the lambda body gets a reference to Uppercase so it can modify it. Without the ampersand, Uppercase would be passed by value. C++11 lambdas include constructs for member functions as well.
Automatic Type Deduction and decltype
In C++03, you must specify the type of an object when you declare it. Yet in many cases, an object’s declaration includes an initializer. C++11 takes advantage of this, letting you declare objects without specifying their types:
auto x=0; //x has type int because 0 is int
auto c='a'; //char
auto d=0.5; //double
auto national_debt=14400000000000LL;//long long
Automatic type deduction is chiefly useful when the type of the object is verbose or when it’s automatically generated (in templates). Consider:
void func(const vector &vi)
{
vector::const_iterator ci=vi.begin();
}
Instead, you can declare the iterator like this:
auto ci=vi.begin();
The keyword auto isn’t new; it actually dates back the pre-ANSI C era. However, C++11 has changed its meaning; auto no longer designates an object with automatic storage type. Rather, it declares an object whose type is deducible from its initializer. The old meaning of auto was removed from C++11 to avoid confusion.
C++11 offers a similar mechanism for capturing the type of an object or an expression. The new operator decltype takes an expression and “returns” its type:
const vector vi;
typedef decltype (vi.begin()) CIT;
CIT another_const_iterator;
Uniform Initialization Syntax
C++ has at least four different initialization notations, some of which overlap.
Parenthesized initialization looks like this:
std::string s("hello");
int m=int(); //default initialization
You can also use the = notation for the same purpose in certain cases:
std::string s="hello";
int x=5;
For POD aggregates, you use braces:
int arr[4]={0,1,2,3};
struct tm today={0};
Finally, constructors use member initializers:
struct S {
 int x;
 S(): x(0) {} };
This proliferation is a fertile source for confusion, not only among novices. Worse yet, in C++03 you can’t initialize POD array members and POD arrays allocated using new[]. C++11 cleans up this mess with a uniform brace notation:
class C
{
int a;
int b;
public:
 C(int i, int j);
};

C c {0,0}; //C++11 only. Equivalent to: C c(0,0);

int* a = new int[3] { 1, 2, 0 }; /C++11 only

class X {
  int a[4];
public:
  X() : a{1,2,3,4} {} //C++11, member array initializer
};
With respect to containers, you can say goodbye to a long list of push_back() calls. In C++11 you can initialize containers intuitively:
// C++11 container initializer
vector vs={ "first", "second", "third"};
map singers =
  { {"Lady Gaga", "            +1 (212) 555-7890      "},
    {"Beyonce Knowles", "            +1 (212) 555-0987      "}};
Similarly, C++11 supports in-class initialization of data members:
class C
{
 int a=7; //C++11 only
public:
 C();
};
Deleted and Defaulted Functions
A function in the form:
struct A
{
 A()=default; //C++11
 virtual ~A()=default; //C++11
};
is called a defaulted function. The =default; part instructs the compiler to generate the default implementation for the function. Defaulted functions have two advantages: They are more efficient than manual implementations, and they rid the programmer from the chore of defining those functions manually.
The opposite of a defaulted function is a deleted function:
int func()=delete;
Deleted functions are useful for preventing object copying, among the rest. Recall that C++ automatically declares a copy constructor and an assignment operator for classes. To disable copying, declare these two special member functions =delete:
struct NoCopy
{
    NoCopy & operator =( const NoCopy & ) = delete;
    NoCopy ( const NoCopy & ) = delete;
};
NoCopy a;
NoCopy b(a); //compilation error, copy ctor is deleted
nullptr
At last, C++ has a keyword that designates a null pointer constant. nullptr replaces the bug-prone NULL macro and the literal 0 that have been used as null pointer substitutes for many years.nullptr is strongly-typed:
void f(int); //#1
void f(char *);//#2
//C++03
f(0); //which f is called?
//C++11
f(nullptr) //unambiguous, calls #2
nullptr is applicable to all pointer categories, including function pointers and pointers to members:
const char *pc=str.c_str(); //data pointers
if (pc!=nullptr)
  cout<Delegating Constructors
In C++11 a constructor may call another constructor of the same class:
class M //C++11 delegating constructors
{
 int x, y;
 char *p;
public:
 M(int v) : x(v), y(0),  p(new char [MAX])  {} //#1 target
 M(): M(0) {cout<<"delegating ctor"<Constructor #2, the delegating constructor, invokes the target constructor #1.
Rvalue References
Reference types in C++03 can only bind to lvalues. C++11 introduces a new category of reference types called rvalue references. Rvalue references can bind to rvalues, e.g. temporary objects and literals.
The primary reason for adding rvalue references is move semantics. Unlike traditional copying, moving means that a target object pilfers the resources of the source object, leaving the source in an “empty” state. In certain cases where making a copy of an object is both expensive and unnecessary, a move operation can be used instead. To appreciate the performance gains of move semantics, consider string swapping. A naive implementation would look like this:
void naiveswap(string &a, string & b)
{
 string temp = a;
 a=b;
 b=temp;
}
This is expensive. Copying a string entails the allocation of raw memory and copying the characters from the source to the target. In contrast, moving strings merely swaps two data members, without allocating memory, copying char arrays and deleting memory:
void moveswapstr(string& empty, string & filled)
{
//pseudo code, but you get the idea
 size_t sz=empty.size();
 const char *p= empty.data();
//move filled's resources to empty
 empty.setsize(filled.size());
 empty.setdata(filled.data());
//filled becomes empty
 filled.setsize(sz);
 filled.setdata(p);
}
If you’re implementing a class that supports moving, you can declare a move constructor and a move assignment operator like this:
class Movable
{
Movable (Movable&&); //move constructor
Movable&& operator=(Movable&&); //move assignment operator
};
The C++11 Standard Library uses move semantics extensively. Many algorithms and containers are now move-optimized.
C++11 Standard Library
C++ underwent a major facelift in 2003 in the form of the Library Technical Report 1 (TR1). TR1 included new container classes (unordered_set, unordered_map, unordered_multiset, and unordered_multimap) and several new libraries for regular expressions, tuples, function object wrapper and more. With the approval of C++11, TR1 is officially incorporated into standard C++ standard, along with new libraries that have been added since TR1. Here are some of the C++11 Standard Library features:
THREADING LIBRARY
Unquestionably, the most important addition to C++11 from a programmer’s perspective is concurrency. C++11 has a thread class that represents an execution thread, promises and futures, which are objects that are used for synchronization in a concurrent environment, theasync() function template for launching concurrent tasks, and the thread_local storage type for declaring thread-unique data. For a quick tour of the C++11 threading library, read Anthony Williams’ Simpler Multithreading in C++0x.
NEW SMART POINTER CLASSES
C++98 defined only one smart pointer class, auto_ptr, which is now deprecated. C++11 includes new smart pointer classes: shared_ptr and the recently-added unique_ptr. Both are compatible with other Standard Library components, so you can safely store these smart pointers in standard containers and manipulate them with standard algorithms.
NEW ALGORITHMS
The C++11 Standard Library defines new algorithms that mimic the set theory operationsall_of(), any_of() and none_of(). The following listing applies the predicateispositive() to the range [first, first+n) and uses all_of(), any_of() andnone_of() to examine the range's properties:
#include 
//C++11 code
//are all of the elements positive?
all_of(first, first+n, ispositive()); //false
//is there at least one positive element?
any_of(first, first+n, ispositive());//true
// are none of the elements positive?
none_of(first, first+n, ispositive()); //false
A new category of copy_n algorithms is also available. Using copy_n(), copying an array of 5 elements to another array is a cinch:
#include
int source[5]={0,12,34,50,80};
int target[5];
//copy 5 elements from source to target
copy_n(source,5,target);
The algorithm iota() creates a range of sequentially increasing values, as if by assigning an initial value to *first, then incrementing that value using prefix ++. In the following listing,iota() assigns the consecutive values {10,11,12,13,14} to the array arr, and {'a', 'b', 'c'} to the char array c.
include 
int a[5]={0};
char c[3]={0};
iota(a, a+5, 10); //changes a to {10,11,12,13,14}
iota(c, c+3, 'a'); //{'a','b','c'}
C++11 still lacks a few useful libraries such as an XML API, sockets, GUI, reflection — and yes, a proper automated garbage collector. However, it does offer plenty of new features that will make C++ more secure, efficient (yes, even more efficient than it has been thus far! See Google'sbenchmark tests), and easier to learn and use.
If the changes in C++11 seem overwhelming, don't be alarmed. Take the time to digest these changes gradually. At the end of this process you will probably agree with Stroustrup: C++11 doesfeel like a new language — a much better one.

Bitwise operators in c#

2011-08-14T11:53:00.000-07:00

Bitwise operators in c# OR(|), XOR(^), AND(&), NOT(~)

This post is a brush up on some of the bitwise operators that we shall be using for creating bitmasks to set permissions(my next post will be on exactly this subject. Bitmasks).

The c# bitwise operators I shall be covering here and are of particular interest to me in my followup post are :

binary OR(|) operator
binary AND(&) operator
XOR (^) operator
Not (~) operator

Binary OR(|) operator

Binary | operators are predefined for the integral types and bool. For integral types, | computes the bitwise OR of its operands. For bool operands, | computes the logical OR of its operands; that is, the result is false if and only if both its operands are false.

Lets focus on the integral types(types that can be represented as numbers) and how the computation takes place.

protected void Page_Load(object sender, EventArgs e)
{

     byte a = 7;
     byte b = 9;
     int orComputed = a | b;

     Response.Write(string.Format(
        "<br />{0} | {1} OR computed :{2}", 
               a, b, orComputed));


}

Output :

7 | 9 Result :15

To understand what just happened we need to look at bits and how each bit(which contains an integral type) is understood by the computer. The computer is going to understand this as binary data in the form of 0's and 1's eg. -->> 00101010(which represents the number 42), this is actaully much easier for a computer to handle since each bit(or integral type as in number), can be interpreted as either on or off signal.

0 = off

1 = on

To understand the bitwise operator with clarity and how it computes the result, lets first construct a base 2 table from right to left incrementing the exponent by 1 for each power. So, since we have 8 bits in a byte, we make a table that lists 8 elements 128, 64, 32, 16, 8, 4, 2, 1.

128	64	32	16	8	4	2	1	Result
0	0	0	0	0	0	0	1	1
0	0	0	0	0	0	1	0	2
0	0	0	0	0	1	0	0	4
0	0	0	0	1	0	0	0	8
0	0	0	1	0	0	0	0	16
0	0	1	0	0	0	0	0	32
0	1	0	0	0	0	0	0	64
1	0	0	0	0	0	0	0	128

If you will look at the above pattern more closely, we notice how the 1 keeps moving 1 digit to the left for every new value in binary. This is also known as a "bit shift".

Ok, now that we have our binary 8bit table with digits to the power of 2^ up to 128, so for a simple 7 | 9, which yielded the result 15, lets look at how it was computed by first creating the binary representation using our base 2 table and then computing the binary | operation, so :

128	64	32	16	8	4	2	1	Calculation	Result
0	0	0	0	0	1	1	1	(4+2+1)	7
0	0	0	0	1	0	0	1	(8+1)	9
0	0	0	0	1	1	1	1	(8+4+2+1)	15

As you can see from the above, binary (|) is being performed on each pair of corresponding bits. If a 1 is present in the either bit or in both bits, otherwise it's 0. Not clear ? Lets try that again. How did we get the result 1111 ? It's a simple comparision. If either bit stacked ontop of one another are 1 or both are 1, then the result is 1, otherwise the result is 0. So 1 on 1 = 1, 1 on 0 = 1 but 0 on 0 = 0.

Binary AND(&) operator

Quoting MSDN Docs :

Binary & operators are predefined for the integral types and bool. For integral types, & computes the logical bitwise AND of its operands. For bool operands, & computes the logical AND of its operands; that is, the result is true if and only if both its operands are true.

So, lets quickly test this :

protected void Page_Load(object sender, EventArgs e)
{
     byte a = 7;
     byte b = 9;

     int orComputed = a & b;
     Response.Write(string.Format(
            "<br />{0} & {1} Result :{2}", 

                    a, b, orComputed));

}

Output is :

7 & 9 Result :1

Lets convert to binary using our base 2 table, and dig deeper :

128	64	32	16	8	4	2	1	Calculation	Result
0	0	0	0	0	1	1	1	(4+2+1)	7
0	0	0	0	1	0	0	1	(8+1)	9
0	0	0	0	0	0	0	1	(1)	1

so, how did we get the binary result 0001(1) ? binary (&) is being performed on each pair of corresponding bits. The comparision is made based on both bits stacked ontop of one another. if both are one's, then we have a 1, anything else is a 0. so 1 on 1 = 1, 1 on 0 = 0, 0 on 0 = 0.

Binary Xor (^) operator

Quoting MSDN Docs:

Binary ^ operators are predefined for the integral types and bool. For integral types, ^ computes the bitwise exclusive-OR of its operands. For bool operands, ^ computes the logical exclusive-or of its operands; that is, the result is true if and only if exactly one of its operands is true.

A simple c# example :

protected void Page_Load(object sender, EventArgs e)
{

     sbyte a = 7;
     sbyte b = 9;
     int orComputed = a^b;//on a negative

     Response.Write(string.Format(
              "<br />{0} ^ {1} Result :{2}", 
                 a,b, orComputed.ToString()));


}

output :

7 ^ 9 Result :14

Now, how did binary (^) Xor'ing 7 ^ 9 produce 14 ? This is because binary (^) is being performed on each pair of corresponding bits. If we have two matching zero's or one's, then the result is 0, otherwise 1. SO, 1 on 1 = 0, 0 on 0 = 0, 1 on 0 = 1, 0 on 1 = 1. Lets look at an example in our base 2 table of 7 and 9 in binary format :

128	64	32	16	8	4	2	1	Calculation	Result
0	0	0	0	0	1	1	1	(4+2+1)	7
0	0	0	0	1	0	0	1	(8+1)	9
0	0	0	0	1	1	1	0	(8+4+2)	14

Not (~) operator

Quoting MSDN Docs:

The ~ operator performs a bitwise complement operation on its operand, which has the effect of reversing each bit. Bitwise complement operators are predefined for int, uint, long, and ulong.

This is also a unary operator so we don't need to pass a value. Unary operators perform an operation on a single operand eg. ~n and not x~y.

Binary (~) operator is the most confusing one. It performs reversing of each bit, so reversing a positive can produce a negative value. Negative Values Use Two's Complement format and is quite tricky.

A simple example :

protected void Page_Load(object sender, EventArgs e)
{

     sbyte a = 7;
     int orComputed1 = ~-a;//on a negative

     int orComputed2 = ~a;// on a positive
     Response.Write(string.Format(

                "<br />~-{0} Result :{1}", 
                    a, orComputed1));


     Response.Write(string.Format(

             "<br />~+{0} Result :{1}", 
                    a, orComputed2));


}

output :

~-7 Result :6

~+7 Result :-8

As you can see, when the NOT(~) operator is applied to a positive number, the resulting value is a negative. This is because the value is reversed. Since this reversing yields a negative or positive depending on what value your reversing, use a signed type (a type that can store a negative value).

In the base table below, our binary number gets inverted. all 1's become 0 and 0 becomes 1.

A signed binary uses the left most bit to keep track of the sign(negative or positive).

In the c# compiler, negative values are represented internally in two's complement format. Two's complement can be obtained by negating each bit of the value, then adding 1. Performing two's complement twice generates the original value.

In the following base 2 table, one typical gotcha when inverting is to remember to start the inversion from the left of the first 1 value in our binary. So, say had we a binary representation of the digit 7(00000111), then we start inverting at the 2nd digit starting at the right, skipping the first(since it's 1) and get 11111001. A last thing to also note is how in our calculation we added a negative -1 to our result instead of a positive 1 -->> (-128+64+32+16+8+1)-1 ; While the two's complement format states that we need add 1, we are actually deducting 1 versus adding 1. This is because we have to consider 0 in the equation.

An easy method to get the two's complement of +7 :(left most is used to track sign, so add -1 to the result) :

128	64	32	16	8	4	2	1	Calculation	Result
0	0	0	0	0	1	1	1	(4+2+1)	7
1	1	1	1	1	0	0	1	(-128+64+32+16+8+1)-1	-8

Note the left most significant pair of corresponding bits in red. A value of 0 means positive and a value of 1 means negative and is used for tracking the sign in a signed binary.

One question still remains, why is the two's complement always a positive less(6) and a negative more(-8) ?

Why aren't we getting -7 for a 7 and vice versa. I guess the answer to this is simply "logic", we have to consider the 0.

-8	-7	-6	-5	-4	-3	-2	-1
7	6	5	4	3	2	1	0

Removing Unused Css form classes from your web application

2011-08-08T05:40:00.000-07:00

Most of you might have seen that while working on a Website project, the CSS gets harder to maintain as the site ages. This might be due to new developers coming in to the project, removal of UI elements (but not the corresponding CSS), refactoring and so on. I think it is a good idea to revisit and clean your css every few weeks before it becomes totally unmanageable. In this post, i am going to outline 2 ways to do so
There is a great Firefox plugin called Dust-Me Selectors which can test individual web pages or spider your Website to find unused CSS selectors. As you navigate from page to page in your Website, it maintains a list of unused CSS selectors that you can remove.
If for some reason you cannot use the plugin, or would like to be more sure, I have also created a small utility (for personal use) that can parse a CSS file to create a list of defined classes and go through the code base to determine which of those classes are actually being used. This utility usually gives me a list of unused CSS classes with an accuracy of greater than 95%. It cannot give a 100% accurate output in cases where the css classes are being assigned dynamically in JavaScript or server side code (it catches some of them, but not all). But it gives you a great starting point. I normally search my codebase for the CSS class name before commenting it out from the CSS file to be sure its not being used in the code anywhere. I delete the commented out CSS classes after a couple of releases if I do not see any issues.
You can download the utility (named CssCleaner) from here. Please remember that this does not come with any kind of warranty, I am just sharing this so that it can be helpful to somebody in a situation similar to mine.
CssCleaner is pretty simple to use. Download the app, unzip it to a folder on your system. You should see 2 files – CssCleaner.exe and CssCleaner.exe.config. The config file is needed by the application and is present to make a couple of things configurable. I’ll talk more about it in a second.

After you run the application, click on "Choose Application Folder" and choose the code base folder for your Website. Click on "Choose CSS File" and select the CSS file that you want to analyze. Change the File Filter if you would like to process files different from the default types. Leaving that textbox blank processes all files. Click on "Process" to run the utility. The unused classes get loaded on the right hand side. In my use, the tool has been pretty fast.
If anybody is interested in the implementation, i use a parser/scanner to parse the CSS file similar to this. Then I go through all the files in the code base, building a list of used CSS classes using a regular expression. The regular expression is picked up from the config file, so you can tweak it as you find suitable. The other thing picked up from the config file is the list of default file types to search for. It then compares the used CSS class list against the available CSS classes and displays the unused classes list.
If you have any suggestions for the tool, or find any bugs, please leave a comment or email me (latish.sehgal at gmail dot com) and I’ll try my best to implement it. I hope that you find this tool helpful.

Dot NET Developers Tools List and More

2011-08-08T05:38:00.000-07:00

I gave a brownbag presentation at my current client recently about the common tools (in addition to Visual Studio), that I use on a regular basis for working with .NET or web development in general. I also threw in some non-development tools that are a part of my day to day life and make things easier. Here’s the complete list:
Note: For a completely awesome and Ultimate Developer’s tool list, be sure to check out Scott’s blog post.

	.NET
Name	Description	Comments
ClrProfiler	The CLR Profiler includes a number of very useful views of the allocation profile, including a histogram of allocated types, allocation and call graphs, a time line showing GCs of various generations and the resulting state of the managed heap after those collections, and a call tree showing per-method allocations and assembly loads.	Working with Cassini
DebugDiag	The Debug Diagnostic Tool (DebugDiag) is designed to assist in troubleshooting issues such as hangs, slow performance, memory leaks or fragmentation, and crashes in any Win32 user-mode process. The tool includes additional debugging scripts focused on Internet Information Services (IIS) applications, web data access components, COM+ and related Microsoft technologies.	Troubleshooting .Net 2.0 memory leaks.
FxCop	FxCop is a code analysis tool that checks .NET managed code assemblies for conformance to the Microsoft .NET Framework Design Guidelines.
LibCheck	This tool allows you to compare two versions of an assembly, and determine the differences. The tool reports the differences as a combination of ‘removed’ and ‘added’ APIs.
NDepend	NDepend is a tool that simplifies managing a complex .NET code base. Architects and developers can analyze code structure, specify design rules, plan massive refactoring, do effective code reviews and master evolution by comparing different versions of the code.	Has Academic, commercial versions.
PEX	Right from the Visual Studio code editor, Pex finds interesting input-output values of your methods, which you can save as a small test suite with high code coverage. Pex performs a systematic analysis, hunting for boundary conditions, exceptions and assertion failures, which you can debug right away. Pex enables Parameterized Unit Testing, an extension of Unit Testing that reduces test maintenance costs.	Has Academic, commercial versions. Getting Started.
Reflector	.NET Reflector enables you to easily view, navigate, and search through, the class hierarchies of .NET assemblies, even if you don’t have the code for them. With it, you can decompile and analyze .NET assemblies in C#, Visual Basic, and IL.	Be sure to check out the Addins
Regulator	The Regulator is an advanced Regular expressions testing tool, featuring syntax highlighting and web-service integration with Regexlib.com’s database of online regular expressions.
Resharper	ReSharper provides solution-wide error highlighting on the fly, instant solutions for found errors, over 30 advanced code refactorings, superior unit testing tools, handy navigation and search features, single-click code formatting and cleanup, automatic code generation and templates.	Free 30 day trial, Full Edition: $199, C# Edition: $149. CodeRush Express is a similar free alternative, but I prefer Resharper.
SandCastle	Enables managed class library developers to easily create accurate, informative documentation with a common look and feel.	Simple how-to.
ViewState Helper	Lets you debug ViewState issues by displaying Page and viewstate details for an asp.net page.	Alternative
Web Development Helper	Web Development Helper is a free browser extension for Internet Explorer that provides a set of tools and utilities for the Web developer, esp. Ajax and ASP.NET developers. The tool provides features such as a DOM inspector, an HTTP tracing tool, and script diagnostics and immediate window.
WinDbg	Microsoft Windows Debugger (WinDbg) is a powerful Windows-based debugging tool. It is capable of both user-mode and kernel-mode debugging.	Excellent blog to learn more.

	Web Development
Name	Description	Comments
CssCleaner	Detect unused css classes in your website (static analysis).	Written by yours truly . Need to add more features to this and maybe change the UI to WPF.
Design	Design is a suite of web-design and development assistive tools which can be utilised on any web-page. Encompassing utilities for grid layout, measurement and alignment, Design is a uniquely powerful JavaScript bookmarklet.
Fiddler	Fiddler logs all HTTP(S) traffic between your computer and the Internet and Fiddler allows you to inspect all HTTP(S) traffic, set breakpoints, and "fiddle" with incoming or outgoing data. Fiddler includes a powerful event-based scripting subsystem, and can be extended using any .NET language.	Make sure you check out the Addons. Wireshark is another alternative.
Firebug	Firebug integrates with Firefox to put a wealth of web development tools at your fingertips while you browse. You can edit, debug, and monitor CSS, HTML, and JavaScript live in any web page.	Use IE toolbar or Firebug Lite for IE. Make sure you check out the extensions.
JSLint	With JavaScript Lint, you can check all your JavaScript source code for common mistakes without actually running the script or opening the web page.
XRAY	XRAY is a bookmarklet for Internet Explorer 6+, and Webkit and Mozilla based browsers (including Safari, Firefox, Camino or Mozilla). Use it to see the box model for any element on any web page.
Xenocode.com	Run any browser (IE 6-8, FF 2,3, Opera, Chrome, Safari) directly from the web.	This is the best and easiest way I have seen to run multiple versions of IE on your box, but their service seems to be down lately. Other options are to use a virtual machine or a program like Multiple IE.

	SQL Development
Name	Description	Comments
AnjLab SqlProfiler	SQL Server Express Edition Profiler provides the most of functionality standard profiler does, such as choosing events to profile, setting filters, etc.	This is good while working with Sql Server Express, which does not come with a profiler.
SqlAssist	Adds Sql Intellisense to Sql Server Management Studio and Visual Studio.	Free 30 day trial, pricing here. Sql Server 2008 has inbuilt intellisense. SqlAssistant is a good alternative for working with multiple database environments.

	Generic Useful Tools
Name	Description	Comments
AutoHotKey	Automate sending keystrokes and mouse clicks by creating/recording macros.
Bart’s Preinstalled Environment (BartPE) bootable windows CD/DVD	Bart’s PE Builder helps you build a "BartPE" (Bart Preinstalled Environment) bootable Windows CD-Rom or DVD from the original Windows XP or Windows Server 2003 installation/setup CD, very suitable for PC maintenance tasks.
Daemon Tools	To use virtual drives.
Instapaper bookmarklet	Instapaper allows you to easily save urls for later, when you have time, so you don’t just forget about them or skim through them.
IrfanView	IrfanView is a very fast, small, compact graphic viewer.
KDiff	Compare, Merge files and directories.
Notepad++	Notepad++ is a free source code editor and Notepad replacement that supports several languages.
Paint.Net	Paint.NET is free image and photo editing software for computers that run Windows.	I use this instead of MS Paint for simple tasks.
Portable Apps	Carry your favorite computer programs along with all of your bookmarks, settings, email and more with you. Use them on any Windows computer. All without leaving any personal data behind.
ProcessExplorer	Process Explorer shows you information about which handles and DLLs processes have opened or loaded.	This has replaced my task manager for the last couple of years.
SlickRun	SlickRun is a free floating command line utility for Windows. SlickRun gives you almost instant access to any program or website.
Synergy	Synergy lets you easily share a single mouse and keyboard between multiple computers with different operating systems, each with its own display, without special hardware. It’s intended for users with multiple computers on their desk since each system uses its own monitor(s).
Videora Converter	Videora Converter is a free video converter that converts video files, YouTube videos, movies and DVD’s so you can play them on your video playing device.
VLC media player	Multimedia player.	Plays most video formats out of the box.
Winamp music player	Mp3 music player.	This supports global hotkey bindings, so I can use use my keyboard to change track, volume without bringing it in focus.
Windows Live Mesh	Keep files

Request.Url - ASP.NET

2011-08-04T00:51:00.000-07:00

Request.Url
Full URL : http://localhost:2000/virtual_dir/myrep/page.aspx?q=qvalue

Request.ApplicationPath :	/virtual_dir
Request.CurrentExecutionFilePath :	/virtual_dir/myrep/page.aspx
Request.FilePath :	/virtual_dir/myrep/page.aspx
Request.Path :	/virtual_dir/myrep/page.aspx
Request.PhysicalApplicationPath :	d:\Inetpub\wwwroot\Websitename\virtual_dir\
Request.QueryString :	/virtual_dir/myrep/page.aspx?q=qvalue
Request.Url.AbsolutePath :	/virtual_dir/myrep/page.aspx
Request.Url.AbsoluteUri :	http://localhost:2000/virtual_dir/myrep/page.aspx?q=qvalue
Request.Url.Host :	localhost
Request.Url.Authority :	localhost:2000
Request.Url.LocalPath :	/virtual_dir/myrep/page.aspx
Request.Url.PathAndQuery :	/virtual_dir/myrep/page.aspx?q=qvalue
Request.Url.Port :	2000
Request.Url.Query :	?q=qvalue
Request.Url.Scheme :	http
Request.Url.Segments :	/
	virtual_dir/
	myrep/
	page.aspx

Understanding Paths in ASP.NET

2011-07-27T06:06:00.000-07:00

There are more than 30 methods in ASP.NET classes that deal with paths and/or URLs. Many developers coming from traditional ASP tend to stick with the methods they know from ASP (which are still there), but there are many other useful methods that can save you a lot of time and headache. Fritz Onion covers the details of managing paths and URLs in ASP.NET, looking at everything from virtual to physical path mapping to root path reference syntax.

A quick scan of the classes in the System.Web.* hierarchy reveals more than 30 methods that deal with paths and/or URLs. In this article, I will cover the more commonly used path and URL functions in ASP.NET—presenting

what they do, how they work, and when to use them.

The best way to understand what each of these functions and properties do is
to try them out and review the results. I have prepared a page that makes calls
to the most commonly used path functions and properties in ASP.NET, which you
can download from

http://staff.develop.com/onion/pathsample.zip.
I recommend that you download this file, unzip it, and place the contents in a
virtual directory on a machine with ASP.NET installed. Try to access the
pathsample.aspx page from a browser, inspect the results, and refer to
your running page as you read the rest of this article.

In case you're not near a suitably equipped computer to run the page,
Table 1 shows the results of running the test page. This page was run and
expressions were all evaluated in the context of a page called
client.aspx, responding to a request made to the following URL
http://localhost/informit/subdir/pathsample.aspx/extra.
The physical directory on the Web server corresponding to this virtual directory
mapping was c:\mywebdirs\informit\subdir, and the top-level virtual
directory for this application was called informit and was located at
c:\mywebdirs\informit.

Table 1 Path Functions in ASP.NET and Their Results

Expression	Evaluation
`this.TemplateSourceDirectory`	`/informit/subdir`
`Request.MapPath("log.txt")`	`c:\mywebdirs\informit\subdir\log.txt`
`this.MapPathSecure("log.txt")`	`c:\mywebdirs\informit\subdir\log.txt`
`Request.Path`	`/informit/subdir/pathsample.aspx/extra`
`Request.FilePath`	`/informit/subdir/pathsample.aspx`
`Request.CurrentExecutionFilePath`	`/informit/subdir/pathsample.aspx`
`Request.PathInfo`	`/extra`
`Request.PhysicalPath`	`c:\mywebdirs\informit\subdir\pathsample.aspx`
`Request.PhysicalApplicationPath`	`c:\mywebdirs\informit\`
`Request.ApplicationPath`	`/informit`
`Request.Url`	`http://localhost/informit/subdir/client.aspx/extra`
`Request.RawUrl`	`/informit/subdir/pathsample.aspx/extra`
`Response.ApplyAppPathModifier("foo.aspx")`	`/informit/subdir/foo.aspx`
`this.ResolveUrl("~/client.aspx")`	`/informit/pathsample.aspx`

Path Mapping

We start by looking at one of the most commonly used path methods in ASP.NET:
MapPath. This useful function converts a virtual path into its
corresponding physical path and is typically used to read or modify physical
files on the server in the context of a Web request. It is available through the
HttpRequest object, and for backward compatibility with classic ASP, it
is also available through the HttpServerUtility object (accessed via
the HttpContext or Page Server property). As an example
of its use, suppose you wanted to write an entry into a log file when a page was
accessed. Assuming that the log file is named log.txt and is located in
the same directory as the .aspx page that is accessing it, you could write to
the file with the following code:

// within a method of the Page class
string logfile = Request.MapPath("log.txt");
using (StreamWriter sw = File.AppendText(logfile))
{
 sw.WriteLine("I was here at {0}", DateTime.Now);
}

Notice in Table 1 that the call to MapPath with a string of
log.txt resulted in the complete path
c:\mywebdirs\informit\subdir\log.txt corresponding to the physical
location of the virtual directory accessed in the request. In general, any time
you call MapPath, it prefixes the string you pass in with the complete
physical directory path to the current directory to which the request was
dispatched. This is useful any time you need to access a physical file on disk
that is placed in the same directory as your page, particularly for things such
as loading XML files, writing to log files, and performing file
manipulation.

Be aware that any time you access the file system from within an ASP.NET
application, you are operating under the restrictive rights associated with the
ASPNET account (or, in Windows Server 2003, NETWORK SERVICE). This account is
specially created for ASP.NET on your machine, and by default is granted only
User privileges. In a typical installation, this means that you cannot
modify existing or create new files from within an ASP.NET page. If you find
yourself wanting to use MapPath to modify or create files, the best
solution is to grant the ASP.NET account write and modify
privileges to that one subdirectory.

There is an additional function for performing virtual to physical path
mapping in ASP.NET called MapPathSecure. This method, also of the
HttpRequest class, differs only in the fact that it makes a File I/O
security demand as you request the translation, but it is used internally in
many of the ASP.NET methods. This demand is not the same as requesting whether
the account has privileges to write to a file, but rather whether the code that
is currently being executed has sufficient trust to perform file I/O (done
through a code access security or CAS check). Most of the time, your ASP.NET
code will be running with full privileges, so this function will always succeed.
It is possible, however, in ASP.NET 1.1 to specify a lower trust level at which
to run your application using the trust element in your configuration
file (or more likely, for some third-party host environment to run your
application at a lower level of trust). If this is a possibility for you, then
it may make sense to call MapPathSecure instead of MapPath, as
it will trigger a code access security exception sooner rather than later,
giving your more flexibility in dealing with the failure.

There are two other potentially useful properties available in the
Request object: PhysicalPath and
PhysicalApplicationPath. The former is the complete physical path to
the endpoint that was requested, and the latter is the complete physical path to
the root of the application.

How to build your own C# Autodialer

2011-07-18T22:58:00.001-07:00

How to build your own C# Autodialer

Let me start with a short background story. One day, one of my oldest friends (who is a professional business man) came to me (the developer) for advice. He had a specific idea to boost his business: he wanted to install an Autodialer software. He asked for my expert opinion about how this could be done. That time I had a lot of work so I didn't have the time to come up with something brand new and write him a program. But I really wanted to help him, so in my freetime I was searching for a convenient solution. I've found it. We've done it. The business is on the wing ever since. My friend gave his approval to publish his story and the method he chose. I've thought this could be useful for many people and for many company.

The key to build an Autodialer, and also to the great success, was a software development kit. It has a sample program to have a look at its facilities. Here's how you configurate it, after downloading, extracting, and opening it:

Right click on MainForm.cs file and select View Code option (Figure 1).

Search for MainForm_Load method. You can find the configuration of the autodialer within this method.

1. ///

2. /// Occurs when the user loads the form.

3. ///

4. ///

5. ///

6. void MainForm_Load(object sender, EventArgs e)

7. {

8. #region DataBinding

9. // See later

10. #endregion

11.

12. #region Configuration

13.

14. autodialer = new Autodialer(GetLocalIP().ToString(), 5060, 5080, 5060, @"..\..\Resources\autodialer-example.wav");

15. autodialer.ProcessingCompleted += autodialer_ProcessingCompleted;

16. autodialer.PhoneLineStateChanged += autodialer_PhoneLineStateChanged;

17.

18. var sipAccount = new SIPAccount(true, "oz890", "oz890", "oz890", "oz890", "192.168.91.212", 5060);

19. autodialer.CreateAndRegisterPhoneLine(sipAccount);

20. #endregion

21.

22. #region Copyright

23. // Implementation.

24. #endregion

25.

26. }

Parameters for the autodialer:

1. public Autodialer(string localIPAddress,

2. int minPort,

3. int maxPort,

4. int localSIPPort,

5. string wavPath)

Parameters:

6. localIPAddress:
This is the local IP address of the computer. If there are more network cards, then you need to enter the IP address of that network card here, with which you connect to the PBX or to the VoIP service provider.

7. minPort:
This is the minimum port that can be used.

8. maxPort:
This is the maximum port that can be used.

9. localSIPPort:
This is the port reserved for SIP. SIP messages will be listened to via this port.

10. wavPath: This is the path for the audio file that will be played during the calls.

The SIP account includes information with which you can register in the PBX or the VoIP service provider successfully.

Parameters for SIP account:

1. public SIPAccount(

2. bool registrationRequired,

3. string displayName,

4. string userName,

5. string registerName,

6. string registerPassword,

7. string domainServerHost,

8. int domainServerPort)

Parameters:

9. registrationRequired
The registration to the PBX is required. Please note that if you do not register in the PBX, you will only be able to make calls but you will not be able to receive calls.

10. displayName
This name will be displayed for the the called party during the calls.

11. userName
This is the username will be used during calls.

12. registerName
This is the name used for registration.

13. registerPassword
This password is needed for registration and for authentication during calls.

14. domainServerHost
This is the IP address or domain name of the PBX.

15. domainServerPort
This is the port number of the PBX.

After configuration, click on Build button in Visual Studio or click F5 on your keypad.

Now you see, that building an Autodialer isn't necessarily a hard thing. You only have to find the appropriate help. Here you can find the sample program for this sdk:

http://www.voip-sip-sdk.com/p_130-how-to-build-an-autodialer-in-c-using-the-ozeki-voip-sip-softphone-source-code-voip.html

Creating SqlParameters Best Practices

2011-07-14T08:01:00.000-07:00

This article summarizes some nice ways to create SqlParameter arrays. When we use SqlHelper, or even without SqlHelper when we use SqlCommands directly, and we want to pass an array of SqlParameters to the function. The method I will discuss does not require you to hard-code the number of elements, nor does it require you to create a temporary list of some sort, but it requires you to have all the values up front that you want to insert into the list.
There are several ways to create this array.

One is to hardcode the number of parameters as follows:
view source print ?
1.SqlParameter array SqlParameter[] sqlParams = new SqlParameter[5];
An evolution of this is to use an ArrayList
ArrayList sqlParams = new ArrayList();
Then add the parameters using sqlParams.Add(…) to add them
Then the final step is to use sqlParams.ToArray() and pass that to your SqlHelper.
Another evolution would be to use a Generic list of SqlParameters
System.Collections.Generic.List sqlParams = new System.Collections.Generic.List();
But in my opinion the BEST way of creating your SqlParameter array is as follows: C# Example:

Vb.Net Example:

You can even use conditionals such as if your questionCode is null you want to insert a null (C# example):
4.
```
SqlParameter[] sqlParams = new SqlParameter[] {
     new SqlParameter("@username", strUserName) ,
     new SqlParameter("@password", strPassword)
  };

  Dim params As SqlParameter() = { _
     New SqlParameter("@CenterID", centerID), _
     New SqlParameter("@TypeID", typeID) _
  }

SqlParameter[] sqlParams = new SqlParameter[] {
  new SqlParameter("@Required", required),
  questionCode == null ? new SqlParameter("@Code", DBNull.Value) : new SqlParameter("@Code", questionCode)
};
```
Update Aug7’09 – Not specifying the DB type of the parameter will actually be slower than manually specifying the parameter sql types (ie int, varchar, etc). However, I find the tradeoff for convenience to be worth a slight loss of speed. This also allows you to change the parameter type in the stored procedure (say from datetime to string), without having to also update it here.

C# Coding Standards Series – Naming Conventions

2011-07-13T12:28:00.000-07:00

Terminology and Definitions for Naming Conventions:
Camel Case (camelCase): The first letter of the word is lower case and then each first letter of the part of the word is upper case;
Pascal Case (PascalCase): The first letter of the word is upper case and then each first letter of the part of the word is upper case;
Underscode Prefix (_underscore): The word begins with underscore char and for the rest of the word use camelCase rule;

General Rules

1. Use Pascal Case for Class names:
Ex:

1	public class HelloWorld { ... };

2. Use Pascal Case for Method names:
Ex:

1	public void SayHello(string name) { ... };

3. Use Camel Case for variables and method parameters:
Ex:

int totalCount = 0;
 
void SayHello(string name)
{
     string fullMessage = "Hello " + name;
     //...
}

4. Avoid all upper case or all lower case names;
5. Do not use Hungarian notation:
Example of Hungarian Notation:
string m_sName; (the prefix m_ means that is a member variable and s means that is a string data type);
6. Avoid abbreviations longer than 5 characters;
7. Avoid using abbreviations unless the full name is excessive:
Ex:
Good: string address; Not good: string addr;
8. Use meaningfull, descriptive words for naming variables;
9. Try to prefix Boolean variables with “Can”, “Is” or “Has”;
10. Do not use Underscore Prefix for local variables names;
11. All member variables must use Underscore Prefix so that they can be identified from other local variables names;
12. Avoid naming conflicts with existing .NET Framework namespaces or types;
13. Do not include the parent class name within a property name:
Ex: Good: Customer.Name; Not good: Customer.CustomerName;
14. When defining a root namespace, use a Product, a Company or a Developer name as the root:
Ex: NorthwindApplication.Utilities;
15. Use Pascal Case for file names;
16. Method name should tell you what it does;
17. A method should do only “one job”. Do not combine multiple jobs in one method even if those jobs have very few lines of code.
Ex:

protected void SaveCustomerName(string customerName)
{
   //code here...
}

Naming Conventions for ASP.NET Controls

In general, naming ASP.NET controls is made using Camel Case naming convention, where the prefix of the name is the abbreviation of the control type name.

Abbreviation	ASP.NET Control
STANDARD CONTROLS
btn	Button
cb	CheckBox
cbl	CheckBoxList
ddl	DropDownList
fu	FileUpload
hdn	HiddenField
lnk	Hyperlink
img	Image
ibtn(btn)	ImageButton
lbl	Label
lbtn(btn)	LinkButton
lb	ListBox
lit	Literal
mv	MultiView
pnl	Panel
ph	PlaceHolder
rb	RadioButton
rbl	RadioButtonList
tbl	Table
txt	TextBox
v	View
DATA CONTROLS
dtl	DataList
dp	DataPager
dtv	DetailsView
ets	EntityDataSource
fv	FormView
gv	GridView
lds	LinqDataSource
lv	ListView
ods	ObjectDataSource
qe	QueryExtender
rpt	Repeater
smd	SiteMapDataSource
sds	SqlDataSource
xds	XmlDataSource
VALIDATION CONTROLS
cpv	CompareValidator
ctv	CustomValidator
rv	RangeValidator
rev	RegularExpressionValidator
rfv	RequiredFieldValidator
vs	ValidationSummary

Please share your opinion about this post by commenting below.

(hide this) .net Naming Conventions and Programming Standards - Best Practices

2011-07-13T12:16:00.001-07:00

This article is the single most popular bit of content from my old site and blog, bar none. While I think books such as the .NET Framework Design Guidelines by Krzystof Cwalina and Brad Abrams do a better job explaining all the standards, I've kept this page up for quick reference and to support the schools and individuals currently using it.

Common .NET Naming Conventions

These are the industry-accepted standard naming conventions for C# and VB.NET programs. For additional information, please see the MSDN help documentation and the book referenced above. While individual naming conventions at organizations may vary (Microsoft only suggests conventions for public and protected items), the list below is quickly becoming the de-facto standard in the industry. Please note the absence of Hungarian Notation. These naming standards should find their way into all of your .NET development, including ASP.NET Web applications, WPF, Silverlight and Windows Forms applications.
Note that while this document predates the online and printed standards documentation from Microsoft, everything below which indicates it is based on .NET library standards is consistent with that documentation and Brad's book. In areas where Microsoft has not provided guidance (Microsoft generally doesn't care what you do in private/non-exposed code. In fact, they aren't even consistent in their internal code in the .NET framework), de facto standards have emerged, and I have captured them here.
The "ux" naming convention for controls is something I have added and found to be helpful in Windows Forms, but not so much in Silverlight and WPF. It is not based on any official standards, but instead based upon a multitude of projects by my teams and others, as well as on-line discussions on the topic. While I strongly recommend that you follow Microsoft guidelines when present, I encourage you to try out the items marked as extensions below and see how they work for you before committing to them.

Type	Standard / Convention	Example
Namespaces	Standard Based Upon Microsoft .NET Library Standards Pascal Case, no underscores. Use CompanyName.TechnologyName as root. If you don't have a company, use your domain name or your own initials. Note that any acronyms of three or more letters should be pascal case (Xml instead of XML) instead of all caps. Why: This convention is consistent with the .NET Framework and is easy to read.	`AppliedIS.TimeCard.BusinessRules` `IrritatedVowel.Controllers` `PeteBrown.DotNetTraining.InheritanceDemo` `PeteBrown.DotNetTraining.Xml`
Assemblies	Standard Based Upon Microsoft .NET Library Standards If the assembly contains a single name space, or has an entire self-contained root namespace, name the assembly the same name as the namespace. Why: This convention is consistent with the .NET Framework and is easy to read. More importantly, however, it keeps your assembly names and namespaces lined up, making it really easy to figure out what is any particular assembly, and what assembly you need to reference for any given class.	`AppliedIS.TimeCard.BusinessRules.dll` `IrritatedVowel.Controllers.dll`
Classes and Structs	Standard Based Upon Microsoft .NET Library Standards Pascal Case, no underscores or leading "C" or "cls". Classes may begin with an "I" only if the letter following the I is not capitalized, otherwise it looks like an Interface. Classes should not have the same name as the namespace in which they reside. Any acronyms of three or more letters should be pascal case, not all caps. Try to avoid abbreviations, and try to always use nouns. Why: This convention is consistent with the .NET Framework and is easy to read.	`Widget` `InstanceManager` `XmlDocument` `MainForm` `DocumentForm` `HeaderControl` `CustomerListDataSet (typed dataset)`
Collection Classes	Standard Based Upon Microsoft .NET Library Standards Follow class naming conventions, but add Collection to the end of the name Why: This convention is consistent with the .NET Framework and is easy to read.	`WidgetCollection`
Delegate Classes	Standard Based Upon Microsoft .NET Library Standards Follow class naming conventions, but add Delegate to the end of the name Why: This convention is consistent with the .NET Framework and is easy to read.	`WidgetCallbackDelegate`
Exception Classes	Standard Based Upon Microsoft .NET Library Standards Follow class naming conventions, but add Exception to the end of the name Why: This convention is consistent with the .NET Framework and is easy to read.	`InvalidTransactionException`
Attribute Classes	Standard Based Upon Microsoft .NET Library Standards Follow class naming conventions, but add Attribute to the end of the name Why: This convention is consistent with the .NET Framework and is easy to read.	`WebServiceAttribute`
Interfaces	Standard Based Upon Microsoft .NET Library Standards Follow class naming conventions, but start the name with "I" and capitalize the letter following the "I" Why: This convention is consistent with the .NET Framework and is easy to read. It also distinguishes classes from interfaces, where (unlike in VB6) are truly different beings. This avoid name collisions as well, as it is quite common to have IFoo and a class named Foo that implements IFoo.	`IWidget`
Enumerations	Standard Based Upon Microsoft .NET Library Standards Follow class naming conventions. Do not add "Enum" to the end of the enumeration name. If the enumeration represents a set of bitwise flags, end the name with a plural. Why: This convention is consistent with the .NET Framework and is easy to read.	`SearchOptions (bitwise flags)` `AcceptRejectRule (normal enum)`
Functions and Subs	Standard Based Upon Microsoft .NET Library Standards Pascal Case, no underscores except in the event handlers. Try to avoid abbreviations. Many programmers have a nasty habit of overly abbreviating everything. This should be discouraged. We're not designing license plates or being charged by the letter :) Functions and subs must differ by more than case to be usable from case-insensitive languages like Visual Basic .NET Why: This convention is consistent with the .NET Framework and is easy to read.	VB: `Public Sub DoSomething(...)` C#: `public void DoSomething(...)`
Properties and Public * Member Variables	Standard Based Upon Microsoft .NET Library Standards Pascal Case, no underscores. Try to avoid abbreviations. Members must differ by more than case to be usable from case-insensitive languages like Visual Basic .NET. Why: This convention is consistent with the .NET Framework and is easy to read.	VB: `Public Property RecordId As Integer` C#: `public int RecordId`
Parameters	Standard Based Upon Microsoft .NET Library Standards Camel Case. Try to avoid abbreviations. Parameters must differ by more than case to be usable from case-insensitive languages like Visual Basic .NET. Why: This convention is consistent with the .NET Framework and is easy to read.	VB: `ByRef recordId As Integer` C#: `ref int recordId`
Procedure-Level Variables	Standard Based Upon De facto Industry-Accepted Practices Camel Case Why: This convention is consistent with the .NET Framework and is easy to read. It also avoids naming collisions with class-level variables (see below)	VB: `Dim recordId As Integer` C#: `int recordId ;`
Class-Level Private and Protected Variables	Standard Based Upon De facto Industry-Accepted Practices Camel Case with Leading Underscore. In VB.NET, always indicate "Protected" or "Private", do not use "Dim". Use of "m_" is discouraged, as is use of a variable name that differs from the property by only case, especially with protected variables as that violates compliance, and will make your life a pain if you program in VB.NET, as you would have to name your members something different from the accessor/mutator properties. Of all the items here, the leading underscore is really the only controversial one. I personally prefer it over straight underscore-less camel case for my private variables so that I don't have to qualify variable names with "this." to distinguish from parameters in constructors or elsewhere where I likely will have a naming collision. With VB.NET's case insensitivity, this is even more important as your accessor properties will usually have the same name as your private member variables except for the underscore. As far as m_ goes, it is really just about aesthetics. I (and many others) find m_ ugly, as it looks like there is a hole in the variable name. It's almost offensive. I used to use it in VB6 all the time, but that was only because variables could not have a leading underscore. I couldn't be happier to see it go away. Microsoft recommends against the m_ (and the straight _) even though they did both in their code. Also, prefixing with a straight "m" is right out. Of course, since they code mainly in C#, they can have private members that differ only in case from the properties. VB folks have to do something else. Rather than try and come up with language-by-language special cases, I recommend the leading underscore for all languages that will support it. If I want my class to be fully CLS-compliant, I could leave off the prefix on any C# protected member variables. In practice, however, I never worry about this as I keep all potentially protected member variables private, and supply protected accessors and mutators instead. Why: In a nutshell, this convention is simple (one character), easy to read (your eye is not distracted by other leading characters), and successfully avoids naming collisions with procedure-level variables and class-level properties.	VB: `Private _recordId As Integer` C#: `private int _recordId ;`
Controls on Forms	An Extension to the Standards May 2009 update Note that I still consider this useful in many respects, especially for intellisense grouping, but have backed away from using this in recent projects, specifically Silverlight and WPF. I still use an appropriate classification suffix such as Field or Label (but not an actual control type) so that I can differentiate between, say, the last name field and the label for it. Examples would be LastNameField, LastNameLabel, NextPageNavigation, PreviousPageNavigation. The classifications you pick will need to make sense to you, and also allow for signficiant flexibility for the designer of the UI to change the control type in Xaml without you having to change the name in the storyboards (runtime checked), code behind (compile-time checked), and control lookups in code behind (runtime checked). I backed away simply because it didn't look right in generated member variables in my applications, or in the x:Name properties in Xaml. It was a code smell issue, albeit a minor one. Note also that in Silverlight and WPF, I only name controls which need to be named because they are used in the code behind or are referred to from a storyboard or relative binding. The name is the primary contract between the code and the visual design, and you want to keep that contract as small as possible. Note that I have seen the "ux" prefix in example code on the net, and from Microsoft. Some folks still find it useful. You'll need to make that decision for yourself. I do not use the ux prefix when working in XAML-based uI, like Silverlight and WPF. Original Information from 2002 In recent projects (since 2002 or so), I have taken to a single prefix for all my UI controls. I typically use "ux" (I used to use "ui", but it wasn't set apart well in intellisense). "ux" comes from my usual design abbreviations where it means "User eXperience", which has also since become a popular acronym. I have found this to be extremely helpful in that I get the desired grouping in the intellisense even better than if I use "txt", "lbl" etc. It also allows you to change combo boxes to text boxes etc. without having to change the names - something that happens often during initial prototyping, or when programming using highly iterative agile/xp methodologies. Why: This convention avoids problems with changing control types (textboxes to drop-down lists, or simple text box to some uber textbox, or text box to date picker, for example), and groups the items together in intellisense. It is also much shorter than most Hungarian conventions, and definitely shorter and less type-dependent than appending the control type to the end of the variable name. I will use generic suffixes which allow me enough freedom to change them around.	`"ux" prefix` `uxUserIdField, uxHeaderLabel, uxPatientDateOfBirthField, uxSubmitCommand` `no "ux" prefix` `LastNameField, LastNameLabel, SubmitCommand, NextPageNavigation`
Constants	Standard Based Upon Microsoft .NET Library Standards Same naming conventions as public/private member variables or procedure variables of the same scope. If exposed publicly from a class, use PascalCase. If private to a function/sub, use camelCase.. Do not use SCREAMING_CAPS Why: This convention is consistent with the .NET Framework and is easy to read. A sizable section of the Framework Design Guidelines is dedicated to why they chose not to go the SCREAMING_CAPS route. Using SCREAMING_CAPS also exposes more of the implementation than is necessary. Why should a consumer need to know if you have an enum, or (perhaps because they are strings) a class exposing public constants? In the end, you often want to treat them the same way, and black-box the implementation. This convention satisfies that criteria.	`SomeClass.SomePublicConstant` `localConstant` `_privateClassScopedConstant`

* Public class-level variables are universally frowned upon. It is considered to be a much better practice to use property procedures (accessors and mutators) to provide read and/or write access to a private member variable. If you must expose a member variable to other classes using "Public", follow the property naming conventions, but don't complain if your guilty conscience keeps you up at night ;-).
You Can find the standards for publicly exposed classes/properties etc at MSDN . If you want to run a tool to validate your code for public standards and required practices, download FXCop or use the analysis tools in Visual Studio.

Why Hungarian Has Fallen Out of Favor with .NET

With his simple question in my guestbook, Andrew Coupe inspired me to write this little blurb here explaining why I feel that Hungarian Notation has outlived its usefulness. If you're sticking to Hungarian Notation in .NET, waffling, or just plain curious - read on.
True Hungarian Notation is a naming convention invented by Charles Simonyi from Microsoft back in the 70s. (For more information on its origins, see this funny article) Back in the day, one of the more promising versions of Hungarian Notation was used in a way that indicated the purpose or logical type of the variables rather than the language-specific type. For example, instead of indicating something was an int, it would be specified that it was an Id or a Quantity. When Hungarian was used this way, it was very useful, especially in languages where variable names were limited in length.
Shortly after the notation started being used, developers came up with standard language-specific data-type based prefixes. I remember when I worked in C/C++, we had things such as "rgsz" meaning an array of zero-terminated strings (rg is short for"reference to a graph" - an array in C/C++). This was useful for a while, but the prefixes became unwieldy in both in length and in understanding the permutations and combinations; you ended up with things not too far from rgszxyzpdqOrderNo. Think that's a stretch? Imagine what the name of a variable that contained a long pointer to an array of arrays of long pointers to some particular structure looked like when you mapped out the full prefix. Yes, we really did have the occassional variable like that in our programs, especially the database engine I worked on.
Then along came Visual Basic. This great rapid application development tool introduced a lot of programmers to Windows programming. Many them were brand new to programming, and gave their variables meaningless or less than helpful, and almost always inconsistent names. In response to this influx of bad code, good VB developers started to use two different variations of the Hungarian naming conventions. One was a traditional "as many letters as needed" set with prefixes such as "s" for String, "i" for Integer, and sometimes things like "arrl" for an array of longs. The second school standardized on three letters for all prefixes "str" for String, and "int" for Integer being two examples.
Some people took the conventions to extremes, and did silly things like prefix database table names with "tbl", stored procedures with "P", VB classes with "C" or "cls", and function names with the Hungarian for their return type. That was and is still just pure silliness, IMHO. I do, however, think that "I" in front of an interface is important as interfaces need to be treated very differently from classes.
During this time, VB4 and eventually VB5 and VB6 came out. VB4 introduced classes and some object-oriented language features to these developers. Developers needed to remember to use "Set" when assigning object variables, and had to remember to set them to "Nothing" when they were done with them. To assist in remembering to do this, developers would prefix all their object variables with "obj" or "o". Typical code around this time was nothing but a ton of variables with names like objResults and oHenry. It looked just a bit odd, and wasn't particularly helpful.
Those of us who worked a lot with COM objects in Visual Basic realized that the prefixes made no sense in public interfaces. In fact, they looked plain awful. Many of us adopted conventions that stated that anything exposed via COM would not have any prefixes whatsoever. That included parameters, functions, classes, etc. This was inline with what Microsoft and most 3rd-party vendors did with all the COM libraries and ActiveX controls they provided.
At the same time, those of us working on large projects noticed a definite laziness on the part of some other programmers (you know who you are! ) when it came to updating the variable prefixes when they changed a variable from, say, an Integer to a Long. This caused far more confusion than was worth. When coupled with the huge multi-page lists of "all the prefixes" for every possible type you could think of, Hungarian started to get in the way more than it helped.
Along comes .NET and just about everything is an object or can be boxed as such, and everything public is exposed to other languages - languages which may not use the same names for the variables we use (this was the same issue we had when writing for COM). If I want to know a variable's type, I can hover over it with the mouse in the VS.NET IDE. If I want to know a variable's use, I simply look at the well-worded variable name.
Now, rather than memorizing lists of prefixes, or prefixing everything with "obj", programmers are able to concentrate on the purpose of the variable rather than the underlying type. This alone has increased programmer productivity by removing the requirement to perform that mental prefix lookup - which for some of us was like a SQL Server full-table scan .
Since the .NET languages were a reasonably clean break from the old versions, it made sense for Microsoft and .NET developers to also change the expected naming conventions at the same time. They knew the adoption of the new conventions would be more likely (and less painful) with the platform shift.
.NET variables and types can have extremely long names, names that can describe the purpose of a variable rather than the underlying type. We don't have to pack as much meaning as possible into just a few letters. Control-space makes typing the long names completely painless, and the long names really assist in understanding and documentation.
Some people still stick to the old Hungarian notation, but those are the hold-outs. Sharing code with them becomes frustrating as the conventions have to be all modified when you do so. If everyone follows the Microsoft-recommended .NET conventions, information exchange and collaboration becomes much easier :-) If you are one of these hold-outs, and have good reasons for sticking to Hungarian, I'd love to hear from you via the contact link at the bottom of this page.
UI controls are something that are still in flux when it comes to conventions. The reason Hungarian is still often used for them is to ensure they are grouped in intellisense. Hungarian is definitely not perfect for this, but it works.

Resources - ASP.Net Coding Standards

2011-07-13T12:14:00.000-07:00

Adopting a common coding standard across your web applications

Note: These standards assume C# but are just as applicable to VB etc. All these standards stay as close as possible to those recommended by Microsoft.
The Microsoft's Design Guidelines for Class Library Developers (MSDN site) is a useful set of guidelines which all ASP.Net developers should take a look at. In particular, those new to C# coding should see the naming conventions section, including capitalisation conventions (Pascal vs camel etc) and when to use nouns, verbs etc for naming of identifiers. It is interesting to note that Microsoft are moving away from the hungarian style of notation in .Net (I think based on the premise that everything is an object anyway in the framework and identifier names should be based on semantics not types).
Although Microsoft's guidelines are an excellent guide, I created this standards page, as I could not find a one-stop summary of standards I could follow quickly when building ASP.Net web applications - Microsoft's are not exactly a quick reference guide! Also, they do not target ASP.Net specifics (e.g. Web Control naming).

Naming and Capitalisation

Below summarises the naming recommendations for identifiers in .Net. Pascal casing is used mainly (ie capitalise first letter of each word) with camel casing (capitalise each word except for the first one) being used in certain circumstances.

Identifier	Case	Examples	Additional Notes	Detailed Info
Class	Pascal	Person, BankVault, SMSMessage, Dept	Class names should be based on "objects" or "real things" and should generally be nouns.
Method	Pascal	GetDetails, UpdateStore	Methods should use verbs or verb phrases.
Parameter	camel	personName, bankCode
Interface	Pascal with "I" prefix	IDisposable	One of the few times when prefixing is adopted.
Property Associated private member variable	Pascal _camelCase	ForeColor, BackColor _foreColor, _backColor	Use underscore camel casing for the private member variables, but keep the names the same as associated property accessors.
Exception Class	Pascal with "Exception" suffix	WebException, SMSException
Event	Pascal plus optional "EventHandler" suffix where relevant	btnSubmit_Click, Painting, Click, Clicked, MyEventHandler	VS uses underscores to separate an object from its event. Be careful with tense (pre/past), e.g. a Close event that can be canceled should have a Closing event and a Closed event. MS also recommend adding the "EventHandler" suffix where thought needed.

Note that acronym parts of phrases may be all in uppercase (e.g. SMSMessage) where relevant.
User interface objects (text boxes, drop down lists etc) are treated as a special case and discussed in the next section.

User Interface Objects and Controls

The Microsoft .Net guidelines do not go into detail on the naming of user interface objects (again probably because they are only objects after all), but one approach that is well adopted is the use of the "control type" prefix convention (similar to hungarian style often used in VB, C++ etc). Although this should not be used for indicating variable types, it is useful for user interface controls as it makes it explicitly clear where user interface elements are in your code.
Some samples are below for ASP.Net web form controls:

Control	Prefix	Example
Label	lbl	lblSurname
TextBox	txt	txtSurname
DataGrid	dg	dgResults
Button	btn	btnSave
ImageButton	ibtn	ibtnSave
Hyperlink	lnk	lnkHomePage
DropDownList	ddl	ddlCompany
ListBox	lst	lstCompany
DataList	dlst	dlstAddress
Repeater	rep	repSection
Checkbox	chk	chkMailList
CheckBoxList	chk	chkAddress
RadioButton	rdo	rdoSex
RadioButtonList	rdo	rdoAgeGroup
Image	img	imgLogo
Panel	pan	panSection
PlaceHolder	plh	plhHeader
Calender	cal	calMyDate
Adrotator	adr	adrBanner
Table	tbl	tblResults
[All] Validators	val	valCreditCardNumber
ValidationSummary	vals	valsErrors

Namespaces

All namespace should use Pascal casing and be prefixed with your company (and department if you wish). See examples below:
Sample "project level" namespaces:

YourCompany.YourDept.YourProject
Visualize.Blog

Generic reusable routines, classes etc which will be used across projects, can sit at the 'company' or 'dept' level, for example:

Visualize.Utils

Commenting Code

Code should be commented where necessary and C# XML commenting tags used, to aid VS intellisense, object browsing and on-line documentation generation if needed. Example: some sample C# source is given below for a method in an SMS tool I developed recently:

///

/// SendSMSMessage sends a text message to a valid mobile number
///

/// Mobile number to send to in format +44 1234 112233
/// Message itself, max 160 chars
/// Message result string from gateway
public string SendSMSMessage(string mobileNo,string message)
{
// rest of code here...

Full details of more XML tags can be found in the Visual Studio.Net on-line help.

jairox'z

Where is the Surface Area Configuration tool in SQL Server 2008

Get list of the stored procedure from database

get list of the stored procedure which contains a

A Study of Delegates

Introduction

Delegates and .NET Compilers

Named Delegates

Anonymous Delegates

Delegates and the CLR/Runtime

License

Understanding Covariance and Contravariance in .NET 4.0

Your Azure Web Role and Full IIS – Culture Changes

License

C# & SQLite – System.Data.SQLite

SQLite Admin Tool

SQLite ADO.Net Provider

How to clear a TextBox value in a single click in C# .NET

Sending HTML e-mail with embedded images

Android applications in C# using Visual Studio

Getting Started

Hello Android

More Information

Interview Questions and Answer on .Net,C#,ASP.NET,SQL Server

Interview Questions and Answer on .Net,C#,ASP.NET,SQL Server

What is URL Routing?

What is URL Routing?

Mapping URLs using ASP.NET MVC

Mapping URLs using ASP.NET Web Forms

Retrieving URLs within an ASP.NET Web Form

Handling PostBack Scenarios

ASP.NET TreeView Sort

7 Page Jump Methods in ASP.NET

Introduction

Page Jump Methods

1、 Make use of HTML tags

<a href=”test.aspx”>test page

This example is very simple. Just use href property of tag to formulate the url of jump page to achieve jump.

2、 HyperLink Control

3、Response.Redirect()

4、Server.Transfer()

5、 Server.Execute()

6、Javascript achieve page jump

7、Respone.Write()

Encrypting all the Stored Procedures of a Database

The Biggest Changes in C++11

The Biggest Changes in C++11 (and Why You Should Care)

Lambda Expressions

Automatic Type Deduction and decltype

Uniform Initialization Syntax

Deleted and Defaulted Functions

nullptr

Delegating Constructors

Rvalue References

C++11 Standard Library

THREADING LIBRARY

NEW SMART POINTER CLASSES

NEW ALGORITHMS

Bitwise operators in c#

Bitwise operators in c# OR(|), XOR(^), AND(&amp;), NOT(~)

Binary OR(|) operator

Binary AND(&) operator

Not (~) operator

Removing Unused Css form classes from your web application

Dot NET Developers Tools List and More

Request.Url - ASP.NET

Understanding Paths in ASP.NET

Table 1 Path Functions in ASP.NET and Their Results

Path Mapping

How to build your own C# Autodialer

Creating SqlParameters Best Practices

C# Coding Standards Series – Naming Conventions

General Rules

Naming Conventions for ASP.NET Controls

(hide this) .net Naming Conventions and Programming Standards - Best Practices

Common .NET Naming Conventions

Why Hungarian Has Fallen Out of Favor with .NET

Resources - ASP.Net Coding Standards

Adopting a common coding standard across your web applications

Naming and Capitalisation

Automatic Type Deduction and `decltype`

Bitwise operators in c# OR(|), XOR(^), AND(&), NOT(~)