public class LogManager
    {
        static LogManager()
        {
            var layout = new PatternLayout("%date [%level] %logger :: %message%newline");
            var appender = new RollingFileAppender
            {
                File = ConfigurationManager.AppSettings["Settings.Logging.Path"],
                Layout = layout
 
            };
            layout.ActivateOptions();
            appender.ActivateOptions();
            log4net.LogManager.GetRepository().Threshold = Level.Debug;
 
            BasicConfigurator.Configure(appender);
        }
 
        public static ILog Log 
        {
            get {
                return log4net.LogManager.GetLogger(new StackTrace().GetFrame(1).GetMethod().DeclaringType);
            }
        }
    }

Usage:

LogManager.Log.Info("This is an Info message");

My understanding is that the reflection method is not lightweight, so you might want to consider not using this in a production environment.

If I wanted to capture “api/{controller}/{id}” I would set up the following route:

config.Routes.MapHttpRoute(
        name: "DefaultApi",
        routeTemplate: "api/{controller}/{id}",
        defaults: new {id = RouteParameter.Optional}
    );

This will capture “api/dogs” and “api/dogs/1″.

But my co-worker wants to make sure that id’s are always an integer to keep away pesky internet savvy folks that try to break the application and he doesn’t trust my controller to do this for us. So he changes the route to:

config.Routes.MapHttpRoute(
        name: "DefaultApi",
        routeTemplate: "api/{controller}/{id}",
        defaults: new {id = RouteParameter.Optional},
        constraints: new {id = @"\d+"}
    );

Suddenly, the route now only captures “api/dogs/1″ and not “api/dogs”. The constraint has overwritten the RoutParameter.Optional on id. While I’m not sure why the two options conflict, to avoid this, keep constraints off the route config and let the controller do its thing. It’s pretty good at it.

[HttpGet]
    public HttpResponseMessage GetDogs(int? id = null)
    {
        if (id.HasValue)
            return JsonNetResult.CreateResult(DogManager.GetById(id.Value));
        else
            return JsonNetResult.CreateResult(new Dog());           
    }

Until I can figure out what causes this, the workaround is to create a new model class without that attribute. All of the other class properties can be the same…

public class InputModel
{
public string value1 { get; set; }
public string value2 { get; set; }
public string value3 { get; set; }
}
 
[HttpGet]
public HttpResponseMessage MyApiMethod(int id, InputModel model)
{
....
do stuff
....
return new HttpResponseMessage(HttpStatusCode.OK);
}

As mentioned above, everytime, my input model would be null! After doing some googling, I found out about a little ditty named “FromUri”. Placing this before a parameter would tell the controller to hydrate the model from Uri variables.

public HttpResponseMessage MyApiMethod(int id, [FromUri] InputModel model)

It works! My model is no longer null and has the expected values from my query string (api/controller/action/id?value1=1&value2=2&value3=3)!

I then stumbled upon a stackoverflow question in which someone was having a similar issue.

Enter Visual Event 2. VE2 is an open source bookmarklet that, when loaded, will highlight all of the objects with events on a page and show you what scripts will be called when they are clicked. This thing is absolutely brilliant. I was instantly able to see what script was being called and found it in seconds. Better still, since it’s a bookmarklet, it should work in most modern browsers too!

This thing will permanently live in my developer toolbox. I highly suggest it for developers working on sites that are js intense.

Visual Event 2 Website

IE9 is getting better, but the legacy that it left and that we developers have to deal with is cringe-worthy. One of my often used layout CSS bits is display:inline-block

Unfortunately, this does not degrade gracefully in IE < 8. I usually have to look this up everytime I view a page in IE, so I figured I’d pen it here so that I can find it more easily. The trick, as many of you might know, is to add the following in the CSS:

zoom: 1;
*display: inline;

Source: How to fix the IE7 and inline-block CSS bug

(function($){
  $.fn.thickbox = function( options ) {  
	  var settings = $.extend( {
		  'title' : '',
		  'href' : '',
		  'group' : false,
		}, options);
    return this.each(function() {
        if ($(this).hasClass('hasThickbox') == false) {
            var $elem = $(this);
            $elem.click(function () {
                var t = settings.title
                var a = settings.href;
                var g = settings.group;
                tb_show(t, a, g);
                this.blur();
                return false;
            });
            $elem.addClass('hasThickbox');
        }
    });
  };
})( jQuery );

I’ve kept it largely the same as it was in its original form so that others can easily see how it works and so that there aren’t too many modifications to the original logic. The function expects the options: Title, href, and group. All 3 work the same way as they did with the original plugin, and the options for Thickbox are still supplied as a query string through the href option value (see herefor an explanation of the query string options).

There are still many things that I’m not particularly fond of with Thickbox, but if you’re being forced to use it, this will at least provide you with a little bit less of a hassle.

Android File Transfer is an application for Macintosh computers (running Mac OS X 10.5 or later) you can use to view and transfer files between your Mac and an Android device (running Android 3.0 or later).

Even though Android phones are a direct competitor to Apple’s iPhone, hopefully Apple will smarten up in the near future and build this in to their operating system. There are many other devices that use this protocol and to not include it would be plain silly.

range.deleteContents();
range.insertNode(newContents);

newContents was simply a span element with some text that I had created using the document.createElement method.

This code works exactly as expected in chrome. If I look into the range object, I  correctly have the new contents. In firefox however, the range object was missing all of its delicious contenty goodness. After doing a bit of re-working, I came up with the following solution:

range.deleteContents();
range.insertNode(newContents);
 
range = document.createRange();
range.selectNode(newContents);

The additional 2 lines make it work and it still functions properly in Chrome. Now when I bring up the range object, it has the new content for me to mess around with again.

Using firefox 10.0.2