emulator: ERROR: unknown virtual device name: 'xxx'
emulator: could not find virtual device named 'xxx'

It’s because the Android emulator works a little differently from the rest of the SDK (the rest of the SDK is Java, emulator.exe is C/++). The rest of the SDK behaves correctly in terms of user home folder (I move mine to a different hard disk) and emulator.exe has it hardcoded (depending on your OS). In Windows 7 and Vista that means it ALWAYS looks in “C:\Users\<username>\.android”. The fix for this is simple (in a command prompt under Vista/Win7):

C:
cd C:\Users\<user name>
mklink /j .android <new home directory>\.android

Worked for me. Source: XDA Developers.

• If you are migrating existing code and worrying only about contracts, switch off background checking. Firstly, this means that the results you get are comprehensive and secondly because of the build time you will think twice about hitting that build key again. Long builds == fewer builds == more time thinking == better code.
• Use code snippets. The ones provided by Microsoft are great! Think about creating your own or changing them. For example cren and cresn no longer throw ArgumentExceptions for me; they are both ArgumentNullExceptions. I also have snippets like create contract class for (cc – scaffolding for ContractClassFor) and contract class implementation (cci – ContractClass attributation).
• Invariants are your friend. Figure out what state a class should really be in and depend on that rather than Contract.Requires everywhere.
• A well placed Contract.Ensures will save you a lot of grief.
• Don’t loose hope. It may seem like it’s daunting at first – but as you start thinking in terms of contracts things become a lot faster. A single well-thought out Contract call will often clear off 5 warnings (for the bigger projects).
• Some classes can be skipped ([ContractVerification(false)]) – especially if they are internal. Don’t gung-ho and try and get everything in contracts; because sometimes they may be ill-suited for the task (and you would by ‘lying’ just to get the stuff to pass). These situations are few and far between; but they are there.
• New development = contracts. Full stop.

Overall I am finding fewer and fewer Contract failures during each build. This is mainly because CodeContracts is getting me into a better and more disciplined mindset. It’s a great tool and I highly recommend it.

It has a few notable features – it gives a reason for the flip, it wraps it in a region, it has a auto-task FLIP: prefix and it explains how it’s used.

            #region Flip - This new behaviour is experimental. -
            // FLIP: This new behaviour is experimental.
            //*/// Two proceding slashes will activate the first block, one will activate the second.
            Console.ReadLine();
            /*/
            Console.ReadLine();
            //*/
            #endregion Flip - This new behaviour is experimental. -

Drop it in your My Code Snippets folder. In VS select the code you want to flip-comment, Hold CTRL, Press K, Press S, Release CTRL, Press M, Press Enter, Press F, Press Enter (I wish you could assign hot keys to snippets!).

Code Block Flipper (WordPress won’t let me upload .snippet – so you will need to rename it)

Yes, big news. I was very surprised when I gave this a shot. It’s really just one of those things you really don’t expect to work. So how does this help us? I am sure you are quite sick of writing the following code (the same stuff applies to WPF, you just need to access it via the Dispatch member):

void _items_CollectionChanged(object sender, CollectionChangedEventArgs<ConnectionListItem> e)
{
    if (InvokeRequired)
    {
        Invoke(new EventHandler<CollectionChangedEventArgs<ConnectionListItem>>( _items_CollectionChanged ), sender, e);
        return;
    }

}

The ‘big news’ allows us to do all the heavy lifting for the dispatch BeginInvoke in one simple class (this is a first try – I’ll get round to reviewing it later on).

    /// <summary>
    /// Represent a wrapper for a delegate.
    /// </summary>
    /// <typeparam name="T">The type of event args.</typeparam>
    public class InvokeEventWrapper<T>
        where T : EventArgs
    {
        private EventHandler<T> _apparantHandler;
        private EventHandler<T> _rawHandler;
        private Control _parent;

        /// <summary>
        /// Initializes a new instance of the <see cref="InvokeDelegateWrapper<T>"/> class.
        /// </summary>
        /// <param name="parent">The parent.</param>
        /// <param name="handler">The handler.</param>
        public InvokeEventWrapper(EventHandler<T> handler)
            : this(null, handler)
        {

        }

        /// <summary>
        /// Initializes a new instance of the <see cref="InvokeDelegateWrapper<T>"/> class.
        /// </summary>
        /// <param name="parent">The parent.</param>
        /// <param name="handler">The handler.</param>
        public InvokeEventWrapper(Control parent, EventHandler<T> handler)
        {
            if (handler == null)
                throw new ArgumentNullException("handler");
            if (parent == null)
                parent = (Control)handler.Target;

            _parent = parent;
            _rawHandler = handler;
            _apparantHandler = new EventHandler<T>(Raise);
        }

        /// <summary>
        /// Performs an implicit conversion from <see cref="SharedTerminals.InvokeDelegateWrapper<T>"/> to <see cref="System.EventHandler<T>"/>.
        /// </summary>
        /// <param name="wrapper">The wrapper.</param>
        /// <returns>The result of the conversion.</returns>
        public static implicit operator EventHandler<T>(InvokeEventWrapper<T> wrapper)
        {
            return wrapper._apparantHandler;
        }

        /// <summary>
        /// Raises the event.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The e.</param>
        private void Raise(object sender, T e)
        {
            if (_parent.InvokeRequired)
                _parent.BeginInvoke(_rawHandler, sender, e);
            else
                _rawHandler(sender, e);
        }
    }

Using it is pretty simple:

1. Navigate to the event in Intellisense.
2. Type +=.
3. Press Tab.
4. Replace EventHandler with InvokeEventWrapper.

So in the end all of that ugly code becomes:

_items.CollectionChanged += new InvokeEventWrapper<CollectionChangedEventArgs<ConnectionListItem>>( _items_CollectionChanged );

You will need to hold onto a reference for that wrapper if you wish to unsubscribe from the event (one of the things I need to look at).

If you attempt to connect to SSRS via the deployment webservice; when SSRS is running in SSL mode (specifically on port 443), you may get one of the following exceptions (which do not occur intermittently):

• The underlying connection was closed: An unexpected error occurred on a send.
• The operation has timed-out.

You might get it for other “The underlying connection was closed” errors, but I have not confirmed that. The issue occurs mainly when you try to upload report definitions that are over approximately 100kb.

The Solution

Let me tell you straight up – there is no reason to disable SSL or alter timeouts. The first thing you want to do is to add a new class to your project; I called mine SslReportService. Implement ReportingService2005 from your WebService reference. You can then override GetWebRequest(Uri) without worrying about your changes being lost of you update your web reference.

Then, in a nutshell:

class SslReportService : ReportService.ReportingService2005
{
  protected override System.Net.WebRequest GetWebRequest(Uri uri)
  {
    var res = (HttpWebRequest)base.GetWebRequest(uri);
    res.SendChunked = true;
    return res;
  }
}

Your mileage may vary; so if this turns up nothing Engels Rajangam has another helpful post on this issue. You might want to read up on this property on MSDN and a pretty good blog post.

http://msdn.microsoft.com/en-us/library/%s.aspx

You can obviously also do something like:

http://msdn.microsoft.com/en-us/library/%s(loband).aspx

In case you need a refresher, here is how you add it:

1. Click the wrench (top right).
2. Options
3. Basics (top)
4. Manage (alongside “Default Search”)
5. Add
6. Give it a name and keyword (the keyword is important).
7. Paste in my URL.

To use it go to your address bar and type the keyword, tab and then the full type name. So for example (my keyword was msdnd):

msdnd : [TAB] : system.xml.serialization.xmlelementattribute : [RETURN]

/// <summary>
/// Gets the unknown elements as a <see cref="List{XElement}"/>.
/// </summary>
[XmlAnyElement]
public List<XElement> UnknownElements
{
    get;
    set;
}

Fantastic (undocumented) news.

1. Followed the pre-setup instructions to the T.
2. Run the installer; health check fails. SQL Server is the wrong version (2008 RTM); can’t find analysis services, NOTHING.
3. Hmm… must need SQL 2008 SP1. Install it via Windows Update.
4. Try again; health check fails. Wrong version of SQL Server, again.
5. Google – get a solution.
6. Follow those instructions to the T.
7. Installer CRASHES. Each time it does this I need to reboot.
8. Eventually just delete the SQL Server version check from hcpackages.xml
9. It looks like it’s installing now.

16 hours later. TFS Server 2005 took me merely 4-5 hours (did it twice). Considering it’s a test-bed server where I am going to continue working on integrating K2 with TFS Server (we are going to be using K2 to automate our builds) this was just plain ridiculous.

It’s clever, and that’s about it, to use Sharepoint. It seems as though TFS might have started off as a Sharepoint extensibility test. Things would be far easier were it not for the whole Sharepoint dependency (and analysis and reporting – I don’t need this).

These guys need to take a hint from the ASP.net team.

I like to think I am pretty familiar with website development; and I have used a wide variety of platforms (from ASP.Net to PHP to RoR). That’s what it comes down to – I know what works and what doesn’t.

Data

Ah yes, the nuts and bolts of any website (even your Wordpress blog uses it). Unfortunately you qualify as a DBA alone (and nothing else) for a reason – databases are as hard as hell to get right. If you think for one minute that you know exactly what you are doing – you are doing it wrong. How do we present this to users in an easy fashion? Something that they are familiar with? Spreadsheets! Everyone knows (or at least should know) Excel. Instead of confusing users with data relationships and so forth give it to them in the following format (more or less):

Granted, those are pretty short and are probably a poor example. It would work like an RDBMS (think Excel but more constrained) with the following exceptions:

• We don’t call them tables, we call them sheets.
• Types are more user friendly. For example: short text, long text, formatted text, date, image etc.
• Columns can have formulas; but they apply to the entire column (aggregated columns or excel formulas).
• Users can willy-nilly alter the schema as they see fit. No constraints like RDBMS (read no-RDBMS).

Now that we have given the user data we need to give them a way to shoot themselves in the foot with it.

Design

ASP.Net has one of these fantastic features: master pages. That’s a confusing term – Word terminology will save the day ‘Templates’. Essentially you design a web page but leave bits of it as ‘todos’. If you really wanted to use tables it might look a bit like the following:

The placeholder is where you would put the body content. For example, the body post out of the ‘Content’ column. These are fully nest-able; so you could define a template for your entire website – and then have child templates for the blog area, the product area, the home page and so forth.

Widgets? ASP.Net controls in a nutshell. The repeating widget would allow you to create something that repeats (the obvious one here would be posts). Everything would be driven by widgets – there would be no HTML (unless within the HTML widget) editing available.

Let me re-iterate that, NO HTML.

Next, any good website would use CSS. The idea here is to kindly steer users toward using (Word again) ‘Styles’. These define how things look (as CSS is supposed to), obviously the true noobies could just ignore them.

Wizards

My friend recently bought himself a printer that could print onto CDs or DVDs. It has one unique feature: down to earth wizards. The main wizard actually has an option called “I’m in a rush – just make me a label.” That’s the kind of stuff I am going to head for.

• What type of website do you want? [Blog] [Products] [Brochure]
• Blog
• [Just make me a blog, I will finish it up later] [Answer some questions about how it want it to work]

I’m sure you get the idea. After working at K2 for so long I am partially poisoned – wizards will be rife.

Doing Something with Data

Once you have a design and data you need to render that. The obvious choice here would be to have special folders, for instance we could allow the user to construct an address by defining a simple format, for example:

<Date>/<Title>

Any field used in that would obviously be made ‘web safe’ by the engine. These folders would then have a single webpage that would allow the user to define how to use that data. The obvious thing here would be to drag the content into the Body placeholder.

Publish It

Why is every website today ASP/PHP/RoR/etc. based? They don’t need to be, for crying out loud. The publishing wizard will compile the entire website down to static web pages (html) and blast them to the server (or to a folder); no fuss, no expensive hosting.

Widgets

Are the most important feature. They will probably take me the longest – I would obviously need a good coverage of them. The obvious thing to do would also allow third parties to author widgets.

Well that about sums it up. Oh yes, it will have all that Office 2007 look goodness.

Windows 7 Network Menu

The trick to this is to set the caption of the window to null (not empty string) and remove the system menu – at least as far as Windows Forms goes. WPF doesn’t let you do this. I had a few options:

• Implement a template to mimic the real window template. Not too sure how glass would work here.
• Use API calls to do it instead.

The second option seemed to be more sensible. As it turns out Windows Forms is doing quite a bit of heavy lifting under the covers – you don’t set the title to null; you actually need to remove the caption (Windows Forms does this for you). In the end it’s as simple as clearing two style flags for the Window.

private class NativeMethods
{
  [DllImport("user32.dll", EntryPoint = "SetWindowLong")]
  static extern IntPtr SetWindowLongPtr32(IntPtr hWnd, int nIndex, IntPtr dwNewLong);
  [DllImport("user32.dll", EntryPoint = "SetWindowLongPtr")]
  static extern IntPtr SetWindowLongPtr64(IntPtr hWnd, int nIndex, IntPtr dwNewLong);
  public static IntPtr SetWindowLong(IntPtr hWnd, int nIndex, IntPtr dwNewLong)
  {
      if (IntPtr.Size == 8)
          return SetWindowLongPtr64(hWnd, nIndex, dwNewLong);
      else
          return SetWindowLongPtr32(hWnd, nIndex, dwNewLong);
  }

  [DllImport("user32.dll", EntryPoint = "GetWindowLong")]
  private static extern IntPtr GetWindowLongPtr32(IntPtr hWnd, int nIndex);
  [DllImport("user32.dll", EntryPoint = "GetWindowLongPtr")]
  private static extern IntPtr GetWindowLongPtr64(IntPtr hWnd, int nIndex);
  public static IntPtr GetWindowLong(IntPtr hWnd, int nIndex)
  {
      if (IntPtr.Size == 8)
          return GetWindowLongPtr64(hWnd, nIndex);
      else
          return GetWindowLongPtr32(hWnd, nIndex);
  }

  const int GWL_STYLE = (-16);
  const int WS_SYSMENU = 0x00080000;
  const int WS_CAPTION = 0x00C00000;

  public static void RemoveMenu(IntPtr hwnd)
  {
      int currentStyle = GetWindowLong(hwnd, GWL_STYLE).ToInt32();
      currentStyle &= ~WS_SYSMENU;
      currentStyle &= ~WS_CAPTION;
      int ret = SetWindowLong(hwnd, GWL_STYLE, new IntPtr(currentStyle)).ToInt32();
  }

}

You simply call that from OnSourceInitialized.

protected override void OnSourceInitialized(EventArgs e)
{
  base.OnSourceInitialized(e);
  WindowInteropHelper wih = new WindowInteropHelper(this);
  NativeMethods.RemoveMenu(wih.Handle);
}

And you will get the following result:

Windows 7 Mimic'ed Menu