Mongoose Web Server

If you ever need a lightweight web server then Mongoose is worth a look:  http://cesanta.com/downloads.html

Just download then run the executable and the directory that it resides in becomes accessible in the browser.

It’s simple and it just works!

Polymer: The future of HTML5

It seems in many ways HTML is moving closer and closer to XAML. 

Through the use of Web Components, Google have come up with a project that allows developers to write HTML web pages that make use of data binding through Node.bind(), custom controls using HTML Imports and modularity with the Shadow DOM - very very cool stuff! 

http://www.polymer-project.org/

https://github.com/polymer/polymer

Webcast introducing Polymer (from May 2013): 

Polymer webcast from Google

Architectual diagram:

platform.js is a poyfill to bring all modern browsers up to a base line allowing devs to be able to use polymer.js.

It is believed that over time the size of platform.js will reduce as browsers catch up.  That said it’s still only 32KB when gzipped.

The team have created a set of controls/elements for app development, built on top of the framework such as:

Everything is an element.  The composability of business applications will lead to much faster development time, enabling programmers to focus on solving business problems and not battling away with boilerplate code.

The future looks incredibly fun for developers.

Windows To Go

You can now create a Windows 8.1 image stored and run on a USB device.

Here’s how to set it up.  From the Control Panel select “Windows To Go”:

Insert your USB key:                                  

Select the Windows ISO image:

Enter a BitLocker password:

Create:                                 

In the Choose a boot option screen, select a boot (startup) option. If you tap or click Yes, the Windows Boot Manager configuration will be modified to automatically boot from your Windows To Go device when it is connected to this host computer:

NOTE If you want to change the boot option after running the wizard, in the Windows 8 Start screen, type Change Windows To Go Startup Options, tap or click Settings to change the search scope, and then tap or click the Change Windows To Go Startup Options app to open it.

When provisioning is complete, tap or click Save and restart to restart the host computer:

 

Full instructions can be found here:  http://www.microsoft.com/en-us/download/details.aspx?id=36184

Path Markup Syntax

Taken from:  http://msdn.microsoft.com/en-us/library/ms752293.aspx

M= Start point

L = Creates a line to this end point

H = Creates a horizontal line between the current point and the specified x-coordinate. H 90 is an example of a valid horizontal line command.

V = Creates a vertical line between the current point and the specified y-coordinate. v 90 is an example of a valid vertical line command.

Z = Close

ExcelMediaTypeFormatter

Working example of implementing an ExcelMediaTypeFormatter for WebApi.

Source:  https://github.com/stevenh77/ExcelFormatterForWebApi/

Full blog write up to follow….

How to serialize an Expression

Download (or use NuGet):  https://github.com/esskar/Serialize.Linq

using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Serialize.Linq.Serializers;
using Serialize.Linq.Tests.Internals;
using System;
using System.Linq.Expressions;

namespace Serialize.Linq.Tests
{
    public class FilmDto
    {
        public string Name { get; set; }
        public DateTime ReleaseDate { get; set; }
    }

    [TestClass]
    public class HowToSerializeAnExpressionTests
    {
        public TestContext TestContext { get; set; }

        private static IQueryable<FilmDto> GetFilms()
        {
            return new List<FilmDto>
                 {
                     new FilmDto { Name = "Gravity", ReleaseDate = new DateTime(2013, 10, 15) },
                     new FilmDto { Name = "Blade Runner", ReleaseDate = new DateTime(1975, 2, 28) },
                     new FilmDto { Name = "Superman", ReleaseDate = new DateTime(1985, 6, 6) },
                 }
                 .AsQueryable();
        }

        [TestMethod]
        public void BasicExpressionSerialization()
        {
            var predicate = (Expression<Func<FilmDto, bool>>)(film => film.Name.ToLower().Contains("n"));
            var serializer = new ExpressionSerializer(new BinarySerializer());
            var bytes = serializer.SerializeBinary(predicate);
            var predicateDeserialized = serializer.DeserializeBinary(bytes);
            this.TestContext.WriteLine("{0} serializes to bytes with length {1}", predicate, bytes.Length);
            
            ExpressionAssert.AreEqual(predicate, predicateDeserialized);

            var films = GetFilms();
            var expectedCount = films.Where(predicate).Count();
            
            // a simple example of executing an expression, leveraging IEnumerable
            var actualCount = films.Where((Expression<Func<FilmDto, bool>>)predicateDeserialized).Count();
            Assert.AreEqual(expectedCount, actualCount);

            // constructing the same call using more Expressions
            Expression whereMethodCall = Expression.Call(
                typeof(Queryable), 
                "Where", 
                new[] { films.ElementType }, 
                films.Expression, 
                Expression.Quote(predicateDeserialized));

            // executing the expression, leveraging IQueryable
            actualCount = films.Provider.CreateQuery<FilmDto>(whereMethodCall).Count();
            Assert.AreEqual(expectedCount, actualCount);
        }
    }
    
    // Bear in mind this issue with .NET 45:  http://forums.asp.net/t/1864636.aspx
    // reproducible if you use:  (film => film.ReleaseDate < new DateTime(1990, 01, 01))
    // (which is fixed with .NET 451!)
    // For finer grain support:
    // http://msdn.microsoft.com/en-us/library/vstudio/bb882637.aspx
}

If you want to swap out the BinarySerializer for Json, this would be the payload:

{
   "__type":"L:#Serialize.Linq.Nodes",
   "NT":18,
   "T":{
      "G":[
         {
            "N":"Serialize.Linq.Tests.FilmDto"
         },
         {
            "N":"System.Boolean"
         }
      ],
      "N":"System.Func`2"
   },
   "B":{
      "__type":"MC:#Serialize.Linq.Nodes",
      "NT":6,
      "T":{
         "N":"System.Boolean"
      },
      "A":[
         {
            "__type":"C:#Serialize.Linq.Nodes",
            "NT":9,
            "T":{
               "N":"System.String"
            },
            "V":"n"
         }
      ],
      "M":{
         "D":{
            "N":"System.String"
         },
         "M":8,
         "S":"Boolean Contains(System.String)"
      },
      "O":{
         "__type":"MC:#Serialize.Linq.Nodes",
         "NT":6,
         "T":{
            "N":"System.String"
         },
         "A":[

         ],
         "M":{
            "D":{
               "N":"System.String"
            },
            "M":8,
            "S":"System.String ToLower()"
         },
         "O":{
            "__type":"M:#Serialize.Linq.Nodes",
            "NT":23,
            "T":{
               "N":"System.String"
            },
            "E":{
               "__type":"P:#Serialize.Linq.Nodes",
               "NT":38,
               "T":{
                  "N":"Serialize.Linq.Tests.FilmDto"
               },
               "N":"film"
            },
            "M":{
               "D":{
                  "N":"Serialize.Linq.Tests.FilmDto"
               },
               "M":16,
               "S":"System.String Name"
            }
         }
      }
   },
   "P":[
      {
         "__type":"P:#Serialize.Linq.Nodes",
         "NT":38,
         "T":{
            "N":"Serialize.Linq.Tests.FilmDto"
         },
         "N":"film"
      }
   ]
}

If you want to swap it out for the XmlSerializer, this would be the payload:

<?xml version="1.0" encoding="UTF-8"?>
<E xmlns="http://schemas.datacontract.org/2004/07/Serialize.Linq.Nodes" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" i:type="L">
   <NT>Lambda</NT>
   <T>
      <G>
         <T>
            <N>Serialize.Linq.Tests.FilmDto</N>
         </T>
         <T>
            <N>System.Boolean</N>
         </T>
      </G>
      <N>System.Func`2</N>
   </T>
   <B i:type="MC">
      <NT>Call</NT>
      <T>
         <N>System.Boolean</N>
      </T>
      <A>
         <E i:type="C">
            <NT>Constant</NT>
            <T>
               <N>System.String</N>
            </T>
            <V xmlns:a="http://www.w3.org/2001/XMLSchema" i:type="a:string">n</V>
         </E>
      </A>
      <M>
         <D>
            <N>System.String</N>
         </D>
         <M>Method</M>
         <S>Boolean Contains(System.String)</S>
      </M>
      <O i:type="MC">
         <NT>Call</NT>
         <T>
            <N>System.String</N>
         </T>
         <A />
         <M>
            <D>
               <N>System.String</N>
            </D>
            <M>Method</M>
            <S>System.String ToLower()</S>
         </M>
         <O i:type="M">
            <NT>MemberAccess</NT>
            <T>
               <N>System.String</N>
            </T>
            <E i:type="P">
               <NT>Parameter</NT>
               <T>
                  <N>Serialize.Linq.Tests.FilmDto</N>
               </T>
               <N>film</N>
            </E>
            <M>
               <D>
                  <N>Serialize.Linq.Tests.FilmDto</N>
               </D>
               <M>Property</M>
               <S>System.String Name</S>
            </M>
         </O>
      </O>
   </B>
   <P>
      <E i:type="P">
         <NT>Parameter</NT>
         <T>
            <N>Serialize.Linq.Tests.FilmDto</N>
         </T>
         <N>film</N>
      </E>
   </P>
</E>

Project().To<T>: Lightweight mapper

Found this very cool code today:

http://www.devtrends.co.uk/blog/stop-using-automapper-in-your-data-access-code

// This is the kind of projection code that we are replacing

//var students = from s in context.Students
//               select new StudentSummary
//                          {
//                              FirstName = s.FirstName,
//                              LastName = s.LastName,
//                              TutorName = s.Tutor.Name,
//                              CoursesCount = s.Courses.Count
//                          };


// The line below performs exactly the same query as the code above.

var students = context.Students.Project().To<StudentSummary>();

Which is all down to the following code:

public static class QueryableExtensions
{
    public static ProjectionExpression<TSource> Project<TSource>(this IQueryable<TSource> source)
    {
        return new ProjectionExpression<TSource>(source);
    }
}

public class ProjectionExpression<TSource>
{
    private static readonly Dictionary<string, Expression> ExpressionCache = new Dictionary<string, Expression>();

    private readonly IQueryable<TSource> _source;

    public ProjectionExpression(IQueryable<TSource> source)
    {
        _source = source;
    }

    public IQueryable<TDest> To<TDest>()
    {
         var queryExpression = GetCachedExpression<TDest>() ?? BuildExpression<TDest>();

        return _source.Select(queryExpression);
    }        

    private static Expression<Func<TSource, TDest>> GetCachedExpression<TDest>()
    {
        var key = GetCacheKey<TDest>();

        return ExpressionCache.ContainsKey(key) ? ExpressionCache[key] as Expression<Func<TSource, TDest>> : null;
    }

    private static Expression<Func<TSource, TDest>> BuildExpression<TDest>()
    {
        var sourceProperties = typeof(TSource).GetProperties();
        var destinationProperties = typeof(TDest).GetProperties().Where(dest => dest.CanWrite);
        var parameterExpression = Expression.Parameter(typeof(TSource), "src");
        
        var bindings = destinationProperties
                            .Select(destinationProperty => BuildBinding(parameterExpression, destinationProperty, sourceProperties))
                            .Where(binding => binding != null);

        var expression = Expression.Lambda<Func<TSource, TDest>>(Expression.MemberInit(Expression.New(typeof(TDest)), bindings), parameterExpression);

        var key = GetCacheKey<TDest>();

        ExpressionCache.Add(key, expression);

        return expression;
    }        

    private static MemberAssignment BuildBinding(Expression parameterExpression, MemberInfo destinationProperty, IEnumerable<PropertyInfo> sourceProperties)
    {
        var sourceProperty = sourceProperties.FirstOrDefault(src => src.Name == destinationProperty.Name);

        if (sourceProperty != null)
        {
            return Expression.Bind(destinationProperty, Expression.Property(parameterExpression, sourceProperty));
        }

        var propertyNames = SplitCamelCase(destinationProperty.Name);

        if (propertyNames.Length == 2)
        {
            sourceProperty = sourceProperties.FirstOrDefault(src => src.Name == propertyNames[0]);

            if (sourceProperty != null)
            {
                var sourceChildProperty = sourceProperty.PropertyType.GetProperties().FirstOrDefault(src => src.Name == propertyNames[1]);

                if (sourceChildProperty != null)
                {
                    return Expression.Bind(destinationProperty, Expression.Property(Expression.Property(parameterExpression, sourceProperty), sourceChildProperty));
                }
            }
        }

        return null;
    }

    private static string GetCacheKey<TDest>()
    {
        return string.Concat(typeof(TSource).FullName, typeof(TDest).FullName);
    }

    private static string[] SplitCamelCase(string input)
    {
        return Regex.Replace(input, "([A-Z])", " $1", RegexOptions.Compiled).Trim().Split(' ');
    }
}