C# 4.0

Nesse artigo serão mostrados 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.

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 equipa 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 clase 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...