Code Karma

Event Aggregator in Javascript

2011-12-23T06:53:00.001-08:00

Event Aggregator in Javascript

Sharding in MongoDB

2011-12-02T06:44:00.000-08:00

This great article should get you the necessary start to setup sharding http://yakiloo.com/mongodb-sharding/#comment-4

The only hurdle you might face during the setup of sharding on you local system would be , is to add "addLocal" option during adding the shard

db.runCommand( { addshard : “localhost:10000″, name : “shard10000″ ,allowLocal:true} );

Please let me know if you have any new discoveries ... Thanks ...

Enabling Compression for WCF service

2011-11-27T10:30:00.000-08:00

The below mentioned links will provide a good walk through of how to enable Compression in IIS, however you should not be surprised if your Req/Res are not getting compressed. One of the discoveries for me was "Adding the appropriate MIME type" in the config file.

http://www.iis.net/ConfigReference/system.webServer/httpCompression

http://www.hanselman.com/blog/EnablingDynamicCompressionGzipDeflateForWCFDataFeedsODataAndOtherCustomServicesInIIS7.aspx

Following the above articles you might add three types 'application/json', 'application/atom%u002bxml' and 'application/atom%u002bxml;charset=utf-8' in to your machine.config.

In my case the content type was 'application/json; charset=utf-8', so I had to run

appcmd.exe set config -section:system.webServer/httpCompression /+"dynamicTypes.[mimeType='application/json; charset=utf-8',enabled='True']" /commit:apphost

A good to discover the additional content types you need to add is to use "Fire Bug" or "Google Developer Tools", and identify the request type for the HTTP request made, it would in the header in "Content-Type" section.

Let me know if you have any other discoveries ... Thanks ....

Tracing in WCF

2011-11-23T06:56:00.001-08:00

Tracing in WCF

JQuery - Drag N Drop

2011-11-07T12:30:00.001-08:00

JQuery - Drag N Drop

Relevant Patterns

2011-06-24T12:00:00.000-07:00

This is an excerpt from "Web Application Architecture Guide" from Microsoft

Category	Relevant Patterns
Caching	• Cache Dependency
	• Page Cache

Exception Management	• Exception Shielding

Logging and Instrumentation	• Provider

Navigation	• Model View Presenter
	• Model View Controller

Page Layout (UI)	• Template View
	• Composite View
	• Transform View
	• Two Step View

Request Processing	• Page Controller
	• Front Controller
	• Passive View
	• Supervising Controller

Service Interface Layer	• Façade
	• Service Interface

Communication	• Intercepting Filter
	• Pipes and Filters
	• Service Interface

Concurrency and Transactions	• Capture Transaction Details
	• Optimistic Offline Lock
	• Pessimistic Offline Lock
	• Coarse Grained Lock
	• Implicit Lock
	• Transaction Script

Coupling and Cohesion	• Adapter
	• Dependency Injection

Data Access	• Active Record
	• Data Mapper
	• Query Object
	• Repository
	• Row Data Gateway
	• Table Data Gateway

Composition	• Composite View
	• Transform View
	• Two-step View

Presentation Entities	• Entity Translator

User Experience	• Asynchronous Callback
	• Chain of Responsibility

UI Processing Components	• Model View Controller (MVC)
	• Passive View
	• Supervisor Controller

Business Components	• Application Façade
	• Chain of Responsibility
	• Command

Business Entities	• Domain Model
	• Entity Translator
	• Table Module

Workflows	• Data-driven workflow
	• Human workflow
	• Sequential workflow
	• State-driven workflow

General	• Application Service
	• Data Transfer Object

Batching	• Parallel Processing
	• Partitioning

Communication	• Duplex
	• Fire and Forget
	• Reliable Sessions
	• Request Response

Data Consistency	• Atomic Transactions
	• Cross-service Transactions
	• Long running transactions

Messaging Channels	• Channel Adapter
	• Message Bus
	• Messaging Bridge
	• Point-to-point Channel
	• Publish-subscribe Channel

Message Construction	• Command Message
	• Document Message
	• Event Message
	• Request-Reply

Message Endpoint	• Competing Consumer
	• Durable Subscriber
	• Idempotent Receiver
	• Message Dispatcher
	• Messaging Gateway
	• Messaging Mapper
	• Polling Consumer
	• Selective Consumer
	• Service Activator
	• Transactional Client

Message Protection	• Data Confidentiality
	• Data Integrity
	• Data Origin Authentication
	• Exception Shielding
	• Federation
	• Replay Protection
	• Validation

Message Routing	• Aggregator
	• Content-Based Router
	• Dynamic Router
	• Message Broker (Hub-and-Spoke)
	• Message Filter
	• Process Manager

Message Transfomation	• Canonical Data Mapper
	• Claim Check
	• Content Enricher
	• Content Filter
	• Envelope Wrapper
	• Normalizer

Rest	• Behavior
	• Container
	• Entity
	• Store
	• Transaction

Service Interface	• Remote Façade

SOAP	• Data Contracts
	• Fault Contracts
	• Service Contracts

Deployment	• Layered Application
	• Three-Layered Services Application
	• Tiered Distribution
	• Three-Tiered Distribution
	• Deployment Plan

Manageability	• Adapter
	• Provider

Performance & Reliability	• Server Clustering
	• Load-Balanced Cluster
	• Failover Cluster

Security	• Brokered Authentication
	• Direct Authentication
	• Federated Authentication (SSO)
	• Impersonation and Delegation
	• Trusted Sub-System

Paste here

LINQ 360

2011-06-16T14:10:00.001-07:00

LINQ 360

Entity Framework, Code First and FluentAPI

2011-06-16T14:08:00.000-07:00

Entity Framework, Code First and FluentAPI

Unit Testing framework selection

2011-06-07T11:34:00.000-07:00

Well after burning couple of hours on internet in the quest for an Unit testing framework , I ended up choosing MSTest + MOQ

The needs of the project were,

1. Expressive and easy to learn

2. Ability to support Partial mocks

Few links that help me make my decision are,

http://codevanced.net/post/Mocking-frameworks-comparison.aspx

http://osherove.com/blog/2009/9/30/poll-which-mockingisolation-framework-do-you-use.html

http://stackoverflow.com/questions/1379230/rhinomock-vs-typemock-vs-nunits-mocking

http://stackoverflow.com/questions/64242/rhino-mocks-typemock-moq-or-nmock-which-one-do-you-use-and-why

Entity Framework and Code promotion process

2011-06-06T13:20:00.000-07:00

Entity Framework and Code promotion process

New features in ASP.Net 4 - Primer

2011-05-18T13:17:00.001-07:00

New features in ASP.Net 4 - Primer

1. ASP.Net Core services

2. ASP.Net web form

3. ASP.Net MVC

4. Dynamic Data

5. ASP.Net chart control

6. Enhancements of ASP.Net multi-targeting

ASP.Net Core services

1. web.config file refactoring

In .the .NET Framework 4, the major configuration elements have been moved to the machine.config file, and applications now inherit these settings. This allows the Web.config file in ASP.NET 4 applications to be empty or to specify only which version of the framework the application is targeting.

2. Extensible Output Caching

Since the time that ASP.NET 1.0 was released, output caching has enabled developers to store the generated output of pages, controls, and HTTP responses in memory. On subsequent Web requests, ASP.NET can serve content more quickly by retrieving the generated output from memory instead of regenerating the output from scratch. However, this approach has a limitation — generated content always has to be stored in memory. On servers that experience heavy traffic, the memory requirements for output caching can compete with memory requirements for other parts of a Web application.

ASP.NET 4 adds extensibility to output caching that enables you to configure one or more custom output-cache providers. Output-cache providers can use any storage mechanism to persist HTML content. These storage options can include local or remote disks, cloud storage, and distributed cache engines.

Output-cache provider extensibility in ASP.NET 4 lets you design more aggressive and more intelligent output-caching strategies for Web sites. For example, you can create an output-cache provider that caches the "Top 10" pages of a site in memory, while caching pages that get lower traffic on disk.

By default, in ASP.NET 4, all HTTP responses, rendered pages, and controls use the in-memory output cache. The defaultProvider attribute for ASP.NET is AspNetInternalProvider.

3. Auto-Start Web Application

Some Web applications must load large amounts of data or must perform expensive initialization processing before serving the first request. The feature provides a controlled approach for starting up an application pool, initializing an ASP.NET application, and then accepting HTTP requests. It lets you perform expensive application initialization prior to processing the first HTTP request.

4. Permanently Redirecting a page

In ASP.NET, developers have traditionally handled requests to old URLs by using the Redirect method to forward a request to the new URL. However, the Redirect method issues an HTTP 302 (Found) response (which is used for a temporary redirect). This results in an extra HTTP round trip.

ASP.NET 4 adds a RedirectPermanent helper method that makes it easy to issue HTTP 301 (Moved Permanently) responses, as in the following example:

RedirectPermanent("/newpath/foroldcontent.aspx");

Search engines and other user agents that recognize permanent redirects will store the new URL that is associated with the content, which eliminates the unnecessary round trip made by the browser for temporary redirects.

5. Sessions state compression

By default, ASP.NET provides two options for storing session state across a Web farm. The first option is a session state provider that invokes an out-of-process session state server. The second option is a session state provider that stores data in a Microsoft SQL Server database.

ASP.NET 4 introduces a new compression option for both kinds of out-of-process session state providers. By using this option, applications that have spare CPU cycles on Web servers can achieve substantial reductions in the size of serialized session state data.

You can set this option using the new compressionEnabled attribute of the sessionState element in the configuration file.

6. Expanding the range of allowable URLs

Previous versions of ASP.NET constrained URL path lengths to 260 characters, based on the NTFS file-path limit. In ASP.NET 4, you have the option to increase (or decrease) this limit as appropriate for your applications, using two new attributes of the httpRuntime configuration element. The following example shows these new attributes.

In previous versions of ASP.NET, the URL character checks were limited to a fixed set of characters. In ASP.NET 4, you can customize the set of valid characters using the new requestPathInvalidChars attribute of the httpRuntime configuration element, as shown in the following example:

By default, the requestPathInvalidChars attribute defines eight characters as invalid.

7. Extensible request validation

ASP.NET request validation searches incoming HTTP request data for strings that are typically used in cross-site scripting (XSS) attacks. The built-in request validation returns an error only when it finds the most common strings that are used in XSS attacks. Previous attempts to make the XSS validation more aggressive resulted in too many false positives.

In ASP.NET 4, the request validation feature has been made extensible so that you can use custom request-validation logic. To extend request validation, you create a class that derives from the new System.Web.Util.RequestValidator class, and you configure the application to use the custom type (in the httpRuntime section of the Web.config file).

8. Object caching and Object caching extensibility

Since its first release, ASP.NET has included a powerful in-memory object cache (System.Web.Caching.Cache). The cache implementation has been so popular that it has been used in non-Web applications. However, it is awkward for a Windows Forms or WPF application to include a reference to System.Web.dll just to be able to use the ASP.NET object cache. To make caching available for all applications, the .NET Framework 4 introduces a new assembly, a new namespace, some base types, and a concrete caching implementation. The new System.Runtime.Caching.dll assembly contains a new caching API in the System.Runtime.Caching namespace. The namespace contains two core sets of classes:

Abstract types that provide the foundation for building any type of custom cache implementation.
A concrete in-memory object cache implementation (the MemoryCache class).

The public caching APIs in the System.Runtime.Caching namespace have been updated to support development of custom caches, if you have used the ASP.NET Cache object, you will find familiar concepts in the new APIs.

9. Extensible HTML, URL, and Http header encoding

In ASP.NET 4, you can create custom encoding routines for the following common text-encoding tasks:

HTML encoding.
URL encoding.
HTML attribute encoding.
Encoding outbound HTTP headers.

You can create a custom encoder by deriving from the new System.Web.Util.HttpEncoder type and then configuring ASP.NET to use the custom type in the httpRuntime section of the Web.config file

10. Performance Monitoring for Individual Applications in a Single Worker Process

In order to increase the number of Web sites that can be hosted on a single server, many hosters run multiple ASP.NET applications in a single worker process. However, if multiple applications use a single shared worker process, it is difficult for server administrators to identify an individual application that is experiencing problems.

ASP.NET 4 leverages new resource-monitoring functionality introduced by the CLR. To enable this functionality, you can add the following XML configuration snippet to the aspnet.config configuration file.

Copy

11. jQuery Included with Web Forms and MVC

12. Content Delivery Network Support

The Microsoft Ajax Content Delivery Network (CDN) enables you to easily add ASP.NET Ajax and jQuery scripts to your Web applications. For example, you can start using the jQuery library simply by adding a script element to your page that points to Ajax.microsoft.com, as shown in the following example:

Copy

By taking advantage of the Microsoft Ajax CDN, you can significantly improve the performance of your Ajax applications.

[assembly: WebResource("Example.js", "application/x-javascript", CdnPath ="http://contoso.com/app/site/Example.js")]

13. ScriptManager Explicit Scripts

If you used the ASP.NET ScriptManager in earlier versions of ASP.NET, your Web application had to load the entire ASP.NET Ajax Library. By taking advantage of the new AjaxFrameworkMode property, you can control exactly which components of the ASP.NET Ajax Library are loaded. For more information, see the AjaxFrameworkMode property.

ASP.Net Web Forms

Web Forms has been a core feature in ASP.NET since the release of ASP.NET 1.0. Many enhancements have been in this area for ASP.NET 4, such as the following:

The ability to set meta tags.
More control over view state.
Support for recently introduced browsers and devices.
Easier ways to work with browser capabilities.
Support for using ASP.NET routing with Web Forms.
More control over generated IDs.
The ability to persist selected rows in data controls.
More control over rendered HTML in the FormView and ListView controls.
Filtering support for data source controls.
Enhanced support for Web standards and accessibility.
Project template changes.

1. Setting Meta Tags with the Page.MetaKeywords and Page.MetaDescription Properties

Two properties have been added to the Page class: MetaKeywords and MetaDescription. These two properties represent corresponding meta tags in the HTML rendered for a page, as shown in the following example:

Copy

   Untitled Page

These two properties work like the Title property does, and they can be set in the @ Page directive.

2. Enabling View State for Individual Controls

A new property has been added to the Control class: ViewStateMode. You can use this property to disable view state for all controls on a page except those for which you explicitly enable view state.

Inherit ==> Inherit the value of ViewStateMode from the parent Control.

Enabled ==> Enable view state for this control even if the parent control has view state disabled.

Disabled ==> Disable view state for this control even if the parent control has view state enabled.

3. Support for Recently Introduced Browsers and Devices

ASP.NET includes a feature that is named browser capabilities that lets you determine the capabilities of the user's browser. Browser capabilities are represented by the HttpBrowserCapabilities object which is stored in the HttpRequest.Browser property. Information about a particular browser's capabilities is defined by a browser definition file.

The browser definition files that are included with ASP.NET 4 are shown in the following list:

•blackberry.browser

•chrome.browser

•Default.browser

•firefox.browser

•gateway.browser

•generic.browser

•ie.browser

•iemobile.browser

•iphone.browser

•opera.browser

•safari.browser

4. A New Way to Define Browser Capabilities

ASP.NET 4 includes a new feature referred to as browser capabilities providers. As the name suggests, this lets you build a provider that in turn lets you write custom code to determine browser capabilities.

In ASP.NET version 3.5 Service Pack 1, you define browser capabilities in an XML file. This file resides in a machine-level folder or an application-level folder. Most developers do not need to customize these files, but for those who do, the provider approach can be easier than dealing with complex XML syntax. The provider approach makes it possible to simplify the process by implementing a common browser definition syntax, or a database that contains up-to-date browser definitions, or even a Web service for such a database.

5. Routing in ASP.NET 4

ASP.NET 4 adds built-in support for routing with Web Forms. Routing is a feature that was introduced with ASP.NET 3.5 SP1 and lets you configure an application to use URLs that are meaningful to users and to search engines because they do not have to specify physical file names. This can make your site more user-friendly and your site content more discoverable by search engines.

For example, the URL for a page that displays product categories in your application might look like the following example:

http://website/products.aspx?categoryid=12

By using routing, you can use the following URL to render the same information:

http://website/products/software

The second URL lets the user know what to expect and can result in significantly improved rankings in search engine results.

The new features include the following:

The PageRouteHandler class is a simple HTTP handler that you use when you define routes. You no longer have to write a custom route handler.
The HttpRequest.RequestContext and Page.RouteData properties make it easier to access information that is passed in URL parameters.
- The RouteUrl expression provides a simple way to create a routed URL in markup.
- The RouteValue expression provides a simple way to extract URL parameter values in markup.
The RouteParameter class makes it easier to pass URL parameter values to a query for a data source control (similar to FormParameter).
You no longer have to change the Web.config file to enable routing.

6. Setting Client IDs

The new ClientIDMode property makes it easier to write client script that references HTML elements rendered for server controls. Increasing use of Microsoft Ajax makes the need to do this more common.

You were not always able to predict what id values ASP.NET would generate, or ASP.NET could generate very long id values. The problem was especially difficult for data controls that would generate multiple rows for a single instance of the control in your markup.

ASP.NET 4 adds two new algorithms for generating id attributes. These algorithms can generate id attributes that are easier to work with in client script because they are more predictable and that are easier to work with because they are simpler. For more information about how to use the new algorithms, see the following topics:

ASP.NET Web Server Control Identification

Walkthrough: Making Data-Bound Controls Easier to Access from JavaScript

Walkthrough: Making Controls Located in Web User Controls Easier to Access from JavaScript

How to: Access Controls from JavaScript by ID

7. Persisting Row Selection in Data Controls

The GridView and ListView controls enable users to select a row. In previous versions of ASP.NET, row selection was based on the row index on the page. For example, if you select the third item on page 1 and then move to page 2, the third item on page 2 is selected. In most cases, is more desirable not to select any rows on page 2. ASP.NET 4 supports Persisted Selection, a new feature that was initially supported only in Dynamic Data projects in the .NET Framework 3.5 SP1. When this feature is enabled, the selected item is based on the row data key. This means that if you select the third row on page 1 and move to page 2, nothing is selected on page 2. When you move back to page 1, the third row is still selected. This is a much more natural behavior than the behavior in earlier versions of ASP.NET. Persisted selection is now supported for the GridView and ListView controls in all projects. You can enable this feature in the GridView control, for example, by setting the EnablePersistedSelection property, as shown in the following example:

Copy

8. FormView Control Enhancements

The FormView control is enhanced to make it easier to style the content of the control with CSS. In previous versions of ASP.NET, the FormView control rendered it contents using an item template. This made styling more difficult in the markup because unexpected table row and table cell tags were rendered by the control. The FormView control supports RenderOuterTable, a property in ASP.NET 4. When this property is set to false, as show in the following example, the table tags are not rendered. This makes it easier to apply CSS style to the contents of the control.

Copy

For more information, see FormView Web Server Control Overview.

9. ListView Control Enhancements

The ListView control, which was introduced in ASP.NET 3.5, has all the functionality of the GridView control while giving you complete control over the output. This control has been made easier to use in ASP.NET 4. The earlier version of the control required that you specify a layout template that contained a server control with a known ID. The following markup shows a typical example of how to use the ListView control in ASP.NET 3.5.

Copy

                                 <% Eval("LastName")%>

In ASP.NET 4, the ListView control does not require a layout template. The markup shown in the previous example can be replaced with the following markup:

Copy

              <% Eval("LastName")%>

	Supported Funcationalities
Control	Paging	Data Grouping	Provide Flexible Layout	Update,Delete	Insert	Sorting
ListView	supported	supported	supported	supported	supported	supported
GridView	supported	Not supported	Not Supported	supported	Not Supported	supported
DataList	Not supported	supported	supported	Not supported	Not supported	Not supported
Repeater	Not supported	Not supported	supported	Not supported	Not supported	Not supported

10. Filtering Data with the QueryExtender Control

A very common task for developers who create data-driven Web pages is to filter data. This traditionally has been performed by building Where clauses in data source controls. This approach can be complicated, and in some cases the Where syntax does not let you take advantage of the full functionality of the underlying database.

To make filtering easier, a new QueryExtender control has been added in ASP.NET 4. This control can be added to EntityDataSource or LinqDataSource controls in order to filter the data returned by these controls. Because the QueryExtender control relies on LINQ, but you do not to need to know how to write LINQ queries to use the query extender.

The QueryExtender control supports a variety of filter options. The following lists QueryExtender filter options.

Term	Definition
SearchExpression	Searches a field or fields for string values and compares them to a specified string value.
RangeExpression	Searches a field or fields for values in a range specified by a pair of values.
PropertyExpression	Compares a specified value to a property value in a field. If the expression evaluates to true, the data that is being examined is returned.
OrderByExpression	Sorts data by a specified column and sort direction.
CustomExpression	Calls a function that defines custom filter in the page.

For more information, see QueryExtenderQueryExtender Web Server Control Overview.

11. Enhanced support for Web standards and Accessibility

Earlier versions of ASP.NET controls sometimes render markup that does not conform to HTML, XHTML, or accessibility standards. ASP.NET 4 eliminates most of these exceptions.

For details about how the HTML that is rendered by each control meets accessibility standards, see ASP.NET Controls and Accessibility.

12. CSS for Controls that Can be Disabled

In ASP.NET 3.5, when a control is disabled (see WebControl.Enabled), a disabled attribute is added to the rendered HTML element. For example, the following markup creates a Label control that is disabled:

Text="Test" Enabled="false" />

In ASP.NET 3.5, the previous control settings generate the following HTML:

Test

In HTML 4.01, the disabled attribute is not considered valid on span elements. It is valid only on input elements because it specifies that they cannot be accessed. On display-only elements such as span elements, browsers typically support rendering for a disabled appearance, but a Web page that relies on this non-standard behavior is not robust according to accessibility standards.

For display-only elements, you should use CSS to indicate a disabled visual appearance. Therefore, by default ASP.NET 4 generates the following HTML for the control settings shown previously:

Test

You can change the value of the class attribute that is rendered by default when a control is disabled by setting the DisabledCssClass property.

13. CSS for Validation Controls

In ASP.NET 3.5, validation controls render a default color of red as an inline style. For example, the following markup creates a RequiredFieldValidator control:

ErrorMessage="Required Field" ControlToValidate="RadioButtonList1" />

ASP.NET 3.5 renders the following HTML for the validator control:

style="color:Red;visibility:hidden;">RequiredFieldValidator

By default, ASP.NET 4 does not render an inline style to set the color to red. An inline style is used only to hide or show the validator, as shown in the following example:

style"visibility:hidden;">RequiredFieldValidator

Therefore, ASP.NET 4 does not automatically show error messages in red. For information about how to use CSS to specify a visual style for a validation control, see Validating User Input in ASP.NET Web Pages.

14. CSS for the Hidden Fields Div Element

ASP.NET uses hidden fields to store state information such as view state and control state. These hidden fields are contained by a div element. In ASP.NET 3.5, this div element does not have a class attribute or an id attribute. Therefore, CSS rules that affect all div elements could unintentionally cause this div to be visible. To avoid this problem, ASP.NET 4 renders the div element for hidden fields with a CSS class that you can use to differentiate the hidden fields div from others. The new class value is shown in the following example:

15. CSS for the Table, Image, and ImageButton Controls

By default, in ASP.NET 3.5, some controls set the border attribute of rendered HTML to zero (0). The following example shows HTML that is generated by the Table control in ASP.NET 3.5:

The Image control and the ImageButton control also do this. Because this is not necessary and provides visual formatting information that should be provided by using CSS, the attribute is not generated in ASP.NET 4.

16. CSS for the UpdatePanel and UpdateProgress Controls

In ASP.NET 3.5, the UpdatePanel and UpdateProgress controls do not support expando attributes. This makes it impossible to set a CSS class on the HTML elements that they render. In ASP.NET 4 these controls have been changed to accept expando attributes, as shown in the following example:

The following HTML is rendered for this markup:

17. Eliminating Unnecessary Outer Tables

In ASP.NET 3.5, the HTML that is rendered for the following controls is wrapped in a table element whose purpose is to apply inline styles to the entire control:

If you use templates to customize the appearance of these controls, you can specify CSS styles in the markup that you provide in the templates. In that case, no extra outer table is required. In ASP.NET 4, you can prevent the table from being rendered by setting the new RenderOuterTable property to false.

18. Layout Templates for Wizard Controls

In ASP.NET 3.5, the Wizard and CreateUserWizard controls generate an HTML table element that is used for visual formatting. In ASP.NET 4 you can use a LayoutTemplate element to specify the layout. If you do this, the HTML table element is not generated. In the template, you create placeholder controls to indicate where items should be dynamically inserted into the control. (This is similar to how the template model for the ListView control works.) For more information, see the Wizard.LayoutTemplate property.

19. New HTML Formatting Options for the CheckBoxList and RadioButtonList Controls

ASP.NET 3.5 uses HTML table elements to format the output for the CheckBoxList and RadioButtonList controls. To provide an alternative that does not use tables for visual formatting, ASP.NET 4 adds two new options to the RepeatLayout enumeration:

UnorderedList. This option causes the HTML output to be formatted by using ul and li elements instead of a table.
OrderedList. This option causes the HTML output to be formatted by using ol and li elements instead of a table.

For examples of HTML that is rendered for the new options, see the RepeatLayout enumeration.

20. Header and Footer Elements for the Table Control

In ASP.NET 3.5, the Table control can be configured to render thead and tfoot elements by setting the TableSection property of the TableHeaderRow class and the TableFooterRow class. In ASP.NET 4 these properties are set to the appropriate values by default.

21. CSS and ARIA support for Menu control

In ASP.NET 3.5, the Menu control uses HTML table elements for visual formatting, and in some configurations it is not keyboard-accessible. ASP.NET 4 addresses these problems and improves accessibility in the following ways:

The generated HTML is structured as an unordered list (ul and li elements).
CSS is used for visual formatting.
The menu behaves in accordance with ARIA standards for keyboard access. You can use arrow keys to navigate menu items. (For information about ARIA, see Accessibility in Visual Studio and ASP.NET.)
ARIA role and property attributes are added to the generated HTML. (Attributes are added by using JavaScript instead of included in the HTML, to avoid generating HTML that would cause markup validation errors.)

Styles for the Menu control are rendered in a style block at the top of the page, instead of inline with the rendered HTML elements. If you want to use a separate CSS file so that you can modify the menu styles, you can set the Menu control's new IncludeStyleBlock property to false, in which case the style block is not generated.

22. Valid XHTML for the HtmlForm Control

In ASP.NET 3.5, the HtmlForm control (which is created implicitly by the tag) renders an HTML form element that has both name and id attributes. The name attribute is deprecated in XHTML 1.1. Therefore, this control does not render the name attribute in ASP.NET 4.

23. Maintaining Backward Compatibility in Control Rendering

An existing ASP.NET Web site might have code in it that assumes that controls are rendering HTML the way they do in ASP.NET 3.5. To avoid causing backward compatibility problems when you upgrade the site to ASP.NET 4, you can have ASP.NET continue to generate HTML the way it does in ASP.NET 3.5 after you upgrade the site. To do so, you can set the controlRenderingCompatibilityVersion attribute of the pages element to "3.5" in the Web.config file of an ASP.NET 4 Web site, as shown in the following example:

If this setting is omitted, the default value is the same as the version of ASP.NET that the Web site targets. (For information about multi-targeting in ASP.NET, see .NET Framework Multi-Targeting for ASP.NET Web Projects.)

24. Project Template Changes

ASP.Net MVC

ASP.Net MVC comes as separate release and is not part of core .Net framework release. New features of ASP.Net MVC 3 could be found at http://www.asp.net/mvc/mvc3

New features in .Net 4 - Primer

2011-05-16T15:04:00.000-07:00

New features in.Net 4 are,

C# Optional and Named Parameters
Dynamic
Dynamic and Functional Language Support
Parallel Processing
Parallel LINQ (PLINQ)
Task Parallel Library (TPL)
Managed Extensibility Framework (MEF)
Distributed Caching with Velocity
ASP.Net MVC

The Common Language Runtime (CLR) is Microsoft’s implementation of the Common Language

Infrastructure (CLI). The CLI is an open standard that defines how different languages can compile to an intermediate bytecode for execution on virtual machines on various platforms.

Essentially, C#, VB .NET, and other .NET languages compile to Common Intermediate Language (CIL) and are executed by the CLR.This means that any platform with an implementation of the CLR can execute your code with zero changes.

C# Optional and Named Parameters

If you have a method that has multiple optional parameters, you can provide names for the

parameters you do want to supply in the form (name : value),

public static void Test(int id, string foo="bar", char initial='a')

{

Console.WriteLine("ID: {0}", id);

Console.WriteLine("Foo: {0}", foo);

Console.WriteLine("Initial: {0}", initial);

}

Test(1, initial : 'z');

Named parameters have to appear after required parameters in method calls; however, they can be provided in any order therein.

Dynamic

A better way of doing reflection

object reverseLib = InitReverseLib();

type reverseType = reverseLib.GetType();

object output = reverseType.InvokeMember( "FlipString", BindingFlags.InvokeMethod, null, new object[] { "No, sir, away! A papaya war is on!" });

Console.WriteLine(output.ToString());

Can be done like,

dynamic reverseLib = InitReverseLib();

Console.WriteLine(reverseLib.FlipString("No, sir, away! A papaya war is on!"));

For the uninitiated, duck typing means “If it looks like a duck and quacks like a duck, it must be a duck.” It refers to the ability of dynamic languages to treat objects the same if they have the same method signatures. For example, if class A has methods Foo and Bar and class B has methods Foo and Bar, then class C can treat A and B identically since they “look” the same.

Dynamic and Functional Language Support

• IronPython

• IronRuby

• F#

Parallel Processing

....

Parallel LINQ (PLINQ)

PLINQ queries implement the IParallelEnumerable interface; as such, the runtime distributes

the workload across available cores or processors. Listing 1–10 describes a typical LINQ query that uses

the standard processing model.

return mySearch.Where(x => myCustomFilter(x));

return mySearch.AsParallel().Where(x => myCustomFilter(x));

Task Parallel Library (TPL)

The TPL provides constructs familiar to developers, such as For and ForEach loops, but calls them via the parallel libraries. The runtime handles the rest for you, hiding the details behind the abstraction.

// declares an array of integers with 10,000 elements

int[] myArray = new int[10000];

for(int index=0; index<10000; index++)

{

// take the current index raised to the 3rd power and find the square root of it

myArray[index] = Math.Sqrt(Math.Pow(myArray[index], 3));

}

can be done like,

// declares an array of integers with 10,000 elements

int[] myArray = new int[10000];

Parallel.For(0, 10000, delegate(int index)

{

// take the current index raised to the 3rd power and find the square root of it

myArray[index] = Math.Sqrt(Math.Pow(myArray[index], 3));

});

Managed Extensibility Framework (MEF)

Fundamentally, MEF exposes ComposableParts, Imports, and Exports, which manage instances of extensions to your application. The MEF core provides methods to allow discovery of extensions and handles proper loading (as well as ensuring that extensions are loaded in the correct order). The nature of extensions is exposed via metadata and attributes, which should be very familiar territory to .NET developers and allows for a very consistent usage across .NET applications.

Distributed Caching with Velocity

Although the in-memory .NET cache is both convenient and fast, the hit ratio is terribly low and not a viable solution in a multiserver situation.

Velocity is Microsoft’s answer to that problem, allowing developers to set up distributed cache servers that hold data in-memory; objects stored in the cache do not have to be retrieved from potentially expensive database calls, resulting in greater availability and a better distribution of workload.

Hit ratio defines the number of times an object was successfully retrieved from the cache (a cache hit) versus how many times it could not be (a miss).

In a distributed environment, one or more caching servers sit separately from the web servers and database servers. The purpose of these servers is to provide extremely quick access to frequently used resources and data, reducing the load incurred by expensive database calls and operations.

With situations such as distributed caching, it’s a good idea to hide the implementation details of the cache behind a custom abstraction (in this case, CMSCache). If at some point you decide that Velocity is not for you and you would rather use Memcached or NCache, it’s much easier to modify or extend your caching classes than to modify every area in your application where caching is used. Save yourself the headache, and hide the guts out of sight.

ASP.Net MVC

The traditional WebForms model is meant to solve the problem of maintaining state on a web page and the HTML output rendered by .NET controls (Buttons, GridViews, and so on) was in no way standards-compliant, and at the time the options were a bit limited in how to resolve these problems. In the years since, Microsoft has definitely cleaned the markup that

standard .NET controls produce, but ViewState remains a critical component in the WebForms solution. ViewState is Microsoft’s primary way of preserving state information between page requests. It consists of one or more hidden input fields

The problem with ViewState is that it can get tremendously large very quickly. Try placing several GridViews with paging inside ASP.NET AJAX UpdatePanels and view the source of your page as you navigate; it becomes obvious that the ViewState is significantly bloating the size of the page that the user receives. Worse, the ViewState appears at the top of the page, potentially putting a large roadblock between you and content that is search engine–friendly; search engines typically index only a particular number of characters in a page’s content, and if 5,000 or more characters are wasted on content-less ViewState data, that’s 5,000 fewer characters that a potential audience could see. ViewState is not for sensitive information.

Model View Controller is designed to solve all those problems and return to .NET developers clean, standardized markup using traditional HTML elements as well as the complete elimination of ViewState. The Model aspect refers to the data source of the application, which for our purposes will be a SQL database. The Controller is the brain of the operation, fetching the appropriate information from the Model and feeding it to the View, which is our user interface.

In the MVC world, the page itself is quite dumb, capable of very little without being told. The View relies on being fed complete state information from the Controller and makes no decisions on its own. The result is a clean separation of concerns, a lightweight page model, and 100 percent control over the markup on your applications. The biggest difference is that in MVP, the UI is responsible for handling user input. In MVC, this is handled by the controller. Who exactly handles the input and decides what logic to execute in an application is actually a very big

implementation decision.

Common Project Management Challenges

2011-05-11T09:01:00.000-07:00

Few of the common project management challenges are,

1. Geographically dispersed project teams

2. Using the wrong tool for the job

3. Overbooked resource

4. Wasting time looking for project assets

5. Too much time spent in project status meeting

Geographically dispersed project teams

Projects are inherently collaborative efforts, and by their very nature project teams are usually comprised of multiple team members, often incorporating multiple organizations and multiple locations. It is essential to manage this asynchronous process well. A centralized project management software (http://www.projectinsight.net/) solution can help manage this challenge, especially when working across multiple time zones.

Using the wrong tool for the job

Many companies attempt to manage projects using desktop software applications like Microsoft Project and Microsoft Excel. The main challenge with using desktop software to manage projects is that these applications were not designed for collaboration among several parties. At worst, the file is shared by e-mailing the file to all parties on the team. At best, the file may be posted on a network or on an extranet and shared from there.

A project management solution that is Web-based can help solve these issues by allowing project managers and their team members to access project information from any browser in the world, at any time of the day or night. The project information is centralized in one database and posted in real-time, assuring that all project members and executive management can view the most recent information about the project.

Overbooked resource

Project teams usually have more demand for projects than they have team members or resources to execute the projects. Project managers and resource managers using desktop applications have a challenging time being able to see how much work each resource has across all projects. Teams without a centralized project management solution often use an Excel spreadsheet to manage workloads and find that this is quite a cumbersome exercise.

A Web-based project management solution has the advantage of storing all projects, all resources and their task assignments in one centralized place. A project management solution should be able to drill down to the specifics projects and tasks to show what is causing over allocation.

Wasting time looking for project assets

All projects have assets that belong to the project and/or task. The common-use file sharing frequently employed on networks seems to be the lowest common denominator for project teams. The challenge with even the best file storage systems on the internal network is that team members still complain that they cannot find critical documents. The other problem with this method is that third parties usually cannot access these internal files. This often results in the project manager resorting to e-mailing assets to these outside resources, which can result in version control problems.

A Web-based project management solution can solve these issues by posting all project assets in the centralized repository that is accessible by all participants, providing version control, and e-mail notifications. Another good feature to look for is the ability for the project team to collaborate on project files and assets by posting comments or threads. That way, the entire project history is captured in the documents repository.

Too much time spent in project status meeting

Many project team members complain about spending too much time in meetings focused on project status updates. A Web-based project management solution can permit each team member to report back on project tasks and activities throughout the workday instead of relying on status meetings. The beauty of Web-based solutions is that each project resource is empowered to report back on his or her tasks, pushing the responsibility back where it belongs, to the team member.

Source: http://www.itbusinessedge.com/slideshows/show.aspx?c=87894

Setup Drupal website on Windows 7

2011-05-06T13:28:00.000-07:00

Setup Drupal website on Windows 7

WebSockets in HTML5

2011-05-05T13:35:00.001-07:00

WebSockets in HTML5

HTML 5

2011-05-05T13:29:00.000-07:00

http://diveintohtml5.org/

Using MVCTurbine

2011-05-05T13:27:00.000-07:00

Using MVCTurbine

Web-API WCF

2011-05-05T13:26:00.001-07:00

Web-API WCF

Placeholder

2011-04-28T13:20:00.000-07:00

Placeholder

Amazon AWS vs Windows Azure vs Force

2011-04-28T13:18:00.001-07:00

Amazon AWS vs Windows Azure vs Force

Drupal using Visual Studio

2011-04-16T11:39:00.001-07:00

In this article lets see how to setup a Drupal website using WAMP,and also load the Drupal website from Visual Studio and debug it. This article is influenced from the book Apress.Pro.Drupal.7.for.Windows.Developers, zillion thanks to Apress, and Brian Travis for giving this wonderful book for Windows community

Hurdle 1

MySQL phpamdin root no password error

Hurdle 2

Internal Server Error

The server encountered an internal error or misconfiguration and was unable to complete your request.

Please contact the server administrator, [no address given] and inform them of the time the error occurred, and anything you might have done that may have caused the error.

More information about this error may be available in the server error log.

'webserver.exe' (Managed (v2.0.50727)): Loaded 'C:\Windows\assembly\GAC_32\mscorlib\2.0.0.0__b77a5c561934e089\mscorlib.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.

'webserver.exe' (Managed (v2.0.50727)): Loaded 'C:\Program Files (x86)\Jcx.Software\VS.Php\2010\webserver.exe'

'webserver.exe' (Managed (v2.0.50727)): Loaded 'C:\Windows\assembly\GAC_MSIL\System\2.0.0.0__b77a5c561934e089\System.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.

'webserver.exe' (Managed (v2.0.50727)): Loaded 'C:\Program Files (x86)\Jcx.Software\VS.Php\2010\vsphp_utils.dll'

'webserver.exe' (Managed (v2.0.50727)): Loaded 'C:\Windows\assembly\GAC_MSIL\System.Windows.Forms\2.0.0.0__b77a5c561934e089\System.Windows.Forms.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.

'webserver.exe' (Managed (v2.0.50727)): Loaded 'C:\Windows\assembly\GAC_MSIL\System.Drawing\2.0.0.0__b03f5f7f11d50a3a\System.Drawing.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.

'webserver.exe' (Managed (v2.0.50727)): Loaded 'C:\Windows\assembly\GAC_MSIL\System.Configuration\2.0.0.0__b03f5f7f11d50a3a\System.Configuration.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.

'webserver.exe' (Managed (v2.0.50727)): Loaded 'C:\Windows\assembly\GAC_MSIL\System.Xml\2.0.0.0__b77a5c561934e089\System.Xml.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.

Executing: C:\Program Files (x86)\Jcx.Software\VS.Php\2010\apache2\bin\apache.exe -f "C:\wamp\www\drupal7\.httpd.conf" -X -DPHP_5.2 -DPHP_5_2_SAPI

Logging disabled (QUIET_MODE set)

Code Contracts in .NET Framework 4

2011-04-12T15:26:00.001-07:00

Code Contracts in .NET Framework 4

101 - Enterprise Architecture Methodologies

2011-04-11T13:36:00.000-07:00

I would want to briefly talk about the four most popular Enterprise Architect process/methodology/framework

The Zachman Framework for Enterprise Architectures
The Open Group Architectural Framework (TOGAF)
The Federal Enterprise Architecture
The Gartner Methodology

The Zachman Framework for Enterprise Architectures

The Zachman "Framework" is actually a taxonomy for organizing architectural artifacts (in other words, design documents, specifications, and models) that takes into account both who the artifact targets (for example, business owner and builder) and what particular issue (for example, data and functionality) is being addressed.

Zachman proposed that there are six descriptive foci (data, function, network, people, time, and motivation) and six player perspectives (planner, owner, designer, builder, subcontractor, and enterprise.) These two dimensions can be arranged in a grid, as shown below

There are 36 intersecting cells in a Zachman grid—one for each meeting point between a player's perspective (for example, business owner) and a descriptive focus (for example, data.). As we move horizontally (for example, left to right) in the grid, we see different descriptions of the system—all from the same player's perspective. As we move vertically in the grid (for example, top to bottom), we see a single focus, but change the player from whose perspective we are viewing that focus.

Few suggestion on Zachman grid,

1. Every architectural artifact should live in one and only one cell. There should be no ambiguity about where a particular artifact lives. If it is not clear in which cell a particular artifact lives, there is most likely a problem with the artifact itself.

2. An architecture can be considered a complete architecture only when every cell in that architecture is complete. A cell is complete when it contains sufficient artifacts to fully define the system for one specific player looking at one specific descriptive focus

3. Cells in columns should be related to each other. Consider, for example, the data column (the first column) of the Zachman grid. From the business owner's (Bret's) perspective, data is information about the business. From the database administrator's perspective, data is rows and columns in the database.

The Open Group Architecture Framework ( TOGAF )

TOGAF divides an enterprise architecture into four categories, as follows:

Business architecture—Describes the processes the business uses to meet its goals
Application architecture—Describes how specific applications are designed and how they interact with each other
Data architecture—Describes how the enterprise datastores are organized and accessed
Technical architecture—Describes the hardware and software infrastructure that supports applications and their interactions

Important part of TOGAF is the Architecture Development Method, better known as ADM. ADM is a recipe for creating architecture. A recipe can be categorized as a process. Given that ADM is the most visible part of TOGAF, I categorize TOGAF overall as an architectural process, instead of either an architectural framework (as The Open Group describes TOGAF) or a methodology (as it describes ADM).

Aspect Oriented Programming and Unity 2.0

2011-04-06T21:54:00.000-07:00

An aspect describes a reusable piece of code that you want to inject in existing classes without touching the source code of those classes.

To maximize the reuse of complex business logic code, we typically tend to design a hierarchy of classes around the core and primary business functions of the system. But when the other non-business-specific concerns that cross-cut through the hierarchy of classes? we will fit features such as caching, security and logging in to business object and there by coupling our functionality with non-functional needs.

Not being a specific responsibility of a given component or family of components, a cross-cutting concern is an aspect of the system that must be dealt with at a different logical level, a level beyond application classes. For relatively simple scenarios, such as tracing, caching and decoration of components in the application tier, the capabilities of DI frameworks usually do

the trick. However, it’s difficult to go with DI frameworks when it comes to domain objects and UI objects. A cross-cutting concern can certainly be seen as an external dependency, and DI techniques certainly allow you to inject external dependencies in a class.

Code injection is differs from dependency injection where CI is insert calls to public endpoints in the aspect at specific points within the body of classes decorated with a given aspect, on the other hand DI is are resolved automatically and self-contained aspect component are attached in to a public class method.

A join point indicates a point in the source code of the target class where you want to inject the aspect’s code. A pointcut represents a collection of join points.

Unity is one of the Enterprise Library application blocks. Also available for Silverlight, Unity is essentially a DI container with additional support for an interception mechanism through which

you can make your classes a bit more aspect-oriented.

Interception is essentially an extremely flexible approach to add new behavior to an object at run time without touching its source code and without affecting the behavior of classes in the same inheritance path. Unity interception is a way to implement the Decorator pattern, which is a popular design pattern devised to extend the functionality of an object at run time as the object is used. A decorator is a container object that receives (and maintains a reference to) an instance of the target object and augments its capabilities toward the outside world.

Interception works regardless of the way in which the object is instantiated, whether the object is created through the Unity container or is a known instance. In the latter case, you can just use a different, completely standalone API. If you do so, however, you lose the configuration fi le support.

Th e interception subsystem is made of three key elements:

1. The interceptor (or proxy);

2. The behavior pipeline;

3. The behavior or aspect.

At the two extremes of the subsystems you find the client application and the target object—that is, the object being assigned additional behaviors not hardcoded in its source code.

Once the client application is configured to use the interception API of Unity on a given instance, any method invocation goes through a proxy object—the interceptor. This proxy object looks at the list of registered behaviors and invokes them through the internal pipeline. Each configured behavior is given a chance to run before or after the regular invocation of the object method. Th e proxy injects input data into the pipeline and receives any return value as initially generated

by the target object and then further modifi ed by behaviors.

In Unity 2.0, interception is just a new extension you add to the container to describe how an object is actually resolved.

http://msdn.microsoft.com/en-us/library/ff660872(v=PandP.20).aspx

Introduction to OData - Open Data Protocol

2011-03-31T10:11:00.000-07:00

Introduction to OData - Open Data Protocol