The candid response I received noted that the techs had been told that new features were coming “within the next couple of weeks.” However, apparently Amazon is being hush-hush as to what the new features will entail, as the tech claimed to know absolutely nothing about them. In fact, the tech was openly irritated by the fact that he was not being told what was coming, and had had no training on the new features.

I will say that I was impressed with the support I received; the fact that Amazon actually has a phone number to call is surprising, and the fact that the person I talked to was obviously US-based (no accent whatsoever) was even more impressive. On top of that, I waited less than a few minutes to receive support. That’s a big win as far as I’m concerned.

Anyway, we have reason to be excited, as Amazon is sharing internally that new features will be coming to their Amazon MP3, Amazon Cloud Player and/or Amazon Cloud Drive services “within the next couple of weeks.” How excited, though, we’ll just have to wait and see…

If you’ve heard any more information or have anything more to add please share it with us below. :)

1. Stop ironing your clothes.

   If you’re like me, buying “wrinkle-free” pants and shirts doesn’t really do any good when you let them sit in the dryer or in a basket for a week before you wear them. And going to work looking like a slob unfortunately doesn’t do much good for your career (which really sucks when you’re lazy).

   So what’s the trick?

   Hang them on the side of the shower, put the shower on full blast (and as hot as possible), close the bathroom door, and give it five minutes. The wrinkles can’t stand the steam and disappear pretty quickly. Sure beats ironing.

   Obviously, environmental buffs will cringe at the thought of this, but if you really want to be environmentally friendly then stop being lazy (or you can just do it while you take your shower, either way).

2. Never pay a bill again.

   Paying bills sucks, not only because it’s a responsible thing to do, but also because it forces you to come to the realization that all of your money is going away. This makes me cringe, so I used to tend to just not pay my bills.

   Problem is, this causes other issues, and you generally end up having more problems on your hands. Not good for laziness, or your credit.

   So what is a lazy man to do?

   Automate your bills, obviously. Most companies will let you pay your bills online, and many will let you schedule your payments so you don’t actually have to do anything to pay the bill. Typically, they’ll just send you an email when you’ve made the payment at the right time every month. This way you never have to actually do anything. Sound good?

   Unfortunately, though, there always seems to be a company on your list that’s stuck in 1984 and can’t seem to get their act together in collecting their money. Well, amuse them and get a bank account that will automatically send them an old-fashioned check in the mail at the same time every month. It’s called “automatic bill pay” and any bank worthy of this decade will do this for you in their Internet banking interface. If your bank still won’t do this, get a different bank. I recommend these guys:

   

3. Take your office with you wherever you go.

   A huge part of being able to be productive and lazy is not having to physically move to get your work done. You’re not likely to get stuff done if you’re not at home and you have no way of remotely getting anything done. I often find myself with free time in the oddest situations, and if I have everything I need with me, I can make something of it. Otherwise, I’m stuck being bored.

   But I can’t take my whole office with me…

   Yes, you can. If it’s all digital, anyway. If you’re still dealing with a briefcase and papers, then you’re really wasting your time. I use a combination of Dropbox (for sharing my entire file collection between computers), PortableApps.com (for sharing applications between computers), Google Docs (for easy online access to all my documents), and Gmail (for email).

   
   

   The best part is that I can access all of my data through all of the aforementioned services (sans PortableApps.com applications) on my Android phone. This means full access everywhere I go, and I can take advantage of waiting times throughout the day to get stuff done that I don’t want to have to do while relaxing in the evening.

4. Stop having to remember/fill in passwords online.

   These days, you probably have logins online for dozens of different websites, and they’re probably all set to the same password (sic) or just a few different passwords (not much better). The security issues of this are a real problem, but lazy is as lazy does.

   Still, though, how do you remember which of those few passwords you’re using for each site? You’ll probably end up trying all three, and if you’re lucky you’ll get in before the site locks you out for your negligence.

   So fix it. Now.

   Use a password manager like LastPass to automatically log you in to all of your websites. LastPass is my favorite because it works with all major web browsers, it’s free, and it’s really easy and convenient to use.

   

   Not only does LastPass allow you to be lazy, but it also secures your online presence. It generates secure passwords for you (if you let it), so your passwords can all be different and even be crazy complicated (because you never have to type them out). Did I mention it will automatically sync between all your computers and browsers? This is one rare product that lets you be lazy and more secure at the same time. Use it.

5. Never listen to another voicemail ever again.

   Voicemails suck because it takes forever to listen to them, especially when they’re from people who don’t know how to be concise. Not to mention horrible voicemail systems that take three years to navigate.

   If you’re like me, your impatience for voicemails and voicemail systems leads to an overflowing voicemail box of three-year-old messages. And they don’t do a whole lot of good three years later. Especially when your voicemail provider automatically deletes them after a month or two.

   But is there really a way around it?

   Yes, there is. It’s called Google Voice and it will automatically translate voicemail messages into emails and/or text messages. This is hyper-productive because all it takes is a quick glance at the email or text message and you’ll get the point, unlike having to dial in, use the prompts, and then listen to the message.

   

   Unfortunately Google Voice is still invitation-only (meaning you have to get an invitation from Google in order to use it), but that will change very soon. There are invitations floating around on various forums (I got mine by simply asking someone for one). To start, though, request an invitation here (directly from Google) and then do some web searches to see if you can find one more quickly. Not having to listen to voicemail messages is far worth the trouble of getting an invite, so don’t let that stop you.

If any of these tips were new to you, let us know how they’ve made you more productive (and/or lazy). Share your own tips, too; we’re all looking for ways to work less, get more done, and have more fun.

jQuery(function() {

  // Initialize the Scrollable control
  jQuery(".scrollable").scrollable();

  // Get the Scrollable control
  var scrollable = jQuery(".scrollable").data("scrollable");

  // Set to the number of visible items
  var size = 3;

  // Handle the Scrollable control's onSeek event
  scrollable.onSeek(function(event, index) {

    // Check to see if we're at the end
    if (this.getIndex() >= this.getSize() - size) {

      // Disable the Next link
      jQuery("a.next").addClass("disabled");

    }

  });

  // Handle the Scrollable control's onBeforeSeek event
  scrollable.onBeforeSeek(function(event, index) {

    // Check to see if we're at the end
    if (this.getIndex() >= this.getSize() - size) {

      // Check to see if we're trying to move forward
      if (index > this.getIndex()) {

        // Cancel navigation
        return false;

      }

    }

  });

});

The code simply hooks into the Scrollable control’s onBeforeSeek event, and stops the control from moving forward if at the end. This will prevent the user from scrolling past the end not only for clicking the forward and backward links, but also for arrow key and mouse wheel input (if mouse wheel support is turned on via the initialization settings for the control). The previous solutions I found from neogisme and soon7 would scroll past and then scroll back and/or disable the forward and backward links, but they didn’t properly prevent the user from scrolling past the end for all forms of input.

Here’s an example of it in action:

Previous

Next

If you end up using this (or have something useful to add to it), please drop me a line below. :)

Update (March 28th, 2011):

Steve Rucker was kind enough to send this to me as a way to make the solution data-driven and more dynamic. If you want simplicity, use the above code, but if you’re looking for it to be more dynamic, dive into Steve’s code below:

Your blog – jQuery Tools Scrollable – Stop Scrolling Past the End – was a huge help! Your code saved me a lot of time – the client wanted to always show 4 items in the scroller, and this worked perfectly.

However, I’m working on a large site that’s pulling dynamic info from a database, so I needed to modify the script to allow for an undetermined number of scrollers.

Here’s what I came up with:

$('.scrollableProducts').each(function (i) {  // loop through scrollers
    var thisCarousel = $('.scrollableProducts:eq(' + i + ')');  // var this scroller
    var size = 4;
    var bucketCount = $(thisCarousel).find('.productLineBucket').length; // get number of buckets in this scroller
    var thisNext = $(thisCarousel).parent().find('a.next'); // var this next controller
    if (bucketCount < size + 1) { // hide next controller if less than size
        thisNext.addClass('disabled');
    }
    $(thisCarousel).scrollable();
    var scrollable = $(thisCarousel).data("scrollable");
    scrollable.onSeek(function () {
        if (this.getIndex() >= this.getSize() - size) {
            thisNext.addClass('disabled');
        }
    });
    scrollable.onBeforeSeek(function (event, index) {
        if (this.getIndex() >= this.getSize() - size) {
            if (index > this.getIndex()) {
                return false;
            }
        }
    });
});

Thanks again, Steve!

Everyone is in need of a good backup, and Dropbox fits the bill very well for most users. In addition, it provides excellent syncing functionality to keep your data up to date between all of the computers that you use. It’s free for the first 2 GB, and above that you can pay for either 50 or 100 GB of space. We’ll be addressing Dropbox Pro accounts (50 or 100 GB accounts) in this article.

In my experience, Dropbox is the most easy to use, mature, and trustworthy service available for online backup and syncing. It does have one caveat, however: the most space you can use is 100 GB (at least for the moment). You can’t even pay for more in a single account. Granted, 100 GB is a lot of space (especially to back up online), but if you’re like me, you have more than 100 GB of precious home movies of your little ones.

So what do you do? Find out after the break…

Here’s what I’ve figured out. It’s a hack but it’s well worth it; it’s working great for me. Dropbox allows you to pay a small monthly fee ($3.99 at the time this article was written) in addition to your standard fee, to enable an extra service they call “Packrat”. Packrat allows you to keep all of your deleted files, as well as all of the previous revisions of all of your files, for all time. This means that when you delete a file from your Dropbox folder it will still remain on the Dropbox servers, and you can go back and restore the file later, if necessary. Dropbox intends this feature to be used for backup purposes (in case files are accidentally deleted, etc.).

This incredible feature is easy to use for more than just-in-case scenarios, however. Due to Dropbox’s unlimited history for deleted files (when using Packrat), you can upload a batch of files, delete them, upload a new batch of files, delete them, and repeat this process until you’ve uploaded every file in your collection. This isn’t great for syncing because it won’t let you sync more than 100 GB at a time between computers, but it is great for backing up that 200 GB home video collection.

Say you have 200 GB of home videos in a folder on your hard disk. This is how you would proceed:

1. Create a folder in your Dropbox folder for the videos that you would like to upload (we’ll call it “Videos”).
2. Move some of the videos in your collection into your new Dropbox Videos folder. Make sure you don’t move too much to fit in your Dropbox account.
3. Wait for these new files to upload to Dropbox (which obviously may take a very long time).
4. Once the files are uploaded, move the video files back to the previous folder they were in, outside of the Dropbox folder. Dropbox will interpret these files as being deleted, but you’ll still be able to retrieve them via deleted files in your Dropbox account.
5. Move a new batch of video files into your Dropbox Videos folder, wait for the files to upload, and repeat the process until all of your files have been uploaded.

Once you have all of your files uploaded (or at any point in the middle of the process), you can go to Dropbox’s website and see your deleted files. Just click the “Show Deleted Files” option on the toolbar (or under More Actions), and you can restore or download your deleted files. The point is that all your files, whether they total more than 100 GB or not, are still backed up on Dropbox’s servers. In the event that your hard drive crashes, it may be a slight nuisance, but you’ll still be able to fairly easily get your files back from Dropbox’s servers. This way, Dropbox can be used as an unlimited backup service. The only catch is that you can only retrieve (and keep syncing) 100 GB at a time, so if your account is already full you’ll have to temporarily delete some other files to retrieve the files you’re going for.

There are services available that provide unlimited backup space for less money (and that don’t require a “hack” to use), but none of them provide the amazing robustness and syncing functionality that Dropbox has. Rather than subscribe to two different services (and have two different bills), I’ve chosen to take this route, and it’s working well for me.

If this article clued you in to this functionality, drop a comment and let me know how it works for you. :)

Update: I’ve been told that using Dropbox’s Packrat features in this manner is against Dropbox’s terms of service. I’ve yet to hear it officially from Dropbox, but use this strategy at your own risk. I’m working on getting Dropbox’s official commentary on the matter; as of yet they have not responded.

Update #2:Per Phillip’s comment below, Dropbox has confirmed that using Packrat in this manner is against their terms of use. Unfortunately for them, however, it is impossible to determine when a user has “correct” or “incorrect” intentions when using the service. For Dropbox’s sake (and for the sake of keeping your account), I would advise against using this method for massive amounts of data. In a pinch, however, I see nothing wrong or dangerous in using Packrat this way, as long as it is done moderately. If Dropbox wants to stop users from using the Packrat service in this manner, they need to better-define what is or is not acceptable usage in measurable ways (instead of in ways they cannot truly confirm).

• Administrator permissions are no longer required to run the application from the Program Files folder; application settings and logs are now stored in the Windows program data folders.
• The application has been tested with and should now work fine with UAC under Windows Vista and Windows 7.
• Summary logs have been added to the end of the logging to report count totals for the various operations.
• Fixed a bug in the new syncing empty folders functionality that caused a neverending loop when the root of either folder was empty.
• Added a “File Filter” property to mapped folders to allow the use of wildcards (*.txt) to restrict which files to sync (as requested by Jason Saul).

Simply run the setup to upgrade to the latest version.

Download UpSync 0.7 Setup
Download UpSync 0.7 Source Code (Visual Studio 2008 required)

Remember to share your thoughts and suggestions!

• Significantly improved error handling
• Delete prompts are now all displayed at once (instead of throughout the process)
• A new “stop prompting and do this for x remaining files” feature has been added
• Code is now StyleCop-compliant (as well as code analysis-compliant)
• Empty folders are now synced properly based on their creation date

You may simply run the new setup and it will automatically upgrade over whatever old version you have installed.

Download UpSync 0.6 Setup
Download UpSync 0.6 Source Code (Visual Studio 2008 required)

Please remember to comment and share your thoughts on the application! :)

1. Careless Ripping

In case you’re not familiar with the lingo, to “rip” an audio CD means to extract the music from the CD and save it to your hard drive in the form of WAV files. These WAV files are simply uncompressed audio data, and they’ll play back in pretty much any audio or music player application. Before an application can make a compressed MP3 out of your music, it must first rip the raw audio data from the CD onto your computer. Most music applications, such as iTunes, will perform all of this behind the scenes for you. This is nice and convenient, but unfortunately doesn’t always yield the best results.

You may have previously noticed that when you’ve used iTunes or another application to try and import a CD that’s been scratched a bit, the end result is not too pleasing. You may end up with “clicks” or “ticks” in your music that are obviously not in the original recording, even when those discs play fine in a CD player. These artifacts are a result of careless ripping, and you may be pleased to know that you can probably still pull the music off those scratched discs without having to hear those annoying ticks all of the time.

The truth is, though, ticks sometimes even show up when ripping a brand new, scratch-free disc. They obviously show up more often on scratched discs, but unfortunately you can’t assume your music will always be ripped safely if your disc isn’t visibly scratched. This is because most ripping mechanisms in common music applications such as iTunes focus primarily on speed, and not accuracy. It’s convenient for the ripping process to be quick, but doesn’t do much good if the end result is poor.

There is one ripping application available, however, which does absolutely everything it can to make sure that the music that is being read is accurate. The application is called Exact Audio Copy, or EAC. Unfortunately, it’s only for Windows, but very fortunately, it is free. It will help to ensure your music is accurate in several ways, including using your CD or DVD drive’s on-board error control mechanisms and even checking your music against an online database to ensure it is correct (a feature called AccurateRip). EAC will need to customize itself for your machine and may take a bit of learning, but all the resources you need are directly on the website I’ve linked. Once you’ve used EAC, you’ll never go back to your old application for ripping, as it gives you 100% peace of mind that your music is without flaws, and even lets you resurrect old scratched-up CDs.

2. Lossless/Lossy Format Confusions

You may have never even heard of “lossy” audio compression before, but chances are your entire music collection is using lossy compression. This isn’t necessarily a bad thing, but you need to be aware of the repercussions of using lossy compression and the alternative of using lossless audio compression.

When you rip your music directly to WAV from an audio CD, you’ll notice that the resulting WAV files are rather large, sometimes up to 50 megabytes or larger per track. It’s inconvenient to store and transfer such large files over the Internet, so people look to compression techniques to reduce the size of the files so that they are more convenient to use. There are two different types of this compression: lossless and lossy. Lossless compression works much like a ZIP file does; it takes the data and does its best to compress it as small as possible, without losing any data. When you extract a zip file, or play a lossless music file, you get the same exact data that was compressed in the first place. It is an exact replica of the audio that was on the CD.

Lossy audio compression, however, knows about how our human ears work, and attempts to remove the portions of the audio data that are the least important to our ears perceiving it as still sounding good. These algorithms are incredibly complicated and have been studied for years; modern lossy compression codecs are so good that most people can’t tell the difference between a song that’s been encoded using lossless or lossy compression. Therefore, in many circumstances, lossy compression is ideal.

You’re no-doubt already familiar with many lossy audio codecs: MP3, AAC (M4A, MP4), and WMA are all lossy audio codecs. You may have never heard of any lossless audio codecs, though; the most popular and recommended of which is FLAC.

So what are the advantages of using a lossless codec? Though you may not be able to hear the difference between lossless and lossy, lossless music files are much more flexible for the future. Often people don’t realize that every time you re-encode a file from one lossy codec to another, you lose quality. For example, if you take an MP3 and re-encode it to an M4A file to match the rest of your collection, you’ll end up with a lower quality file than you had in your original MP3. This is because of the lossy audio techniques used in the compression, which are meant to only be used once. If you keep converting your files to different codecs, you may start to hear the loss of quality relatively quickly. Re-compressing a lossy music file is a no-no; never re-compress a lossy music file to another lossy codec to match the rest of your collection. Lossless music files do not suffer from this problem, however, and can be re-compressed to any format in the future without any loss of quality, which is the biggest advantage to using a lossless codec.

For most people, though, as long as you’re aware of what not to try and do with a lossy music file, lossy is the way to go. This is because you generally don’t need to re-compress your music these days, and you most often can’t hear a difference between modern lossy and lossless audio formats. Lossless is nice to have, but doesn’t compress near as well as lossy does, so lossless music files are often ridiculously large and difficult to manage (not to mention player support is still fairly limited).

If you want to try and hear the difference between lossless and lossy audio formats, download the foobar2000 music player and the ABX Comparator plugin. This will guide you through a series of “double-blind” listening tests to see if you really can tell the difference. Trust me, though, you probably can’t. Foobar2000 is also very useful and convenient for compressing and tagging music files after ripping them.

3. Non-Gapless Audio
Chances are you’ll have some CDs or albums in your collection where two or more tracks are strung together without any silence between them, sometimes with the same instruments playing across the tracks. If the codec, encoder, and/or player you’re using are not gapless, you’ll hear a glitch, or pause in the music between these tracks. This gets very annoying and breaks the listening experience between tracks.

It wasn’t until recently that lossy audio codecs supported gapless audio, so it used to be that this was another good reason to use a lossless audio codec. These days, however, gapless is supported by several lossy formats, so gapless audio is no longer a reason to use a lossless codec.

In order to get gapless playback of your lossy music files, though, you need three things: you need a codec that supports gapless audio, an encoder that creates gapless audio files, and a player that will play these gapless files correctly. This isn’t as difficult as it sounds, though you may find that some of your older music files are not gapless and will need re-ripped using more modern tools.

The easiest way to create gapless files these days is to use iTunes to encode to VBR AAC 256. These are the default encoding options for the latest versions of iTunes, but make sure you get the latest version as previous versions of iTunes did not encode gaplessly. There are many other options, but this format is in my opinion the most ideal because of the quality, compatibility, and features (such as gapless playback) available. Remember, though, to use EAC to rip the files first before using iTunes to encode the files. These gapless files can then be played gaplessly in iTunes, foobar2000, or Winamp, among other players. Many players, however, such as Microsoft’s Windows Media Player, still do not play these gapless files correctly, and will still result in hearing annoying gaps between tracks. This is a good reason to avoid these players.

4. Improper Compilation Tagging

You may have noticed previously that sometimes music players don’t handle compilation albums well, or albums that have a different artist for each track. Ideally, you want to be able to find your music both by the main artist or topic (such as in a soundtrack) of the album, and by the artist of each individual track. Modern tags and music players solve this issue with the “Album Artist” tag.

For example, if you have a soundtrack album, you would put each separate track’s artist name in the “Artist” tag for the song. Then, the standard is to put “Various Artists” in the “Album Artist” tag. This way, the album will show up in your collection as “Various Artists – Name Of Soundtrack Album”, but will still be searchable by the various artists on the album. Otherwise, without populating the “Album Artist” field, most players will interpret the album as many separate albums, one for each different artist on the CD. iTunes does work slightly different, though the concept is the same. They’ve simply added a “Collection” check box to the tag, which specifies that the album is a collection (though you can still use the “Album Artist” tag just the same).

Occasionally, you may find an album that has a true album artist, but has subsequent artists for each track. In this case, the solution is obvious; put the album artist’s name in the “Album Artist” field, and each track’s separate artist name in the “Artist” field. This works much the same as in the previous, soundtrack scenario.

5. DRM

Unless you’ve been living under a rock these past few years, you’ve probably heard something about DRM related to music. DRM stands for Digital Rights Management and it’s a way for the rotten record companies to restrict where and when we can listen to the music we’ve purchased. Until recently, everything purchased from the iTunes store was covered in nasty DRM. Thankfully, DRM has been removed for all future purchases, but you’ve probably got some still in your collection if you’ve purchased music from iTunes in the past few years.

Don’t let DRM bite you when you least expect it. Do your best to only purchase DRM-free music, and consider your DRM-laden music files not future-proof unless you can somehow strip them of the DRM (yes, in some cases, you can, but it’s not easy).

It’s also worth noting that though music purchased from the iTunes store no longer has DRM, it can still be tracked back to you as the person who bought the song, and get you into legal trouble if you share it. In my opinion, this is reason enough in itself to boycott the iTunes store (though I have to admit I haven’t been as faithful to this as I’d like to be).

Whew!

By now, if you’ve made it this far, you’re practically a digital music collection master. Or something like that. To reiterate, here are the five main points to remember:

• Do your best to rip audio CDs accurately using EAC.
• Don’t abuse lossy audio formats; never re-encode from one lossy format to another.
• When possible (and necessary), be sure to use a gapless codec, encoder, and player.
• Tag your compilation albums properly using the “Album Artist” tag.
• Avoid DRM whenever possible.

These tips should help you to obtain a much more consistent and higher quality music library. If you’ve gotten this far, surely it’s worth leaving a comment or two! Let me know if you disagree with anything in the article or have anything to add. Comments will always receive a reply. :)

To get started, create a class in your project called MessageBoxHelper (or name it whatever you wish). Replace the code in the file with the following code:

using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;

internal static class MessageBoxHelper
{
    internal static void PrepToCenterMessageBoxOnForm(Form form)
    {
        MessageBoxCenterHelper helper = new MessageBoxCenterHelper();
        helper.Prep(form);
    }

    private class MessageBoxCenterHelper
    {
        private int messageHook;
        private IntPtr parentFormHandle;

        public void Prep(Form form)
        {
            NativeMethods.CenterMessageCallBackDelegate callBackDelegate = new NativeMethods.CenterMessageCallBackDelegate(CenterMessageCallBack);
            GCHandle.Alloc(callBackDelegate);

            parentFormHandle = form.Handle;
            messageHook = NativeMethods.SetWindowsHookEx(5, callBackDelegate, new IntPtr(NativeMethods.GetWindowLong(parentFormHandle, -6)), NativeMethods.GetCurrentThreadId()).ToInt32();
        }

        private int CenterMessageCallBack(int message, int wParam, int lParam)
        {
            NativeMethods.RECT formRect;
            NativeMethods.RECT messageBoxRect;
            int xPos;
            int yPos;

            if (message == 5)
            {
                NativeMethods.GetWindowRect(parentFormHandle, out formRect);
                NativeMethods.GetWindowRect(new IntPtr(wParam), out messageBoxRect);

                xPos = (int)((formRect.Left + (formRect.Right - formRect.Left) / 2) - ((messageBoxRect.Right - messageBoxRect.Left) / 2));
                yPos = (int)((formRect.Top + (formRect.Bottom - formRect.Top) / 2) - ((messageBoxRect.Bottom - messageBoxRect.Top) / 2));

                NativeMethods.SetWindowPos(wParam, 0, xPos, yPos, 0, 0, 0x1 | 0x4 | 0x10);
                NativeMethods.UnhookWindowsHookEx(messageHook);
            }

            return 0;
        }
    }

    private static class NativeMethods
    {
        internal struct RECT
        {
            public int Left;
            public int Top;
            public int Right;
            public int Bottom;
        }

        internal delegate int CenterMessageCallBackDelegate(int message, int wParam, int lParam);

        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        internal static extern bool UnhookWindowsHookEx(int hhk);

        [DllImport("user32.dll", SetLastError = true)]
        internal static extern int GetWindowLong(IntPtr hWnd, int nIndex);

        [DllImport("kernel32.dll")]
        internal static extern int GetCurrentThreadId();

        [DllImport("user32.dll", SetLastError = true)]
        internal static extern IntPtr SetWindowsHookEx(int hook, CenterMessageCallBackDelegate callback, IntPtr hMod, int dwThreadId);

        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        internal static extern bool SetWindowPos(int hWnd, int hWndInsertAfter, int X, int Y, int cx, int cy, int uFlags);

        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        internal static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
    }
}

I won’t go into too much detail describing the above code, because most of it is just Win32 API greek. The gist of it though is there’s a parent static class called MessageBoxHelper that contains two subclasses. The NativeMethods subclass is another static class that simply provides the interfaces into the Win32 API calls. The MessageBoxCenterHelper subclass is instantiated by the parent class, and performs the actual calls to center the message box. I’m not overly familiar with the way callbacks, delegates, and events work when using the Win32 API, so I won’t attempt to explain the logic behind these methods.

Usage

The above implementation may be fairly involved, but using it is extremely easy. Simply call the MessageBoxHelper.PrepToCenterMessageBoxOnForm static method before calling your message box:

using System;
using System.Windows.Forms;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Click(object sender, EventArgs e)
    {
        MessageBoxHelper.PrepToCenterMessageBoxOnForm(this);
        MessageBox.Show("Hello!", "Hello!", MessageBoxButtons.OK, MessageBoxIcon.None, MessageBoxDefaultButton.Button1, 0);
    }
}

It’s worth noting that this code does pass all Code Analysis rules, so you can be confident you won’t have to rewrite any of it to make it pass. I do have one small warning, however; make sure that you always call the PrepToCenterMessageBoxOnForm method immediately before your MessageBox.Show call. Calls to the PrepToCenterMessageBoxOnForm method that are not met with a MessageBox.Show call can interfere with whatever the next form that pops up happens to be, and can result in odd behavior. Still, you’re not likely to want to put the code anywhere else, anyway, and I’ve used it in many enterprise projects without running into any issues.

Let me know if you appreciate this or have any questions or suggestions in the comments!

Update: Many thanks to Matt Stan for pointing out in the comments that the class also works well for centering a folder browser dialog window (by simply calling the PrepToCenterMessageBoxOnForm method before calling the ShowDialog method). It may work for some other dialogs as well, and not just these two. Apparently, however, it does not work for a file open dialog. I’ll be doing a bit of research to see if I can modify the code to support all .NET standard dialogs. I may or may not be successful.

For now, you can assume that it is safe to use on other dialogs, if it works properly. It is probably guaranteed beyond a reasonable doubt to work regularly within the same .NET framework version for these other dialogs as well. Regardless, most likely it will work indefinitely for all future .NET framework versions (unless something is significantly restructured in .NET). The code simply attempts to get a handle to the upcoming window and center it via an event, so it should work generically for most types of windows, and should be plenty safe.

Thanks, Matt!

Update #2: I’ve done some research on the .NET dialogs, relating to the centering mechanism. As well as message boxes, the ColorDialog, FontDialog, and FolderBrowserDialog dialogs do center properly as well. However, the OpenFileDialog and the SaveFileDialog dialogs unfortunately do not. This is because somewhere in the order of events after the new position is given these dialogs automatically center themselves on the screen. This functionality is somehow different from the other dialogs. You can observe this happening if you add “0×40″ (SWP_SHOWWINDOW) to the SetWindowPos method’s flags. If you do this, you can see the dialog come up in the correct spot, centered on the form, and then quickly jump to the center of the screen. Unfortunately, I can’t seem to get around this. The only solutions I’ve seen involve extending the OpenFileDialog and SaveFileDialog controls, which is a completely different direction than this article is taking.

WordPress for BlackBerry is currently at version 0.9.0.134 in beta, but it sure does seem to be working well enough for me. Of course, it only has a subset of the full WordPress admin features, but it has pretty much everything you need for what you’d want to do on the road (full page, post, and comment viewing, adding, editing, and deleting).

It seems there’s no end to what I can do on my BlackBerry these days. It sure beats my days with Windows Mobile…

The single biggest clue that a developer either has no idea what they are doing or simply doesn’t care about their code is inconsistency.  We all have different preferences and coding styles, but when a developer can’t pick a particular approach to take they come off as incredibly amateur, and for good reason.  Inconsistent code is difficult to read, and is thus difficult to modify in the future.

The majority (or even the entirety) of the list below revolves around writing consistently styled and consistently performing C# code.  Much of this list is admittedly anal retentive, but all of it is guaranteed to improve the quality and readability of your code.

1.  Use the Code Analysis features in Visual Studio.

The Code Analysis features are anal retentive by nature, as you quickly discover when you begin to use them for the first time.  They are, however, worth their weight in gold; they are the most immediately effective way to improve your C# code.

Each time you build your code, Code Analysis will examine it to be sure that a large and growing list of “best practices” are met, and will create warnings in your Error List if they are not.  You cannot call your code “good” code unless it passes Visual Studio’s code analysis with flying colors.  There are exceptions to this rule, but they are few and far between.

Enabling Code Analysis in your C# Visual Studio 2005 or 2008 project depends on whether you’re working with a Windows or Web application.

For a Windows application, go to your Solution Explorer and double-click the project’s Properties node.  From here, select the Code Analysis tab on the left hand side.  Check the Enable Code Analysis on Build check box, and you’re on your way.  You’ll notice that you can enable and disable any of the various checks individually, but I recommend leaving them all checked unless you’ve found a warning that you’re sure you can ignore.  As I’ve stated previously, the Code Analysis is almost always right.

For a Web application, go to your Solution Explorer and select the root node for your website.  Then go up to the Analyze menu and select Code Analysis Configuration.  From here, check the Enable Code Analysis on Build check box and you’re on your way.

2.  Use regions consistently and effectively.

Nobody likes digging through a huge code file to find a particular method, and C#’s regions help to solve this problem.  Here is an example:

#region Private Variables

private int x;
private int y;

#endregion

#region Public Properties

public int X
{
    get
    {
        return x;
    }
}

public int Y
{
    get
    {
        return y;
    }
}

#endregion

In Visual Studio, regions can be collapsed or expanded using the +/- buttons to the left of the region names in the code window. This helps to make it much easier to find a particular method you are looking for. There are many ways to organize your code with region statements, but I prefer to separate the code by type of construct (variables, constructors, event handlers, methods, properties, etc.) and access modifier (public, internal, protected, or private).

3.  Handle white space consistently.

C# ignores white space, which means you can put extra spaces and lines pretty much wherever you like.  Or, if you’re insane, you can jam ten-thousand lines of code into a very angry single line of actual text, separated only by semicolons.

Here are a few things to consider, though:

• Code with more white space is generally much easier to read.  Less condensed code is easier on the eyes and with screen real estate being as ample as it is these days, there’s little reason to try and jam your code into as few lines as possible.  For the most part, bigger is better.
• Even though code blocks, such as if and while statements, do allow you to omit the curly braces, this generally makes your code harder to read.  The general consensus is to always use curly braces even when there is only one line of code you are executing between them.
• Consistency, consistency, consistency.  If you put new lines after you close blocks of code, be sure you do it everywhere.  Don’t “feel it out.”  Come up with your own strategy (preferably similar or the same to most other peoples’ strategies) and stick to it.

4.  Always specify your access modifiers and choose them carefully.

C# access modifiers are simply the public, internal, protected, and private keywords that you typically place in front of variables, properties, and methods.  Though these are often overlooked, they provide meaning to the functionality behind your code and help to better define the structure of your code through encapsulation.

Here are some grossly oversimplified definitions and uses for the four modifiers.  These definitions are lacking some detail, but should be plenty of information to handle the vast majority of circumstances:

Private members are only accessible to the class in which they live.  All variables, properties, methods, etc. that do not need to be accessed outside the immediate class should be marked as private.

Protected members are accessible to the class in which they live, as well as any classes that derive from (extend) the class.  The protected modifier should be used on variables, properties, methods, etc. that may need to be accessed by classes that may derive from (extend) the current class.

Internal members are accessible everywhere within the current project, but are inaccessible by other projects that might reference the current project.  In other words, using the internal modifier specifies that only classes within the current EXE or DLL file can access the member.  The internal modifier should be used on all variables, properties, methods, etc. that need to be available to other classes within the project, but should not be available outside the project.

Public members are accessible everywhere, period.  There are no restrictions to their access.  This particular modifier is often overused, as the internal modifier is overlooked.  The public modifier should only be used for members or classes that are or would possibly be needed outside of the current project.

As far as defining classes, typically only internal or public are used, depending on if they need to be accessible outside the project.  This, however, does not account for nested classes, which can have any of the four access modifiers.  Always specify your access modifiers to avoid confusion as to when and where the class or member can be used.

5.  Learn the ways to properly use exceptions and stick to them.

C# exceptions are extremely powerful and convenient, but when used incorrectly, they can both slow your application down and hinder output to the end user.

There are two basic rules of thumb to using exceptions properly:

• Never catch an exception when you can check for and prevent the error instead.  A typical scenario is trying to open a file that you’re not entirely sure really exists.  You can wrap the file open code in a try catch, or you can use File.Exists to determine if the file exists before attempting to open it.  Exceptions in C# are expensive, so you only want an exception to be raised if a true error occurs.  If you can predict that it might happen for a particular reason, you should be able to check to make sure that it won’t happen before proceeding.  This will help to improve performance significantly.
• Also, never catch the root Exception class, or any high-level, broad exception.  If you catch an Exception class, and you incorrectly assume that the user didn’t fill in a particular field as a result, the user will see your incorrect error message and be unable to see the actual error that occurred.  This is unacceptable.  Instead, research the methods you are calling to determine the particular types of exceptions they raise, and catch these specific exceptions.  This way, if something occurs that you didn’t expect, the end user will see the detailed error message anyway.  The MSDN documentation does a great job of providing you with all of the details you need regarding every exception that is possible for every single method in the .NET framework.

6.  ALWAYS use using statements.

In case you’re not familiar with the syntax of using statements, here is an example:

using (StreamWriter writer = new StreamWriter("C:\\file.txt"))
{
    writer.WriteLine("Hello!");
}

Using statements can be used wherever you’re instantiating an object that is IDisposable (can be disposed using the Dispose method).  If you don’t actively dispose objects that support the IDisposable interface, you’re asking for all sorts of performance and memory leak trouble.  Here are the advantages of using statements over calling the Dispose method directly:

• Even if an exception is raised within your using statement block, the runtime will still ensure that the object gets properly disposed.  This is automatic with the using statement and is impossible without it.  Before using statements were added in .NET 2.0, you had to attempt to dispose of your objects within a catch block, which was far from error-prone.  Never take this approach.
• Using statements help to visually define the scope of a variable that requires disposing.  You can quickly and easily see the start and end of the lifetime of the variable.  Once you are in the habit of consistently using using statements to dispose of objects you will very rarely (if ever) forget to dispose of an object, because of the block nature of the statement.
• Using statements even allow you to return from a method within the statement.  The object is still disposed of properly in this situation.  In other words, if you use a using statement, the object is GUARANTEED to be disposed of despite any and all circumstances.  That’s a pretty big and valuable promise.

There is much more to writing good C# code than these 6 rules, but these are the rules that I see consistently broken that are driving me to an early grave.  Let me know in the comments if you think I’m missing something important or disagree with any of my statements.