Update it all, VisualStudio Changes

csharp/hamming/Hamming.cs

@@ -0,0 +1,14 @@
+internal class Hamming {
+  public static int Compute(string strand1, string strand2) {
+    int ret = 0;
+    if(strand1.Length != strand2.Length) {
+      throw new System.ArgumentException("Strands must be same length");
+    }
+    for(int i = 0; i < strand1.Length; i++) {
+      if(strand1[i] != strand2[i]) {
+        ret++;
+      }
+    }
+    return ret;
+  }
+}

csharp/hamming/HammingTest.cs

@@ -0,0 +1,47 @@
+using NUnit.Framework;
+
+[TestFixture]
+public class HammingTest
+{
+    [Ignore]
+    [Test]
+    public void No_difference_between_empty_strands()
+    {
+        Assert.That(Hamming.Compute("",""), Is.EqualTo(0));
+    }
+
+    [Ignore]
+    [Test]
+    public void No_difference_between_identical_strands()
+    {
+        Assert.That(Hamming.Compute("GGACTGA","GGACTGA"), Is.EqualTo(0));
+    }
+
+    [Ignore]
+    [Test]
+    public void Complete_hamming_distance_in_small_strand()
+    {
+        Assert.That(Hamming.Compute("ACT","GGA"), Is.EqualTo(3));
+    }
+
+    [Ignore]
+    [Test]
+    public void Hamming_distance_is_off_by_one_strand()
+    {
+        Assert.That(Hamming.Compute("GGACGGATTCTG","AGGACGGATTCT"), Is.EqualTo(9));
+    }
+
+    [Ignore]
+    [Test]
+    public void Smalling_hamming_distance_in_middle_somewhere()
+    {
+        Assert.That(Hamming.Compute("GGACG","GGTCG"), Is.EqualTo(1));
+    }
+
+    [Ignore]
+    [Test]
+    public void Larger_distance()
+    {
+        Assert.That(Hamming.Compute("ACCAGGG","ACTATGG"), Is.EqualTo(2));
+    }
+}

csharp/hamming/README.md

@@ -0,0 +1,50 @@
+# Hamming
+
+Write a program that can calculate the Hamming difference between two DNA strands.
+
+A mutation is simply a mistake that occurs during the creation or
+copying of a nucleic acid, in particular DNA. Because nucleic acids are
+vital to cellular functions, mutations tend to cause a ripple effect
+throughout the cell. Although mutations are technically mistakes, a very
+rare mutation may equip the cell with a beneficial attribute. In fact,
+the macro effects of evolution are attributable by the accumulated
+result of beneficial microscopic mutations over many generations.
+
+The simplest and most common type of nucleic acid mutation is a point
+mutation, which replaces one base with another at a single nucleotide.
+
+By counting the number of differences between two homologous DNA strands
+taken from different genomes with a common ancestor, we get a measure of
+the minimum number of point mutations that could have occurred on the
+evolutionary path between the two strands.
+
+This is called the 'Hamming distance'.
+
+It is found by comparing two DNA strands and counting how many of the
+nucleotides are different from their equivalent in the other string.
+
+    GAGCCTACTAACGGGAT
+    CATCGTAATGACGGCCT
+    ^ ^ ^  ^ ^    ^^
+
+The Hamming distance between these two DNA strands is 7.
+
+# Implementation notes
+
+The Hamming distance is only defined for sequences of equal length. This means
+that based on the definition, each language could deal with getting sequences
+of equal length differently.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure you're exercise file you're submitting is in the `exercism/csharp/<exerciseName>` directory.
+
+For example, if you're submitting `bob.cs` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/csharp/bob/bob.cs`.
+
+## Source
+
+The Calculating Point Mutations problem at Rosalind [http://rosalind.info/problems/hamm/](http://rosalind.info/problems/hamm/)
+
+## Submitting Incomplete Problems
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+