O que acontece se eu retornar antes do final da instrução using? O dispose será chamado?

Tenho o seguinte código

using(MemoryStream ms = new MemoryStream())
{
     //code
     return 0;
}

O dispose()método é chamado no final das usingchaves de instrução, }certo? Já que eu returnantes do final do usingenunciado, o MemoryStreamobjeto será descartado corretamente? o que acontece aqui?

Sim, Disposeserá chamado. É chamado assim que a execução sai do escopo do usingbloco, independentemente do meio que levou para sair do bloco, seja o fim da execução do bloco, uma returninstrução ou uma exceção.

Como @Noldorin corretamente aponta, o uso de um usingbloco no código é compilado em try/ finally, Disposesendo chamado no finallybloco. Por exemplo, o seguinte código:

using(MemoryStream ms = new MemoryStream())
{
     //code
     return 0;
}

efetivamente se torna:

MemoryStream ms = new MemoryStream();
try
{
    // code
    return 0;
}
finally
{
    ms.Dispose();
}

Portanto, como finallytem garantia de execução após o trybloco ter concluído a execução, independentemente de seu caminho de execução, Disposeé garantido que será chamado, não importa o quê.

Para obter mais informações, consulte este artigo do MSDN .

Adendo:
apenas uma pequena advertência a ser adicionada: como Disposeé garantido que será chamado, é quase sempre uma boa ideia garantir que Disposenunca lance uma exceção ao implementar IDisposable. Infelizmente, existem algumas classes na biblioteca central que fazer lance em determinadas circunstâncias, quando Disposeé chamado - Eu estou olhando para você, Proxy WCF Serviço de Referência / Cliente! - e quando isso acontece, pode ser muito difícil rastrear a exceção original se ela Disposefoi chamada durante o desenrolamento de uma pilha de exceções, uma vez que a exceção original é engolida em favor da nova exceção gerada pela Disposechamada. Pode ser enlouquecedoramente frustrante. Ou isso é frustrantemente enlouquecedor? Um dos dois. Talvez ambos.

usingas instruções se comportam exatamente como try ... finallyblocos, portanto, sempre serão executadas em quaisquer caminhos de saída de código. No entanto, acredito que eles estão sujeitos às raras e raras situações em que os finallyblocos não são chamados. Um exemplo que posso lembrar é se o encadeamento em primeiro plano sai enquanto os encadeamentos em segundo plano estão ativos: todos os encadeamentos exceto o GC são pausados, o que significa que os finallyblocos não são executados.

Edição óbvia: eles se comportam da mesma forma, independentemente da lógica que os permite manipular objetos ID descartáveis, d'oh.

Conteúdo bônus: eles podem ser empilhados (onde os tipos são diferentes):

using (SqlConnection conn = new SqlConnection("string"))
using (SqlCommand comm = new SqlCommand("", conn))
{

}

E também delimitado por vírgulas (onde os tipos são iguais):

using (SqlCommand comm = new SqlCommand("", conn), 
       SqlCommand comm2 = new SqlCommand("", conn))
{

}

Seu objeto MemoryStream será descartado corretamente, não há necessidade de se preocupar com isso.

Com a usinginstrução, o objeto será descartado independentemente do caminho de conclusão.

Leitura adicional ...

• http://aspadvice.com/blogs/name/archive/2008/05/22/Return-Within-a-C_2300_-Using-Statement.aspx
• http://csharpfeeds.com/post/8451/Return_Within_a_Csharp_Using_Statement.aspx

Dê uma olhada em seu código no reflector depois de compilá-lo. Você descobrirá que o compilador refatora o código para garantir que dispose seja chamado no fluxo.