Kristofer's Blog

Passing custom data to your Azure VMs, a metadata service workaround?!

KristofeL — Mon, 16 May 2016 20:39:28 GMT

Sometimes you develop a solution where your VM need to be aware of itself and the information associated with the VM during deployment:

What is the Azure identification of me as a VM Instance?
What datacenter/region have I been deployed to?
What is the Fully Qualified Domain Name, FQDN, for me as a Virtual Machine?

These questions are very easy to answer if you as an administrator take a look into the Azure portal, but it’s not that easy if you want a program or script to do the same, if it runs on top of the provisioned VM. So if I were a script running on the VM how would I figure out these things? A common approach to this problem would be to call out to an internal service built into the cloud platform, and ask: Who am I? Where am I? How can someone reach me? These service are often referred to as metadata services and can provide this kind of metadata for the running instance. At the time of writing this blog post, there are no such service generally available in Azure. So an option to this approach would instead be to pass in such information at deploy time, into the provisioning VM and saved in a place where it can be reached later on. It’s not a perfect replacement to a metadata service, but it offers a lot of abilities that could be tricky to solve otherwise. In Azure this feature is called “Custom Data” and is text that you can pass in while provisioning your VM either through REST APIs, PowerShell CmdLets, Azure Command Line Interface (CLI) or using an ARM Template. In this example I’ll show a way to automatically pass in custom data using an ARM Template so that every time your VMs have started up, they know their name, what region they are deployed to and what the associated FQDN is. The full template can be found on https://github.com/krist00fer/azure-quickstart-templates/tree/master/101-vm-customdata-windows while I do the last fixes to have it incorporated into the full repository of Azure Quick Start Templates at https://github.com/azure/azure-quickstart-templates. In short, my template has parameters for vmLocation (region to deploy to) and vmName (a name you assign to the azure resource that will be implemented as your VM). There is also a variable called pipName (name of the public IP address) that as following: "pipName": "[concat(parameters('vmName'), 'pip')]", i.e. I give my public IP address resource the same name as my VM, but with the prefix 'pip'. Later down in the template definition you find the actual VM definition and there you find the osProfile property:

"osProfile": {
          "computerName": "[parameters('vmName')]",
          "adminUsername": "[parameters('adminUsername')]",
          "adminPassword": "[parameters('adminPassword')]",
          "customData": "[base64(concat(parameters('vmName'), '|', parameters('vmLocation'), '|', reference(variables('pipName')).dnsSettings.fqdn))]"
        },

You can see that except for computerName, adminUsername and adminPassword, I've also added the property "customData" passing in a base64 encoded string that is the combination of the vmName parameter, the vmLocation parameter and the assigned Fully Qualified Domain Name, FQDN. Deploying this template will give you a new VM that you could remote into and find a file at: C:\AzureData\CustomData.bin This file contains the above sent in customData string, already decoded and ready to use. Executing the following PowerShell Script in the VM would then parse and separate the passed in values:

$customData = (Get-Content C:\AzureData\CustomData.bin).Split('|')
$vmName = $customData[0]
$vmLocation = $customData[1]
$fqdn = $customData[2]

PS C:\> $vmName
vm001

PS C:\> $vmLocation
North Europe

PS C:\> $fqdn
customdatavm001.northeurope.cloudapp.azure.com

So there you have it. You can know query the passed in information to understand similar things to what a Metadata Service would give you. It's not entirely bullet proof for all scenarios, but provides a simple solution to many problematic things you might encounter.

The Git Command Line 101 for Windows Users

KristofeL — Tue, 02 Jul 2013 08:57:00 GMT

I'm currently working on a project using Git as source control system and I thought it would be useful to write down some notes and questions that have been answered during this project.

Git, GitHub and TFS, what's what?

So, here is a really good start if you are new to Git. Let's straighten out some facts first:

Git is a distributed version control system
GitHub is a service to host your Git repository
TFS (Team Foundation Server/Service) is a Application Lifecycle Management, ALM, Server developed by Microsoft and also available as a service at https://tfs.visualstudio.com . TFS can handle your source code through a traditional TFS Source Control Repository or as a Git repository, i.e. you can use both TFS (as ALM Server) together with Git as Source Control system.

So, let it be clear. Git is NOT GitHub. Git doesn't have to be used with GitHub (even though you can). Git CAN be used together with Team Foundation Service, TFS.

How can I install Git on my Windows machine?

There are several ways of installing Git including just going off to https://gitscm.com/ and downloading the installer for Windows. I do like to keep my dependencies up to date using a packet manager called Chocolatey though, so If you are anything like me, then install Chocolatey and then use the command: > cinst git Make sure you have Git.exe in your path by just executing "git" from PowerShell or your traditional Command Prompt. If it's not, make sure you find Git.exe and add that folder to your path. That's it! There are special Git shells that you can use, but I like the original PowerShell one the best with the addition of Posh-Git that can be installed directly from the website or by using Chocolatey: > cinst poshgit Posh-Git (abbreviation for PowerShell Git) is a set of PowerShell scripts that adds additional functionality to PowerShell users using Git. It's simple but good, try it out!

I want to start working on someone else's project, how do I connect to that source control server?

Git is a distributed Source Control system, i.e. you can and will communicate with a remote server, but only when you think you are ready to do so. I.e. you don't have a constant connection to a remote server like with TFS or other Source Control systems. In order to start working on someone else's repository you need to clone it. To clone a repository is precisely what it sounds like, i.e. you create an exact replica/copy of that other repository on your computer. That "clone" contains all information that is available on the remote server, including: source code with history, comments, etc. So after a repository is cloned you'll have all information needed locally. The repositories you want to clone are often (but not always) hosted on some public service out on the Internet and you'll need the URL to the repository you want to clone, for example (https://github.com/username/yourproject or https://username.visualstudio.com/DefaultCollection/_git/yourproject). You can get those URL's from the respective service that are hosting them. Go to your favorite command line shell (mine is PowerShell), change folder to one of your choice, i.e. c:\dev\repos\ and enter: > git clone [put your url here] [put name of project here] You don't need to put in a project name if you don't want to but it can be useful to do so if the default project name is long, contains strange characters (HttpUrlEncoded) or if you just want a different name on your computer.

I want to start a new project on my machine that has no connection to no one else's repository. How do I do that?

Since Git is a distributed Source Control Manager, you don't have to be connected to any server in order to use a local repository, even if that repository was created as a clone of another one. So it's really easy to setup a new local repository. Move to a folder of your choice, i.e. c:\dev\repos\mynewproj. Then enter the following from the command line: > git init That's it, you're done!

I want to check out files in order to edit them?

Git doesn't use the notion of checking out files. If you want to edit a file, just edit it. If you want to add a file, just add it. See next section about how to check in pending changes to understand how this works.

I want to check in pending changes, but how?

So check in pending changes is a two stage operation in Git. First you need to tell Git what changes it should care about and once that is done you commit those changes to your local repository. Something that is really different and important to understand compared to using TFS or any other centralized source control system is that those changes then only gets committed locally on your computer. So let's start by first committing to your local repository and I'll explain how to "push" your changes back to the central repository later on. First we tell Git what to include in the coming commit by using the command add: > git add . NOTICE the "dot" after add! You can specify exactly what files to add by specifying those as arguments after "git add" or you can just tell Git to add every file within the current folder including any sub folders by using the "git add ." syntax. This command has told Git that we (soon) want to commit changes made to every changed, added or removed file in my folder (or subfolders). Let's continue to commit those changes: > git commit –m "your comment here" So now you have "checked in your pending changes" in your locally repository. Remember those changes has not yet left your computer, so continue and read coming sections in order to understand how we can "push" those changes to someone else.

I did a "git commit" but forgot to enter a comment using –m. What the #!"¤#!" happened?

Ok, first of all, keep calm and sit down in the boat. If you enter "git commit" but omit to enter a comment using the "–m" parameter. Git will open up the default editor for you to edit your check in note. By default that is Vim. From the home page you can read: "Vim is an advanced text editor that seeks to provide the power of the de-facto Unix editor 'Vi', with a more complete feature set." Ok, so what might just be presented in front of you is a text editor, hosted inside your console shell (i.e. PowerShell for me). Vim is a very power full editor if you know how to use it but it also has "quite a high" threshold to learn… and all you want to do is write a commit message. I won't go into how you use Vim, but here is how you can get on with your commit.

Alternative 1 – Exit Vim without entering any comment

A blank or unsaved comment will be counted as an aborted attempt to commit your changes and you can exit Vim by following these steps:

Press to make sure you are not in edit mode (you can press Esc several time if you are uncertain)
Press :q! (that is , this tells Vim to discard any changes and exit)

Git will then respond: "Aborting commit due to empty commit message" and you are once again free to commit using: > git commit –m "your comment here"

Alternative 2 – Use Vim to write a comment

Follow the following steps to use Vim for writing your comments

Press to enter Edit Mode (or Insert Mode).

That will leave you with a blinking cursor on the first line. Add your comment.

Press to make sure you are not in edit mode (you can press Esc several time if you are uncertain)

Press :wq (that is , this will tell Vim to save changes and exit)

Git responds that your commit has gone through as you would expect. If you want to, you can use any other editor by configuring Git with another default editor, but I won't go into that right now. Either you love Vim and use it or you don't and then you'll remember to add the "–m" parameter from now on.
Ok, I get it how to "check in pending changes locally" but how can I get those changes back to my colleagues in the project?
So this is how a distributed source control system like Git really differs to a centralized one like TFS. If you were to "check in pending changes" using TFS traditional Source Control system, then your changes would be on the server by now, but since we are using Git right now and if you've done a "commit" (see section above) then your changes is still locally on your computer. In order to get your changes to a remote server you use a command called "push". So let's start simple and do some assumptions before we continue. Let's assume you have created a local repository by cloning a remote repository and let's also assume that you are the only one working on that project right now, i.e. no other changes is going on in the source code right now. So you now have locally committed changes that you want to share with a remote repository. This is done using a command called "git push". The push command will take the current state of your local repository and update the remote repository with the same changes. As long as the above assumptions are correct (that you've cloned your repository from an external one) then you only need to write: > git push If everything worked according to plans, then your changes are now available on the server for others to use.
How do I "get latest version" using Git?
A fundamental thing to remember here is that Git is a distributed source control system, i.e. when you say "get latest version" you really have to think about it like "I want to get the latest version according to THAT repository". But to keep it more in line with a centralized source control system like for example TFS, you could say that you want to incorporate all changes available on the server that I originally cloned from. > git pull That's it! Or is that it? So even though the command "git pull" seems simple and receives the latest version from the server, this command is source for discussion. "git pull" is actually two commands in one. By default "git pull" equals "git fetch" + "git merge" but let's talk some more about this in next section.
When using Git, I don't have to handle merge conflicts, right? At least that's what I've heard.
Ok, this is a really interesting question or more of a rumor that goes on out there. I've heard it several times from close friends that: -"Git is so much easier to use than TFS Source Control since I don't have to handle merge conflicts!". This is absolutely wrong! You do have to handle merge conflicts in Git as well. Let's just face the following example: Person A changes file "readme.txt" locally on her computer. Person B also change information in his version of "readme.txt", in his local repository. They have both cloned their repositories from "The Server", so they both have the some origin. Person A does a local commit (i.e. "git add ." and "git commit") and then pushes her changes up to "The Server" (i.e. "git push"). Person B is now ready to push his changes to the server and tries to push them to "The Server" using "git push". Git will respond with an error message, telling Person B that his local repository is running behind the repository on "The Server". In order to go ahead with pushing his changes to the server, Person B first need to update his local repository to the same state as the servers state and he does that by doing a "git pull". As you remember "git pull" is actually two commands executed at once, first "git fetch" and then (by default) "git merge". "git fetch" fetches and updates the local repository with changes made to the remote repository. "git merge" tries to incorporate those changes into your code that you have locally on your computer and might succeed, but in this case, since both Person A and Person B has changed the same file and perhaps at the same place, a merge conflict will occur. CONFLICT (content): Merge conflict in readme.txt Automatic merge failed; fix conflicts and then commit the result. What Person B now have to do is to once again open up "readme.txt". Look at the comments added by Git (look for a lot of arrows pointing to the left or right) and then resolve the conflicts manually. When conflicts are resolved, Person A does a "add" and a new "commit" and then can push the changes up to the remote repository… that is as long as no one else already made another update of the remote repository. There are books (and blog posts) about how to handle merges and merge strategies and I won't go any further on this topic right now, but be reassured. You will have some "fun" merge conflicts to handle even when using Git.
To round it up…
There is a whole lot more to learn about Git, but all of that is not part of Git 101. Have a look and even though there are a lot of graphical user interfaces to be used out there, make sure you give the command line option a try, it's not as bad as you might first think. If you find any errors or incorrectness, please let me know.

TechEd Europe 2013

KristofeL — Sat, 22 Jun 2013 14:10:35 GMT

I'm currently preparing for my session at TechEd Europe 2013 and I suddenly feel the urge to once again start blogging to my own MSDN Blog. The last years I've been busy updating other blogs, social networks etc. but my own blog has kind of been left to itself. It's time for a change! If you don't find any more interesting blog postings on my blog in a couple of weeks, then please make sure you nag me for it!!!
So I'm speaking at TechEd Europe in Madrid next week. My session "WAD-B338 Build Real-World Modern Apps with Windows Azure Mobile Services on Windows Store, Windows Phone, iOS, or Android" is scheduled on Thursday 27^th of June (3^rd day of TechEd) in Hall 7.5. Some teaser what I'm planning to talk about:
Authentication
Complex Scripts
Deployment and Versioning
Custom APIs and TestingBuild Real-World Modern Apps with Windows Azure Mobile Services on Windows Store, Windows Phone, iOS, or Android
It's going to be a somewhat a different session than my colleague Nick Harris (@cloudnick) did a couple of days ago at TechEd North America since we have already updated Windows Azure Mobile Services with some new features that we want you to know about.Build Real-World Modern Apps with Windows Azure Mobile Services on Windows Store, Windows Phone, iOS, or Android
It feels good to be back on my own blog and expect more to come really soon.

Unit testing with Microsoft Moles

KristofeL — Sun, 07 Mar 2010 05:58:38 GMT

I’ve been thinking for a while: “How come Microsoft doesn’t have a Mocking Library like Moq, Rhino Mock, NMock, Typemock, etc?”. Off course you could argue that we don’t need one of our own, you could use one of the existing once or you could just implement some stubs yourself. I’ve lately been drawn towards Moq for its great support for refactoring, but Rhino Mock is the framework I’ve used the most.

Last night, I discovered something fun though. It turns out that Microsoft Research have been busy with something called Microsoft Moles and a first release is now out for you to try out. Let me introduce Microsoft Moles to you by this example.

Let’s say you have this simplified WCF Order Service, implemented like this:

1: using System;
2: using System.ServiceModel;
3:
4: namespace AI.ServiceLibrary
5: {
6: // Service Contract
7: [ServiceContract(
8: Namespace = "https://assemblyinfo.com/Contracts/OrderService/2010/03",
9: Name = "OrderService")]
10: public interface IOrderService
11: {
12: [OperationContract]
13: int AddOrder(Order order);
14: }
15:
16: // Data Contracts
17: public class Order
18: {
19: public int ID { get; set; }
20: public DateTime OrderDate { get; set; }
21: public string CustomerName { get; set; }
22: public OrderDetail[] Details { get; set; }
23: }
24:
25: public class OrderDetail
26: {
27: public string ArticleNumber { get; set; }
28: public int Quantity { get; set; }
29: }
30:
31: // Simplified OrderService Implementation
32: public class OrderService : IOrderService
33: {
34: public int AddOrder(Order order)
35: {
36: // Set OrderDate to current date
37: order.OrderDate = DateTime.Now;
38:
39: // Save order using Order Repository
40: var repository = new OrderRepository();
41: int orderId = repository.SaveOrder(order);
42:
43: // Return Order ID generated by database
44: return orderId;
45: }
46: }
47: }

So lets create some Unit Tests for this WCF Service, but first, let us recapture what a Unit Test really is. A Unit Test is a test that tests the smallest testable part of your code. In a unit test we don’t want to be dependent of other parts of our system and specially not dependent of other products like the file system, a SQL Server or any other third party application. Don’t get me wrong here, you could and perhaps should write automatic tests that test the integration between several components and applications, but those tests are not Unit Tests, those are Integration Tests. In a unit test we want to isolate our test to test only one (or the smallest) part of our code.

If you look at the implementation of OrderService above, you can see that we have a strict dependency for a class called OrderRepository at row 40, that seems to save our order to a database and returns a new OrderId. This is a problem for us because we can not test our OrderService without testing our OrderRepository as well.

Another problem can be found at row 37 where we set the OrderDate to the current date and time. How can we predict that value? We don’t know at what time our test is going to be run.

1: [TestMethod]
2: public void CanAddOrderWithoutMole()
3: {
4: var service = new OrderService();
5: var order = new Order()
6: {
7: CustomerName = "Test Customer",
8: Details = new OrderDetail[]
9: {
10: new OrderDetail() {ArticleNumber="A123", Quantity=1 },
11: new OrderDetail() {ArticleNumber="B456", Quantity=2 }}
12: };
13:
14: var orderId = service.AddOrder(order);
15:
16: Assert.AreEqual( /* */, orderId);
17:
18: // We can't control OrderDate because we don't know the exact time
19: // the test is executed. We could guess quite well, but if the call
20: // to AddOrder takes time, we can't be sure.
21: }

The traditional way to fix this problem is to refactor the original code to implement some kind of pattern that helps us substitute our hard coded dependencies. One popular pattern is the Dependency Injection Pattern which essentially says that every class should take its dependent objects as in-parameters to its constructor (or through properties). I won’t go in to that pattern right now, but this is a good pattern and as I’ll try to cover in a follow up post, I’ll show you how Microsoft Mole might help you even though you have decided to use this pattern.

But if we don’t want to or are unable to refactor our code, how do we do then? This is when Microsoft Moles comes as a savior. With Microsoft Mole, you can substitute almost any .NET method with a version of your own. Yeah, that’s right. If you don’t like the current implementation of DateTime.Now, you could substitute it to always return a date that you control or if you don’t have full control of what the AddOrder method on the OrderRepository does, then substitute it for another implementation. Let me show you.

1: [TestMethod]
2: [HostType("Moles")]
3: public void CanAddOrderWithoutMole()
4: {
5: int callesToSaveOrder = 0;
6:
7: // Replace the current implementation of DateTime.Now
8: // with one that allways return the same date
9: MDateTime.NowGet = () => new DateTime(2010, 03, 07, 14, 20, 0);
10:
11: MOrderRepository.AllInstances.SaveOrderOrder = (r, o) =>
12: {
13: // Increase counter to be sure of how many times
14: // our implementation of SaveOrder gets called
15: callesToSaveOrder++;
16:
17: // Customer name should be the one we provided
18: Assert.AreEqual("Test Customer", o.CustomerName);
19:
20: // Order date should be the 2010-03-07 14:20:00, because
21: // we just replaced the implementation of DateTime.Now
22: Assert.AreEqual(new DateTime(2010, 03, 07, 14, 20, 0), o.OrderDate);
23:
24: // Allways return 42 as OrderID
25: return 42;
26: };
27:
28: var service = new OrderService();
29: var order = new Order()
30: {
31: CustomerName = "Test Customer",
32: Details = new OrderDetail[]
33: {
34: new OrderDetail() {ArticleNumber="A123", Quantity=1 },
35: new OrderDetail() {ArticleNumber="B456", Quantity=2 }}
36: };
37:
38: var orderId = service.AddOrder(order);
39:
40: // Make sure the OrderID is 42 ...
41: Assert.AreEqual(42, orderId);
42: // ... and that we only made one call to SaveOrder
43: Assert.AreEqual(1, callesToSaveOrder);
44: }

At line 9 above, you can see how I substitute the current implementation of DateTime.Now with an own implementation that always returns 2010-03-07 14:20:00. You can see that I use a “Magic Class” called MDateTime to do that. And on line 11 you can see how I replace the current implementation of SaveOrder of the OrderRepository class by interacting with another “Magic Class” called MOrderRepository. As it turns out, this is no magic at all.

Microsoft Moles generates classes for me according to my specifications in .moles files and in this example I’ve configured Moles to generate Mole Types for mscorlib.dll and my service library. You can configure exactly what classes gets generated to save some execution and generation times, but in this example I’ve just let Moles to generate Mole Types for the complete assemblies.

Content of: mscorlib.moles

1: xml version="1.0" encoding="utf-8" ?>
2: <Moles xmlns="https://schemas.microsoft.com/moles/2010/">
3: <Assembly Name="mscorlib" />
4: Moles>

Content of: AI.ServiceLigrary.moles

1: xml version="1.0" encoding="utf-8" ?>
2: <Moles xmlns="https://schemas.microsoft.com/moles/2010/">
3: <Assembly Name="AI.ServiceLibrary" />
4: Moles>

Moles also made me aware that I had to add the following attribute at assembly level, which I did in my AssemblyInfo.cs file:

1: [assembly: MoledType(typeof(System.DateTime))]

So, that’s it, when I run my Unit Test, and yes this is really a Unit Test and not an Integration Test, it passes and informs me that my AddOrder method inside my OrderService works as it should. Just to prove that I’m not doing Integration Testing here I’ll even show you my implementation of my OrderRepository:

1: public class OrderRepository
2: {
3: public int SaveOrder(Order order)
4: {
5: throw new NotImplementedException();
6: }
7: }

Amazing, isn’t it? We have just made a Unit Test out of code that normally isn’t Unit Testable at all. With that said, I still like to point out the following:

Microsoft Mole is a great! It can help you Unit Test what wasn’t unit testable before (actually some Mocking Frameworks like Typemock have made this possible before).

I still want my systems to be loosely coupled and would still recommend you to implement some patterns to make your system just that. Just because Moles might save you some troubles of implementing one of those patterns, doesn’t make it necessary a good thing.

Make sure you understand how to implement the Dependency Injection Pattern and know how to use Inversion of Control Containers like Unity, NSpring, etc. Microsoft Moles can also help you implement the stubs you would need to Unit Test you components that implements the Dependency Injection Pattern.

Microsoft PEX is a tool that will help you implement Unit Tests with high code coverage and is a very interesting technology. Make sure you’ll have a look at that as well. I might even cover that topic later as well.

Please look at this post on the Visual Studio Team Test blog to find out more information and how you can download Pex and Moles.

Creating and Hosting an even more Minimal WCF Service in .NET 4 using F#

KristofeL — Mon, 01 Mar 2010 15:17:17 GMT

Visual Studio 2010 and .NET 4 will include support for a new language called F#. I must admit that you have to learn how to love F#, it’s not that often love at first sight, because you just can’t figure out what is going on. Even though I’m beginning to like F# more and more and who knows… I might even love it some time soon. Today I got the time to think a lot, during a drive to and from a customer of mine, about how it should be to implement my minimal WCF 4 Service using F#, and it turned out to be pretty straight forward. I think I’ll be trying to use more of F# later on.

Notice how I decided to use the F# function printfn to output text to the console instead of Console.WriteLine which I could have used if I’d liked to.

1: open System
2: open System.ServiceModel
3: open System.ServiceModel.Description
4:
5: []
6: type TimeService() =
7: []
8: member this.GetTime() =
9: DateTime.Now
10:
11: let main =
12: use host = new ServiceHost(typeof, new Uri("https://localhost:4711"))
13: host.Description.Behaviors.Add(new ServiceMetadataBehavior(HttpGetEnabled = true));
14: host.Open()
15:
16: printfn "Service is up'n running at %s" (host.Description.Endpoints.[0].Address.ToString())
17: printfn "Press any key to shut down service"
18: Console.ReadKey()

Creating and hosting a minimal WCF Service in .NET 4

KristofeL — Thu, 11 Feb 2010 15:27:43 GMT

12th of March… that’s the date when we release Visual Studio 2010 and .NET Framework 4. I’m so excited and if you have a MSDN Subscription you can already download the Release Candidate right now. If you don’t have a MSDN Subscription you’ll have to wait some more hours before you can download the release candidate.

Anyway, I got into a discussion with my colleague about WCF and as I went along testing what we discussed I couldn’t help admiring how simple it is to get up and running with a WCF Service in .NET 4. The following example creates and hosts a WCF Service as a Web Service using basicHttpBinding and exposes the metadata, WSDL, if you just steer your browser to the address of the service. In this example https://localhost:4711/?wsdl . Also notice that no other configuration… I repeat. No other configuration is needed!

WCF will create default endpoints using default bindings and if you want to, you could override default behavior in this app by adding information in your application config file (app.config or web.config), but you don’t need to. This will make it tremendously easier to get up and running with your WCF Services.

Here you go:

1: using System;
2: using System.ServiceModel;
3: using System.ServiceModel.Description;
4:
5: namespace MinimalWebService
6: {
7: class Program
8: {
9: static void Main()
10: {
11: using (var host = new ServiceHost(typeof(TimeService), new Uri("https://localhost:4711")))
12: {
13: host.Description.Behaviors.Add(new ServiceMetadataBehavior() { HttpGetEnabled = true });
14: host.Open();
15:
16: Console.WriteLine("Service is up'n running at {0}", host.Description.Endpoints[0].Address);
17: Console.WriteLine("Press any key to shut down service");
18: Console.ReadKey();
19: }
20: }
21: }
22:
23: [ServiceContract]
24: public class TimeService
25: {
26: [OperationContract]
27: public DateTime GetTime()
28: {
29: return DateTime.Now;
30: }
31: }
32: }

Installing the Visual Studio 2008 Development Stack… in the right order

KristofeL — Mon, 04 May 2009 18:07:00 GMT

I just installed Windows 7 RC and once again found myself sitting with a clean Windows installation with no applications installed. That might be a nice feeling, but if you are like me, you will start to feel bored and actually a little bit lost within a couple of minutes without Visual Studio :-)

So how do you go ahead and install Visual Studio nowadays? Well, gone are the days where there only where one installer and you where done. Today there are several installers you have to run, just to setup Visual Studio 2008 to an updated application. This is due to extensions and service packs that have been released after the initial release of Visual Studio 2008. So is it not just to install all of these updates then? Well, yes and no. You should probably install them all, but it’s important that you do it in the right order.

That’s why I completed a list of the order you ought to install Visual Studio and some of the additional updates. Here you go:

Install Visual Studio 2008

If you have Visual Studio Team System 2008 Database Edition och Development Edition, make sure you install both, cause they are since October 1st, 2008, one product.

If you have Visual Studio 2008 Professional or any other version of Visual Studio Team System 2008 Team Suite, just install that version and continue to #2

Install Visual Studio 2008 Team Explorer
… if you are connecting to a Team Foundation Server instance… and you are, right? Make sure you install Team Explorer before #3
Download here.

Install Visual Studio 2008 Service Pack 1
If you ever find yourself in the position that you have installed Visual Studio 2008 Team Explorer after you have installed Visual Studio 2008 Service Pack 1, then you have to reinstall the Service Pack once again.
Download here.

Install Visual Studio Team System 2008 Database Edition GDR R2
… if you have installed Database Edition or Team Suite.
Download here.

Install MSDN Library for Visual Studio 2008 SP1
Download here.

Install any additional applications and extensions to Visual Studio you would like

Visual Studio Team System 2008 Team Foundation Server Power Tools
Download here.

Microsoft Silverlight 2 Tools for Visual Studio 2008 SP1
Download here.

Any Microsoft SDKs
Find links to every SDK here.

Microsoft Expression Studio 2

SQL Server 2008 Development Edition

Etc.

I hope this helps some of you getting started with a fresh installation of Visual Studio 2008.

Silverlight 2

KristofeL — Wed, 15 Oct 2008 03:45:41 GMT

Yesterday, we released Silverlight 2. You can learn more about Silverlight 2 and install it on the official Microsoft Silverlight Site. I for sure will dig deep into Silverlight in a couple of days.
silverlight.RealeaseNewVersionToPublic(new Version(2, 0)); // See you around!

Test Driven Development, TDD, will become quicker and better with Visual Studio Team System 2010

KristofeL — Wed, 08 Oct 2008 14:57:13 GMT

We have just recently started to talk about our next developer tool, Visual Studio Team System 2010, and I must say that I’m in love with one new feature already. Ok, I haven’t really tried it yet for myself, but just to read about this feature makes my Test Driven heart pump a little bit faster.
Identification of Impacted Tests – Visual Studio Team System 2010 will have a Test Impact View, that identifies all the tests that should be run to validate a code change. That is great, cause TDD is all about:

Red – Make sure you have a test that fails, by running all tests. If no tests fail, then write a new one that does fail!

Green – Fix the failing test by least effort.

Refactor – Make the code better, without changing any behavior of the code.

Now this has worked well before, but the first bullet point might take some time when you have a couple of thousand tests. Well you might think that the application should be better partitioned so that you don’t end up with that many tests, but the reality is that you might get there anyway (and some tests might even be integration tests that tests complicated interactions between several components and sometime you want to run those too). Anyway, I’ve been there, where the tests take too long time to run, that you start to cheat. You try to guess what tests that are impacted of a specific code change and only run those. Perhaps you run all tests before you check-in your code, but perhaps you cheat even there (even though you know you shouldn’t… shame on you if you commit this sin… shame on me if I have sinned).
This new feature in Visual Studio Team System 2010 will help you to figure out what tests are actually impacted by the code change you are about to introduce and will therefore speed up testing and development. Especially when using TDD.
Read more about this feature and other new features in Visual Studio Team System 2010 here:
https://msdn.microsoft.com/sv-se/vsts2008/products/bb725993(en-us).aspx

VSTS Developer Edition merges with Database Edition

KristofeL — Mon, 06 Oct 2008 04:25:19 GMT

Good news for all you developers that are also working with databases (I know... that's probably all of you.) We have made changes to Visual Studio Team System Editions. From now on Developer Edition and Database Edtion can be seen as one Edition.

If you own or are about to buy one of these editions, you can get the other edition for free, right away.

More info on:

Somasegar's blog

Gert Drapers "Data Dude" (good FAQ)

In the next version of Visual Studio Team System, code name "Rosario", these editions will be merged into one new edition.