Developer's Corner

Free Online E-Books

2011-12-26T22:15:00.000-08:00

Using LINQ to SQL

2009-12-01T23:07:00.000-08:00

What Is LINQ to SQL?

LINQ to SQL is an O/RM (object relational mapping) implementation that ships in the .NET Framework "Orcas" release, and which allows you to model a relational database using .NET classes. You can then query the database using LINQ, as well as update/insert/delete data from it.

LINQ to SQL fully supports transactions, views, and stored procedures. It also provides an easy way to integrate data validation and business logic rules into your data model.

Modeling Databases Using LINQ to SQL:

Visual Studio "Orcas" ships with a LINQ to SQL designer that provides an easy way to model and visualize a database as a LINQ to SQL object model. My next blog post will cover in more depth how to use this designer (you can also watch this video I made in January to see me build a LINQ to SQL model from scratch using it).

Using the LINQ to SQL designer I can easily create a representation of the sample "Northwind" database like below:

My LINQ to SQL design-surface above defines four entity classes: Product, Category, Order and OrderDetail. The properties of each class map to the columns of a corresponding table in the database. Each instance of a class entity represents a row within the database table.

The arrows between the four entity classes above represent associations/relationships between the different entities. These are typically modeled using primary-key/foreign-key relationships in the database. The direction of the arrows on the design-surface indicate whether the association is a one-to-one or one-to-many relationship. Strongly-typed properties will be added to the entity classes based on this. For example, the Category class above has a one-to-many relationship with the Product class. This means it will have a "Categories" property which is a collection of Product objects within that category. The Product class then has a "Category" property that points to a Category class instance that represents the Category to which the Product belongs.

The right-hand method pane within the LINQ to SQL design surface above contains a list of stored procedures that interact with our database model. In the sample above I added a single "GetProductsByCategory" SPROC. It takes a categoryID as an input argument, and returns a sequence of Product entities as a result. We'll look at how to call this SPROC in a code sample below.

Understanding the DataContext Class

When you press the "save" button within the LINQ to SQL designer surface, Visual Studio will persist out .NET classes that represent the entities and database relationships that we modeled. For each LINQ to SQL designer file added to our solution, a custom DataContext class will also be generated. This DataContext class is the main conduit by which we'll query entities from the database as well as apply changes. The DataContext class created will have properties that represent each Table we modeled within the database, as well as methods for each Stored Procedure we added.

For example, below is the NorthwindDataContext class that is persisted based on the model we designed above:

LINQ to SQL Code Examples

Once we've modeled our database using the LINQ to SQL designer, we can then easily write code to work against it. Below are a few code examples that show off common data tasks:

1) Query Products From the Database

The code below uses LINQ query syntax to retrieve an IEnumerable sequence of Product objects. Note how the code is querying across the Product/Category relationship to only retrieve those products in the "Beverages" category:

C#:

VB:

2) Update a Product in the Database

The code below demonstrates how to retrieve a single product from the database, update its price, and then save the changes back to the database:

C#:

VB:

Note: VB in "Orcas" Beta1 doesn't support Lambdas yet. It will, though, in Beta2 - at which point the above query can be rewritten to be more concise.

3) Insert a New Category and Two New Products into the Database

The code below demonstrates how to create a new category, and then create two new products and associate them with the category. All three are then saved into the database.

Note below how I don't need to manually manage the primary key/foreign key relationships. Instead, just by adding the Product objects into the category's "Products" collection, and then by adding the Category object into the DataContext's "Categories" collection, LINQ to SQL will know to automatically persist the appropriate PK/FK relationships for me.

VB:

4) Delete Products from the Database

The code below demonstrates how to delete all Toy products from the database:

C#:

VB:

5) Call a Stored Procedure

The code below demonstrates how to retrieve Product entities not using LINQ query syntax, but rather by calling the "GetProductsByCategory" stored procedure we added to our data model above. Note that once I retrieve the Product results, I can update/delete them and then call db.SubmitChanges() to persist the modifications back to the database.

C#:

VB:

6) Retrieve Products with Server Side Paging

The code below demonstrates how to implement efficient server-side database paging as part of a LINQ query. By using the Skip() and Take() operators below, we'll only return 10 rows from the database - starting with row 200.

C#:

VB:

Summary

LINQ to SQL provides a nice, clean way to model the data layer of your application. Once you've defined your data model you can easily and efficiently perform queries, inserts, updates and deletes against it.

Currency Format for Server Side Controls

2009-11-05T20:46:00.000-08:00

monthReceipts.Text = String.Format("{0:£#,##0.00}", Convert.ToDecimal(m_accin));

m_accin = Parameter Name

Java Script Debugger in Internet Explorer 8

2009-01-22T01:11:00.000-08:00

When Internet Explorer 8 is installed, built-in Java Script debugger ships along. Since this is an in-proc debugger one need not launch a separate app.

It has all the familiar Visual Studio 2008 Features debugger like call stacks, watches, locals and immediate window.

To get to the debugger just press SHIFT+F12, or click the developer tools icon in the command bar.
After launching the Developer Tools, switch to the script tab.

2008-12-12T07:01:00.000-08:00

What is Multi-Targeting?

With the past few releases of Visual Studio, each Visual Studio release only supported a specific version of the .NET Framework. For example, VS 2002 only worked with .NET 1.0, VS 2003 only worked with .NET 1.1, and VS 2005 only worked with .NET 2.0.

One of the big changes we are making starting with the VS 2008 release is to support what we call "Multi-Targeting" - which means that Visual Studio will now support targeting multiple versions of the .NET Framework, and developers will be able to start taking advantage of the new features Visual Studio provides without having to always upgrade their existing projects and deployed applications to use a new version of the .NET Framework library.

Now when you open an existing project or create a new one with VS 2008, you can pick which version of the .NET Framework to work with - and the IDE will update its compilers and feature-set to match this. Among other things, this means that features, controls, projects, item-templates, and assembly references that don't work with that version of the framework will be hidden, and when you build your application you'll be able to take the compiled output and copy it onto a machine that only has an older version of the .NET Framework installed, and you'll know that the application will work.

Creating a New Project in VS 2008 that targets .NET 2.0

To see an example of multi-targeting in action on a recent build of VS 2008 Beta 2, we can select File->New Project to create a new application.

Notice below how in the top-right of the new project dialog there is now a dropdown that allows us to indicate which versions of the .NET Framework we want to target when we create the new project. If I keep it selected on .NET Framework 3.5, I'll see a bunch of new project templates listed that weren't in previous versions of VS (including support for WPF client applications and WCF web service projects):

If I change the dropdown to target .NET 2.0 instead, it will automatically filter the project list to only show those project templates supported on machines with the .NET 2.0 framework installed:

If I create a new ASP.NET Web Application with the .NET 2.0 dropdown setting selected, it will create a new ASP.NET project whose compilation settings, assembly references, and web.config settings are configured to work with existing ASP.NET 2.0 servers:

When you go to the control Toolbox, you'll see that only those controls that work on ASP.NET 2.0 are listed:

And if you choose Add->Reference and bring up the assembly reference picker dialog, you'll see that those .NET class assemblies that aren't supported on .NET 2.0 are grayed out and can't be added to the project (notice how the "ok" button is not active below when I have a .NET 3.0 or .NET 3.5 assembly selected):

So why use VS 2008 if you aren't using the new .NET 3.5 features?

You might be wondering: "so what value do I get when using VS 2008 to work on a ASP.NET 2.0 project versus just using my VS 2005 today?" Well, the good news is that you get a ton of tool-specific value with VS 2008 that you'll be able to take advantage of immediately with your existing projects without having to upgrade your framework/ASP.NET version. A few big tool features in the web development space I think you'll really like include:

JavaScript intellisense

Much richer JavaScript debugging

Nested ASP.NET master page support at design-time

Rich CSS editing and layout support within the WYSIWYG designer

Split-view designer support for having both source and design views open on a page at the same time

A much faster ASP.NET page designer - with dramatic perf improvements in view-switches between source/design mode

Automated .SQL script generation and hosting deployment support for databases on remote servers

You'll be able to use all of the above features with any version of the .NET Framework - without having to upgrade your project to necessarily target newer framework versions. I'll be blogging about these features (as well as the great new framework features) over the next few weeks.

So how can I upgrade an existing project to .NET 3.5 later?

If at a later point you want to upgrade your project/site to target the NET 3.0 or NET 3.5 version of the framework libraries, you can right-click on the project in the solution explorer and pull up its properties page:

You can change the "Target Framework" dropdown to select the version of the framework you want the project to target. Doing this will cause VS to automatically update compiler settings and references for the project to use the correct framework version. For example, it will by default add some of the new LINQ assemblies to your project, as well as add the new System.Web.Extensions assembly that ships in .NET 3.5 which delivers new ASP.NET controls/runtime features and provides built-in ASP.NET AJAX support (this means that you no longer need to download the separate ASP.NET AJAX 1.0 install - it is now just built-in with the .NET 3.5 setup):

Once you change your project's target version you'll also see new .NET 3.5 project item templates show up in your add->new items dialog, you'll be able to reference assemblies built against .NET 3.5, as well as see .NET 3.5 specific controls show up in your toolbox.

For example, below you can now see the new control (which is an awesome new control that provides the ability to do data reporting, editing, insert, delete and paging scenarios - with 100% control over the markup generated and no inline styles or other html elements), as well as the new control (which enables you to easily bind and work against LINQ to SQL data models), and control show up under the "Data" section of our toolbox:

Note that in addition to changing your framework version "up" in your project properties dialog, you can also optionally take a project that is currently building against .NET 3.0 or 3.5 and change it "down" (for example: move it from .NET 3.5 to 2.0). This will automatically remove the newer assembly references from your project, update your web.config file, and allow you to compile against the older framework (note: if you have code in the project that was written against the new APIs, obviously you'll need to change it).

What about .NET 1.0 and 1.1?

Unfortunately the VS 2008 multi-targeting support only works with .NET 2.0, .NET 3.0 and .NET 3.5 - and not against older versions of the framework. The reason for this is that there were significant CLR engine changes between .NET 1.x and 2.x that make debugging very difficult to support. In the end the costing of the work to support that was so large and impacted so many parts of Visual Studio that we weren't able to add 1.1 support in this release.

VS 2008 does run side-by-side, though, with VS 2005, VS 2003, and VS 2002. So it is definitely possible to continue targeting .NET 1.1 projects using VS 2003 on the same machine as VS 2008.

New Features of Visual Studio 2008 for .NET Professionals

2008-12-03T05:02:00.000-08:00

1. LINQ Support

LINQ essentially is the composition of many standard query operators that allow you to work with data in a more intuitive way regardless.

The benefits of using LINQ are significant – Compile time checking C# language queries, and the ability to debug step by step through queries.

2. Expression Blend Support

Expression blend is XAML generator tool for silverlight applications. You can install Expression blend as an embedded plug-in to Visual Studio 2008. By this you can get extensive web designer and JavaScript tool.

3. Windows Presentation Foundation

WPF provides you an extensive graphic functionality you never seen these before. Visual Studio 2008 contains plenty of WPF Windows Presentation Foundation Library templates. By this a visual developer who is new to .NET, C# and VB.NET can easily develop the 2D and 3D graphic applications.

Visual Studio 2008 provides free game development library kits for games developers. currently this game development kits are available for C++ and also 2D/3D Dark Matter one image and sounds sets.

4. VS 2008 Multi-Targeting Support

Earlier you were not able to working with .NET 1.1 applications directly in visual studio 2005. Now in Visual studio 2008 you are able to create, run, debug the .NET 2.0, .NET 3.0 and .NET 3.5 applications. You can also deploy .NET 2.0 applications in the machines which contains only .NET 2.0 not .NET 3.x.

5. AJAX support for ASP.NET

Previously developer has to install AJAX control library separately that does not come from VS, but now if you install Visual Studio 2008, you can built-in AJAX control library. This Ajax Library contains plenty of rich AJAX controls like Menu, TreeView, webparts and also these components support JSON and VS 2008 contains in built ASP.NET AJAX Control Extenders.

6. JavaScript Debugging Support

Since starting of web development all the developers got frustration with solving javascript errors. Debugging the error in javascript is very difficult. Now Visual Studio 2008 makes it is simpler with javascript debugging. You can set break points and run the javaScript step by step and you can watch the local variables when you were debugging the javascript and solution explorer provides javascript document navigation support.

7. Nested Master Page Support

Already Visual Studio 2005 supports nested master pages concept with .NET 2.0, but the problem with this Visual Studio 2005 that pages based on nested masters can't be edited using WYSIWYG web designer. But now in VS 2008 you can even edit the nested master pages.

8. LINQ Intellisense and Javascript Intellisense support for silverlight applications

Most happy part for .NET developers is Visual Studio 2008 contains intellisense support for javascript. Javascript Intellisense makes developers life easy when writing client side validation, AJAX applications and also when writing Silverlight applications
Intellisense Support: When we are writing the LINQ Query VS provides LINQ query syntax as tool tips.

9. Organize Imports or Usings

We have Organize Imports feature already in Eclipse. SInce many days I have been waiting for this feature even in VS. Now VS contains Organize Imports feature which removes unnecessary namespaces which you have imported. You can select all the namespaces and right click on it, then you can get context menu with Organize imports options like "Remove Unused Usings", "Sort Usings", "Remove and Sort". Refactoring support for new .NET 3.x features like Anonymous types, Extension Methods, Lambda Expressions.

10. Intellisense Filtering

Earlier in VS 2005 when we were typing with intellisense box all the items were being displayed. For example If we type the letter 'K' then intellisense takes you to the items starts with 'K' but also all other items will be presented in intellisense box. Now in VS 2008 if you press 'K' only the items starts with 'K' will be filtered and displayed.

11. Intellisense Box display position

Earlier in some cases when you were typing the an object name and pressing . (period) then intellisense was being displayed in the position of the object which you have typed. Here the code which we type will go back to the dropdown, in this case sometimes programmer may disturb to what he was typing. Now in VS 2008 If you hold the Ctrl key while the intellisense is dropping down then intellisense box will become semi-transparent mode.

12. Visual Studio 2008 Split View

VS 2005 has a feature show both design and source code in single window. but both the windows tiles horizontally. In VS 2008 we can configure this split view feature to vertically, this allows developers to use maximum screen on laptops and wide-screen monitors.

Here one of the good feature is if you select any HTML or ASP markup text in source window automatically corresponding item will be selected in design window.

13. HTML JavaScript warnings, not as errors

VS 2005 mixes HTML errors and C# and VB.NET errors and shows in one window. Now VS 2008 separates this and shows javascript and HTML errors as warnings. But this is configurable feature.

14. Debugging .NET Framework Library Source Code

Now in VS 2008 you can debug the source code of .NET Framework Library methods. Lets say If you want to debug the DataBind() method of DataGrid control you can place a debugging point over there and continue with debug the source code of DataBind() method.

15. In built Silverlight Library

Earlier we used to install silverlight SDK separately, Now in VS 2008 it is inbuilt, with this you can create, debug and deploy the silverlight applications.

16. Visual Studio LINQ Designer

Already you know in VS 2005 we have inbuilt SQL Server IDE feature. by this you no need to use any other tools like SQL Server Query Analyzer and SQL Server Enterprise Manger. You have directly database explorer by this you can create connections to your database and you can view the tables and stored procedures in VS IDE itself. But now in VS 2008 it has View Designer window capability with LINQ-to-SQL.

17. Inbuilt C++ SDK

Earlier It was so difficult to download and configure the C++ SDK Libraries and tools for developing windows based applications. Now it is inbuilt with VS 2008 and configurable

18. Multilingual User Interface Architecture - MUI

MUI is an architecture contains packages from Microsoft Windows and Microsoft Office libraries. This supports the user to change the text language display as he wish.
Visual Studio is now in English, Spanish, French, German, Italian, Chinese Simplified, Chinese Traditional, Japanese, and Korean. Over the next couple of months. Microsoft is reengineering the MUI which supports nine local languages then you can even view Visual studio in other 9 local languages.

19. Microsoft Popfly Support

Microsoft Popfly explorer is an add-on to VS 2008, by this directly you can deploy or hosting the Silverlight applications and Marshup objects

20. Free Tools and Resources

People may feel that I am a promoter to Visual Studio 2008 as a salesman, but we get plenty of free resources and free tools with Visual Studio 2008.
Visual Studio 2008 Trial
101 LINQ Samples
Free .NET 3.5 control libraries with free sample programs,
You can get plenty of free video training tutorials from Microsoft BDLC - Beginner Developer Learning Center,
C++ games development library,
Microsoft has provided lot of e-Books,
P2P library and
Microsoft is providing Coding4Fun sample program kit.
Visual Studio Registration Discounts: If you register the Visual Studio you get Free Control Libraries, Books, Images, and Discounts.
Download Visual Studio 2008 free trial

21. We can use for Commercial

Earlier you were spending lot of money to host your .NET applications for commercial use. Now you no need to worry Now Microsoft is providing you to host your application free on Popfly for web pages and also visual studio express projects.

Microsoft Chart Controls for Microsoft .NET Framework 3.5

2008-11-27T01:25:00.000-08:00

Microsoft recently released a cool new ASP.NET server control - - that can be used for free with ASP.NET 3.5 to enable rich browser-based charting scenarios:
Download the free Microsoft Chart Controls
Download the VS 2008 Tool Support for the Chart Controls
Download the Microsoft Chart Controls Samples
Download the Microsoft Chart Controls Documentation
Visit the Microsoft Chart Control Forum
Once installed the control shows up under the "Data" tab on the Toolbox, and can be easily declared on any ASP.NET page as a standard server control.

Get Max Number On String

2008-10-23T22:05:00.000-07:00

--"TOOL_TYP_CODE" = COLUMN NAME
--"DMS_DCT_TOOL_TYPE" = TABLE
--"WBD0" = CODE LAST
SELECT
MAX(CONVERT(INTEGER,SUBSTRING(TOOL_TYP_CODE,5,4)))
FROM DMS_DCT_TOOL_TYPE
WHERE TOOL_TYP_CODE LIKE 'WBD0%'

To disable autorecovery in .net

2008-10-16T22:27:00.000-07:00

To disable autorecovery in .net :

Go to Registry and change to 0 (zero) value of the following key:

HKEY_CURRENT_USER\Software\Microsoft\Microsoft SQL Server\90\Tools\Shell\General\AutoRecover\AutoRecover Enabled

Generate Serial No. in SQL

2008-10-16T01:40:00.000-07:00

Row_Number() over (Order by Emp_ID) as Serial

C# Basic Questions

2008-10-06T21:33:00.000-07:00

Que:- What’s the implicit name of the parameter that gets passed into the class’ set method?
Ans:- Value, and its datatype depends on whatever variable we’re changing.

Que:- How do you inherit from a class in C#?
Ans:- Place a colon and then the name of the base class. Notice that it’s double
colon in C++.

Que:- Does C# support multiple inheritance?
Ans:- No, use interfaces instead.

Que:- When you inherit a protected class-level variable, who is it available to?
Ans:- Classes in the same namespace.

Que:- Are private class-level variables inherited?
Ans:- Yes, but they are not accessible, so looking at it you can honestly say that they are not inherited. But they are.

Que:- Describe the accessibility modifier protected internal.
Ans:- It’s available to derived classes and classes within the same Assembly (and naturally from the base class it’s declared in).

Que:- C# provides a default constructor for me. I write a constructor that takes a string as a parameter, but want to keep the no parameter one. How many constructors should I write?
Ans:- Two. Once you write at least one constructor, C# cancels the freebie constructor, and now you have to write one yourself, even if there’s no implementation in it.

Que:- What’s the top .NET class that everything is derived from?
Ans:- System.Object.

Que:- How’s method overriding different from overloading?
Ans:- When overriding, you change the method behavior for a derived class. Overloading simply involves having a method with the same name within the class.

Que:- What does the keyword virtual mean in the method definition?
Ans:- The method can be over-ridden.

Que:- Can you declare the override method static while the original method is non-static?
Ans:- No, you can’t, the signature of the virtual method must remain the same, only the keyword virtual is changed to keyword override.

Que:- Can you override private virtual methods?
Ans:- No, moreover, you cannot access private methods in inherited classes, have to be protected in the base class to allow any sort of access.

Que:- Can you prevent your class from being inherited and becoming a base class for some other classes?
Ans:- Yes, that’s what keyword sealed in the class definition is for. The developer trying to derive from your class will get a message: cannot inherit from Sealed class WhateverBaseClassName. It’s the same concept as final class in Java.

Que:- Can you allow class to be inherited, but prevent the method from being over-ridden?
Ans:- Yes, just leave the class public and make the method sealed.

Que:- What’s an abstract class?
Ans:- A class that cannot be instantiated. A concept in C++ known as pure virtual method. A class that must be inherited and have the methods over-ridden. Essentially, it’s a blueprint for a class without any implementation.

Que:- When do you absolutely have to declare a class as abstract (as opposed to free-willed educated choice or decision based on UML diagram)?
Ans:- When at least one of the methods in the class is abstract. When the class itself is inherited from an abstract class, but not all base abstract methods have been over-ridden.

Que:- What’s an interface class?
Ans:- It’s an abstract class with public abstract methods all of which must be implemented in the inherited classes.

Que:- Why can’t you specify the accessibility modifier for methods inside the interface?
Ans:- They all must be public. Therefore, to prevent you from getting the false impression that you have any freedom of choice, you are not allowed to specify any accessibility, it’s public by default.

Que:- Can you inherit multiple interfaces?
Ans:- Yes, why not.

Que:- And if they have conflicting method names?
Ans:- It’s up to you to implement the method inside your own class, so implementation is left entirely up to you. This might cause a problem on a higher-level scale if similarly named methods from different interfaces expect different data, but as far as compiler cares you’re okay.

Que:- What’s the difference between an interface and abstract class?
Ans:- In the interface all methods must be abstract; in the abstract class some methods can be concrete. In the interface no accessibility modifiers are allowed, which is ok in abstract classes.

Que:- How can you overload a method?
Ans:- Different parameter data types, different number of parameters, different order of parameters.

Que:- If a base class has a bunch of overloaded constructors, and an inherited class has another bunch of overloaded constructors, can you enforce a call from an inherited constructor to an arbitrary base constructor?
Ans:- Yes, just place a colon, and then keyword base (parameter list to invoke the appropriate constructor) in the overloaded constructor definition inside the inherited class.

Que:- What’s the difference between System.String and System.StringBuilder classes?
Ans:- System.String is immutable; System.StringBuilder was designed with the purpose of having a mutable string where a variety of operations can be performed.

Que:- What’s the advantage of using System.Text.StringBuilder over System.String?
Ans:- StringBuilder is more efficient in the cases, where a lot of manipulation is done to the text. Strings are immutable, so each time it’s being operated on, a new instance is created.

Que:- Can you store multiple data types in System.Array?
Ans:- No.

Que:- What’s the difference between the System.Array.CopyTo() and System.Array.Clone()?
Ans:- The first one performs a deep copy of the array, the second one is shallow.

Que:- How can you sort the elements of the array in descending order?
Ans:- By calling Sort() and then Reverse() methods.

Que:- What’s the .NET datatype that allows the retrieval of data by a unique key?
Ans:- HashTable.

Que:- What’s class SortedList underneath?
Ans:- A sorted HashTable.

Que:- Will finally block get executed if the exception had not occurred?
Ans:- Yes.

Que:- What’s the C# equivalent of C++ catch (…), which was a catch-all statement for any possible exception?
Ans:- A catch block that catches the exception of type System.Exception. You can also omit the parameter data type in this case and just write catch {}.

Que:- Can multiple catch blocks be executed?
Ans:- No, once the proper catch code fires off, the control is transferred to the finally block (if there are any), and then whatever follows the finally block.

Que:- Why is it a bad idea to throw your own exceptions?
Ans:- Well, if at that point you know that an error has occurred, then why not write the proper code to handle that error instead of passing a new Exception object to the catch block? Throwing your own exceptions signifies some design flaws in the project.

Que:- What’s a delegate?
Ans:- A delegate object encapsulates a reference to a method. In C++ they were referred to as function pointers.

Que:- What’s a multicast delegate?
Ans:- It’s a delegate that points to and eventually fires off several methods.

Que:- How’s the DLL Hell problem solved in .NET?
Ans:- Assembly versioning allows the application to specify not only the library it needs to run (which was available under Win32), but also the version of the assembly.

Que:- What are the ways to deploy an assembly?
Ans:- An MSI installer, a CAB archive, and XCOPY command.

Que:- What’s a satellite assembly?
Ans:- When you write a multilingual or multi-cultural application in .NET, and want to distribute the core application separately from the localized modules, the localized assemblies that modify the core application are called satellite assemblies.

Que:- What namespaces are necessary to create a localized application?
Ans:- System.Globalization, System.Resources.

Que:- What’s the difference between // comments, /* */ comments and /// comments?
Ans:- Single-line, multi-line and XML documentation comments.

Que:- How do you generate documentation from the C# file commented properly with a command-line compiler?
Ans:- Compile it with a /doc switch.

Que:- What’s the difference between and XML documentation tag?
Ans:- Single line code example and multiple-line code example.

Que:- Is XML case-sensitive?
Ans:- Yes, so and are different elements.

Que:- What debugging tools come with the .NET SDK?
Ans:- CorDBG – command-line debugger, and DbgCLR – graphic debugger. Visual Studio .NET uses the DbgCLR. To use CorDbg, you must compile the original C# file using the /debug switch.

Que:- What does the This window show in the debugger?
Ans:- It points to the object that’s pointed to by this reference. Object’s instance data is shown.

Que:- What does assert() do?
Ans:- In debug compilation, assert takes in a Boolean condition as a parameter, and shows the error dialog if the condition is false. The program proceeds without any interruption if the condition is true.

Que:- What’s the difference between the Debug class and Trace class?
Ans:- Documentation looks the same. Use Debug class for debug builds, use Trace class for both debug and release builds.

Que:- Why are there five tracing levels in System.Diagnostics.TraceSwitcher?
Ans:- The tracing dumps can be quite verbose and for some applications that are constantly running you run the risk of overloading the machine and the hard drive there. Five levels range from None to Verbose, allowing to fine-tune the tracing activities.

Que:- Where is the output of TextWriterTraceListener redirected?
Ans:- To the Console or a text file depending on the parameter passed to the constructor.

Que:- How do you debug an ASP.NET Web application?
Ans:- Attach the aspnet_wp.exe process to the DbgClr debugger.

Que:- What are three test cases you should go through in unit testing?
Ans:- Positive test cases (correct data, correct output), negative test cases (broken or missing data, proper handling), exception test cases (exceptions are thrown and caught properly).

Que:- Can you change the value of a variable while debugging a C# application?
Ans:- Yes, if you are debugging via Visual Studio.NET, just go to Immediate window.

Que:- Explain the three services model (three-tier application).
Ans:- Presentation (UI), business (logic and underlying code) and data (from storage or other sources).

Que:- What are advantages and disadvantages of Microsoft-provided data provider classes in ADO.NET?
Ans:- SQLServer.NET data provider is high-speed and robust, but requires SQL Server license purchased from Microsoft. OLE-DB.NET is universal for accessing other sources, like Oracle, DB2, Microsoft Access and Informix, but it’s a .NET layer on top of OLE layer, so not the fastest thing in the world. ODBC.NET is a deprecated layer provided for backward compatibility to ODBC engines.

Que:-. What’s the role of the DataReader class in ADO.NET connections?
Ans:- It returns a read-only dataset from the data source when the command is executed.

Que:- What is the wildcard character in SQL? Let’s say you want to query database with LIKE for all employees whose name starts with La.
Ans:- The wildcard character is %, the proper query with LIKE would involve ‘La%’.

Que:- Explain ACID rule of thumb for transactions.
Ans:- Transaction must be Atomic (it is one unit of work and does not dependent on previous and following transactions), Consistent (data is either committed or roll back, no “in-between” case where something has been updated and something hasn’t), Isolated (no transaction sees the intermediate results of the current transaction), Durable (the values persist if the data had been committed even if the system crashes right after).

Que:- What connections does Microsoft SQL Server support?
Ans:- Windows Authentication (via Active Directory) and SQL Server authentication (via Microsoft SQL Server username and passwords).

Que:- Which one is trusted and which one is untrusted?
Ans:- Windows Authentication is trusted because the username and password are checked with the Active Directory, the SQL Server authentication is untrusted, since SQL Server is the only verifier participating in the transaction.

Que:- Why would you use untrusted verificaion?
Ans:- Web Services might use it, as well as non-Windows applications.

Que:- What does the parameter Initial Catalog define inside Connection String?
Ans:- The database name to connect to.

Que:- What’s the data provider name to connect to Access database?
Ans:- Microsoft.Access.

Que:- What does Dispose method do with the connection object?
Ans:- Deletes it from the memory.

Que:- What is a pre-requisite for connection pooling?
Ans:- Multiple processes must agree that they will share the same connection, where every parameter is the same, including the security settings.

Asp.net Questions

2008-10-06T21:30:00.000-07:00

Que:- What is the sequence in which ASP.NET events are processed ?
Ans:- Following is the sequence in which the events occur :-
* Page_Init.
* Page_Load.
* Control events.
* Page_Unload event.
Page_init event only occurs when first time the page is started, but Page_Load occurs in subsequent request of the page.

Que:- In which event are the controls fully loaded ?
Ans:- Page_load event guarantees that all controls are fully loaded. Controls are also accessed in Page_Init events but you will see that viewstate is not fully loaded during this event.

Que:- How can we identify that the Page is PostBack ?
Ans:- Page object has a “IsPostBack” property which can be checked to know that is the page posted back.

Que:-What is event bubbling ?
Ans:- Server controls like Datagrid, DataList, Repeater can have other child controls inside them. Example DataGrid can have combo box inside datagrid. These child control do not raise there events by themselves, rather they pass the event to the container parent (which can be a datagrid, datalist, repeater), which passed to the page as “ItemCommand” event. As the child control send there events to parent this is termed as event bubbling.

Que:- If we want to make sure that no one has tampered with ViewState, how do we ensure it?
Ans:- Using the @Page directive EnableViewStateMac to True.

Que:- What is AppSetting Section in “Web.Config” file?
Ans:- Web.config file defines configuration for a webproject. Using “AppSetting” section we can define user defined values. Example below defined is ConnectionString” section which will be used through out the project for database connection.

Que:- Where is ViewState information stored ?
Ans:- In HTML Hidden Fields.

Que:- How can we create custom controls in ASP.NET ?
Ans:- User controls are created using .ASCX in ASP.NET. After .ASCX file is created you need to two things in order that the ASCX can be used in project:

* Register the ASCX control in page using the
* Now to use the above accounting footer in page you can use the below directive.

Que:- How many types of validation controls are provided by ASP.NET ?
Ans:- There are six main types of validation controls :-
1). RequiredFieldValidator :-

It checks whether the control have any value. It's used when you want the control should not be empty.

2). RangeValidator :-

It checks if the value in validated control is in that specific range. Example
TxtCustomerCode should not be more than eight length.

3). CompareValidator:-

It checks that the value in controls should match the value in other control. Example
Textbox TxtPie should be equal to 3.14.

4). RegularExpressionValidator:-

When we want the control value should match with a specific regular expression.

5). CustomValidator:-

It is used to define UserDefined validation.

6). ValidationSummary:-

It displays summary of all current validation errors.

Que:- Can you explain what is “AutoPostBack” feature in ASP.NET ?
Ans:- If we want the control to automatically postback in case of any event, we will need to check this attribute as true. Example on a ComboBox change we need to send the event immediately to the server side then set the “AutoPostBack” attribute to true.

Que:- How can you enable automatic paging in DataGrid ?
Ans:- Following are the points to be done in order to enable paging in Datagrid :-
* Set the “AllowPaging” to true.
* In PageIndexChanged event set the current pageindex clicked.

Que:-What is the difference between “Web.config” and “Machine.Config” ?
Ans:- “Web.config” files apply settings to each web application, while Machine.config” file apply settings to all ASP.NET applications.

Que:- What is the difference between Server.Transfer and response.Redirect ?
Ans:- Following are the major differences between them:-
* Response.Redirect sends message to the browser saying it to move to some
different page, while server.transfer does not send any message to the browser
but rather redirects the user directly from the server itself. So in server.transfer
there is no round trip while response.redirect has a round trip and hence puts
a load on server.

* Using Server.Transfer you can not redirect to a different from the server itself.
Example if your server is www.yahoo.com you can use server.transfer to move
to www.microsoft.com but yes you can move to www.yahoo.com/travels, i.e.
within websites. This cross server redirect is possible only using
Response.redirect.

* With server.transfer you can preserve your information. It has a parameter
called as “preserveForm”. So the existing query string etc. will be able in the
calling page. In response.redirect you can maintain the state, but has
lot of drawbacks.

Que:- What is the difference between Authentication and authorization?
Ans:- This can be a tricky question. These two concepts seem altogether similar but there is wide range of difference. Authentication is verifying the identity of a user and authorization is process where we check does this identity have access rights to the system. In short we can say the following authentication is the process of obtaining some sort of credentials from the users and using those credentials to verify the user’s identity. Authorization is the process of allowing an authenticated user access to resources. Authentication always proceed to Authorization; even if your application lets anonymous users connect and use
the application, it still authenticates them as being anonymous.

Que:- What are the various ways of authentication techniques in ASP.NET?
Ans:- Selecting an authentication provider is as simple as making an entry in the web.config file for the application. You can use one of these entries to select the corresponding built in authentication provider:

* authentication mode=”windows”
* authentication mode=”passport”
* authentication mode=”forms”
* Custom authentication where you might install an ISAPI filter in IIS that
compares incoming requests to list of source IP addresses, and considers
requests to be authenticated if they come from an acceptable address. In that
case, you would set the authentication mode to none to prevent any of the
.net authentication providers from being triggered.

Que:- How does authorization work in ASP.NET?
Ans:- ASP.NET impersonation is controlled by entries in the applications web.config file. The default setting is “no impersonation”. You can explicitly specify that ASP.NET shouldn’t use impersonation by including the following code in the file

It means that ASP.NET will not perform any authentication and runs with its own
privileges. By default ASP.NET runs as an unprivileged account named ASPNET. You
can change this by making a setting in the processModel section of the machine.config
file. When you make this setting, it automatically applies to every site on the server. To user a high-privileged system account instead of a low-privileged set the userNameattribute of the processModel element to SYSTEM. Using this setting is a definite security risk, as it elevates the privileges of the ASP.NET process to a point where it can do bad things to the operating system.

Que:- What’s difference between Datagrid, Datalist and repeater ?
Ans:- A Datagrid, Datalist and Repeater are all ASP.NET data Web controls.
They have many things in common like DataSource Property, DataBind Method
ItemDataBound and ItemCreated.
When you assign the DataSource Property of a Datagrid to a DataSet then each DataRow
present in the DataRow Collection of DataTable is assigned to a corresponding
DataGridItem and this is same for the rest of the two controls also. But The HTML code generated for a Datagrid has an HTML TABLE element created for the particular DataRow and its a Table form representation with Columns and Rows.
For a Datalist its an Array of Rows and based on the Template Selected and the
RepeatColumn Property value We can specify how many DataSource records should
appear per HTML table row. In short in datagrid we have one record per row, but in
datalist we can have five or six rows per row.
For a Repeater Control, the Datarecords to be displayed depends upon the Templates
specified and the only HTML generated is the due to the Templates.
In addition to these, Datagrid has a in-built support for Sort, Filter and paging the Data,which is not possible when using a DataList and for a Repeater Control we would require to write an explicit code to do paging.

Que:- From performance point of view how do they rate ?
Ans:- Repeater is fastest followed by Datalist and finally datagrid.

Que:- What is the method to customize columns in DataGrid?
Ans:- Use the template column.

Que:- How can we format data inside DataGrid?
Ans:- Use the DataFormatString property.

Que:- How to decide on the design consideration to take a Datagrid, datalist or repeater ?
Ans:- Many make a blind choice of choosing datagrid directly, but that's not the right way.
Datagrid provides ability to allow the end-user to sort, page, and edit its data. But it comes at a cost of speed. Second the display format is simple that is in row and columns.
Real life scenarios can be more demanding that With its templates, the DataList provides more control over the look and feel of the displayed data than the DataGrid. It offers better performance than datagrid Repeater control allows for complete and total control. With the Repeater, the only HTML emitted are the values of the databinding statements in the templates along with the HTML markup specified in the templates—no "extra" HTML is emitted, as with the DataGrid and DataList. By requiring the developer to specify the complete generated HTML markup, the Repeater often requires the longest development time. But repeater does not provide editing features like datagrid so everything has to be coded by programmer. However, the Repeater does boast the best performance of the three data Web controls.
Repeater is fastest followed by Datalist and finally datagrid.

Que:- Difference between ASP and ASP.NET?
Ans:- ASP.NET new feature supports are as follows :-

Better Language Support

* New ADO.NET Concepts have been implemented.
ASP.NET supports full language (C#, VB.NET, C++) and not simple scripting
like VBSCRIPT..

Better controls than ASP

* ASP.NET covers large set’s of HTML controls..
* Better Display grid like Datagrid, Repeater and datalist.Many of the display
grids have paging support.

Controls have events support

* All ASP.NET controls support events.
* Load, Click and Change events handled by code makes coding much simpler and much better organized.

Compiled Code

The first request for an ASP.NET page on the server will compile the ASP.NET code and
keep a cached copy in memory. The result of this is greatly increased performance.
Better Authentication Support
ASP.NET supports forms-based user authentication, including cookie management and
automatic redirecting of unauthorized logins. (You can still do your custom login page and custom user checking).

User Accounts and Roles

ASP.NET allows for user accounts and roles, to give each user (with a given role) access to different server code and executables.

High Scalability

* Much has been done with ASP.NET to provide greater scalability.
* Server to server communication has been greatly enhanced, making it possible
to scale an application over several servers. One example of this is the ability
to run XML parsers, XSL transformations and even resource hungry session objects on other servers.

Easy Configuration

Configuration of ASP.NET is done with plain text files.
* Configuration files can be uploaded or changed while the application is running.
No need to restart the server. No more metabase or registry puzzle.

Easy Deployment

No more server restart to deploy or replace compiled code. ASP.NET simply redirects all new requests to the new code.

Que:- What are major events in GLOBAL.ASAX file ?
Ans:- The Global.asax file, which is derived from the HttpApplication class, maintains a pool
of HttpApplication objects, and assigns them to applications as needed. The Global.asax
file contains the following events:

Application_Init: Fired when an application initializes or is first called. It is invoked for
all HttpApplication object instances.

Application_Disposed: Fired just before an application is destroyed. This is the ideal
location for cleaning up previously used resources.

Application_Error: Fired when an unhandled exception is encountered within the
application.

Application_Start: Fired when the first instance of the HttpApplication class is created.
It allows you to create objects that are accessible by all HttpApplication instances.
Application_End: Fired when the last instance of an HttpApplication class is destroyed.
It is fired only once during an application's lifetime.

Application_BeginRequest: Fired when an application request is received. It is the first
event fired for a request, which is often a page request (URL) that a user enters.

Application_EndRequest: The last event fired for an application request.

Application_PreRequestHandlerExecute: Fired before the ASP.NET page framework
begins executing an event handler like a page or Web service.

Application_PostRequestHandlerExecute: Fired when the ASP.NET page framework has finished executing an event handler

Applcation_PreSendRequestHeaders: Fired before the ASP.NET page framework sends
HTTP headers to a requesting client (browser).

Application_UpdateRequestCache: Fired when the ASP.NET page framework completes
handler execution to allow caching modules to store responses to be used to handle
subsequent requests.

Application_AuthenticateRequest: Fired when the security module has established the
current user's identity as valid. At this point, the user's credentials have been validated.
Application_AuthorizeRequest: Fired when the security module has verified that a user
can access resources.

Session_Start: Fired when a new user visits the application Web site.

Session_End: Fired when a user's session times out, ends, or they leave the application
Web site.

Que:- What order they are triggered ?
Ans:- They're triggered in the following order:

* Application_BeginRequest
* Application_AuthenticateRequest
* Application_AuthorizeRequest
* Application_ResolveRequestCache
* Application_AcquireRequestState
* Application_PreRequestHandlerExecute
* Application_PreSendRequestHeaders
* Application_PreSendRequestContent
<>
* Application_PostRequestHandlerExecute
* Application_ReleaseRequestState
* Application_UpdateRequestCache
* Application_EndRequest.

Que:- How can we force all the validation control to run ?
Ans:- Page.Validate

Que:- How can we check if all the validation control are valid and proper ?
Ans:- Using the Page.IsValid() property you can check whether all the validation are done.

Que:- Which JavaScript file is referenced for validating the validators at the client side ?
Ans:- WebUIValidation.js javascript file installed at “aspnet_client” root IIS directory is used
to validate the validation controls at the client side

Que:- What is Tracing in ASP.NET ?
Ans:- Tracing allows us to view how the code was executed in detail.

Que:- How do we enable tracing ?
Ans:-

Que:- How can we kill a user session ?
Ans:- Session.abandon

Que:- How do I send email message from ASP.NET ?
ANs:- ASP.NET provides two namespaces System.WEB.mailmessage classand
System.Web.Mail.Smtpmail class. Just a small homework create a Asp.NET project and
send a email at "Email Adress". Do not Spam.

Que:- Explain the differences between Server-side and Client-side code?
Ans:- Server side code is executed at the server side on IIS in ASP.NET framework, while
client side code is executed on the browser.

Multiple Duplicate Keys in App.Config Files

2008-10-04T08:50:00.000-07:00

In Windows applications written before the advent of .NET, developers used various methods for providing configuration information to applications, such as .INI files, System Registry, etc. All .NET applications are designed to read configuration from either the app.config (Winform or console apps) or web.config (web apps) file. This normally means the developer adds configuration data to the appSettings section of the app.config file, as shown below.

appSettings
add key="myKey" value="myValue"
appsettings

The developer can access this information in the application by the use of the following code:

Dim value As String = ConfigurationSettings.AppSettings("myKey")

This works fine for most applications, but as application complexity increases, a need arises to have duplicate keys in the appSettings section. There is a problem in the implementation of AppSettings Method. When the application loads, the app.config file is read by the application (behind the scenes) and the values from the App.Config file are placed in a NamedValueCollection. The problem is that if you have multiple duplicate keys in a section, only the last value in the section will be placed into the NamedValueCollection. The reason for this is that the collection works like a VB Collection, where you cannont have duplicate keys. If you examine the code through Reflector, you will see that the code is implemented in the following way:

collection(i).value = key ' if the value already exists

instead of

collection(i).Add(key)

In order to get around this shortcoming, you can implement a sosphicated solution by using IConfigurationSectionHandler. However, any chance I have to keep something simple, I always do it. That's a rule of life with me as a programmer. To me, there is enough complication in programming Windows and Web applications, that cannot be escaped, to unnecessarily complicate something, just to use something that I have never used in the .NET Framework. Some will not agree, but as you know, if you have read many of my articles, the KISS (keep it simple stupid) principle is always in my mind.

My simple solution allows multiple "logical" duplicate keys without actually having real duplicates in the appSettings section. After all, the whole purpose is to get the data to the application without having to recompile the application every time you want to add the ability to handle new customers, etc., in the application. In this example, I have the requirement to be able to add a new customer name along with a userid and password to the app.config file. The application will use the customer names in a combo box, from which the user will select the desired customer. The application will then pick up the userid and password associated with the customer and use it to call a Web Service.

The code shown below, in the FillCustomerCollection method, will be called by the Form_Load event. This method will build a collection of CustAcctPW objects. On return from this method, a method to load the combo box will be called. Finally, when the user selects a user from the combo box, the application will go through the collection to find the selected customer, and then retrieve the associated userid and password. I will not show all of that ancillary code, but I will quickly explain the logic behind this simple method.

Instead of having multiple, duplicate keys in appSettings, which will not work, I will place a "NumberCustomers" key and value in the appSettings section of the app.config file. Next, I will add two "Customer" keys and associated values. Instead of duplicating the key, I simply give them keys of "Customer001", "Customer002", etc. The appSetting section that contains my customers is shown below.

<configuration>
<appSettings>

-- Add Customer keys with Name|Account|PW -->
<add key = "NUMBERCUSTOMERS" value = "2" />
<add key = "CUSTOMER001" value="Jones Co|JONESUser|!23*(Abc1" />
<add key = "CUSTOMER002" value= "NYTA|NYTAUserid|y*hg01K" />
appSettings>
configuration>

The NumberCustomers value will determine the number of times to loop to retrieve the customers and associated data values. Obviously, you want to make sure that the value of NumberCustomers changes if you add or remove a customer, but then any other invalid value in your app.config file will probably cause something ugly in your application. I use the NumberCustomers as an index which will be converted to string and appended to "Customer" to access the appSetting. I concatenate multiple values of Customer, Userid (Account), and Password in the value field delimited by "|". The FillCustomerCollection method is shown below, along with the CustAcctPW class and collection.

'''

''' The App Config file will have multiple CUSTNBRnnn keys in appsettings.
''' It will also have a NumberCustomers key with value = nbr of CustNbr occurrences.
''' Retrieve the number and use it to compute the value of each CustNbrnnn key value.
''' This must be done because the ConfigurationSettings.AppSettings method only picks up
''' the last value of a duplicate key name (bummer). This is because the code that builds
''' the NamedValueCollection stores into the collection, if a value exists, instead of
''' adding to the collection. It's built like an old VB Collection. I.,e., you can't have
''' but one occurrence of the same key name. But we wlll not be daunted...
'''

'''
Private Sub FillCustomerCollection()
Dim nbrCusts As Integer = _
CType(ConfigurationSettings.AppSettings("NUMBERCUSTOMERS"), Integer)
colCustomers = New Collection

For i As Integer = 1 To nbrCusts
Dim custKey As String = "CUSTOMER" & Format(i, "000")
Dim custValue As String = ConfigurationSettings.AppSettings(custKey)
Dim cust As New CustAcctPW
Dim m As Match = Regex.Match(custValue, _
"(?\w+)\|(?\w+)\|(?\w+)")
If m.Success Then
cust.Customer = m.Groups("cust").Value
cust.Account = m.Groups("acct").Value
cust.PW = m.Groups("pw").Value
colCustomers.Add(cust)
End If
Next
End Sub

Private colCustomers As Collection
Public Class CustAcctPW
Public Customer As String
Public Account As String
Public PW As String
End Class

The following method fills the combo box from the collection of customer data created by the FillCustomerCollection method shown above.

' Fill the customer combo box with customer numbers from the
' colCustomers collection.
Private Sub FillCustomerCombo(ByVal colCustomers As Collection)
Me.cboSelectCustomer.Items.Clear()
For i As Integer = 1 To colCustomers.Count
Dim cust As CustAcctPW = CType(colCustomers(i), CustAcctPW)
Me.cboSelectCustomer.Items.Add(cust.Customer)
Next
End Sub

Finally, the following combo box event handler fills the userid and password text boxes when the user selects a customer in the combo box.

Private Sub cboSelectCustomer_SelectedIndexChanged(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles cboSelectCustomer.SelectedIndexChanged
If formLoading Then Exit Sub
For i As Integer = 1 To colCustomers.Count
Dim cust As CustAcctPW = CType(colCustomers(i), CustAcctPW)
If cust.Customer = cboSelectCustomer.Text Then
Me.txtAccount.Text = cust.Account
Me.txtPassword.Text = cust.PW
End If
Next
End Sub

Inserting Multiple Record in SQL

2008-09-04T02:23:00.001-07:00

DECLARE @intFlag INT
SET @intFlag = 1
WHILE (@intFlag <=28)
BEGIN
UPDATE 'TABLE NAME'
SET 'Column Name' = '000000' -- Note: Column Name that you want to update.
WHERE ('Column ID' = @intFlag) -- Note: Unique Column ID of TAble
SET @intFlag = @intFlag + 1
END
GO

Label Formatting

2008-08-04T22:52:00.001-07:00

Label1.Text = System.Text.RegularExpressions.Regex.Replace(objListTrn.CourseOutLine, "\n", "
", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

Delegates in .NET

2008-07-18T22:34:00.000-07:00

What is a Delegate?
When we talk about delegates in .NET then one thing that comes to our mind is what delegate means to a novice developer. In simple words we can say delegates are a .NET object which points to a method that matches its specific signature.

In other words delegates are function pointers that point to function of matching signatures. Function pointers which are extensively used in c/c++ to points to a function holds only the memory address of the function, it doesn’t carry further information about the function parameters, return type etc. On the other hand .NET framework has introduced a type-safe mechanism called delegates, with automatic verification of the signature by the compiler.

So comparatively delegates add a safety dimension in handling function pointers in .NET.
So we can say that delegates are type-safe, object oriented, secure .NET objects which can be used to invoke methods of matching signature.

While using delegates it is very much necessary to make sure that the functions which the delegates points has the same number of argument type and same return type. For example if we have a method that takes a single string as a parameter and another method that takes two string parameters, then we need to have two separate delegate type for each method.

Types of Delegate:

Single cast delegate
A delegate is called single cast delegate if it invokes a single method. In other words we can say that SingleCast Delegates refer to a single method with matching signature. SingleCast Delegates derive from the System.Delegate class

SingleCast Delegates can be defined using the following syntax:

public delegate int mySingleCastDelegate int iFirstargument, int iSecondArgument);

Single cast delegate example:

using System;
namespace SingleCastDelegateDemoApplication
{
class mySingleDelegateClass
{
public delegate int mySingleCastDelegate(int iFirstargument,
int iSecondArgument);
static void Main(string[] args)
{
mySingleDelegateClass clsSingleCastDelegate = new mySingleDelegateClass();
mySingleCastDelegate singleCastMaxNumberDelegate =
new mySingleCastDelegate(clsSingleCastDelegate.myMaxFunction);
int iMaxNumberResult = singleCastMaxNumberDelegate(10, 20);
Console.WriteLine(@"Result by calling the myMaxFunction method using a
delegate: {0}", iMaxNumberResult);
Console.Read();
}
public int myMaxFunction(int iFirstNumber, int iSecondNumber)
{
if (iFirstNumber > iSecondNumber)
return iFirstNumber;
else
return iSecondNumber;
}
}
}

Multicast Delegates:
MultiCast Delegates are nothing but a single delegate that can invoke multiple methods of matching signature. MultiCast Delegate derives from System.MulticastDelegate class which is a subclass of System.Delegate.

In Multi-Casting basically we create a single delegate that in turn invokes multiple encapsulated methods. We can use MultiCast Delegates when multiple calls to different methods are required. For example if we are required to call two methods on a single button click event or mouse over event then using MultiCast Delegates we can easily call the methods.

The System.MulticastDelegate class provides required methods to play with delegates. There are two methods, Combine and Remove, which are used to play with delegates.

The Combine method is a static method of System.MulticastDelegate class which is used to combine the delegates and the Remove method is used to remove the delegate from the list.
The Combine method takes an array of delegate as a parameter and returns a new delegate that represents the combination of all the delegates in the array.

MultiCast Delegate can have arguments and can have return values as well. The only things is that the methods pointed by delegate needs to have same return type as that of the return type of delegate.

In the below code snippet I have defined a delegate which can act as a multicast delegate to encapsulate methods that takes two parameter as of type integer and returns nothing.

public delegate void MyMulticastDelegate(int p, int q);

Multi cast delegate example:

using System;
namespace MultiCastDelegatesDemoapplication
{
class MultiCastDelegatesClass
{
//delegate declaration
Public delegate void MyMulticastDelegate(int p, int q);
static void Main(string[] args)
{
MultiCastDelegatesClass clsMultiCastDelegate =
new MultiCastDelegatesClass();
MyMulticastDelegate myDelegate = null;
MyMulticastDelegate myMultiCastDelegateAddition =
new MyMulticastDelegate(clsMultiCastDelegate.myAddtionfunction);
MyMulticastDelegate myMultiCastDelegateMaxNumber =
new MyMulticastDelegate(clsMultiCastDelegate.myMaxFunction);
Console.WriteLine("Used Combine function to bind the delegates... ");
myDelegate = (MyMulticastDelegate)System.Delegate.Combine(myMultiCastDelegateAddition,
myMultiCastDelegateMaxNumber);
//call made using the multicast delegate
myDelegate(10, 23);
Console.WriteLine();
Console.WriteLine(@"Used Remove function to remove the delegate from
the list.. ");
myDelegate = (MyMulticastDelegate)System.Delegate.Remove(myDelegate,
myMultiCastDelegateMaxNumber);
myDelegate(10, 23);
Console.Read();
}
//function calculates the sum of passed arguments
public void myAddtionfunction(int iFirstNumber, int iSecondNumber)
{
int result = iFirstNumber + iSecondNumber;
Console.WriteLine(@"In myAddtionfunction called by a multi cast delegate:
Result is :" + result);
}
//function checks the max value of passed arguments
public void myMaxFunction(int iFirstNumber, int iSecondNumber)
{
int max ;
if (iFirstNumber > iSecondNumber)
{
max = iFirstNumber;
}
else
{
max = iSecondNumber;
}
Console.WriteLine(@"In myMaxFunction called by a multi cast delegate:
Result is :" + max);
}
}
}

Passing Values between ASP.NET Web Forms

2008-07-03T21:04:00.000-07:00

Introduction:

ASP.NET webforms provide excellent event driven programming model to developers. This does simplifies the overall design of your application but poses some problems of its own. For example, in traditional ASP you can easily pass values from one ASP page to another ASP page using POST. The same thing is not possible in ASP.NET if you want to stick to web form model (i.e. Server side form and control processing.). There are, however, some ways that can be used to overcome this situation. This article examines various possibilities to do the same. More specifically we will cover how to pass values using querystring, how to use session variables to do the same and finally how to use Server.Transfer method to do that.

Using Querystring:

Querystring is a day old mechanism to pass values across pages. The main advantage of this method is it is very simple. However, disadvantages are the values are visible in the browser address bar and you can not pass objects this way. This method is best suited when you want to pass small number of values that need not be secured from others. In order to implement this method you will follow these steps:

Create the web form with controls.
Provide some button or link button that posts the form back.
In the click event of the button create a string that holds URL for another.
Add control values to this URL as querystring parameters .
Response.Redirect to another form with this URL.

Following code snippet shows how it works:

Source Web Form:

private void Button1_Click
(object sender, System.EventArgs e)
{
string url;
url="anotherwebform.aspx?name=" +
TextBox1.Text + "&email=" +
TextBox2.Text;
Response.Redirect(url);
}

Destination Web Form:

private void Page_Load
(object sender, System.EventArgs e)
{
Label1.Text=Request.QueryString["name"];
Label2.Text=Request.QueryString["email"];
}

Using Session variables:

This is yet another way to pass values across pages. Here you store control values in session variables and access them in another web form. However, as you know storing too much data in session can be an overhead on the server. So, you should use this method with care. Also, it requires some kind of clean up action from your side so that unwanted session variables are removed. The typical sequence of steps will be as follows:

Create the web form with controls.
Provide some button or link button that posts the form back.
In the click event of the button add session variables and set them to control values.
Response.Redirect to another form.
In that form access Session variables and remove them if necessary.

Following code shows this in action:

Source Web Form:

private void Button1_Click
(object sender, System.EventArgs e)
{
//textbox1 and textbox2 are webform
//controls
Session["name"]=TextBox1.Text;
Session["email"]=TextBox2.Text;
Server.Transfer("anotherwebform.aspx");
}

Destination Web Form:

private void Page_Load
(object sender, System.EventArgs e)
{
Label1.Text=Session["name"].ToString();
Label2.Text=Session["email"].ToString();
Session.Remove("name");
Session.Remove("email");
}

Using Server.Transfer:

This is somewhat complex but sophisticated method of passing values across pages. Here you expose the values you want to access in other pages as properties of the page class. This methods require you to code extra properties that you can access in another web form. However, the efforts are worth considering. Overall this method is much cleaner and object oriented than earlier methods. The entire process works as follows:

Create the web form with controls.
Create property Get procedures that will return control values.
Provide some button or link button that posts the form back.
In the button click event handler call Server.Transfer method that will transfer execution to the specified form.
In the second form you can get a reference to the first form instance by using Context.Handler property. Then you will use the get properties we created to access the control values.

Source Web Form:

public string Name
{
get
{
return TextBox1.Text;
}
}
public string EMail
{
get
{
return TextBox2.Text;
}
}

Now, call Server.Transfer.

private void Button1_Click (object sender, System.EventArgs e)

{

Server.Transfer("anotherwebform.aspx");

}

Destination Web Form:

private void Page_Load
(object sender, System.EventArgs e)
{
//create instance of source web form
WebForm1 wf1;
//get reference to current handler instance
wf1=(WebForm1)Context.Handler;
Label1.Text=wf1.Name;
Label2.Text=wf1.EMail;
}

10 of the Biggest Platform Development Mistakes

2008-07-02T01:37:00.000-07:00

Just like with golf, technology is as much about ensuring that your bad hits are recoverable as it is ensuring that you make great ones. We’re all going to have failures in our careers but avoiding the really big pitfalls will help you keep your company on the right growth path. Here are 10 common mistakes we at AKF Consulting see made during platform development — and the ones we believe are the most important to avoid.

1) Failing to design for rollback:

If you’re developing a SaaS platform and you can only make one tweak to your current process, make it so that you can always roll back any code changes. We know that it takes additional engineering work and testing but in our experience, such effort yields the greatest ROI.

2) Confusing product release with product success:

Do you have “release” parties? Don’t — you are sending your team the wrong message. A release has little to do with creating shareholder value. Align your celebrations with achieving specific business objectives, such as increasing sign-ups by 10 percent.

3) Assuming a new Product Development Lifecycle (PDLC) will fix issues with missing delivery dates:

Too often CTOs see repeated problems in their development life cycles, such as missing release dates, and wrongly blame the development methodology. Make sure you’re fixing the right thing — lack of ownership or involvement in and/or incomplete understanding of the current PDLC are among the most common root causes of late dates.

4) Allowing history to repeat itself:

Organizations don’t spend enough time looking at past failures. The best and easiest way to improve your future performance is to track your past failures, group them by causation and treat the root cause rather than the symptoms. Keep incident logs and review them monthly to identify recurring problems.

5) Scaling through third parties:

If you’re a hyper-growth SaaS site, you don’t want to be locked into a vendor for your future business viability; rather you want to make sure that the scalability of your site is a core competency and that it’s built into your architecture. Define how your platform scales through your efforts, not through the systems that a third-party vendor provides.

6) Relying on QA to find your mistakes:

You cannot test quality into a system and it’s mathematically impossible to test all possibilities within complex systems to guarantee the correctness of a platform or feature. QA is a risk mitigation function and it should be treated as such. Defects are an engineering problem, and that’s where the problem should be treated.

7) Relying on “revolutionary” or “big bang” fixes:

The degree of success of complete rewrites or re-architecture efforts typically ranges somewhere between not returning the expected ROI and complete failure. The best projects — and the ones with the greatest returns — are not revolutionary but evolutionary. Go ahead and paint that vivid description of the ideal future, but approach it as a series of small steps.

8) Not taking into account the multiplicative effect of failure:

Every time you have one service call another service in a synchronous fashion, you are lowering your theoretical availability. If each of your services is designed to be 99.999 percent available, then the product of all of the service calls is your theoretical availability. Five calls is (.99999)^5 or 99.995 availability. Eliminate synchronous calls wherever possible and create fault-isolative architectures to help you identify problems quickly.

9) Failing to create and incent a culture of excellence:

Bring in the right people and hold them to high standards. You will never know what your team can do unless you find out how far they can go. Set aggressive yet achievable goals and motivate them with your vision. Be a leader.

10) Not having a business continuity/disaster recovery plan:

No one expects a disaster, but they happen, and if you can’t maintain normal business operations you will lose both revenue and customers. A solid business continuity plan explains to everyone how to operate in the event of an emergency. Even worse is not having a disaster recovery plan, which outlines how you will restore your site in the event a disaster shuts down a critical piece of your infrastructure, such as your collocation facility or connectivity provider. Our preference is to provide your own disaster recovery through multiple collocation facilities.

What's New in MSDN Code Gallery?

2008-07-01T01:43:00.000-07:00

What's New in MSDN Code Gallery?

How technology changes us......

2008-06-29T22:03:00.000-07:00

SQL Server Function to Determine a Leap Year

2008-06-27T23:19:00.000-07:00

There are few rules to consider when determining when a year is a leap year. For instance, contrary to popular belief not all years divisible by 4 are leap years. For instance, the year 1900 was not a leap year. However, you needn't bother yourself about leap year rules... you can let the SQL Server engine do the work for you!

The following scalar function takes in a year and returns a bit flag indicating whether the passed in year is a leap year or not.

create function dbo.fn_IsLeapYear (@year int)

returns bit

begin

return(select case datepart(mm, dateadd(dd, 1, cast((cast(@year as varchar(4)) + '0228') as datetime)))

when 2 then 1

else 0

end)

end

That's all there is to it! The function takes in the year, appends '0228' to it (for February 28th) and adds a day. If the month of the next day is a 2 (as extracted by the DATEPART function), then we're still in February so it must be a leap year! If not, it is not a leap year.

Here are a few examples:

Improve Web Application Performance

2008-06-26T20:53:00.000-07:00

Introduction:

In the IT world, software applications are being rapidly developed. Clients, and so employers, are just looking for those teams/individuals who can build up applications rapidly, just bothering to make their application live; but what often happens after an application goes live is that users start to use the application and it doesn’t respond well. At this point, clients start to lose users and business.

To code an application is not a big deal; I believe it can be done by virtually anyone, meaning it is not necessary to have great knowledge or experience. Improving performance of an existing application (especially an one put together rapidly) could be quite risky and could cause many ripple effects. Things must be planned first to avoid horrible results.
The following are a few points that can make a site scalable and reliable; but which may initially slow down development. I believe that overall, when maintenance and future changes are taken into account, total development time would be reduced.

1. Minimize HTTP based Requestss:

Problem 1: Serving images - no matter if they are of less than 1 KB - as separate web resources, cause separate web requests to the server, which impact performance.

Solutions:

Use Image Maps to merge up images, though image Maps could only merge up those images which are in sequence, like navigation images, so it depends upon your web site/page design.
Use Inline images. Inline images could increase your HTML page size but would cause fewer requests to the server.
CSS Sprites can also be used to merge up images and setting their position and backgrounds.

Problem 2: Using CSS is very good practice but serving stylesheets as separate resources, thus causing separate requests, should be considered very carefully.

Solutions:

Try your best to combine all your CSS based classes into a single .css file as lot of .css files will cause a large amount of requests, regardless of the file sizes.
.css files are normally cached by browsers, so a single and heavy .css file doesn’t cause a long wait on each page request.
Inline .css classes could make HTML heavy, so again: go ahead with a single.css file.

Problem 3: JavaScript is an awesome scripting language which can be quite powerful to play with. Nonetheless, it should be used carefully not only for request size issues; but also because it can have a way of causing unpredictable performance issues.

Solution:

Inline JavaScript could make the HTML page heavy, so it’s preferred to serve separate .js files or a single JavaScript file to keep all JavaScript-based scripts in a single place.

JavaScript files also get cached automatically by browsers, so they usually aren’t requested each time the page is loaded by the browsers.

2. HTTP Compression:

HTTP Compression is used to compress contents from the web server. HTTP requests and responses could be compressed, which can result in great performance gains. Through HTTP compression, the size of the payload can be reduced by about 50%, which is great. Isn’t it?

HTTP Compression is now widely supported by browsers and web servers.

If HTTP compression is enabled on the web server, and if the request header includes an Accept-Encoding: gzip, deflate header, the browser supports gzip and deflate compression mechanisms, so the response can be compressed in any of the given formats by the web server in order to reduce the payload size. This leads to an increase in performance. Latter that compressed response is decompressed by the browser and rendered normally.

Following are very good links which detail HTTP Compression and their implementations:

Click here to get detailed knowledge on HTTP compression.
Click here to learn how to enable HTTP compression in IIS.

3. Correct Formatted Images at the Right Place:

Problem: Normally designers use JPG or GIF formats quite randomly and ignore some other good formats to compress images.
Solution:

Correct format should be used for right purpose like:-
If you have to place a background image, some large image or a screenshot then the suggested format is JPG/JPEG.
If you have to use small graphics like button images, header images, footer images, navigation bar images or clip arts, then the suggested format is PNG.
If an image is not required to be in high or true colors and 256 colors are enough, then GIF is preferred.

4. Compress CSS, JavaScript and Images

CSS files (.css), images and JavaScript (.js) files can be compressed, as normally .css and .js files contain unnecessary spaces, comments, unnecessary code and such other things. A number of high quality (and free) utilities are available to help you pre-compress your files.

Following are a few good links for such utilities:

Compress PNG images by clicking here
Compress JPG images by clicking here
Compress .CSS files by clicking here and here and here
Compress .Js files by clicking here and here and here

5. CSS at Top

The recommended approach is to put CSS links on top of the web page, as it makes the page render progressively efficient. Since users want to see the contents of a page whilst it’s loading rather than white spaces, contents/formats should be given on top. HTML Specifications clearly say to declare style sheets in the head section of a web page.

6. Javascript at Bottom

When scripts are defined on top of the page they can take unnecessary time to load; they don’t show the contents that users are expecting after making any request to an HTTP web server. It's better to display a the HTML contents of a page, then load any scripting code (when possible, of course).

Preferably use/link up JavaScript-based scripts at the bottom of a web page. Alternatively you can use the defer attribute, which runs the script at the end of page loading, but that is not the preferable approach as it is not browser independent. For example, Firefox doesn’t support it and could mess up with document.write, so only use it once you fully understand the implications.

7. Content Delivery Network: (CDN)

When a browser makes a request to any web page – that is, he types a URL/URI of any web page or web site, a request goes through many hops (routers and computers) and then finally reaches its final destination. This happens both for requests and responses. This operation affects performance and can severely effect load time.

A Content Delivery Network implies a collection of computers, distributed all over the world, which deliver data (contents). Through a CDN you can have your website data on multiple servers distributed in different locations around the world. Distribute web application data in different places around the world so request can be served from the nearest location and save time (which means performance and money as well).

8. Ajax
Problemm: Ajax is being increasingly used to improve usability, but oftentimes in a way which increases overall server load.

Solutions:

Preferably use the GET method for Ajax based Requests, because if you use POST method then the request header would be sent first, followed by the data, which basically splits the request in two steps. A single-step request can be achieved with GET if a cookie is not too long and the URL is not larger than 2k.

When using ASP.NET AJAX and the UpdatePanel control for partial page rendering, use the maximum number of update panels to update small chunks of page, but use them wisely. Don’t set the Update property to Always unless needed. Instead, set the update mode to Conditional, otherwise all the partial chunks would be sent together after each asynchronous postback.

Ajax based requests can also be cached when using the GET method. If the URL is the same, then cached data can be used from the client, and a round trip to the server can be avoided.

9. Ajax vs. Callback

Problem: Ajax is a great solution for asynchronous communication between client (web browser) and HTTP servers, but one solution can't be applied to every problem. This means that Ajax is great mechanism for sending requests to the server without making a full page postback, but what if you need to send a request to the server and don’t even need partial rendering?

Solution: Best solution is Callback.

For example, if you need to check whether a user exists or not, or if a user has forgotten his/her password and you just need to send a request to the server to check if user name exist, there is no need for client-side render - just a server side operation.
Following are a couple of great links which explain callbacks: Please click here here.
and

10. Reduce Cookie size

Cookies are stored on the client side to keep information about users (authentication and personalization). Since HTTP is a stateless protocol, cookies are common in web development to maintain information and state. Cookies are sent with every HTTP requests, so try to keep them low in size to minimize effects on the HTTP response.

Cookie’s size should be minimized as much as possible.
Cookies shouldn’t contain secret information. If really needed, that information should be either encrypted or encoded.
Try to minimize the number of cookies by removing unnecessary cookies.
Cookies should expire as soon as they become useless for an application.

11. Use Cache appropriately

Cache mechanism is a great way to save server round trips - and also database server round trips - as both round trips are expensive processes. By caching data we can avoid hitting them when unnecessary. Following are few guidelines for implementing caching::

Static contents should be cached, like “Contact us” and “About us” pages, and such other pages which contain static information.
If a page is not fully static, it contains some dynamic information. Such pages can leverage the ASP.NET technology, which supports partial page caching.
If data is dynamically accessed and used in web pages - like data being accessed from some file or database - and even if data is consistently or regularly changed, then that data could be cached by using ASP.NET 2.0 cache dependency features. As soon as data changes from the back-end by some other means, the cache would be updated.
Now that web technologies such ASP.NET have matured and offer such great caching capabilities, there's really no reason not to make extensive use of them.

Following are few very good links to implement caching for different types of data (static and dynamic):

Click here to cache Full page (static page caching).
Click here and here to cache partial page caching.
Click here to cache dynamic data with dependency.

12. Upload compiled code rather than source code

Pre-compiled ASP.NET pages perform much better than source code versions. Actually pre-compilation give web sites a performance boost especially when the first request is made to a folder containing that resource. Uploading a pre-compiled version boosts up performance since the server doesn’t need to compile a page at request-time.

13. Conclusions

Following are few good practices to gain better performance::

For HTTP compression, GZip is considered the most effective and most popular by means of browsers and HTTP server. It can reduce file size up to 70% in size.
Always keep JavaScript and CSS in external files.
Avoid redirects until needed. Server.Transfer is also provided so consider that as well since it performs better in some conditions.
Minimize use of Iframes as it's costly.
Avoid try-catch blocks for control-flow as they perform poorly. Exceptions should be used only in truly exceptional situations.
Minimize Cookie/CSS sizes.
Minimize DOM objects on page as they are heavy weight.
Use link tags rather than @import to use/link up CSS.
Favicon, being a static image displayed in the browser’s address bar, should be cacheable and compressed.
Always prefer a cache-friendly folder structure. For example, create specific folders for static contents, like /static for static images/static pages…
SSL can never be cached so minimize its usage. Keep it for those pages which need to be secure, rather than using it for all the pages.
HTTP Post requests can’t be cached, so choose the HTTP method appropriately.
Prevent Denial of Service (Dos) attacks.
Prevent SQL Injection.
Prevent Cross Site Scripting (XSS).

Hghlight Datagrid or GridView Row on Mouse Over

2008-06-24T01:30:00.000-07:00

This article will show how you can Ajax with GridView to display popup messages when mouse moves over certain column. In the demo project I have added first column as an image column with a help icon in it. This kind of implements a feature that if you want more information about the row you can move mouse over this icon, a asynchronous request is sent to server for data about that row and when call returns the returned message is show as a popup message. This technique combines traditional use of GridView along with AJAX to get more data on demand for grid. I have used Anthem.Net AJAX library in my demo project. You can use library of your choice if you are not familiar with Anthem.Net.

I have used the technique from my article How to access gridview cell values on client side and How to highlight datagrid or GridView row on mouse over to raise the client side events for AJAX with appropriate values for that record from client side. Following code snippet from the demo project shows how I have added handlers for onmouseover and onmouseout eventd for the cells. In onmouseover event I pass ProductId value of the record which gets passed back to server during AJAX call. protected void OnRowCreated(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.Header)
{
if (String.Empty != m_strSortExp)
{
AddSortImage(e.Row);
}
}
if (e.Row.RowType == DataControlRowType.DataRow)
{
DataRowView drv = e.Row.DataItem as DataRowView;
if (null != drv)
{
Object ob = drv["ProductID"];
e.Row.Cells[0].Attributes.Add("onmouseover", "onMouseOnRow('" + ob.ToString() + "');");
e.Row.Cells[0].Attributes.Add("onmouseout", "onMouseOutOfRow();");
e.Row.Attributes.Add("onmouseover", "this.className='hightlighrow';");
e.Row.Attributes.Add("onmouseout", "this.className='normalrow'");
}
}
m_iRowIdx++;
}

AJAX and Anthem Usage
Following steps describe the steps to follow in using Anthem.Net. Most of this discussion is available in Anthem.Net InvokePageMethodsample project of this library.
Add a public method called GetGridRowHelp to your page so that it takes in ProductId value as parameter:
public String GetGridRowHelp(String strRecordId)
{
if (null != m_dsProducts)
{
Int32 iProdId = 0;
Int32.TryParse(strRecordId, out iProdId);
DataRow prodRow = GetProductDataRow(iProdId);
if (null != prodRow)
{
return String.Format("Price for {0} is {1:c}", prodRow["Name"], prodRow["ListPrice"]);
}
}
return "Could not find product " + strRecordId;
}
Apply the Anthem.Method attribute to the GetGridRowHelp method. Without this, it can't be invoked from clients:
[Anthem.Method]
public String GetGridRowHelp(String strRecordId)
{
........
}
Register the page with the Anthem manager when the page fires its Load event:
protected void Page_Load(object sender, EventArgs e)
{
Anthem.Manager.Register(this);
......
}
In event that gets fired when mouse moves over the image icon in grid view, call Anthem_InvokePageMethod which results in calling server-side GetGridRowHelp method:

The first argument to Anthem_InvokePageMethod needs to be the name of the method you want to invoke
The second argument is the array of parameters for that method
The third argument is a function that will get invoked here on the client when the server-side call back completes
The argument to the client-side call back function is a result object. It has a value and an error property. If an error occurred on the server, value will be null and error won't be:
On server side, we retrieve DataRow corresponding to the ProductId passed from client side, and construct our simple help message. When client call completes, this help message is set in a span and the div holding that span is made visible. In onmouseout event the div showing help message is hidden again.
This mixing of GridView with AJAX could not get any simpler than this. You can extent this technique to do more wonderful things with presentation of data in DataGrid or GridView

ATLAS FilteredTextBox Extender

2008-06-21T23:30:00.000-07:00

What is an extender? The AJAX Control Toolkit uses extenders to provide additional capabilities that go beyond what the normal ASP.NET controls can do out-of-the-box. This is because these extenders use client-side script to perform animations, transformations, or other cool effects. These features are available in DHTML, while some may be browser-specific; however, to the developer, the extender handles all the work through the script that it emits, and all we need to worry about is the setup of the extender.

Using the FilteredTextBox Extender

To use the toolkit, you have to download it (the link is in the References section), and unzip it in your Visual Studio 2005\Projects folder. Navigate to the SampleWebSite\bin directory to get to the AjaxControlToolkit.dll file, which contains all of the extenders. In the code sample, I used the following web configuration setup in the pages element:

<add

 tagPrefix="ajaxtoolkit"

 namespace="AjaxControlToolkit"

 assembly="AjaxControlToolkit" />

Using this following configuration, I setup a sample that allows the user to enter a phone number. The code segment is as follows:

Enter a Phone Number:

<asp:TextBox ID="txtPhoneNumber" runat="server" />

<ajaxtoolkit:FilteredTextBoxExtender

  ID="extPhoneNumber"

  runat="server"

  TargetControlID="txtPhoneNumber"

  FilterType="Numbers, Custom"

  ValidChars="-">

ajaxtoolkit:FilteredTextBoxExtender>

Notice that the textbox doesn't have anything special added to it; the extender emits script for it, which an extender is linked to it through the TargetControlID (a consistent property to target a control throughout the control library). The other properties that were used were:

FilterType - The filter type is an enumeration that supports multiple assignments separated by a comma. It has possible values of LowerCaseLetters, UpperCaseLetters, Numbers, and Custom. In the above example, I use Numbers and Custom options.
ValidChars - When using Custom FilterType, the ValidChars property contains a listing of characters that are the only ones allowed in the textbox.

Result

The effective result is that only numbers and the - character are allowed to be typed in to the textbox. No other values can be keyed in. However, validation is still needed to ensure that the values are in the correct order (this extender doesn't require the values be in any order). In the above example, I would have still needed that a RegularExpressionValidator be used to ensure a correct format. This is a way though, to ensure that the correct results are provided in your applications that you develop.

Another Example

How would you set this up for name? FilterType has a combination of UppercaseLetters and LowercaseLetters that can be used; however, this doesn't take care of the space. This means that the Custom option must be used as well, allowing for a ValidChars parameter of " ". Using this, you can also ensure that only the correct name data can be entered. The example is below:

Enter your Name:

<asp:TextBox ID="txtName" runat="server" />

<ajaxtoolkit:FilteredTextBoxExtender

  ID="extName"

  runat="server"

  TargetControlID="txtName"

  FilterType="UppercaseLetters,LowercaseLetters,Custom"

  ValidChars=" " />

When running the form, this filter actually restricts the keyboard from entering values outside this range. Only letters and spaces are allowed to be typed in. The extender adds a script reference that points to a script stored as an embedded resource in the DLL for the control library, and the reference is generated dynamically. Using this extender, you can see a means to make validation of data easier in your applications.

Introduction to Silverlight

2008-06-19T05:06:00.000-07:00

What is Silverlight?

Silverlight is a browser plug-in that that extends the web development experience far beyond the limitations of plain HTML and JavaScript. Being a Microsoft product, you might expect it to work best (or only) on Windows and Internet Explorer. So you may be pleasantly surprised to know that it works equally well on Windows and on the Mac, and it also works equally well on the Firefox and Safari web browsers. Since Silverlight is a client side technology, it doesn't matter what backend server software or platform you're running - even Apache/Linux will do just fine.

Version 1.0

Silverlight version 1.0 - scheduled for release this summer - is very comparable to Adobe Flash. It delivers high performance multimedia and animation capabilities that can blend seamlessly with HTML. It's capable of playing a variety of audio and video file formats, such as MP3, WMA, and WMV. It handles streaming quite well, so media can start playing immediately without having to wait for the entire file to download.

Silverlight's user interface is defined with a subset of XAML - an XML format shared with Windows Presentation Foundation (WPF). This facilitates vector based animations, a claim that goes beyond Flash's current capabilities. Silverlight's compiled object model can be navigated via JavaScript for seamless interaction between embedded Silverlight components and the page that hosts them.

When users encounter a Silverlight 1.0 enhanced web page for the first time, they'll be prompted with the quick & easy installation that's only about a 1.2 megabyte download.

You can download the beta version of Silverlight 1.0 now.

Version 1.1

While the multimedia and animation capabilities of Silverlight 1.0 are certainly great for graphic designers, Silverlight version 1.1 (currently in alpha) starts to provide the kind of business oriented functionality that the majority of web developers need.

Probably the most exciting feature of version 1.1 is the built-in cross platform subset of the .NET Framework. While you can still mix in as much (or as little) JavaScript as you'd like, you'll now have the option of running your own fully compiled .NET code within IE, Firefox, or Safari. Those developers who hate JavaScript should be thrilled to know they can now write their client side code in C#, VB.NET, or any other .NET language. This .NET code can interact with the browser's object model so it can manipulate the page's HTML in addition to interacting with any Silverlight user interface that may be embedded in the page. You'll now be able to replace slow performing JavaScript code with fully compiled .NET code that could easily execute hundreds of times faster.

A variety of useful classes are included in Silverlight 1.1 for working with cutting edge technologies like LINQ, generics, multithreading, and invocation of Windows Communication Foundation (WCF) web services. There's also support for XML manipulation, networking, I/O, collections, globalization, and JSON serialization.

ASP.NET support is also provided for things like personalization, profiles, role membership, and invocation of ASMX web services. On a related note, the next release of ASP.NET is expected to include a variety of tools for easing Silverlight development, including built-in controls that make it easy to embed Silverlight content.

Unfortunately there are currently no definite plans to include any significant number of controls in Silverlight 1.1 - not even a basic button control is currently in the mix. They do at least provide a control class that can be used to build your own controls, and alternately it's not terribly difficult to make basic controls using XAML and some custom code - but certainly we'd prefer not to have to write such basic code. Luckily there are several controls available in the separate Silverlight 1.1 Alpha SDK download.

Since Silverlight 1.1 is still only in alpha, its uncertain exactly what other functionality may ultimately make it into the release version. The current download size for this far more functional version of Silverlight hovers at around 4MB.

Future Versions

From my conversations with Silverlight mastermind Scott Guthrie and his merry band of genius underlings, they've got a lot of mouthwatering functionality planned for upcoming versions of Silverlight. General themes include a rich set of built-in controls, data binding support, XLINQ, RSS, Xml Serialization, Opera support, and improved layout management. And that's just for starters.

In general the vision is to transform Silverlight from its current 1.0 state of multimedia powerhouse into a highly productive business tool capable of powering rich applications of virtually every kind.

Even with all this extra functionality, Silverlight's team has a long term secret goal of keeping the download size under 5MB. Shhhh! Don't tell anybody!

Development Tools

Currently the lack of polished tools for developing Silverlight applications is its biggest hindrance. The next version of Visual Studio (codenamed Orcas) is expected to ship with rich Silverlight support. However, the current beta version of Orcas clearly still needs a lot of work before achieving this goal. If you're brave enough to be tinkering with the Orcas beta then you might as well download the Silverlight Tools Alpha add-on to try out its Silverlight development capabilities.

Microsoft's new Expression suite of products is currently closer to being in a finished state. They are presently more polished and less buggy than Orcas. Specifically, Expression Blend is probably the most valuable Expression product for Silverlight development. However, be forewarned that the Expression suite is intended more for graphic designers than software developers. Therefore Visual Studio-oriented developers should expect a significant learning curve.

Summary

Silverlight is a brilliant idea that still has a ways to go before it reaches its potential. Nevertheless, it should definitely be on every web developer's radar. It's a distinct possibility that Silverlight could be the future of web development. Imagine a world where web developers no longer deal with HTML, and instead write rich, compiled .NET code that runs everywhere as ubiquitously as HTML does now. If Microsoft plays its cards right, this will happen.

JavaScript with ASP.NET 2.0 Pages

2008-06-16T08:35:00.000-07:00

ASP.NET 2.0 has made quite a few enhancements over ASP.NET 1.x in terms of handling common client-side tasks. It has also created new classes, properties and method of working with JavaScript code. This article explores the enhancements and the various ways of injecting JavaScript programmatically into ASP.NET 2.0 pages.

Introduction

In ASP.NET 1.x days, many client-side tasks, such as tracking mouse events, setting page focus, displaying/hiding a section of page, was not directly supported by asp.net. This is because ASP.NET applications are server-based; all web control events are handled on the server side. The constant round trips to and from server often slows down work processes, and the page-refreshing often ensured a web form would to lose its focus or its scroll position. Therefore programmers still rely on a multitude of JavaScript to keep web pages nimble and responsive. However, in ASP.NET 1.x, injecting JavaScript always involves two steps and quite some code: First, you weave your JavaScript function into a string in your code-behind page; second, you use the Page class of your web form to register the script, using either the Page.RegisterStartupScript or the Page.RegisterClientScriptBlock method.

ASP.NET 2.0 has inherited some of the ASP.NET 1.x approaches of including JavaScript in a web form. Moreover, it has added many methods and properties to smooth and simplify the handling of some of the most common client-side tasks. It has also introduced new ways to include JavaScript on the server side or load JavaScript from resources. In this article will go into detail of the enhancements and the various ways of working with Script code in ASP.NET 2.0.

Client-Side Enhancements

In this section, we will consider three common client-side tasks that ASP.NET 2.0 have made as easy as setting properties of controls.

1. Setting focus to web controls

In ASP.NET 1.x, it is not possible to programmatically set focus to a web server control without a bit help from the JavaScript's function focus(). Here is how it was commonly done in C#:

//ASP 1.x method of setting focus to a specific control. You need

//to first pass the control's id as the parameter, then define the 

//JavaScript function in a string variable then call the Page class

//to register the script. You may use either RegisterStartupScript() 

//or RegisterClientScriptBlock() method.



private void SetFocus(String ctrlID)

{

// Build the JavaScript String

System.Text.StringBuilder sb = new System.Text.StringBuilder();

sb.Append("")



// Register the script code with the page.

Page.RegisterStartupScript("FocusScript", sb.ToString());

}

However, in ASP 2.0, there are three ways to dynamically set the focus to a specific control, all in just one line of code. You pass the control ID as the parameter and call the Page.SetFocus(control) method, which enables you to set the focus to a particular control immediately after a page is initiated or loaded.

void Page_Init(object sender, EventArgs e)

{

SetFocus(ControlToSetFocus);

}

Or you can call the Focus method that is available to all web controls. You can call it in the Page_load event or based on a user's response to set up a skip pattern. For example, if you have a TextBox web control called Textbox1, you may simply call:

TextBox1.Focus();

ASP 2.0 web forms also have a property called DefaultFocus. By setting the DefaultFocus property, you can set the focus to a desired control when page loads.

For example, the code below will automatically set the focus on TextBox2 when the web form is loaded:

<form defaultfocus="textbox2" runat="server">

<asp:textbox id="textbox1" runat="server"/>

<asp:textbox id="textbox2" runat="server"/>

form>

2. Popping up Message Boxes

Confirming with users before they take actions with potentially irreversible consequences like record deleting is a common practice, so is alerting users about important information with a JavaScript alert box. In ASP.NET 1.x, with either a delete column of a DataGrid, or a regular web control, we need to attach the JavaScript alert(msg) or confirm(msg) function to the control's attributes or register the script with the Page class.

For example, we can use the following code to add the alert script to a button control:

<script language="C#" runat="server">

protected  void Page_Load(object sender, EventArgs e){

  //Set the button's client-side onmouseover event

  btnClick.Attributes.Add("onClick", "alert('Ouch, you clicked me!');");

}

script>



<form runat="server">

<asp:button runat="server" Text="Click Me!" id="btnClick" />

form>

Or similarly we can attach the confirm(msg) script to a button.

<script language="C#" runat="server">

protected void Page_Load(object sender, EventArgs e){

  //Set the button's client-side onmouseover event

  btnDelete.Attributes.Add("onClick",

  "return confirm('You sure you want to delete the record?');");

}

script>



<form runat="server">

<asp:button runat="server" Text="Delete!" id="btnDelete" />

form>

However, with a ASP.NET 1.x DataGrid, we need to place the code for confirm messagebox in the DataGrid's OnItemDataBound or OnItemCreated event handler. The code below shows how this can be done in the OnItemDataBound event.

<script language="c#" runat="server">

private void DataGrid1_ItemDataBound(Object sender, DataGridItemEventArgs e)

{

  // First, make sure we're NOT dealing with a Header or Footer row

  If (e.Item.ItemType == ListItemType.Item ||

      e.Item.ItemType == ListItemType.AlternatingItem )

  {

    //Assume  the first column of DataGrid1 is the Delete ButtonColumn

    LinkButton deleteButton = e.Item.Cells(0).Controls(0);



    //We can now add the onclick event handler

    deleteButton.Attributes.Add("onclick",

    "javascript:return confirm('Are you sure you want to delete

       this record?')";

  }

}

script>



<form runat="server">

<asp:datagrid id="DataGrid1" runat="server"

  ...

  OnItemDataBound="DataGrid1_ItemDataBound">

  ...

asp:datagrid>

form>

In ASP.NET 2.0, to add a client-side message box is just a matter of setting the OnClientClick property, as the following:

<asp:Button ID=button1 runat=server

OnClientClick="return('Are you sure you want to delete this record')"

Text="Delete Record" />

However, with GridView, the approach is similar to that of ASP.NET 1.x in terms of adding a confirmation box before deleting a GridView row. That is, you have to attach the confirm() script to the attributes of the delete column. Only with ASP.NET 2.0, you need to place the confirmation script within the RowDataBound event handler.

<script language="c#" runat="server">

// ...

protected void GridView1_RowDataBound(object sender, GridViewRowEventArgs e)

{

  if (e.Row.RowType == DataControlRowType.DataRow)

  {

    //suppose you have a link button column

    LinkButton l = (LinkButton)e.Row.FindControl("LinkButton1");

    l.Attributes.Add("onclick",

    "javascript:return confirm('Are you sure you want to delete

       this record?'");

  }

}

script>

As an alternative, you can convert the CommandField to a TemplateField and add a Button with the onClientClick property set to confirm().

<form id="form1" runat="server">

<asp:SqlDataSource runat="server"

  ID="SqlDataSource2"

  ConnectionString="..."

  SelectCommand="SELECT [CategoryID], [CategoryName],

                [Description] FROM [Categories]"

  DeleteCommand="Delete from categories where categoryID=@categoryID">

  <DeleteParameters>

    <asp:Parameter Name=categoryID Type=int16 />

  DeleteParameters>

asp:SqlDataSource>



<asp:GridView ID="GridView2" runat=server AutoGenerateColumns="False"

datasourceid="SqlDataSource2" DataKeyNames=CategoryID>

<Columns>

  <asp:BoundField DataField="CategoryID"

    HeaderText="ID"

    readonly=true/>

    <asp:BoundField DataField="CategoryName" HeaderText="Name"/>

    <asp:BoundField DataField="Description" HeaderText="Description" />

    <asp:TemplateField HeaderText="Delete">

      <ItemTemplate>

        <asp:Button ID="deleteButton" runat="server"

          CommandName="Delete" Text="Delete"

          OnClientClick="return confirm('Are you sure you want

          to delete this record?');" />

      ItemTemplate>

    asp:TemplateField>

Columns>

asp:GridView>



...

3. Maintaining Page Scrolling Position

In ASP 2.0, it is very easy to maintain a web page's scrolling position across postbacks. To achieve this, simply add a page directive at the top of your webpage:

<%@ Page ... MaintainScrollPositionOnPostback="true" %>

However in ASP 1.x, it is not quite so simple, even though ASP.NET 1.x has a Smartnavigation page directive that supposedly enables you to achieve the same goal. But as noted in many online posts and publications, SmartNavigation has many known issues and it works only with Internet Explorer 5.5 or later. Several developers wrote some JavaScript code and wrapped the code inside a custom server control to work around the problem. For example, there is an article by Steve Stchur addressing this issue: Maintaining Scroll Position on Postback

Injecting JavaScript Code

ASP.NET 2.0 not only provides ways to simplify some of the most common client-side tasks, it also allows you to write and include your own JavaScript in a web form. There are three ways to do so:

Injecting script blocks directly into a web page
Including JavaScript on the server side
Embedding JavaScript in Resources

As mentioned above, in ASP.NET 1.x, to include script in a web page, you always have to take two steps:

Define the JavaScript in a string variable
Register with the Page class

In ASP.NET 2.0, there is a similar approach. However, instead of the Page class, it is recommended you register the script using the methods exposed by the ClientScript property of the Page class. ClientScript is an instance of a new ASP.NET 2.0 class called ClientScriptManager. Moreover, ClientScript has many more new methods to work with JavaScript.

Injecting Script blocks on demand

Script blocks on demand are code that execute only if a code-specific event is triggered on the client side. To inject script blocks on demand, use ClientScript.RegisterClientScriptBlock. The following example shows how to pop up a new window when the button btnPopUp is clicked using the RegisterClientScriptBlock method:

<script runat="server">

protected void btnPopUp_Click(object sender, EventArgs e)

{

  //Build a Pop Up JavaScript

  //please note the peculiar '/script' in the last line of the script string

  //This is to work around the problem that compiler would mistake the 

  //closing script tag as the outer script closing tag.

  //For details, please see

  //http://support.microsoft.com/default.aspx?scid=kb;EN-US;827420



  System.Text.StringBuilder sb = new System.Text.StringBuilder();

  sb.Append("");

  sb.Append("window.open('javascript.htm', 'CustomPopUp',");

  sb.Append("'width=200, height=200, menubar=yes, resizable=no');<");

  sb.Append("/script>");



  //register with ClientScript

  //The RegisterStartupScript method is also slightly different

  //from ASP.NET 1.x

  Type t = this.GetType();

  if (!ClientScript.IsClientScriptBlockRegistered(t, "PopupScript"))

    ClientScript.RegisterClientScriptBlock(t,"PopupScript", sb.ToString());

}

script>



<form id="form2" runat="server">

<asp:Button ID="btnPopUp" runat="server"

  Text="PopUp" OnClick="btnPopUp_Click" />

form>

Startup Script Blocks

Like the Page.RegisterStartupScript method with ASP.NET 1.x, ASP.NET 2.0 has ClientScript.RegisterStartupScript to execute JavaScript when the page first loads. The above example could be converted to:

// ...

Type t = this.GetType();

if (!ClientScript.IsStartUpScriptRegistered(t, "PopupScript"))

ClientScript.RegisterStartUpScript(t,"PopupScript", popupScript);

Including JavaScript on the server side

You can also include external JavaScript files via codebehind. Let's say you have a JavaScript file called myJavaScript.js, and you would like include it inside the web form by using the RegisterClientScriptInclude method, as shown in the following:

ClientScript.RegisterClientScriptInclude("MyScript","MyJavaScript.js")

This piece of code will inject the following JavaScript include in your html code generated by the server:

<script src="MyJavaScript.js" type="text/javascript">script>

Embedding JavaScript in Resources

In ASP.NET 2.0, you can also add your JavaScript or image files or CSS stylesheet as embedded resources. However, to do so, you must create a custom control, add necessary scripts or files to the project, then set the files property of Build Action as an embedded resources, as illustrated in the following screenshot:

For this article, I borrowed (however simplified) a custom control called AutoComplete Dropdownlist as an example. Briefly, to be able to access the JavaScript in the embedded resource, you need to take two steps: Declare the resource in the control's class file or in the AssemblyInfo.cs using the syntax:

[assembly: WebResource("{namespace}.{filename}", "{content-type}")]

And in our example, it would be:

[assembly: WebResource("WebControlLibrary1.AutoComplete.js", "text/javascript")]

By doing so, we mark the file as accessible through the WebResource.axd HTTP handler, then we may retrieve the actual file from the resources of the project's assembly by calling the method GetWebResourceUrl(type, webresource).

Now we can inject the JavaScript or other resource file by using the RegisterClientScriptInclude method.

protected override void OnPreRender(EventArgs e)

{

base.OnPreRender(e);

this.Page.ClientScript.RegisterClientScriptInclude("AutoComplete",

this.Page.ClientScript.GetWebResourceUrl(typeof(AutoCompleteDropDownList),

"WebControlLibrary1.AutoComplete.js"));

}

Summary

JavaScript is essential to keep web pages nimble and responsive. While ASP.NET 1.x has been cumbersome working with script, ASP.NET 2.0 has made great enhancements to remedy the limitations. It has made dealing with some of the most common client-side tasks as easy as setting control properties, and has introduced new classes and methods to allow injecting JavaScript into webforms more flexible.

.NET Framework 3.5 New Features

2008-06-15T01:15:00.000-07:00

.NET Framework 3.5 New Features

Faster .NET Framework execution	Base Class Library – New Class Additions	Language Integrated Query (LINQ)
1. Faster garbage collection 2. Smarter, faster NGen requiring smaller working set RAM 3. 64 bit client improvements 4. ThreadPool performance improvements 5. Security check caching during NGen	6. BigInteger, HashSet and DateTime2 types 7. NSA Suite ”B” and FIPs compliant cryptography 8. Lightweight Reader/Writer Lock Classes 9. Anonymous and Named Pipes IO Classes 10. Integration with Event Tracing for Windows 11. New Addin hosting model for extensibility	Deep integration of LINQ data-awareness into the programming languages and framework.
Workflow Enabled Services – Process and Messaging together	Web 2.0 Friendly and AJAX Enabled WCF Services	Visual Studio Developer Tools for WF, WCF and in Visual Studio “Orcas”
Using workflow to provide for durable and long-running services. New Tools, WF activities and new programming model classes have been added to simplify building workflow-enabled services using WF and WCF. This allows a .NET Framework developer to build business logic for a service using WF and expose messaging from that service using WCF. These improvements not only provide tools for this scenario but they reduce the amount of glue code that was previously required.	Ajax is a web development technique for making asynchronous exchanges of small amounts of data between browser and web service calls from the browser client script to the web server. A programming model is provided for building Ajax style web applications using WCF services. An HTTP programming model is also provided allowing for REST style web services.	Visual Studio”Orcas” has built in tools for web service authoring with WCF and for building workflow enabled software with WF. There are new project templates for WCF services, WF business logic, workflow enabled services, and AJAX services. The templates are conveniently set up to compile and run even before any custom code is added enabling .NET developers to get going quickly. There are also numerous other tools for developing with WF, WCF and WPF.
*More WS- Standards Support**	RSS and ATOM Syndication API	Partial Trust Support for WCF Hosting
Implementation in WCF of the latest OASIS specifications Web Services Atomic Transaction (WS-AtomicTransaction) 1.1, WS-ReliableMessaging 1.1, WS-SecureCOnversation and Web Services Coordination (WS-Coordination) 1.1.	Applications built using WCF will be able to easily expose syndicated data which can be consumed by an RSS or ATOM reader.	Partial trust on the vlient is provided for ASMX parity focussing mainly on partially trusted WCF applications deployed through click-once. Support is provided for basic HTTP binding provided that the application runs in the Internet zone permissions and have granted the apropriate WebPermission. Secure communication is possible through transport security only. All other features are not available to partially trusted applications including hosting services, duplex communications, non-HTTP transports, WS-* protocols and any WF use.
Rules Data Improvements	Built-in WPF tools for Visual Studio “Orcas”	Additional WPF Features and Improved Performance
The rules engine in WF is improved to add support for C# 3.0 extension metods, and for operator overloading . Also the ”new” operator is added to compete the base set of expression types.	The Visual Studio designer for WPF was previously released as a CTP. It is not integrated into the development environment and is significantly improved.	WPF has smoother animations, faster startup and better overall performance. There are also new data types available for data binding with LINQ. Better integration support is now provided for with codename “WPF/E”.

C# Object Clone Wars

2008-06-11T23:51:00.000-07:00

Cloning C# objects is one of those things that appears easy but is actually quite complicated with many "gotchas." This article describes the most common ways to clone a C# object.

Shallow vs. Deep Cloning

There are two types of object cloning: shallow and deep. A shallow clone copies the references but not the referenced objects. A deep clone copies the referenced objects as well.

Hence, a reference in the original object and the same reference in a shallow-cloned object both point to the same object. Whereas a deep-cloned object contains a copy of everything directly or indirectly referenced by the object. See wikipedia for a detailed explanation.

ICloneable Interface

The ICloneable interface contains a single Clone method, which is used to create a copy of the current object.

public interface ICloneable
{
   object Clone();
}

The problem with ICloneable is that the Clone method does not explicitly specify whether it is performing a shallow or deep copy, so callers can never be sure. Hence, there is some discussion about making ICloneable obsolete in the .NET Framework. The MSDN documentation seems to hint that Clone should perform a deep copy, but it is never explicitly stated:

The ICloneable interface contains one member, Clone, which is intended to support cloning beyond that supplied by MemberWiseClone… The MemberwiseClone method creates a shallow copy…

Type-Safe Clone

Another disadvantage of ICloneable is that the Clone method returns an object, hence every Clone call requires a cast:

Person joe = new Person();
joe.Name = "Joe Smith";
Person joeClone = (Person)joe.Clone();

One way to avoid the cast is to provide your own type-safe Clone method. Note that you must still provide the ICloneable.Clone method to satisfy the ICloneable interface:

public class Person : ICloneable
{
   public string Name;
   object ICloneable.Clone()
   {
       return this.Clone();
   }
   public Person Clone()
   {
       return (Person)this.MemberwiseClone();
   }
}

Clone Options

Following are some of the more common approaches to clone a C# object:

1. Clone Manually

One way to guarantee that an object will be cloned exactly how you want it is to manually clone every field in the object. The disadvantage to this method is it's tedious and error prone: if you add or change a field in the class, chances are you will forget to update the Clone method. Note that care must be taken to avoid an infinite loop when cloning referenced objects that may refer back to the original object. Here is a simple example that performs a deep copy:

public class Person : ICloneable
{
   public string Name;
   public Person Spouse;
   public object Clone()
   {
       Person p = new Person();
       p.Name = this.Name;
       if (this.Spouse != null)
           p.Spouse = (Person)this.Spouse.Clone();
       return p;
   }
}

2. Clone with MemberwiseClone

MemberwiseClone is a protected method in the Object class that creates a shallow copy by creating a new object, and then copying the nonstatic fields of the current object to the new object. For value-type fields, this performs a bit-by-bit copy. For reference-type fields, the reference is copied but the referred object is not; therefore, the original object and its clone refer to the same object. Note this works for all derived classes, and hence you only need to define the Clone method once in the base class. Here is a simple example:

public class Person : ICloneable
{
   public string Name;
   public Person Spouse;
   public object Clone()
   {
       return this.MemberwiseClone();
   }
}

3. Clone with Reflection

Cloning by Reflection uses Activator.CreateInstance to create a new object of the same type, then performs a shallow copy of each field using Reflection. The advantage of this method is it's automated and does not need to be adjusted when members are added or removed from the object. Also, it can be written to provide a deep copy. The disadvantage is it uses Reflection, which is slower and not allowed in partial trust environments. Sample code

4. Clone with Serialization

One of the easiest ways to clone an object is to serialize it and immediately deserialize it into a new object. Like the Reflection approach, the Serialization approach is automated and does not need to be adjusted when members are added or removed from the object. The disadvantage is that serialization can be slower than other methods including Reflection, and all cloned and referenced objects must be marked Serializable. Also, depending on what type of serialization you use (XML, Soap, Binary), private members may not be cloned as desired. Sample code here and here and here.

5. Clone with IL

A fringe solution is to use IL (Intermediate Language) to clone objects. This approach creates a DynamicMethod, gets the ILGenerator, emits code in the method, compiles it to a delegate, and executes the delegate. The delegate is cached so that the IL is generated only the first time and not for each subsequent cloning. Although this approach is faster than Reflection, it is difficult to understand and maintain. Sample code

6. Clone with Extension Methods

Havard Stranden created a custom cloning framework using extension methods. The framework creates a deep copy of an object and all referenced objects, no matter how complex the object graph is. The disadvantage is this is a custom framework with no source code (Update: source code now included, see comment below), and it cannot copy objects created from private classes without parameterless constructors. Another problem, which is common to all automated deep copy methods, is that deep copying often requires intelligence to handle special cases (such as unmanaged resources) that cannot be easily automated.

Google to Deliver GWT 1.5

2008-06-11T03:36:00.000-07:00

Google is expected to roll out the latest version of the Google Web Toolkit at its developer conference.

Google will hold its second major software developer conference May 28 and 29, delivering a host of new technology, services and advice for developers around the Google platform.

Among the new technology expected to be delivered at the event in San Francisco, known as Google I/O, will be a new version of the GWT (Google Web Toolkit), sources said. Google is expected to announce the availability of GWT 1.5 in some capacity.

The Google Web Toolkit makes it easier for Java developers to write high-performance Asynchronous JavaScript and AJAX (Asynchronous JavaScript and XML) applications in Java.

“You write your front end in the Java programming language and GWT compiles your source into highly optimized JavaScript,” said a description of GWT on Google’s Web site. “Writing Web apps today is a tedious and error-prone process. You spend 90 percent of your time working around browser quirks, and JavaScript's lack of modularity makes sharing, testing and reusing AJAX components difficult and fragile. It doesn't have to be that way.”

Although he did not address the issue of a GWT 1.5 announcement, Bruce Johnson, a Google software engineer and tech lead for GWT, said one of the biggest areas where Google has made a lot of progress recently is that “we can fully support the Java 5 system” with support for generics and annotations.

Another area of major progress is in performance. “With [GWT] 1.5, we’ve added a whole new set of compiler optimizations,” Johnson said. He added that “performance matters so much. With GWT, you can take a nice Java code base and compile it into JavaScript that runs faster than code you can write by hand.”

In addition, today any important application is going to be written and targeted at the browser, Johnson said. With the advent of AJAX, “you see a focus on higher functionality within the browser. But with JavaScript there are so many browser quirks that it’s like a minefield,” Johnson said.

He said fighting these browser quirks is not a good use of people’s time, “so we realized a tool needed to be invented. GWT takes the focus of using existing tools.”

Google also provides API libraries for GWT, including an API that supports its Gears online/offline browser extension. “We provide an out-of-the-box API in low-level JavaScript to provide a nice way to Gears-enable your apps,” he said.

In the future, areas of focus for GWT include delivering better tools for the platform, Johnson said. GWT currently supports all the major Java IDE (integrated development environments), but one area of focus might be to deliver a plug-in for Eclipse to make it even easier to use the open-source IDE with GWT. Google also plans to continue to drive performance with compiler optimizations and other things, Johnson said.

Adoption of GWT has been good, Johnson said. “We gauge it by the quality of the apps” being built with GWT, although the technology has had millions of downloads, he said.

Lombardi Software is one GWT user that has built some compelling technology with the Google tool. Lombardi provides BPM (business process management) technology and services to help customers with their process improvement initiatives. Lombardi products are built on open standards and provide ongoing prioritization, planning, visibility and control of business processes, said Wayne Snell, senior director of marketing at the company.

Snell said Lombardi is using GWT because “it offers the best platform for our engineers to quickly develop and easily maintain a true enterprise-class Web 2.0 application using standard Java tooling and skills.”

About two years ago, Lombardi decided to create a new product for the BPM market that combined easy-to-use process modeling and wiki-like collaboration for business users to document processes, Lombardi said. The current market was full of traditional client-server offerings that required the user to install the software locally and set up central servers if they wanted to collaborate with other users.

“So, we designed the world’s first enterprise-class Web 2.0 process modeling tool—Lombardi Blueprint,” Snell said. “We needed the user’s experience to be fast, highly interactive and easy enough to use by any business user.”

He said Lombardi looked at four or five different toolkits and even prototyped the mapping and diagramming views in Adobe Flash and the Dojo Toolkit before settling on GWT.

“The tooling for these other options wasn’t up to par compared to Java IDEs and the effort to maintain straight JavaScript or ActionScript would have become overwhelming over time,” Snell said. “In addition, we required an enterprise-class run-time that could handle several thousand concurrent users collaborating in real-time per server.”

He said Lombardi developers gain four main benefits from using GWT: support for tooling, hosted mode debugging, cross-compilation and the ability to use existing skills in Java.

“We can use the excellent modern tools and IDEs available for Java to write code for GWT,” Snell said. “Refactoring operations that would be very difficult to perform directly in JavaScript can be done easily when using GWT because the source code is Java. The tool chain for Java development is fantastic and lots of these tools can be applied to developing code for GWT. In the end, allowing our Java developers to use their tools of choice speeds development compared to alternatives.”

In addition, regarding cross-compilation, “we can compile the same GWT Java code to both JavaScript and Java byte code and run it both in a browser and on the server,” Snell said.

What's New in the .NET Framework 3.5

2008-06-10T22:17:00.000-07:00

.NET Compact Framework

The .NET Compact Framework version 3.5 expands support for distributed mobile applications by including the Windows Communication Foundation (WCF) technology. It also adds new language features such as LINQ, new APIs based on community feedback, and improves debugging with updated diagnostic tools and features.
For details about these new features and enhancements, see What's New in the .NET Compact Framework Version 3.5

ASP.NET

The .NET Framework 3.5 includes enhancements in targeted areas of ASP.NET and Visual Web Developer. The most significant advance is improved support for the development of AJAX-enabled Web sites. ASP.NET supports server-centric AJAX development with a set of new server controls and APIs. You can enable an existing ASP.NET 2.0 page for AJAX by adding a ScriptManager control and an UpdatePanel control so that the page can update without requiring a full page refresh.
ASP.NET also supports client-centric AJAX development with a new client library called the Microsoft AJAX Library. The Microsoft AJAX Library supports client-centric, object-oriented development, which is browser-independent. By using the library classes in your ECMAScript (JavaScript) you can enable rich UI behaviors without roundtrips to the server. You can mix the degree of server-centric and client-centric development to meet the needs of your application. Furthermore, Visual Web Developer includes improved IntelliSense support for JavaScript and support for the Microsoft AJAX Library.
ASP.NET and Visual Web Developer now support the creation of both ASMX and WCF-based Web services and the seamless use of either implementation from Web pages using Microsoft AJAX Library. Furthermore, server-side application services including forms authentication, roles management, and profiles are now exposed as Web services that can be consumed in WCF-compatible applications, including client script and Window Forms clients. ASP.NET enables all Web-based applications to share these common application services.
Other improvements in ASP.NET include a new data control, ListView, for displaying data; a new data source control, LinqDataSource, that exposes Language Integrated Query (LINQ) to Web developers through the ASP.NET data source control architectures; a new tool, ASP.NET Merge Tool (Aspnet_merge.exe), for merging precompiled assemblies; and tight integration with IIS 7.0. ListView is a highly customizable control (using templates and styles) that also supports edit, insert, and delete operations, as well as sorting and paging functionality. The paging functionality for ListView is provided by a new control called DataPager. You can use the merge tool to combine assemblies to support a range of deployment and release management scenarios. The integration of ASP.NET and IIS 7.0 includes the ability to use ASP.NET services, such as authentication and caching, for any content type. It also includes the ability to develop server pipeline modules in ASP.NET managed code and supports unified configuration of modules and handlers.
Other improvements in Visual Web Developer include multitargeting support, inclusion of Web Application Projects, a new Design view, new Cascading Style Sheets (CSS) design tools, and support for LINQ for SQL databases. Multitargeting enables you to use Visual Web Developer to target development of Web applications to specific versions of the .NET Framework, including versions 2.0, 3.0, and 3.5.
For more information, see What's New in ASP.NET and Web Development.

Add-Ins and Extensibility

The System.AddIn.dll assembly in the .NET Framework 3.5 provides powerful and flexible support to developers of extensible applications. It introduces a new architecture and model that helps developers with the initial work to add extensibility to an application and by ensuring that their extensions continue working as the host application changes. The model provides the following features:
Discovery
You can easily find and manage sets of add-ins in multiple locations on a computer with the AddInStore class. You can use this class to search for and obtain information about add-ins by their base types without having to load them.
Activation
After an application chooses an add-in, the AddInToken class makes it easy to activate. Simply choose the isolation and sandboxing level and the system takes care of the rest.
Isolation
There is built-in support for application domains and process isolation of add-ins. The isolation level for each add-in is in the control of the host. The system handles loading application domains and processes and shutting them down after their add-ins have stopped running.
Sandboxing
You can easily configure add-ins with either a default or customized trust level. Support includes Internet, Intranet, Full Trust, and “same-as-host” permission sets, as well as overloads that let the host specify a custom permission set.
UI Composition
The add-in model supports direct composition of Windows Presentation Foundation (WPF) controls that span application domain boundaries. You can easily allow add-ins to contribute directly to the UI of the host while still retaining the benefits of isolation, ability to unload, sandboxing, and versioning.
Versioning
The add-in architecture makes it possible for hosts to introduce new versions of their object model without breaking existing add-ins or impacting the developer experience for new ones.
For more information, see Add-ins and Extensibility.

Common Language Runtime

Collections

HashSet<(Of <(T>)>) provides high performance set operations to the .NET Framework. A set is a collection that contains no duplicate elements, and whose elements are in no particular order. For more information, see HashSet Collection Type.

Diagnostics

The EventSchemaTraceListener class provides tracing of end-to-end, schema-compliant events. You can use end-to-end tracing for a system that has heterogeneous components that cross thread, AppDomain, process, and computer boundaries. A standardized event schema (see Event Representation for Event Consumers) has been defined to enable tracing across these boundaries. This schema is shared by various tracing technologies, including Windows Vista diagnostics tools such as Event Viewer. The schema also enables the addition of custom, schema-compliant elements.
The EventSchemaTraceListener class is tuned for logging performance with implicit support for lock-free tracing.

I/O and Pipes

Pipes provide interprocess communication between any processes running on the same computer, or on any other Windows computer within a network. The .NET Framework provides access to two types of pipes: anonymous pipes and named pipes. For more information about pipes, see Pipes.

Garbage Collection

The GCSettings class has a new LatencyMode property that you can use to adjust the time that the garbage collector intrudes in your application. You set this property to one of the values of the new GCLatencyMode enumeration.
The GC class has a new Collect(Int32, GCCollectionMode) method overload that you can use to adjust the behavior for a forced garbage collection. For example, you can use this overload to specify that the garbage collector should determine whether the current time is optimal to reclaim objects. This overload takes a value from the new GCCollectionMode enumeration.

Reflection and Reflection Emit in Partial Trust

Assemblies that run with partial trust can now emit code and execute it. Emitted code that calls only public types and methods needs no permissions beyond the permissions demanded by the types and methods that are accessed. The new DynamicMethod(String, Type, array[]()[]) constructor makes it easy to emit such code.
When emitted code needs to access private data, the new DynamicMethod(String, Type, array[]()[], Boolean) constructor allows restricted access. The host must grant ReflectionPermission with the new RestrictedMemberAccess flag to enable this feature, which gives emitted code the ability to access private data only for types and methods in assemblies with equal or lesser trust levels. See Walkthrough: Emitting Code in Partial Trust Scenarios.
For reflection, a host grant of RestrictedMemberAccess similarly allows restricted use of methods that access private properties, call private methods, and so on, but only for target assemblies with equal or lesser trust levels.

Better Reader/Writer Lock

The new ReaderWriterLockSlim class provides performance that is significantly better than ReaderWriterLock, and comparable with the lock statement (SyncLock in Visual Basic). Transitions between lock states have been simplified to make programming easier and to reduce the chances of deadlocks. The new class supports recursion to simplify migration from lock and from ReaderWriterLock.

ThreadPool Performance Enhancements

Throughput for the dispatch of work items and I/O tasks in the managed thread pool is significantly improved. Dispatch is now handled in managed code, without transitions to unmanaged code and with fewer locks. The use of ThreadPool is recommended over application-specific thread pool implementations.

Time Zone Improvements

Two new types, DateTimeOffset and TimeZoneInfo, improve support for time zones and make it easier to develop applications that work with dates and times in different time zones. For a discussion of which type to use in particular situations, see Choosing Between DateTime, DateTimeOffset, and TimeZoneInfo.

TimeZoneInfo

The new TimeZoneInfo class largely supplants the existing TimeZone class. You can use TimeZoneInfo to retrieve any time zone defined in the registry, rather than just the local time zone and Coordinated Universal Time (UTC). You can also use this class to define custom time zones, to serialize and deserialize custom time zone data, and to convert times between time zones. For more information about developing applications that use the TimeZoneInfo class, see Times and Time Zones.

DateTimeOffset

The new DateTimeOffset structure extends the DateTime structure to make working with times across time zones easier. The DateTimeOffset structure stores date and time information as a UTC date and time together with an offset value that indicates how much the time differs from UTC.

SQL Server 2005 SP1 Users Face Vista, Longhorn Glitches

2008-06-08T02:48:00.000-07:00

Microsoft SQL Server 2005 customers will have to upgrade from Service Pack 1 to an as-yet unavailable Service Pack 2 before their applications will be able to work with Vista or the Longhorn server.Microsoft's corporate customers may have another reason to take their time upgrading to Vista. The latest one is that the current version, Microsoft's SQL Server 2005 Service Pack 1, released in April 2006, won't work with Vista or with the related Longhorn server.

These two operating systems will only support SQL Server 2005 SP2 "or later when it becomes available," according to Microsoft's SQL Server support Web pages. But there is no indication on these sites of how soon it will deliver SP2 or whether it will deliver the service pack at about the same time Vista and Longhorn are released.

Microsoft is also reminding customers that even older versions of the database, SQL Server 7.0 or 6.5, won't run on Vista or Longhorn and it might be a good time to update to SQL Server 2005 because it was "designed to take advantage of the upcoming security and performance enhancements" in the new operating systems.

Microsoft is urging customers using earlier versions of the database to obtain a trial version of SQL Server 2005 and Vista Beta 2 to test their applications to resolve any incompatibilities.

Furthermore, MDSE (Microsoft SQL Server Desktop Engine) 1.0 and 2000, free bare-bones versions of the database engine, also won't work with Vista.

Microsoft is telling customers that they should switch to the SQL Server 2005 Express Edition to replace MSDE if they plan to build a new application and distribute it with a database.

It's apparent that Microsoft is fine-tuning the marketing and distribution of virtually all the versions database product. This includes the mobile edition, which until recently has been known as SQL Server Everywhere.

The new name is SQL Server Compact Edition, as confirmed on the MSDN blog of Microsoft product manager Steve Lasker.

He wrote on Oct. 31 that the company is going back to an earlier name for the product because "compact" reflects its true nature.

"By leveraging an existing name, it allowed us to quickly turn around the name change and meet our commitment to ship in '06," Lasker wrote.

He also suggested the name change would help clear up any potential market confusion between the SQL Server Compact and Express editions.

C# Class Wrapping

2008-06-06T03:54:00.001-07:00

public class Class1
{
public Class1()
{
}
public int GetResult(ref string parameter1, int parameter2)
{
parameter1 = "Class1 did this";
return 1011;
}
}
public class Class2
{
public Class2()
{
}
public int GetResult(ref string parameter1, int parameter2)
{
parameter1 = "Class2 did this";
return 2048;
}
}
They don't do much, but the "trick" is to call the right one through her name, not actually knowing which one is it. // Replace "Remote1" with Name of the assembly where your class definitions are
string sClassName = "Remote1." + textBox1.Text;
System.Runtime.Remoting.ObjectHandle ObjHandle; // with this we "wrap" the right class
object ObjUnwrapped;
System.Reflection.MethodInfo PerformMethod;
object[] MethodParameters = new object[2]; // array of parameters
MethodParameters[0] = " "; // since it's ref string, we have to give it some value
MethodParameters[1] = 0; // integer
try
{
ObjHandle = Activator.CreateInstance("Remote1", sClassName);
ObjUnwrapped = ObjHandle.Unwrap(); // We "Unwrap the object
PerformMethod = ObjUnwrapped.GetType().GetMethod("GetResult"); // This is method we want
int Result = Convert.ToInt32(PerformMethod.Invoke( ObjUnwrapped, MethodParameters));
}
catch (Exception ex)
{
// if anything goes wrong, we end up in here
}

Great Computer Programming Quotes

2008-06-03T21:22:00.000-07:00

Computers:

"Computers are useless. They can only give you answers."
(Pablo Picasso)

"Computers are like bikinis. They save people a lot of guesswork."
(Sam Ewing)

"They have computers, and they may have other weapons of mass destruction."
(Janet Reno)

"That's what's cool about working with computers. They don't argue, they remember everything, and they don't drink all your beer."
(Paul Leary)

"If the automobile had followed the same development cycle as the computer, a Rolls-Royce would today cost $100, get a million miles per gallon, and explode once a year, killing everyone inside."
(Robert X. Cringely)

Computer Intelligence:

"Computers are getting smarter all the time. Scientists tell us that soon they will be able to talk to us. (And by 'they', I mean 'computers'. I doubt scientists will ever be able to talk to us.)"
(Dave Barry)

"I've noticed lately that the paranoid fear of computers becoming intelligent and taking over the world has almost entirely disappeared from the common culture. Near as I can tell, this coincides with the release of MS-DOS."
(Larry DeLuca)

"The question of whether computers can think is like the question of whether submarines can swim."
(Edsger W. Dijkstra)

"It's ridiculous to live 100 years and only be able to remember 30 million bytes. You know, less than a compact disc. The human condition is really becoming more obsolete every minute."
(Marvin Minsky)

Trust:

"The city's central computer told you? R2D2, you know better than to trust a strange computer!"
(C3PO)

"Never trust a computer you can't throw out a window."
(Steve Wozniak)

Software:

"Most software today is very much like an Egyptian pyramid with millions of bricks piled on top of each other, with no structural integrity, but just done by brute force and thousands of slaves."
(Alan Kay)

"I've finally learned what 'upward compatible' means. It means we get to keep all our old mistakes."
(Dennie van Tassel)

Operating Systems:

"There are two major products that come out of Berkeley: LSD and UNIX. We don't believe this to be a coincidence."
(Jeremy S. Anderson)

"19 Jan 2038 at 3:14:07 AM"
(End of the word according to Unix–2^32 seconds after January 1, 1970)

"Every operating system out there is about equal… We all suck."
(Microsoft senior vice president Brian Valentine describing the state of the art in OS security, 2003)

"Microsoft has a new version out, Windows XP, which according to everybody is the 'most reliable Windows ever.' To me, this is like saying that asparagus is 'the most articulate vegetable ever.' "
(Dave Barry)

Internet:

"The Internet? Is that thing still around?"
(Homer Simpson)

"The Web is like a dominatrix. Everywhere I turn, I see little buttons ordering me to Submit."
(Nytwind)

"Come to think of it, there are already a million monkeys on a million typewriters, and Usenet is nothing like Shakespeare."
(Blair Houghton)

Software Industry:

"The most amazing achievement of the computer software industry is its continuing cancellation of the steady and staggering gains made by the computer hardware industry."
(Henry Petroski)

"True innovation often comes from the small startup who is lean enough to launch a market but lacks the heft to own it."
(Timm Martin)

"It has been said that the great scientific disciplines are examples of giants standing on the shoulders of other giants. It has also been said that the software industry is an example of midgets standing on the toes of other midgets."
(Alan Cooper)

"It is not about bits, bytes and protocols, but profits, losses and margins."
(Lou Gerstner)

"We are Microsoft. Resistance Is Futile. You Will Be Assimilated."
(Bumper sticker)

Hardware:

"Hardware: The parts of a computer system that can be kicked."
(Jeff Pesis)

Programmers:

"Programmers are in a race with the Universe to create bigger and better idiot-proof programs, while the Universe is trying to create bigger and better idiots. So far the Universe is winning."
(Rich Cook)

"Most of you are familiar with the virtues of a programmer. There are three, of course: laziness, impatience, and hubris."
(Larry Wall)

"The trouble with programmers is that you can never tell what a programmer is doing until it's too late."
(Seymour Cray)

"That's the thing about people who think they hate computers. What they really hate is lousy programmers."
(Larry Niven)

"For a long time it puzzled me how something so expensive, so leading edge, could be so useless. And then it occurred to me that a computer is a stupid machine with the ability to do incredibly smart things, while computer programmers are smart people with the ability to do incredibly stupid things. They are, in short, a perfect match."
(Bill Bryson)

"Computer science education cannot make anybody an expert programmer any more than studying brushes and pigment can make somebody an expert painter."
(Eric Raymond)

"A programmer is a person who passes as an exacting expert on the basis of being able to turn out, after innumerable punching, an infinite series of incomprehensive answers calculated with micrometric precisions from vague assumptions based on debatable figures taken from inconclusive documents and carried out on instruments of problematical accuracy by persons of dubious reliability and questionable mentality for the avowed purpose of annoying and confounding a hopelessly defenseless department that was unfortunate enough to ask for the information in the first place."
(IEEE Grid newsmagazine)

"A hacker on a roll may be able to produce–in a period of a few months–something that a small development group (say, 7-8 people) would have a hard time getting together over a year. IBM used to report that certain programmers might be as much as 100 times as productive as other workers, or more."
(Peter Seebach)

"The best programmers are not marginally better than merely good ones. They are an order-of-magnitude better, measured by whatever standard: conceptual creativity, speed, ingenuity of design, or problem-solving ability."
(Randall E. Stross)

"A great lathe operator commands several times the wage of an average lathe operator, but a great writer of software code is worth 10,000 times the price of an average software writer."
(Bill Gates)

Programming:

"Don't worry if it doesn't work right. If everything did, you'd be out of a job."
(Mosher's Law of Software Engineering)

"Measuring programming progress by lines of code is like measuring aircraft building progress by weight."
(Bill Gates)

"Writing code has a place in the human hierarchy worth somewhere above grave robbing and beneath managing."
(Gerald Weinberg)

"First learn computer science and all the theory. Next develop a programming style. Then forget all that and just hack."
(George Carrette)

"First, solve the problem. Then, write the code."
(John Johnson)

"Optimism is an occupational hazard of programming; feedback is the treatment."
(Kent Beck)

"To iterate is human, to recurse divine."
(L. Peter Deutsch)

"The best thing about a boolean is even if you are wrong, you are only off by a bit."
(Anonymous)

"Should array indices start at 0 or 1? My compromise of 0.5 was rejected without, I thought, proper consideration."
(Stan Kelly-Bootle)

Users:

"Any fool can use a computer. Many do."
(Ted Nelson)

"There are only two industries that refer to their customers as 'users'."
(Edward Tufte)

Windows Communication Foundation Service (WCF )

2008-06-01T03:29:00.000-07:00

Windows Communication Foundation or WCF, is a robust programming model used to build applications that inter-communicate running in different platform and different system.

Why WCF ?

Today, when we build distributed applications, we have number of programming models. In present .net 2.0 we can use following concept to build distributed applications.

1. ASP.NET Web Services (ASMX)
2. Web Services Enhancements (WSE)
3. MSMQ / System. Messaging
4. Enterprise Services
5. Remoting

Each programming model has a different set of APIs, different feature sets, and a different core set of scenarios like,

1. ASP.NET Web Services (ASMX)

Our current Web services stack provides basic Web services support and interoperability with Web services running on non-Microsoft platform.

2. Web Services Enhancements (WSE)

A supported extension to the .NET Framework that provides end-to-end standards-based security for Web services.

3. System. Messaging

This namespace in the .NET Framework provides managed APIs to MSMQ, enabling developers to build asynchronous reliable distributed applications.

4. Enterprise Services

Provided through the System.EnterpriseServices namespace in the .NET Framework, Enterprise Services (or “ES”) provides managed APIs to COM+. COM+ provides component-based programming for doing enterprise critical functionality such as transaction.

5. Remoting

Provided through the System.Remoting namespace in the .NET Framework, .NET Remoting exposes the CLR type system remotely and provides location transparency for objects.

Features Table 1

Functionalities	Web Service	WSE	MSMQ	ES	Remoting
Inter Operability	YES	YES	NO	NO	NO
Security(End to End)	NO	YES	YES	YES	YES
Reliable	NO	NO	YES	NO	NO
Transaction	NO	NO	NO	YES	YES
Performance	NO	NO	YES	YES	YES

While these technologies provide a wide range of functionality, they exist in silos – isolated from one another. This creates an impedance mismatch across the technologies hindering our ability as developers to “compose” or combine functionality across them. For example:

We want to use .NET Remoting for its rich extensibility model, but we want an ES-style transaction to flow. How do we do this? Or we want to use ASMX for its interoperability, but you want to provide direct reliable messaging guarantees. How is this accomplished?

Today, scenarios like these that involve the combination of functionality across these technologies are more of a challenge than it should be. They often involve hundreds and sometimes thousands of lines of code to accomplish. With WCF, the challenges of silo programming models become a thing of the past. WCF provides you with a unified programming model that brings together the best aspects of existing Microsoft technologies. What this means is that, with WCF, you will no longer need to wonder “which technology do I use (ASMX, Remoting, etc)” when building a connected system. All of the application-to-application and intra-application communication for your connected will be handled by WCF. This unified programming model is exposed to you through the System. Service Model namespace. Since WCF provides all of the features of these existing Microsoft technologies, WCF supports all of the scenarios currently supported by these technologies.

Features Table 2

Functionalities	WCF
Inter Operability	YES
Security(End to End)	YES
Reliable	YES
Transaction	YES
Performance	YES

In addition, WCF enables new scenarios that are currently not possible or very hard to implement with existing technologies because WCF allows you to compose functionality across these existing technologies. For example, this means that you’ll be able to achieve secure, reliable, transacted Web services by combining/composing the functionality that previously existed in silos.

10 Things You Can Do To Motivate Your Team

2008-05-30T04:19:00.000-07:00

#1: Believe in your team’s objectives

Do you believe in what you want the team to accomplish? Do you think your goals are realistic? If not, rethink your position, because your team will sense your uncertainty. You may say the right words, but your body language and overall demeanor will give you away. On the other hand, if you truly are dedicated and believe in your goals, your team will sense it and will react accordingly.

#2: Model the behavior you want from the team

Don’t be a hypocrite — lead by example. You want your team to interact courteously and professionally with others, but do you do so yourself? If you ask them to put in extra hours, are you there along with them? Country artist Rodney Atkins sings about how one day, his four-year-old son said “a four-letter word,” but how later that night, all by himself he got on his knees and prayed. What did the son say when asked about how he learned to do both things? “I’ve been watchin’ you.”

#3: Keep a positive attitude

Don’t laugh. If you have these attitudes, how do you think your team will react? If you model a negative attitude, your team will pick it up. I know it sounds trite, but try to stay upbeat.

Doing so doesn’t mean being unrealistic. It does mean, however, that you try to look at the glass as being half full rather than half empty. Instead of saying, for example, “This project will never succeed because of issues 1, 2, and 3,” consider saying, “If we want this project to succeed, it’s critical that we resolve issues 1, 2, and 3.”

#4: Be clear about your goals

It’s hard for your team to accomplish its goals if those goals are unclear or unknown to them. More important, it’s hard to get them even to agree with those goals if they don’t know what they are. Make sure your team knows what you are expecting of them. If you can quantify your goals so that you can measure how well you did compared to what you expected, so much the better.

#5: Get feedback from the team members

Unless you hear from your team members, you may have little or no idea of how effective or clear you are. Few of us enjoy hearing bad news or criticism, but if there’s a problem in what we’re doing, it’s important that we hear it.

When discussing issues with the team, don’t shoot the messenger. When listening to a team member, try to separate the message and issue from the person. Similarly, when someone is offering suggestions or discussing issues, try to separate your own self and ego from the discussion. If you do shoot the messenger, all you will have done is make your team even more reluctant to talk frankly with you in the future.

#6: Set expectations

Make sure your team knows what to expect of you. If they do, there’s less chance that they’ll be unpleasantly surprised or disappointed.

Suppose, from the previous point, you had a discussion with a team member, who made a few suggestions. Some of them are workable (so that you could act on them), but others aren’t. Before having this discussion, it would be good to let your team know that while you will listen to them, you may or may not adopt all of their suggestions. One would hope they’d realize this already, but it’s best to be explicit. Furthermore, if you do adopt a suggestion, make sure everyone knows about it.

#7: Avoid mixed messages

Consultant and trainer Robert Mager, in his book Analyzing Performance Problems, discusses the uses of consequences and rewards in shaping human behavior. Specifically, he points out that to encourage desirable behavior, there must be positive rewards for it. Conversely, to discourage undesirable behavior, there must be consequences that result from it. Believe it or not, some people mix up these two points. Have you, as a parent, ever said to your child, “Any time you have problem, you can talk to Mommy or Daddy”? What happens when they do? You become irritated and yell at them, “Come back later! Can’t you see I’m busy?!” If you send similar mixed messages to your staff, you will make it harder for them to act the way you want.

#8: Know the difference between exhorting and belittling

It’s fine and good for you to want greater and higher quality results from your team. However, be aware of the line between exhorting someone to do better and belittling them because they aren’t right now. The latter might work, but the chances are greater that it might only create resentment and turn out to be counterproductive.

A couple of weeks ago, after a rehearsal of the choir I direct, I said to two young men, “I want to see confidence in your eyes when you’re singing.” I didn’t say to them, “You idiots, you don’t know the music.” In other words, in keeping with the positive/negative point discussed earlier, I focused on where I wanted them to be, rather than on the fact that they weren’t there right now.

#9: Correct in private

If personal issues of a team member are becoming a problem, address them with the person in private. Don’t embarrass the person by bringing it up in public. Such issues include attendance and punctuality, dress, and general professionalism.

What about a mistake involving work? Use discretion here. Using the choir example again: Suppose a person has an incorrect rhythm in a measure. I will just take a moment and work it out with that person in front of the group. If he or she gets it, fine. However, if he or she were consistently missing notes and rhythms, I would need to talk privately with that person to see what’s going on.

#10: Praise in public

When someone does something right, you probably are happy and want that person to continue doing it. You also probably want to make that person look good in front of the others, and for the others to be motivated to improve their own performance. For those reasons, recognize good work in public, rather than in private.

Other things being equal, of course, most people would prefer money and praise rather than praise alone. However, praise alone still can motivate, as long as you’re sincere and specific in what you’re praising. Generalities are unhelpful. Rather, focus on the specific action, and how it benefited the group.

In the case of the young men I mentioned earlier, I spoke to them again just a few days ago, after our last rehearsal, which went really well. I said to one of them, “Remember I told you I wanted to see confidence in your eyes? Well, I see it now.” To the other, I said, “You’ve been practicing, right?” When he nodded yes, I continued, “See what a difference it makes?”

"A Programmer is a device for turning coffee into code"

2008-05-29T00:05:00.000-07:00

On the merits of caffeine:

“As the mathematician Paul Erdos said, 'A mathematician is a device for turning coffee into theorems.' Academics, designers, programmers, and creative professionals everywhere will surely empathize.”

http://www.oreilly.com/catalog/mindhks/chapter/hack92.pdf

Power Toys for .NET Compact Framework 3.5 have been released

2008-05-26T08:51:00.000-07:00

The Power Toys for .NET Compact Framework 3.5 have just gone live at http://www.microsoft.com/downloads/details.aspx?familyid=C8174C14-A27D-4148-BF01-86C2E0953EAB&displaylang=en. If you downloaded a previous version, you might want to upgrade as there have been several bug fixes and improvements made to several of the tools.

What’s New

Many here are likely familiar with Remote Performance Monitor which shipped as a part of .NET Compact Framework 2.0 SP1 and the Heap Viewer extension that shipped 2.0 SP2. This time we’ve added the CLR Profiler based on the desktop tool, NetCF SVCUtil for making it easy to consume WCF services on device, and the App Config tool for creating config files on the fly. We’ve improved our remote tools platform to make it significantly easier to use: client side tools components now deploy automatically so tools “just work”, everything works with emulators and a common device manager UI is provided to keep tabs on all your remote devices.

Comprehensive documentation for the tools is now also provided out of the box in the form of a chm file.

The Tools

NETCF CLR Profiler – CLR Profiler is an instrumenting allocation profiler for NETCF applications. It provides detailed allocation visualizations, allocation callstacks and other views of the managed heap for diagnosing various memory management issues.

NETCF ServiceModel Metadata Tool – The .NET Compact Framework ServiceModel Metadata Tool (netcfsvcutil.exe) allows you to generate a Windows Communication Foundation (WCF) client proxy to help developers consume WCF services on device. Like svcutil.exe, which is the desktop version of the utility, netcfsvcutil.exe is a command-line tool that generates service model code from metadata documents and generates metadata documents from service model code.

App Configuration Tool - On-device tool for specifying what version of NETCF an application will run against (ie. Create config file), displaying installed versions of NETCF and displaying info about DLLs in the GAC.

Remote Logging Configuration Tool– The Logging Configuration Tool enables users to easily configure logging options on a NETCF device including: loader, interop, network, error and finalizer logs. (used to be a part of RPM)

Remote Performance Monitor and GC Heap Viewer – Provides real time counter data (ranging from Garbage Collector activity to type loading info) on a running NETCF application. The GC Heap Viewer feature allows you to capture the managed heap at any moment your app is running to view live references, and allows you to compare multiple snapshots to find memory leaks.

NETCF Network Log Viewer – A utility for viewing NETCF network log data.

Microsoft Windows XP Service Pack 3 Release

2008-05-25T03:06:00.000-07:00

Windows XP Service Pack 3 (SP3) is a rollup of the hotfixes and updates released since the Release to Manufacturing (RTM) of Windows XP Service Pack 2 (SP2). It does not include any new features.

1. Microsoft Windows XP Professional SP3 supports the same product key range available in the SP2c release. System builders who updated their images with SP2c will not have to re-image in order for the product keys on SP3 Certificates of Authenticity (COAs) to install the software successfully.

2. No extended product key range is available for Microsoft Windows XP Home and Starter editions. These two products will not have the product key range extended with this release. You can continue to use existing images without any issues.

3. No integrated SP3 release is available for Microsoft Windows XP Media Center Edition or Microsoft Windows XP Tablet PC Edition. The SP3 releases for these products will be available only through Windows Update.

http://oem.microsof t.com/script/ ContentPage. aspx?pageid= 564232&wa=wsignin1. 0

Windows 7( Vienna)

2008-05-24T10:59:00.000-07:00

Formerly known as Blackcomb and Vienna is the successor of Windows Vista. Windows 7 is expected to be released sometime in 2010

Windows 7 (formerly known as Blackcomb and Vienna) is the working name for the next major version of Microsoft Windows as the successor of Windows Vista.[1] Microsoft has announced that it is "scoping Windows 7 development to a three-year timeframe", and that "the specific release date will ultimately be determined by meeting the quality bar."[2] Windows 7 is expected to be released sometime in 2010.[3] The client versions of Windows 7 will ship in both 32-bit and 64-bit versions.[2] A server variant, codenamed Windows Server 7, is also under development.

C# String Tips

2008-05-24T05:46:00.000-07:00

Fill a String with Repeating Characters:

To fill a string with repeating characters, use the string class constructor. For example, to fill a string with twenty asterisks:

string s = new string( '*', 20 );

Check for Blank String:

A blank string can be represented by a null reference or empty string (String.Empty or ""). If you attempt to call a method on a null string, an exception will occur. Hence, to check for a blank string, you should use the new .NET v2.0 static function String.IsNullOrEmpty:

String.IsNullOrEmpty( s )

Reverse a String:

There has been extensive analysis on algorithms to reverse a string. The following is a good balance between speed and clarity and works well with Unicode and alternate character sets:

static public string Reverse( string s )
{
   char[] charArray = s.ToCharArray();
   Array.Reverse( charArray );
   return new string( charArray );

}

Compare Strings:

Because a string reference can be null, you should avoid using the equality symbol == or the Compare member function when comparing strings. Instead, use the static String.Compare method. This method has the advantage that it can handle null string references, compare strings ignoring case, and compare strings using a specific culture:

if (String.Compare( s1, s2, true ) == 0)

Convert String to Numeric Value:

Each numeric data type such as int, Int32, double, etc. has a static TryParse method that converts a string to that data type without throwing an exception. The method returns a bool whether the string contained a value with the specified data type. For example:

string s = "42″;
int i;
int.TryParse( s, out i );

String Right:

Noticeably absent from the string class is the Right method. But you can replicate it easily using the Substring method. Here is a simple method that wraps this up nicely:

static string Right( string s, int count )
{
   string newString = String.Empty;
   if (s != null && count > 0)
   {
       int startIndex = s.Length - count;
       if (startIndex > 0)
           newString = s.Substring( startIndex, count );
       else
            newString = s;
   }
   return newString;
}

IndexOf Ignoring Case:

The string's IndexOf methods are all case-sensitive. Fortunately, the Globalization namespace contains the CompareInfo class that includes a case-insensitive IndexOf method. For example:

using System.Globalization;

string s1 = "C# is a GREAT programming language.";
string s2 = "great";

CompareInfo Compare = CultureInfo.InvariantCulture.CompareInfo;
int i = Compare.IndexOf( s1, s2, CompareOptions.IgnoreCase );

Visual Studio 2008 and .NET Framework 3.5 Service Pack 1 Beta

2008-05-15T01:05:00.000-07:00

Earlier today we shipped a public beta of our upcoming .NET 3.5 SP1 and VS 2008 SP1 releases. These servicing updates provide a roll-up of bug fixes and performance improvements for issues reported since we released the products last November. They also contain a number of feature additions and enhancements that make building .NET applications better (see below for details on some of them).

We plan to ship the final release of both .NET 3.5 SP1 and VS 2008 SP1 this summer as free updates. You can download and install the beta here.

SQL Prompt Pro - now with customizable code layout

2008-05-15T00:58:00.000-07:00

SQL Prompt now has automatic code layout for easy code readability. No more eye-strain viewing unfamiliar scripts.

Combined with SQL Prompt parsing your queries as you type and suggesting keywords, table names, and join conditions (amongst others), writing and editing queries just got even easier.

Below shows some code before and after layout - the formatting can be customized to your own preferred style if desired.

Find out more about SQL Prompt Pro or try it for yourself.

Convert .NET data types using Parse and TryParse

2008-05-10T02:18:00.000-07:00

Convert .NET data types using Parse and TryParse

All base types in .NET Framework offer Parse method which is used to convert string value to different types. For example, you can convert string into int, double, short, float, boolean etc. Parse methods are very useful because programmers donâ€™t need to write any of their own conversion routines for common input scenarios. However, these methods also have some problems which programmers must need to keep in mind when they are writing their code which is using Parse methods.

Click to Read Full Tutorial

C# Free Video Programming Tutorials

2008-05-10T01:47:00.000-07:00

C# Free Video Programming Tutorials

Learn programming for free
Free Video lessons
Click here >>> C# Free Video Programming Tutorials

Windows Workflow Foundation Web Workflow Approvals Starter Kit

2008-05-05T00:46:00.000-07:00

http://www.microsof t.com/downloads/ details.aspx? FamilyID= A438A9B9- 9F15-42EC- 866F-2EA58E10DB3 6&displaylang= en

Overview

This starter kit is a Visual Studio 2005 (with updates for Visual Studio 2008) project that demonstrates using Windows Workflow Foundation for simple task-oriented workflow in an ASP.NET Web application. A workflow model is used to automate work order requests at a small example company. It includes three pre-defined roles which each play a part in the work order creation, approval and monitoring. The starter kit may be modified for other workflow models to suit other small Web-based task management systems.

http://www.microsof t.com/downloads/ details.aspx? FamilyID= A438A9B9- 9F15-42EC- 866F-2EA58E10DB3 6&displaylang= en

10 Things You Should Know About Microsoft's Silverlight

2008-05-05T00:44:00.000-07:00

http://www.computer world.com/ action/article. do?command= viewArticleBasic&articleId=9029725

Crafting a Web strategy is important for any thriving business. However, implementing that strategy with rich Internet applications is not always as easy as it should be. To ease that pain, Microsoft Corp. recently announced Silverlight, a cross-platform, cross-browser plug-in for Web application developers. The plug-in, currently available as a Release Candidate (which for all intents and purposes means it's released now), enables rich application development including media, interactivity and animation. The Silverlight plug-in currently works with Internet Explorer and Firefox Web browsers on Windows and with Firefox and Safari on Mac OS X.

For the complete article please follow the link below:

http://www.computer world.com/ action/article. do?command= viewArticleBasic&articleId=9029725

60 More AJAX- and Javascript Solutions For Professional Coding

2008-05-03T01:17:00.000-07:00

http://www.smashing magazine. com/2008/ 04/15/60- more-ajax- and-javascript- solutions- for-professional -coding/

This post presents over 60 new useful Ajax scripts, libraries and solutions which you can use in your future projects. License agreements can change from time to time — please read them carefully before using the script in a commercial web-application.

Useful Ajax Scripts
Mocha UI
Mocha is a web applications user interface library built on the Mootools javascript framework.

An Accessible Slider
“Recently we designed and developed an interface that required a slider control, which allows users to choose one or a range of values on a continuum. Values on a slider can represent anything from hours on a clock to the volume on a music player to a complex, proprietary data set. In its simplest form, the slider is displayed as an axis of values with a handle to drag and select a value, or two handles for selecting a range.”

FancyUpload
Swf meets Ajax. An upload widget that allows queued multiple-file upload including progress bars.

Coda Popup Bubbles
“When you move the mouse over the popup, this triggers a mouseout on the image used to trigger the popup being shown. I’ll explain (carefully) how to make sure the effect doesn’t fail in this situation.”

Facebook Style Input Box
The approach to re-create the autocomplete method of adding multiple recipients to messages used on Facebook. “I’d seen it in Facebook before, which has a really decent implementation of this concept (it work well, but it doesn’t respect any modern programming principles; basically, it’s a big tag soup with lots of inline Javascript)”

Rich Text Editor
The Rich Text Editor is a UI control that replaces a standard HTML textarea. It allows for the rich formatting of text content, including common structural treatments like lists, formatting treatments like bold and italic text, and drag-and-drop inclusion and sizing of images. The Rich Text Editor’s Toolbar is extensible via a plugin architecture so that advanced implementations can achieve a high degree of customization. The tool is based uponYahoo UI Library.

Further Ajax scripts

Maillist

An AJAX addon for your site, a Mail list. An email address can be submitted without having to reload the whole page.
ClickHeat
ClickHeat is an Ajax-powered visual heatmap of clicks on a page, showing hot and cold click zones. You can also use the heatmap generator outside ClickHeat for your own applications, using PHP and GD library.
Step by Step - Show and explain visitors what your page has for them.
You might have encountered interactive demos created with screencasting and screengrabbing software that explain an interface to users in a step-by-step manner. This is exactly what this script does for web sites.
FontSize slider
Enables visitors to define the font-size of the page.
Facebox
Facebox is a jQuery-based, Facebook-style lightbox which can display images, divs, or entire remote pages. It’s simple to use and easy on the eyes. Download the tarball, view the examples, then start enjoying the curves.

.NET 3.5 Enhancements Training Kit

2008-05-02T03:21:00.000-07:00

Brief Description

.NET Framework 3.5 Enhancements Training Kit containing Labs, Demos and PPTs

Overview

The.NET Framework 3.5 Enhancements Training Kit includes presentations,hands-on labs, and demos. This content is designed to help you learnhow to utilize the .NET 3.5 Enhancement features including: ASP.NETMVC, ASP.NET Dynamic Data, ASP.NET AJAX History, ASP.NET Silverlightcontrols, ADO.NET Data Services and ADO.NET Entity Framework.

http://www.microsof t.com/downloads/ details.aspx? FamilyID= 355C80E9- FDE0-4812- 98B5-8A03F5874E9 6&displaylang= en

20 Tips to Improve ASP.net Application Performance

2008-05-02T00:49:00.000-07:00

Not a .net Developer?

Are you an asp.net developer? If you aren't don't worry, If you are an ASP.net developer, listen up!
Get Ready for Massive Gains

There are certain things you should take into account when you are developing your applications. Over the last 12 years or so of working with asp and asp.net, I have learned to avoid and do certain things that increase your application performance by a massive amount! Below are my top 20 tips to improving ASP.net application Performance.

1. Disable Session State

Disable Session State if you're not going to use it. By default it's on. You can actually turn this off for specific pages, instead of for every page:

<%@ Page language="c#" Codebehind="WebForm1.aspx.cs" AutoEventWireup="false" Inherits="WebApplication1.WebForm1" EnableSessionState="false" %>

You can also disable it across the application in the web.config by setting the mode value to Off.

2. Output Buffering

Take advantage of this great feature. Basically batch all of your work on the server, and then run a Response.Flush method to output the data. This avoids chatty back and forth with the server.

<%response.buffer=true%>

Then use:

<%response.flush=true%>

3. Avoid Server-Side Validation

Try to avoid server-side validation, use client-side instead. Server-Side will just consume valuable resources on your servers, and cause more chat back and forth.

4. Repeater Control Good, DataList, DataGrid, and DataView controls Bad

Asp.net is a great platform, unfortunately a lot of the controls that were developed are heavy in html, and create not the greatest scaleable html from a performance standpoint. ASP.net repeater control is awesome! Use it! You might write more code, but you will thank me in the long run!

5. Take advantage of HttpResponse.IsClientConnected before performing a large operation

if (Response.IsClientConnected)
{
// If still connected, redirect
// to another page.
Response.Redirect("Page2CS.aspx", false);
}

What is wrong with Response.Redirect? Read on...

6. Use HTTPServerUtility.Transfer instead of Response.Redirect

Redirect's are also very chatty. They should only be used when you are transferring people to another physical web server. For any transfers within your server, use .transfer! You will save a lot of needless HTTP requests.

7. Always check Page.IsValid when using Validator Controls

So you've dropped on some validator controls, and you think your good to go because ASP.net does everything for you! Right? Wrong! All that happens if bad data is received is the IsValid flag is set to false. So make sure you check Page.IsValid before processing your forms!

8. Deploy with Release Build

Make sure you use Release Build mode and not Debug Build when you deploy your site to production. If you think this doesn't matter, think again. By running in debug mode, you are creating PDB's and cranking up the timeout. Deploy Release mode and you will see the speed improvements.

9. Turn off Tracing

Tracing is awesome, however have you remembered to turn it off? If not, make sure you edit your web.config and turn it off! It will add a lot of overhead to your application that is not needed in a production environment.

10. Page.IsPostBack is your friend

Make sure you don't execute code needlessly. I don't know how many web developers forget about checking IsPostBack! It seems like such a basic thing to me! Needless processing!

11. Avoid Exceptions

Avoid throwing exceptions, and handling useless exceptions. Exceptions are probably one of the heaviest resource hogs and causes of slowdowns you will ever see in web applications, as well as windows applications. Write your code so they don't happen! Don't code by exception!

12. Caching is Possibly the number one tip!

Use Quick Page Caching and the ASP.net Cache API! Lots to learn, its not as simple as you might think. There is a lot of strategy involved here. When do you cache? what do you cache?

13. Create Per-Request Cache

Use HTTPContect.Items to add single page load to create a per-request cache.

14. StringBuilder

StringBuilder.Append is faster than String + String. However in order to use StringBuilder, you must

new StringBuilder()

Therefore it is not something you want to use if you don't have large strings. If you are
concatenating less than 3 times, then stick with String + String. You can also try String.Concat

15. Turn Off ViewState

If you are not using form postback, turn off viewsate, by default, controls will turn on viewsate and slow your site.

public ShowOrdersTablePage()
{
this.Init += new EventHandler(Page_Init);
}

private void Page_Init(object sender, System.EventArgs e)
{
this.EnableViewState = false;
}

16. Use Paging

Take advantage of paging's simplicity in .net. Only show small subsets of data at a time, allowing the page to load faster. Just be careful when you mix in caching. How many times do you hit the page 2, or page 3 button? Hardly ever right! So don't cache all the data in the grid! Think of it this way: How big would the first search result page be for "music" on Google if they cached all the pages from 1 to goggle ;)

17. Use the AppOffline.htm when updating binaries

I hate the generic asp.net error messages! If I never had to see them again I would be so happy. Make sure your users never see them! Use the AppOffline.htm file!

18. Use ControlState and not ViewState for Controls

If you followed the last tip, you are probably freaking out at the though of your controls not working. Simply use Control State. Microsoft has an excellent example of using ControlState here, as I will not be able to get into all the detail in this short article.

19. Use the Finally Method

If you have opened any connections to the database, or files, etc, make sure that you close them at the end! The Finally block is really the best place to do so, as it is the only block of code that will surely execute.

20. Option Strict and Option Explicit

This is an oldy, and not so much a strictly ASP.net tip, but a .net tip in general. Make sure you turn BOTH on. you should never trust .net or any compiler to perform conversions for you. That's just shady programming, and low quality code anyway. If you have never turned both on, go turn them on right now and try and compile. Fix all your errors.

There are hundreds more where these came from, however I really feel that these are the most critical of the speed improvements you can make in ASP.net that will have a dramatic impact on the user experience of your application. As always if you have any suggestions or tips to add, please let us know! We would love to hear them!

Have web development!

How to Videos (Visual Studio 2008)

2008-04-30T06:10:00.000-07:00

Useful Videos/Material for VS 2008

Learn Visual Studio 2008

Visual Studio 2008 in Action

Looking For Cool Technology Toys?

2008-04-30T01:40:00.000-07:00

Elekit Robotic Arm - Everyone can use an extra hand and now you can actually get one. Elekit has created a fully programmable and workable USB Robotic Arm. It has five separate movements: grab/release, lift/lower, pivot sideways, and rotate wrist. Internal LED lights allow you to see it at work. This is a kit, so you actually have to do a small amount of assembly, but just keep thinking of the rewards of your labors when it passes you those Doritos that are not quite in reach. The Robotic Arm will be making its Japanese $80.00 debut in March in a limited addition from Elekit.

X7-G100 Game Board - Easy to Master... who needs a Joystick? The A4Tech X7-G100 Gaming Keyboard has 4 large swappable red rubber keys and a one-touch volume control. The G100 is heavier than a regular keyboard for stability and even better, it’s waterproof so you don’t have to worry about spilling your Bud while you thwart off the bad guys. It’s available at A4Tech for $29.00. Plug it into your USB and let the games begin.

USB Wireless Mouse - Just admit it... you'd much rather check your e-mail in the comfort of your own bed with a laptop than sit at some back-wrenching computer desk for hours on end. Thanko, most famous for their nifty plug-and-play warming gadgets, has developed the USB Wireless Mouse EZ that can actually be utilized in the air. Simply place and move your finger on the red light and watch the screen cursor respond. The button also functions as a single or double clicker. Compatible with both PC and Mac, it can be used as a normal optical mouse and can recharge its batteries while you work. Find this clever computer rodent at Thanko’s RareMono Shop for a price of $35.67.

USB Gadget Keeps Beverages Cool or Warm - There are cup warmers and then there are beverage coolers. USB.brando has managed to combine the two. Simply plug it into your USB connection, set it to chill for a 13 degree decrease or warm for a 29º increase, then wait 10 minutes. The gadget has a built-in fan and comes with a 98cm cable so you don’t have to worry about your coffee spilling into your keyboard if you're only mildly awake. Available at USB.brando for an inexpensive $24.00.

Kodak Easyshare AIO Inkjet Printers - The folks at Eastman Kodak are coming out with their own line of Easyshare All-In-One inkjet printers. Claiming to save up to 50% in professional printing costs, this translates into a 4x6 inch image for as inexpensive as ten cents a print. Kodak’s ink cartridges will cost you a mere $9.99 for black and $14.99 for color. You can get the 5100 and 5300 models at Best Buy beginning in March for $149.99 and $199.99 respectively. The deluxe 5500 will be available in April at the Kodak Store for $299.99.

Missile Launchers Cure Cubicle Boredom - Feeling claustrophobic in your Dilbertesque space at work? One alternative to hanging out at the water cooler is this missile launcher. With 3 feet of USB cable, this plug-and-play can move horizontally or vertically and comes with 3 foam missiles. It can shoot up to 20 feet, is compatible with Windows XP, and comes with sound effects software. Get two and not only will you save a few dollars, you can have wars with the cubicle next to you. The launcher can be found at Latest Buy for AU $39.99 (US $31.56) and the Twin Battle Pack is available for US $59.21.

ION Audio iTTUSB Turntable Converts Analogue to Digital - What top 10 list is complete without a musical gadget? The plug-n-play ION Audio iTTUSB Turntable connects to your PC or Mac and turns your vinyl collection into digital CD or MP3s. It will work with 33 1/3, 45, and 78 rpm records, and features high-speed recording, adjustable pitch, and anti-skate capabilities. It even includes an auxiliary line in to convert audio cassettes, and RCA outputs to play records through your speaker systems when you are done converting. The iTTUSB comes with stylus, 45 adapter, and 90-day warranty, and can be found at Sharper Image for $199.95.

Wood Contour Peripherals - This line of peripherals just oozes your inner CEO. Wood Contour offers luxury wood and stone keyboards, monitors, and mice. Each one is custom made from one piece of hardwood such as cherry, oak, ash, and mahogany, or Corian stone. You can even request personalizations such as your company’s logo or initial engraving. Class does not come cheap, but if you cannot afford a whole set, you can compromise with the company’s overstock of individual peripherals from prices beginning at $129.95. If you want to look like YOU should be the boss, visit Wood Countour for your own set of wood-be peripherals.

USB Lava Lamp - For a change of pace, hook up this nostalgic lava lamp to your computer. At a height of 6-inches and in colors of white, red, or blue, you can rest your eyes from the glare of your monitor for at least a few minutes. LavaWorld also carries USB glitter lamps, computer vacuums, and lava fans. The groovy gadgets are available at LavaWorld and various retail outlets at prices starting at $6.99.

Star Wars mimobots - Your new favorite USB storage keys just have to be mimobots. Launched in 2005, Mimoco has basically turned a simple concept into a collection with a cult following. In limited editions of 250 - 500 units, all are hi-speed and come in 256MB, 512MB, 1GB or 2GB capacities. You'll dig their Star Wars collection with Chewy and Darth Vader, now that they've recently added a Storm Trooper and R2-D2. Prices start at $79.95.