In software development, a  design Pattern describes a general solution to a design problem that recurs repeatedly in many projects. Software designers adapt the Pattern solution to their specific project. Patterns use a formal approach to describing a design problem, its proposed solution, and any other factors that might affect the problem or the solution. A successful Pattern should have established itself as leading to a good solution in three previous projects or situations.

Here are 3 categories of the Patterns involved in software designing...

1) Creational Patterns

Abstract factory pattern: centralize decision of what factory to instantiate

Factory method pattern: centralize creation of an object of a specific type choosing one of several implementations

Anonymous subroutine objects pattern

Builder pattern: separate the construction of a complex object from its representation

Lazy initialization pattern: tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the needed first time

Prototype pattern: used when the inherent cost of creating a new object in the standard way (e.g., using the 'new' keyword) is prohibitively expensive 

Singleton pattern: restrict instantiation of a class to one object

2) Structural Patterns

Adapter pattern: 'adapts' one interface for a class into one that a client expects

Composite pattern: a tree structure of objects where every object has the same interface

Aggregate pattern: a version of the Composite pattern with methods for aggregation of children

Bridge pattern: decouple an abstraction from its implementation so that the two can vary independently

Container pattern: create objects for the sole purpose of holding other objects and managing them

Decorator pattern: add additional functionality to a class at run time where subclassing would result in an exponential rise of new classes

Extensibility pattern: aka. Framework - hide complex code behind a simple interface

Facade pattern: create a simplified interface of an existing interface to ease usage for common tasks

Flyweight pattern: a high quantity of objects share a common properties object to save space

Proxy pattern: a class functioning as an interface to another thing

Pipes and filters: a chain of processes where the output of each process is the input of the next

Private class data pattern: restrict accessor/mutator access

3) Behavioral Patterns

Chain of responsibility pattern: Command objects are handled or passed on to other objects by logic-containing processing objects

Command pattern: Command objects encapsulate an action and its parameters

Interpreter pattern:  Implement a specialized computer language to rapidly solve a specific set of problems

Iterator pattern: Iterators are used to access the elements of an aggregate object sequentially without exposing its underlying representation

Mediator pattern: Provides a unified interface to a set of interfaces in a subsystem

Memento pattern: Provides the ability to restore an object to its previous state (rollback)

Observer pattern: aka Publish/Subscribe or Event Listener. Objects register to observe an event which may be raised by another object

State pattern: A clean way for an object to partially change its type at run time

Strategy pattern: Algorithms can be selected on the fly

Template method pattern: Describes the program skeleton of a program

Visitor pattern: A way to separate an algorithm from an object

Single-serving visitor pattern: Optimise the implementation of a visitor that is allocated, used only once, and then deleted

Hierarchical visitor pattern: Provide a way to visit every node in a hierarchical data structure such as a tree

Look for subsequent posts for clarification of each one from C# point of view...

Cheers!!!

via netfxguide

The Microsoft .NET Framework 3.0 (NetFX3 or WinFX), is the new managed code programming model for Windows. NetFXGuide presents the best resources about the .NET Framework 3.0 including videos, tutorials, articles, source code and much more.

 

Cheers!!

Presented here is a nice article on Asp.Net optimization.. Via John Belthoff

************

If you read all of the websites dedicated to Asp.Net you will inevitably read about the wonders of the DataGrid, DataList, and Repeater controls. While each of these has its place, if you are only displaying data there is a much faster and more efficient means to do so. A normal asp page execution procedure goes something like this. The code queries the database based on the Article I.D. and then brings back that information to the page where you display it in the fashion that you would like. This is a fairly straight forward approach with asp and is done all the time.

So how do we speed up our asp.net pages?

Number 1: Use Asp.Net Caching!

This is a no-brainer, and I won't go into the brilliance or details of asp.net caching here because at the time of this writing Google has 2,780,000 articles on the topic. Basically instead of querying the database each time the page is loaded you only query the database once and load that result into the system cache. Subsequent calls to load the page retrieve the data from the cache as opposed to the database which gives you an instant and considerable performance boost. You can then set the cache for how long the cache should store the information as well as many other features. If you are not using the cache, you should be whenever possible!

Number 2: If possible, do NOT use the standard Asp.Net controls.

That's right. The standard asp.net controls are designed for rapid development and not page performance. They allow you to design pages that grab and display data very quickly but their actual performance suffers because of the extra overhead which is there for ease and speed of development time and not page execution speed.

Instead, create either a User Control or even better yet a Web Custom Control which is by far the fastest performance wise and really quite easy to create and use.

Number 3: Use an SqlDataReader or even better yet use a set based command for Sql Server data retrieval and simply execute that one command against the database.

An asp.net SqlDataReader is a fast forward only datareader that closes the connection after it reads the last set of results. Now for my article pages we are only returning 1 particular result. In this case we would opt for the set based command. If you had more than 1 result returned, in your table of contents for instance, you would use the SqlDataReader because you are returning multiple sets of results.

Set based commands are stored procedures that bring back data through parameters as opposed to a result set which then in turn needs to be looped through to obtain your data. So instead of writing your stored procedure like the following which brings back 1 result set:

Select Title, Body, Author
From Articles
Where ArtID = 215

We can write it using a set based command like this.

Create Procedure mysp_GetArticle

@Title varchar(200) Output,
@Body varchar(8000) Output,
@Author varchar(500) Output

As

Select @Title = Title, @Body = Body, @Author = Author
From Articles
Where ArtID = 215

GO

The above query will return only the three parameters called for and not a result or record set so you don't have to then walk through the returned record set that has only 1 result in it anyway. This second little process of work decreases your performance so you should avoid it whenever possible. Combine this technique with the asp.net cache.

Number 4: Use Classes and ArrayLists as opposed to returning an SqlDataReader.

Create a class and then if there are more than one set of results store those results into individual instantiations of that class. Finally store each of those classes into an ArrayList. You can then store only that ArrayList into the asp.net cache. So instead of getting the results back from a SqlDataReader when loading your page you get them from the ArrayList which is stored in the cache. Nice huh?

Finally... you want to incorporate all of these techniques into your final results which would be performed in the following manner and sequence.

On the first time the page loads, query the database and return all of your data storing it into individual classes. Then store each of those classes into an ArrayList. If you only have one single result you may store only the class into the cache. Then take your ArrayList and store it into the cache.

Next create a Web Custom Control and pass the cached ArrayList to the custom control and loop out your data using the HtmlTextWriter which is very fast. Remember each subsequent call to load the page will be called from the cache which stores your ArraList of classes or your single class.

Certainly it takes a significant amount of additional coding to do it in this fashion, especially when you take proper error handling into consideration, but if you follow this approach your pages will be screeching fast, you will immediately notice the difference, and your asp.net pages will execute in the proper sequence - Data handling in the Page_Load function and the html display in the Page_Render function.

Further, you will be glad you did and so will your visitors.

************

VISIBILITY.net is one of the first Enterprise business applications to be written from the outset entirely using Microsoft.NET framework and Web services architecture. This methodology provides engineer-to-order (ETO) manufacturers with a distinct set of advantages when deploying the enterprise resource planning (ERP) application. VISIBILITY.net has a highly functional user interface, providing the user with a multi-document interface (multiple windows) in a single browser session.

Visibility extended the standard Microsoft ASP.NET development environment by providing a highly intuitive, interactive user experience that would not usually be possible within an Internet application. This accomplishment is achieved with a zero client interface. VISIBILITY.net does not download any software onto client PCs to operate. Any client PC with Internet Explorer 5.5 or later is capable of operating with VISIBILITY.net.

VISIBILITY.net is deployed as a true internet application - the system administrator need not know anything about the client hardware because no installation is necessary. In doing so it provides ubiquitous access for users inside the four walls of your organisation, for users at remote plants and sales offices, and for users 'on the road'.

* Internet Standards based - some ERP vendors have put a 'tick in the box' against industry standards such as HTTP, XML, .NET and Web services through the use of 'bolt-on' technology modules.

The very core of the VISIBILITY.NET application makes use of this technology today, without the need for additional middleware or integration applications. Read Full article here...

Via windowsfordevices.com

McObject has released a C# implementation of a dual-licensed object-oriented embedded database that can be used to develop Window CE and Pocket PC applications. Originally written in Java, Perst boasts "tight integration" with C# and support for the .NET Compact Framework (CF), along with high performance and a modest footprint, the company says.

According to McObject, Perst's tight integration with C# results in "exceptional transparent persistence and ease in working with objects." The company adds that the database's typical 30 to 300 KB run-time code footprint enables it to satisfy the resource constraints of many embedded applications, and also makes it suitable for C# applications requiring high-speed data management.

Typical applications include mobile and embedded devices, industrial systems, Web services, and packaged software, according to the company.

In contrast to object/relational databases, or tools that provide object/relational mapping, Perst stores data directly in C# objects, McObject explains. This eliminates the need for expensive (in performance terms) run-time conversions between the database representation of the data and the C# representation, the company adds.

Additionally, "Perst ensures integrity via transactions that adhere to the ACID properties (Atomicity, Consistency, Isolation and Durability) with very fast recovery," McObject said.

Other Perst features include garbage collection, detection of hanging references, automatic schema evolution, XML import/export utilities, and master-slave replication support with the option to run read-only queries on slave nodes, according to McObject.

The company is offering Perst under a dual-license model. Users can download and modify the database source code and use it freely in non-commercial applications that are neither sold nor used internally by a business, and for which source code is made available. A commercial license is required when Perst-based software is sold or used for business, or if source code will be withheld, according to McObject.

Today, I was trapped in an interesting issue while  implementing a auto-complete URL dropdown in my new C# WinForm application. As in IE, I was able to select a url after it was visible in the dropdown but after selecting, enter press was just being ignored. (rather in IE, hitting enter enters the selected value in the box. I simply tried to implement KeyDown event for the ComboBox but to my despair, all the keys but "Enter" was being caught in the event by enter key wasn't invoking the event at all...

 

I went around Googling and it was not very late when I found the solution. and it was "Overriding IsInputKey  method to have Enter key handled. here is the code..

 

public class YourComboBox : ComboBox

{

            public YourComboBox() : base()

            {

            }

            /// <summary>

            /// Key Handler

            /// </summary>

            /// <param name="keyData"></param>

            protected override bool IsInputKey(Keys keyData)

            {

                        if (keyData == Keys.Enter)

                                    return true;

 

                        return base.IsInputKey (keyData);

            }

}

 

Now your Combo box should be driven from YourComboBox  and simply KeyDown event should be caught..(with little care)

 

 

private void yourComboBox1_KeyDown(object sender, KeyEventArgs e)

{

            if (e.KeyCode == Keys.Enter)

            {

                        e.Handled = true; //remember this line to tell base function that you handled the event already...

                        //Do something...

            }

}

 

 

This and you are all set...

 

Cheers!!

 

 

 

I have recently moved my blog from community server to dasBlog. While setting up google Adsense ads on the site, I was caught up in a specific requirement as in where to put the ads. Google suggests that for high CTR ratio, ads should be placed just above the content and this left me searching for ways to put adsense in start of First Post's body content.

A simple way to implement this was modify your latest post every time you write a post ... cumbersome huh?? Not only cumbersome, this also invalidates your RSS as the feeds doesn't allow <_SCRIPT_> tag in the XML. Looked around little more thinking that I might not be the first one having this kinda requirement ...but to my disappointment, I couldn't find any such generic way to achieve this...

finally this is what I used as a workaround...I don't claim that this is the best possible way to do it but given my one day old relationship with with dasBlog code....this is the most generic change I could make to have it working for me...(Yes you read  it right...there is little code change in newtelligence.DasBlog.Web.Core.dll)..

here is what I did...

1. First create a category named "AdPost" and add first post to it.
2. Then modify site.config file to add one more element..Look closely for html tags converted to literals...

<InContentAdsense>
&lt;DIV style=&quot;PADDING-RIGHT: 5px; PADDING-LEFT: 5px; FLOAT: right; PADDING-BOTTOM: 5px;PADDING-TOP: 5px&quot;&gt;
&lt;SCRIPT type=text/javascript&gt;&lt;!--
google_ad_client = &quot;pub-123123123123123123&quot;;
google_alternate_color = &quot;FFFFFF&quot;;
google_ad_width = 300;
google_ad_height = 250;
google_ad_format = &quot;300x250_as&quot;;
google_ad_type = &quot;text&quot;;
google_ad_channel =&quot;&quot;;
google_color_border = &quot;EEEEEE&quot;;
google_color_bg = &quot;FFFFFF&quot;;
google_color_link = &quot;355EA0&quot;;
google_color_url = &quot;355EA0&quot;;
google_color_text = &quot;333333&quot;;
//--&gt;
&lt;/SCRIPT&gt;
&lt;SCRIPT src=&quot;http://pagead2.googlesyndication.com/pagead/show_ads.js&quot; type=text/javascript&gt;
&lt;/SCRIPT&gt; &lt;/DIV&gt;
</InContentAdsense>

Note: By this change there was some issues with configuration update page which I'll figure out later...

    3.  Set up thecodebase and add this code and declarition in SiteConfig.cs under project <b>newtelligence.DasBlog.Web.Core</b>

string inContentAdsense = null;   //to be added in declarition
public string InContentAdsense {
get { return inContentAdsense; }
set { inContentAdsense = value; }
}

      4. In the same project open Macros.cs and modify method ..public virtual Control Items{ ....}

         here is the modification....

string cntnt = entry.Content;
if (entry.Categories.IndexOf("AdPost") != -1)
{         
  entry.Content = requestPage.SiteConfig.InContentAdsense +  cntnt;
}
requestPage.ProcessItemTemplate(entry, itemPlaceHolder);
entry.Content = cntnt;
 

All this and you are ready to roll....Replace your web dll with this dll (newtelligence.DasBlog.Web.Core.dll) and place the config settings in right place.....Now in whichever post you wanna show Adsense, just add it to category  AdPost!!!! don't forget to reove other posts from AdPost category as google allowes only 3 instances of an add to be displayed!!!  On request I can forward you my copy of newtelligence.DasBlog.Web.Core.dll which would cover step 3 and 4.

Hope there would be a much streamlined solution provided for this in next version of dasBlog...

Cheers!!

 

Microsoft announced a major win today in retails sector. Target Corporation, the national's second-largest discount general merchandise retailer, is headed to adopt Microsoft® .NET Framework based technologies within its 1,400 stores in 47 U.S. states. Target will migrate its systems within each store to the Microsoft .NET Framework 2.0, Windows Serveral 2003 and Microsoft SQL Server⢠2005, core technologies that deliver on the Microsoft Smarter Retailing strategy for connecting people, information, systems and devices.

According to Janet Schalk, chief information officer at Target Corporation, Microsoft technologies can help us drive down costs through a simplified architecture and easier-to-use development tools, These cost savings will enable us to invest in additional innovations that will enhance the store experience for our guests.

Microsoft provides technologies to Target in other key operational and customer-facing areas as well. This comes as a great example of Microsoft Smarter Retailing (http://www.microsoft.com/smartretail), an initiative designed to help retailers improve how they sell and operate. Read the full story here

Today I ran into an issue with one of my DNN sites... I changed site settings and set the login page to one of the tabs which resulted in no access to login page for me and my users...I tried some of the solutions on the web but none of the earlier worked because I had removed friendly URLs host setting.

To get the access back try adding ctl=login to the end of a query string it forces a load of the login dialog eg http://www. mysite.com/default.aspx?ctl=login . If this doesn't work, try this to get around the problem http://www.mysite.com/Home/ tabid/<36>/ctl/Login/Default.aspx (change <36> with home tab id)

If this also doesn't work, John Mitchell has also posted a solution in his blog, where he has created an alternate login page that you can upload, you can view the details here:

http://blogs.snapsis.com/PermaLink,guid,05e0a045-4944-4f85-aa12-ac9cb774e2fb.aspx

Finally last one worked for me...Thanks John

Cheers

Found an interesting MSDN link having posters for high-level class diagrams of .NET framework library...

Check it out here...

Cheers!!

Via John Mueller.

Configuration—the act of modifying the settings for an assembly—is becoming an essential part of .NET development. The .NET Framework 1.1 Configuration Utility provides a means of configuring the assemblies on your system in different ways.

This article explains why assemblies require configuration, shows how to use the .NET Framework 1.1 Configuration Utility to perform the task, and explores an alternative you can try in some cases. More...

Today, somebody asked me about the difference between constant and readonly type declarations and about when to use which one. Here is the interesting detailed comparison with three different examples…

a) private const int EXAMPLE1 = 450;
b) private static readonly DateTime EXAPMLE2 = DateTime.Now
c) private readonly DateTime EXAMPLE3 = DateTime.Now;

 

The Difference:

First one creates a compile-time constant,
Second creates a run-time class constant,
Third creates a run-time object constant.

1) Compile-time Constants

Symbols defined as const (EXAMPLE1 in this case) are replaced with the value of the constant at COMPILE TIME. Therefore statement if (ValueInConst == EXAMPLE1) would get converted to the same MSIL as if (ValueInConst == 450). The compiler replaces the symbol with the value of the constant. This is the main point to compile-time constants.  Compile-time constants can only be used effectively for built-in integral and floating-point types (primitive types), enums, or strings. These are the only types that allow you to assign meaningful constant values as part of the initialization process.  The IL generated for a compile-time constant contains the value, not the symbol. The value is "burned in" at compile time.

2) Readonly Values

Readonly values are those constants which cannot be modified after the constructor has executed. Readonly values are different, however, in that they're set at run time. You have much more flexibility in working with run time constants. Run-Time constants can be of any type; as long as you can assign them in your constructors, they will work. I could not create DateTime values with const but I can make readonly values from DateTime structures.

Secondly, readonly values can be used for instance constants, storing different values for each instance of the class type. The main distinction is that readonly values are resolved at run time. The Intermediate Language generated when you reference a readonly constant reference the readonly variable, not the value.

Which one to use?

The main difference between const and readonly fields is in their flexibility. Suppose you've defined both const and readonly fields like below:

public class SomeValues 
{ 
   public static readonly constOne = 2; 
   public const constTwo = 5; 
} 

Then, in an application these values are referenced and displayed using likely sum statement.

Console.WriteLine("Sum is {0}",SomeValues.constOne + SomeValues.constTwo); 

If you run above snippet, Output will be “Sum is 7”.

After few days you release a new version of the assembly with the following changes:

public class SomeValues
{ 
   public static readonly constOne = 50;
   public const constTwo = 30; 
}

You distribute the assembly without rebuilding the application assembly. You'll get an absurd result as “Sum is 55” !!!!. The snippet now uses the value 50 as constOne, and 5 (OLD VALUE) as constTwo. The const value of cosntTwo (5) was placed into the application assembly by the compiler. On the other hand, constOne was declared as readonly, so it gets resolved at run time. Therefore, the application assembly uses the new value without recompiling the application assembly. Simply installing an updated version of the Infrastructure assembly is enough. Another advantage is that using readonly constants generates smaller sized assembly. Whenever you use a const value, compiler has to inserts the value of the constant. On the contrary, when you reference a readonly value compiler references that symbol not the value. On the flip side, readonly type doesn't work to initialize an attribute. The actual value of the object must be available at compile time for the attribute to get created correctly. Therefore, only values declared as const (or enums) can be used in this instance.

One major advantage constants provide over readonly is that it can be used in places where readonly values cannot be used (as in Attributes). You can use const values as the parameters to attribute constructors but you can’t use readonly values, or variables

There are some small performance gains using const instead of readonly but if you want to have little flexibility, readonly declaration has it for you. This flexibility overrides the small performance gains from using const. Everything except attribute parameters and enums should be declared readonly.

Via Leo

I encountered a very informative post about ASP.Net page life cycle on an equally informative blog from Leo.

Any ASP.NET developer should know the inner workings of the ASP.NET engine. The Page control is its backbone. Knowing the control lifecycle in the page considerably helps in the day-to-day and advanced development projects. read more..

Of course there are lotsa websites having articles on the similar topic but this one takes the bet because of it's beautiful graphical representation (a picture speaks thousands words )

Open Source .Net IDE #develop (SharpDevelop) has got even better.  Written entirely in standards-based C#, 

the #develop version, released September 10, sets a "solid foundation for the growth" of Open Source tools for .NET development projects,

Developers at #develop, have added project-level import for VS.NET and other features to their 1.0 version of their #develop (SharpDevelop) Open Source IDE for C#, VB.NET, Managed C++ and ILAsm projects built to run on Microsoft's .NET platform.

The focus of the Open Source #develop IDE project is "on making #develop portable to other CLRs and platforms" to allow #develop to run with native look and feel on Microsoft .NET / Windows, as well as Mono on Windows and Mono on Linux. Aside from standard code creation and debugging facilities, #develop also brings a full environment to the project, including Windows Forms, testing, auto-insertion capabilities for code and tweaks and even an XML preview feature.... read more...

An IDE can be downloaded here

Read out about this  exciting product recently launched in the market....it comes with Visual Studio .NET 2003 integration support.It lets you visually design forms and generate XAML user interface code with Visual Studio.

Look at an impressive screen shot taken form website created using XAMLON.

                           

Features and tools include:

• Visual Studio .NET 2003 integration
• Declarative 3-D support
• Extensive new sample applications
• AiSVG (Adobe Illustrator SVG) to XAML converter
• XamlPad, a simple editor for XAML with real-time preview

Brief:

The Xamlon engine enables developers to use XAML to rapidly build and deploy applications for current versions of Windows with the confidence that their applications will easily port to future Windows releases. A key new feature of Xamlon v0.9 is the integration of Visual Studio.NET 2003, which allows developers to harness the power of Visual Studio to design rich application interfaces and automatically generate the XAML code for those interfaces. In addition to Visual Studio integration, other new features of Xamlon v0.9 include basic 3-D support, new samples and an Adobe Illustrator SVG to XAML converter.  Read More

Related Links:

Home

Download it here

XAML Blogs

Scott Mitchell has written a good series of articles on data structures in .NET.

This six-part series examines a variety of data structures, some of which are included in the .NET Framework Base Class Library and some of which are custom written. Please find it below..

Part 1. - An Extensive Examination of Data Structures
Part 2. - The Queue, Stack, and Hashtable
Part 3. - Binary Trees and BSTs
Part 4. - Building a Better Binary Search Tree
Part 5. - From Trees to Graphs
Part 6. - Efficiently Representing Sets

Details about the author can be found here...

Enjoy!!!