Dot Net - Pros & Cons

Html5 Web Designing softwares

2012-12-17T03:06:00.000-08:00

Adobe Muse: Adobe Muse is a website designing software which supports Html5. It’s basic concept is everyone can creates website without coding knowledge.

Microsoft Expression web 4: Microsoft Expression web 4 sp1 support Html5. But it need to install Html5 schema plugin. It has some installation guide.

Adobe Dreamweaver 11.0.3: Adobe Dreamweaver is a most famous Adobe web design software. Adobe Dreamweaver 11.0.3 update support Html5.

WebSite X5 Evolution 9: WebSite X5 Evolution 9 is a great tool to create html 5 websites. It’s offer to inntegrates JavaScript jQuery library ,UTF8 format.

Tumult Hype (support Mac OS only): Tumult hype is a most popular Html5 Web content making software for Mac OS. User can creates Animated presentations.

Adobe edge: Adobe edge is a most powerful adobe application to create html5 web content.

HTML5 Builder: html5 builder is a powerful application to create html5 based website and apps

Kendo UI: Kendo UI offer user to create Html5 web apps.

Easy Html5 Video Convertor: Easy Html5 Video is a free html5 video convertor Used to create html5 video

Photo Slideshow Maker: Photo Slideshow Maker offer user to create html5 photo slide show

Microsoft Excel cannot access the file is solved by creating a folder?

2012-11-05T07:13:00.000-08:00

Error:
Microsoft Office Excel cannot access the file 'c:\inetpub\wwwroot\Timesheet\App_Data\Template.xlsx'. There are several possible reasons:

The file name or path does not exist.
The file is being used by another program.
The workbook you are trying to save has the same name as a currently open workbook.

Solution:

Create directory "C:\Windows\SysWOW64\config\systemprofile\Desktop " (for 64 bit Windows) or "C:\Windows\System32\config\systemprofile\Desktop " (for 32 bit Windows)
Set Full control permissions for directory Desktop (for example in Win7 & IIS 7 & DefaultAppPool set permissions for user "IIS AppPool\DefaultAppPool")

How to find the Query Execution Time

2012-10-11T03:45:00.003-07:00

One method is to save the time before and after the query and to calculate the difference, something like this:

DECLARE @start_time DATETIME, @end_time DATETIME
SET @start_time = CURRENT_TIMESTAMP

-- query goes here

SET @end_time = CURRENT_TIMESTAMP
SELECT DATEDIFF(ms, @start_time, @end_time)

WCF Books

2012-10-09T23:13:00.000-07:00

Programming WCF Services, 2nd Edition: Programming WCF Services will teach you how to design and develop SOA-WCF-based applications. You will need to be an experienced developer who has a fair understanding of .NET and C# 2.0. A couple of points about Programming WCF Services, first, this isn't a beginners book; the author dives down into advanced material in spots almost without notice. If you want to become proficient using WCF, you will be buying this book eventually. You will find that this book will become both a reference as well as well as a guide.

Author: Juval Lowy

ISBN: 978-0-596-52130-1

Wrox-Professional WCF Programming: This book is very good for beginners. This books covers all the topics in WCF in general. I will recommend this book, for initial stage of learning.

Author: Scott Klein

ISBN: 9780470089842

Microsoft Windows Communication Foundation Step by Step: Covering the concepts and details necessary to enable you to build connected solutions, this book offers hands-on guidance for creating the Web services you need to implement robust business applications for Windows. Teach yourself the essentials of Windows Communication Foundation-one step at a time. With this practical tutorial, you get hands-on guidance for creating the Web services you need to implement robust business applications for Windows.

Author: John Sharp

ISBN: 9780735623361

Pro WCF: Practical Microsoft SOA Implementation Book Description: This is also a very good book. The book covers all the WCF topics in depth while using a lot of examples schemas and screenshots. This is a great book about how to develop WCF services. I really recommend this book, but I like juval's more.

Author: Chris Peiris, Dennis Mulder, Shawn Cicoria,

ISBN: 1590597028

Microsoft Windows Communication Foundation: Hands-on: You will gain a comprehensive understanding of how to apply the Windows Communication Foundation to almost any distributed computing problem, from enterprise scale to peer-to-peer. Most importantly, after reading the book and working through the examples, you will actually have considerable experience using WCF, because the book takes you through the steps of actually building Windows Communication Foundation solutions.

Author: Craig McMurtry

ISBN: 0672328771

Learning WCF: This also one of the nice book from O'Relliy. One of my great architect also recommend this book.

Author: Michele Leroux Bustamante

ISBN: 978-0-596-10162-6

C# - Threading

2012-09-14T02:06:00.001-07:00

In itself, this is a huge topic. Most easy-to-apply, synchronization-related optimizations focus on minimizing the amount of code executing inside synchronized blocks, which may involve moving some code from inside to outside such blocks. In some cases, thoughtful programming may allow elimination of synchronization entirely from a class (see "Immutable Objects").

Performing a multithreaded micro-benchmark is more complicated than running a simple loop. In the simplest method, multiple threads are spawned, each looping over the benchmarked code; the reading is not started until all threads are successfully executing the code, and is terminated before the threads are shut down.

Thread Reuse
Newbie programmers make the common mistake of spawning a new thread for every request or other action. This can result in worse performance than using a single-threaded approach; the relative performance degradation is worse the quicker the individual requests can be serviced.

Writing Your Own Threading Code
Even better than the .NET thread pool, with its dependence on delegates, is to write your own threading code. Instead of using QueueUserWorkItem(), you typically write your own queueing code to coordinate work items. This also allows other benefits such as priority-based queueing.

Immutable Objects
Immutable objects are objects in which the data cannot be changed. In most cases, this is achieved by setting all fields in constructor methods and providing only property getters and/or methods that retrieve data from the object, without any mutator logic whatsoever. Many classes in the .NET Common Type System are immutable: System.String, System. Drawing.Font, etc. In addition, care should be taken that any values returned from property accessors, etc. are immutable as well. Otherwise, this data may be copied to insure the integrity of the object itself. Example 11 shows the performance benefit of immutable objects over synchronization.

Data Copying
This flies in the face of the advice given earlier, to minimize the use of objects. However, it's really the other side of the coin from immutable objects. Object copying allows you to use the data in a non-immutable object, but in a way that still completely avoids synchronization. The more highly multithreaded the environment, the more strategies like this make sense.

Read-Write Locks
Synchronization issues in managed code mirror those in databases. In some situations, optimistic concurrency strategies can be used; in some dirty reads are acceptable, etc. For situations in which a structure is seldom updated and often read, the ReaderWriterLock class can give significant performance benefits over simple synchronization. It allows either multiple read access or single write access at once. Example 12 compares ReaderWriterLock to simple synchronization in a read-heavy scenario.

C# - Working With Strings

2012-09-14T02:05:00.000-07:00

Don't Use String.Format() to Concatenate Strings
While string-formatting routines built into .NET are very useful for globalization and other tasks, they're not meant to be used for appending strings to each other. Example 7 tests the performance difference between String.Format() and string concatenation.

Use StringBuilder to Build Strings Inside Loops
The StringBuilder class is basically an array list for string fragments; the StringBuilder takes care of expanding its internal char array, hiding this from the user. The use of this class is also specially optimized by the .NET compiler, making it impossible to duplicate this functionality with equivalent performance (for instance, by manipulating char arrays directly and converting to a string afterwards). Example 8 shows the performance benefit of building a large string using StringBuilder instead of string concatenation.

Don't Use StringBuilder to Concatenate Small Numbers of Strings
Many .NET developers who consider themselves well-versed in performance matters advocate the use of the StringBuilder class whenever possible. However, it's not the fastest approach for concatenating small numbers of strings. Actually, any number can be combined in a single statement, although the performance benefit tends to dwindle above five or six substrings. This is due to instantiation and destruction overhead for the StringBuilder instance, as well as method-call overhead involved in calling Append() once for every added substring and ToString() once the string is built. What are the alternatives? Plus-sign concatenation and the String.Concat() method are equivalent; I prefer plus signs for readability. Note that this cannot be used across loops because the entire concatenation must occur within a single statement. Example 9 tests String.Concat() vs. StringBuilder for various numbers of substrings.

Don't Be Afraid to Use String Literals
Many developers incorrectly assume that a new object is created for every string literal, and, therefore, avoid their use. In some cases, using string literals directly in your code is a better approach than using string constants! It can make the code easier to understand and has no adverse impact on performance. This is due to the use of the .NET interned string table; this table maintains a String instance for every known string and reuses this instance whenever the same character sequence is used as a literal. See the documentation of the String.Intern() method for more details. Example 10 compares string literals to the use of string constants.

C# - Working with Collections

2012-09-14T02:03:00.001-07:00

Avoid Overuse of Collections
This might sound strange, but I'm not advocating working without data structures. The fact is, I've seen collections used many times when they don't actually simplify the code or provide any benefit at all. The single biggest avoidable use of collections is the use of an ArrayList when a simple array would suffice. It should be obvious that there's no way that calling a collection method - which may do significant work under the covers - can compare to something as simple as an array access for performance. See Example 3 for more information.

For vs ForEach
The rumor abounds that the foreach loop is bad for performance. The truth is actually a little more complicated. Basically, foreach involves no performance penalty when used against arrays. However, when used against lists it involves the same overhead as creating an enumerator and using it within a try/catch block! Ildasm.exe may come in handy here to see what's going on. This isn't a complete killer, but if you do enough list access you may want to avoid it. Example 4 compares the two statements for access against an array and an ArrayList.

Enumerators: Don't Go Overboard
Just because the possibility exists for the enumerating of a collection doesn't mean you have to do it. For instance, the ArrayList class is useful as an array replacement; one of its best features is indexed element access. By using an enumerator with ArrayList, you hide its most useful features and introduce needless overhead. Example 5 shows the performance difference between indexed access and the use of an enumerator.

Avoid Overuse of Collection Wrappers
A peek at the code in classes such as ArrayList shows that, to implement synchronized, fixed-size, and read-only versions of these, methods such as Synchronized() actually create a new wrapper list around the original one (this scheme was copied from Java). While this is nice from certain design standpoints, it degrades performance; the method-call overhead for each operation is multiplied. For a fixed-size, synchronized ArrayList, this overhead is tripled! Chances are, if you're working with a collection and need synchronization, the code using the collection is already synchronized. In any case, simply locking on the collection itself around every access turns out to be faster than using a synchronized wrapper. Example 6 compares the use of a synchronized ArrayList with synchronizing access to an ArrayList.

C# - Properties, Methods, and Delegates

2012-09-14T02:02:00.003-07:00

Avoiding Overuse of Property Getters and Setters
Most people don't realize that property getters and setters are similar to methods when it comes to overhead; it's mainly syntax that differentiates them. A non-virtual property getter or setter that contains no instructions other than the field access will be inlined by the compiler, but in many other cases, this isn't possible. You should carefully consider your use of properties; from inside a class, access fields directly (if possible), and never blindly call properties repeatedly without storing the value in a variable. All that said, this doesn't mean that you should use public fields! Example 1 demonstrates the performance of properties and field access in several common situations.

About Delegates
Delegates are slower to execute than interface methods. Delegates are often used to introduce a level of indirection in code, but in almost all cases interfaces allow a cleaner design. Of course, it's impossible to completely shun delegates; the entire event-handling paradigm in .NET is based on them. Example 2 compares the performance of delegates and direct method calls.

Minimizing Method Calls
The .NET compiler is capable of performing many optimizations for release builds. One of them is called "method inlining." If method A calls method B and certain other conditions are met, such as the code in method B being small enough, the code from B will be copied into A during compilation. However, .NET won't or can't inline certain types of methods, such as virtual methods or methods over a certain size. Each method invocation/property access entails significant overhead, such as the allocation of a stack frame, etc. Of course, you should never repeatedly call a method for the same result on purpose, but you should also be mindful of the impact of method calls in general.

Using the 'Sealed' Keyword
Wherever extensibility is not required, you should use the sealed keyword. This makes your design easier to understand, as someone can tell at a glance if a certain class or method isn't meant to be extended or overridden. It also increases the chances that the compiler will inline code.

C# - Working with Objects and Value Types

2012-09-14T02:01:00.000-07:00

Objects: A Double Whammy
Objects are expensive to use, partly because of the overhead involved in allocating memory from the heap (which is actually well-optimized in .NET) and partly because every created object must eventually be destroyed. The destruction of an object may take longer than its creation and initialization, especially if the class contains a custom finalization routine. Also, the garbage collector runs in an indeterministic way; there's no guarantee that an object's memory will be immediately reclaimed when it goes out of scope, and until it's collected, this wasted memory can adversely affect performance.

The Garbage Collector in a Nutshell
It's necessary to understand garbage collection to appreciate the full impact of using objects. The single most important fact to know about the garbage collector is that it divides objects into three "generations": 0, 1, and 2. Every object starts out in generation 0; if it survives (if at least one reference is maintained) long enough, it goes to 1; much later, it transitions to 2. The cost of collecting an object increases with each generation. For this reason, it's important to avoid creating unnecessary objects, and to destroy each reference as quickly as possible. The objects that are left will often be long-lived and won't be destroyed until application shutdown.

Lazy Instantiation/Initialization
The Singleton design pattern is often used to provide a single global instance of a class. Sometimes it's the case that a particular singleton won't be needed during an application run. It's generally good practice to delay the creation of any object until it's needed, unless there's a specific need to the contrary - for instance, to pre-cache slow-initializing objects such as database connections. The "double-checked locking" pattern is useful in these situations, as a way to avoid synchronization and still ensure that a needed action is only performed once. Lazy initialization is a technique that can enhance the performance of an entire application through object reduction.

Avoiding Use of Class Destructors
Class destructors (implemented as the Finalize() method in VB.NET) cause extra overhead for the garbage collector, because it must track which objects have been finalized before their memory can be reclaimed. I've never had a need for finalizers in a purely managed application.

Casting and Boxing/Unboxing Overhead
Casting is the dynamic conversion of a type at runtime to another, and boxing is the creation of a reference wrapper for a value type (unboxing being the conversion back to the wrapped value type). The overhead of both is most heavily felt in collections classes, as they all - with the exception of certain specialized ones like StringDictionary - store each value as an Object. For instance, when you store an Int32 in an ArrayList, it is first boxed (wrapped in an object) when it is inserted; each time the value is read, it is unboxed before it is returned to the calling code.

This will be fixed in the next version of .NET with the introduction of generics, but for now you can avoid it by creating strongly typed collections and by typing variables and parameters as strongly as possible. If you're unsure about whether or not boxing/unboxing is taking place, you can check the IL of your code for appearances of the box and unbox keywords.

Trusting the Garbage Collector
Programmers new to .NET sometimes worry about memory allocation to the point that they explicitly invoke System.GC.Collect(). Garbage collection is a fairly expensive process, and it usually works best when left to its own devices. The .NET garbage collection scheme can intentionally delay reclamation of objects until memory is available, and in particular longer-lived objects (those that make it to generation 1 or 2) may not be reclaimed for an extended period. Even a simple "Hello, world!" console application may allocate 15 MB or more of memory for its "working set." My advice: don't call GC.Collect() unless you really know what you're doing.

AJAX Calendar Extender IE8 Bug

2012-09-02T06:58:00.003-07:00

The calendar extender that comes with the AJAX Control Toolkit has a bug in IE8 whereby the "left/right" arrows to scroll through months do not work.

This is caused by the fact that the ‘title’ div spans the full width of the control and so the links end up behind this div.

To fix this problem, add the following line to your stylesheet:

.ajax__calendar_title {width:140px; margin:auto; }

SQL SERVER – Reset sa Password

2011-12-26T09:09:00.001-08:00

1.Open the SQL Server express management studio
2.Connect to SQL Server using windows authentication
3.Right click the server name and choose properties
4.Go to security tab. Change server authentication to “SQL Server and Windows Authentication mode”
5.Click OK and restart SQL Server
6.Go to SQL Server studio management express
7.Expand the server and choose security and expand logins
8.Right click on SA, from properties modify the password and confirm password

Or

To reset the sa password, you can make the following:
1. Login to the SQL Server box as the Administrator.
2. Run SQL Server Enterprise Manager.
3. Right-click the server name and choose ‘Edit SQL Server Registration properties’.
4. Choose ‘Use Windows authentication’ and click OK button.
5. Expand a server, expand a Security and click Logins.
6. Double-click the sa login and specify new password on the General tab. (enable Login to)

Or You Can Use

USE [master]
GO
ALTER LOGIN [sa] WITH DEFAULT_DATABASE=[master],
DEFAULT_LANGUAGE=[us_english], CHECK_EXPIRATION=ON, CHECK_POLICY=ON
GO
USE [master]
GO
ALTER LOGIN [sa] WITH PASSWORD=N’’ MUST_CHANGE
GO

Or

From a command prompt
OSQL -S -E
1> EXEC sp_password NULL, ‘’, ‘sa’
2> GO

Pragmatic Bookshelf - Mastering DOJO

2010-05-12T23:49:00.001-07:00

Pragmatic Bookshelf - Mastering DOJO - Javascript and Ajax Tools for Great Web Experience

To download Click Here

OReilly Dojo The Definitive Guide

2010-05-12T23:35:00.001-07:00

OReilly Dojo The Definitive Guide

To download Click Here

Professional JavaScript Frameworks - Prototype YUI, ExtJS, Dojo, MooTools 2009

2010-05-12T19:57:00.001-07:00

Professional JavaScript Frameworks - Prototype YUI, ExtJS, Dojo, MooTools 2009

To download Click Here
www.amaderforum.com

Visual Studio 2008 Tips & Tricks for Developers

2009-01-25T09:55:00.000-08:00

Working in Full Screen Mode in Visual Studio
1. Alt+Shift+Enter is the shortcut to enter to fullscreen mode in Visual Studio
2. Its sometimes really helpful and more appealing for developers to work in full screen mode

Editing
1. For Copying a line in the IDE just go to the start of the line and press Ctrl+C,there is no need to select anything
2. For Pasting a line just go to the start of the line and just press Ctrl+V
3. For Deleting a line just go to the start of the line and press Ctrl+X, this is not actually delete but its similar to cut if you do Ctrl+X on current line and go to some other place in your code and do Ctrl+V then it will paste the same line there.

Expanding and Collapsing the code units
1. This nice little shortcuts has saved me a lot of time.Whenever i am working on a large piece of code i always get confused and make some changes in other Method or property because they were looking similar.
2. But now with this shortcut i collapse one method as soon as it is finished.
3. The shortcut is Ctrl+M+M.
4. Just go to the beginning or end of the method or property or any code block and hit the shortcut it will expand or collapse the code block comparing to its present state.
5. If you want to collapse all your code units or blocks to their definitions then the shortcut to achieve this is Ctrk+M+O or Ctrl+M Ctrl+O.This is also a very handy shortcut which helps a lot in development.

Automatic Text Indentation and Formatting
1. This shortcut helps me to write beautiful and decorative code which is easy to understand by any person.
2. Shortcut is just press Ctrl+K+D.
3. This works not only in C# and VB code behind but it works well in aspx pages.
4. If you want to just format the selected piece of code then just press Ctrl+K+F

Microsoft Unveils Next Version of Visual Studio and .NET Framework

2008-09-29T21:35:00.001-07:00

Reveals extensive enhancements for simplified application life-cycle management, provides sneak peek at all key focus areas for Visual Studio 2010 and the .NET Framework 4.0.

Microsoft Corp. today provided the first look at the next version of its developer tools and platform, which will be named Visual Studio 2010 and the .NET Framework 4.0. Microsoft described the next release through the following five focus areas: riding the next-generation platform wave, inspiring developer delight, powering breakthrough departmental applications, enabling emerging trends such as cloud computing, and democratizing application life-cycle management (ALM).

Today’s announcement included an in-depth look at how Visual Studio Team System (VSTS) 2010 (code-named “Rosario”) will help democratize ALM with a unique solution that brings all the members of a development organization into the application development life cycle, and removes many of the existing barriers to integration. Additional details on the other focus areas will be disclosed over the product development cycle.

“With Visual Studio 2010 and the .NET Framework 4.0, we are focused on the core pillars of developer experience, support for the latest platforms spanning client, server, services and devices, targeted experiences for specific application types, and core architecture improvements,” said S. “Soma” Somasegar, senior vice president of the Developer Division at Microsoft. “These pillars are designed specifically to meet the needs of developers, the teams that drive the application life cycle from idea to delivery, and the customers that demand the highest quality applications across multiple platforms. You can expect to hear a lot more about Visual Studio 2010 and the .NET Framework 4.0 in the coming months.”

Democratizing Application Life-Cycle Management
Today, much of application development remains siloed throughout the enterprise, leading to decreased productivity and lengthy product development cycles. With VSTS 2010, Microsoft is taking the next step forward in giving individuals and development organizations an advanced solution that enables them to integrate effectively and build and deliver high-quality applications.
This includes new capabilities that make it easier for all contributors on the software team to participate throughout the life cycle — from the core developers and testers to the wider team of project managers, designers and business analysts. Highlights include the following:

Modeling tools. With VSTS 2010 Architecture, Microsoft will enable both technical and nontechnical users to create and use models to collaborate and to define business and system functionality graphically. The new version supports both Unified Modeling Language and Domain Specific Language support, so development organizations will have the right tool for right job. The new modeling capabilities in VSTS 2010 are a core part of the larger Microsoft modeling platform, which will also include the “Oslo” repository, tools and language.
Improved efficiency throughout the test cycle. With VSTS 2010, Microsoft has made a significant investment in testing features and dramatically simplifying the tools required to integrate testing across the life cycle. New features include the ability to eliminate nonreproducible bugs, fast setup and deployment of tests to ensure the highest degree of completeness of test, focused test planning and progress tracking, and ensuring that all code changes are properly tested.
Substantial improvements in collaboration capabilities. Microsoft has made major investments in the capabilities and scalability of Team Foundation Server (TFS) including significant improvements that allow teams to configure and adopt any flavor of Agile development processes. Teams can track and trace work more easily with richer linking of work items enabling hierarchical work item relationships. In the source code management system, TFS now provides visualization tools for tracking changes across branches and into the production build. VSTS 2010 also introduces workflow-based builds that catch errors before they have a chance to affect the rest of the team or, worse, enter production. Finally, administrators will find dramatically simpler TFS deployment and management.

“The application life cycle is an integral part of today’s business. Regardless of core competencies, all organizations are driven by software that is created and customized to deliver a competitive advantage,” said Theresa Lanowitz, founder of voke, inc. “Enterprises that invest in an ALM solution can decrease their total cost of ownership of applications in their IT portfolio, and bring about a global approach that is an integrated and expansive system consisting of people, processes and technology. This global approach to ALM facilitates collaboration and takes the risk out of software development to produce predictable and reliable results for an optimized business outcome. Solutions such as VSTS are poised to take advantage of market opportunity by offering an application life-cycle platform to help enterprises realize this ROI benefit.”
In another move to increase integration across the life cycle, Microsoft also announced that VSTS 2010 will provide a unified VSTS Development and Database product. As a benefit to existing Software Assurance (SA) customers, those who currently own Visual Studio Team System 2008 Development Edition or Visual Studio Team System 2008 Database Edition will receive all the following products starting Oct. 1, 2008, for free:

Visual Studio Team System 2008 Development Edition
Visual Studio Team System 2008 Database Edition
Visual Studio 2005 Team System for Software Developers
Visual Studio 2005 Team System for Database Professionals

VB.NET vs C#.NET

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

VB.NET Advantages

Support for optional parameters - very handy for some COM interoperability
Support for late binding with Option Strict off - type safety at compile time goes out of the window, but legacy libraries which don't have strongly typed interfaces become easier to use.
Support for named indexers (aka properties with parameters).
Various legacy VB functions (provided in the Microsoft.VisualBasic namespace, and can be used by other languages with a reference to the Microsoft.VisualBasic.dll). Many of these can be harmful to performance if used unwisely, however, and many people believe they should be avoided for the most part. Some methods here are apparently faster than the more idiomatic .NET equivalent, however. Readability should be considered: using VB functions probably makes the code easier for a VB-classic programmer to read, but harder for someone from a background in another .NET language to read.
Simpler (in expression - perhaps more complicated in understanding) event handling, where a method can declare that it handles an event, rather than the handler having to be set up in code.
The ability to implement interfaces with methods of different names. (Arguably this makes it harder to find the implementation of an interface, however.)
Catch ... When ... clauses, which allow exceptions to be filtered based on runtime expressions rather than just by type.
The VB.NET part of Visual Studio .NET compiles your code in the background. While this is considered an advantage for small projects, people creating very large projects have found that the IDE slows down considerably as the project gets larger. (Note: This may only affect VS.NET 2002. I haven't tested it yet with VS.NET 2003 or VS2005 beta 2.)

C# Advantages

XML documentation generated from source code comments. (Available in VB.NET with Visual Studio 2005.)
Operator overloading. (Available in VB.NET with Visual Studio 2005.)
Language support for unsigned types. You can use them from VB.NET, but they aren't in the language itself. (Available in VB.NET with Visual Studio 2005.)
The using statement, which makes unmanaged resource disposal simple. (Available in VB.NET with Visual Studio 2005.)
Volatile variables.
Explicit interface implementation, where an interface which is already implemented in a base class can be reimplemented separately in a derived class. Arguably this makes the class harder to understand, in the same way that member hiding normally does.
Unsafe code. This allows pointer arithmetic etc, and can improve performance in some situations. However, it is not to be used lightly, as a lot of the normal safety of C# is lost (as the name implies). Note that unsafe code is still managed code, i.e. it is compiled to IL, JITted, and run within the CLR.

What ASP.NET Developers Should Know About JavaScript - Part 3

2008-03-10T22:18:00.003-07:00

Part - 1

Part - 2

Part - 3

Where Are We With Object Oriented JavaScript?
With our brief diversion into JSON complete, let's return to the topic of object oriented JavaScript. So far we've learned the following:

Every JavaScript object is a dictionary.

This is useful information for constructing objects, but it's only a starting point. To get to the next level of abstraction, we'll need to add a second piece of knowledge:

Every JavaScript function is an object.

#2 is what we will discuss in the next topic.

JavaScript Functions
A JavaScript function is a chunk of executable code, but it's also a first class object. This is fundamentally different from methods in C# and Visual Basic. We can invoke methods in C# and VB, but we can't treat those methods as datatypes (although delegates and lamda expressions in C# make this area a little bit fuzzy). In JavaScript, we can manipulate functions using other JavaScript code, assign functions to variables, store functions inside arrays, nest functions inside other functions, and pass functions as a parameter to other functions. This might sound strange, so let's walk through a simple example.

function add(point1, point2)
{
var result = {
x : point1.x + point2.x,
y : point1.y + point2.y
}
return result;
}

The above code defines a function named "add". The function expects two parameters, and expects that these two parameters will both have x and y properties that it can add together. It returns the result as a new object (created in object notation) with x and y properties. We could use invoke this function as in the following sample:

var p1 = { x: 1, y: 1 };
var p2 = { x: 1, y: 1 };

// use our add function
var p3 = add(p1, p2);

alert(p3.x + "," + p3.y);

The resulting dialog box will display "2,2".

Technically, what we've done with the add function is create a new function object, and assigned the function object to a variable named add. We could take the same function object and assign it to different variables and invoke the function through those variables.

function add(point1, point2)
{
var result = {
x : point1.x + point2.x,
y : point1.y + point2.y
}
return result;
}

var foo = add
var bar = add

var p1 = { x: 1, y:1 };
var p2 = { x: 1, y:1 };

// invoke add through foo variable
// p3 should be 2,2
var p3 = foo(p1, p2);

// invoke add again through bar variable
// 2,2 + 1,1 = 3,3
p3 = foo(p3, p1);

alert(p3.x + "," + p3.y);

The resulting dialog box should now display "3,3".

Functions as Methods
We can also assign a function object to an object property. As we noted before, this promotes the function to the status of "method".

var point1 =
{
x: 3,
y: 5,
add: function(otherPoint)
{
this.x = this.x + otherPoint.x;
this.y = this.y + otherPoint.y;
}
};

var point2 =
{
x: 1,
y: 1
};

// add 3,5 to 1,1
point1.add(point2);
// shows 4,6
alert(point1.x + "," + point1.y);

The first part of the code uses object notation to create an object with x, y, and add properties. The add property is a function object, and inside we've introduced the "this" keyword. Just as every instance method in C# has an implicit "this" parameter (and every instance method in VB has "Me" parameter), every JavaScript method has an implicit "this" parameter that represents the object through which the method was invoked. "this.x" will reference the x property of point1, because we invoke the add method using point1.

What is a problem is that we have two "point" objects, but one has an add method and one does not. Remember, we are not defining classes like we would in C# or VB, we are simply creating objects and adding properties and methods on the fly. If we wanted to same add method in both point1 and point2, we could write the following code.

function addPoints(otherPoint)
{
this.x = this.x + otherPoint.x;
this.y = this.y + otherPoint.y;
}

var point1 =
{
x: 3,
y: 5,
add: addPoints
};

var point2 =
{
x: 1,
y: 1,
add: addPoints
};

// add 3,5 to 1,1
point1.add(point2);

// shows 4,6
alert(point1.x + "," + point1.y);

Now we've defined a function object and assigned the object to a variable named addPoints. We use addPoints to create new add methods in both the point1 and point2 objects. Does the "this" reference still work in addPoints? Yes it does, because "this" will still reference the object through which the method was invoked. "this" is a bit ephemeral in JavaScript, as we see later on, but we can can now invoke the add method on either the point1 or point2 object.

This syntax is feeling uncomfortable, however. It looks as if we are trying to create a Point class that will define the properties and methods for all Point objects. But JavaScript doesn't have classes, so that would be a dream, right? We'll forever need to include all this object literal code every time we need a point object, right? Let's hope we never move into 3 dimensions where the definition of our point objects will change.

Fortunately, there is a better solution.

Constructor Functions
In JavaScript, a constructor function works in conjunction with the new operator to initialize objects. A constructor function can improve our previous code, because we can use the function to initialize every object we want to use as a Point.

function Point(x,y)
{
this.x = x;
this.y = y;
}

var p1 = new Point(3,5);
var p2 = new Point(4,6);

// shows 3,5
alert(p1.x, p1.y);

Constructor functions are just regular functions. It's just we've designed the function to be used with the new operator. By convention, we generally capitalize constructor functions to make other programmers aware of their significance.

When we use the new operator with the Point function, the new operator will first create a new object. The new operator then invokes the Point function and passes a reference to the newly created object in the implicit "this" parameter. Inside the Point function we are creating new name/value pairs using the parameter values passed to the function.

Constructor Functions and Object Methods
We can also create methods on an object inside a constructor function.

function Point(x,y)
{
this.x = x;
this.y = y;
this.add = function(point2)
{
this.x += point2.x;
this.y += point2.y;
}
}

var p1 = new Point(3,5);
var p2 = new Point(4,6);

p1.add(p2);

// shows 7,11
alert(p1.x + ',' + p1.y);

This approach works well, but there is an alternate approach we can use which is more in favor today. To understand this approach, we'll need to introduce a new piece of knowledge. Let's review the first two:

Every JavaScript object is a dictionary.
Every JavaScript function is an object.

Now for number 3:

Every JavaScript object references a prototype object.

Let's talk about prototypes.

Object Prototypes
Prototypes are a distinguishing feature of the JavaScript language. C#, Visual Basic, C++, and Java are all examples of class-based programming languages. To create objects, we must first write a class that defines fields, properties, methods, and events. When we create a new object, we are creating an instance of that class.

In JavaScript, there are no classes. JavaScript is a prototype-based programming language. Every object has a prototype property that references its prototype object. Any properties and methods that are a part of an object's prototype will appear as properties and methods of the object itself.

Remember that every function is an object, and every object references a prototype object. That means every constructor function references a prototype object. This is extremely useful when used in conjunction with the "new" operator, because of steps taken by the new operator:

Create an empty object.
Assign the value of the constructor function's prototype property to the new object's prototype property.
Invoke the constructor function, passing the new object as the "this" reference.

The above 3 steps mean that all objects created by a constructor function will have the same prototype – the prototype object for the constructor function. If we can modify the constructor function's prototype object, we will modify all objects the constructor function ever creates (or has already created). You can almost think of every object as inheriting from it's prototype, because it will include all the properties and methods defined by its prototype. I say "almost" because this thinking can be dangerous in some edge cases.

Fortunately, there is an easy syntax we can use to add new properties and methods into a prototype object.

Prototype Programming
Remember, all objects in JavaScript are dictionaries, and a prototype object is no exception. We can modify an object' s prototype simply by referencing it's prototype property, and we can add properties and methods to that prototype object. Let's rewrite our Point "class" one more time.

function Point(x,y)
{
this.x = x;
this.y = y;
}

Point.prototype.add = function(point2)
{
this.x += point2.x;
this.y += point2.y;
}

var p1 = new Point(3,5);
var p2 = new Point(4,6);

p1.add(p2);

// shows 7,11
alert(p1.x + ',' + p1.y);

The methods and properties we add to Point.prototype will be shared by all objects that are constructed from the Point constructor function. When we add methods to an object using the constructor function – each object gets a new property referencing a function object, so the prototype approach is more efficient (shared function objects) as well as being a little easier to read. This prototype approach is used by many of today's JavaScript frameworks.

Putting It All Together
The topics we've discussed so far put us close to "simulating" classes in JavaScript. There are just a couple more topics we need to introduce before wrapping up.

One topic is encapsulation. In JavaScript, every name/value pair we add to an object becomes a public property. There are no keywords in JavaScript to restrict accessibility (like the internal, protected, and private keywords in C#). Nevertheless, we can simulate private members.

Private Members
Douglas Crockford published an article "Private Members In JavaScript" that demonstrates how to add private members to a JavaScript object. Information hiding is an important technique in object oriented programming, and many JavaScript toolkits use Crockford's approach to private members.

Private members have to be made in an object's constructor function. Both local vars and parameters are eligible to become private members using a closure. A closure in JavaScript is an inner function that references a local var or parameter in its outer function. Those local variables and parameters, which typically go out of scope when the outer function finishes execution are now "enclosed" by the inner function, which can continue to reference and use those variables.

Let's re-write our sample once more, this time providing public "get" and "set" accesors for our points.


function Point(x, y)
{
this.get_x = function() { return x; }
this.set_x = function(value) { x = value; }
this.get_y = function() { return y; }
this.set_y = function(value) { y = value; }
}

Point.prototype.print = function()
{
return this.get_x() + ',' + this.get_y();
}

var p = new Point(2,2);
p.set_x(4);
alert(p.print());

Client code can no longer access the x and y values of a point object directly. Instead, the code has to go through the set_ and get_ methods.

Namespaces
Namespaces are crucial for avoiding type name collisions, which can be a bad thing in JavaScript. Unlike a compiled language like C# or VB, where a type name collision will result in a compiler error and an un-shippable product, in JavaScript you can still ship the code and might not find out about the collision until it's too late. JavaScript will happily overwrite one value with another. Since we are now including JavaScript code from all over the place, the practice of using namespace is important.

There is just one problem.

JavaScript doesn't support namespaces.

This is ok, because we can "simulate" namespace using objects. Let's put our "Point class" into a Geometry namespace.

var Geometry = {}

Geometry.Point = function(x,y)
{
this.x = x;
this.y = y;
}

Geometry.Point.prototype =
{
print: function()
{
return this.x + ',' + this.y;
}
}

var p1 = new Geometry.Point(5,2);
alert(p1.print());

Essentially, we are adding our constructor function to the Geometry object. By adding other constructor functions (Rectangle, Square, etc), we could keep all of our types inside Geometry and not pollute the global namespace. Most JavaScript frameworks use a similar technique.

In Conclusion
This article presented three key pieces of knowledge:

Every JavaScript object is a dictionary.
Every JavaScript function is an object.
Every JavaScript object references a prototype object.

Those are three fundamental facts about JavaScript that also make JavaScript different from mainstream CLR languages like C# and VB.NET. Embracing and internalizing these differences will put you ahead of the game in understanding modern JavaScript frameworks, toolkits, and libraries.
This article is by K. Scott Allen. Questions? Comments? Bring them to my blog.

Part - 1

Part - 2

Part - 3

What ASP.NET Developers Should Know About JavaScript - Part 2

2008-03-10T21:58:00.003-07:00

Part - 1

Part - 2

Part - 3

Object Oriented JavaScript
JavaScript does have an object data type – but these objects can behave differently from the objects we create in C# and VB code. In C# and VB we create new objects by telling the runtime which class we want to instantiate. A class is a template for object creation. A class defines the properties and methods an object will have, and these properties and methods are forever fixed. We can't manipulate an object by adding or removing properties and methods at runtime.

In JavaScript there are no classes, so we have no template for object creation. Then how do properties and methods become part of an object? One approach is to dynamically create new properties and methods on an object after construction. To create a new property, all we need to do is assign a new value for a property. The following code creates a new object, then adds an x and y property to the object. Finally, the script writes the values of the two new properties into an area in the HTML document.

var p = new Object();
p.x = 3;
p.y = 5;
message.innerHTML = p.x + "," + p.y;

JavaScript objects are entirely different from C# and VB objects because they are ultimately a collection of name and value pairs. We can access an object's values using the dot operator "." followed by the name of the value. A value isn't constrained to holding simple integer types as we have shown in the first example, but could hold an array, function, or even other object.

If you are thinking a JavaScript object sounds like a Dictionary from the .NET framework class library, then you are heading in the right conceptual direction.

JavaScript Objects Are Dictionaries
A JavaScript object is similar to a Dictionary in the sense we can associate any arbitrary piece of data with any arbitrary string. In fact, there is an alternate syntax for accessing the values inside an object which makes the object look exactly like a dictionary. Instead of using the . operator to access a value, we can use the [] operator. The [] operator is a common sight when we work with collections like arrays, dictionaries, and hashtables.

Let's rewrite our first example using the [] operator.

p["x"] = 3;
p["y"] = 5;
message.innerHTML = p["x"] + "," + p.y;

The above piece of script produces the same result as our first script. It creates a new object, then adds x and y properties to the object, then writes out the values. Note that if we access a property that does not exist, we'll get back a value of "undefined". For instance, the line of code "alert(p.z);" would force a dialog box to appear with the string "undefined" inside

Creating Object Methods
We can also add functions into the collection of values inside an object. Functions associated with an object become methods of the object. The following code sample shows how to create and use a method with the name of "print".

var p = new Object();
p["x"] = 3;
p.y = 5;
p["print"] = function()
{
message.innerHTML = p.x + "," + p.y;
}
p.print();

Notice we alternate use of the . operator and the [] operator. We can use these two operators interchangeably, for the most part, to create and access an object's properties and methods. Sometimes these operators lead to confusion, because it's not clear if a particular piece of code is trying to create new properties on an object, or if it's trying to set existing properties to new values. Fortunately, there is a third syntax available that makes our intent explicitly clear.

Object Literals
The object literal syntax of JavaScript allows us to create an object and specify its properties using shorthand. The syntax uses a comma-separated list of name and value pairs, where the name and the value themselves are separated by a colon. Let's rewrite our code and create our object using this object initialization syntax.

var p =
{
x : 5,
y : 3,
print : function() { message.innerHTML = p.x + ',' + p.y; }
}

p.print();

In the above code it becomes clear where object initialization begins and ends. Also note that we can nest object literals, and that the property values inside the object literals do not need to be constants – we can use any legal JavaScript expression. The following code will contains a nested object (address), and assigns the current date to a new createdDate property.

var person =
{
name: "Scott Allen",     createdDate: new Date()
website: "OdeToCode.com",
address: { state: "MD", postalCode: "21044" },
};

alert(person.address.state);
alert(person.createdDate);

The object literal syntax is popular because of its explicit intent and compact size. If you look at the source code for many of today's popular JavaScript frameworks, you'll see they are using object literals inside. Frameworks, however, aren't the ones using object literals.

Object Literals and JSON
JavaScript Object Notation (JSON) is a lightweight data-interchange format based on a subset of the object literal syntax. Technically, JSON is a stricter version of the object literal syntax. For example, string literals must be enclosed in double quotes – no single quotes are allowed.

JSON allows JavaScript to exchange data over the network (typically with the XmlHttpRequest object) and interoperate with other applications. Many web service providers offer JSON as a serialization format and as an alternative to XML. When our JavaScript contacts the web service, the web service will return its data in JSON. There is no need for our code to manipulate XML data with an XML API - instead our code can use JavaScript's eval statement to convert JSON into an object graph.

var jsonString = "({ x : 3, y: 5 })";

var p = eval(jsonString);
alert(p.x + ',' + p.y);

JSON is becoming hugely popular on the web. JSON is human readable and easily consumable in JavaScript. Also, exchanging data with JSON typically results in smaller payloads than using XML. ASP.NET AJAX includes a JavaScriptSerializer class to use JSON on the server-side in managed code.

Part - 1

Part - 2

Part - 3

What ASP.NET Developers Should Know About JavaScript - Part 1

2008-03-10T21:48:00.002-07:00

Part - 1

Part - 2

Part - 3

JavaScript – It's beat up, put down, shrugged off and kicked around. Cursed by the web browser's inconsistency yet blessed by a pervasive ubiquity -it's a technology many try to disregard even when its potential is something few can ignore. If you want to write an interactive application for the web today, then you'll need some JavaScript code on your side.

This article approaches JavaScript from the perspective of an ASP.NET developer who is comfortable with the paradigms and patterns of either C# or Visual Basic. The article doesn't look at how to use JavaScript from ASP.NET exactly, but it does look at why JavaScript is so different from the two languages we commonly use with the .NET CLR. The article assumes you already know that JavaScript is a loosely-typed language (because you don't have to declare the type of data you store in a variable), and that the syntax is similar to the C family of languages (with charming curly braces and stunningly beautiful semi-colons).

What Is Wrong With JavaScript?
The introduction didn't paint a flattering picture of the JavaScript language, but the truth is JavaScript is a good language. The biggest sources of pain when programming with JavaScript aren't because of the language. The biggest pains come from:

The tools
The implementations
The bad practices

JavaScript Tools
Most of the tools we use in a Visual Studio environment are geared to languages targeting the CLR. If you program in C# or Visual Basic, you'll be assisted by Intellisense, class browsers, class diagrams, code snippets, code analysis, and a world class debugger. The menus will list refactoring commands, and unit testing is only a few keystrokes away.

Contrast the above with the experience of programming with JavaScript. There is no Intellisense (although the feature is coming in the next version of Visual Studio), the debugger is finicky, and most of the other tools listed above are missing entirely. Of course, the majority of the code we write in Visual Studio is not JavaScript, but as the demands of the web have required more scripting, we've started to need better tools. The lack of tools makes JavaScript more difficult to work with.

Bad Implementations
JavaScript is hosted by many different types of web browsers, and is generally our primary means to manipulate a browser's DOM. While ostensibly governed by W3C standards, we all know each browser contains variations and idiosyncrasies. Script code that works on one version of a browser might not work on a different version of the same browser. These scenarios cause a lot of pain in testing and re-writing of JavaScript code. This pain isn't the language's fault – we will never see the day when all browsers implement web standards with 100% accuracy.

Bad Practices
JavaScript is an accessible language. We don't need special tools or compilers. We can view the source code of any page on the Internet and copy the script code for our own purposes – and many people do. Of course, not everyone who uses JavaScript is a software developer with an eye for good code. All sorts of people use JavaScript, and all sorts of ugly JavaScript code perpetuates itself on the Internet.

Even software developers (the author included) have taken a quick and dirty approach to writing JavaScript. It's only script code, after all, and just slapping the code into a text editor to get the desired result is all we need. It's not until we have to untangle a mess that we realize a more disciplined approach would have ultimately saved us time.

With all of these problems in the JavaScript environment – why do we still want to torture ourselves by writing JavaScript code?

What is Right with JavaScript?
Over the last few years, the amount of JavaScript code you'll find in the typical web application has surged. There are a couple good reasons for the surge:

JavaScript is ubiquitous
JavaScript is mature

Ubiquity
If you want to write an application that will reach as many users as possible, then you'll be writing a web application. You can reach users on Windows, Macintosh, Linux, and hundreds of other platforms on devices both large and small.

How will you make a web application interactive? You'll use JavaScript. Your users won't have to install a runtime, or an ActiveX control, or download some interpreting engine. They'll install a web browser that includes JavaScript support, as so many do, and they'll happily use your application. JavaScript is the most ubiquitous programming language on the planet.

Maturity
As the demand for JavaScript code has increased, the frameworks and libraries of well-tested and robust JavaScript code have begun to emerge. Many of these frameworks abstract away the browser idiosyncrasies we discussed earlier, and can greatly reduce the amount of time we invest in writing and debugging cross-platform JavaScript code. Here are some of the most popular frameworks:

ASP.NET AJAX
Prototype
Script.aculo.us
The Dojo Toolkit
Yahoo! UI Library

We've also begun to see the emergence of proven practices and design patterns. The practices put the object oriented features of JavaScript to good use. What's that? You didn't know JavaScript was object oriented? We might not have applied OOP practices to JavaScript code over the last few years, but the capability does exist.

Part - 1

Part - 2

Part - 3

New in Visual Studio 2008

2008-03-04T04:07:00.001-08:00

Visual Studio 2008 is the version of Visual Studio which comes with the .NET Framework 3.5. It was released to MSDN subscribers on 19 November 2007 alongside the .NET Framework 3.5.
Visual Studio 2008 can target development in .NET Framework versions 2.0, 3.0 and 3.5. Visual Studio 2008 comes with many new feature over Visual Studio 2005. Visual Studio 2008 features a XAML based designer (codenamed Cider), workflow designer, LINQ to SQL designer (for defining the type mappings and object encapsulation for SQL Server data), XSLT debugger, JavaScript Intellisense support, JavaScript Debugging support. Here is a list of some of the new features found in Visual Studio 2008.

Multi-Targeting support
Javascript Intellisense
Javascript debugging
Code editing improvements
Nested Master Page support
Web designer and CSS improvements
New Split View including vertical split
Enhanced support for the ASP.NET AJAX Extensions
LINQ to SQL designer
Enhanced XML support
Support for Silverlight
Support for WPF
Support for debugging .NET Framework 3.5 class libraries

Apress Beginning ASP NET 3.5 in CSharp

2008-02-01T00:13:00.002-08:00

Apress Beginning ASP NET 3.5 in CSharp 2008 From Novice to Professional 2nd.Edition Nov 2007

To download Click Here

Good Books for ASP.Net

2008-01-10T02:38:00.004-08:00

Asp.net Bible Vb.net & C#
Download

Programming in ASP.NET Bible
Download

ASP.NET Bible
Download

Beginning ASP.NET Databases using VB.NET
Download

Asp.net 2.0 in C#
Download

Pro ASP.NET in C# 2005

Download

Pro ASP.NET 2.0 E-Commerce in C Sharp 2005
Download

Essential ASP.NET With Examples in C Sharp
Download

O'reilly - C Sharp in a Nutshell
Download

Tips & Tricks - SQL Server 2008

2007-12-26T04:37:00.002-08:00

Did you know... How to perform date/time conversions using SQL Server
The first considerations is the actual date/time needed. The most common is the current date/time using getdate(). To change the format of the date, you convert the requested date to a string and specify the format number corresponding to the format needed using select convert(varchar, getdate(),)

Did you know.. How to get operating system content into SQL Server
Use the xp_cmdshell extended stored procedure to access the file system and bring the contents into SQL Server. By using a combination of both OS level commands and SQL Server commands you can pull this data into SQL Server for processing.

Did you know... How to delete duplicate rows when there is no primary key
An option that SQL Server gives you is the ability to set ROWCOUNT which limits the numbers of records affected by a command. The default value is 0 which means all records, but this value can be set prior to running a command.

Tips & Tricks - Visual Studio 2008

2007-12-26T04:29:00.001-08:00

Did you know... How to reach the Navigation bar via the keyboard?
To jump to the navigation bar via the keyboard, press Ctrl+F2. This is bound to the command Window.MoveToNavigationBar, so your keyboard shortcut mileage may vary. To toggle between the Objects list and the Members list press Tab or Shift+Tab. Additionally, you can hide (or show) the navigation bar by going to Tools - Options -Text Editor - All Languages - General and setting the Navigation bar option to the desired setting. Note that since this is found in AllLanguages, you can customize this for any listed language under the Text Editor node.

Did you know... what's the difference between smart indenting and block indenting?
Smart indenting is the option you want provided you want the cursor to be properly indented whenever you press enter or arrow up and down through the code. An example is when you create a new method called foo(), then hit enter. You'll notice the cursor will automatically indent itself. If you continue to hit enter, the cursor will remain indented. Not all languages support this smart indenting, but if it does, this should be the default setting for that language. Block indenting is similar to a document editor. The difference here is when you type in foo() and hit enter, only that first new line is automatically indented. The next newline places the cursor at column 0. None will not indent any new lines. You will have to indent everything manually.

Did you know... How to turn off Intellisense by default
Go to Tools - Options - Text Editor - All Languages - General and uncheck Auto List Members and Parameter Information. If you just want to disable intellisense by default for a particular language, go to the Text Editor - - General option page and set the behavior there.

Did you know... How to change the Brace Matching color?
Go to Tools - Options - Fonts and Colors, select Brace Matching (Rectangle), and set to the desired color.

Did you know... How to keep tabs or to insert spaces?
Go to Tools - Options - Text Editor - - Tabs to switch between using tabs or to insert spaces instead.