+++ to secure your transactions use the Bitcoin Mixer Service +++

 

We need Your Support. Make a Donation now! or Buy Me A Coffee

Saltar para o conteúdo

C Sharp

Origem: Wikipédia, a enciclopédia livre.
 Nota: o título deste verbete seria C#. Porém, devido a limitações técnicas sobre o uso de cerquilhas em títulos, utilizou-se C Sharp.
 Nota: Este artigo é sobre a linguagem de programação. Para a nota/acorde musical, veja Dó sustenido.
C#
C Sharp
Paradigma
Surgido em julho de 2000 (23 anos)
Última versão 12.0 (14 de novembro de 2023; há 6 meses[1])
Criado por Microsoft
Estilo de tipagem
  • estática
  • dinâmica
  • forte
  • segura
  • insegura
  • nominativa
  • inferida
Principais implementações
Dialetos: Cω
Influenciada por
Influenciou
Licença: MIT
Extensão do arquivo: .cs
Página oficial msdn.microsoft.com

C# é uma linguagem de programação, multiparadigma, de tipagem forte, 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, principalmente, Java. O código fonte é compilado para Common Intermediate Language (CIL) que é interpretado pela máquina virtual Common Language Runtime (CLR). C# é uma das linguagens projetadas para funcionar na Common Language Infrastructure da plataforma .NET Framework.[5]

Objetivos do projeto[editar | editar código-fonte]

A norma ECMA lista os objetivos de design para C#:[5]

  • A linguagem C# destina-se a ser simples, moderna, de propósito geral e orientada a objetos.[5]
  • A linguagem e suas implementações devem fornecer suporte para princípios de engenharia de software, tais como verificação de tipo forte, verificação de limites de array, detecção de tentativas de usar variáveis não inicializadas e coleta automática de lixo. A robustez do software, a durabilidade e a produtividade do programador são importantes.[5]
  • A linguagem destina-se a ser utilizada no desenvolvimento de componentes de software adequados para implantação em ambientes distribuídos.[5]
  • A portabilidade é muito importante para o código fonte e programadores, especialmente aqueles já familiarizados com C e C++.[5]
  • O apoio à internacionalização é muito importante.[5]
  • C# deve ser adequada para escrever aplicações tanto para sistemas hospedados e incorporados, que vão desde o muito grande que usam sistemas operacionais sofisticados, até o muito pequeno com funções dedicadas.[5]
  • Embora aplicações C# se destinam a ser econômicas no que diz respeito à memória e requisitos de energia de processamento, a linguagem não foi concebida para competir diretamente no desempenho e tamanho com C ou linguagem Assembly.[5]

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.[6]

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#.[6]

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 início à 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#.[6]

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.[6]

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.[6]

Etimologia[editar | editar código-fonte]

A nota dó 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++.[não consta na fonte citada] Entretanto, a cerquilha de "C#" se refere ao sinal musical sustenido (♯, em inglês: sharp), que aumenta em meio tom uma nota musical.[7]

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

Versões[editar | editar código-fonte]

C# 1.0[10]
  • Alia o poder de C++ com a simplicidade do Visual Basic[10]
  • Código gerenciado com a noção de assemblies carregando o bytecode com segurança embutida e controle de versões[10]
  • Orientação a objeto[10]
  • Tudo deriva de Object[10]
  • Os tipos são Estruturas, Enumerações, Classes, Interfaces, Delegados e Ponteiros (só em contexto unsafe)[10]
  • Tipagem estática[10]
  • Eventos[10]
  • Interoperabilidade com código não gerenciado através de DLL nativa e componentes COM[10]
  • Coletor de lixo de memória baseado em gerações[10]
  • Compilador Just-in-time[10]
  • Facilidades de integração com ferramentas e IDE[10]
  • Sintaxe para documentação[10]
  • Sistema de exceção uniforme[10]
  • Mecanismo de metadados[10]
  • Extensiva biblioteca padrão[10]
C# 2.0[11]
  • Tipos e métodos genéricos[11]
  • Tipos Parciais[11]
  • Métodos anônimos[11]
  • Iteradores[11]
  • Tipos anuláveis[11]
  • Acessibilidade separada para Getter/setter[11]
  • Conversões de grupo de métodos para delegados[11]
  • Co e Contravariância para delegados[11]
  • Classes estáticas[11]
  • Inferência de delegado[11]
  • Interface web[11]
C# 3.0[12]
  • Variáveis locais implicitamente tipadas[12]
  • Inicializadores de objetos e coleções[12]
  • Propriedades auto-implementadas[12]
  • Tipos anônimos[12]
  • Métodos de extensão[12]
  • Expressões de consulta[12]
  • Expressões Lambda[12]
  • Árvores de expressão[12]
  • Métodos parciais[12]
C# 4.0[13]
  • Vinculação dinâmica[13]
  • Argumentos nomeados e opcionais[13]
  • Co e contravariância genérica[13]
  • Tipos embutidos de interoperabilidade ("NoPIA")[40][13]
C# 5.0[14]
  • Métodos assíncronos[14]
  • Atributos de informação do chamador[14]
C# 6.0[15]
  • Compilador como serviço (Roslyn)[15]
  • Importação de membros de tipos estáticos no espaço de nomes[15]
  • Filtros de exceção[15]
  • Await em blocos catch/finally[15]
  • Inicializadores de propriedades automáticas[15]
  • Valores padrões para propriedades apenas getter[15]
  • Membros com corpos como expressão[15]
  • Propagador de Null (operador condicional de null, checagem de null sucinta)[43][15]
  • Interpolação de string[15]
  • Operador nameof[15]
  • Inicializador de dicionário[15]
C# 7.0[16]

Características em processo de desenvolvimento[16]

  • Literais binários[16]
  • Separadores de dígitos[16]
  • Funções locais[16]
  • Switch para tipos[16]
  • Retorno de referências[16]
  • Tuplas[16]
  • Declaração Out (Out var ou Out "tipo")[16]
  • Pattern Matching[16]
  • Returno de async arbitrário[16]
  • Registros (Record)[16]
C# 7.1[17]
  • async Método Main[17]
  • default Expressões literais[17]
  • Nomes de elementos de tupla inferidos[17]
C# 7.2[18]
  • Técnicas para escrever código eficiente seguro[18]
  • Argumentos nomeados que não estejam à direita[18]
  • Sublinhados à esquerda em literais numéricos[18]
  • Modificador de acesso private protected[18]
  • Expressões ref condicionais[18]
C# 7.3[19]
C# 8.0[1]
C# 9.0[20]
C# 10.0[21]
  • Diretivas Using Globais e Implícitas[21]
  • Declaração de Namespace com escopo de arquivo[21]
  • Melhorias dos tipos de estrutura[21]
  • Manipulador de strings interpolado[21]

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).[22]

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.[22]

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

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

  • Simplicidade: os projetistas de C# costumam dizer que essa linguagem é tão poderosa quanto o C++ e tão simples quanto o Visual Basic;[22]
  • Completamente orientada a objetos: em C#, qualquer variável tem de fazer parte de uma classe;[22]
  • Fortemente tipada: isso ajudará a evitar erros por manipulação imprópria de tipos e atribuições incorretas;[22]
  • Gera código gerenciado: assim como o ambiente .NET é gerenciado, assim também é o C#;[22]
  • Tudo é um objeto: System.Object é a classe base de todo o sistema de tipos de C#;[22]
  • 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;[22]
  • 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;[22]
  • Flexibilidade: se o desenvolvedor precisar usar ponteiros, o C# permite, mas ao custo de desenvolver código não gerenciado, chamado “unsafe”;[22]
  • 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).[23]

Sintaxe[editar | editar código-fonte]

A sintaxe da linguagem C# é semelhante à de outras linguagens de estilo C, como C, C ++ e Java. Em particular:[22]

  • Os pontos e vírgulas são usados para denotar o fim de uma declaração.[22]
  • As chaves são usadas para agrupar declarações. As declarações são geralmente agrupadas em métodos (funções), métodos em classes, e classes em namespaces.[22]
  • As variáveis são atribuídas usando um sinal de igual, mas comparadas usando dois sinais iguais consecutivos.[22]
  • Colchetes são usados com arrays, tanto para declará-los e para obter um valor em um determinado índice em um deles.[22]
  • Possui uma forma limitada de diretivas de compilação.[22]
  • Essencialmente imperativa, como todas linguagens mainstream.[22]

Orientação a objeto[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).[24]

Esta foi uma decisão de design do arquiteto principal da linguagem para evitar complicações e simplificar os requisitos arquitetônicos em toda a CLI. Ao implementar múltiplas interfaces que contêm um método com a mesma assinatura, C# permite implementar cada método dependendo da interface com a qual esse método está sendo chamado ou, permite implementar o método uma vez e ter que ser uma invocação em uma chamada através de qualquer uma das interfaces da classe.[24]

A linguagem permite que se acesse um objeto como se ele fosse de outro tipo de acordo com o contrato, de maneira polimórfica.[24]

As classes podem ser abstratas e exigirem que sejam derivadas através da palavra-chave abstract. Nesse tipo de classe métodos não precisam ser obrigatoriamente implementados deixando para suas filhas implementar.[24]

Existem algumas visibilidades possíveis para determinar o encapsulamento:[24]

public Os membros assim declarados podem ser acessado de qualquer local da aplicação[24]
private Apenas os membros da classe atual podem acessar um membro declarado como privado[24]
protected Somente pode ser acessado pela própria classe e as derivadas dela[24]
internal Qualquer classe dentro um mesmo assembly pode acessar esse membro[24]
private protected Pode ser acessado pela classe atual e derivadas, dentro do mesmo assembly[24]

C# suporta sobrecarga de alguns operadores.[24]

Programação funcional[editar | editar código-fonte]

Embora primariamente uma linguagem imperativa, até o C# 2.0 oferecia suporte limitado para programação funcional através de funções de primeira classe e encerramentos sob a forma de delegados anônimos. O suporte foi expandido no C# 3.0 para programação funcional com a introdução de uma sintaxe leve para expressões lambda, métodos de extensão e uma sintaxe de compreensão de lista na forma de uma linguagem de "compreensão de consulta". Em C# 7 mais um passo é dado com novos conceitos, tais como: records, pattern matching, tuplas, etc.[25]

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

C# tem um sistema de tipo de dados unificado. Este sistema de tipo unificado é chamado Common Type System (CTS).[26]

Um sistema de tipo unificado implica que todos os tipos, incluindo primitivos, como inteiros, são subclasses da classe System.Object. Por exemplo, cada tipo herda um método ToString().[27]

O CTS separa os tipos de dados em duas categorias:[27]

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

As instâncias de tipos de valores não têm identidade referencial nem semântica de comparação referencial - comparações de igualdade e desigualdade para tipos de valor comparam os valores de dados reais dentro das instâncias, a menos que os operadores correspondentes estejam sobrecarregados. Tipos de valor são derivados de System.ValueType, sempre têm um valor padrão e sempre podem ser criados e copiados. Algumas outras limitações em tipos de valor são que eles não podem derivar uns dos outros (mas podem implementar interfaces) e não podem ter um construtor padrão explícito (sem parâmetros).[27]

Os tipos de valor normalmente representam dados simples, como valores int ou bool. Os tipos de valor próprios da linguagem são os tipos integrais, o tipo decimal e os tipos de ponto flutuante float (um número de ponto flutuante IEEE de 32 bits) e double, e ainda char (uma unidade de código Unicode de 16 bits) e System.DateTime que identifica um ponto específico no tempo com nanossegundo de precisão). Outros exemplos são enum (enumerações) e struct (estruturas definidas pelo usuário).[27]

We need Your Support. Make a Donation now! or