Code Snippets

WPF: Byte Array to Bitmap Value Converter

Scott Galloway — Sat, 13 Feb 2010 23:10:50 GMT

I wrote this for use in a little project but as I’m no longer using it, I though I’d stick it on here for anyone who wants it. Essentially, this allows you to take a byte Array (in my case, in the File property of my ThumbnailViewModel) and get it back as a BitmapImage for use in DataBinding…

It also has the property of accepting a parameter which lets you specify the size of thumbnail to use (ThumbSize). Here, I actually have multiple ThumbNails (in the List<ThumbNailViewModel>) and select one using the parameter.

Given this resource string and XAML,

<UserControl.Resources>
    <local:BytesToBitmapConverter x:Key="bytesToBitmapConverter"/>
</UserControl.Resources>

<Image Name="IconImage" Source="{Binding Path=ThumbNails, Converter={StaticResource bytesToBitmapConverter}, ConverterParameter=Small}"/>

    public class BytesToBitmapConverter : IValueConverter
    {

        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {


            var thumbs = value as List<ThumbnailViewModel>;
            var param = parameter as String;
            var thisThumb = thumbs.Find(x => x.ThumbnailSize == (ThumbSize)Enum.Parse(typeof(ThumbSize),param));

            BitmapImage bi = new BitmapImage();
            bi.BeginInit();
            bi.CacheOption = BitmapCacheOption.OnLoad;
            bi.StreamSource = new MemoryStream(thisThumb.File);
            bi.EndInit();
            return bi;

        }



        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {

            throw new Exception("The method or operation is not implemented.");

        }

    }

WPF for the Web guy…a story of pain, despair and learning

Scott Galloway — Wed, 20 Jan 2010 20:53:59 GMT

Well, OK I’m over dramatizing it a tad :) As you may have noticed from my last post I’ve started working of some stuff which is outside my comfort zone. I recently joined a company called cozwecan,working for a chap named @RobertTheGrey, the first project we’re working on is a photo sales site…you know kind of like Getty Images / Smugmug / Flickr except for direct photographer-customer sales. As the only full-time developer (so far!) I’ve been tasked with building the vast majority of the applications (be they web, desktop, etc…) which we need for the business to work.

Obviously one of the most critical bits for an e-commerce site is stuff to sell! In our case this is a stock of really high quality photographs taken by professional photographers around the world. First question; how do we get these images on the site, and how do we let the photographers add information to their photographs to let them be found by folks who want to buy them? Well, that’s the first problem I’ve been asked to solve!

When working on the requirements, it quickly became clear that this had to be a desktop app, it needed to allow operations on multi-megabyte photographs, needed to allow ‘tagging’ offline. Especially during initial loading, there’s 10-100s of thousands of images getting worked on…forcing this to be online adds a nasty lag and makes the task a pain in the butt to complete. Above all, it needed to be reliable!
Now, in my dev head this led to a number of decisions about the features the app would need to support:

1. Intuitive, responsive UI; the users are not necessarily computer-savvy, need to use obvious UI metaphors and make it fast enough to be pleasant to use.
2. Needs to do some offline image processing; we’re planning on hosting this on the cloud….CPU time costs cash :)
3. Should work offline
4. Needs to be built around reliable upload of multi-meg files (across potentially tiny connection bandwidths).

So, these are the basic needs…technically this leads me to some technology choices:

1. Multi-threading / concurrency (as with any real desktop app) is key…as is a decent Desktop technology…
2. See above, we need to ‘watch’ for new files arriving, make thumbnails transparently etc…
3. So, it needs some sort of persistence…along with other non-core app requirements (e.g. tagging) we’ll likely need a little, lightweight DB.
4. Needs ‘block’ based uploads with retry / verification of uploaded items…

Luckily I’ve been a dev for quite a while and had at least some idea where to start…the biggest challenge would be learning!
Firstly, the obvious desktop platform de jour is WPF…this is in essence the current replacement for WinForms, it’s VERY customizable but has a somewhat infamously steep learning curve. I’ve spent a bit of cash on books on WPF, followed all the PDC presentations, podcasts etc…on the subject matter. After 3 weeks I’m finally getting comfortable with it…
Second, I needed a DB…needed to be lightweight, needed to support LINQ (what, I like LINQ :)), needed to support some sort of ORM technology.
The most obvious choice was SQL Server Compact Edition, a kind of cut down SQL server which is great for desktop apps…however…I could not get it working! Turns out it’s really sensitive to the versions of various installed components. This was a red light for me…I needed the DB to be as stand-alone as possible! That left one obvious choice:
SQLite, from the website:

‘SQLite is a software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine. SQLite is the most widely deployed SQL database engine in the world. The source code for SQLite is in the public domain.’

Perfect! For .NET support, I used the SQLite ADO.NET provider (there is a C# only port of SQLite, but it’s slower and not needed for my scenario. Deployment is literally including a reference and creating a file…now it does have one pretty severe limitation which I’ll cover later :)

My ORM choices were nHibernate or EF…there being support for SQLite in both of these platforms.
Now, I have used nHibernate for a recent project (disclaimer, I left fairly early in the project :)) and one of the things which annoyed me was the large number of dependencies, and the seeming fragility across versions of these dependencies. For a low impact desktop app, this was just too large a footprint and too big a risk. So I had to count it out.
This left me with one choice…Entity Framework. Now, this wasn’t an easy choice…I have used EF in the past (tinkered with it) and found it a painful experience…(others have too which led to this). Now, I’m not getting into the politics behind MS choice to push EF (and yes, it was a political choice), but V1 is fairly buggy, and for me at least fairly unnatural. This led to my second learning ‘opportunity’…Master Entity Framework! As I write this, it’s literally 2 hours since I worked out my last bit of EF pain…which led to this model:

Looks simple…well, yeah…but it’s taken me AGES to get to this…I know SQL really well, C# REALLY well, but the mix of obscure concepts, poor documentation and obfuscated error messages makes working / learning EF way too hard! EF 4 (in VS 2010 / .NET 4) improves this…and it can’t come soon enough!

So, that’s worked out…I hope :)

So, I mentioned previously that SQLite has a bit of an issue…it doesn’t really like concurrency. Well, that’s an overstatement…it is a multi-read, single write system. Once you realize it’s an issue it’s fairly easy to solve. I use this pattern:

public static void AddRange(IEnumerable<UploadFile> files)
        {
            using (PixEntities ent = new PixEntities())
            {
                using (new ReadLock(entityLock))
                {

                    using (new WriteLock(entityLock))
                    {
                        foreach (var file in files)
                        {
                            ent.AddToUploadFiles(file);
                            ent.SaveChanges();
                        }
                    }
                }
            }
        }

As you seen, this has two main elements…I use a ReadLock (where I would normally read *from* the DB, in this case umm, I don’t :)) then I use a WriteLock to wrap any operation where I write to the DB. The observant will also notice what looks like a bug…I do ent.SaveChages() for each iteration of the loop…this is another SQLite quirk, it doesn’t support batch updates…and gives a weird error about file locks if you try :)

The little locking class I use is from here, but I’ve put it below for your use…anyway, this is part one of several parts of my experiences in working on cozwecan…stay tuned!

  public static class Locks
    {
        public static void GetReadLock(ReaderWriterLockSlim locks)
        {
            bool lockAcquired = false;
            while (!lockAcquired)
                lockAcquired = locks.TryEnterUpgradeableReadLock(1);
        }


        public static void GetReadOnlyLock(ReaderWriterLockSlim locks)
        {
            bool lockAcquired = false;
            while (!lockAcquired)
                lockAcquired = locks.TryEnterReadLock(1);
        }


        public static void GetWriteLock(ReaderWriterLockSlim locks)
        {
            bool lockAcquired = false;
            while (!lockAcquired)
                lockAcquired = locks.TryEnterWriteLock(1);
        }


        public static void ReleaseReadOnlyLock(ReaderWriterLockSlim locks)
        {
            if (locks.IsReadLockHeld)
                locks.ExitReadLock();
        }


        public static void ReleaseReadLock(ReaderWriterLockSlim locks)
        {
            if (locks.IsUpgradeableReadLockHeld)
                locks.ExitUpgradeableReadLock();
        }


        public static void ReleaseWriteLock(ReaderWriterLockSlim locks)
        {
            if (locks.IsWriteLockHeld)
                locks.ExitWriteLock();
        }


        public static void ReleaseLock(ReaderWriterLockSlim locks)
        {
            ReleaseWriteLock(locks);
            ReleaseReadLock(locks);
            ReleaseReadOnlyLock(locks);
        }


        public static ReaderWriterLockSlim GetLockInstance()
        {
            return GetLockInstance(LockRecursionPolicy.SupportsRecursion);
        }


        public static ReaderWriterLockSlim GetLockInstance(LockRecursionPolicy recursionPolicy)
        {
            return new ReaderWriterLockSlim(recursionPolicy);
        }
    }


    public abstract class BaseLock : IDisposable
    {
        protected ReaderWriterLockSlim _Locks;


        public BaseLock(ReaderWriterLockSlim locks)
        {
            _Locks = locks;
        }


        public abstract void Dispose();
    }


    public class ReadLock : BaseLock
    {
        public ReadLock(ReaderWriterLockSlim locks)
            : base(locks)
        {
            Locks.GetReadLock(this._Locks);
        }


        public override void Dispose()
        {
            Locks.ReleaseReadLock(this._Locks);
        }
    }


    public class ReadOnlyLock : BaseLock
    {
        public ReadOnlyLock(ReaderWriterLockSlim locks)
            : base(locks)
        {
            Locks.GetReadOnlyLock(this._Locks);
        }


        public override void Dispose()
        {
            Locks.ReleaseReadOnlyLock(this._Locks);
        }
    }


    public class WriteLock : BaseLock
    {
        public WriteLock(ReaderWriterLockSlim locks)
            : base(locks)
        {
            Locks.GetWriteLock(this._Locks);
        }


        public override void Dispose()
        {
            Locks.ReleaseWriteLock(this._Locks);
        }
    }

Image Utilities

Scott Galloway — Thu, 07 Jan 2010 13:41:40 GMT

Thought I’d just post some dumb little utility classes that I had hanging about in my code repository (and always end up trying to find).

They’re just little utility classes for finding out image format / extensions / content types for various images…(and before any smartass pipes up, yes much of this info is in registry…but this is intended for use where I can’t access that)

 public static class Imaging
    {

        public static string GetContentTypeByImageFormat(ImageFormat format)
        {
            string ctype = "image/x-unknown";

            if (format.Equals(ImageFormat.Gif))
            {
                ctype = "image/gif";
            }
            else if (format.Equals(ImageFormat.Jpeg))
            {
                ctype = "image/jpeg";
            }
            else if (format.Equals(ImageFormat.Png))
            {
                ctype = "image/png";
            }
            else if (format.Equals(ImageFormat.Bmp) || format.Equals(ImageFormat.MemoryBmp))
            {
                ctype = "image/bmp";
            }
            else if (format.Equals(ImageFormat.Icon))
            {
                ctype = "image/x-icon";
            }
            else if (format.Equals(ImageFormat.Tiff))
            {
                ctype = "image/tiff";
            }

            return ctype;
        }

        public static ImageFormat GetImageFormatByContentType(string contentType)
        {
            ImageFormat format = null;

            if (contentType != null)
            {
                if (contentType.Equals("image/gif"))
                {
                    format = ImageFormat.Gif;
                }
                else if (contentType.Equals("image/jpeg") || contentType.Equals("image/pjpeg"))
                {
                    format = ImageFormat.Jpeg;
                }
                else if (contentType.Equals("image/png"))
                {
                    format = ImageFormat.Png;
                }
                else if (contentType.Equals("image/bmp"))
                {
                    format = ImageFormat.Bmp;
                }
                else if (contentType.Equals("image/x-icon"))
                {
                    format = ImageFormat.Icon;
                }
                else if (contentType.Equals("image/tiff"))
                {
                    format = ImageFormat.Tiff;
                }
            }

            return format;
        }

        public static string GetFileExtensionByContentType(string contentType)
        {
            string ext = "bin";

            if (contentType.Equals("image/gif"))
            {
                ext = "gif";
            }
            else if (contentType.Equals("image/jpeg") || contentType.Equals("image/pjpeg"))
            {
                ext = "jpg";
            }
            else if (contentType.Equals("image/png"))
            {
                ext = "png";
            }
            else if (contentType.Equals("image/bmp"))
            {
                ext = "bmp";
            }
            else if (contentType.Equals("image/x-icon"))
            {
                ext = "ico";
            }
            else if (contentType.Equals("image/tiff"))
            {
                ext = "tif";
            }

            return ext;
        }

        public static string GetContentTypeByFileExtension(string fileExtension)
        {
            switch (fileExtension)
            {
                case ("gif"):
                    return "image/gif";
                case ("jpg"):
                    return "image/jpeg";
                case ("jpeg"):
                    return "image/jpeg";
                case ("bmp"):
                    return "image/bmp";
                case ("tif"):
                    return "image/tiff";


            }
            return "application/octet-stream";

        }
    }

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 :)

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: }

Premature optimization and user perception...my pet project and CSS Sprites

Scott Galloway — Sat, 12 Jul 2008 02:54:36 GMT

One of the themes I'm looking at for vNext of ASP.NET is the optimization of sites by reducing the number of server requests required for a single page.
A new classic in the area of improving the perceived performance of your sites by reducing the number of server roundtrips is Steven Sounders book 'High Performance Websites'. Steven's book is very small, very readable and probably the best book on anything to do with the web that I've read in years.
This book was a huge revelation for me...I spent most of my coding career writing the slickest, highest performing code I could...and frankly thinking about the structure of the actualy pages the user sees would've been a better use of my time in a lot of cases. As an example,, this was one of the last sites which I worked on as a full time developer...the code is about the best I ever created, the DB is optimized up the wazoo and I very nearly killed myself trying to make it 'perfect'...but for the hundreds of hours I spent sweating blood over the code you could now spend a couple of thousand dollars on a faster server and improve the performance even more...(even ignoring the fact that it's HUGELY overengineered...even has it's own MVC system and templating feature...hey, I was bored!)
As servers get faster and programming frameworks get more efficient, the amount of time your web server actually spends processing a page, doing a DB request and whatever else it has to do to generate HTML gets smaller and smaller; with better use of caching, AJAX and other techniques it's likely that you page actually returns it's total content to the user in milliseconds.... You can really only make minimal gains to 'preceived performance' in your sites by optimizing the dynamic code in your web application these days...(and this will likely only reduce over time)

Welcome to Moore's law

The fact is that for 99% of web pages the issue is no longer really about optimizing the amount of time your page takes to return HTML content to the user...it's what happens afterwards which leads to poor download performance.

The Problem

Websites nowadays have more and more separate elements in a single webpage, images, css, js files, flash content, videos etc...often the number of requests sent from single page can take MANY (as in several orders of magnitude) times longer than the bit we developers commonly fret about. As an example a few seconds ago I requested the CNN homepage, the actual page of HTML content loaded in 222ms, but the OTHER 153 requests for the rest of the stuff the page needed took a total of 4.65s.
One way to avoid a large number of these other requests is to combine requests for multiple objects together. In ASP.NET 3.5 SP1 we'll be shipping a feature called 'ASP.NET AJAX Script Combining', as the name suggests this feature combines multiple HTTP requests (in this case for the ASP.NET AJAX scripts) into a single request, potentially greatly reducing the number of roundtrips to the server.

Where is this going?

Well, a feature I've been playing with (and which I'm considering for ASP.NET vNext) is an ASP.NET CSS Sprite Control. Zack Owens has already posted about a technique for doing this in ASP.NET, but I wanted to increase the usability of generating these sprites; think using an ASP.NET image control and them magically being combined and output as part of a Sprite...
For those who don't know, CSS Sprites are essentially a technique which involves combining multiple images into one and using CSS to specify which one to show when they download. With this technique you both reduce the number of server requests as well as 'pre-loading' images on the fly (when's the last time you had an image rollover which seemed to stutter as it loaded the next image?).
Anyway, that's the idea; below is a some ASP.NET markup I'm playing with...this would resuly in a single PNG image being generated, along with a CSS definition for the sprite and for each 'image' to be displayed in the page.
This is still very much a work in progress and there's a ton of challenges around persisting the generated image in a scalable way etc...But well, I've been quiet of late so I thought I'd let you know what I'm playing with these days...

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<cs:SpriteManager runat="server" GroupName="DEFAULTGROUP" ImageFormat="png"></cs:SpriteManager>
</head>
<body>
<form id="form1" runat="server">
<cs:Sprite ID="Sprite" ReferenceId="Clock" runat="server" ImageUrl="~/icons/Clock.ico"/>
<cs:Sprite ID="Sprite1" ReferenceId="Contacts" runat="server" ImageUrl="~/icons/contacts 1.ico"/>
<cs:Sprite ID="Sprite2" ReferenceId="Alerts" runat="server" ImageUrl="~/icons/alerts.ico" />
<cs:Sprite ID="Sprite3" ReferenceId="Download" runat="server" ImageUrl="~/icons/download.ico"/>
<cs:Sprite ID="Sprite4" ReferenceId="Desktop" runat="server" ImageUrl="~/icons/desktop.ico" />
</form>
</body>
</html>

Dumb little recursive, generic FindControl method...

Scott Galloway — Wed, 14 May 2008 18:32:39 GMT

Doing some app building and I needed to use FindControl to manipulate a control in the OnItemCreated event in a Repeater...well, to save a bit of typing I came up with this extension method:

namespace Presentation

{

public static class ControlHelper

{

public static T FindControl<T>(this System.Web.UI.Control root, string controlId, bool recursive) where T: System.Web.UI.Control

{

if(root.Controls!=null && root.Controls.Count>0 && root.FindControl(controlId) != null)

{

return root.FindControl(controlId) as T;

}

else if(recursive)

{

return FindControl<T>(root, controlId, recursive);

}

return null;

}

Pretty simple but it lets me do the following :

var link = e.Row.FindControl<HyperLink>("MenuLink", true);

if(link!=null) link.NavigateUrl="http://www.mostlylucid.net";

Not a HUGE time-saver but it just makes my code a bit tidier...

Grrr...poor use of singletons and a very cool Generic Singleton pattern!

Scott Galloway — Thu, 01 May 2008 05:42:20 GMT

I posted earlier that I'm switching to blogengine.net, as part of this I've been fiddling around with the code (as is my way..I'll contribute back to the source when I've finished). One of my major pet hates is poor use of the singleton pattern, especially as there's a definitive article on the pattern in .NET and how to do it well. It's actually likely that this pattern is overkill in this case and a ReaderWriterLockSlim could be better (though it has it's own problems) . Anyway, on the assumption that a Singleton is the best choice here, let's look at the current code:

public static BlogSettings Instance

{

get

{

if (blogSettingsSingleton == null)

{

blogSettingsSingleton = new BlogSettings();

}

return blogSettingsSingleton;

}

If you look at the article I mentioned above you'll see that this is the version which is specifically called out as follows:

"the above is not thread-safe. Two different threads could both have evaluated the test if (instance==null) and found it to be true, then both create instances, which violates the singleton pattern. Note that in fact the instance may already have been created before the expression is evaluated, but the memory model doesn't guarantee that the new value of instance will be seen by other threads unless suitable memory barriers have been passed.'

The common 'best' singleton pattern (well, it's debatable...but generally the best...) is a lot more wordy (see version 5 in that article) so I was please to find this post on a Generic Singleton (actually this was posted a while ago on Codeproject)...really nice. In the Utils class I added this:

/// <summary>

/// Provides a Singleton implementation using Generics.

/// </summary>

/// <typeparam name="T">Type of singleton instance</typeparam>

public sealed class Singleton<T> where T : new()

{

Singleton() { }

public static T Instance

{

get

{

return Nested.instance;

}

class Nested

{

// Explicit static constructor to tell C# compiler

// not to mark type as beforefieldinit

static Nested() { }

internal static readonly T instance = new T();

}

The code for returning the instance then becomes:

public static BlogSettings Instance

{

get

{

return Utils.Singleton<BlogSettings>.Instance;

}

You have to also change the constructor for BlogSettings to public to allow this this to work which does let devs shoot themselves in the foot (by ignoring the singleton) and you of course have to balance the benefit agains that risk...

Work in progress, Response.RelativeRedirect

Scott Galloway — Wed, 23 Apr 2008 22:00:43 GMT

Inspired by this post, only covers simple cases but it's a start. Essentially this is an extended version of Response which only allows redirection to pages within the same site...so allows /default.aspx, does not allow http://www.evildomain.com/default.aspx. I've also ripped off a member of my team's excellent work on Response.Redirecting to a new window. This method uses extension methods, to use it just drop the file in App_Code and Response gets two new members. Oh and it's incomplete because I didn't account for encoded / obfuscated URLs...I'll update when I do...

using System;

using System.Web;

using System.Web.UI;

public static class EnhancedRedirect

{

public static void RelativeRedirect(this HttpResponse response, string path)

{

RelativeRedirect(response, path, "_self");

}

public static void RelativeRedirect(this HttpResponse response, string path, string target)

{

RelativeRedirect(response, path, target, string.Empty);

}

public static void RelativeRedirect(this HttpResponse response, string path, string target, string windowFeatures)

{

if (!string.IsNullOrEmpty(path) && !path.StartsWith("http:") && !path.Contains("//"))

Redirect(response, path, target, windowFeatures);

else

{

throw new InvalidOperationException("Cannot redirect outside of the current site.");

}

public static void Redirect(this HttpResponse response, string url, string target, string windowFeatures)

{

Redirect(response, path, target, string.Empty);

}

public static void Redirect(this HttpResponse response, string url, string target, string windowFeatures)

{

if ((String.IsNullOrEmpty(target) || target.Equals("_self", StringComparison.OrdinalIgnoreCase)) && String.IsNullOrEmpty(windowFeatures))

{

response.Redirect(url);

}

else

{

Page page = (Page)HttpContext.Current.Handler;

if (page == null)

{

throw new InvalidOperationException("Cannot redirect to new window outside Page context.");

}

url = page.ResolveClientUrl(url);

string script;

if (!String.IsNullOrEmpty(windowFeatures))

{

script = @"window.open(""{0}"", ""{1}"", ""{2}"");";

}

else

{

script = @"window.open(""{0}"", ""{1}"");";

}

script = String.Format(script, url, target, windowFeatures);

ScriptManager.RegisterStartupScript(page, typeof(Page), "Redirect", script, true);

}