C Sharp

Origem: Wikipédia, a enciclopédia livre.
(Redirecionado de C♯)
Ir para: navegação, pesquisa

Nota: O título correto deste artigo é C#. A substituição ou omissão do sinal # se deve por restrições técnicas.

C♯
Paradigma Orientação a objetos
estruturado
imperativo
Surgido em 2001
Última versão 5.0 (15 de agosto de 2012)
Criado por Microsoft
Estilo de tipagem: estática e dinâmica, forte, segura e insegura
Compiladores .NET Framework, Mono, DotGNU
Dialetos:
Influenciada por Java,[1] C++, Eiffel, Modula-3, Object Pascal[2]
Influenciou D, F♯, Fantom, Java 5,[3] Nemerle, Vala
Licença: Domínio público / CLR Proprietária
Página oficial msdn.microsoft.com

C♯, também escrito como C# ou C Sharp (em português lê-se "cê charp"), é uma linguagem de programação orientada a objetos, fortemente tipada, desenvolvida pela Microsoft como parte da plataforma .NET. A sua sintaxe orientada a objetos foi baseada no C++ mas inclui muitas influências de outras linguagens de programação, como Object Pascal e Java.

História[editar | editar código-fonte]

Anders Hejlsberg - criador do C#.

A linguagem C# faz parte do conjunto de ferramentas oferecidas na plataforma .NET e surge como uma linguagem simples, robusta, orientada a objetos, fortemente tipada e altamente escalável a fim de permitir que uma mesma aplicação possa ser executada em diversos dispositivos de hardware, independentemente destes serem PCs, handhelds ou qualquer outro dispositivo móvel.

O avanço das ferramentas de programação e dos dispositivos eletrônicos inteligentes, criou problemas e novas exigências. As novas versões de componentes compartilhados eram incompatíveis com o software antigo. Os desenvolvedores reconheceram a necessidade de software que fosse acessível para qualquer um e disponível por meio de praticamente qualquer tipo de dispositivo. Para tratar dessas necessidades, a Microsoft anunciou sua iniciativa .NET e a linguagem de programação C#.[4]

Durante o desenvolvimento da plataforma .NET, as bibliotecas foram escritas originalmente numa linguagem chamada Simple Managed C (SMC), que tinha um compilador próprio. Mas, em Janeiro de 1999, uma equipe de desenvolvimento foi formada por Anders Hejlsberg, que fora escolhido pela Microsoft para desenvolver a linguagem. Dá-se inicio à criação da linguagem chamada Cool. Um pouco mais tarde, em 2000, o projeto .NET era apresentado ao público na Professional Developers Conference (PDC), e a linguagem Cool fora renomeada e apresentada como C#.

A criação da linguagem, embora tenha sido feita por vários programadores, é atribuída principalmente a Anders, hoje um Distinguished Engineer na Microsoft. Ele fora o arquiteto de alguns compiladores da Borland, e entre suas criações mais conhecidas estão o Turbo Pascal e o Delphi.

A Microsoft submeteu o C# à ECMA para uma padronização formal. Em Dezembro de 2001 a associação liberou a especificação ECMA-334 Especificação da Linguagem C#. Em 2003 tornou-se um padrão ISO (ISO/IEC 23270). Há algumas implementações em desenvolvimento, destacando-se a Mono, implementação open source da Novell, o dotGNU e o Portable.NET, implementações da Free Software Foundation, e o BDS 2008, implementação da CodeGear.

Etimologia[editar | editar código-fonte]

A nota sustenido em clave de sol.

Pensava-se que o nome C# viria duma sobreposição de quatro símbolos +, dando a impressão de ++++, uma alusão à continuação do C++. Entretanto, o # de C# se refere ao sinal musical sustenido (♯), pronunciado sharp em inglês, que aumenta em meio tom uma nota musical.[5]

Porém, devido a limitações técnicas (fontes padrões, navegadores, etc) e o fato do símbolo do sustenido (♯) não estar presente nos teclados, o cerquilha (#) foi escolhido para ser usado no nome escrito.[6] Essa convenção é refletida no ECMA-334 C# Language Specification, a especificação técnica da linguagem.[7] Entretanto, em determinados lugares, como em propagandas e capas de livros, é usado o símbolo sustenido.[8]

Características[editar | editar código-fonte]

O C# é uma linguagem de programação visual dirigida por eventos e totalmente orientada a objetos. Permite um novo grau de intercâmbio entre linguagens (componentes de software de diferentes linguagens podem interagir). Os desenvolvedores podem empacotar até software antigo, para trabalhar com novos programas C#. Além disso, os aplicativos C# podem interagir pela Internet usando padrões do setor, como SOAP (protocolo de acesso a objetos simples) e XML (linguagem de marcação extensível).

O C# tem raízes em C, C++ e Java, adaptando os melhores recursos de cada linguagem e acrescentando novas capacidades próprias. Ele fornece os recursos que são mais importantes para os programadores, como programação orientada a objetos,strings, elementos gráficos, componentes de interface com o usuário gráfica (GUI), tratamento de exceções, múltiplas linhas de execução, multimídia (áudio, imagens, animação e vídeo), processamento de arquivos, estruturas de dados pré-empacotadas, processamento de banco de dados, redes cliente/servidor com base na Internet e na World Wide Web e computação distribuída.

Principais características do C#[editar | editar código-fonte]

Dentre as características essenciais do C# podemos citar:

  • Simplicidade: os projetistas de C# costumam dizer que essa linguagem é tão poderosa quanto o C++ e tão simples quanto o Visual Basic;
  • Completamente orientada a objetos: em C#, qualquer variável tem de fazer parte de uma classe;
  • Fortemente tipada: isso ajudará a evitar erros por manipulação imprópria de tipos e atribuições incorretas;
  • Gera código gerenciado: assim como o ambiente .NET é gerenciado, assim também é o C#;
  • Tudo é um objeto: System.Object é a classe base de todo o sistema de tipos de C#;
  • Controle de versões: cada assembly gerado, seja como EXE ou DLL, tem informação sobre a versão do código, permitindo a coexistência de dois assemblies homônimos, mas de versões diferentes no mesmo ambiente;
  • Suporte a código legado: o C# pode interagir com código legado de objetos COM e DLLs escritas em uma linguagem não-gerenciada;
  • Flexibilidade: se o desenvolvedor precisar usar ponteiros, o C# permite, mas ao custo de desenvolver código não-gerenciado, chamado “unsafe”;
  • Linguagem gerenciada: os programas desenvolvidos em C# executam num ambiente gerenciado, o que significa que todo o gerenciamento de memória é feito pelo runtime via o GC (Garbage Collector).[9]

Tipos de dados[editar | editar código-fonte]

Os tipos de dados em C# são tipos de valor ou tipos de referência. Uma variável de tipo de valor contém dados desse tipo. Uma variável de tipo de referência contém o endereço da localização na memória em que os dados estão armazenados. Os tipos de valor normalmente representam dados simples, como valores int ou bool. Os tipos de referência, por outro lado, se referem a objetos, os quais podem conter muitos dados individuais. Os tipos de valor internos são os tipos integrais, os tipos de ponto flutuante e os tipos decimal e bool. Os tipos de referência internos são string e object. Os programadores também podem criar tipos de valor e tipos de referência. Os tipos de referência que os programadores podem criar são classes, interfaces e delegados. Existem dois tipos de conversões no C#: implícita e explícita. Segundo seu escopo e disponibilidade, as variáveis podem ser do tipo Static (o valor fica disponível para todos os objetos da classe em que a variável foi declarada), Instance (criada na memória cada vez que instanciamos um novo objeto) e Array (grupo de elementos do mesmo tipo de dado).

Classes[editar | editar código-fonte]

Em C#, a unidade de programação é a classe. Os objetos são eventualmente instanciados (criados) dessas classes, e as funções são encapsuladas dentro dos “limites” das classes como métodos. Definições de classe C# não necessitam de arquivos de cabeçalho ou arquivos separados (IDL, Interface Definition Language). Também permite interfaces, um meio de fazer um contrato com uma classe para processos que a interface determina. No C#, uma classe pode herdar de apenas um objeto pai (parent), mas uma classe pode implementar múltiplas interfaces. C# proporciona também um suporte a structs (estruturas). C# proporciona suporte total de delegates (delegados): para invocação de métodos indiretamente. Delegates são referência de tipos seguros que encapsulam métodos com assinaturas e tipos de retorno específicos.[10]

Classe Console[editar | editar código-fonte]

A classe Console, do namespace System, fornece suporte básico para leitura e escrita de caracteres. Os principais métodos usados para essas funcionalidades são:

  • Write: escreve uma informação específica em tela.
  • WriteLine: escreve uma informação específica em tela e pula uma linha em seguida.
  • ReadLine: captura uma linha de texto digitada pelo usuário e retorna seu valor na forma de string.
  • ReadKey: captura um único caracter digitado pelo usuário. O retorno desse método é um objeto da classe ConsoleKeyInfo, que contém informações sobre a tecla digitada pelo usuário.
  • Clear: esse método limpa toda a tela do console. Útil para programas que exigem formatação dos resultados.

Classe Convert[editar | editar código-fonte]

Ao utilizar o método ReadLine da classe Console, obtemos informação do usuário no formato string. Muita vezes precisamos converter o texto lido para outro tipo. Neste caso, podemos usar a Classe Convert, que fornece diversos métodos para conversão entre os tipos básicos de dados. Exemplo:

int num;
string texto =2;
num = Convert.ToInt32 (texto);

Propriedades[editar | editar código-fonte]

Uma propriedade é o atributo de uma classe (o tamanho de uma string, por exemplo). Propriedades não denotam localizações de armazenamento mas contém declarações executáveis que são usadas para ler ou escrever o valor da propriedade. As propriedades podem ser dos tipos:

  • static: usamos o modificador static. Não podemos nos referir a uma propriedade static usando this. Usamos apenas seu nome.
  • instance: é a propriedade padrão.

Os acessores das propriedades são declarações executáveis que lêem ou escrevem o valor de uma propriedade. São eles o get (é um método sem nenhum parâmetro que retorna o valor da propriedade) e set (método que atribui o valor em uma propriedade).

Métodos[editar | editar código-fonte]

Método é um membro de uma classe que permite implementar uma ação. Consiste de um cabeçalho (contém um atributo, um modificador, um tipo de retorno, um nome do membro e uma lista formal de parâmetros) e um corpo (bloco de declarações). O C# inclui 8 modificadores: [11]

new O modificador new em um método indica que o método
derivado é planejado para esconder o método base
public É usado para garantir que um método é acessado por todas
as classes sem qualquer restrição
static O modificador static indica que o método pertence somente
ao tipo static e não pode referir-se a métodos non-static ou variáveis em uma classe
virtual É usado quando a implementação de um método pode ser mudada por classes derivadas
sealed Em um método, previne uma classe derivada sobrescrever um método
override É usado para modificar um método de uma classe base na classe derivada
abstract Em um método, indica que o método não contém implementação
extern Indica que o método é implementado externamente

Os métodos da classe Math permitem que o programador efetue certos cálculos matemáticos comuns. Os métodos são chamados escrevendo-se o nome do método, seguido de um parêntese de abertura, do argumento (ou uma lista de argumentos separados por vírgulas) do método e um parêntese de fechamento. Exemplo: para calcular e imprimir a raiz quadrada de 900.0 podemos escrever:

Console.WriteLine ( Math.Sqrt ( 900.0 ) ) ;

O C# permite que vários métodos de mesmo nome sejam definidos na mesma classe, desde que esses métodos tenham diferentes conjuntos de parâmetros (número, tipos ou ordem dos parâmetros). Isso é chamado sobrecarga de métodos. Quando um método sobrecarregado é chamado, o compilador C# seleciona o método correto examinando o número, os tipos e a ordem dos argumentos da chamada.

Delegates[editar | editar código-fonte]

É um elemento que permite que você faça referência a um método. É semelhante a um ponteiro de função, mas sua diferença se baseia em ser totalmente orientado a objetos encapsulando a instância de método ou objeto.[12]

O objeto de delegação pode ser passado para o código que pode chamar o método referenciado sem ter que saber em tempo de compilação qual método será chamado. Usando delegates você tem a flexibilidade para implementar qualquer funcionalidade em tempo de execução. A única restrição é que o método seja compatível com o tipo de declaração do delegate, usando assim perfeitamente invocação anônima. Delegates possuem a seguintes propriedades:

  • São como Ponteiros em C++, mas são do tipo seguro;
  • Permitem métodos para serem passados por parâmetros;
  • Podem ser usados para definir métodos callback.[13]

Exemplo:

// Declare delegate -- defines required signature:
delegate double MathAction (double num);
class DelegateTest
{
// Regular method that matches signature:
static double Double(double input)
 {
return input * 2;
 }
static void Main()
{
// Instantiate delegate with named method:
MathAction ma = Double;
// Invoke delegate ma:
double multByTwo = ma(4.5);
Console.WriteLine("multByTwo: {0}", multByTwo);
// Instantiate delegate with anonymous method:
MathAction ma2 = delegate(double input)
{
return input * input;
     };
double square = ma2(5);
Console.WriteLine("square: {0}", square);
// Instantiate delegate with lambda expression
MathAction ma3 = s => s * s * s;
double cube = ma3(4.375);
Console.WriteLine("cube: {0}", cube);
}
// Output:
// multByTwo: 9
// square: 25
// cube: 83.740234375
}

Passagem de parâmetros[editar | editar código-fonte]

Os tipos de parâmetros são quatro:

  • valor: corresponde a uma variável local que recebe seu valor inicial do argumento fornecido quando um método é chamado. Isto acontece porque um parâmetro de valor declarado em um método refere-se à localização da memória diferente daquela do argumento chamado em um método.
  • referência: um parâmetro declarado com o modificador ref é chamado de parâmetro de referência. Diferente do parâmetro de valor, o parâmetro de referência não cria uma nova localização na memória. Refere-se à mesma localização de memória do argumento chamado em um método.
  • saída: um parâmetro declarado com o modificador out é um parâmetro de saída. Parâmetros de saída são usados em métodos que retornam vários valores. Refere-se à mesma localização de memória do argumento chamado em um método. É necessário atribuir um parâmetro de saída antes do método retornar um valor.
  • params: um parâmetro params pode ser um array de única dimensão ou um array de várias dimensões.

Namespace[editar | editar código-fonte]

A palavra-chave de namespace é usada para declarar um escopo que contém um conjunto de objetos relacionados. Você pode usar um namespace para organizar elementos de código e para criar globalmente tipos exclusivos.[14] [15] [16] [17] [18]

Namespaces possuem as principais propriedades:

  • Usados para organizar códigos de grandes projetos;
  • A diretiva using evita a necessidade de especificar o nome para cada classe;
  • Há sempre um namespace global que faz referência ao namespace System do .Netframework.

Enum[editar | editar código-fonte]

Enum em C# é usado para declarar uma enumeração, um tipo distinto que consiste em um conjunto de constantes nomeados lista de enumerador.

Usados geralmente dentro de namespace para ser visível para acesso das classes e usados dentro de classes e structs, sendo considerados constantes numéricas.

Por característica começa com 0 mas pode ser inicializado com outro valor.

Não devem conter espaço em branco em seu nome. E principalmente: se for atribuído a uma variável, deve ser feita uma conversão explícita do tipo enum para o tipo da variável tratada. Exemplo:

public class EnumTest2
{
enum Range : long { Max = 2147483648L, Min = 255L };
static void Main()
{
long x = (long)Range.Max;
long y = (long)Range.Min;
Console.WriteLine("Max = {0}", x);
Console.WriteLine("Min = {0}", y);
 }
}
/* Saída:
Max = 2147483648
Min = 255
*/

Interface[editar | editar código-fonte]

Interfaces pertencem aos tipos de referência, em que definem contratos que são implementados por uma classe ou estrutura (que a utiliza para simular herança já que não oferece suporte para herdar outra estrutura). Uma classe pode implementar múltiplas interfaces.[19] [20]

Uma Interface pode conter métodos, propriedades, eventos e indexadores, mas não pode implementar seus métodos.

Principais Propriedades:

  • Uma interface é como uma classe base abstrata. Qualquer classe ou estrutura que implementa a interface deve implementar todos os seus membros;
  • Uma interface não pode ser instanciada diretamente. Seus membros são implementados por qualquer classe ou estrutura que implementa a interface;
  • Interfaces podem conter eventos, indexadores, métodos, propriedades;
  • As interfaces não contêm qualquer implementação dos métodos;
  • Uma classe ou estrutura pode implementar interfaces múltiplas. Uma classe pode herdar uma classe base e também implementar uma ou mais interfaces.
interface ISampleInterface
{
void SampleMethod();
}
class ImplementationClass : ISampleInterface
{
// implementação explícita do membro da interface:
void ISampleInterface.SampleMethod()
{
// Implementação do Método.
 }
static void Main()
 {
// Instância da interface.
ISampleInterface obj = new ImplementationClass();
// Chamada do membro.
obj.SampleMethod();
}
}

Iterador[editar | editar código-fonte]

Iteradores são utilizados para percorrer uma coleção de dados como uma lista.

O método iterator é um get personalizado para coleções, em C# usa-se a declaração de produzir retorno de um elemento de cada vez, como o operador yield return recordando o local atual do código e retornando a executar no mesmo local para a próxima iteração.

Por meio do foreach um iterator pode retornar mais de um valor até o fim do bloco ou quando o comando yield break for encontrado. Seus tipos de retorno mais usados são: IEnumerable, IEnumerable<T>, IEnumerator ou IEnumerator<T>.

Exemplo:

static void Main()
{
foreach (int number inSomeNumbers())
 {
Console.Write(number.ToString() + " ");
 }
// Saída: 3 5 8
Console.ReadKey();
}
public static System.Collections.IEnumerableSomeNumbers()
{
yieldreturn 3;
yieldreturn 5;
yieldreturn 8;
}

Recursos Visual Studio[editar | editar código-fonte]

Sendo a principal IDE de desenvolvimento C# junto ao .NetFramework para compilação dos projetos, a IDE foi evoluindo junto à linguagem, dando suporte para desenvolvimento de outras linguagens como VB, C++, ASP.NET, e arquivos de sistemas DLLs.

C# 1.2 trouxe junto com a atualização do .NetFramework 1.1 a possibilidade de desenvolvimento mobile por meio de recursos ASP.NET, o que foi a primeira grande mudança da linguagem.

Principais comandos[editar | editar código-fonte]

  • if : executa um bloco de código com base no valor de uma expressão booleana;
  • goto : transfere o controle para uma estrutura de comandos que é identificada por um rótulo;
  • while : executa condicionalmente o código dentro do bloco while zero ou mais vezes;
  • do...while : executa condicionalmente o código dentro do do uma ou mais vezes;
  • for : seu uso é recomendado quando sabemos a quantidade de repetições que devemos mostrar no console;
  • foreach : percorre cada um dos elementos de um array;
  • switch : executa o bloco de código que é associado com o valor da expressão de controle.

Coleções[editar | editar código-fonte]

Coleções são grupos de objetos de tipos semelhantes. O gerenciamento da quantidade de objetos que as compõem é feito internamente nas coleções; por sua vez, quando usamos um array o seu tamanho precisa ser gerenciado pelo programador. No namespace collections, encontramos uma série de coleções predefinidas a partir das quais podemos criar nossas próprias coleções. Além disso, neste namespace podemos encontrar a implementação de estruturas de dados como pilhas, listas, listas ordenadas, filas, e todas são implementadas usando coleções. Algumas classes membros do namespace System.Collections:

  • ArrayList: usa um array cujo tamanho é incrementado dinamicamente conforme necessário;
  • CollectionBase: usada como classe para implementar coleções fortemente tipadas;
  • Queue: coleção de objetos que implementa uma fila do tipo “primeiro a entrar, primeiro a sair”;
  • SortedList: coleção que implementa uma lista ordenada;
  • Stack: coleção de objetos que implementa uma pilha (último a entrar, primeiro a sair).

Exceptions – Exceções[editar | editar código-fonte]

Exceções em C# fornecem uma maneira estruturada, uniforme e segura de manipulação, tanto em nível de sistema e erros condicionais de aplicação. Exceptions em C# são similares a Exceções em C++, mas com algumas importantes diferenças:

  • Em C#, todas as exceptions representam um instância de classe derivada de System.Exception. Em C++, qualquer valor de qualquer tipo pode ser usado para representar uma exceção.
  • Em C# o Bloco finally pode ser escrito ao final do código para executar em ambas as situações de exceção ou execução normal. Em C++ é difícil escrever sem duplicar códigos.

Exceções possuem as principais propriedades:

  • Um Bloco try em torno de uma instrução pode lançar exceções;
  • Após a execução do bloco try, o fluxo de controle vai para o primeiro manipulador de exceção associado que está presente em qualquer lugar na pilha de chamadas. O catch é usado para definir o manipulador de exceção;
  • Se nenhum manipulador de exceção para uma determinada exceção estiver presente, o programa apresenta erro.

Exceções podem ser explicitamente geradas por um programa usando a palavra-chave throw.

Exemplo:

static void TestCatch2()
{
System.IO.StreamWritersw = null;
try
 {
sw = newSystem.IO.StreamWriter(@"C:\test\test.txt");
sw.WriteLine("Hello");
 }
catch (System.IO.FileNotFoundException ex)
 {
// Put the more specific exception first.
System.Console.WriteLine(ex.ToString()); 
 }
catch (System.IO.IOException ex)
 {
// Put the less specific exception last.
System.Console.WriteLine(ex.ToString()); 
 }
finally
 {
sw.Close();
 }
System.Console.WriteLine("Done");
}

Escrevendo um programa[editar | editar código-fonte]

Um programa em C# contém 4 elementos principais:

  • uma declaração de namespace: contém as bibliotecas de classe que você pode usar em um programa. A diretiva using System especifica que o programa pode utilizar a biblioteca no namespace System.
  • uma classe: contém as declarações de dados e métodos para uma aplicação;
  • um método Main: semelhante ao C++, todos os programas C# começam executando o método Main ;
  • e uma declaração do programa.

Compilando o código[editar | editar código-fonte]

As aplicações desenvolvidas em C# são baseadas em arquivos (com extensão .cs) contendo o código-fonte dos programas. Quando você compila seu código, cria um assembly. Um assembly é uma coleção de arquivos que aparecem ao programador como uma única DLL, biblioteca de link dinâmico (Dynamic Link Library), ou executável (EXE). Em .NET, um assembly é a unidade básica de reutilização, versionamento, segurança e implantação. O CLR proporciona um número de classes para manipulação de assemblies.

Herança[editar | editar código-fonte]

Um dos principais recursos da programação orientada a objetos é a herança. Herança é uma forma de reutilização de software em que as classes são criadas pela absorção dos dados e comportamentos de uma classe já existente e aprimorando-as com novos recursos. Ao criar uma classe, em vez de escrever variáveis de instância e métodos complementares novos, o programador pode indicar que a nova classe deve herdar as variáveis de classe, propriedades e métodos de outra classe. Uma classe derivada é mais específica do que sua classe base e representa um grupo mais especializado de objetos. Normalmente, a classe derivada contém os comportamentos de sua classe base e comportamentos adicionais. No caso de herança simples, uma classe é derivada de uma única classe base. Ao contrário do C++, o C# não suporta herança múltipla (que ocorre quando uma classe é derivada de mais de uma classe base direta).

Coleta de lixo[editar | editar código-fonte]

O operador new aloca memória para o objeto e, então, chama o construtor desse objeto. Ao contrário do C e do C++, em que os programadores devem gerenciar a memória de maneira explícita, o C# realiza o gerenciamento de memória internamente. A plataforma .NET realiza a coleta de lixo da memória para retornar a memória do sistema que não é mais necessária. Quando o coletor de lixo executa, ele localiza os objetos para os quais o aplicativo não tem referências. Tais objetos podem ser coletados nesse momento ou durante uma execução subseqüente do coletor de lixo. A alocação e liberação de recursos, como conexões de rede, conexões de banco de dados e arquivos, devem ser manipuladas explicitamente pelo programador. Uma técnica empregada em conjunto com o coletor de lixo é definir um destrutor.

Exemplos de código[editar | editar código-fonte]

Segue, abaixo, o programa teste Olá Mundo, que exibe a frase "Olá, Mundo!":

using System;
 
namespace Teste
{
    class OlaMundo
    {
        static void Main()
        {
            Console.WriteLine("Olá, Mundo!");
        }
    }
}

Bibliotecas[editar | editar código-fonte]

Captura de tela do Banshee, um media player desenvolvido em C#

Ao contrário das outras linguagens de programação, nenhuma implementação de C# actualmente inclui qualquer conjunto de bibliotecas de classes ou funções. Mesmo assim, esta linguagem está muito vinculada à plataforma .NET, da qual obtém as suas classes ou funções de execução. O código é organizado num conjunto de espaços de nomes que agrupam as classes com funções semelhantes. Por exemplo, System.Windows.Forms contém o sistema Windows Forms; System.Console é usado para entrada/saída de dados.

Um nível de organização superior é fornecido pelo conceito de montador, que pode ser um simples arquivo ou múltiplos arquivos ligados juntos que podem conter muitos espaços de nomes ou objetos. Programas que precisam de classes para realizar uma função em particular podem se referenciar aos montadores como System.Drawing.dll e System.Windows.Forms.dll assim como a biblioteca core (conhecida como mscorlib.dll na implementação da Microsoft).

Ver também[editar | editar código-fonte]

Referências

  1. Why Microsoft's C# isn't (em inglês). Página visitada em 26 de agosto de 2010.
  2. The A-Z of Programming Languages: C# (em inglês). Página visitada em 26 de agosto de 2010.
  3. Java 5 catches up with C# (em inglês). Página visitada em 26 de agosto de 2010.
  4. "C# - Como Programar", H. M. Deitel, São Paulo: Pearson Education, 2003
  5. C#/.NET History Lesson (em inglês). Página visitada em 24 de agosto de 2011.
  6. Microsoft C# FAQ (em inglês). Página visitada em 24 de agosto de 2011.
  7. C# Language Specification (em inglês). Página visitada em 24 de agosto de 2011.
  8. Visual C#.net Standard (em inglês). Página visitada em 24 de agosto de 2011.
  9. "C# e .NET - Guia do Desenvolvedor", Edwin Lima, Eugênio Reis, Rio de Janeiro: Campus, 2002
  10. http://msdn.microsoft.com/pt-br/vstudio/hh341490 Recursos do Visual C# Página visitada em 29 de Março de 2013
  11. Curso online Bradesco - C#, http://www.ev.org.br/Paginas/Home.aspx, página visitada em 30/03/13
  12. http://msdn.microsoft.com/pt-br/library/vstudio/618ayhy6 Referência de C# Página visitada em 30 de Março de 2013
  13. http://msdn.microsoft.com/pt-br/library/vstudio/900fyy8e.aspx 30/03/13
  14. http://msdn.microsoft.com/pt-br/library/vstudio/67ef8sbd Página visitada em 30 de Março de 2013
  15. http://download.microsoft.com/download/a/9/e/a9e229b9-fee5-4c3e-8476-917dee385062/CSharp%20Language%20Specification%20v1.0.doc CSharp Language Specification C# 1.0 (em inglês) Página visitada em 29 de Março de 2013
  16. http://download.microsoft.com/download/5/e/5/5e58be0a-b02b-41ac-a4a3-7a22286214ff/csharp%20language%20specification%20v1.2.doc CSharp Language Specification C# 1.2 (em inglês) Página visitada em 30 de Março de 2013
  17. http://download.microsoft.com/download/9/8/f/98fdf0c7-2bbd-40d3-9fd1-5a4159fa8044/csharp%202.0%20specification_sept_2005.doc CSharp Language Specification C# 2.0 (em inglês) Página visitada em 30 de Março de 2013
  18. http://www.microsoft.com/en-us/d ownload/details.aspx?id=7029 CSharp Language Specification C# 4.0 (em Inglês) Página visitada em 29 de Março de 2013
  19. http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=dfbf523c-f98c-4804-afbd-459e846b268e CSharp Language Specification C# 3.0 (em inglês) Página visitada em 29 de Março de 2013
  20. http://msdn.microsoft.com/pt-br/library/vstudio/ms228593 CSharp Language Specification C# 5.0 (em inglês) Página visitada em 30 de Março de 2013

Ligações externas[editar | editar código-fonte]