String compression by using repeated characters count

String as an Array

You got your string parameter:

string originalString

Then you turned it into a list:

OriginalList.AddRange(originalString);

Then you turned it into an array:

charArray = OriginalList.ToArray();

And finally used it as:

character = (charArray[i]);

Instead of all that, you could have just done this:

character = (originalString[i]);

Class Design

Instantiating a StringCompression class every time you wanna compress a string can be avoided by just declaring the function CompressionMethod as static since the class has no members anyway. So in Main, you only have to do:

StringCompression.CompressionMethod("String here");

Or better: make it an extension method.

String Builder

Instead of a list of strings in:

CompressedList = new List<string>();

You could instead use a String Builder to create the resulting string.

Single Responsibility Principle

This method is doing to much. It is compressing the string and writes it to the Console. You can avoid this by returning a string from this method and add another method for doing the output.

General

• if you would increase i before the inner while loop you will save one iteration of this loop. You don't need to check the character against itself.
  If you change this you need to initialize n with 1.

• The condition if(n == 1) should be removed because it doesn't add any value. A better way would be to check for n > 1 and if that is true add the count. Here a explaining comment about why this is used would be good.

• speaking about comments, comments should explain why something is done in the way it is done. Let the code speak for itself about what is done by using descriptive names for variables, methods and classes.

  A comment like

  // add characters to the new list 
  CompressedList.Add(character.ToString());  
  

  does not add value to the code but noise. We clearly see that the character is added to the list, so no need to comment on that.

Other than these points I completely agree with @helix answer.

Apart from other reviews I show you an alternative how you can make this really short with LINQ and Regex:

OK, the first solution wasn't perfect. This one will however do it correctly:

var alphabet = Enumerable.Range(97, 26).Select (i => (char)i + "+");
var pattern = "(" + string.Join("|", alphabet) + ")";

var compressed2 =
    Regex.Matches(str, pattern)
    .Cast<Match>().Select (m => new 
    { 
        Char = m.Groups[1].Value[0], 
        Count = m.Groups[1].Value.Length 
    })
    .Aggregate (string.Empty, (result, nextGroup)  => 
        result.ToString() 
        + nextGroup.Char 
        + (nextGroup.Count > 1 ? nextGroup.Count.ToString() : string.Empty));

For:

var str = "aaabbccdddeezbbb";

the result is:

a3b2c2d3e2zb3

• First get letter groups with regex and their lengths
• Then aggregate them to the final string