ASP.Net

On the Road to iTextFileResult: Getting the Results from System.Web.MVC.WebFormViewEngine

Jay Kimble — Thu, 10 Sep 2009 14:27:13 GMT

I’m in the process of building a new ActionResult for ASP.NET MVC. This new ActionResult will allow you to transform data into a PDF, RTF, or HTML (it uses iTextSharp behind the scenes, and yes, I have a working prototype right now that isn’t all that useful yet.. and you have to know way too much in order to use it as of this time).

Essentially what I want to do is use any view engine that the programmer chooses and convert the resulting html, xml, or regular string data into a file that gets pushed to the browser. All this works for all of the alternative engines, but the default engines doesn’t work… so, without further adieu

Challenge #1: WebFormViewEngine ignores the TextStream you give it

Actually this might be the only challenge here. I tried numerous solutions.. none of which worked. I finally cracked open the MVC source code and determined that I needed to inherit form their class and do some overriding… In my API I created BufferedViewPage, and BufferedViewPage<T> so I could intercept the RenderView code. Here’s a copy of my current (in progress) version of BufferedViewPage:

public class BufferedViewPage : ViewPage, IBufferWebFormView

{

    public TextWriter Writer { get; set; }

  

    public override void RenderView(ViewContext viewContext)

    {

        ViewContext = viewContext;

        InitHelpers();

        // Tracing requires Page IDs to be unique.

        ID = Guid.NewGuid().ToString();

        var wfv = viewContext.View as WebFormView;

        var page = (wfv!=null?wfv.ViewPath:""); // View should always be WebFormView

  

        if (viewContext.ViewData["____writer"] != null)

        {

            Writer = viewContext.ViewData["____writer"] as TextWriter;

        }

        ProcessRequest(new HttpContext(new simpleWR(page, viewContext.HttpContext, viewContext.HttpContext.Response.Output)));

        if (Writer != null)

            this.Render(new HtmlTextWriter(Writer));

  

    }

}

You will see that I’m injecting a new writer into the ViewData (I’ll eventuually come up with a better mechanism, but it works for now). My code for the most part copies what the standard WebFormViewPage does except that you’ll see that if the page is a WebFormView it runs Render after running ProcessRequest. I’m not sure if this is problematic or not, but it works! Before I release the actual library I will probably clean this up quite a bit (this is mainly an exercise in helping anyone who wants to use the WebFormViewEngine, but somehow capture the result and do something else with it..

BTW, the part of the code here you don’t see is that before I render I make sure buffering is on and then I clear the response text after generating this (which clearing the response was about the only thing I could do.. that generated data in HttpContext.Current.Response.Output is lost to you… at least I couldn’t find a way to get at it…)

jQuery-UI visual studio intellisense (vsdoc) file

Jay Kimble — Mon, 20 Jul 2009 13:19:18 GMT

If you’ve ever tried to use jQuery UI with Visual Studio, you’ve run into a JavaScript parse error and you lose JavaScript intellisense in Visual Studio. I wasn’t exactly sure of the issue until I read someone’s advice (who was just trying to get the datepicker working) to simply include a dummy jquery-datepicker-vsdoc.js file. So I did this for the jquery-ui.js file and lo and behold, no JavaScript parsing errors, and I had intellisense for everything EXCEPT jQuery UI.

Anyway, I dug around and couldn’t find one… so I created the beginnings of one. What you get is very core level (and not an actual working file). Simply add it to your project along side your jquery-ui.js file and VS will automagically realize that when it gives you intellisense for JavaScript and you are using (or have referenced) the jquery-ui file.

As I said it’s not complete. The areas that I know for sure is that it doesn’t give you any of the theming support.. actually the jquery.ui object is pretty much not there at all… I did get the effects and all the base controls intellisense working (datepicker, tabs, dialogs, etc.). It’s not perfect, but it will be a good start for someone else…

How to Use it
So to use this simply add it alongside your jquery-ui.js file in visual studio and visual studio should pick up my file and use it to give you intellisense. If you are using an external JS file you’ll need to use “/// <reference… /> to reference the JS file.

If I get around to it I will publish an update in the future.

File Attachment: jquery-ui-vsdoc.js

Better JavaScript class generation

Jay Kimble — Wed, 24 Jun 2009 21:15:32 GMT

For years, I have been espousing how great Script# is. I often do an advanced MS ASP.NET Ajax client talk and end it with a Script# talk. Mainly because I think that the idea of learning the nuances of JavaScript OO techniques can be a little confusing. It’s really the challenge (All you need to do is search the archives of my blog and you’ll see my own confusion on this topic).

I think many web developers can wrap their heads around building the functionality, but making something private/public/static can get a little confusing. Especially if you are used to using something like C# or VB to do it.

Kevin “ByteMaster” Wolf and I have been talking about this. As a result of those talks I started playing with an idea of allowing developers create something that feels more like OO… Anyway, I have come up with a very alpha version.

A Better OO For JavaScript??

compileClasses({    

    testClass: {        

        ctor: function() {            

            // this is a test        

        },        

        private: {            

            privateVar:1,            

            privateMethd:function() {                

                // test method            

            }        

        },        

        public:{            

            // public stuff here            

            publicVar:"2"        

        },        

        static:{            

            //public statics            

            staticVar:"test"        

        }    

    },    

    testClass2: {        

        ctor: testFunc,        

        private: {            

            privateVar2:"2"        

        },        

        public:{            

            publicMethod:function() {                

                return true;            

            },            

            myVar:"this is a test",            

            dispose:function() {            

            }        

        },        

        implements:["Sys.IDisposable"]    

    }

});

Two classes are defined here.. the first one is the testClass. you will see that I’m creating a JSON object that has members called “ctor” (constructor), “private” (private members are contained within this object), “public” (public members are contained within this object),”static” (static public members are contained within this object), and “implements” (“array of interfaces that are implemented). I also will handle single inheritance using a member called “inherits.”

I think this makes class definition a little more straightforward for those of us who aren’t closure gurus, and it just might replace the pull of Script# on my life.

Right now this all works with a simple function that uses the MS Ajax Client framework. I’m considering doing this for other frameworks (so if you love some other framework, never fear I’m considering your framework as well).

I created a codeplex project which contains a single release that contains a simple ASP.NET project (could have been a simple html page too).. Don’t fret I expect the code to be a ton cleaner in the next version (I’m reading the MEAP version of John Resig’s Secrets of the JavaScript Ninja (and am learning a ton!)

Here’s the link: JsClassDef Project

Let me know what you think.. does it stink? is it cool? I know it ain’t Resig-like, but both Kevin and I think the simplified structure is nice and not un-JavaScript-like

Using the Ajax control toolbox with jQuery (and ASP.NET MVC)

Jay Kimble — Wed, 10 Jun 2009 02:19:30 GMT

[Here’s a preview of something I’m going to show Thursday night at the Tampa MVC group.]

You may have thought that by jumping on ASP.NET MVC that you have to leave behind all the cool Ajax Control Toolbox controls.. or more than likely you realize that it’s possible to use them, but one has to be a “JavaScript Rocket Scientist” to use them..

It’s really not, but you do need a couple things to use them.. First of all go here (Bertrand Le Roy’s blog) and pick up the jQuery plugin that let’s you instantiate MS Ajax Behaviors. Next go here to the Ajax Control Toolbox project and get both the ScriptFilesOnly project and the Source code as with MVC you won’t need anything but the JS files since the source/DLLs are for WebForms-related controls, but the Source code contains the debug version of the JS files which we’ll need (By the way, 6 months from now that link to the Ajax Control Toolbox will be old so you’ll probably want to get the latest release, and not the release I pointed at).

Now let’s look at how you would wire up the DropShadow behavior (aka the DropShadow Extender). First of all, we need to figure out the references. Thanks to Visual Studio 2008, this is easy. Using the text editor/view of your choice, open up the DropShadowBehavior.Debug.js from the Source project (not the ScriptOnly zip); this is located under the zip file at .\AjaxControlToolkitSource\AjaxControlToolkit\DropShadow. When you open up the file you will see the following at the top of the file:

/// <reference name="MicrosoftAjax.debug.js" />

/// <reference name="MicrosoftAjaxTimer.debug.js" />

/// <reference name="MicrosoftAjaxWebForms.debug.js" />

/// <reference path="../ExtenderBase/BaseScripts.js" />

/// <reference path="../Common/Common.js" />

/// <reference path="../RoundedCorners/RoundedCornersBehavior.js" />

/// <reference path="../Compat/Timer/Timer.js" />

The first 3 items are all the standard MS Ajax client library, so we’ll need to reference those. Now we need to look at the last 4 items. If you open up the files from the ScriptOnly zip file, you aren’t going to find these exact named files; to find the right file look at the end of the file name to find the actual file you need to reference. You’ll also need to reference jQuery and Bertrand Le Roy plugins. Here’s what the references look like:

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

<script src="Scripts/jquery-1.3.2.js" type="text/javascript"></script>

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

  

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

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

<script src="Scripts/AjaxCT/AjaxControlToolkit.ExtenderBase.BaseScripts.js" type="text/javascript"></script>

<script src="Scripts/AjaxCT/AjaxControlToolkit.Common.Common.js" type="text/javascript"></script>

<script src="Scripts/AjaxCT/AjaxControlToolkit.RoundedCorners.RoundedCornersBehavior.js" type="text/javascript"></script>

<script src="Scripts/AjaxCT/AjaxControlToolkit.Compat.Timer.Timer.js" type="text/javascript"></script>

<script src="Scripts/AjaxCT/AjaxControlToolkit.DropShadow.DropShadowBehavior.js" type="text/javascript"></script>

Here’s how we can then make every div with a “box” class to have a drop shadow:

$().ready(function() {

    $(".box").create(AjaxControlToolkit.DropShadowBehavior,

            { 

                Opacity: 0.3,

                Rounded: false,

                TrackPosition: true,

                Width: 5

            });

});

See that JSON string (lines 3-8). If you look at those settings closely and compare them to the Ajax Control Toolbox documentation web site, you’ll see that these are the same settings that the extender uses which should make everything easy.

The two ways one writes JavaScript code..

Jay Kimble — Tue, 21 Apr 2009 15:44:54 GMT

I think sometimes in the past I have been guilty in my presentation on JavaScript (JS) of not defining for myself who my audience is. Actually I know that I’ve done a poor job of this. You see there are 2 ways to write JavaScript code. Something that I knew, but recently realized the importance of.

OO Baby
If you are building your own controls then you are all about building things in an OO manner because it helps you in the areas on manageability. You may or may not be testing your components with automated/unit test tools and quality is everything.. as well as browser compatibility. When doing this one of the major struggles in your world will probably be in the area of memory leaks (I’ve joined the coalition to kill IE6).

To be honest this is probably not you, but if you’ve come to one of my deep JS talks… this is my target (and my cardinal sin… sorry)

The way you probably use JS
Ok, the most common use of JS and the way that I think most people use it is to do minimal coding to wire up some validation or to wire up some interaction or even to include some Web 2.0 control (aka “Ajax Control”). Your mantra is “I want to get in and out quickly so that I don’t have to touch JS more than I need to…" We usually don’t take the time to test this stuff because it feels more declarative and that seems trustworthy (although you could test it)

This is exactly why jQuery is so popular. Not only does encourage this type of thinking (and even embraces it), but the re-usable plugins take on this same sort of thinking (the show/hide methods come to mind). That and the sheer fluency of the library makes it easy to use. The selectors are really a variation of the same selectors that CSS uses so you are re-using knowledge that should already be in your head as a web-developer/designer..

Anyway, while JS OO is cool.. most of us work the other way (and even those of us who use JS OO do most of our JS coding using the latter method)

Client-side Scripting 101 Part 2: JavaScript OOP Basics

Jay Kimble — Tue, 03 Feb 2009 21:50:02 GMT

[Sorry this took so long to get out… I have been distracted by Windows 7 and am working between 2 OS’ on 1 machine… Win7 is now my primary OS and I didn’t have this post here… that and I’m now twittering doesn’t help either]

Ok, since in the first version of my last article I referenced the "prototype" property, it felt natural to begin by talking about JavaScript OOP basics. Now, I’m not going to try to define all the terms that usually get associated with the type of OOP used in JavaScript ("JS" hereafter). I want to give you --my valued reader-- with the practical knowledge. So let’s go over how JS as a language works:

JavaScript objects and types are extensible simply through use
What this means that to add a field to a JS object you need only reference the field. As a result there are 3 states of any value that you interrogate in JS: has a value (like 2, "v2", etc), is null, is undefined. "Null" means that the type member (property, field, method) is defined, but as of yet there is no value here. "Undefined" means that a type member does not exist as of yet. So let’s illustrate this with some code:

        1: var myObj = {};

       2: myObj.myNewProperty = null;

       3: var test1 = typeof(myObj.myNewProperty) == "undefined"; // returns false

       4: var test2 = typeof(myObj.myOtherNewProperty) == "undefined"; // returns true

       5: var test3 = (myObj.myNewProperty == null); // returns true

So what did we do there? Well, we created a new object; the "{}" is short hand for "new object()." BTW, that’s really JSON syntax (there’s more to that and we’ll cover it much later in another column). After creating an empty object we create a "myNewProperty" field and set it’s value to null (this field is created and is "defined"). Next we do a couple tests on the variable. The first test checks to see if the "myNewProperty" field on the created object is undefined (it is defined so test1 is false). The next test checks to see if the "myOtherNewProperty" field on the created object is undefined (since this is the first time we referenced it, the field is in fact undefined, so test2 is true). Finally we test to see if the "myNewProperty" field on the created object is null (which it is).

JavaScript object’s members can be referenced like a dictionary
In the example above we could have referenced the "myNewProperty" field like this:

myObj["myNewProperty"] = null;

What this means that with JS we can sometimes reference object members as if they were an array or more like a HashTable in .NET. The real importance of this is that JS objects are really strange characters in that they can be manipulated like both an object and an array/dictionary/hashtable. We’ll be briefly revisiting this syntax at the end of the Prototype section (but don’t blink… it’s really fast).

Function is used to create a class
So thus far, we have extended objects and not classes. In JS we can use the Function type to define a class (I know that seems weird, but bear with me). Functions can contain other functions which have access to all the variables within them and any variable that it’s parent function can access. The constructor is actually the parent function. Let’s look at an example:

       1: function myClass()

       2: {

       3:   var privateVar = "Private variable";

       4:   this.publicVar = "public variable";

       5:   this.publicFn = function() {

       6:     // this fn can manipulate any of the above vars including the private ones

       7:     privateVar = "Private accessed by publicFn";

       8:     return "Public Function";

       9:   }

      10: }

myClass is a class that has a single private variable called “privateVar”. It has 1 public variable/field called “publicVar” and a public function called “publicFn.” We can create a variable of this type by doing the following:

       1: var myNewObject = new myClass();
  

The above example isn’t the way this is normally done though. Here’s why. That initial function/constructor looks really weird with the function declaration inside of it (imagine a public field declared after the a function declaration. It would get really messy quickly).

Prototype
So instead there is a special properties called “prototype” which can be used to add additional members to a function. Here’s an example of what that looks like:

       1: myClass = function()

       2: {

       3:     var privateVar = "Private Var";

       4:     this.publicVar = "Public Var";

       5: }

       6: myClass.prototype.publicFN = function()

       7: {

       8:     privateVar = "Private var accessed by function";

       9:     return "Public Function"

      10: }

We made a couple changes here. First we switched the order around for the function declaration. This is all perfectly legal. The function syntax creates an anonymous function and assigns it to the myClass (for instance). As you can see from the prototype syntax on line 6 that you simply extend the prototype object like we did earlier in the first code example.

We’re almost done. Let’s make a slight change to the more preferred syntax(and see our first very small example of JSON):

       1: myClass = function()

       2: {

       3:     var privateVar = "Private Var";

       4:     this.publicVar = "Public Var";

       5: }

       6: myClass.prototype = {

       7:     publicFn : function() {

       8:         privateVar = "Private Var changed by function";

       9:         return "Public Function";

      10:     },

      11:     get_PrivateVar : function() {

      12:         return privateVar;

      13:     }

      14: }

Not much has changed from the last version except one thing, and we’re setting the prototype function to an object (remember that the squiggly brackets are JSON syntax for object). The methods are mapped out using a “name:value” syntax. and is comma separated (you get a weird error if that comma is missing). We also went ahead and added one more new member which now exposes our private variable via a “property” get function.

There’s actually another variation on the syntax, but this is good enough for now. With this in hand you should be able too read just about any JavaScript object library and figure out where you can call things.

You might also notice that inheritance doesn’t look like it’s baked in… which is absolutely correct! Inheritance is not baked in. You have to use a separate framework to get it (it shouldn’t be that hard to see how one would get inheritance. One way would be to simply query the Parent type’s prototype and add those methods/properties to the child class; we can do all this by using that dictionary/HashTable syntax we mentioned above and a foreach loop. There are other ways as well but that is way beyond the scope of this tutorial --and really isn’t something you should care all that much about right now).

After all, being able to read this syntax was our overall goal (we want to use Script# to actually do our programming).

Next time we’ll cover Script# basics. (I’ll try not to take 3 weeks to get you the next installment)

"Subsonic" for Services found: Subsonic 3 + ADO.NET Data Services (Astoria)

Jay Kimble — Tue, 18 Nov 2008 19:02:26 GMT

About a month ago if you asked me what was big in my dev world (in other words what are you looking for). I would have promptly told you that I was looking for the "Subsonic" of services. In other words I wanted to create a database and hook a connection string and have everything generated for me... I want drop dead simple.

Astoria was as close as I could get, but it didn’t quite achieve what I was looking for. Don’t get me wrong, it’s easy enough. I’m just not sure what I think of EF yet which is not to say that I don’t like it... just that I sometimes want something simple. Rob Teixeira has noted that for some there are "too many knobs." I’d have to say I’m somewhat in that camp (although I’m not very informed either and I’m not a huge lover of Linq to SQL either).

I love the simplicity of Subsonic. I really do, and I really want to leverage something that simple for building a Data Service. Rob Conery (I love Rob... You can have ScottHa or Haacked... I’ll take Conery... He’s my hero!) recently released a preview of Subsonic 3.0 which is fully Linq-Queryable and also has the normal Subsonic Query engine... it’s the best of all worlds (except it’s not backwards compatible).

Since my readings from John Papa’s book taught me that Astoria doesn’t need an EF model that regular classes could work, and I have a personal project that could use an easier more service friendly manner of editing/viewing data, I decided to try this out.

Preview 1 was an abysmal failure. Well, to be fair I quit because Preview 2 came out. I stuck with Preview 2 and earlier today I got it all working.

Here’s how to do it. #1 follow Rob’s instructions (on any of the links I’ve provided and get Subsonic stuff working). I did all this in a separate DLL project.
Create a regular web site (or web project)
1. make sure there is a connection string in the web.config that has the same name as the "ProviderName" variable in the _Settings.tt file
2. Add an ADO.NET Data Service to your web site/project.
3. Add this attribute to your service class
```
[System.ServiceModel.ServiceBehavior(IncludeExceptionDetailInFaults = true)] 
```
4. Next set the DataService T type to the "DB" class of your Subsonic generated class. It will look something like this:
```
public class NorthwindService : DataService<Northwind.DB>
```
Tada! You are done...

A couple notes

Both Preview 1 and 2 build a class model that exposes an object/class called "DB." Think of this class as "Context" (even though EF and Linq2SQL context classes do a lot more). For the sake of Astoria, you just need a class that exposes all your entities in an IQueryable manner (which "DB" will do).

I ran into one error that was messing me up. If you make name of your Primary Key IDs "ID" then everything in the above worked fine. If it didn’t I am going to provide an alternate set of templates (TT files) for you to use. What’s missing is that Astoria expects an "ID" property. You can get around this by tagging each entity class with

[System.Data.Services.Common.DataServiceKey("{tablename_id}")]

This also means that you have to include the System.Data.Services.Client.DLL in your Subsonic project.

My TT files (based on Preview 2)

I added a new variable in _Settings.tt that let’s you turn off the attribute used for setting the PK in your entity classes. It’s called "EnableForUseWIthAstoria." Here they are :

Subsonic3 preview 2 Astoria Ready Templates

Closing thoughts

With all this in hand you should be able to create Astoria Services with any DB that Subsonic supports (which I believe is a larger number than what EF currently supports.

Additionally, like Rob Conery, I want to stress this is all experimental. This code might run off with your wife, children, it might decide to use your PC late at night to play video games thereby increasing your electricity, etc. (in other words this is all experimental right now... have fun with it, and be careful ... you probably don’t want to use it for live/mission critical code).

PDC2008: Reactions to ASP.NET 4.0 upcoming features presentation

Jay Kimble — Thu, 30 Oct 2008 16:05:13 GMT

I’m listening/watching this video on Channel9 which is on the ASP.NET 4.0 preview. Scott Hunter is the main presenter (at least at the beginning). This will probably be a little different of a post by me...

Web Forms

Did he say "HTML Standards Compliant?" (cool!)
ClientIDs will be controlled by us (no more mangling... Hurray!)
Moving away from table-based controls and using CSS2 adapters (sort of... invisibly)
URL Routing (yawn... We have this in SP1... It’ll probably be easier to use)
Supposedly better View-state controls (I’m dubious about this)

More granular control
Ability to turn off Viewstate on Gridview/Listview without issues

Client Script

jQuery intellisense (did he go to a Google site?)
Ajax Control Toolkit will be adopted by MS (it will be a part of ASP.NET in 4.0)

MS will support it.
MS will enhance it

Rich Client-side templating controls (I’m already embedded in this stuff)

[Wow.. Bertrand is up..]
[I wish I could see the source code... I hope they give that away]
The big thing is that JS it’s pretty easy to do and it minimizes the amount code you need to write on the client

Phil’s demo (mentioned below) reiterates that MS Ajax and jQuery work well together

ASP.NET MVC [not something I’m extremely excited about, but I am interested in it]

Hint at a auto build of pages when you point at an object... (Dynamic Data??)
Ajax in MVC with MVC

[It’s Phil Haaack...]
Phil demos Partial rendering

returning a couple items in a JSON string
[Actually in some respects Ajax can be easier in an MVC app... in any MVC app not just MS' ASP.NET MVC]
[Phil blew up his text... I can actually read it]
Next demo is sort of an UpdatePanel-like demo [simple To Do list updated without a page render by the browser]

Uses "using Ajax.BeginForm" to define the scope of the form tag [very cool IMO]
BeginForm has some options that let you define what you want to happen when the form is submitted and returns and then what you can execute something after the submit is done [in this case a background call is made and a specified DOMElement is updated and then jQuery effect is called]

ASP.NET Dynamic Data

More than Scaffolding [Not to self I need to check this out some more]

[Scott Hunter is demoing this]
Demo is a blog app [same as one of the initial Rails tutorials]
It builds a set of templates for your data model
It uses these templates for the data display/edit/etc.

Enhancing (surprise, surprise) MVC [for those who don’t know this makes ASP.NET MVC a real competitor to Rails]
Supports custom Data Layer aka Business Logic Data Source
Better filtering
Better control over column order, and columns that are shown
Dynamic Data to ADO.NET Data Services [Pronounced "Astoria"]
[Another demo to show the last 3]

Search screen [a lot of which is automated if not all... he doesn’t show how we get here... just the code that is here]
Created via LinqDataSource with a where child tag that has additional child tags defining fields to search on
Same LinqDataSource can control the visibility of fields

Dynamic Data works against IQueryable Data source : LinqDataSource (EF, LINQ to SQL, etc.), AstoriaDataSource, Business Logic DataSource (sort of like the Object DataSource except that the class is IQueryable aka usable from a LINQ query [Cool!])

Astoria DataSource which allows an Astoria service as the source of data in a server-side app [Yay!]
ASP.NET Core changes

Swap out the Cache mechanism via a provider mechanism [Yay!]
Fixes to pain points

[I skipped the questions]

Tampa UX (TUX) First Meeting Tomorrow Night (Sept. 10th, 2008)!

Jay Kimble — Tue, 09 Sep 2008 18:28:54 GMT

Since we are still waiting on the website to go live (it will be at http://www.tampaux.org once the files get copied up), here’s some detailed info on the TUX meeting tomorrow ay 6:30 (for food) with the actual meeting starting around 7:00pm (we should be done around 9:00pm)

Here’s Answers Systems (where we’re meeting) on Virtual Earth

That address is

4029 Tampa Rd, Oldsmar, FL 34677-3206.

Basically, if you are coming from Tampa, take Hillsborough Ave. to Oldsmar. We’re the bullding (on the same side of the street) just past the McDonald’s that you come to after passing RaceTrack Rd.

If you are coming from Pinellas, take 580 (or Tampa Rd) east. Look for right after 580 merges with Tampa Rd, look for the McDonald’s on the left (you can also turn at the light right after the merger with Tampa Rd. (but then you have to drive clear through the parking lot to get to our building).

Answers Systems is the building next to McDonald’s (actually it is across the little side road there... not sure of the name... the back of our building faces McDonald’s).

BTW, if you get lost my cell phone is 727.608.6453 (feel free to call me if you get lost).

PS Contest!

In case you forgot, some lucky winner will walk away with an MSDN Premium Subscription (thanks to Bill Reiss)

Writing Better JS Components

Jay Kimble — Tue, 12 Aug 2008 12:04:33 GMT

Perry (my boss... a developer/manager... he codes and manages) and I have been having a recurring conversation lately. One that keeps bringing to my mind a product that I knew about when I worked for ZAC Catalogs (way back in the day). I would daresay that none of you had even heard of it (although we did pick it up as a result of Xtras carrying it, so maybe a few of you knew about it). I believe it was a called "MFC DataGrid Wizard" or something like that. Anyway what it did was build a custom DataGrid component for you based on selections in a wizard. You selected what features you needed and then it would take it’s full-featured Grid source code (which came with the component) and would dynamically generate a full blown component for you with just the features you needed.

There are two reasons this has become a topic for discussion for me. The first is that we are currently struggling with a set of third party components that a prior developer/manager pushed all over our main site. The components are ones that you have probably heard great things about them and they are pretty cool. The problem is when you shove these components everywhere! We are having ViewState issues among other things... One of the components is a full-featured Grid control (client-side) that while nice we usually only use as a glorified listbox (we use it for selecting an item). As a result I built a specialized DataGrid for our company (one that I’ll be doing a walkthrough on its codebase at the first TUX user group meeting next month)

The other reason is this post from Bertrand LeRoy where he talks about a simple grid for ASP.NET. Here’s my problem with Bertrand’s post. The grid he talks about as being simple really doesn’t sound all that simple to my ears. Let me list a couple features:

Column drag/drop
Different column types
Data Sorting/Paging
Inline editing

Now mind you these are awesome features if you need them all then you would want to use something like this, but a lot of times what we need is something simpler. You could use the aforementioned grid for this, but the grid will probably still use ViewState (because it needs it maintain state for the paging, sorting, and editing features). It might need several more scripts or <shudder /> it’s script might be 500-1000 lines longer because of the added features.

A Better Way

I have been thinking about a better way to "do" script components. We really need to have a wizard that asks us what we will be needing in the components and then the main script file can be customized (as can the server side code) to remove certain things. It could be done really easy with templates for the script. You need a template for the main file, and additional includes based on features. The server side would work pretty much the same way. I know that no company really wants to give away their source, but even if they were able to do this for script code that would make our lives a lot easier.