Efficiency of static constant list initialization in C# vs C++ static arrays

I apologize in advance. My domain is mostly C (and C++). I'm trying to write something similar in C#. Let me explain with code.

In C++, I can use large static arrays that are processed during compile-time and stored in a read-only section of the PE file. For instance:

typedef struct _MY_ASSOC{
    const char* name;
    unsigned int value;
}MY_ASSOC, *LPMY_ASSOC;

bool GetValueForName(const char* pName, unsigned int* pnOutValue = nullptr)
{
    bool bResult = false;
    unsigned int nValue = 0;

    static const MY_ASSOC all_assoc[] = {
        {"name1", 123},
        {"name2", 213},
        {"name3", 1433},
        //... more to follow
        {"nameN", 12837},
    };

    for(size_t i = 0; i < _countof(all_assoc); i++)
    {
        if(strcmp(all_assoc[i].name, pName) == 0)
        {
            nValue = all_assoc[i].value;
            bResult = true;
            break;
        }
    }

    if(pnOutValue)
        *pnOutValue = nValue;

    return bResult;
}

In the example above, the initialization of static const MY_ASSOC all_assoc is never called at run-time. It is entirely processed during the compile-time.

Now if I write something similar in C#:

    public struct NameValue
    {
        public string name;
        public uint value;
    }

    private static readonly NameValue[] g_arrNV_Assoc = new NameValue[] {
        new NameValue() { name = "name1", value = 123 },
        new NameValue() { name = "name2", value = 213 },
        new NameValue() { name = "name3", value = 1433 },
        // ... more to follow
        new NameValue() { name = "nameN", value = 12837 },
    };

    public static bool GetValueForName(string name, out uint nOutValue)
    {
        foreach (NameValue nv in g_arrNV_Assoc)
        {
            if (name == nv.name)
            {
                nOutValue = nv.value;
                return true;
            }
        }

        nOutValue = 0;
        return false;
    }

The line private static readonly NameValue[] g_arrNV_Assoc has to be called once during the host class initialization, and it is done for every single element in that array!

So my question -- can I somehow optimize it so that the data stored in g_arrNV_Assoc array is stored in the PE section and not initialized at run-time?

PS. I hope I'm clear for the .NET folks with my terminology.