How-To

MSXML 6 failure on SQL Server 2005 Tools install

Stacy Vicknair — Wed, 09 Sep 2009 19:37:39 GMT

Today I ran into this problem when setting up the SQL Server Management Tools for SQL Server 2005. Like any good little code slinger, I googled (if you are particular to Microsoft, you can read that as “binged”) to see who’s had the problem, because it’s no news that when you aren’t on the crest of the tech wave that someone else has had the same issue.

In particular, MSXML 6 would fail and the log would have a message similar to:

MSI (s) (40:58) [22:16:00:859]: MainEngineThread is returning 1605

Well, undoubtedly I found many other results for others who have had this issue, primarily those that have XP SP3. To get around this failure, you’ve got to install the tool available at the link below and then use it to remove any entry starting with MSXML 6. For me, I had two entries, one “parser” and one SP2. Afterwards, just start the install over again.

I think what made the experience frustrating for me is that the SQL Server 2005 Setup fails in too friendly of a way. I’m used to the brutal honesty of the NUnit GUI. Give me a big red bar to illustrate how bad I failed or get out.

For the uninstall tool:
http://support.microsoft.com/kb/290301

A couple resources about the problem itself:
http://social.msdn.microsoft.com/Forums/en-US/sqlsetupandupgrade/thread/493b5a95-1af6-4ec1-aa24-92875e4497c0
http://www.eggheadcafe.com/conversation.aspx?messageid=33740907&threadid=33664744

Technorati Tags: MSXML6,MSXML,SQLServer2005,SQL Server 2005

How To: Create a plugin architecture in VB.NET

Stacy Vicknair — Wed, 06 May 2009 18:19:35 GMT

Creating a plugin architecture in .NET can be achieved in a few steps using the .NET framework. All it takes is a little time, a common interface and reflection. In this blog we’re going to look at how to make a simple plugin that performs basic integer calculations. As a disclaimer, this method is not CLS compliant. If that is necessary for you, then stick around and I hope to have a new version that maintains compliance posted.

The code in this blog is mostly illustrative, and the full code is available on CodePlex at the following link:

http://wtfnext.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=27051

Setting up a common interface

Our main console application has to know just basic things about our plugin. It doesn’t need to know any more about it than that it complies to an expected interface. For this example, our plugins must:

Expose a class named Plugin
The class must implement our common interface: IPlugin.
The plugin must end in “Plugin.dll” and be present in the application directory.

If we get all of these done, we can connect to the plugin successfully. The first step is to define the IPlugin interface, which acts as the basic contract between any plugin and the console application. We’ll place this in its own project to compile into a separate DLL, so that we can easily reference it from our plugin projects.

Public Interface IPlugin
    ReadOnly Property Name() As String
    ReadOnly Property ActionName() As String
    Sub Calculate(ByVal value1 As Integer, ByVal value2 As Integer)
End Interface

Consuming the interface according to our rules

So our calculation plugins will expose the name, what their action is and a calculate function that operates on two values. We can create an example plugin that performs addition:

Public Class Plugin
    Implements IPlugin

    ReadOnly Public Property Name() As String Implements IPlugin.Name
        Get
            Return "Addition"
        End Get
    End Property

    ReadOnly Public Property ActionName() As String Implements IPlugin.ActionName
        Get
            Return "Add Values"
        End Get
    End Property

    Public Sub Calculate (ByVal value1 As Integer, ByVal value2 As Integer) Implements IPlugin.Calculate
        Dim result As Integer = value1 + value2
        MessageBox.Show ("The result is " + result.ToString)
    End Sub
End Class

See how we named the class that implements the plugin as just Plugin? This is because this is what the consol application expects. We can have other classes and whatnot in our plugin that do the meat of our work, but the application that consumes the plugin only cares that the possible plugin follow our rules stated earlier.

Checking and consuming the plugin

In our console application, all we’ve got to do is grab our possible plugins, then check their validity. Once we’re sure it is valid, we can consume it via the interface.

Dim asm As Assembly = Assembly.LoadFrom(possiblePlugin)
Dim myType As System.Type = asm.GetType(asm.GetName.Name + ".Plugin")
Dim implementsIPlugin As Boolean = GetType(IPlugin).IsAssignableFrom(myType)
If implementsIPlugin Then
    Console.WriteLine(asm.GetName.Name + " is a valid plugin!")

    Dim plugin As IPlugin = CType(Activator.CreateInstance(myType), IPlugin)
    Console.WriteLine("{0}: {1}", plugin.Name, plugin.ActionName)
    plugin.Calculate(5, 4)
End If

Wrapping things up

Well, this was a quick and dirty look at implementing your own plugin architecture into your application. Please leave feedback or questions. I’d be happy to hear both!

Technorati Tags: VB.NET,Plugin,architecture

Hot-To: Model a Work Breakdown Structure with Project 2007 and Visio 2007

Stacy Vicknair — Sun, 11 Jan 2009 18:05:25 GMT

If you’re trying to make a WBS from your suite of 2007 applications, Microsoft Download Center has a Visio add-on that might save you some time.

To get a WBS pumped out quickly, just do the following:

Download and install Microsoft Office Visio 2007 WBS Modeler.
Open Visio, and start from the new WBS Modeler.
Open Project and open the project you want to make a WBS for.
In Visio, click WBS Modeler, then Import From Microsoft Office Project…

Click through a couple more settings and here you have it. An easy WBS, and best of all it is free! When I was looking around the best alternative looks like it will run you around $200.

Technorati Tags: Project,Visio,WBS

How-To: Enumerate the Internet Explorer Installed OpenSearch Engines

Stacy Vicknair — Wed, 26 Nov 2008 19:27:41 GMT

For my recent Launcher project, I was constructing a ribbon that would allow the user to search the web via their engines installed in Internet Explorer. The engines themselves are an XML document following the OpenSearch schema. For firefox, these xml documents just get stored locally. What does IE do with theirs?

Well, IE sticks them in the registry. Why? Maybe someone else can answer that. Here's a brief look at how to get the search engines out of the registry. The following snippets of code come from the launcher project. If you want to see how I abstracted the engines and the complete code, you can download it from Codeplex. If you want to critique the code or make suggestions on how I can code better, leave me a comment here. I'm not the best programmer and I'm starving to learn.

First off, lets give a simple answer to this post: How do I enumerate the IE search engines? The search engines are located in Software\Microsoft\Internet Explorer\SearchScopes, the rest of the task is just enumerating the keys and values to extract important information.

First off, I made a straightforward structure to represent my individual search engine:

Public Structure SearchEngine
    Private m_DisplayName As String
    Public Property DisplayName() As String
        Get
            Return m_DisplayName
        End Get
        Set(ByVal value As String)
            m_DisplayName = value
        End Set
    End Property

    Private m_SearchString As String
    Public Property SearchString() As String
        Get
            Return m_SearchString
        End Get
        Set(ByVal value As String)
            m_SearchString = value
        End Set
    End Property

    Private m_isDefault As Boolean
    Public Property isDefault() As Boolean
        Get
            Return m_isDefault
        End Get
        Set(ByVal value As Boolean)
            m_isDefault = value
        End Set
    End Property

    Public Overrides Function ToString() As String
        Return m_DisplayName.ToString
    End Function
End Structure

This structure just contains the display name, the search string and whether or not it is the default.

I fill a list of search engines as so:

Private Sub GatherEnginesFromRegistry()
    'Clear list
    m_engineList.Clear()

    Dim regKey As RegistryKey = Registry.CurrentUser.OpenSubKey("Software\Microsoft\Internet Explorer\SearchScopes", False)
    'Gather Default key
    Dim defaultKey As String = regKey.GetValue("DefaultScope")

    'Gather all search engines
    For Each subKey As String In regKey.GetSubKeyNames
        Dim engine As New SearchEngine
        Dim engineKey As RegistryKey = regKey.OpenSubKey(subKey)
        If engineKey.GetValue("") = String.Empty Then
            engine.DisplayName = engineKey.GetValue("DisplayName")
        Else
            engine.DisplayName = engineKey.GetValue("")
        End If
        engine.SearchString = engineKey.GetValue("URL")
        If (subKey = defaultKey) Then
            engine.isDefault = True
        Else
            engine.isDefault = False
        End If
        m_engineList.Add(engine)
        engineKey.Close()
    Next

    regKey.Close()
End Sub

Here you see regKey as a key to the SearchScopes subkey within CURRENT_USER. Within SearchScopes the DefaultScope value contains the subkey name for the default search engine.

After fetching the name of the default engine, I just iterate through eachsubKey and convert it into my structure, and add it to a generic list. The important values being DisplayName and URL. However, if the (Default) value for the subkey is specified, I take it instead of the DisplayName. Why? because LiveSearch does this oddity:

The DisplayName is a DLL call of sorts and the (Default) is the name? What's up with that? :\

And finally, to use the search within an application just replace the {searchTerms} in the URL with the appropriate URI formatted text and send it on its way via Process.Start!

Private Sub btnSearch_Click(ByVal sender As System.Object, ByVal e As Microsoft.Office.Tools.Ribbon.RibbonControlEventArgs) Handles btnSearch.Click
    Process.Start(searchURL.Replace("{searchTerms}", ConvertStringToURI(searchText)))
End Sub

Technorati Tags: How-To,IE Search Engine Enumeration

How to: Set up Google Analytics on your GeeksWithBlogs blog

Stacy Vicknair — Fri, 21 Nov 2008 18:58:08 GMT

If you haven't seen Google analytics before, you ought to know this: it rocks. You'll get great reports on everything from geographic location to browser to flash version (Why no Silverlight version, eh Google?) See example awesomeness here:

Obviously I've only recently set this up. However, since it is up and running and working great, I figured I'd show you how to get yours up and running as well.

Firstly, sign up for Google Analytics. Then afterwards, Google will provide a script to monitor the site usage. But if you can't access the head for your site, where do you put it? Good question. Almost million dollar.

So since there's only one question when it comes to Google Analytics and GWB, I figured I'd just throw out the answer.

Q. Where do I put the JavaScript thingy?

A. Put it in your news section. Google screams a tantrum that you've got to stick it in the <head> of your html, but the whole thing works out fine right in the news section (which you can edit in your GWB admin panel).

So my next question is, Does anyone know how to get Google Webmaster Tools working on GWB?

Technorati Tags: geekswithblogs,google analytics

Custom Code Snippets Series Part 3: XML Example

Stacy Vicknair — Tue, 04 Nov 2008 18:45:58 GMT

Hey guys,

Here we are, and I’m taking the time to finish up my first series at my new host geekswithblogs! For this part of the series we’ll be taking a look at a practical example of an XML snippet, namely the snippet to create snippets.

I’ve created my own version, but if you’ve toyed with XML snippets before you would know that Microsoft has already included a snippet snippet. This is a good alternative to the “Hard” way described in Part 1, but what if you want a little more of a custom feel to your snippet snippet?

Getting Started

This time around I’ve published the code on Codeplex, at the following address:

http://www.codeplex.com/wtfnextsnippetseries

You can download the premade snippet directly, and then we’ll be looking into the elements of the snippet briefly.

A look through the XML

This snippet is fairly straightforward, and many of the items you might recognize if you are familiar with snippets or have gone through the first part of this series. Our header section is straightforward, and we make good use of literals.

There is one literal that we need to note here: CDATAEND. There’s a bit of a quirk that requires a workaround when making an XML snippet, and that’s if we need to use a CDATA section within our snippet itself.

The problem is that a CDATA section cannot contain another CDATA section. As a result, making a snippet of another snippet becomes complicated. How do you do it? Simply put a literal in the CDATA of your snippet that represents the terminator for the internal CDATA in the snippet.

So, we see in the snippet itself this:

    <Snippet>
      <Code Language="$Language$">
        <![CDATA[$selected$$CDATAEND$
      </Code>
    </Snippet>

and we have the literal CDATAEND defined as this:

<Literal Editable="false">
  <ID>CDATAEND</ID>
  <Default>]]&gt;</Default>
</Literal>

The $selected$ is a placeholder for any selected text when we use the SurroundsWith datatype. This allows us to highlight some VB or whatever and when we insert the snippet it automatically knows we want the code selected to be surrounded by our snippet, and have the selection inserted at the $selected$ point.

Summary

So this concludes the brief look at snippets, and I want to tell you guys that I’ll appreciate any feedback. The “Hard” way isn’t really that bad, and all in all (if you’re like me) it gives you complete quick control over your snippet creation. The “Easy” way is an external application, and is designed with syntax highlighting for a language specific creation, so you won’t be popping out the XML or C# snippets from the VB snippet creator.

Please post comments if you have criticisms or anything to say, I’m looking forward to improving the quality of this blog and of myself, and feedback will help with both!

Technorati Tags: Custom Code Snippets Series,snippet,xml

Custom Code Snippets Series Part 2 of 3: The “Easy” Way

Stacy Vicknair — Mon, 20 Oct 2008 15:58:08 GMT

Here we are at part two of the Custom Code Snippet Series. In the previous part we covered how to make your own snippet by creating an XML .snippet file and adding to it the necessary content to get a custom snippet up and running.

This time around, we’re going to cover the “Easy” method of creating custom code snippets: through a GUI. Thankfully, the MSDN itself has a Code Snippet Editor for both Visual Basic 2005 and 2008 available at the following links. This tutorial will make use of the Visual Basic 2005 Code Snippet Editor.

To get the 2005 version:
http://msdn.microsoft.com/en-us/vbasic/ms789085.aspx

to get the 2008 version:
http://msdn.microsoft.com/en-us/vbasic/bb973770.aspx

So, after installing the Code Snippet Editor, we’re ready to get started.

Add the path to My Code Snippets

Right off the bat, you can tell we are going to have a small issue. Looking through the tree in the snippet editor does not show the custom code snippets! That’s alright, we’ll just add our path.

Right-click in the tree view area of the program and select Add Path…. Browse to the path we discussed for saving snippets in the previous part:My Documents > Visual Studio YYYY > Code Snippets > Language of Choice > My Code Snippets.

Now we can see our custom code snippets in the editor. If you’ve done the previous part in this series you should see the cmdWrite snippet show up in the tree under the My Code Snippets folder:

Create new snippet in My Code Snippets

Why do I stress putting the new snippets in our My Code Snippets folder? If you want a centralized location that is somewhat protected from other users of the computer, in your My Documents folder makes sense. You might even want to make your own location that you point Visual Studio to, that way you can implement version control to make sure changes benefit your code and rollback if they do not.

To create a new snippet, just right click the folder and select Add New Snippet. Name your snippet, today we’re going to make a simple For loop, so I’ll name this one ForLoop. Obviously, you’ll make snippets that matter more.

Once you create the snippet, double click on it. Here you’ll see a GUI representation of the XML document. Fairly straightforward.

To start, let’s fill in our info. Here’s what I put:

Now let’s put in our VB code into the editor at the top. Here’s what I put:

Dim count as integer = 0
Dim countMax as integer = 100

For count = 0 to countMax
    'Something to do
Next

Now we’ll transform this code into a dynamic snippet. I want count to be a choice for the variable name, so highlight count and on the Replacements tab at the bottom hit the yellow plus sign.

count will become surrounded by $ symbols, and become a decadent orange color. At the bottom, you’ll see that most information has been filled in for us. For type, we’ll leave it blank, and for tooltip, we’ll just describe the replacement. Now, do the same for countMax.

We’re practically done! Flip over to the Test tab and hit the big test button. Did it work okay? If so, we’re ready to find it in VS and start using it, just make sure to save your snippet!

Check it out in Visual Studio

Go ahead and close the Snippet Editor and open up a new console project in Visual Studio, VB of course.

If you’ve set up the same snippet as me, go ahead and type ForLoop? and hit Tab twice and you should see your new snippet come to life!

Technorati Tags: Custom Code Snippets Series,VB .NET,Tutorials

For those geeks that want decent looking <pre> code

Stacy Vicknair — Tue, 14 Oct 2008 18:48:51 GMT

I mashed together a variety of random web resources on how to make a decent pre tag for code and the output looks like this (ignore how incredibly bad this code is... I was testing SVN and making sporadic changes... Steve McConnell would strangle me):

Module Module1
    Sub Main()
        Console.BackgroundColor = ConsoleColor.DarkBlue
        Console.ForegroundColor = ConsoleColor.White
        Console.Clear()

        My.User.InitializeWithWindowsUser()

        Dim sw As New Stopwatch()
        sw.Start()

        Dim username As String = My.User.IsInRole(ApplicationServices.BuiltInRole.Administrator).ToString

        Console.WriteLine("User is admin: " & username & "!")
        sw.Stop()
        Console.WriteLine("Time: " & sw.Elapsed.ToString)
        Console.ReadLine()

        
    End Sub
End Module

There’s word wrap, and it’s at least differentiated from the rest of the post nicely IMO. the code is as follows:

pre {border: solid 1px #CCCCCC; 
 font-size: 1.3 em;   
 margin: 10px; 

 padding:10px; 

 background: #EEEEEE; 
 white-space: pre-wrap;  
 white-space: -moz-pre-wrap !important;

 white-space: -pre-wrap;

 white-space: -o-pre-wrap; 

 word-wrap: break-word;

}

Hope it helps some of you other code bloggers :)

Technorati Tags: Code,Pre,CSS,GWB

Custom Code Snippets Series Part 1 of 3: The “Hard” Way

Stacy Vicknair — Tue, 14 Oct 2008 18:12:43 GMT

In this brief series I’m going to go over creating your own custom code snippets for use in Visual Studio 2005 or later. We’ll be using the XML Schema from Visual Studio 2005, but I assure you it works for both.

This series will contain three parts:

The “Hard” Way
The “Easy” Way
Practical Example of an XML Snippet

The reason we’re going to call this version the “Hard” way is because there are snippet generator apps available, including one made by the teams themselves.

So before we begin, I’d like to say that I prefer to use the “Hard” way. For me, it helps me have a greater understanding with limited reliance on other software. Also, if the schema changes (which is very very doubtful) I will have instant knowledge of what needs fixing via intellisense tools.

Step 1: Create a new .snippet file

A .snippet file is just like having a .vb or .c file. A glorified text document. To start off, I like to have a text file with the following already in it:

<?xml version="1.0" encoding="utf-8" ?> 
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title></Title>
      <Shortcut></Shortcut>
      <Description></Description>
      <Author></Author>
      <HelpUrl></HelpUrl>
      <SnippetTypes>
        <SnippetType></SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Code Language="">
        <![CDATA[]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

What this allows you to do is get intellisense from Visual Studio when creating the snippet, as well as you have a starting structure that is common to most snippets, and it is just a matter of filling in the blanks.

You can create this in notepad, and then save it out to where you want to store your snippets. If you want exclusive access to your snippets as well as to have them “installed” automatically, drop them in your My Documents > Visual Studio YYYY > Code Snippets > Language of Choice > My Code Snippets directory. For this example, I’ll be working with Visual Studio 2005 and a VB .NET snippet. I’ll be naming my output cmdWrite.snippet, and my snippet will write a string to the console and then wait for the user to hit enter.

Step 2: Open .snippet in Visual Studio and fill in the blanks

By using Visual Studio to edit the snippet, we’ll get the rich experience of intellisense and syntax highlighting to make this process a bit easier.

Now we’ll start adding the meat and potatoes, and for reference check out the Schema Reference from the MSDN.

The Header Section

The Header contains all of that important information to say what this snippet is all about. The Title contains what the snippet will be named in intellisense, the shortcut is the snippet shortcut, the description is what shows as a tooltip when selecting the snippet.

The SnippetTypes section goes over what your snippet plans to do. Does it just insert at the point? Does it wrap around the text highlighted? Could it do either?

The Snippet Section

The Snippet section is where you put the real code for the snippet into play.

To get our show started, we’ve got to let the snippet know our intentions. Setting the language to “VB” does just that.

Now, the real code goes into the CDATA[] brackets. This is everything you want exported into Visual Studio when printed.

For this example we’re just adding the following:

Console.Writeline($String$)
Console.ReadLine()

Now, huh? What’s that $String$ business? Well, we want to have some intelligence to our simple script, so we gave it a literal declaration. To add this into the snippet XML, add it before the code block. This will specify we want a string to replace our $String$ placeholder:

<Declarations>
    <Literal>
        <ID>String</ID>
        <ToolTip>Replace with string to write.</ToolTip>
        <Default>"Hello World!"</Default>
    </Literal>
</Declarations>

Now we’re ready to save this out and try it out! Go ahead and save and close Visual Studio. Reopen and start a new VB console application and insert the snippet you’ve just made!

For final comparison, here is my finished code:

<?xml version="1.0" encoding="utf-8" ?> 
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet"> 
    <CodeSnippet Format="1.0.0"> 
        <Header>
            <Title>Command Writeline</Title>
            <Shortcut>cmdWrite</Shortcut>
            <Description>Writes a string to the commandline and then waits for the user to hit enter</Description>
            <Author>Stacy Vicknair</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>String</ID>
                    <ToolTip>Replace with string to write.</ToolTip>
                    <Default>"Hello World!"</Default>
                </Literal>
            </Declarations>
            <Code Language="VB" Kind="method body">
                <![CDATA[
                    Console.Writeline($String$)
                    Console.ReadLine()
                ]]>
            </Code>
        </Snippet>
    </CodeSnippet> 
</CodeSnippets>

References:

http://msdn.microsoft.com/en-us/library/ms171418(VS.80).aspx

http://weblogs.asp.net/srkirkland/archive/2007/10/29/creating-a-custom-code-snippet.aspx

Technorati Tags: Custom Code Snippets Series,Snippets,VB .NET

Free mail hosting from Windows Live Part 2

Stacy Vicknair — Tue, 07 Oct 2008 17:23:51 GMT

Continuing on from what I started in the Part 1 post, I’m going to show you how to get set up with Windows Live mail for your domain (assuming GoDaddy, but correlations will be present). It’s easy, relatively quick, and will result in a free service that ought to minimize your mail frustration.

Step 1: Get an account started on domains.live.com

To get started, browse over to http://domains.live.com. Towards the bottom of the page, click get started and then enter in your domain information.

Leave the radio button next to Set up Windows Live Hotmail for my domain selected, because that would be the main point of this article ;)

After clicking Continue, you’ll be prompted for whether or not you want to associate the domain with a new Live ID or with your current Live ID. This is a personal choice, but if I had done this over I would have created a new one. Otherwise, during the setup you’ll find yourself juggling between Live IDs to test out the new mail accounts. Pick your poison, then review the settings and choose whether or not to accept them.

Step 2: Set up your MX Records

Now that you’ve registered with domains.live.com, you should come to a screen telling you about how bad of a person you are because your service is Pending DNS configuration and you have not been authenticated to even be associated with the domain.

So, let’s get that fixed. Now, log into GoDaddy or your other domain provider and get to where you can edit the domain configuration. For GoDaddy, sign in and go to the Domain Manager.

Select the domain your aiming to set up. Towards the middle of all that craziness, you should spot a section entitled Total DNS, and below the section select the link Total DNS Control and MX Records.

As you see above, even with a domain you never use there are some default settings for MX with GoDaddy. This is because they do give you your own accounts, I believe up to 50, and I believe they even allow pop access. If you think you want to stick with this, reevaluate the pros and cons I listed in Part 1.

Firstly, remove all of the old MX Records. No turning back now! (Well, you could always turn back… call support if necessary) Refer back to your Windows Live Admin center window and you’ll see the new MX Record that you need to add. On the MX section back in GoDaddy click Add New MX Record and enter in the information as seen in Live Admin Center. Host name is the Host field in WLAC, and Goes To Address is the MX Server in WLAC.

Optionally, you can add the TXT record to GoDaddy as well, but it should not be required.

After refreshing fervently for a while in the WLAC eventually you will have proven your administrative status (from the GoDaddy changes, not the fervent refreshing). From here you can add new mail accounts or configure the account however you please. Mail accounts will be able to log in at mail.live.com.

Optional Step 3: Set up mail.yourdomain.com

so you’ve got mail, and you want it to be accessibly AT LEAST from your domain right? So now we set up the CNAME to do the redirection.

By now your domain should have authenticated, and you can select Custom addresses in the WLAC. Make sure Hotmail is selected in the drop-down, and hit Add.

An Ajax control will prompt you for the CNAME you want to use, in this case I’ll use mail. You’ll see the page reload and you’ll now have a specified link between mail and hotmail, but you aren’t done just yet.

Pop back in to the GoDaddy domain Management, and add a new CNAME record. The alias will be whatever you chose before and the Points to Host Name value will be go.domains.live.com.

Hit okay, go get some coffee, come back and you should be good to go!

Technorati Tags: Microsoft,Windows Live,domains,mail