mostlylucid

Leaving Microsoft…for real! Got a job?

Scott Galloway — Wed, 14 Oct 2009 02:27:42 GMT

Tomorrow, after 4 1/2 years, including 2 years with the ASP.NET Team I’m finally leaving Microsoft.

The reasons for leaving are varied, I am resigning, but the timing is not entirely my own choice. I’m looking at this as an opportunity, I’ve done a huge amount of thinking about the course my life should take next and this really is a positive step in that direction. I have no bitterness nor animosity towards Microsoft, they hung in longer than a lot of employers would and that led me to stay too long in a job I wasn’t suited for. They are a great company, the majority of the people I worked with are passionate, really smart people and I’ll miss them a lot. Some others are power hungry jerks and completely dissociated from the real world…but then every company has their share of those people.

I am at heart a developer, I love designing and building web applications and frankly I’m incredibly good at it and I especially love working with other people who are good at it too (or want to be). I posted some time ago about how I got to where I was (well, am until about midday tomorrow). Now I need to look for a job which gives me the same level of excitement which I’ve lost of late. I am really grateful to have had the chance to mature professionally, all the prima-donna shit which comes through lacking confidence in my own skills that I had previously has gone. I’ve seen what life is like in the place every developer using ASP.NET longs to go and well, it wasn’t for me.

Right now I plan to move back to my native Scotland and find a job where they need someone like me, someone who still has a passion for web technologies and the drive and knowledge to build pretty much anything.

Dead Simple Geolocation…

Scott Galloway — Tue, 13 Oct 2009 04:56:34 GMT

Messing around with this stuff of late, @TheCodeJunkie requested it so here’s a really simple way to get a location and show a map :). This version uses the W3C Geolocation API on browsers that support it (FireFox 3.5, Safari, iPhone, Opera) and falls back to using Google Gears on other browsers (including IE).

Just a really dumb sample right now but who knows, someone might find it useful! I’ll update later with some of the more advanced stuff I’m working on in this area…

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
    <title></title>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <script type="text/javascript" src="http://ecn.dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.2"></script>
    <script src="Scripts/gears_init.js" type="text/javascript"></script>
    <script type="text/javascript">
        function SetLocation() {
            if (typeof (navigator.geolocation) != "undefined") {
                geo = navigator.geolocation;
                positionOptions = { maximumAge: 600000 };
            }
            else {
                if (!window.google || !google.gears) {
                returnUrl = this.location.href;
                location.href = "http://gears.google.com/?action=install&message=Gears now enabled!" +
                    "&return=" + returnUrl;
                }

                geo = google.gears.factory.create('beta.geolocation');
                positionOptions = {enableHighAccuracy:true, maximumAge: 600000};
            }
            geo.getCurrentPosition(GetMap, handleError,positionOptions);
        }
        function GetMap(position) {

            latitude = position.coords.latitude;
            longitude = position.coords.longitude;
            map = new VEMap('myMap');
            map.HideDashboard();


            map.LoadMap(new VELatLong(latitude, longitude), 15, 'h', false);
            var shape = new VEShape(VEShapeType.Pushpin, map.GetCenter()); shape.SetTitle('You are here!'); map.AddShape(shape);
        }
        function handleError(positionError) {
            alert('Attempt to get location failed: ' + positionError.message);
        }      
    </script>
</head>
<body onload="SetLocation();">
    <div id='myMap' style="position: relative; width: 1000px; height: 1000px;">
    </div>
</body>
</html>

ServerControlWithSprinklesAndBacon Part 1.

Scott Galloway — Mon, 14 Sep 2009 00:20:01 GMT

It seems to many that the days of ASP.NET Web Form Server Controls have just about come to an end. The problem many people have with Server Controls is that they have a pretty high ‘concept count’ in their construction. The arrival of ASP.NET MVC with it’s deliberate decision to eschew Server Controls in favor of very simple ‘HTML Helpers’ and simple inline markup generation seemed to put the final nail in the coffin of these old war-horses of ASP.NET.

Whilst writing a chapter in a book I’m working on about ASP.NET 4, I got to thinking about a Server Control prototype I worked on last year…the ServerControlWithSprinklesAndBacon. In essence the SCWSB (as it will hereon be called) was a vastly over engineered attempt to answer a simple requirement:

Is it possible for a Server Control to change it’s design & run time behaviors based on the adapter the user has selected.

Why on earth would I want to do this? Well, one of the changes we made for ASP.NET 4 is in improving the CSS and Rendering behaviors of a number of our Server Controls which ship with ASP.NET. In an earlier incarnation of this work, we looked at doing this using Control Adapters; a feature which switches out the runtime code used to generate the HTML for a control. As it turned out, we decided to go in a different direction for achieving this (which does not use control adapters) as it was felt that Control Adapters introduced too much complexity into the mix.

Originally, you would have been able to specify the Control Adapter to use for a specific control within a page at runtime (in fact, you could use another feature called ‘Adapter Groups’ to define them at almost any level from app right through to control…but I digress). The main use for Control Adapters was to be in allowing you to use alternate rendering behaviors, think, more CSS Friendly HTML or even totally different markup…. A problem with this was that one of the most fundamental features of Server Controls, Designer support would be lost when taking this approach. In fact in ASP.NET 4, you *do* lose a lot of designer functionality when using the controlRenderingCompatabilityVersion=”4.0” setting, for example, AutoFormats no longer work for most controls.

Anyway, this lack of designer support for changing control adapters on a specific control bugged me to no end…and I spent a number of sleepless nights working on the problem. In the end here’s what I wanted to achieve:

Add support for ‘designer’ control adapters, so rather than just runtime, control adapters also changed design time HTML.
Work out how to change the items in the Property Grid for a control based on the selected control adapter (so, hide some that no longer apply and add some new ones)
Make them easy to use…

In looking at these requirements, I needed to plumb the (relatively unexplored) depths of the ASP.NET Server Control framework, use some features in ways they were never really supposed to be used and discover way more about how Server Controls interact with the VS.NET design surface than anyone really should…in Part 2 I’ll take you on that journey and show you how I came up with the ServerControlWithSprinklesAndBacon…

ASP.NET 4 Beta 1: WebForms Routing extension methods

Scott Galloway — Tue, 19 May 2009 20:23:41 GMT

When we were adding WebForm routing to ASP.NET 4 Beta 1, we didn’t have a chance to add in a couple of methods which make working with Routes and Web Forms a lot easier!

Note: the code below is ‘similar’ to that which we’re adding ASP.NET 4 Beta 2, *that* code will be of much higher quality however, this is a sample only!

        1: using System;

       2: using System.Collections.Generic;

       3: using System.Linq;

       4: using System.Web;

       5: using System.Web.Routing;

       6:  

       7:     public static class RouteExtensions

       8:     {

       9:         public static string GetUrlForRoute(this System.Web.UI.Page page, string routeName, RouteValueDictionary parameters)

        {

            VirtualPathData vpd= RouteTable.Routes.GetVirtualPath(null, routeName, parameters);

            return vpd.VirtualPath;

        }

        public static string GetUrlForRoute(this System.Web.UI.Page page, RouteValueDictionary parameters)

        {

            VirtualPathData vpd = RouteTable.Routes.GetVirtualPath(null, parameters);

            return vpd.VirtualPath;

        }

  

        public static void IgnoreRoute(this RouteCollection routes, string url)

        {

            routes.IgnoreRoute(url, null);

        }

  

        public static void IgnoreRoute(this RouteCollection routes, string url, object constraints)

        {

            if (routes == null)

            {

                throw new ArgumentNullException("routes");

            }

            if (url == null)

            {

                throw new ArgumentNullException("url");

            }

            IgnoreRouteInternal internal3 = new IgnoreRouteInternal(url);

            internal3.Constraints = new RouteValueDictionary(constraints);

            IgnoreRouteInternal item = internal3;

            routes.Add(item);

        }

  

        public static Route MapRoute(this RouteCollection routes, string name, string url, string physicalFile)

        {

            return routes.MapRoute(name, url, physicalFile, null, null);

        }

  

        public static Route MapRoute(this RouteCollection routes, string name, string url, string physicalFile, object defaults)

        {

            return routes.MapRoute(name, url, physicalFile, defaults, null);

        }

  

        public static Route MapRoute(this RouteCollection routes, string name, string url, string physicalFile, string[] namespaces)

        {

            return routes.MapRoute(name, url, null, null, namespaces);

        }

  

        public static Route MapRoute(this RouteCollection routes, string name, string url, string physicalFile, object defaults, object constraints)

        {

            return routes.MapRoute(name, url, physicalFile,  defaults, constraints, null);

        }

  

        public static Route MapRoute(this RouteCollection routes, string name, string url, string physicalFile, object defaults, string[] namespaces)

        {

            return routes.MapRoute(name, url, physicalFile,  defaults, null, namespaces);

        }

  

        public static Route MapRoute(this RouteCollection routes, string name, string url, string physicalFile, object defaults, object constraints, string[] namespaces)

        {

            if (routes == null)

            {

                throw new ArgumentNullException("routes");

            }

            if (url == null)

            {

                throw new ArgumentNullException("url");

            }

            if (physicalFile == null)

            {

                throw new ArgumentNullException("physicalfile");

            }

            Route route2 = new Route(url, new PageRouteHandler(physicalFile));

            route2.Defaults = new RouteValueDictionary(defaults);

            route2.Constraints = new RouteValueDictionary(constraints);

            Route item = route2;

            if ((namespaces != null) && (namespaces.Length > 0))

            {

                item.DataTokens = new RouteValueDictionary();

                item.DataTokens["Namespaces"] = namespaces;

            }

            routes.Add(name, item);

            return item;

        }

  

        // Nested Types

        private sealed class IgnoreRouteInternal : Route

        {

            // Methods

            public IgnoreRouteInternal(string url)

                : base(url, new StopRoutingHandler())

            {

            }

  

            public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary routeValues)

            {

                return null;

            }

        }

    }



So, how do you use these methods?

These extensions add a few simple methods:

MapRoute

Stolen shamelessly from MVC. These methods provide a shortcut to defining Routes for WebForms.

RouteCollection.MapRoute(string name, string url, string physicalFile);

For example to map a simple route you can now do:

RouteTable.Routes.MapRoute(“ProductDetailsRoute”, “products/{productid}”, “~/ProductDetails.aspx”);

Also has a couple of variants allowing for defining defaults etc…

RouteCollection.MapRoute(string name, string url, string physicalFile, object defaults);

RouteCollection.MapRoute(string name, string url, string physicalFile, object defaults, string[] namespaces);

GetRouteForUrl

Page.GetUrlForRoute(string routeName, RouteValueDictionary parameters);

Using a specifically named route and RouteValueDictionary containing a number of parameters will give you back a string containing the Url to use. REALLY useful in databound apps!

e.g.,

<asp:hyperlink ID="HyperLink1" runat="server"  NavigateUrl='<%# Page.GetUrlForRoute("ProductDetailsRoute",new RouteValueDictionary( new {productid= Eval("ProductID")}))%>'  Text="Details"></asp:hyperlink>

Page.GetUrlForRoute(RouteValueDictionary parameters);

Same thing, but auto-matches the RouteValueDictionary parameters against a route…

IgnoreRoute

Allows you to define urls which should not be tried for matches against routes (can be useful for upgrading WebForms apps)

RouteCollection.IgnoreRoute(string url);

RouteCollection.IgnoreRoute(string url, object constraints);

GridView with no Inline Styles (mostly!)

Scott Galloway — Sat, 09 May 2009 06:48:02 GMT

UPDATE: I’ve put the entire CSS Manager source including this control on my Codeplex site, you can get it here.

This has been a bit of an obsession for the past couple of days…I wrote previously about a little CSS combining control which I’m working on. As part of this I wanted to experiment with ways of optimizing our current controls.

Well, I thought I’d throw this up (in both meanings of the term) here for some quick reference. Again, not fully implemented, just an experiment. You’ll also quickly notice that there’s some other gubbins missing; like my CSSManager base page, I’ll update this post with their location once I get them tidied up a bit.

Well, what do I do to avoid inline styles, simple…cheat :). Firstly I went spelunking in the GridView control using Reflector and saw where the styles are actually set. A method called ‘PrepareControlHierarchy’, this basically sets the style properties on all of GridView’s child controls. The ‘other’ way you can do this is through the use of Control Adapters (e.g., the CSS Friendly Adapters), but they’re a bit more involved than I wanted for this.
In this method I basically call ‘Reset()’ on the styles and set ‘CSSClass’ for each of the styles instead.
For the actual styles, I pull them into a string and throw them over to my little Page control for addition to my CSS Manager thingy…(again, be online soon). This then renders the style out to either page or an external CSS file.

Anyway, as I’ve said this is really just a hack but it was a fun little thing to play with…and who knows, someone might find it useful!

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using System.Web.UI.WebControls;

   6:  using System.Web.UI;

   7:  using System.Drawing;

   8:  using System.IO;

9:

  10:  namespace CSSManager

  11:  {

  12:      public class CSSGridView : GridView

  13:      {

14:

  15:          public new CSSManagerPage Page

  16:          {

  17:              get

  18:              {

  19:                  return (CSSManagerPage)base.Page;

  20:              }

  21:          }

22:

  23:          protected override void OnPreRender(EventArgs e)

  24:          {

25:

  26:              if (!DesignMode)

  27:              {

  28:                  StringBuilder sb = new StringBuilder();

  29:                  if (this.Controls.Count > 0)

  30:                  {

  31:                      bool controlStyleCreated = base.ControlStyleCreated;

  32:                      Table table = this.Controls[0] as Table;

33:

34:

35:

  36:                      if (table == null)

  37:                          throw new Exception("The first control must be a Table");

38:

39:

40:

  41:                      Style baseStyle = base.ControlStyle;

  42:                      string baseStyleName = this.ClientID + "BaseStyle";

  43:                      sb.AppendFormat(".{0}{{{1}}}", baseStyleName, baseStyle.GetStyleAttributes(this).Value);

44:

  45:                      table.ControlStyle.Reset();

  46:                      table.ControlStyle.CssClass = baseStyleName;

47:

  48:                      Style alternatingRowStyle = AlternatingRowStyle;

  49:                      alternatingRowStyle.MergeWith(RowStyle);

  50:                      sb.AppendFormat(".{0}{{{1}}}", this.ClientID + "AlternatingRow", alternatingRowStyle.GetStyleAttributes(this).Value);

  51:                      sb.AppendFormat(".{0}{{{1}}}", this.ClientID + "Row", RowStyle.GetStyleAttributes(this).Value);

52:

  53:                      foreach (GridViewRow row in this.Rows)

  54:                      {

55:

  56:                          switch (row.RowType)

  57:                          {

  58:                              case DataControlRowType.Header:

  59:                                  if (this.ShowHeader && (this.HeaderStyle != null))

  60:                                  {

  61:                                      string className = this.ClientID + "HeadStyle";

62:

  63:                                      sb.AppendFormat(".{0}{{{1}}}", className, HeaderStyle.GetStyleAttributes(this).Value);

  64:                                      row.ControlStyle.Reset();

  65:                                      row.CssClass = className;

  66:                                  }

  67:                                  break;

68:

69:

  70:                              case DataControlRowType.Footer:

  71:                                  if (this.ShowFooter && (this.FooterStyle != null))

  72:                                  {

  73:                                      string className = this.ClientID + "FootStyle";

  74:                                      sb.AppendFormat(".{0}{{{1}}}", className, FooterStyle.GetStyleAttributes(this).Value);

  75:                                      row.ControlStyle.Reset();

  76:                                      row.CssClass = className;

  77:                                  }

  78:                                  break;

79:

80:

  81:                              case DataControlRowType.DataRow:

  82:                                  string rowClassName = string.Empty;

  83:                                  if ((row.RowIndex % 2) == 0)

  84:                                  {

  85:                                      rowClassName = this.ClientID + "AlternatingRow";

86:

  87:                                  }

  88:                                  else

  89:                                  {

  90:                                      rowClassName = this.ClientID + "Row";

  91:                                  }

  92:                                  row.ControlStyle.Reset();

  93:                                  row.CssClass = rowClassName;

  94:                                  break;

95:

  96:                          }

97:

  98:                      }

  99:                  }

 100:                  this.Page.RegisterCSSStyle(sb.ToString());

 101:              }

 102:              base.OnPreRender(e);

 103:          }

 104:

 105:

 106:

 107:          protected override void PrepareControlHierarchy()

 108:          {

 109:              if (DesignMode)

 110:                  base.PrepareControlHierarchy();

 111:          }

 112:

 113:      }

 114:  }

What does this actually generate? Well, if you’ve seen the output you normally get from a GroidView you’ll be familiar with all of the inline styles (so, style=”font-family…” etc…which are duplicated for every single row…which kind of sucks as they’re almost all exactly the same. This little control instead generates a little bit of CSS.

   1:  <style type="text/css">

   2:      .GridView1BaseStyle{background-color:White;border-color:#CCCCCC;border-width:1px;border-style:None;font-family:Verdana;}.GridView1AlternatingRow{color:#000066;}.GridView1Row{color:#000066;}

   3:  </style>

Then hooks that up to the GridView:

   1:  <table class="GridView1BaseStyle" border="0" id="GridView1">

   2:          <tr>

   3:              <th scope="col">Discontinued</th><th scope="col">ProductID</th><th scope="col">ProductName</th><th scope="col">QuantityPerUnit</th><th scope="col">ReorderLevel</th><th scope="col">UnitPrice</th><th scope="col">UnitsInStock</th><th scope="col">UnitsOnOrder</th><th scope="col">Categories.CategoryID</th><th scope="col">Suppliers.SupplierID</th>

   4:          </tr><tr class="GridView1AlternatingRow">

   5:              <td><span disabled="disabled"><input id="GridView1_ctl02_ctl00" type="checkbox" name="GridView1$ctl02$ctl00" disabled="disabled" /></span></td><td>1</td><td>Chai</td><td>10 boxes x 20 bags</td><td>10</td><td>18.0000</td><td>39</td><td>0</td><td>1</td><td>1</td>

   6:          </tr>…

So you see that we (mostly) got rid of all of the inline styles; apart from the annoying “border=0” which is a major pain in the ass to clear out! In ASP.NET 4 you’ll be able to turn this off as well though!

Oh, one important thing. This also works with Auto-Formatting…and the designer :)

The strange case of the disappearing Feature: AdapterGroup

Scott Galloway — Mon, 27 Apr 2009 16:07:58 GMT

AdapterGroups are in Beta 1 but will (likely) not be in Beta 2 of ASP.NET 4.0

This week I have the job of removing a feature which I originally designed for ASP.NET 4.0. This feature is ‘AdapterGroups’, so what is it?

As you may be aware ASP.NET has a capability which allows switching how a control is rendered based on the capabilities of the browser the user makes the request for an ASPX page using. One of the ways this using a feature called Control Adapters. Even though these were originally designed to support mobile browsers, one of the most common uses for them right now is to ‘fix up’ the markup which many of our controls render using the CSS Control Adapters, these in essence modify the code which specific controls (those with adapters) use to render their output. See Scott Guthrie’s post as well as the original whitepaper on how these work; oh, and of course Fritz Onion’s great article on the topic.
So, by now you should see that Control Adapters can be pretty handy when you need to replace the default rendering which our controls provide to be more CSS compliant (or, whatever else you have an adapter for…). One of our big pushes in ASP.NET 4.0 is to improve how controls by default work with CSS; and we’re making a number of changes to the controls themselves to make this happen.
Originally the plan was to use the CSS Control Adapters for this, but they had some problems:

1. They’re potentially hard to configure. You have to understand how to use browser files (remember, the original use was for switching markup for mobile devices)

For example, to change a single adapter on a specific control type, you’d have to create an App_Browsers directory in your app then create a new *.browser file and enter it’s contents, pointing to the adapter you have created (or dropped the dll ofg into your bin directory). This sample is taken from Fritz Onion’s MSDN article

   1: <browsers>

   2:   <browser refID="Default">

   3:     <controlAdapters>

   4:       <adapter

   5:         controlType="System.Web.UI.WebControls.BulletedList"

   6:         adapterType="MsdnMagazine.BulletedListControlAdapter"

   7:       />

   8:     </controlAdapters>

   9:   </browser>

  10: </browsers>

2. you can only configure these by control for a whole site at a time (want to change just the one you have problems with, well…tough!)
Number two is where AdapterGroup came in…the idea being that if you wanted to use one of the CSS Control Adapters for just one specific page / one specific control with which you were having problems, well you could just do this:

   1: <%@ Page Language="C#" AutoEventWireup="true"  CodeFile="Default.aspx.cs" Inherits="_Default" AdapterGroup="CSSAdapterGroup" %>

Notice in the above snippet that I’ve just set the AdapterGroup property for this page. This corresponds to a group defined in a *.browser file as follows:

   1: <browsers>

   2:   <browser refID="Default">

   3:     <controlAdapters>

   4:         <adapterGroup name="CSSAdapterGroup" >

   5:               <adapter

   6:                 controlType="System.Web.UI.WebControls.BulletedList"

   7:                 adapterType="MsdnMagazine.BulletedListControlAdapter"

   8:               />

   9:             </controlAdapters>

  10:         </adapterGroup>

  11:   </browser>

  12: </browsers>

Notice, that we’ve identified a specific set (well, one in this case!) of Control Adapters as belonging to this specific adapter group. It’s also possible to set this at site (by specifying the defaultAdapterGroup attribute in the Page config element), as well as just for individual controls, e.g.,

   1: <asp:Menu ID="Menu1" runat="server" adapterGroup="CSSAdapterGroup">

   2: ...

   3: </asp:Menu>

Again, the idea being that if you wanted just to fix up a page / control at a time to use specific adapters then this became possible.

However, as the owner of the feature I was never able to sell the rest of the team on this concept. So, my task in the next few days is to have this feature removed before Beta 2 ships…well, I liked it :-)

Thus ends the story of the disappearing feature…

Little hack: CSS Combiner / Minifier ASP.NET Control

Scott Galloway — Fri, 24 Apr 2009 20:59:13 GMT

CAUTION: When I say hack I mean it…this is in NO WAY production ready…it’s just a sample at this stage. If it causes your dog to explode, don’t blame me!

I thought I’d throw a work in progress online for people to have a play with. This is one of my little pet projects (I’m not allowed to write code at work…not a dev as I’[m always reminded!).

So, what does it do?

Well, one of the major performance issues for current websites is the number of requests they make back to the server, not the actual server-side processing time. When I first wrote about this after reading Steve Sounders excellent ‘High Performance Websites’ it was frankly a surprise to me! Well, anyway recently I’ve been playing with a number of ASP.NET server control which aim at making optimizing the number of server calls an ASP.NET app has to make much fewer. The first of these is the (as yet) unpublished CSS Sprite Control. Below is the beginning of the second; this was written in a couple of hours last night as I couldn’t sleep for thinking about how it might work. The code is VERY rough but it demonstrates the concept pretty well.

In essence I wanted the minimum effort possible to combine and compress multiple <link rel=”stylesheet”> CSS file entries together, minimize them using YUI Compressor (for .NET…on Codeplex) and output a time dependent (in this case, Date Modified for the file) hash for the file name (in a fixed location at the moment, “~/OutputCSS/”), then output a tag in the page for this new file.

So, how does it work?

Well, imagine you had a page with some stylesheet definitions like this:

   1: <link type="text/css" rel="stylesheet" href="../../../build/logger/assets/logger.css"/>

   2: <link type="text/css" rel="stylesheet" href="../../../build/yuitest/assets/testlogger.css"/>

   3: <style type="text/css">

   4: #container, #container2 {

   5:     width: 400px;

   6: }

7:

   8: .yui-carousel-element {

   9:     margin: 0;

  10:     padding: 0;

  11: }

12:

  13: .yui-carousel-element li {

  14:     border: none;

  15:     margin: 0;

  16:     padding: 0;

  17:     width: 100px;

  18: }

  19: </style>

As you can see we have two CSS file definitions and a style tag. Wouldn’t it be nice if we could combine and minify these…well…here’s how my little hacky control lets you do it:

   1: <asp:CSSManager runat="server">

   2:         <link type="text/css" rel="stylesheet" href="~/build/logger/assets/logger.css"/>

   3:         <link type="text/css" rel="stylesheet" href="../../../build/yuitest/assets/testlogger.css"/>

   4:         <style type="text/css">

   5:         #container, #container2 {

   6:             width: 400px;

   7:         }

8:

   9:         .yui-carousel-element {

  10:             margin: 0;

  11:             padding: 0;

  12:         }

13:

  14:         .yui-carousel-element li {

  15:             border: none;

  16:             margin: 0;

  17:             padding: 0;

  18:             width: 100px;

  19:         }

  20:         </style>

  21: </asp:CSSManager>

You can see in the snippet above that we just wrapped the CSS definitions in <asp:CSSManager>…</asp:CSSManager> tags…that’s all there is to it! One other thing, the observant will have noticed that I can now use a ~/ in the href…it’s a nice side effect of this method…lets you avoid the crazy path traversal stuff (../../../)

Obviously this is still a bit limited, it doesn’t work in Partial Trust, doesn’t handle multiple scopes; say, Site level CSS, Page Level CSS and Masterpages where you’d want multiple sheets with different contents. Plan is to keep working on this for a little while…so I will almost certainly update this soon.

Source follows…

   1: using System;

   2: using System.Collections.Generic;

   3: using System.ComponentModel;

   4: using System.Text;

   5: using System.Web.UI;

   6: using System.Web.UI.HtmlControls;

   7: using System.IO;

   8: using System.Security.Cryptography;

   9: using Yahoo.Yui.Compressor;

10:

  11: namespace CSSManager

  12: {

  13:     [DefaultProperty("Text")]

  14:     [ToolboxData("<{0}:CSSManager runat=server></{0}:CSSManager>")]

15:

  16:     [ParseChildren(true, "cssFiles")]

  17:     public class CSSManager : Control, INamingContainer

  18:     {

19:

  20:         public const string FILE_PATH = "~/OutputCSS/{0}.css";

21:

  22:         public CSSManager() { }

23:

  24:         public List<HtmlGenericControl> CSSFiles

  25:         {

  26:             get;

  27:             set;

  28:         }

29:

30:

  31:         private StringBuilder combinedSheets = new StringBuilder();

32:

  33:         public string GetStyleSheet(string virtualPath)

  34:         {

  35:             string filePath = Context.Server.MapPath(virtualPath);

  36:             if (!string.IsNullOrEmpty(filePath))

  37:             {

  38:                 return File.ReadAllText(filePath);

  39:             }

  40:             return string.Empty;

41:

  42:         }

43:

  44:         public string CalculateFileHash(string filePaths)

  45:         {

  46:             MD5CryptoServiceProvider csp = new MD5CryptoServiceProvider();

  47:             byte[] pathBytes = csp.ComputeHash(System.Text.UTF8Encoding.UTF8.GetBytes(filePaths));

  48:             return BitConverter.ToUInt64(pathBytes, 0).ToString();

49:

  50:         }

51:

  52:         public void WriteFile(string textToWrite, string fileHash)

  53:         {

  54:             File.WriteAllText(Context.Server.MapPath(string.Format(FILE_PATH, fileHash)), textToWrite);

  55:         }

56:

  57:         public string CreateDatedFilePath(string filePath)

  58:         {

  59:             FileInfo fi = new FileInfo(Context.Server.MapPath(filePath));

  60:             if (fi.Exists)

  61:             {

  62:                 return fi.LastWriteTimeUtc.Ticks.ToString() + "#" + filePath;

  63:             }

  64:             return string.Empty;

65:

66:

  67:         }

68:

  69:         protected override void CreateChildControls()

  70:         {

71:

  72:             if (this.DesignMode == true)

  73:             {

  74:                 foreach (var file in CSSFiles)

  75:                 {

  76:                     string rel = file.Attributes["rel"];

77:

  78:                     string href = file.Attributes["href"];

79:

  80:                     if (rel.ToLowerInvariant() == "stylesheet")

  81:                     {

  82:                         file.Attributes["href"] = this.ResolveClientUrl(Context.Server.MapPath(href));

  83:                         this.Controls.Add(file);

  84:                     }

85:

  86:                 }

  87:             }

  88:             StringBuilder filePaths = new StringBuilder();

  89:             int i = 0;

  90:             foreach (var file in CSSFiles)

  91:             {

  92:                 string tagName = file.TagName.ToLowerInvariant();

  93:                 if (tagName == "link")

  94:                 {

  95:                     string rel = file.Attributes["rel"];

  96:                     string href = file.Attributes["href"];

97:

  98:                     if (rel.ToLowerInvariant() == "stylesheet")

  99:                     {

 100:                         string styleSheet = GetStyleSheet(href);

 101:                         if (!string.IsNullOrEmpty(styleSheet))

 102:                             combinedSheets.Append(styleSheet);

 103:                         filePaths.AppendFormat("{0}#", CreateDatedFilePath(href));

 104:                     }

 105:                 }

 106:                 else if (tagName == "style")

 107:                 {

 108:                     string inner = file.InnerHtml;

 109:                     combinedSheets.Append(inner);

 110:                     filePaths.Append("CSSSTYLE_" + i);

 111:                     i++;

 112:                 }

 113:

 114:             }

 115:             string minimizedStyles = CssCompressor.Compress(combinedSheets.ToString(), 0, CssCompressionType.Hybrid);

 116:             string fileHash = CalculateFileHash(filePaths.ToString());

 117:             WriteFile(minimizedStyles, fileHash);

 118:

 119:             HtmlGenericControl gen = new HtmlGenericControl();

 120:             gen.TagName = "link";

 121:             gen.Attributes.Add("href", this.ResolveClientUrl(string.Format(FILE_PATH, fileHash)));

 122:             gen.Attributes.Add("rel", "stylesheet");

 123:             this.Controls.Add(gen);

 124:         }

 125:

 126:     }

 127: }

A history of what comes next...(totally random!)

Scott Galloway — Sun, 05 Apr 2009 21:18:07 GMT

This is basically a brain dump…watching / reading too much Sci-Fi :-) Was thinking about the Technological Singularity and how it could happen…which lead me to a different slant on the topic…Be glad I usually spare you these strange mental spasms! I kinda liked this one tho’

Starter phase: transparent electronic retinal implant

Uses nano electrodes to stimulate the retina given specific wavelengths of infrared light. A minor modification would allow the use of this device as an optical overlay. A very small camera may be implanted within the vitreous fluid of the eye, allowing the instantaneous interpretation of the current visual field.Such information can also be 3dimensionally processed through the use of synchronized implantable camera electrode modules in both eyes. A very small, directable and morphable lens in front of the camera module would also permit focus / zoom functions for the user. Direct nerve / optic center stimulation using variable length nano scale electrodes. Covers a precisely shaped 3 dimensional area of the brain, permitting direct creation of eye equivalent images.

Even further, the creation of interface layers within the brain, permitting replication of communication patterns when passing through the brain. permits the replacement of any brain function by electronic simulation. There should be no realistic boundary to this technology, with any structure able to be simulated.a fully deployable, nanoscale mesh running throughout the brain would enable complete neural interface capabilities. This deep interaction would allow the exact replication and expansion of neural function in an external ultra computer. These simulations are well suited to quantuum computing devices. The vast increase in speed of processing and virtually limitless computational and memory enhancements provided by these computer allows virtually limitless enhancements of the human mind. Instantaneous with the creation of the first of these devices is the arrival of true ai.

Once humans experience true computer interaction they choose to forever abandon physical form. Able to live infinite lifetimes in a few milliseconds, the physical form quickly becomes abandoned. The last hold outs quickly find themselves alone on a planet of abandoned bodies. The vast worldwide network now comprised on trans humans is every individuals prefect heaven. We are become gods...time begins.

Back to life…

Scott Galloway — Fri, 27 Mar 2009 17:11:25 GMT

TechDays MVC 4.0 Overview

TechDays MVC Presentation

Well, I’ve been back in the US for 5 days now, still really jet lagged but getting there; also managed to pick up a stomach bug at some point…Yes, I’m a hypochondriac!

The three weeks I spend travelling round Europe were really fun, I got to head home and see family for a couple of days as well as spend time in Helsinki, Finland, Antwerp, Belgium and Vasteras, Sweden.

The picture below is Peli de Halleux and myself standing on the frozen Baltic Sea…which a few minutes before we’d been swimming in!

The three TechDays conferences (twitter feed) were really fun, and my first chance to present to the people who use our products. I presented sessions on MVC as well as covering a lot of the stuff that’s in ASP.NET 4.0. By the end of the 6 talks (2 at each conference) I was pretty confident (always a challenger for me) and enjoying the experience.
Meeting our users is always fun, discovering how people are using our products and the problems they’re having (the #aspnetpain hashtag is partly the result of this).

I also got a chance to spend some ‘quality time’ with our 4.0 features as well as MVC. Oddly, I don’t get to spend as much time using our stuff as I’d like (my work day is packed with toommuch other stuff). Using our new WebForm Routing feature was a lot of fun; and gave me a bunch of ideas for making things easier (for example, currently it’s not great on DataBound controls; when Beta 1 rolls around I’ll post some extension methods here to make life easier). I also got to thinking a lot more about how people will advance their apps, maybe not to full MVC but a stepping stone to aid transition; using Routing, adopting an MVP pattern etc…

Of course I also got tom play with the MVC framework; which is a really fun way to build apps (like many others I rolled my own MVC / MVP frameworks in the past). The new scaffolding functionality Phil and the team added in RC1 really moves this framework to a whole different level for beginners. Frankly if I were building an app nowadays, I’d use MVC…

Anyway, now I’m back and catching up on work, always a lot to do…

NOTE: The PPTs at the top of the post presentations from TechDays, if you want to use them for anything, feel free! (The speaker notes in the first one are kinda rough, please don’t take them as ‘the official word!’

In Scotland, it’s 3:30am and the beginning of a long 3 weeks

Scott Galloway — Wed, 04 Mar 2009 03:46:13 GMT

I’m writing this from bed in my parent’s house in Scotland.The next 3 weeks has me doing one of my least favorite activities in the world; presenting, 6 times in 3 countries.

Specifically I’m presenting at an MS conference called TechDays in Finland (this week), Belgium (next week) and Sweden (the week after). I really don’t like presenting and have forced myself to do these three conferences; presenting on ASP.NET 4.0 (including a look at VS10’s web dev features) and ASP.NET MVC (the very latest RC2). I am as usual extremely nervous…so we’ll see how it goes!

As I write this I leave for the airport in 12 hours to fly to Helsinki, Finland…just discovered that I forgot some small items in the snowstorm at work last week; visible items which make me look bad to the team. This will keep me awake all night and play on my mind for weeks (welcome to the mind of the depressive!). I completed hundreds of individual tasks last week but these 4 bugs will impact my career more than any other…sucks!

Anyway, going to try and get more sleep, next time I blog, I’ll be in Helsinki!