Outsourcing to Sleestak

The problem with computer literacy

jamesa — Mon, 06 Oct 2008 18:08:00 GMT

A recent post on Boing Boing is titled Paper and pencil better for the brain than software? The gist of the article and its associated links is that software, in guiding us through common tasks, actually makes us dumber. The Dutch psychologist Christof van Nimwegen has performed studies demonstrating the deleterious effects of being plugged-in. From the post:

"Van Nimwegen says much software turns us into passive beings, subjected to the whims of computers, randomly clicking on icons and menu options. In the long run, this hinders our creativity and memory, he says."

This certainly sounds right to me, from personal experience. About a year ago, my company gave away GPS navigation devices as Christmas gifts to all the consultants. The results are twofold. On the one hand, we all make our appointments on time now, because we don't get lost anymore. On the other, we have all lost our innate sense of direction -- that essential skill that got the species through the hunter-gatherer phase of our development. Without my GPS, I am effectively as blind as a bat without echolocation.

In Charles Stross's novel about the near future, Accelerando, this experience is taken a step further. The protagonist Manfred Macx is at one point mugged on the street, and his connection to the Internet, which he carries around with him hooked up to his glasses, is taken away. As a man of the pre-singularity, however, his personality has become so distributed over search engines and data portals that without this connection he is no longer able to even identify himself. This is the nightmare of the technologically dependent.

Doctor van Nimwegen's study recalls Plato's ambivalence about the art of writing. His mentor Socrates, it may be remembered, never put anything to writing, which he found inherently untrustworthy. Consequently all we know of Socrates comes by way of his disciple Plato. Plato, in turn, was a poet who ultimately became distrustful of his own skills, and railed against it in his philosophical writings. From the modern viewpoint, however, whatever it is that we lose when we put "living" thoughts down to writing, surely it is only through poetry that we are able to recover and sustain it.

It is through poetic imagery that Plato explains Socrates's misgivings about letters in the Phaedrus:

At the Egyptian city of Naucratis, there was a famous old god, whose name was Theuth; the bird which is called the Ibis is sacred to him, and he was the inventor of many arts, such as arithmetic and calculation and geometry and astronomy and draughts and dice, but his great discovery was the use of letters. Now in those days the god Thamus was the king of the whole country of Egypt; and he dwelt in that great city of Upper Egypt which the Hellenes call Egyptian Thebes, and the god himself is called by them Ammon. To him came Theuth and showed his inventions, desiring that the other Egyptians might be allowed to have the benefit of them; he enumerated them, and Thamus enquired about their several uses, and praised some of them and censured others, as he approved or disapproved of them. It would take a long time to repeat all that Thamus said to Theuth in praise or blame of the various arts. But when they came to letters, This, said Theuth, will make the Egyptians wiser and give them better memories; it is a specific both for the memory and for the wit. Thamus replied: O most ingenious Theuth, the parent or inventor of an art is not always the best judge of the utility or inutility of his own inventions to the users of them. And in this instance, you who are the father of letters, from a paternal love of your own children have been led to attribute to them a quality which they cannot have; for this discovery of yours will create forgetfulness in the learners' souls, because they will not use their memories; they will trust to the external written characters and not remember of themselves. The specific which you have discovered is an aid not to memory, but to reminiscence, and you give your disciples not truth, but only the semblance of truth; they will be hearers of many things and will have learned nothing; they will appear to be omniscient and will generally know nothing; they will be tiresome company, having the show of wisdom without the reality.

We can certainly see aspects of Manfred Macx's experience of disorientation in our dependence on tools like Google and Wikipedia, which provide us all with the same degree of wisdom, or at least the same show of wisdom. In tracking down the above quote about Theuth, I had to rely on a vague reminiscence that this memory passage occurred in either the Timaeus or the Phaedrus, and then used my browser search functionality to track down the specific paragraph. Very handy, that search feature. But how much more wonderful it would have been had I been able to call that up from my own theater of memory.

My only stand against the steady march of progress (from which I make my living, it should be remembered) is that I turn my spell-checker off when I write emails and articles. A consulting manager recently chastised me for this practice, which he found error prone and somewhat irresponsible. To this I could only reply, "but I already know how to spell."

I should have added, "...for now."

Visual Studio 2008 SP1 Toolbox Crash

jamesa — Sat, 04 Oct 2008 17:18:27 GMT

For the past month or so, whenever I tried to add a control to my Visual Studio Toolbox, the IDE would shut itself down. My solution, of course, was to avoid adding tools to my Toolbox.

Finally I decided that I needed to do something, ahem, a little smarter. The specific problem occurred when I tried to use the Context Menu's "Choose Items..." option on my toolbox. It turns out that the Power Commands (when did I install that?) has a conflict with VS 2008. This apparently can also mess up the class viewer in Visual Studio 2008. There are two work-arounds for this. The first is to hack a config file for your IDE settings. That solution can be found here: http://social.msdn.microsoft.com/Forums/en-US/vssetup/thread/e2434065-9921-4861-b914-9cc9d6c55553/

Unfortunately this didn't work for me. The second work-around is simply to uninstall the Power Commands. If you go into Add/Remove Programs, it is listed as PowerCommands for Visual Studio 2008.

Reflection

jamesa — Mon, 08 Sep 2008 18:55:00 GMT

Like may others, I recently received the fateful email notifying me that Lutz Roeder will be giving up his work on .NET Reflector, the brilliant and essential tool he developed to peer into the internal implementation of .NET assemblies. Of course the whole idea of reflecting into an assembly is cheating a bit, since one of the principles of OO design is that we don't care about implementations, only about contracts. It gets worse, since one of the main reasons for using .NET Reflector is to reverse engineer someone else's (particularly Microsoft's) code. Yet it is the perfect tool when one is good at reading code and simply needs to know how to do something special -- something that cannot be explained, but must be seen.

While many terms in computer science are drawn from other scientific fields, reflection appears not to be. Instead, it is derived from the philosophical "reflective" tradition, and is a synonym for looking inward: introspection. Reflection and introspection are not exactly the same thing, however. This is a bit of subjective interpretation, of course, but it seems to me that unlike introspection, which is merely a turning inward, reflection tends to involve a stepping outside of oneself and peering at oneself. In reflection, there is a moment of stopping and stepping back; the "I" who looks back on oneself is a cold and appraising self, cool and objective as a mirror.

Metaphors pass oddly between the world of philosophy and the world of computer science, often giving rise to peculiar reversals. When concepts such as memory and CPU's were being developed, the developers of these concepts drew their metaphors from the workings of the human mind. The persistent storage of a computer is like the human faculty of memory, and so it was called "memory". The CPU works like the processing of the mind, and so we called it the central processing unit, sitting in the shell of the computer like a homunculus viewing a theater across which data is streamed. Originally it was the mind that was the given, while the computer was modeled upon it. Within a generation, the flow of metaphors has been reversed, and it is not uncommon find arguments about the computational nature of the brain based on analogies with the workings of computers. Isn't it odd that we remember things, just like computers remember things?

The ancient Skeptics had the concept of epoche to describe this peculiar attitude of stepping back from the world, but it wasn't until Descartes that this philosophical notion became associated with the metaphor of optics. In a letter to Arnauld from 1648, Descartes writes:

"We make a distinction between direct and reflective thoughts corresponding to the distinction we make between direct and reflective vision, one depending on the first impact of the rays and the other on the second."

This form of reflective thought, in turn, also turns up in at an essential turning point in Descartes' discussion of his Method, when he realizes that his moment of self-awareness is logically dependent on something higher:

"In the next place, from reflecting on the circumstance that I doubted, and that consequently my being was not wholly perfect, (for I clearly saw that it was a greater perfection to know than to doubt,) I was led to inquire whence I had learned to think of something more perfect than myself;"

Descartes uses the metaphor in several places in the Discourse on Method. In each case, it is as if, after doing something, for instance doubting, he is looking out the corner of his eye at a mirror to see what he looks like when he is doing it, like an angler trying to perfect his cast or an orator attempting to improve his hand gestures. In each case, what one sees is not quite what one expects to see; what one does is not quite what one thought one was doing. The act of reflection provides a different view of ourselves from what we might observe from introspection alone. For Descartes, it is always a matter of finding out what one is "really" doing, rather than what one thinks one is doing.

This notion of philosophical "true sight" through reflection is carried forward, on the other side of the channel, by Locke. In his Essay Concerning Human Understanding, Locke writes:

"This source of ideas every man has wholly in himself; and though it be not sense, as having nothing to do with external objects, yet it is very like it, and might properly enough be called internal sense. But as I call the other Sensation, so I call this REFLECTION, the ideas it affords being such only as the mind gets by reflecting on its own operations within itself. By reflection then, in the following part of this discourse, I would be understood to mean, that notice which the mind takes of its own operations, and the manner of them, by reason whereof there come to be ideas of these operations in the understanding."

Within a century, reflection becomes so ingrained in philosophical thought, if not identified with it, that Kant is able to talk of "transcendental reflection":

"Reflection (reflexio) is not occupied about objects themselves, for the purpose of directly obtaining conceptions of them, but is that state of the mind in which we set ourselves to discover the subjective conditions under which we obtain conceptions.
...
"The act whereby I compare my representations with the faculty of cognition which originates them, and whereby I distinguish whether they are compared with each other as belonging to the pure understanding or to sensuous intuition, I term transcendental reflection."

In the 20th century, the reflective tradition takes a peculiar turn. While the phenomenologists continued to use it as the central engine of their philosophizing, Wilfred Sellars began his attack on "the myth of the given" upon which phenomenological reflection depended. From an epistemological viewpoint, Sellars questions the implicit assumption that we, as thinking individuals, have any privileged access to our own mental states. Instead, Sellars posits that what we actually have is not clear vision of our internal mental states, but rather a culturally mediated "folk psychology" of mind that we use to describe those mental states. In one fell swoop, Sellars sweeps away the Cartesian tradition of self-understanding that informs the cogito ergo sum.

In a sense, however, this isn't truly a reversal of the reflective tradition but merely a refinement. Sellars and his contemporary heirs, such as the Churchlands and Daniel Dennett, certainly provided a devastating blow to the reliability of philosophical introspection. The Cartesian project, however, was not one of introspection, nor is the later phenomenological project. The "given" was always assumed to be unreliable in some way, which is why philosophical "reflection" is required to analyze and correct the "given." All that Sellars does is to move the venue of philosophical reflection from the armchair to the laboratory, where it no doubt belongs.

A more fundamental attack on the reflective tradition came from Italy approximately 200 hundred years before Sellars. Giambattista Vico saw the danger of the Cartesian tradition of philosophical reflection as lying in its undermining of the given of cultural institutions. A professor of oratory and law, Vico believed that common understanding held a society together, and that the dissolution of civilizations occurred not when those institutions no longer held, but rather when we begin to doubt that they even exist. On the face of it, it sounds like the rather annoying contemporary arguments against "cultural relativism", but is actually a bit different. Vico's argument is rather that we all live in a world of myths and metaphors that help us to regulate our lives, and in fact contribute to what makes us human, and able to communicate with one another. In the 1730 edition of the New Science, Vico writes:

"Because, unlike in the time of the barbarism of sense, the barbarism of reflection pays attention only to the words and not to the spirit of the laws and regulations; even worse, whatever might have been claimed in these empty sounds of words is believed to be just. In this way the barbarism of reflection claims to recognize and know the just, what the regulations and laws intend, and endeavors to defraud them through the superstition of words."

For Vico, the reflective tradition breaks down those civil bonds by presenting man as a rational man who can navigate the world of social institutions as an individual, the solitary cogito who sees clearly, and cooly, the world as it is.

This begets the natural question, does reflection really provide us with true sight, or does it merely dissociate ourselves from our inner lives in such a way that we only see what we want to see? In computer science of course (not that this should be any guide to philosophy) the latter is the case. Reflection is accomplished by publishing metadata about a code library which may or may not be true. It does not allow us to view the code as it really is, but rather provides us a mediated view of the code, which is then associated with the code. We assume it is reliable, but there is no way of really knowing until something goes wrong.

AJAX Control Toolkit: Script Only

jamesa — Tue, 26 Aug 2008 16:15:04 GMT

I previously posted about how to use the Microsoft Ajax Library in order to provide Globalization script functionality without using the ScriptManager control. Why would you want to do this?

One issue is that Microsoft is currently working on the ASP.NET MVC framework, which will provide a way of doing web applications that is more familiar to PHP and JSP programmers. In other words, it doesn't use the WebForms infrastructure that has underpinned Microsoft's whole approach to web development for the past six years. The original promise of WebForms was to abstract web development so it looks more like traditional Windows Forms development. In order to accomplish this, the developers at Microsoft have worked hard to abstract the underlying web technology using windows components that render html and emit client script for the developer.

But now the tide is turning, and with WPF and XAML, Microsoft's newest technology for building desktop applications, we are seeing a transition to the development metaphors that we have become accustomed to in web development.

ASP.NET AJAX was originally developed following the WebForms paradigm. While other AJAX frameworks provided script libraries that you needed to manipulate using client script (typically javascript), Microsoft provided their framework wrapped in controls like the ScriptManager and the UpdatePanel. Even the Ajax Control Toolkit, the Microsoft backed opensource project that extends ASP.NET AJAX with additional controls, follows this model.

But the MVC model doesn't follow this model. It follows the model followed by every other vendor of web technology.

So how do ASP.NET MVC and ASP.NET AJAX come together if they follow these radically different models? Well ... the Microsoft AJAX team also provides the underlying scripts for their framework in the Microsoft Ajax Library, which can be used in JSP, PHP, or even your traditional HTML page if you are willing to do the muscle work required to hook into them. They can also, of course, be used with the MVC framework.

The Ajax Control Toolkit now also exposes its underlying script files for general use, allowing use to get all the great ACT functionality with WebForms or a ScriptManager. The only problem is that learning to use the library without controls to manage our state and emit our code is difficult, and there is very little online help to get you started.

Stephen Walther is now helping people through this difficulty on his blog, and it is a wonderful thing. He has already tackled the Popup Calendar and Autocomplete. Expect to hear more from him in the near future. I can't wait to see what he does next.

h/t to Bertrand Leroy's Tales From the Evil Empire for highlighting this.

Recipe: Session Expired Monitor with ASP.NET AJAX

jamesa — Mon, 25 Aug 2008 19:19:00 GMT

code download

Sessions are a way of preserving information on a web site between page hits, allowing the programmer to emulate a stateful application when, in fact, web pages are not really stateful. They are also among the banes of web development, since sessions eventually timeout when there is no interaction between the user and the web app for a prolonged period of time. In ASP.NET, this period has a default of 20 minutes, which is really hardly enough time to pick up a donut, refill one's coffee, and chat with fellow workers before returning to one's computer. What this often means is that the user, upon returning to their computer and continuing work after a 20 minute break will find that all of the data entry they have been doing has been lost. Worse, strange errors will begin to appear in his web browser if the loss of a session is not handled gracefully.

The most common workaround is to increase the session grace period, called the session timeout. This is set in your web.config file, and typically looks like this (the timeout period is measured in minutes):

  <system.web>
    <sessionState
      mode="InProc"
      cookieless="false"
      timeout="20"
     />
  </system.web>

A second way of handling this is to add extra code to an app that keeps the session state alive even if the user isn't doing anything.

A third, and the most common, way is to provide code that redirects a user to a "session expired" page if they try to interact with a web page for which the session has timed-out. This can be a bit awkward, however, since it is a passive solution that can cause the user some dismay as they hit a submit key only to be taken to a completely unexpected page.

This post deals with an active approach to the same problem. When the user's session has expired, it will generate a popup message in the user's browser window letting him know that he has been inactive for too long. Additionally it can redirect the browser to a new page with a warning message letting him know what happened. The user still loses all of his work, of course, but at least this way he knows what happened when he returns to his desk following his coffee break.

This solution uses three tricks. One is the event model for Master Pages in ASP.NET: whenever a Content Page is refreshed, its OnLoad event is called, along with the OnLoad events of the Master Page and any user controls hosted by either the Content Page or the Master Page (the actual order of these events is 1. controls on the Master Page, 2. controls in the Content Page, 3. the Master Page and finally 4. the Content Page).

The second trick is the way ASP.NET Extensions Timer control gets reset. This is done simply by setting the interval to a new value. Every time the interval is set to a new value, or even the same value, the countdown on the timer begins again.

The third trick is that the session timeout one sets in the web.config file can be read programmatically simply by querying a property of the Session object.

Putting all of this together, one can build a web user control that simply sits on a Master Page and knows when the user session is ready to expire. It resets itself to the full timeout period any time a Content Page is refreshed. when the session expires, the user control can raise an informative message, redirect to another page, or, potentially, simply extend the session timeout (not covered here, but easy to do if you are interested).

A user control to monitor the session timeout is included in the code sample linked at the top of this post. Here is how you can build your own.

Session Timeout Monitor Recipe:

Ingredients:

One Master Page
One User Control
An Update Panel
An ASP.NET Ajax Extensions Timer
A Panel control
A Button control

1. Create a new User Control in your project.

2. Drop an Update Panel on the User Control and set its mode property to "Always".

3. Add an Extensions Timer (not to be confused with the Futures TimerControl) to your project, dropping it in the Update Panel. Name it TimerTimeout.

Normally, this configuration of the timer control and a conditional update panel is used to refresh a portion of a web page on a regular schedule, for instance in order to create a self-updating clock display. In this case, however, the timer and update panel are used simply to trigger a notification that the session has expired.

4. In the User Control's code behind, add the following lines to the OnLoad event:

        protected void Page_Load(object sender, EventArgs e)
        {
            int milliseconds = 60000;
            TimerTimeout.Interval = Session.Timeout * milliseconds;
        }

This event will be called any time a content page is refreshed. Whenever this happens, the code inside the event handler resets the AJAX Extensions Timer control to the full session lifespan as set in the web config file, in effect making the timeout for the Timer match the timeout for the session.

Since the Timer control's Interval property is measured in milliseconds, while the session.Timeout is measured in minutes, a conversion factor of sixty thousand must be used to translate one time period into the other.

To finish this notifier, the Timer's Tick event needs to be handled. The Tick event gets called when the Timer's Interval finally runs out. In this implementation, the Tick event can either generate a popup message or cause a page redirect.

5. Place a Panel inside the Update Panel. Set its Visible property to false.

6. Write a simple message inside the Update Panel, such as "Your session has expired."

7. Drop a Button inside the Panel. This Button will be used to allow the user to hide the popup message.

8. Add a public property to the User Control called SessionExpiredRedirect:

        private string _sessionExpiredRedirect;

        public string SessionExpiredRedirect
        {
            get { return _sessionExpiredRedirect; }
            set { _sessionExpiredRedirect = value; }
        }

This will be used to set the web page to which the Timer will redirect the user upon session timeout. If no value is set, a popup message will appear, instead.

9. Handle the Timer's Tick event:

        protected void TimerTimout_Tick(object sender, EventArgs e)
        {

            if (!string.IsNullOrEmpty(SessionExpiredRedirect))
            {
                if (SessionExpiredRedirect.IndexOf("~")==0)
                    Response.Redirect(
                        VirtualPathUtility.ToAppRelative(
                        SessionExpiredRedirect));
                else
                    Response.Redirect(SessionExpiredRedirect);
            }
            else
                this.PanelTimeout.Visible = true;
        }

This handler checks to see if a value has been set for the SessionExpiredRedirect property. If not, it makes the Panel control inside the Update Panel visible.

10. To make the Panel control truly popup, set its CssClass property to "timeoutMessage". Add the following css style to the page.

<style type="text/css">
.timoutMessage
{
    position:absolute;
    top:100px;
    left:200px;
    background-color:#F5F7F8;
    border-style:groove;
    border-color:Navy;
    padding:15px;
}
</style>

11. Finally, compile this User Control and drag it on to the Master Page. In design mode, the user control will display a misleading exception message. Just ignore it.

12. Make sure the Master Page includes an ASP.NET AJAX Script Manager component.

This completes the recipe. Any Content Page in this project will now automatically include the timeout monitor you have built. Cookies are optional: this recipe will work with a session managed either with cookies or in cookieless mode. It will only work if the session mode is InProc.

Garnish with buttered radishes. Serve at room temperature.

Extending the Ajax Control Toolkit Tab Container with Lazy Loading

jamesa — Mon, 25 Aug 2008 15:06:00 GMT

download source code

ASP.NET has been missing a good, free tab control for a long time. With the ACT Tab Container, we were finally given one. It typically runs in client-side only mode, but can interact with server-code if we set its AutoPostback property to true.

Compared to what we had before, it is a huge improvement. The peculiar thing about it, however, is that it isn't actually an Ajax control. It doesn't use asynchronous postbacks or web service calls to talk to the server -- instead you just have these two mode: run it using client script only, or run it using server-side events and code-behind only.

So a few months ago I rectified this for a project, and only found out afterwards that Matt Berseth had already outlined the technique on his blog. You basically run the tab container in client-side mode, and add update panels to the tab panels that you want to be ajaxy. You then hook up the client-side ActivePageChanged event in such a way that it spoofs the Update Panel contained in the tab, causing an asynchronous (or partial) postback.

Matt also gave this technique a cool name. He called it 'lazy loading the tab panel'. Like lazy loading in OOP, using this technique the update panels inside each tab panel only do something when its tab is selected. Information is loaded only when its needed, and not before.

I must admit that I hold some resentment against Matt for coming up with this first, and for coming up with the cool moniker for it. On the other hand, the solution I came up with encapsulates all of the javascript needed for this into a nice simple extender control that you can drop on your page, which his does not, and I'm rather proud of this.

The VS 2008 project for this extender is linked at the top of this post. To use it, you need to compile the project and add the compiled assembly to your project, or else just add the project to your solution and add a project reference.

1. Drop the TabContainerExtender control into your page.

2. Set the Extender's TargetControlID property to your TabContainer's ID.

3. In the RegisterUpdatePanels element of the Extender, map your tabs to your update panels. This mapping tells the extender which Update Panels to activate when each tab is selected.

Your markup will look something like this:

    <cc2:TabContainerExtender ID="TabContainerExtender1" 
    runat="server" 
    TargetControlID="TabContainer1" OnActiveTabChanged="ActiveTabChanged">
    <RegisterUpdatePanels>
    <cc2:UpdatePanelInfo TabIndex="0" UpdatePanelID="UpdatePanel1" />
    <cc2:UpdatePanelInfo TabIndex="1" UpdatePanelID="UpdatePanel2" />
    <cc2:UpdatePanelInfo TabIndex="2" UpdatePanelID="UpdatePanel3" />
    </RegisterUpdatePanels>
    </cc2:TabContainerExtender>

4. If you want to add some code-behind to your active tab changed event, add set the OnActiveTabChanged property of the Extender to the name of your handler. The thrown event will pass the correct Index number for the active Tab, as well as the ID of the mapped Update Panel. The handler's signature looks like this:

        protected void ActiveTabChanged(int index, string panelID)
        {
            ...
        }

I highly encourage you to read Matt Berseth's blog entry (which I have to admit is pretty good) to get a clear idea of the techniques being applied in this ajax extender. If you just need a quick solution, however, feel free to download this code from the link at the top and use it any way you like with no strings attached. There is a sample project attached to the solution that will demonstrate how to use the Tab Container Extender, in case you run into any problems with lazy loading your panels.

For reference, here is the code for the sample implementation, which loads controls on the fly based on the tab selected:

    <cc1:TabContainer ID="TabContainer1" runat="server">
    <cc1:TabPanel ID="TabPanel1" runat="server" HeaderText="Tab Panel 1">
    <ContentTemplate>
        <asp:UpdatePanel ID="UpdatePanel1" runat="server">
        <ContentTemplate>
        Content 1 ...
        <br />
            <asp:PlaceHolder ID="PlaceHolder1" runat="server"></asp:PlaceHolder>      
        </ContentTemplate>
        </asp:UpdatePanel>    
    </ContentTemplate>
    </cc1:TabPanel>
        <cc1:TabPanel ID="TabPanel2" runat="server" HeaderText="Tab Panel 2">
    <ContentTemplate>
        <asp:UpdatePanel ID="UpdatePanel2" runat="server">
        <ContentTemplate>
        Content 2 ...
        <br />
            <asp:PlaceHolder ID="PlaceHolder2" runat="server"></asp:PlaceHolder>      
        </ContentTemplate>
        </asp:UpdatePanel>    
    </ContentTemplate>
    </cc1:TabPanel>
        <cc1:TabPanel ID="TabPanel3" runat="server" HeaderText="Tab Panel 3">
    <ContentTemplate>
        <asp:UpdatePanel ID="UpdatePanel3" runat="server">
        <ContentTemplate>
        Content 3 ...
        <br />
            <asp:PlaceHolder ID="PlaceHolder3" runat="server"></asp:PlaceHolder>      
        </ContentTemplate>
        </asp:UpdatePanel>    
    </ContentTemplate>
    </cc1:TabPanel>
    </cc1:TabContainer>
    <cc2:TabContainerExtender ID="TabContainerExtender1" 
    runat="server" 
    TargetControlID="TabContainer1" OnActiveTabChanged="ActiveTabChanged">
    <RegisterUpdatePanels>
    <cc2:UpdatePanelInfo TabIndex="0" UpdatePanelID="UpdatePanel1" />
    <cc2:UpdatePanelInfo TabIndex="1" UpdatePanelID="UpdatePanel2" />
    <cc2:UpdatePanelInfo TabIndex="2" UpdatePanelID="UpdatePanel3" />
    </RegisterUpdatePanels>
    </cc2:TabContainerExtender>

Ajax AutoComplete Extender with WCF

jamesa — Fri, 22 Aug 2008 14:41:00 GMT

The problem with conjuring tricks is that they lose practically all their glamour once you find out how they are done. It's very cool to see David Blaine walk down the street, do a few passes over his hand, and resurrect a fly which proceeds to flee. It's rather disappointing to do a google search and discover that in order to prepare for this trick, the first requirement is that you freeze a fly.

My trick is to make an autocomplete extender from the Ajax Control Toolkit call a WCF service instead of an asmx service. For this recipe, I assume that you are already familiar with the autocomplete extender, and that you are using Visual Studio 2008. I warn you in advance -- my trick disappoints. It is so trivially easy that, once the technique spreads, it is very unlikely to impress your colleagues at work, much less get you a date with a supermodel.

Start by creating a new web project called AutocompleteWCF. Add a reference to the AjaxControlToolkit.dll. Open up the default aspx page that is generated with your project, and add the following code to:

    <form id="form1" runat="server">
    <asp:ScriptManager ID="ScriptManager1" runat="server">
    </asp:ScriptManager>
    <div>
            <asp:TextBox runat="server" ID="myTextBox" Width="300" autocomplete="off" />
            <ajaxToolkit:AutoCompleteExtender
                runat="server" 
                BehaviorID="AutoCompleteEx"
                ID="autoComplete1" 
                TargetControlID="myTextBox"
                ServicePath="Autocomplete.svc" 
                ServiceMethod="GetCompletionList"
                MinimumPrefixLength="0" 
                CompletionInterval="1000"
                EnableCaching="true">
            </ajaxToolkit:AutoCompleteExtender>
    </div>
    </form>

This is the standard demo code that is shipped with the Ajax Control Toolkit Sample Website. I've simplified it a bit by removing the animations. The only significant change I've made is to change the ServicePath from Autocomplete.asmx to Autocomplete.svc, the latter being the extension for a WCF service.

The next step is to create our service and add a GetCompletionList operation to it. The easiest way to do this is to go to Add | New Item and just select the Ajax-enabled WCF Service item template, but this would be so easy that it is hardly worth doing.

Instead, create a new WCF Service using the WCF Service Item Template and call it Autocomplete.svc. Visual Studio will automatically generate a service interface for you. Delete the interface. We don't need it. (To be more specific, I don't know how to get this to work with an interface, so I'm just going to ignore that it is possible.)

Again, I am going to rip off the ACT sample app and just borrow the code from their webservice and place it in our WCF service. The WCF service class (Autocomplete.svc.cs) will look like this:

    [ServiceContract(Namespace = "")]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class Autocomplete
    {
        [OperationContract]
        public string[] GetCompletionList(string prefixText, int count)
        {
            if (count == 0)
            {
                count = 10;
            }
            if (prefixText.Equals("xyz"))
            {
                return new string[0];
            }
            Random random = new Random();
            List<string> items = new List<string>(count);
            for (int i = 0; i < count; i++)
            {
                char c1 = (char)random.Next(65, 90);
                char c2 = (char)random.Next(97, 122);
                char c3 = (char)random.Next(97, 122);
                items.Add(prefixText + c1 + c2 + c3);
            }
            return items.ToArray();
        }

A few things worth noting:

1. Autocomplete does not implement the IAutocomplete Interface. Even though this is generated automatically, with the WCF Service item template, you should remove it.

2. The service contract has a blank Namespace explicitly declared.

3. The ASPNetCompatibilityRequirements attribute must be added to our class.

This takes care of the code that calls the WCF service, as well as the service itself. We now have rig up the web.config file. If you've been working with WCF for any length of time, then you know that this is where the problems usually occur. Fortunately, the configuration is fairly simple. You need to set up an endpoint behavior for your service that enables web scripting (much the way asmx web services must be decorated with the ScriptService attribute in order to be called from client-script). You also will need to turn AspNetCompatibilityEanbled on for the hosting environment.

    <system.serviceModel>
        <behaviors>
            <endpointBehaviors>
                <behavior name="AjaxBehavior">
                    <enableWebScript/>
                </behavior>
            </endpointBehaviors>
        </behaviors>
        <serviceHostingEnvironment aspNetCompatibilityEnabled="true"/>
        <services>
            <service name="AutocompleteWCF.Autocomplete">
                <endpoint address="" behaviorConfiguration="AjaxBehavior" binding="webHttpBinding" contract="AutocompleteWCF.Autocomplete"/>
            </service>
        </services>
    </system.serviceModel>

And that is all you need to do make the AutoComplete Extender work with a WCF service instead of an asmx web service. I told you it would be unimpressive.

Of course, using a WCF service for Ajax has all the limitations that using an asmx file for Ajax did. First of all, you can't call a service that is in a different domain than the page which hosts your client-code. This is a security feature, to prevent malicious code from redirecting your harmless javascript to something nasty on the world wide web.

Second, you can't call just any service from your client-side code. The service must be explicitly marked as something that can be called from client code. In asmx web services, we used ScriptService for this. In WCF services, we similarly use EnableWebScript binding property.

Now I feel like I've wasted your time, so here's a YouTube video of David Blaine to make up for it. And remember, David Blaine is to Chris Angel what Daisy Duke was to Alexis Carrington. It's an existential thing, and at some point, you've just got to pick sides and stay put in a way that will determine who you are for the rest of your life.

Are you a David Blaine/Daisy Duke kind of person or are you a Chris Angel/Alexis Carrington sort? Do some soul searching and please let me know what you learn about yourself.

ASP.NET AJAX: Script Globalization without the ScriptManager

jamesa — Fri, 22 Aug 2008 14:40:00 GMT

I just spent about four hours trying to solve a problem I'll probably never actually encounter in the wild. Someone posted on the asp.net forums about script globalization using ASP.NET AJAX. This can be set up pretty easily by simply using the ScriptManager control and setting its EnableScriptGlobalization property to true. ScriptManager takes care of importing the necessary scripts and handling all the underlying code required to make things work.

What the seeker on the forums wanted to know, however, was whether this could be accomplished without the ScriptManager. In theory, all the ASP.NET AJAX framework scripts can be downloaded and used in a non-platform dependent manner.

Certain software problems are ubiquitous, and people tend to fall over themselves blogging and posting about them until Microsoft or some other vendor eventually either fixes the problem and it goes away. On the other hand, there are problems in the software bestiary that are so rare that working on them is the programming equivalent of doing cryptozoology.

This was a juicy problem of that sort. And I believe I have a solution. It basically involves redoing some of what the ScriptManager does automatically, but what the hey.

To support globalization in ecmascript, the ScriptManager basically sets a variable called __cultureInfo behind the scenes. This is then used by various ASP.NET AJAX script methods to provide formatting information. This is actually explained in the Microsoft documentation for the feature.

Behind the scenes, it seems clear, the ScriptManager is querying the CurrentUICulture of the current thread in order to determine the browser's preferred language, and passing this to the __cultureInfo variable. The trick, then, is to determine the format of the culture data passed to __cultureInfo.

Here I had to use reflection to discover that there is an internal ClientCultureInfo type in the Sys.Web.Extensions assembly. It made sense that this was being serialized and passed to the __cultureInfo variable. With some trial and error, I finally got the serialization correct.

To make this work, you will need to download the Ajax Framework Library, which is a collection of javascript files. You will need to import the MicrosoftAjax.js file into your web project, and then reference it in your page, like this:

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

You will also need to create the ClientCultureInfo class for your project, and make sure that it is serializable. I tried DataContractJsonSerializer class to do my serializing, but had problem getting the DateTimeFormatInfo type to serialize correctly, so I finally opted to use the now obsolete JavaScriptSerializer. Here's what the class looks like:

    public class ClientCultureInfo
    {
        public string name;
        public DateTimeFormatInfo dateTimeFormat;
        public NumberFormatInfo numberFormat;
        public ClientCultureInfo(CultureInfo cultureInfo)
        {
            this.name = cultureInfo.Name;
            this.numberFormat = cultureInfo.NumberFormat;
            this.dateTimeFormat = cultureInfo.DateTimeFormat;
        }
        public static string SerializedCulture(ClientCultureInfo info)
        {
            JavaScriptSerializer js = new JavaScriptSerializer();
            return js.Serialize(info);
        }
    }

Now that we have the culture info formatted correctly, we need to be able to pass it to the client variable. We'll create a public property in the code-behind that is accessible from the client, and set its value in the Page.Load event handler:

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                CultureInfo cultureInfo = System.Threading.Thread.CurrentThread.CurrentUICulture;
                ClientCultureInfo o = new ClientCultureInfo(cultureInfo);
                SerializedCulture = ClientCultureInfo.SerializedCulture(o);
            }
        }
        public string SerializedCulture
        {
            set
            {
                ViewState["kultur"] = value;
            }
            get
            {
                if (ViewState["kultur"] == null)
                    return string.Empty;
                else
                    return ViewState["kultur"].ToString();
            }
        }

Finally, we need to use this code-behind property to set __cultureInfo. Just add the following script block to your markup in order to set the current culture:

<script type="text/javascript">
    // Get the name field of the CurrentCulture object   
    var __cultureInfo = '<%= this.SerializedCulture %>';
    Sys.CultureInfo.CurrentCulture = Sys.CultureInfo._parse(__cultureInfo);
</script>

I added this to the bottom of the page. To test whether this works, you will need to set the language property of your browser (if you are using IE, like I am). I set mine to French for testing. Then append the following script block below the one setting the culture above:

<script type="text/javascript">
    var currentCultureInfoObj = Sys.CultureInfo.CurrentCulture;
    var d = new Date();
    alert("Current culture is " + currentCultureInfoObj.name 
    + " and today is " 
    + d.localeFormat('dddd, dd MMMM yyyy HH:mm:ss'));  
</script>

If you encounter any problems, it is possible that the web.config file is overriding the culture information from the browser. In that case, make sure the culture is set to "auto" in the config file, like this:

    <system.web>
        <globalization uiCulture="auto" culture="auto" />
    </system.web>