The dotNET blog

Haiti's earthquake - Fund raising

2010-01-13T14:29:00.001-05:00

I've been working from projects to projects for the last 2 years with a few breaks, so I didn't had time to keep posting fresh posts about the .NET world. I will try, in 2010, to share with you guys all the things I've learned (and there's a LOT!).

But for now, I'm taking a few moments to ask for your help. As all of you may know, Haiti was hit by a major earthquake on January 12 2010. Those people really need our help. One of my good friend is from Haiti. He lives in Montreal right now, but his family is still living there.

After the earhtquake, we tried to get in touch with the family as soon as we learned the news. They finally contact us this morning with fresh news. Thankfully, just a few scratches. But the house is GONE.

I'm not the Red-Cross or the Salvation Army. But I want to help. I've told my friend that I would do everything in my power to raise some money to help the family rebuild their lifes. This is where you guys can help. Please consider to make a little donation using the link below. If one of my articles was useful to you in any way, please take the time to donate to help those people in needs.

You can donate any amount you want. I will personnaly send all the money raised to the family directly thru my friend.

I hope that this message will find his way.

Thank you for your help.

An Xml-Driven, Self-Caching ASCX MenuStrip Control

2007-01-04T10:46:00.000-05:00

A great idea from Peter Bromberg, original article can be found here

If you are like me, you are always looking for ways to make your programming life easier - reusable class libraries and controls being a prime target of this effort. One of the things that annoys me about ASP.NET 2.0 is that it offers an ASP.NET menu control, but I just can't bring myself to like it. Sure, it's highly configurable, works with SiteMap xml data, and so on. But, regardless of the amount of tinkering I"ve done, there always seems to be some little annoyance about it's behavior that "gets my goat".

For the kind of development I do, I rarely need one of those fancy-schmancy multilevel javascript callback xpealidocious bodacious scriptabobulous menu thingies. All I need is what I like to call a "MenuStrip". Its a control that lays out items that link to to where you want to go, and it fits with the CSS and design of your page. I don't need dropdowns because if you click an item, you go to that page where I would have another one of these with page-specific items on it, including a "HOME" item that can take you back to the home page (or to where you came from). You can drag the control into a ContentPlaceholder on your page, set an XML source file for the menu items, and you are done.

What I"ve done here, since I couldn't find one already done - that I liked, is to create such an animal, with these features:

1) The CSS to match my page layout is inline in the ASCX page portion of the control. It's not a lot of CSS, so I'd rather have it "keep it's own". If I ever need to change it for another site, that's easy to do.

2) The control loads the XML to display its contents into a DataSet, and caches it for speed. It also sports a file-based CacheDependency so that if I want to change the items on a particular menu, all I need to do is edit the small Xml File that specifies them. When the file is changed, the Cache Item gets invalidated and the control automatically reloads the modified file, updating my changes instantly.

3) You can specify the name of the Xml file to use as a property of the control - so each MenuStrip on each page knows exactly which Xml file to use for the items it is supposed to display.

Here's an example of what one looks like, minus the page, and I also have a separate page where you can look at images of two different versions:

Here's a link to the bigger pictures.

When you download this solution, I'm going to include a MasterPage and two Default pages with two different versions of the control on them, so everything will integrate nicely in a nice site layout. The original CSS Layout came from a free template for SNews, a PHP CMS application; I've converted it to a nice MasterPage.

Now let's look at the code for the ASCX codebehind:

 1 using System;
 2 using System.Data;
 3 using System.Configuration;
 4 using System.Collections;
 5 using System.Web;
 6 using System.Web.Security;
 7 using System.Web.UI;
 8 using System.Web.UI.WebControls;
 9 using System.Web.UI.WebControls.WebParts;
10 using System.Web.UI.HtmlControls;
11 using System.Data.SqlClient;
12 
13 namespace MenuStrip
14 {
15     public partial class ucMenu : System.Web.UI.UserControl
16     {
17         private string menuFile = "Menu.xml";
18 
19         public string MenuFile
20         {
21             get { return menuFile; }
22             set { menuFile = value; }
23         }
24 
25         protected void Page_Load(object sender, EventArgs e)
26         {
27             PopulateMenu();
28         }
29 
30 
31             private void PopulateMenu()
32             {
33                 DataSet ds=new DataSet();
34                 if (Cache[menuFile] != null)
35                 {
36                     ds = (DataSet)Cache[menuFile];
37                 }
38                 else
39                 {
40                     ds.ReadXml(Server.MapPath(menuFile));
41                     Cache.Insert(menuFile,ds, new
42   System.Web.Caching.CacheDependency(Server.MapPath(menuFile)));
43 
44                 }
45                     DataTable dt = ds.Tables[0]; 
46                 HyperLink hl = null;
47                 string ctrlId = "";
48                 for (int i = 0; i < dt.Rows.Count; i++)
49                 {
50                     ctrlId = "HyperLink" + i.ToString();
51                     hl = (HyperLink)this.FindControl(ctrlId);
52                     hl.NavigateUrl = (string)dt.Rows[i]["NavigateUrl"];
53                     hl.Text = (string)dt.Rows[i]["Text"];
54                 }                
55            }
56     }
57 }

You see that the Menustrip control has a public MenuFile property which allows us to specify the Xml File in the declarative markup for the control, like so:

<uc1:ucMenu ID="UcMenu1" runat="server" MenuFile="Menu.Xml" />

Then, I have the control load the required file into a DataSet, Cache it and set a file-based CacheDependency, and it proceeds to "fill in" the NavigateUrl and Text Properties of a bunch of blank Hyperlink Controls that I have in the HTML Markup portion of the ASCX "Page". The rest is done via CSS. You can have as many "blank" Hyperlink controls in the HTML markup of the ASCX as you think you may have menu-items, controls that aren't populated by the code simply don't show up.

This may be a little different approach than other "menu" thingies that you have seen, I hope you like it. The solution you can download below has two fully working versions of the control, and the items point to actual pages on eggheadcafe.com (we'd like you to stick around while you are experimenting with it).

One last item - this is a WAP (Web Application Project) NOT a "WebSite" project. If you haven't installed the WAP add-in, you will find that the solution does not load. You can find out more about WAP along with a link to the download at ScottGu's Blog here.

Download the Visual Studio 2005 Web Application Project Solution that acompanies this article

Creating Custom Cache Dependency

2006-09-27T14:00:00.000-04:00

ASP.NET 2.0 offers you several ways to set a dependency between a cached item and a file(s), another cached item(s) or SQL Server database table. No doubt they satisfy most of the real world needs. However, at times the features offered by these dependencies are not sufficient. In such cases you can create your own dependency and use it instead of inbuilt ones. In this article you learn how this can be accomplished.
Read more...

Localization Made Easy with ASP.NET 2.0

2006-09-06T16:42:00.000-04:00

Do you have an ASP.NET application ready and now you want to translate it into different languages, or are you developing a new application for which you want to support localization? If yes, ASP.NET 2.0 makes it easier than ever before to do so.

More details here

ASP.NET Caching Dependencies

2006-08-25T10:32:00.000-04:00

The concept of Caching was introduced in ASP.NET 1.X and has been improved significantly in ASP.NET 2.0. Caching allows you to store commonly used items in the memory and thus not create them from scratch when they are requested. There are different types of Caching available in the .NET framework. In this article the author will introduce us to Caching dependencies.

View State: The Silent Perf Killer

2006-08-08T14:23:00.000-04:00

In some ways, view state is the greatest thing since sliced bread. After all, it’s view state that allows pages and controls to persist state across postbacks. That’s why you don’t have to write code to keep the text in a TextBox from disappearing when a button is clicked as you did in classic ASP, or requery a database and rebind a DataGrid following a postback.

But view state has a dark side, too: when it grows too large, it’s a silent performance killer. Some controls, such as TextBoxes, are judicious with view state. Others, notably DataGrids and GridViews, emit view state in proportion to the amount of information displayed. I cringe when I see a GridView displaying 200 or 300 rows of data. Even though ASP.NET 2.0 view state is roughly half the size of ASP.NET 1.x view state, one lousy GridView can easily cut the effective bandwidth of a connection between a browser and a Web server by 50 percent or more.

You can turn off view state for individual controls by setting EnableViewState to false, but some controls, particularly DataGrids, lose some of their functionality when denied the freedom to use view state. A much better solution to taming view state is keeping it on the server. In ASP.NET 1.x, you can override a page’s LoadPageStateFromPersistenceMedium and SavePageStateToPersistenceMedium methods and handle view state however you like. The overrides shown in the code below prevent view state from being persisted in a hidden field and persist it in session state instead.


protected override object LoadPageStateFromPersistenceMedium ()
{
    string key = Request.RawUrl + &quot;_VIEWSTATE&quot;;
    object state = Session[key];               
    return (state == null) ?
        base.LoadPageStateFromPersistenceMedium () : state;
}

protected override void
    SavePageStateToPersistenceMedium (object viewState)
{
    string key = Request.RawUrl + &quot;_VIEWSTATE&quot;;
    Session[key] = viewState;
}

Storing view state in session state is particularly effective when paired with the default session state process model—that is, when session state is stored in memory in the ASP.NET worker process. If session state is stored in a database instead, then only testing will show whether keeping view state in session state improves or degrades performance.

The same technique works in ASP.NET 2.0, but ASP.NET 2.0 offers a simpler means for persisting view state in session state. You begin by defining a custom page adapter whose GetStatePersister method returns an instance of the .NET Framework SessionPageStatePersister class:


public class SessionPageStateAdapter :
    System.Web.UI.Adapters.PageAdapter
{
    public override PageStatePersister GetStatePersister ()
    {
        return new SessionPageStatePersister(this.Page);
    }
}

Then you register the custom page adapter as the default page adapter by dropping an App.browsers file like the following into the application’s App_Browsers folder:


<browsers>
  <browser refID="Default">
    <controlAdapters>
      <adapter controlType="System.Web.UI.Page"
        adapterType="SessionPageStateAdapter" />
    </controlAdapters>
  </browser>
</browsers>

(You can name the file anything you like as long as it has a .browsers extension.) Thereafter, ASP.NET will load the page adapter and use the returned SessionPageStatePersister to persist all page state, including view state.

One downside to using a custom page adapter is that it acts globally for every page in the application. If you’d prefer to persist view state in session state for some pages but not for others, use the technique shown in the first snippet of this article. Additionally, you can run into issues with this technique if a user creates multiple browser windows within the same session.

Client-side programming with Atlas: Builder AU: Program

2006-05-04T15:46:00.000-04:00

Microsoft has developed its own approach to AJAX development called Atlas, which promises browser ubiquity as well as tight, albeit optional, ASP.NET integration. In this column, we survey the Atlas architecture to get a better understanding of how you may use it in your development work.

Optimizing Your Asp.Net Pages for Faster Loading and Better Performance

2006-05-03T13:55:00.000-04:00

In this article the author discusses some options for speeding up the loading of your ASP.NET pages. Some tips include using caching, control use, and data handling techniques.

Using ASP.NET HTTP Handlers to create a photo album

2003-12-21T23:29:00.000-05:00

In this article you'll learn about the .NET Framework's equivalent of ISAPI extensions: the ASP.NET HTTP Handlers. Using a photo album as example, the author explains the creation and configuration of HTTP Handlers and he discusses caching to improve performance.

Data binding and Web Services using Custom Collections

2003-12-09T09:19:00.000-05:00

The data binding capabilities in .NET are great, you can bind many controls to almost any type of data, but in some scenarios data binding has its limitations. For example data binding is not possible when using custom collections, instead of DataSets, coming from a Web Service. This article explains the problem and a possible, easy-to-use, solution: a class that dynamically builds wrapper classes at run time, which exposes the field member of the proxy classes as properties.

2003-12-05T12:34:00.000-05:00

Using Managed Components from Unmanaged Code:
Mansoor is back to explain .NET runtime's forward compatibility feature. Here he shows us how to access .NET components from COM components.

2003-12-05T12:24:00.000-05:00

Accessing Active Directory Through the .NET Framework:
The System.DirectoryServices namespace gives users access to some rudimentary user administration via ASP.NET. This article first reviews what the Active Directory (AD) is, then looks briefly at the actual System.DirectoryServices namespace itself, and finally presents the code that allows us to add, edit, and delete users.

2003-12-05T09:04:00.000-05:00

Designing Your Apps to Handle Loss of Connectivity Well:
Many applications have a built-in dependency on a live network connection that doesn't become obvious until you try to operate them on a disconnected device. This paper highlights techniques you can use to architect your applications to handle loss of connectivity in an intelligent way. This will lead to a better user experiences and greater customer satisfaction.

2003-12-04T22:36:00.000-05:00

Caching Google Web Service Request
This describes how to use the Google Web Service and serialization in order to cache Google search requests so that the website owner doesn't go past the 1000 request limit set by Google. This will allow you to limit the number of requests you make to the Google Web service. This is done by serializing the Google Request Object into an XML file and writing it to the disk. Then when a user does a search the search engine checks the cache before going to Google to request the search.

2003-12-04T13:26:00.000-05:00

Strategy to distribute secure database connection strings in an enterprise environment - .NET:
The following article discusses a simple strategy to maintain and distribute connection strings securely.

2003-12-03T20:31:00.000-05:00

ASP.NET.4GuysFromRolla.com: Quickly Editing an XML File
Today virtually all Web sites use a traditional relational database for persistent storage, retrieval and modification of data. Databases have numerous advantages, such as having a rich standardized querying language (SQL), providing transaction support, and good performance. Anytime you are building a professional-grade Web site, or are dealing with large amounts of data, it behooves you to use a database to store and retrieve the data. Sometimes, though, for smaller Web sites or for small amounts of data, a database seems like a bit of overkill. Too, for Web site hosting companies that charge extra to have database support, it might not make sense to pay this extra fee if you only need to store a tiny bit of persistent information. This article, by Zubair Ahmed, demonstrates how a simple XML file can be used to store, retrieve, modify and even delete records with the help of the DataGrid Web control.

Below is a sneak-peak of the user interface we'll be building for editing this XML file. Note that by the end of this article you'll be able to build a means to insert new records in an XML file, as well as update and delete existing records. Additionally, feel free to check out the live demo.

2003-12-03T15:09:00.000-05:00

Bind a Datalist to a Remote XML File:
In this article we will cover binding a remote XML file to a datalist. In this specific example, the remote file will be an RSS file containing syndicated content.

2003-12-03T14:45:00.000-05:00

Hosting the ASP.NET runtime in your own application - part 2:
In this second article you will learn how to create an application that enables running an ASP.NET application from a cd-rom.

2003-12-03T14:44:00.000-05:00

Hosting the ASP.NET runtime in your own application - part 1:
It's quite easy to host the ASP.NET runtime in your own application. This first article in a series of two demonstrates how to execute ASP.NET pages and display the result in Internet Explorer.

2003-12-03T14:38:00.000-05:00

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

2003-12-03T14:32:00.000-05:00

Adding Attributes to an Object Within a Datalist:
In this article we cover the difference between adding attributes to objects directly and objects contained within a datalist. In this specific example we will add some Javascript behind an image button for a confirmation dialog.

2003-12-03T14:25:00.000-05:00

Highlighted Hovering and Anywhere Selecting A DataGrid Row

2003-12-03T13:29:00.000-05:00

How To Pass Parameters to Threads in Windows Forms Applications and Get Results:
Launching new threads is easy, but it's not as obvious how you can pass parameters to the threads and get the results back. In addition, accessing Windows Forms controls from multiple threads can cause problems. In this article, you'll see how to pass parameters, receive results, and access controls safely from multiple threads in a Windows Forms application.

2003-12-03T13:17:00.000-05:00

Using System.DirectoryServices to Search the Active Directory
Duncan Mackenzie describes how to use the System.DirectoryServices namespace to search for information in Microsoft Active Directory.