Existe uma desvantagem no uso do AggressiveInlining em propriedades simples?

Aposto que eu mesmo poderia responder se soubesse mais sobre as ferramentas para analisar como o C # / JIT se comporta, mas como não o faço, por favor, pergunte.

Eu tenho um código simples como este:

    private SqlMetaData[] meta;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private SqlMetaData[] Meta
    {
        get
        {
            return this.meta;
        }
    }

Como você pode ver, eu coloquei AggressiveInlining porque acho que deveria estar embutido.
Eu acho que. Não há garantia de que o JIT incluiria o contrário. Estou errado?

Poderia fazer esse tipo de coisa prejudicar o desempenho / estabilidade / qualquer coisa?

Compiladores são bestas inteligentes. Geralmente, eles extraem automaticamente o máximo de desempenho possível de qualquer lugar que puderem.

Tentar enganar o compilador geralmente não faz uma grande diferença e tem muitas chances de sair pela culatra. Por exemplo, inlining torna seu programa maior, pois duplica o código em todos os lugares. Se sua função for usada em muitos lugares ao longo do código, poderá ser prejudicial, como apontado @CodesInChaos. Se for óbvio que a função deve ser incorporada, você pode apostar que o compilador fará isso.

Em caso de hesitação, você ainda pode fazer as duas coisas e comparar se houver algum ganho de desempenho, essa é a única maneira certa até agora. Mas minha aposta é que a diferença será negligenciável, o código fonte será apenas "mais barulhento".

Você está certo - não há como garantir que o método seja incorporado - Enumeração MSDN MethodImplOptions , SO MethodImplOptions.AggressiveInlining vs TargetedPatchingOptOut .

Os programadores são mais inteligentes que um compilador, mas trabalhamos em um nível superior e nossas otimizações são produtos do trabalho de um homem - o nosso. Jitter vê o que está acontecendo durante a execução. Ele pode analisar o fluxo de execução e o código de acordo com o conhecimento colocado por seus projetistas. Você pode conhecer melhor o seu programa, mas eles conhecem melhor o CLR. E quem será mais correto em suas otimizações? Não sabemos ao certo.

É por isso que você deve testar qualquer otimização que fizer. Mesmo que seja muito simples. E leve em consideração que o ambiente pode mudar e sua otimização ou des otimização pode ter um resultado inesperado.

Edição: Eu sei que a minha resposta não respondeu exatamente a pergunta, embora não haja desvantagem real, dos meus resultados de tempo também não há vantagem real. A diferença entre um getter de propriedades embutido é de 0,002 segundos em 500 milhões de iterações. Meu caso de teste também pode não ser 100% exato, pois está usando uma estrutura, porque existem algumas ressalvas no jitter e alinhamento com estruturas.

Como sempre, a única maneira de realmente saber é escrever um teste e descobrir. Aqui estão meus resultados com a seguinte configuração:

Windows 7 Home  
8GB ram  
64bit os  
i5-2300 2.8ghz  

Projeto vazio com as seguintes configurações:

.NET 4.5  
Release mode  
Start without debugger attached - CRUCIAL  
Unchecked "Prefer 32-bit" under project build settings  

Resultados

struct get property                               : 0.3097832 seconds
struct inline get property                        : 0.3079076 seconds
struct method call with params                    : 1.0925033 seconds
struct inline method call with params             : 1.0930666 seconds
struct method call without params                 : 1.5211852 seconds
struct intline method call without params         : 1.2235001 seconds

Testado com este código:

class Program
{
    const int SAMPLES = 5;
    const int ITERATIONS = 100000;
    const int DATASIZE = 1000;

    static Random random = new Random();
    static Stopwatch timer = new Stopwatch();
    static Dictionary<string, TimeSpan> timings = new Dictionary<string, TimeSpan>();

    class SimpleTimer : IDisposable
    {
        private string name;
        public SimpleTimer(string name)
        {
            this.name = name;
            timer.Restart();
        }

        public void Dispose()
        {
            timer.Stop();
            TimeSpan ts = TimeSpan.Zero;
            if (timings.ContainsKey(name))
                ts = timings[name];

            ts += timer.Elapsed;
            timings[name] = ts;
        }
    }

    [StructLayout(LayoutKind.Sequential, Size = 4)]
    struct TestStruct
    {
        private int x;
        public int X { get { return x; } set { x = value; } }
    }


    [StructLayout(LayoutKind.Sequential, Size = 4)]
    struct TestStruct2
    {
        private int x;

        public int X
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get { return x; }
            set { x = value; }
        }
    }

    [StructLayout(LayoutKind.Sequential, Size = 8)]
    struct TestStruct3
    {
        private int x;
        private int y;

        public void Update(int _x, int _y)
        {
            x += _x;
            y += _y;
        }
    }

    [StructLayout(LayoutKind.Sequential, Size = 8)]
    struct TestStruct4
    {
        private int x;
        private int y;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Update(int _x, int _y)
        {
            x += _x;
            y += _y;
        }
    }

    [StructLayout(LayoutKind.Sequential, Size = 8)]
    struct TestStruct5
    {
        private int x;
        private int y;

        public void Update()
        {
            x *= x;
            y *= y;
        }
    }

    [StructLayout(LayoutKind.Sequential, Size = 8)]
    struct TestStruct6
    {
        private int x;
        private int y;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Update()
        {
            x *= x;
            y *= y;
        }
    }

    static void RunTests()
    {
        for (var i = 0; i < SAMPLES; ++i)
        {
            Console.Write("Sample {0} ... ", i);
            RunTest1();
            RunTest2();
            RunTest3();
            RunTest4();
            RunTest5();
            RunTest6();
            Console.WriteLine(" complate");
        }
    }

    static int RunTest1()
    {
        var data = new TestStruct[DATASIZE];
        var temp = 0;
        unchecked
        {
            //init the data, just so jitter can't make assumptions
            for (var j = 0; j < DATASIZE; ++j)
                data[j].X = random.Next();

            using (new SimpleTimer("struct get property"))
            {
                for (var j = 0; j < DATASIZE; ++j)
                {
                    for (var i = 0; i < ITERATIONS; ++i)
                    {
                        //use some math to make sure its not optimized out (aka don't use an incrementor)
                        temp += data[j].X;
                    }
                }
            }
        }
        //again need variables to cross scopes to make sure the jitter doesn't do crazy optimizations
        return temp;
    }

    static int RunTest2()
    {
        var data = new TestStruct2[DATASIZE];
        var temp = 0;
        unchecked
        {
            //init the data, just so jitter can't make assumptions
            for (var j = 0; j < DATASIZE; ++j)
                data[j].X = random.Next();

            using (new SimpleTimer("struct inline get property"))
            {
                for (var j = 0; j < DATASIZE; ++j)
                {
                    for (var i = 0; i < ITERATIONS; ++i)
                    {
                        //use some math to make sure its not optimized out (aka don't use an incrementor)
                        temp += data[j].X;
                    }
                }
            }
        }
        //again need variables to cross scopes to make sure the jitter doesn't do crazy optimizations
        return temp;
    }

    static void RunTest3()
    {
        var data = new TestStruct3[DATASIZE];
        unchecked
        {
            using (new SimpleTimer("struct method call with params"))
            {
                for (var j = 0; j < DATASIZE; ++j)
                {
                    for (var i = 0; i < ITERATIONS; ++i)
                    {
                        //use some math to make sure its not optimized out (aka don't use an incrementor)
                        data[j].Update(j, i);
                    }
                }
            }
        }
    }

    static void RunTest4()
    {
        var data = new TestStruct4[DATASIZE];
        unchecked
        {
            using (new SimpleTimer("struct inline method call with params"))
            {
                for (var j = 0; j < DATASIZE; ++j)
                {
                    for (var i = 0; i < ITERATIONS; ++i)
                    {
                        //use some math to make sure its not optimized out (aka don't use an incrementor)
                        data[j].Update(j, i);
                    }
                }
            }
        }
    }

    static void RunTest5()
    {
        var data = new TestStruct5[DATASIZE];
        unchecked
        {
            using (new SimpleTimer("struct method call without params"))
            {
                for (var j = 0; j < DATASIZE; ++j)
                {
                    for (var i = 0; i < ITERATIONS; ++i)
                    {
                        //use some math to make sure its not optimized out (aka don't use an incrementor)
                        data[j].Update();
                    }
                }
            }
        }
    }

    static void RunTest6()
    {
        var data = new TestStruct6[DATASIZE];
        unchecked
        {
            using (new SimpleTimer("struct intline method call without params"))
            {
                for (var j = 0; j < DATASIZE; ++j)
                {
                    for (var i = 0; i < ITERATIONS; ++i)
                    {
                        //use some math to make sure its not optimized out (aka don't use an incrementor)
                        data[j].Update();
                    }
                }
            }
        }
    }

    static void Main(string[] args)
    {
        RunTests();
        DumpResults();
        Console.Read();
    }

    static void DumpResults()
    {
        foreach (var kvp in timings)
        {
            Console.WriteLine("{0,-50}: {1} seconds", kvp.Key, kvp.Value.TotalSeconds);
        }
    }
}

Os compiladores fazem muitas otimizações. Inlining é um deles, quer o programador queira ou não. Por exemplo, MethodImplOptions não tem uma opção "embutido". Porque o embutimento é feito automaticamente pelo compilador, se necessário.

Muitas outras otimizações são feitas especialmente se ativadas nas opções de compilação, ou o modo "release" fará isso. Mas essas otimizações são do tipo "funcionou para você, ótimo! Não funcionou, deixe" otimizações e geralmente oferecem melhor desempenho.

[MethodImpl(MethodImplOptions.AggressiveInlining)]

é apenas um sinalizador para o compilador de que uma operação embutida é realmente necessária aqui. Mais informações aqui e aqui

Para responder sua pergunta;

Não há garantia de que o JIT incluiria o contrário. Estou errado?

Verdade. Nenhuma garantia; Nem o C # tem uma opção "forçar a inclusão".

Poderia fazer esse tipo de coisa prejudicar o desempenho / estabilidade / qualquer coisa?

Nesse caso, não, como é dito em Gravando aplicativos gerenciados de alto desempenho: uma cartilha

Os métodos get e set de propriedade geralmente são bons candidatos para inlining, pois tudo o que eles fazem é normalmente inicializar membros de dados privados.