So, you want a Collection which should hold your strings. The easiest and fastest would be to simply use an array. So let us do it.

Because you are using this for pooling strings, we we only need a string[] array. We should add a method bool TryGetValue(string key, out string value) and a string Add(string value).

If we use an array we need to initialize this array to a given capacity at the constructor level and add a possibility to let the array grow if needed.

I decided to use the name you want CoolClass but it should be better named to something more meaningful.

We need to check if a given "key" is in the array at two places, the TryGetValue() and the Add() method. So let us introduce another method int IndexOf(string key) which returns the index of the given keyand if it isn't in the array it returns -1, which should be extracted to a const.

This leads to

public class CoolClass
{
    private string[] array;
    private int capacity;
    private int lastElement = -1;
    private const int elementNotFound = -1;

    public CoolClass() : this(1024) { }
    public CoolClass(int capacity)
    {
        this.capacity = capacity;
        array = new string[capacity];
    }

    public bool TryGetValue(string key, out string value)
    {
        int i;
        if ((i = IndexOf(key)) != elementNotFound)
        {
            value = array[i];
            return true;
        }

        value = null;
        return false;
    }

    public void Add(String value)
    {
        if (value != null)
        {
            int i;
            if ((i = IndexOf(value)) != elementNotFound)
            {
                lastElement++;
                if (lastElement >= capacity)
                {
                    Grow();
                }
                array[lastElement] = value;
            }
        }
    }

    private int IndexOf(string key)
    {
        for (int i = 0; i < lastElement; i++)
        {
            if (array[i] == key)
            {
                return i;
            }
        }
        return elementNotFound;
    }

    private void Grow()
    {
        capacity = capacity * 2;
        Array.Resize(ref array, capacity);

    }
}  

But maybe we should think about this. Why shouldn't we rename the TryGetValue() to GetOrAdd() and remove the Add() method ? Because we don't want to handle cases where the string isn't pooled in the client code.

public class CoolClass
{
    private string[] array;
    private int capacity;
    private int lastElement = -1;
    private const int elementNotFound = -1;

    public CoolClass() : this(1024) { }
    public CoolClass(int capacity)
    {
        this.capacity = capacity;
        array = new string[capacity];
    }

    public string GetOrAdd(string key)
    {
        if (key == null) { return null; }

        int i;
        if ((i = IndexOf(key)) != elementNotFound)
        {
            return array[i];
        }

        lastElement++;
        if (lastElement >= capacity)
        {
            Grow();
        }

        array[lastElement] = key;
        return array[lastElement];

    }

    private int IndexOf(string key)
    {
        for (int i = 0; i < lastElement; i++)
        {
            if (array[i] == key)
            {
                return i;
            }
        }
        return elementNotFound;
    }

    private void Grow()
    {
        capacity = capacity * 2;
        Array.Resize(ref array, capacity);

    }
}

You reallay should use braces {} for singleline if statements too, this won't harm but makes the code less error prone.

Also it isn't mentioned explicitly in the naming guidelines how to name internal static variables, you should use camelCase casing for naming them.

By using a guard clause like

if (string.IsNullOrEmpty(value) || value.Length > 200) { return value; }  

you can return early and therefor you save horizontal spacing which improves the readability of the code.

Data Structure

I think what you're looking for is simply just a List. Looking up the time complexities for List, we can see here:

• Add O(1) [note: amortized, the O(n) on 'beyond capacity' is negligible]
• Remove/RemoveAt O(n)
• Item[i]/Find(i) O(1)

Just a note: you can verify these complexities in the MSDN(for example, going to List<T>.Add, one of the remarks will tell you the complexities), but I found the above table to be a nice and succinct way of showing multiple collections.

Not to attack Heslacher's implementation, but I found IndexOf to be O(n). I'm always dubious of roll-your-own array implementations.

Based on your problem description, though, the two main things you're going to be using are Add and Item[], and since those are O(1) I think List is an easy and efficient candidate.

Alternative - Unique Elements

If you want to guarantee uniqueness(no duplicates), then there's HashSet<T>. Here's an SO question on it. The time complexities are essentially the same. The catch is that if T hashes poorly and there's a lot of collision, the lookup is up to O(n)(this would mean all objects in the collection have the same hash and you essentially have an array). Strings typically hash well, so this shouldn't be a problem.

Code Review

I hate to say it but I just don't have anything to review. To be honest this question would do just as well or better on the Programmers SE. You covered the coding style with Heslacher, so other than that your code is well-formed, easily understood and there's not a whole lot of it. I could nitpick that Pool seems to be an Add and a Get, but the way you use it makes sense, and separating them would probably make the code more complex and ugly. At this point I'm just rambling because this is the code review SE...but I got nothing.

I focused a bit on complexities because your original problem included space complexity(double the strings, double the memory), and time complexities may not actually make a huge difference at run-time for you. So what you choose - array, list, hashset, etc - is really up to you and your environment.