http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.callermembernameattribute(v=vs.110).aspx

Hate the INotifyPropertyChanged pattern in .NET, and especially the syntax of needing to pass the name of the property being changed (via a string or an Expression or …)?

There’s finally a built-in solution in .NET 4.5!

private string _testValue;
public string TestValue
{
    get { return _testValue; }
    set {
        if (_testValue != value)
        {
            _testValue = value;
            RaisePropertyChanged();
        }            
    }
}

protected void RaisePropertyChanged([CallerMemberName] String propertyName = null)
{
    var eventHandler = this.PropertyChanged;
    if (eventHandler != null)
    {
        eventHandler(this, new PropertyChangedEventArgs(propertyName));
    }
}

A new attribute you can apply to optional parameters which emits the name of the Caller! So in the example above, it’s “TestValue.”

Rock on!

Through testing SnugUp for the past 4 years, I’ve made quite the mess of my SmugMug account. Literally hundreds of poorly organized and often completely junk albums. I’ve been wanting to clean it up, but SmugMug’s UI for that is so obnoxiously slow and tedious that I decided I wanted to write a tool to make it easier to manage.

Admittedly, given the amount of time I’ve spent on writing the tool (which I’m not yet finished with), I could have cleaned up my SmugMug account dozens of times. However, with my developer hat on, I thought, how fun would that be?

So, I’ve started to create the SnugUp.Browser. It’s a bit of an interesting beast in that it is a Windows application that hosts a web browser to display its UI. I’d tried using WPF/XAML and just couldn’t get the look I was wanting in a reasonable amount of time and effort.

<RANT>WPF desperately needs a VirtualizingWrapPanel. Microsoft needs to ship it. </RANT>

So, I created a WinForms project to host the IE Web Browser. (Arrgh, the WPF WebBrowser sucks still. It’s not nearly as feature complete as the one from WinForms!). Internally, the web pages are served via an HttpListener.

try
{
    int portSuggest = GetAvailablePort();
    portSuggest = 40000;
    _listener.Prefixes.Add(string.Format("", portSuggest));
    _listener.Start();
    while (maxConnections-- > 0)
    {
        _listener.BeginGetContext(HandleRequest, _listener);                    
    }
}
catch (Exception ex)
{
    Debug.WriteLine(ex);
}

The HandleRequest method responds in two ways:

1. Respond with JSON data (as if it were a web service). 99% of the code needed to access SmugMug’s APIs was already written in a C# library I wrote for SnugUp.
2. Respond with binary data, providing a “proxy” to a service. This was needed to handle downloading images from the application. When the request was directly made from the WebBrowser to SmugMug, it was refused as the http-referer header was not a valid source apparently (SmugMug didn’t like “http://localhost:/####” as the referrer.

resourceRequested = context.Request.Url.LocalPath.Replace('/', '.');
if (resourceRequested.StartsWith(".")) { resourceRequested = resourceRequested.Substring(1); }
Debug.WriteLine(string.Format("Requested: {0}", resourceRequested));
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format("SnugUp.Resources.{0}", resourceRequested)))
{
    if (stream == null)
    {
        //context.Response.StatusCode = 404;

        if (url.LocalPath.StartsWith("/proxy"))
        {
            var proxyUrl = url.Query.Substring("?url=".Length);
            extension = Path.GetFileName(proxyUrl);
            try
            {
                WebClient client = new WebClient();
                byte[] buffer = client.DownloadData(proxyUrl);
                context.Response.Headers.Add("Expires", DateTime.UtcNow.AddDays(30).ToString("R"));                                        
                context.Response.ContentType = GetContentType(context, extension);
                context.Response.OutputStream.Write(buffer, 0, buffer.Length);                                         
            }
            catch
            {

                context.Response.StatusCode = 404;
            }
        }

    }
    else
    {
        string contentType = GetContentType(context, extension);

        context.Response.ContentType = contentType;                                
        stream.CopyTo(context.Response.OutputStream);
    }
    // Close the Response to send it to the client.
    //                        }
}

If the resource can’t be found as an Embedded Resource, it tries a proxy.

I built a tiny router for the web services so that I could easily plug-n-play new functionality:

public virtual object Route(string path, dynamic data)
{
    if (path.StartsWith("/")) { path = path.Substring(1); }
    var paths = path.Split('/');

    if (paths.Length > 0)
    {
        var controllerName = paths[0];
        var controllerType = Type.GetType(string.Format("SnugUp.Controller.{0}Controller", controllerName), false, true);
        if (controllerType != null)
        {
            var instance = InitializeControllerInstance(controllerType);
            // default?
            if (paths.Length > 1)
            {
                MethodInfo method = controllerType.GetMethod(paths[1]);
                if (method != null)
                {
                    try
                    {
                        object results = method.Invoke(instance, new object[] {data});
                        return results;
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex);
                    }
                }
            }
        }
    }
    return null;
}

It just looks up a request dynamically, maps to a method, and calls it (the response is eventually serialized as JSON).

For UI, I’m currently using Bootstrap (although that may be removed), Knockout.JS, and jQuery. I’m doing a bit of trickery to make sure that only what’s visible on the screen is loaded (even when the user scrolls up and down … it’s pretty smart).  I’ll likely post more about that in a future update.

The app is becoming larger… and bloated a bit when compared to my original needs.

It now can show the images from the gallery as well.

The project is hosted on GitHub. It uses JSON.NET for parsing the return values from the Nest servers.

There are three projects, with the lib containing the assembly that is used by the two test applications. One is a console app and the other a simple WPF application:

(My thermostats are named Zero, One, and Two).

If there’s interest, I plan on adding some methods to the library which allow modification of data (such as the current temperature), and ideally, support for live updates from the devices if I can make sense of the data that is returned.

FYI: I’ve now written a Node version of the API, detailed here.