Converting a ResourceSet of bitmaps into a sorted List
First of all let's try to make it more concise:

var zoomLevels = Properties.Resources.ResourceManager
    .GetResourceSet(CultureInfo.CurrentUICulture, true, true);
    .Cast&lt;DictionaryEntry&gt;()
    .Select(x =&gt; ParseZoomLevelAndNormalize(x.Key))
    .OrderBy(x =&gt; x);


Note that you do not need to create multiple temporary lists (not that you will ever note this waste) using ToList(). Also note that parsing code has been moved to a separate function. Let's talk about that...

static float ParseZoomLevelAndNormalize(object resourceName)
{
    string zoomLevel = Convert.ToString(resourceName).Substring(1);

    return Single.Parse(zoomLevel,
        NumberStyles.Number, CultureInfo.InvariantCulture) / 100;
}


If you do not thin it's clear enough then you should introduce separate functions to explain what it is doing:

var precalculatedMaps = new PrecalculatedMaps();
var zoomLevels = precalculatedMaps.ZoomLevels.Select(x =&gt; x / 100);


Where PrecalculatedMaps hides the implementation detail (now it's a resource file, in future might be a folder in file system). ZoomLevels property simply return a standard IEnumerable&lt;float&gt; of available zoom levels (in range [0...100]). Proof of concept:

sealed class PrecalculatedMaps
{
    public IEnumerable&lt;float&gt; ZoomLevels
    {
        get
        {
            if (_zoomLevels == null)
                _zoomLevels = ReadAvailableZoomLevels().OrderBy(x =&gt; x);


            return _zoomLevels;
        }
    }

    private IEnumerable&lt;float&gt; _zoomLevels;

    private static IEnumerable&lt;float&gt; ReadAvailableZoomLevels()
    {
        return Properties.Resources.ResourceManager
            .GetResourceSet(CultureInfo.CurrentUICulture, true, true);
            .Cast&lt;DictionaryEntry&gt;()
            .Select(x =&gt; ParseZoomLevel(x.Key));
    }

    private static float ParseZoomLevel(object resourceName)
    {
        string zoomLevel = Convert.ToString(resourceName).Substring(1);

        return Single.Parse(zoomLevel,
            NumberStyles.Number, CultureInfo.InvariantCulture);
    }
}


Note that here I made few assumptions which you can't ignore:


Resource names are valid numbers (otherwise Single.Parse() will throw an exception).
Numbers are formatted using en-US locale. In your code you're parsing using CultureInfo.CurrentCulture (the default if you do not specify any IFormatProvider). For integer numbers you will probably never have trouble but it's better to be sure, right?
There is always a leading underscore (that might be VS default but you can change resource name by hand). Do you want to handle the case? Change .Substring(1) with .TrimStart('_').
If you have only natural numbers then you can use NumberStyles.Integer instead of NumberStyles.Number (which allows decimals).




OK, that was about your actual code but let me say few words about the algorithm. Zooming an image is not an incredibly slow operation, I don't know how you did it and which technology you use for UI then I can't give you better ideas but:


You limit zooming to integer factors.
You can cache those generated images.
You can generate images only at special thresholds (for example 200%, 50%, 25%) leaving the exact scale in/out duty to UI controls (which are pretty good at this). This might not be applicable if your zoom algorithm is REALLY slow and undoubtedly better than canonical decimation/interpolation algorithms already in use.
You can debounce zoom requests to do not generate hundreds images when user is zooming from 100% to 10% and he's not interested in the intermediate images (leaving the duty to scale things to UI controls).