C# 4.0
Por Fabiano Belmonte

O Visual Studio 2010 e .NET Framework 4,0 em breve estará em fase beta, e
existem alguns novos recursos excelentes que todos nós podemos esperar
animados com este novo lançamento. Juntamente com o Visual Studio 2010 e do.
NET Framework 4,0 veremos a versão 4.0 da linguagem de programação C #.
Neste artigo eu gostaria de olhar um pouco a trás de onde começou a linguagem de
programação C # e olhar para onde Anders Hejlsberg do C # e sua equipe querem
chegar.

Em 1998, o projeto C # começou com o objetivo de criar uma simples, moderna e

orientada a objeto, linguagem de programação que se tornou conhecido como o.
NET. A Microsoft lançou o. NET e a linguagem de programação C #, em meados
2000 e desde então, C # tornou-se uma das mais populares linguagens de
programação em uso hoje. Foi lançado então o C# 1.0

A versão 2.0 da linguagem evoluiu de mais, particularmente acho que e umas das
maiores evoluções em tão pouco tempo de uma linguagem e passou a dar suporte
aos genéricos, métodos anônimos, iterators, tipos parciais e tipos anuláveis.

Ao conceber a versão 3.0 da linguagem a ênfase foi para permitir a LINQ

(Language Integrated Query), que exigia a adição das seguintes funcionalidades:

• Implictly Typed Local Variables.

• Extension Methods.
• Lambda Expressions.
• Object and Collection Initializers.
• Annonymous types.
• Implicitly Typed Arrays.
• Query Expressions and Expression Trees.

No passado linguagens de programação foram projetadas com um determinado

paradigma em mente, e como tal, temos linguagens que foram, como exemplo,
destinadas a serem orientadas a objeto ou funcionais. Hoje, porém, as linguagens
que a ser concebidas com vários paradigmas em mente. Na versão 3.0 da
linguagem de programação C # adquiriu várias capacidades funcionais
normalmente associados a programação para permitir Language Integrated Query
(LINQ).

Na versão 4.0 do C # continua a evoluir, embora desta vez, a equipe do C # foram

inspiradas por linguagens dinâmica como Perl, Python e Ruby. A realidade é que
existem vantagens e desvantagens para ambas as linguagens seja ela escrita
estaticamente e dinamicamente.

Outro paradigma alem do design e inovação é concorrente que é um paradigma

que tem certamente influenciaram o desenvolvimento do Visual Studio 2010 e do.
NET Framework 4.0.

Agora o que o C# traz de novo:

• Dynamically Typed Objects.
• Optional and Named Parameters.
• Improved COM Interoperability.
• Safe Co- and Contra-variance.

Chega de papo e vamos olhar para algum exemplos em C # 4.0 utilizando essas
inovações língua ...

Em C # Hoje você pode ter, o seguinte código que é uma instância de uma classe
escrita estaticamente . NET então chama o método Add em que a classe para obter
a soma de dois inteiros:

Calculator calc = GetCalculator();

int sum = calc.Add(10, 20);

Nosso código fica ainda mais interessante se a classe Calculadora não é escrita
estaticamente, mas está escrito em COM, Ruby, Python, ou mesmo JavaScript.
Mesmo se soubéssemos que a classe é uma calculadora. objeto NET, mas não
sabemos qual o tipo específico que é, então, teria de utilizar reflection para
descobrir atributos e o tipo em tempo de execução e, em seguida, dinamicamente
invocar o método Add.

object calc = GetCalculator();

Type type = calc.GetType();
object result = type.InvokeMember("Add",
BindingFlags.InvokeMethod, null,
new object[] { 10, 20 });
int sum = Convert.ToInt32(result);
Se a calculadora classe foi escrito em JavaScript, então nosso código ficaria algo como a seguinte.
ScriptObect calc = GetCalculator();
object result = calc.InvokeMember("Add", 10, 20);
int sum = Convert.ToInt32(result);
Com C # 4,0 teríamos simplesmente escrever o seguinte código:
dynamic calc = GetCalculator();
int result = calc.Add(10, 20);

No exemplo acima declaramos uma variável calc, cujo tipo estático é dinâmico.
Sim, você leu corretamente que nós escrevemos estaticamente nosso objeto a ser
dinâmico. Teremos então dinâmico usando método invocação para chamar o
método Add e em seguida, dinâmico conversão para converter o resultado da
dinâmica de uma invocação digitado estaticamente inteiro.

Você está ainda encorajado a usar tipagem estática sempre que possível, porque os
benefícios que oferecem línguas escrita estaticamente nós. Usando C # 4,0 no
entanto, deve ser menos doloroso nessas ocasiões em que você tem de interagir
com objetos dinamicamente digitado.
Outro grande benefício do uso de C # 4.0 é que a linguagem suporta agora
facultativa e parâmetros nomeados e por isso vamos agora dar uma olhada em
como esta característica irá mudar a maneira de conceber e escrever o seu código.
Um desenho padrão você ver como muitas vezes que um determinado método está
sobrecarregado, porque o método deve ser chamado com um número variável de
parâmetros.

Vamos assumir que temos o seguinte método OpenTextFile juntamente com três
sobrecargas do método com diferentes assinaturas. Sobrecargas do método
primário em seguida chame o método primário de passar os valores padrão no
lugar desses parâmetros para os quais um valor não foi especificado na chamada
para o método sobrecarregado.

public StreamReader OpenTextFile(

string path,
Encoding encoding,
bool detectEncoding,
int bufferSize) { }
public StreamReader OpenTextFile(
string path,
Encoding encoding,
bool detectEncoding) { }
public StreamReader OpenTextFile(
string path,
Encoding encoding) { }
public StreamReader OpenTextFile(string path) { }

No C # 4.0 O método primário pode ser refactored para usar parâmetros opcionais
como mostra o seguinte exemplo:

public StreamReader OpenTextFile(

string path,
Encoding encoding = null,
bool detectEncoding = false,
int bufferSize = 1024) { }

Perante esta declaração, é agora possível chamar o método OpenTextFile omitindo

um ou mais dos parâmetros opcionais.

OpenTextFile("foo.txt", Encoding.UTF8);

Também é possível usar o C # 4,0 suporte para parâmetros nomeados e, como tal,
o método pode ser chamado OpenTextFile omitindo um ou mais dos parâmetros
opcionais, enquanto especificando também outro parâmetro pelo nome.

OpenTextFile("foo.txt", Encoding.UTF8, bufferSize: 4098);

O nome dos argumentos deve ser fornecido somente estância última embora desde
quando eles podem ser fornecidas em qualquer ordem.

Se você alguma vez escrito qualquer código que executa um certo grau de
interoperabilidade COM você provavelmente visto como o código seguinte.

object filename = "test.docx";

object missing = System.Reflection.Missing.Value;
doc.SaveAs(ref filename,
 ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing);

Com os parâmetros opcionais e nomeado linguagem C # 4,0 prevê melhorias

significativas na interoperabilidade COM e, portanto, o código acima pode agora ser
refactored tal que o convite é apenas:

doc.SaveAs("foo.txt");

Ao realizar a interoperabilidade COM você perceber que você é capaz de omitir a ref
modifer embora o uso do modificador ref ainda é necessário quando não exerçam
COM interoperabilidade.

Com as versões anteriores das tecnologias era necessário também um navio

Primary Interop Assembly (PIA), juntamente com o seu aplicativo gerenciado. Isso
não é necessário quando se utiliza C # 4.0, porque o compilador irá injetar vez o
interop tipos diretamente para as Assembly de seu aplicativo gerenciado e só vai
injetar os tipos que você está usando e não de todos os tipos encontrados no
interior da PIA.

O último aperfeiçoamento lingüístico que vamos explorar é co-variância e contra-

variância e vamos começar por explorar com a co-variância. NET matrizes.

string[] names = new string[] {

"Anders Hejlsberg",
"Mads Torgersen",
"Scott Wiltamuth",
"Peter Golde" };
Write(names);

Desde versão 1.0 em um array o. NET Framework foi co-variante significando que
uma matriz de strings, por exemplo, pode ser passada para um método que espera
um array de objetos. Como tal, a matriz acima pode ser transmitida para o
seguinte Escreve método que espera um array de objetos.

private void Write(object[] objects)

{
}

Infelizmente, em matrizes. NET não são co-seguro variante como podemos ver na
seguinte código. Partindo do pressuposto de que os objetos variável é uma matriz
de strings da seguinte terá êxito.

objects[0] = "Hello World";

Embora se uma tentativa é feita para atribuir um inteiro à matriz de strings uma
ArrayTypeMismatchException é jogado.

objects[0] = 1024;
Em ambos os C # 2.0 e C # 3,0 invariantes são genéricos e, portanto, um erro
compilador iria resultar o seguinte código:

List<string> names = new List<string>();

Write(names);

Quando o Escreve método é definido como:

public void Write(IEnumerable<object> objects) { }

Generics com C # 4,0 apoiar agora segura co-variância e contra-variância através

do uso das palavras-chave dentro e fora contextuais. Vamos dar uma olhada em
como isso muda a definição do <T> IEnumerable e IEnumerator <T> interfaces.
public interface IEnumerable<out T>

{
IEnumerator<T> GetEnumerator();
}
public interface IEnumerator<out T>
{
T Current { get; }
bool MoveNext();
}

Você perceberá que o tipo de parâmetro T da interface IEnumerable foi prefixado

com o fora contextuais palavra-chave. Dado que a interface IEnumerable é
somente leitura, não há capacidade especificada na interface para inserir novos
elementos com a lista, ela é segura para o tratamento de algo mais derivados como
algo menos derivados. Com a palavra-chave fora contextuais estamos afirmando
que contratualmente IEnumerable <out T> segurança é co-variante. Dado que
IEnumerable <out T> segurança é co-variante podemos agora escrever o seguinte
código:

IEnumerable<string> names = GetTeamNames();

IEnumerable<object> objects = names;

Porque a interface IEnumerable <out T> utiliza a palavra-chave no contexto do

compilador podem motivo que a atribuição acima é seguro.

Utilizando a palavra-chave no contexto podemos alcançar seguro contra-variância,

ou seja, tratar algo menos derivados como algo mais derivados.

public interface IComparer<in T>

{
int Compare(T x, T y);
}

Dado que IComparer <in T> é segura contra-variante podemos agora escrever o seguinte código:

IComparer<object> objectComparer = GetComparer();

IComparer<string> stringComparer = objectComparer;

Embora o actual build CTP do Visual Studio 2010 e do. NET Framework 4,0 tem
suporte limitado para a variância melhorias em C # 4,0 a próxima versão beta
permite que você use o novo para dentro e para fora contextuais tais como
palavras-chave em tipos IComparer <in T>. O. NET Framework equipa está a
atualizar os tipos, no âmbito de ser co-seguro e contra-variante.

Eu mostrei aqui alguns recursos que você pode achar útil para explorar as
capacidades da linguagem de programação C # 4,0 e gostaria de encorajá-lo a
também fazer download e instalar a versão beta.

Bons Códigos...

Artigo cedido pelo autor.

Leia mais em http://www.linhadecodigo.com.br/Colaborador.aspx?id=555