Escolar Documentos
Profissional Documentos
Cultura Documentos
Apostila Do Lilo
Apostila Do Lilo
CONTEÚDO
Pré-requisitos: .......................................................................................................................................................................................... 4
DVD de Acompanhamento .............................................................................................................................................................. 4
Instalação .................................................................................................................................................................................................... 5
Instalação do Servidor Web (IIS) ................................................................................................................................................. 5
Instalação do .NET Framework .................................................................................................................................................... 6
Instalando o Visual Studio 2005................................................................................................................................................... 9
Instalando Componentes Adicionais ........................................................................................................................................ 14
O Visual Studio 2005 ............................................................................................................................................................................ 15
Menu Principal................................................................................................................................................................................... 16
Barra de Atalhos................................................................................................................................................................................ 16
Solution Explorer .............................................................................................................................................................................. 16
Properties Window .......................................................................................................................................................................... 17
ToolBox ................................................................................................................................................................................................. 19
Area de Trabalho .............................................................................................................................................................................. 19
Start Page ........................................................................................................................................................................................ 20
Aplicação em modo de Design ................................................................................................................................................ 21
Aplicação em modo de Codificação ...................................................................................................................................... 22
A linguagem C#....................................................................................................................................................................................... 23
História da Linguagem ................................................................................................................................................................... 23
Criação do Nome .......................................................................................................................................................................... 24
Normalização ................................................................................................................................................................................. 24
Política .............................................................................................................................................................................................. 24
Características.................................................................................................................................................................................... 24
Produtividade e Segurança ...................................................................................................................................................... 25
Abraça os padrões emergentes de programação Web ................................................................................................. 26
Elimina erros de programação de alto custo .................................................................................................................... 26
Reduz os custos de desenvolvimento do dia a dia com suporte pré-construído para versioning ............. 26
Melhor mapeamento entre processos de negócio e implementação ..................................................................... 27
Interoperabilidade extensiva .................................................................................................................................................. 27
Bibliotecas de código .................................................................................................................................................................. 28
Estruturas da linguagem .................................................................................................................................................................... 29
Criando uma Solução....................................................................................................................................................................... 29
Criando o Programa Alo Mundo ................................................................................................................................................. 30
Estruturas básicas ............................................................................................................................................................................ 33
Comentários ................................................................................................................................................................................... 33
PRÉ-REQUISITOS:
Para o bom andamento do curso e para que o aluno possa testar os programas aqui desenvolvidos faz-
se necessário ter um mínimo de infra-estrutura computacional para se criar um ambiente de
desenvolvimento:
O computador deve ter pelo menos 1.0 GHz de processador e 512Mb de RAM e 2Gb livre no Disco
Rígido.
Caso o queira instalar o SQL Server 2005 Express Edition, que é um servidor de banco de dados
poderoso e gratuito da Microsoft, recomenda-se pelo menos 1Gb RAM.
DVD DE ACOMPANHAMENTO
Para facilitar, junto a apostila é entregue um DVD com a seguinte estrutura, onde:
INSTALAÇÃO
Para preparar um ambiente integrado de desenvolvimento completo baseado em .NET, tanto para
Windows quanto para Web, temos que seguir os seguintes passos:
O IIS (Internet Information Services) é um servidor web criado pela Microsoft para seus sistemas
operacionais possuindo um conjunto integrado de serviços de rede que permite publicar conteúdo e
disponibilizar arquivos e aplicações em ambientes Internet/Intranet/Extranet, totalmente integrado ao
sistema operacional e dotado de uma interface administrativa 100% gráfica, o IIS é uma das melhores
opções disponíveis para hospedagem de web sites, site FTP e grupos de notícias, bem como o
desenvolvimento de aplicações para Web.
Sua primeira versão foi introduzida com o Windows NT Server versão 4, e passou por várias
atualizações. As últimas versões disponíveis são:
Uma de suas principais características é a geração de páginas HTML dinâmica como o ASP (Active
Server Pages) e ASPX (evolução do ASP), mas também pode usar outras tecnologias com adição de
módulos de terceiros.
Depois do lançamento da plataforma .NET em 2002 o IIS ganhou também a função de gerenciar o
ASP.NET. Este é formado basicamente por dois tipos de aplicações:
Páginas Web: Páginas tradicionais acessadas por usuários, contém a extensão ASPX
Web Services: Funções disponibilizadas pela rede, chamada por aplicativos ASMX
O ASP.NET é compilado antes da execução. Esta característica traz vantagens sobre as opções
interpretadas, como o ASP, JSP e o PHP.
Além de servidor web, suporta a criação e a utilização de certificados digitais com o Certificate Services,
a tecnologia de colaboração via Internet com Sharepoint Services e WebDAV, as diretivas Server-Side
Includes (SSI) e auditoria completa de visitas e uso.
Microsoft .NET é uma iniciativa da Microsoft em que visa uma plataforma única para desenvolvimento e
execução de sistemas e aplicações. Todo e qualquer código gerado para .NET, pode ser executado em
qualquer dispositivo ou plataforma que possua um framework: a "Plataforma .NET" (.NET Framework).
Com idéia semelhante à plataforma Java, o programador deixa de escrever código para um sistema ou
dispositivo específico, e passa a escrever para a plataforma .NET.
A plataforma .NET, é executada sobre uma CLR (Common Language Runtime - Ambiente de Execução
Independente de Linguagem) interagindo com uma Coleção de Bibliotecas Unificadas, que juntas são o
próprio framework. Esta CLR é capaz de executar, atualmente, mais de vinte diferentes linguagens de
programação, interagindo entre si como se fossem uma única linguagem, entre elas podemos citar:
APL Scheme
Boo Curriculum
Fortran Mondrian
Pascal SmallTalk
C++ Eiffel
Haskell Oberon
Perl Standard ML
C# Forth
Java Oz
Python Microsoft Visual Basic
COBOL Delphi
Microsoft JScript® J#
RPG Ruby
Component Pascal Lua
Mercury
Esta plataforma permite a execução, construção e desenvolvimento de Web Services e Aplicações Web
de forma integrada e unificada.
A plataforma .NET se baseia em um dos principios utilizados na tecnologia Java (compiladores JIT), os
programas desenvolvidos para ela são duplo-compilados, ou seja são compilados duas vezes, uma na
distribuição e outra na execução.
Um programa é escrito em qualquer umas das linguagens de programação disponível para a plataforma,
o código fonte gerado pelo programador é então compilado pela linguagem escolhida gerando um
código intermediário em uma linguagem chamada MSIL (Microsoft Intermediate Language).
Este novo código fonte gera um arquivo chamado de Assembly, de acordo com o tipo de projeto:
No momento da execução do programa ele é novamente compilado, desta vez pelo JIT (Just In Time
Compiler), de acordo com a utilização do programa, por exemplo:
Temos um Web Site desenvolvido em ASP.NET, ao entrar pela primeira vez em uma página o JIT irá
compilá-la, nas outras vezes que algum outro usuário acessar esta página, ele usará esta compilação.
Também é possível, através de ferramentas específicas, "pré-compilar" o código para que não se tenha o
custo da compilação JIT durante a execução.
O fato desta arquitetura utilizar a MSIL gera uma possibilidade pouco desejada entre os criadores de
software que é a de fazer a "engenharia reversa", ou seja, a partir de um código compilado, recuperar o
código original. Isto não é uma idéia agradável para as empresas que sobrevivem da venda de softwares
produzidos nesta plataforma.
Por causa disso, existem ferramentas que "ofuscam" este código MSIL, trocando nomes de variáveis,
métodos, interfaces e etc para dificultar o trabalho de quem tentar uma engenharia reversa num código
compilado MSIL.
A versão atual do .NET Framework é a 3.0, chamado de WinFx. Esse é o framework padrão do Windows
Vista, mas pode ser instalado no Windows XP sem problemas. O WinFx foi lançado oficialmente no fim
de 2006 e as principais funcionalidades adicionadas em relação a versão 2.0 é a incorporação de 3
tecnologias base:
O .Net Framework 3.0 (WinFx) pode ser baixado diretamente do site da Microsoft pelo endereço:
http://www.microsoft.com/downloads/details.aspx?displaylang=pt-br&FamilyID=10CC340B-F857-4A14-83F5-25634C3BF043
ou para quem tem o DVD que acompanha a apostila, basta seguir os seguintes passos:
Microsoft Visual Studio 2005 é um programa desenvolvido pela Microsoft, que possibilita um ambiente
integrado de desenvolvimento (IDE). Existem várias versões do mesmo, dentre elas podemos citar:
O Visual Studio Express que consiste em 6 produtos separados com objetivos específicos que
são o Visual Basic 2005 Express Edition, Visual C# 2005 Express Edition, Visual C++ 2005
Express Edition, Visual J# 2005 Express Edition, Visual Web Developer 2005 Express Edition, e
SQL Server 2005 Express Edition.
O Visual Studio 2005 Professional Edition que é composto pelos 6 programas acima integrados
e mais algumas funcionalidades existente apenas na versão Professional tais como ferramentas
de Acessibilidade, Testes Automatizados e Análise, e principalmente, o suporte a add-ins e
macros de terceiros, que permitem estender a funcionalidade da IDE.
O Visual Studio 2005 Team Edition que tem todas as funcionalidades do Professional, mas uma
extensa lista de características específicas para colaboração em equipe, gerenciamento de
projetos, ferramentas de Banco de Dados e Business Inteligence – BI, entre muitas outras
características. Nessa versão se faz necessário um servidor chamado Team Server rodando
sobre o Windows 2003 Server, juntamente com o Banco de Dados SQL Server 2005 e Sharepoint
Services 2007.
Com isso, o Visual Studio é considerado a melhor ferramenta para análise, desenho e desenvolvimento
de aplicações (projetos de desenvolvimento).
O Visual Studio 2005 Express pode ser baixado gratuitamente do site da Microsoft pelo endereço:
http://msdn.microsoft.com/vstudio/express/downloads/
ou para quem tem o DVD que acompanha a apostila, tem uma versão trial de 180 dias da versão Team
Edition do Visual Studio.
Uma das grandes vantagens da plataforma .NET é a extensa variedade de objetos complementares que
podem ser reutilizados em seus projetos de desenvolvimento. Os objetos vão desde componentes
visuais que melhoram a interface de sua aplicação, até modelos e frameworks de negócios que facilitam
o desenvolvimento de projetos complexos.
Esse tipo de modelo de extensão por meio de componentes (que já existia na época do Delphi) é um
grande aliado da plataforma, o que a distingue enormemente dos demais (a proporção de componentes
existentes para plataforma .NET em comparação a outras plataformas como Java, é maior que a
proporção de computadores com Windows Instalado versus Linux).
Todos eles tem uma versão demo totalmente funcional na qual podem ser utilizados em seu projeto em
fase de desenvolvimento. Lógico que ao comercializá-lo, far-se-á necessário o licenciamento do mesmo.
Existem também uma variedade de componentes gratuitos e poderosos disponíveis para download, e
quem sabe, você mesmo não crie sua suíte de componentes e disponibiliza para outros.
No DVD, na pasta Componentes, temos algumas dessas suítes de componentes que podem ser
instalados no seu computador para complementar as funcionalidades já existentes no Visual Studio. É
altamente recomendável trabalhar com eles, já que diminui muito o tempo de desenvolvimento de um
sistema e deixa o mesmo com um aspecto bem mais profissional, o que diminui substancialmente o
custo de um projeto e aumenta a qualidade do mesmo.
Para instalá-los basta executar o pacote correspondente a cada um dos componentes e seguir os passos
básicos para instalação (clicar Next, Next, Next e Install).
O Visual Studio 2005, como já foi visto, é um ambiente integrado de desenvolvimento (IDE) para a
plataforma .NET. Podemos considerá-lo também uma ferramenta RAD (Rapid Application
Development), que nos permite criar aplicações de maneira bem rápida e intuitiva, uma herança do
Delphi, já que a equipe que desenvolveu o .NET foi a mesma que outrora desenvolveu o Delphi da
Borland.
O Visual Studio (VS) é divido em vários módulos, dentre os principais podemos citar:
MENU PRINCIPAL
Todas as ações que o VS pode executar, é acessível pelo Menu Principal, desde a criação de um projeto,
seu acompanhamento (gerenciamento), até a sua distribuição.
Para acessar o Menu Principal, basta selecionar o item desejado com o mouse ou usar teclas de atalho
correspondentes a cada item de menu. Com a tecla Alt+[Letra sublinhada no menu], acessamos
diretamente o item menu indicado.
BARRA DE ATALHOS
As funções mais comuns do Menu Principal, tem um equivalente na Barra de Atalhos, que é uma
maneira mais fácil de ser acionada (com apenas um clique).
Nem todas as barras de atalhos estão visíveis por padrão, apenas as principais, dado um determinado
contexto (quando estamos codificando um programa as barras apresentadas podem ser diferentes
quando estamos desenhando uma janela).
Para verificar todas as barras de atalhos disponíveis e poder visualizá-las ou não, basta ir no menu
View, no item ToolBars e selecionar as Barras de Atalhos que gostaria que estivesse disponíveis.
SOLUTION EXPLORER
É o local onde gerenciamos todos nossos projetos, seus arquivos e configurações. Podemos dizer que o
Solution Explorer está para os projetos de desenvolvimento tanto quanto o Windows Explorer está para
os arquivos e recursos do Windows.
O conceito de Solution é usado pela Microsoft para definir um conjunto de projetos, seja ele de
desenvolvimento, de banco de dados, de testes ou de distribuição.
Para visualizar essa janela (caso ela não esteja visível), basta ir no menu View e selecionar Solution
Explorer, ou usar a tecla de atalho Crtl+W+S.
PROPERTIES WINDOW
Como toda a programação .NET é baseada em Orientação a Objetos, e os objetos por definição tem
características (propriedades) e apresenta um determinado comportamento (executam ações dado uma
determinada circunstância/evento), a janela Properties Windows tem como objetivo mostrar as
propriedades de cada objeto pertencente ao Sistema e gerenciar todos os eventos na qual esse objeto
poderá responder.
Para visualizar essa janela (caso ela não esteja visível), basta ir no menu View e selecionar Properties
Window, ou usar a tecla de atalho Crtl+W+P.
Caso você deseje que essas propriedades fiquem em ordem alfabética em vez de categorizadas, basta
clicar em ou clicar em para voltar a ficar categorizadas.
Como foi falado anteriormente, na janela Properties também pode-se visualizar aspectos relacionados
ao comportamento do objeto. Nessa janela, mais especificamente o comportamento é definido pelos
eventos que um objeto pode tratar, e quando um desses eventos ocorre podemos relacionar uma ação a
ser executada com um desses eventos
Como exemplo pode-se imaginar no que vai acontecer (ação) quando clicarmos com o mouse
(evento) em cima dessa janela.
Para visualizar os eventos tratados por esse objeto em questão, basta clicar em , e caso deseje voltar
a visualizar as propriedades, clique em .
TOOLBOX
Para visualizar essa janela (caso ela não esteja visível), basta ir
no menu View e selecionar Toolbox, ou usar a tecla de atalho
Crtl+W+X.
AREA DE TRABALHO
É o local onde visualizamos e modificamos o layout de um sistema ou seu código fonte. É a parte
principal do Visual Studio, onde permite aos programadores, analistas, gerentes de projeto,
administradores de banco de dados, arquitetos de software, entre outros a interagir com o ambiente
para criar soluções em projetos de desenvolvimento de sistemas.
Start Page
Quando iniciamos o VS, uma Página Inicial (Start Page) é mostrada na área de trabalho. Nessa página
podemos visualizar:
Caso essa página não esteja disponível, clique em View, depois em Other Windows e selecione Start
Page.
Boa parte de um projeto de desenvolvimento envolve a definição da interface com o usuário. Com o
Visual Studio, pode-se visualizar, mesmo no momento do desenvolvimento, uma interface exatamente
igual ao que será apresentada ao usuário final (tecnologia WYSIWYG – What You See Is What You Get).
Na janela acima temos muitos componentes visuais, que serão apresentados exatamente iguais ao
usuário quando o programa for executado.
Entretanto, em modo de desenvolvimento, componentes não visuais também são vistos para poderem
ser editados. É o caso do componente chamado Estilo (abaixo da figura). Componentes não visuais
estarão disponibilizados na área abaixo da janela e somente são visíveis no modo de desenvolvimento e
não em execução.
Um sistema certamente tem uma lógica de programação por traz dele, codificado em uma determinada
linguagem, que no nosso caso é o C# (C Sharp).
Assim como pode-se ver uma janela em modo de desenho (exemplo anterior), pode-se visualizar todo o
código fonte por traz daquela interface, o código que representa toda a funcionalidade de sua aplicação
(nesse caso da janela).
Caso o exemplo mostrado fosse de um projeto para Web, também seria possível visualizar o código
HTML por traz de cada página Web.
A LINGUAGEM C#
Nas últimas duas décadas, C e C++ foram as linguagens mais amplamente usadas para o
desenvolvimento de software comercial e de negócios. Embora as duas linguagens proporcionem ao
programador uma quantidade enorme de controle granular, esta flexibilidade possui um custo para a
produtividade. Comparadas com uma linguagem como o Microsoft® Visual Basic®, aplicações C e C++
equivalentes freqüentemente demoram mais para serem desenvolvidas. Devido a complexidade e
longos tempos de ciclo associados a essas linguagens, muitos programadores C e C++ vêm procurando
uma linguagem que ofereça um melhor balanceamento entre poder e produtividade.
A solução ideal para programadores C e C++ seria o desenvolvimento rápido combinado ao poder de
acesso a funcionalidade total da plataforma básica. Eles desejam um ambiente totalmente sincronizado
com os padrões Web emergentes que proporcione a fácil integração com as aplicações existentes.
Adicionalmente, desenvolvedores C e C++ gostariam de ter a habilidade de codificar em baixo nível
quando e se a necessidade aparecer.
A solução Microsoft para este problema é uma linguagem chamada C#. C# é uma moderna linguagem
orientada a objeto que habilita os programadores a construir rapidamente uma ampla gama de
aplicações para a nova plataforma Microsoft .NET, a qual proporciona ferramentas e serviços que
exploram totalmente a computação e as comunicações.
Devido ao seu elegante projeto orientado a objeto, C# é uma escolha excelente para arquitetar uma
ampla gama de componentes – de objetos de negócio de alto nível a aplicações no nível do sistema.
Usando construções de linguagem C# simples, estes componentes podem ser convertidos em serviços
Web, permitindo que eles sejam invocados pela Internet, a partir de qualquer linguagem rodando em
qualquer sistema operacional.
Principalmente, C# é projetado para trazer desenvolvimento rápido para o programador C++ sem
sacrificar o poder e o controle que têm sido a característica fundamental do C e C++. Devido a esta
herança, C# possui um alto grau de fidelidade com C e C++. Desenvolvedores familiarizados com estas
linguagens podem se tornar produtivos em C# rapidamente.
HISTÓRIA DA LINGUAGEM
A linguagem C# foi criada junto com a arquitetura .NET. Embora existam várias outras linguagens que
suportam essa tecnologia (como VB.NET, C++, J#), C# é considerada a linguagem símbolo do .NET pelas
seguintes razões:
Foi criada praticamente do zero para funcionar na nova plataforma, sem preocupações de
compatibilidade com código de legado.
O compilador C# foi o primeiro a ser desenvolvido.
A maior parte das classes do .NET Framework foram desenvolvidos em C#.
O criação da linguagem, embora tenha sido feita por vários desenvolvedores, é atribuída principalmente
a Anders_Hejlsberg , hoje um “Distinguished Engineer” na Microsoft. Anders Hejlsberg era
desenvolvedor de compiladores na Borland, e entre suas criações mais conhecidas estão o Turbo Pascal
e o Delphi.
Criação do Nome
Muitos pensam que o nome C# viria de uma sobreposição de 4 símbolos "+" dando a impressão de
"++++". Na verdade o "#" de C# refere-se ao sinal musical, que aumenta um tom denotado por uma letra
(entre A e G) pela metade de um tom. O símbolo real seria o ♯ e não o #, porém, devido a limitação de
telas, fontes e alguns browsers, no momento da normalização junto a ECMA, fora especificado apenas
que o nome da linguagem seria uma letra C maiúscula (U+0043) e o sinal "#" (U+0023), facilitando
assim, publicações e artigos com um caracter encontrado facilmente dos layouts de teclado padrões.
Normalização
A Microsoft submeteu o C# a ECMA para uma padronização formal. Em Dezembro de 2001 a ECMA
liberou a especificação ECMA-334 Especificação da Linguagem C#. Em 2003 tornou-se uma padrão ISO
(ISO/IEC 23270). Há algumas implementações em desenvolvimento, destacando:
Recentemente a Microsoft anunciou planos de adicionar o suporte a tipos parciais, generics e outras
características. A padronização pela ECMA/ISO destas características foi solicitada, mas ainda não são
parte da versão padrão da linguagem.
Política
Muitos dos produtos e iniciativas da Microsoft geram polêmica no campo político e a criação e desenho
da C# não foi excepção. Devido à natureza fechada da C# com uma instituição comercial, a discussão
política continua em relação à legitimidade da sua normalização, as suas semelhanças com Java, o seu
futuro como uma linguagem para uso generalizado e outros assuntos. Alguns peritos em segurança
encontram-se cépticos em relação à eficácia do mecanismo de segurança do CLR e criticam a sua
complexidade.
Ao contrário de linguagens proprietárias tal como a Visual Basic, a Microsoft optou por submeter a C# a
um processo de normalização. No entanto, a Microsoft continua a ser a principal força a induzir
mudanças e inovação na linguagem. Além disso, a Microsoft tornou bem claro que a C#, tal como outras
linguagens .NET, é uma parte importante da sua estratégia de software, tanto para uso interno e para
consumo externo. A Microsoft leva a cabo um papel ativo em descrever a linguagem como uma
componente da sua estratégia global de negócios.
CARACTERÍSTICAS
C# (pronuncia-se "cê chárp" em português ou "cí charp" em inglês) é, de certa forma, a linguagem de
programação que mais diretamente reflete a plataforma .NET sobre a qual todos os programas .NET
executam. C# está de tal forma ligado a esta plataforma que não existe o conceito de código não-
gerenciado (unmanaged code) em C#. Suas estruturas de dados primitivas são objetos que
correspondem a tipos em .NET. A desalocação automática de memória por garbage colletor além de
várias de suas abstrações tais como classes, interfaces, delegados e exceções são nada mais que a
exposição explicita dos recursos do ambiente .NET.
Quando comparada com C e C++, a linguagem é restrita e melhorada de várias formas incluindo:
Ponteiros e aritmética sem checagem só podem ser utilizados em uma modalidade especial
chamada modo inseguro (unsafe mode). Normalmente os acessos a objetos é realizada através
de referências seguras, as quais não podem ser invalidadas e normalmente as operações
aritméticas são checadas contra sobrecarga (overflow).
Objetos não são liberados explicitamente, mas através de um processo de coleta de lixo
(garbage collector) quando não há referências aos mesmos, prevenindo assim referências
inválidas.
Destrutores não existem. O equivalente mais próximo é a interface Disposable, que juntamente
com a construção using block permitem que recursos alocados por um objeto sejam liberados
prontamente. Também existem finalizadores, mas como em Java sua execução não é imediata.
Como em Java, só é permitida a herança simples, mas uma classe pode implementar várias
interfaces abstratas. O objetivo principal é simplificar a implementação do ambiente de
execução.
C# é mais seguro com tipos que C++. As únicas conversões implícitas por default são conversões
seguras, tais como ampliação de inteiros e conversões de um tipo derivado para um tipo base.
Não existem conversões implícitas entre inteiros e variáveis lógicas ou enumerações. Não
existem ponteiros nulos (void pointers) (apesar de referências para Object serem parecidas). E
qualquer conversão implícita definida pelo usuário deve ser marcada explicitamente,
diferentemente dos construtores de cópia de C++.
A sintaxe para a declaração de vetores é diferente ("int[] a = new int[5]" ao invés de "int a[5]").
Membros de enumeração são colocados em seu próprio espaço de nomes (namespace)
C# não possui modelos (templates), mas C# 2.0 possui genéricos (generics).
Propriedades estão disponíveis, as quais permitem que métodos sejam chamados com a mesma
sintaxe de acesso a membros de dados.
Recursos de reflexão completos estão disponíveis
Apesar de C# ser freqüentemente tido como similar a Java, existem uma série de diferenças
importantes, tais como:
Produtividade e Segurança
A nova economia Web – onde os concorrentes estão a apenas um clique de distância – está forçando as
empresas a responder aos desafios competitivos mais rapidamente do que nunca. Desenvolvedores são
chamados para diminuir tempos de ciclo e produzir revisões mais incrementais de um programa, ao
invés de uma única versão monumental.
O novo modelo para desenvolvimento de aplicações significa que mais e mais soluções requerem o uso
de padrões Web emergentes tais como Hypertext Markup Language (HTML), Extensible Markup
Language (XML) e Simple Object Access Protocol (SOAP). Ferramentas de desenvolvimento existentes
foram desenvolvidas antes da Internet ou quando a Web conforme nós a conhecemos hoje estava na sua
infância. Como resultado, elas nem sempre proporcionam a melhor forma de trabalhar com as novas
tecnologias Web.
O que é ainda melhor, o framework dos serviços Web pode tornar os serviços Web existentes iguais a
objetos C# nativos para o programador, permitindo assim que os desenvolvedores utilizem os serviços
Web existentes com as habilidades de programação orientada a objeto que eles já possuem.
Existem mais recursos sutis que tornam o C# uma excelente ferramenta de programação Internet. Por
exemplo, o XML está emergindo como a forma padrão de passar dados estruturados pela Internet, que
freqüentemente são muito pequenos. Para performance melhorada, C# permite que os dados XML
sejam mapeados diretamente em um tipo de dados struct ao invés de uma classe. Esta é uma forma
mais eficiente de tratar pequenas quantidades de dados.
Mesmo os programadores C++ mais experientes podem cometer o mais simples dos erros – esquecer de
inicializar uma variável, por exemplo – e freqüentemente estes erros simples resultam em problemas
não previstos que podem permanecer não descobertos por longos períodos de tempo. Uma vez que um
programa está em uso na produção, pode ser muito custoso corrigir mesmo o mais simples erro de
programação.
O projeto moderno do C# elimina os erros de programação C++ mais comuns. Por exemplo:
O resultado final é uma linguagem que torna bem mais fácil para os desenvolvedores escrever e manter
programas que resolvem problemas de negócio complexos.
Reduz os custos de desenvolvimento do dia a dia com suporte pré-construído para versioning
Atualização de componentes de software é uma tarefa com alta probabilidade de erro. Revisões feitas
no código podem alterar não intencionalmente a semântica de um programa existente. Para auxiliar o
desenvolvedor neste problema, C# inclui o suporte a versioning na linguagem. Por exemplo, a
sobrescrita de método deve ser explícita; ela não pode acontecer de forma inadvertida como no C++ ou
Java. Isto ajuda a evitar erros de codificação e preserva flexibilidade de versioning. Um recurso
relacionado é o suporte nativo para interfaces e herança de interface. Estes recursos habilitam
frameworks complexos a serem desenvolvidos e evoluídos com o tempo.
Com o alto nível de esforço gasto pelas corporações no planejamento de negócio, é imperativo ter um
forte conexão entre os processos abstratos de negócio e a implementação real de software. Mas a
maioria das ferramentas de linguagem não possui uma forma fácil de unir lógica de negócio ao código.
Por exemplo, os desenvolvedores provavelmente utilizam comentários de código hoje em dia para
identificar quais classes formam um objeto de negócio abstrato particular.
A linguagem C# permite metadados extensíveis typed que podem ser aplicados a qualquer objeto. Um
arquiteto de projeto pode definir atributos específicos de domínio e aplicá-los a quaisquer classes de
elemento da linguagem, interfaces e assim por diante. O desenvolvedor pode então examinar via
programação os atributos de cada elemento. Isto torna fácil, por exemplo, escrever uma ferramenta
automatizada que garantirá que cada classe ou interface está identificada corretamente como parte de
um objeto de negócio particular, ou simplesmente criar relatórios com base nos atributos específicos de
domínio de um objeto. A forte união entre os metadados customizados e o código do programa ajuda a
fortalecer a conexão entre o comportamento pretendido do programa e a implementação real.
Interoperabilidade extensiva
O ambiente type-safe gerenciado é apropriado para a maioria das aplicações corporativas. Mas a
experiência mostra que algumas aplicações continuam a exigir código "nativo", ou por razões de
performance ou para interoperar com interfaces de programação de aplicação (APIs) existentes. Estes
cenários podem forçar os desenvolvedores a usar C++ mesmo quando eles prefeririam usar um
ambiente de desenvolvimento mais produtivo.
Incluindo suporte nativo para o Component Object Model (COM) e APIs baseadas em
Windows®.
Permitindo o uso restrito de ponteiros nativos.
Com C#, cada objeto é automaticamente um objeto COM. Desenvolvedores não têm mais que
implementar explicitamente interfaces IUnknown e outras interfaces COM. Ao invés disto, estes
recursos são pré-construídos. De forma similar, programas C# podem usar nativamente objetos COM
existentes, independente da linguagem usada para sua criação.
Para os desenvolvedores que precisam disto, C# inclui um recurso especial que habilita um programa a
chamar qualquer API nativa. Dentro de um bloco de código marcado especialmente, desenvolvedores
podem usar ponteiros e recursos C/C++ tradicionais tais como memória gerenciada manualmente e
aritmética de ponteiro. Esta é uma enorme vantagem sobre os outros ambientes. Isto significa que
programadores C# podem construir sobre sua base de código C e C++ existente, ao invés de descartá-la.
Nos dois casos – suporte a COM e acesso API nativo – a intenção é proporcionar ao desenvolvedor o
poder e o controle essenciais sem ter que deixar o ambiente C#.
Bibliotecas de código
ESTRUTURAS DA LINGUAGEM
Nesse capítulo, iremos introduzir a linguagem C# básica (sem uso de orientação a objeto) através de
alguns exemplos simples.
O aluno deve entender, neste momento, que C# é apenas uma outra linguagem de programação, assim
como C, Pascal, Basic, Fortran, Cobol.
Tipos básicos
Constantes
Decisões
Laços
Veremos também como criar, compilar e executar programas usando o Visual Studio. Observe que não
veremos chamadas de sub-programas (subrotinas ou funções) aqui, este assunto é bem diferente em
C#, devido à orientação a objeto, e será visto à frente.
Importante! Você é responsável por aprender detalhes adicionais da linguagem C#. O que faremos em
aula não é uma cobertura completa da linguagem.
Nas IDEs mais novas, como o Visual Studio (VS), o conceito de programa é estendido para Projeto de
Desenvolvimento, logo, para você criar um programa, deve-se primeiro, criar um Projeto que vai
agregar seu sistema.
O VS além do conceito de Projetos, tem também o conceito de Solução, que nada mais é do que um
conjunto de projetos. No exemplo que vamos dar, vamos criar uma Solução que vai levar seu nome, e
vamos dividir essa solução em 3 partes, projetos do tipo Console, do tipo Windows e do Tipo Web.
Para tanto:
O objetivo principal desse programa não é mostrar a mensagem Alo Mundo para o usuário, o objetivo é
apresentar o ambiente de desenvolvimento que você usará, mostrando como se cria um programa
(projeto), assim como compilar, executar, salvar e recuperar o mesmo.
Como o objetivo dessa sessão é apenas mostrar aspectos da linguagem C#, todos os projetos que
criaremos aqui serão do tipo Console e, portanto estarão dentro da pasta Console. Um programa do
tipo Console é um programa que não apresenta interface gráfica, não contém janelas ou qualquer outro
componente visual, apenas lógica de programação.
No conteúdo do arquivo Program.cs está definido uma classe. Agora para criar o programa Alo Mundo,
vamos digitar o código de acordo com o mostrado abaixo. As particularidades do código são mostradas
pelos balões e explicadas prontamente. Mais informações sobre essa estrutura serão abortadas
posteriormente nessa apostila.
4. Na classe Program temos um método (conceito a ser abordado na Orientação a Objetos) chamado
Main que identifica a primeira ação a ser executada pelo programa. Logo, se quisermos que o programa
execute alguma ação primeiramente, basta colocar os comandos dentro desse método que são
delimitados por { e }.
ESTRUTURAS BÁSICAS
Antes de começarmos a criar algoritmos complexos, vamos conhecer algumas estruturas simples que
são usadas no C# (assim como em outras linguagens, mas com sintaxe diferente) que são:
Comentários
Blocos de comandos
Variáveis e seus Tipos
Conversão de Tipos
Comandos de Escrita e Leitura
Comentários
Criar comentários em seu código fonte é muito importante, já que possibilita um entendimento melhor
dos algoritmos ali implementados. Os comentários na hora da compilação são ignorados, por isso você
pode usar (e não abusar) deles.
/* */ : Textos delimitados por essa seqüência de caracteres ficam todos comentados mesmo
que o texto contenha mais de uma linha.
// : Texto com essa seqüência de caracteres na frente dele viram comentário de uma única linha
/// : Texto com essa seqüência de caracteres na frente dele viram comentário para
documentação XML
Para mostrar a funcionalidade da documentação de seu código inserindo esses 3 tipos de comentários,
vamos alterar o programa Alo Mundo:
using System;
using System.Collections.Generic;
using System.Text;
namespace Alo {
/// <summary>
/// A classe Program é uma classe criada automaticamente pelo VS e serve
/// para executar o programa a ser desenvolvido
/// </summary>
class Program {
/// <summary>
/// Método que define quais acões serão executados primeiramente
/// quando o programa for executado
/// </summary>
/// <param name="args">Um conjunto de parâmetros do tipo string que podem ser
/// passados ao programa
/// </param>
static void Main(string[] args) {
// Escreve Alo Mundo! no monitor
Console.WriteLine("Alo Mundo!");
// Espera que o usuário tecle algo para finalizar a execução do progama
Console.ReadLine();
}
Blocos de Comando
Todos os comandos em C# tem que terminar com um ponto-e-vírgula ( ; ) e esses comandos tem que
estar delimitados por um bloco que tem início e fim, representados no C# pelos caracteres abre-chaves
( { ) que define o início do bloco e fecha-chaves ( } ) que define o fim do bloco.
O namespace precisa ser delimitado com um início e fim, no caso com { e }, assim como o classe e o
método Main. Outras estruturas també precisam ser delimitadas, e que serão vistas ao longo da
apostila.
Por essa delimitação sabemos que a o método Main está dentro da classe Program que esta dentro do
namespace Alo.
Por padrão o Visual Studio fecha as chaves na mesma coluna onde ela foi aberta, mas podemos
configurar para o padrão usado no Java, onde abrimos as chaves logo após o comando que abre ela e
fechamos a mesma coluna que o comando foi iniciado, como exemplo:
A endentação em ambos os casos é importantíssimo, onde um bloco de comando que esteja dentro de
outro bloco, deve estar alinhado pelo menos com 3 espaços para dentro (ou um tab como usado no VS).
Uma variável consiste em um elemento ao qual lhe damos um nome e lhe atribuímos um determinado
tipo de informação, quer dizer, variáveis são estruturas que possibilitam armazenar valores e serem
modificados e recuperados a contento. As variáveis podem ser consideradas como a base da
programação.
A variável que nós chamamos "a" possui um elemento de informação de tipo texto que é "cachorro".
Assim como, a variável "b" contém o valor "morde". Poderíamos definir uma terceira variável que fosse
a soma destas duas:
c = a + b
Como podemos observar, as variáveis tem um tipo que podem ser alem de números e textos, tipos
booleanos, vetores, tipos complexos (classes na Orientação a Objetos), entre outros. Além disso,
percebe-se que valores textuais são delimitados por aspas duplas, já valores numéricos não precisam.
Em ciência da computação tipos de variáveis ou dados é um nome para uma combinação de valores e de
algumas operações que uma variável pode executar, podem variar conforme o sistema operacional e a
linguagem de programação e são utilizados para indicar ao compilador ou interpretador as conversões
necessárias para obter os valores em memória durante a construção do programa. Por outro lado,
ajudam também o programador a detectar eventuais erros.
Tipos de dados primitivos são tipos que tem tamanho fixo e sempre apresentam um valor padrão, além
de serem armazenados na pilha do programa para acesso rápido. Os tipos primitivos do C# são:
O tipo string não é primitivo pois não tem tamanho fixo e tem operações específicas associada a ela
(string é uma classe). O tipo string serve para armazenar qualquer texto no padrão Unicode.
Em C# para se declarar uma variável primeiro temos que definir o tipo para depois definir o nome da
variável e opcionalmente, iniciá-la com algum valor.
Sintaxe:
TipoDeDado nomeDdaVariável [= valorInicial];
Exemplo:
// declaração de uma variável do tipo int (inteiro) com o nome de idade
int idade;
Ou
// declaração de uma variável do tipo int (inteiro) com o nome de idade e iniciada com
// o valor 20
int idade = 20;
Caso tenhamos duas variáveis do mesmo tipo, podemos declarar as duas ao mesmo tempo, apenas
separando-as por vírgulas:
double nota1, nota2, media;
nota1 = 8;
nota2 = 7;
media = (nota1 + nota2) / 2;
Ou
double nota1 = 8, nota2 = 7, media = (nota1 + nota2) / 2;
As variáveis em C# são estáticas (assim como em Java, Pascal, entre outros), isto é, não podem ter tipo
de dados modificado na sua execução (como o phyton, php etc..., que tem tipos dinâmicos).
No modelo estático, uma variável do tipo numérica em nenhum momento pode receber outro tipo de
informação a não ser tipos numéricos. Já as variáveis dinâmicas podem mudar seu tipo de informação
ao longo da execução de um programa.
Outra característica importante também é a necessidade de se declarar uma variável e seu tipo
previamente (como C# e Java) ou apenas usar uma variável e deixar que o compilador atribua em modo
de execução o tipo da mesma (VBScript, PHP, Phyton, etc...). No primeiro caso damos o nome de
Linguagem Fortemente Tipada e no outro respectivamente, de Linguagem Fracamente Tipada.
Conversão de Tipos
Apesar do C# ser baseado em variáveis estáticas, é possível converter os tipos de dados de uma
variável, desde que essa conversão seja possível, por exemplo:
É possível converter qualquer tipo primitivo para string mas nem sempre é possível o contrario
Um string que representa um número pode ser convertido para um tipo numérico, caso não
represente, a conversão gerará uma exceção.
Um numero pode sempre ser convertido para um número com mais bits, exemplo, um tipo byte
(8 bits) pode ser convertido para um do tipo int (32 bits).
O contrário nem sempre é possível (de um tipo com mais bits para representá-lo para um com
menos bits), desde que o valor não exceda o limite do tipo menor, a conversão ocorrerá sem
problemas, senão, haverá uma exceção (erro) na execução.
Nas conversões que sempre poderão acontecer, o mesmo é feito automaticamente, sem precisar
“forçar” nenhuma dessas conversões. Logo é possível converter sem problemas (automaticamente) os
tipos:
De byte, short, int, long, float, double, char, bool para string
De byte para short, de short para int, de int para float, de float para Double
De Double para float, long para int, de int para short, de short para byte
De uma string para um tipo numérico
Esses tipos de conversões tem que ser feita de forma explícita, e no C# existem algumas formas de se
fazer isso. A mais simples é usando a classe Convert.
Essa classe implementa vários métodos que permite a conversão de qualquer tipo para outro, desde
que essa conversão seja possível.
// converte uma string que representa o valor 1024 para o tipo short
short numero16bits = Convert.ToInt16("1024");
// converte uma string que representa o valor 34123 para o tipo int
int numero32bits = Convert.ToInt32("34123");
// converte uma string que representa o valor 123123.12455 para o tipo double
double numeroReal64bits = Convert.ToDouble("123123.12455");
Como vamos trabalhar primeiramente com programas não visuais, isto é, aplicações do tipo Console, é
importante aprendermos uma maneira de ler informações do usuário e também enviar.
Para tanto, o C# implementa alguns métodos dentro da classe Console que faz parte do espaço de
nomes (namespace) chamado System.
Para escrever alguma informação na tela podemos usar esses dois comandos:
Console.WriteLine( informação );
Console.Write( informação );
Onde
Onde
Exemplo
Para explicar melhor o conceito de variáveis, leitura e escrita, vamos implementar um projeto cujo
objetivo é ler o nome de um aluno, ler as notas de duas provas e depois mostrar o nome é a média do
aluno:
using System;
using System.Collections.Generic;
using System.Text;
namespace Basico {
class Program {
static void Main(string[] args) {
// declaração das variáveis
string aluno;
double nota1, nota2;
// fazendo os cálculos
double media = (nota1 + nota2) / 2;
ESTRUTURAS DE DECISÃO
O C# assim como outras linguagens apresentam diversas estruturas que controla a execução (fluxo e
comportamento) de um programa. Dentre elas podemos citar as estruturas de decisão permitem que
escolhamos qual parte do código será executado dado uma expressão booleana (que pode ter como
resultado, apenas dois valores: verdadeiro ou falso).
if – else if - else
Um exemplo de estrutura de decisão é a estrutura IF (SE), que serve para mudar o fluxo da execução de
um programa dado uma expressão booleana. A maioria dos programas tomam decisões que afetam seu
fluxo. As declarações que tomam essas decisões são chamadas de declarações de controle.
Sintaxes:
Obs: Usando quando temos apenas um comando Obs: Usando quando temos vários comandos fazendo
fazendo parte do if parte do if
if – else if – else
if (expressao booleana 1) { Onde:
comandos bloco 1; Os comandos do bloco 1 serão somente executados
... se a expressão booleana 1 for verdadeira;
} else if (expressao booleana 2){
comandos bloco 2; Os comandos do bloco 2 serão somente executados
... se a expressão booleana 2 for verdadeira;
} else if ... {
... Os comandos do bloco n serão somente executados
} else if (expressao booleana n){ se a expressão booleana n for verdadeira;
comandos bloco n;
... Os comandos do bloco else serão somente
} else { executados se nenhuma expressão booelana anterior
comandos bloco else; for verdadeira.
...
}
O uso de chaves é obrigatório quando se quer que mais de um comando seja executado quando uma
expressão é verdadeira ou não. Caso o fluxo seja direcionado para apenas um comando, a chaves não se
faz necessária. As chaves delimitam blocos de comando, similiar ao Inicio...Fim usando nos algorítimos.
switch
O comando switch existe nas principais linguagens de programação (C, C++, Java, C#). Seu propósito é
permitir que o valor de uma variável ou expressão controle o fluxo de execução do programa.
Sintaxe:
O comando deve começar com a palavra reservada switch, e cada bloco de execução deve conter a
palavra reservada case acompanhada do valor que a variável de controle deve ter. Para finalizar o
bloco, devemos usar o comando break.
Switch
switch ( expressão ) { Onde:
case valor1: Os comandos relacionados ao case valor1 serão
comandos; somente executados se o valor da expressão for
break; igual ao valor1;
case valor2:
comandos; Os comandos relacionados ao case valor2 serão
break; somente executados se o valor da expressão for
... igual ao valor2;
case valorN:
comandos; Os comandos relacionados ao case valorN serão
break; somente executados se o valor da expressão for
default: igual ao valorN;
comandos;
break; Os comandos do bloco default serão somente
} executados se nenhuma expressão tiver um valor
definido na estrutura case.
Exemplo
Para explicar melhor o conceito de estruturas de decisão, vamos implementar um programa cujo
objetivo é similar ao exercício anterior, sendo que este irá mostrar se o aluno passou por média (média
maior ou igual a 6), vai pra final ou reprovou de vez (média menor que 3).
Para os alunos que passaram por média, o programa ainda definirá um conceito para aquele aluno:
A+ para média 10
A para média 9
para média 8
B para média 7
using System;
using System.Collections.Generic;
using System.Text;
namespace Decisao {
class Program {
// fazendo os cálculos
double media = (nota1 + nota2) / 2;
}
}
}
ESTRUTURAS DE REPETIÇÃO
O C# assim como outras linguagens apresentam diversas estruturas que permitem a execução de um
comando ou um bloco de comandos mais de uma vez (ou nenhuma em alguns casos), controlando o
fluxo de execução de um programa.
Esse fluxo de execução é controlado por uma expressão booleana, por isso, uma estrutura de repetição é
normalmente é composto por essa expressão mais um comando ou um bloco de comandos. No caso, a
expressão booleana - chamada de expressão de controle ou condição de parada - será avaliada e, se for
verdadeira, o comando será executado, caso contrário, o fluxo de repetição será parado.
Deve-se observar que, caso o comando - ou bloco de comandos - executado dentro de uma estrutura de
repetição não altere nenhum dos elementos da expressão de controle, a repetição será infinita.
Não é incomum especificar-se, como expressão de controle do, uma expressão que sempre seja
verdadeira, tornando a repetição infinita um efeito desejado. Nesses casos, ou há uma outra estrutura
de controle dentro dos comandos a serem repetidos que terminará o laço de repetição - tal como um
comando break - ou o programa controla um conjunto de ações que realmente deverá ser executado
ininterruptamente - como um sistema operacional ou um programa de controle de um dispositivo
portátil, por exemplo.
for
No comando for, podemos dizer que o(s) comando(s) será(ao) executado(s) por uma quantidade pré-
definida de vezes, utilizando-se pra isso, um contador interno, inicializado previamente, que será
modificado a cada iteração do comando for.
A execução da estrutura for então está vinculada a esse contados, executando o(s) comandos enquanto
a expressão booleana, que envolve o contador, for verdadeiro, ou parando a execução caso ele seja falso.
Sintaxe:
for
for (VI; CP; INC) Onde:
comando; VI é nde o contador é iniciado com um Valor
Inicial;
while
No comando while, podemos dizer que o(s) comando(s) será(ao) executado(s) enquanto a expressão
for verdadeira - daí derivando o nome do comando while. O fato de a expressão ser avaliada antes de o
comando ser executado caracteriza o comando while como sendo um repetitivo pré-testado,
diferenciando-o de comandos repetitivos pós-testados, tais como o do-while.
Como o while é uma estrutura de repetição pré-testado, pode acontecer que os comandos definidos no
bloco de comandos possam não ser executados.
Sintaxe:
while
while (CP) Onde:
comando; CP é Condição de Parada que nada mais é do que
uma expressão booleana (ou expressão de controle)
que controlará a execução ou não dos comandos da
ou estrutura while;
while (CP) {
comandos;
}
do... while
No comando do...while, podemos dizer que o(s) comando(s) será(ao) executado(s) enquanto a
expressão for verdadeira - daí derivando o nome do comando while. O fato de a expressão ser avaliada
depois de o comando ser executado (usando-se o comando do – faça - antes do while) caracteriza o
comando como sendo um repetitivo pós-testado, onde sempre pelo menos uma vez os comandos
definidos no bloco de comandos serão executados.
Sintaxe:
do...while
do Onde:
comando; CP é Condição de Parada que nada mais é do que
while (CP) uma expressão booleana (ou expressão de controle)
que controlará a execução ou não dos comandos da
estrutura do...while;
ou
do {
comandos;
} while (CP)
Exemplo
Para explicar melhor o conceito de estruturas de repetição, vamos implementar um programa cujo
objetivo é criar um menu de execução que sempre será mostrado enquanto o usuário não digitar 0.
Caso ele digitar 1 o programa deverá mostrar a tabuada de 1 a 9 e caso ele digite 2, o programa
mostrará a soma de todos esses números da tabuada.
using System;
using System.Collections.Generic;
using System.Text;
namespace Repeticao {
class Program {
static void Main(string[] args) {
int opcao;
do {
Console.WriteLine("\n\n[1] - Mostrar Tabuada");
Console.WriteLine("[2] - Somar Tabuada");
Console.WriteLine("[0] - Sair do Programa");
Console.Write("Selecione uma opcao -> ");
opcao = Convert.ToInt32(Console.ReadLine());
switch (opcao) {
case 1:
for (int i = 1; i < 10; i++) {
Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}\t{8}",
1*i, 2*i, 3*i, 4*i, 5*i, 6*i, 7*i, 8*i, 9*i);
}
break;
case 2:
int j = 1, soma = 0;
while (j < 10) {
soma = 1*j + 2*j + 3*j + 4*j + 5*j + 6*j + 7*j + 8*j + 9*j;
j++;
}
Console.WriteLine("A soma da tabuada e {0}", soma);
break;
}
} while (opcao != 0);
Console.WriteLine("Programa terminado");
Console.ReadLine();
}
}
}
SUBPROGRAMAS
Em ciência da computação , uma subprograma (função ou procedimento) são códigos incluídos dentro
de programas de computador e relativamente independente do resto do código do programa. Maurice
Wilkes, Stanley Gill e David Wheeler são os inventores de subprogramas.
Elas ajudam a estruturar o código de forma organizada e simples, e fundamentam a estrutura de todo
software em tempo de desenvolvimento. Um subprograma é frequentemente uma função chamada
diversas vezes em diferentes momentos do programa, geralmente mais utilizada para programação
estruturada, que distinguem funções, e procedimentos, outras linguagens como linguagem C e LISP não
as distinguem. Na orientação a objetos os subprogramas são chamados de métodos, onde
procedimentos são métodos que tem o tipo de retorno void e funções são métodos que tem um tipo de
retorno diferente de void.
Subprogramas que são muito utilizadas em programas são incluídas da biblioteca padrão da linguagem.
Como utilizamos uma linguagem orientada a objetos, o C#, o que são definidos no programa são
métodos, que serão explicados com mais detalhes no próximo capítulo, específico para Orientação a
Objetos.
Como forma de explanação apenas, vamos definir por cima a sua sintaxe e forma de utilização.
Sintaxe: