If you haven’t gotten a chance to look at ASP.NET Web API yet, please do so, it’s a very promising addition to the newly open sourced ASP.NET web stack. As always, we’d love to get some feedback and contributions, let us know what you think and how we can improve our project!

Links:

• Official WebApiContrib Site
• WebApiContrib Organization on Github
• WebApiContrib Source Code
• The JabbR room for WebApiContrib

There are several reasons why I can see they are more beneficial to have than not, I’ll list those out now:

• Diffs display better on files that end in newlines
• When I press “Ctrl + End” or “Cmd + Down” I don’t expect the file to scroll right (if the line is long enough)

So maybe bullet points weren’t necessary there because I only had two points, but it’s always been a pet-peeve of mine and I’m curious if there’s ever a good reason not to have one at the end.

Sure, the newline can go away in minified files, but I shouldn’t really care about diffs and actually editing them in an editor, so that doesn’t really count. I would consider that a deployment version, not a development version. I’m just referring to files that are shared in source control.

Working on a large eCommerce web site gives me the “privilege” of working with other companies that integrate with us via JavaScript files placed in our code. Privilege is a euphemism here, it’s usually a pain. Some are good yes, but many of these companies write crappy JavaScript. Coming from me, that’s a harsh statement, I love JavaScript but I’m not as good at it as I’d like to be.

One of these companies has a couple files on their servers that are slow loading for our users at times. Since we sell to most anybody worldwide our users can come from all over the world. These files are slow to load sometimes because our partner doesn’t have a very robust server network. We were told that they could not be downloaded from them and served through our domain because they change too often. We were skeptical so I thought it would be interesting to see how often they actually change.

I posted a question on Twitter asking for a program that could be scheduled at a configured interval to download a file via http and version it. I’d like to see how the file changes over time. It seemed to me like something was probably out there and that I shouldn’t write something myself, this is why I asked before I started coding like a mad-man. I got some good responses and cron was the most common response, but I’m running Windows because that the best OS for our company and the work we do.

The smart and talented Brian Hogan (follow him, seriously, do it!) suggested wget, which I already had on my machine at work. In my limited experience with wget, I realized I could schedule a task to run a batch file to issue the wget command. Simple enough, right? Now, when it comes to versioning… we use git for all of our source control so why not just set up a local git repo? Brian’s suggestion and my love of git made this task super simple.

The code is (generically) as follows:

(you have to run ‘git init’ and commit your first version, but from then on…)

call wget http://domain.com/directory/file.js -r

call git add -A
call git commit -am "Current version"

The moral of this story blog post is that there’s probably already a good way to do something that I just haven’t figured out yet. It’s super common, but can be tough to consider at times. This is why we pair when coding, ask for advice on code design and generally shouldn’t work in a “silo”. Just some food for thought!

If you have more questions on this hit me up on Twitter @ChrisMissal.

The View was strongly typed as IEnumerable<string> and looked something like this:

<% if(Model.Any()) { %>
<ul id="messages">
<% foreach (var message in Model) { %>
    <li><%: message %></li>
<% } %>
</ul>
<% } %>

The code behind for putting the Model into the view was also pretty simple:

<pre>
public ActionResult Messages()
{
return PartialView(messageService.GetMessages());
}

The implementation of MessageService was also very simple:

<pre>
public IEnumerable<string> GetMessages()
{
while (Queue.Count > 0)
yield return Queue.Dequeue();
}

I could set a breakpoint and see messages being queued up, but the list items weren't being rendered on the page. See the problem?

The issue isn't in the Messages() action or the GetMessages() method. In the view, when .Any() is called, it will enumerate the collection and dequeue all the messages. After that happens, there is nothing to loop through in the foreach. This was fixed easy enough with the following in MessageService:

<pre>
public IEnumerable<string> GetMessages()
{
return GetDequeuedMessages().ToArray();
}

Hopefully this helps you from pulling your hair out if you didn't catch it right away!

AppHarbor

What: If you haven’t heard about AppHarbor yet, go check it out. They offer Git and Mercurial hosting that will also run unit tests (with various frameworks). You’re able to deploy different versions of your site with a single click and they have SQL Server support.

Why: It’s free and easy. It runs your tests. It lets you deploy any version of your code. It’s getting better each day.

Continuous Integration

What: Why should I describe it when others can do so much better:

Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily – leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly. This article is a quick overview of Continuous Integration summarizing the technique and its current usage. – Martin Fowler

Why: Deliver your most current build through a web site by typing “git push AppHarbor master”. It wont build your binary unless your tests pass. This means there’s no way to push a new downloadable version of your code unless all tests pass; it’s just nice and easy.

How to do this?

The code is super simple, you can download the assembly to do this from the application that actually does it. Visit http://cheap-ci.apphb.com.

Some Questions and Thoughts

I don’t know if this is useful or not, but I wanted to try it. Let me know what I’m missing or doing wrong. Let me know if there’s something to do better. The thought popped in my head the other day, and now that I have a proof of concept, I thought I should share.

LinqPad

I won a copy of this at our local .Net Users Group, CRineta, and it has been great since I started using it! If I just want a single quick query of a DB, the “object-like” format it returns the data in is really nice. Querying large log files (by different names, on different servers) for interesting data is also a breeze.

mRemote

Throughout a standard work day, I’ll remote into a couple or more servers for various reasons or need to open up PuTTY to SSH into network hardware. This allows me to keep one app open to do all these things while keeping different sessions on tabs. It also saves my settings so I don’t have to remember them.

Swype

I recently upgraded my phone from the crumby Motorola Backflip to the awesome Motorola Atrix. Since the Atrix ships with Android 2.2, you get Swype right out of the box. It’s hard to describe how Swype works, you’ll just have to watch a video or have a friend show you. It’s so much faster than tapping and seems to start to figure out what you’re thinking before you’re even done telling it what to input. I’d list this as the best mobile device technology since touch screens; it’s great!

Evernote

I’ve had Evernote for a bit now, but i’m using it more and more lately. It’s letting me get rid of some paper clutter and cutting back on emails (or drafts) to myself to remind me of things.

In comments, the words “gold” and “silver” are underlined with that color. I don’t know if this is just an easter egg or if there’s more to it. I’m curious if anybody else has noticed this or other words. Ideally, this is some sort of golden ticket added by JetBrains and I win a prize visit to the “factory”! ;)

error: Malformed value for branch.autosetuprebasefatal: bad config file line 18 in .git/config

In the image, you’ll notice the branch reads “(ref: re…)”

I was getting this error because I incorrectly had the value of “true” for branch.autosetuprebase instead of “always”. Luckily, the error line tells me which setting has the incorrect value, but reports it as line 18 when in actuality, the line is 17. If I misspell autosetuprebase, the following error is reported:

fatal: bad config file line 17 in .git/config

It seems weird that an error on the same line would report two different line numbers depending on whether it was the key or the value that contained the issue. If you run across a config error like this, just try to remember to look at the value if it supplies you with the setting. If it’s generic enough like the second error, it’s probably the right line number. Since I’m not a pro at git, I’d be curious to know why it behaves this way if anybody can provide any insight.

I believed had an abstraction almost ready to go with NUnit’s TestCaseSource and TestCaseData classes, but there was one little piece that was bothering me. Our previous tests were subclassing our TypeConverters and overriding the ConvertCore method to make it public. This seemed goofy, but also seemed necessary after upgrading AutoMapper from 0.4 to version 1.0 a while back. Today I asked whoever was listening on Twitter for ways that they test their TypeConverters, and Matt Hinze (@mhinze) pointed me towards ResolutionContext.New(), which makes our tests much simpler, and removes the need for subclassing. From here, there’s not much to do.

Our original tests looked something like this:

[TestFixture]
public class StringToSectionConverterTests
{
	[TestCase(null, Section.Unknown)]
	[TestCase("", Section.Unknown)]
	[TestCase("category", Section.Category)]
	[TestCase("brand", Section.Brand)]
	[TestCase("machine", Section.Machine)]
	[TestCase("model", Section.Machine)]
	[TestCase("make", Section.Make)]
	[TestCase("jacky treehorn", Section.Unknown, ExpectedException = typeof(ArgumentException))]
	public void ConvertCore_returns_expected_result(string source, Section expected)
	{
		// Arrange
		var resolver = new TestStringToSectionConverter();

		// Act
		var result = resolver.ConvertCore(source);

		// Assert
		result.ShouldEqual(expected);
	}

	private class TestStringToSectionConverter : StringToSectionResolver
	{
		public new Section ConvertCore(string source)
		{
			return base.ConvertCore(source);
		}
	}
}

After some fairly easy changes and some excellence from NUnit, we now have something like this:

public abstract class TypeConverterTesterBase where T : TypeConverter
{
	public abstract IEnumerable GetTestData { get; }

	[TestCaseSource("GetTestData")]
	public TDestination Source_can_be_converted_to_expected_destination(TSource source)
	{
		var typeConverter = Activator.CreateInstance();
		return typeConverter.Convert(ResolutionContext.New(source));
	}

	public TestCaseData CaseReturning(TSource source, TDestination destination)
	{
		return new TestCaseData(source).Returns(destination);
	}

	public TestCaseData CaseThrowing(TSource source) where TException : Exception
	{
		return new TestCaseData(source).Throws(typeof(TException));
	}
}

[TestFixture]
public class StringToSectionConverterTests : TypeConverterTesterBase<StringToSectionConverter, string, Section>
{
    public override IEnumerable GetTestData
    {
        get
        {
            yield return CaseReturning(null, Section.Unknown);
            yield return CaseReturning("", Section.Unknown);
            yield return CaseReturning("Category", Section.Category);
            yield return CaseReturning("brand", Section.Brand);
            yield return CaseReturning("machine", Section.Machine);
            yield return CaseReturning("model", Section.Machine);
            yield return CaseReturning("make", Section.Make);
            yield return CaseReturning("section", Section.Section);
            yield return CaseThrowing("jacky treehorn");
        }
    }
}

For tests like this where you’re testing data transformations, NUnit has TestCaseSource and TestCaseData. These are super helpful; check them out if you haven’t used them before.

• NUnit TestCaseSource
• AutoMapper