WC01 - WCF Com C#

WCF – Web Services
com C#
Arquitetura Orientada a
Serviços
Sobre Este Curso
Público Alvo
Desenvolvedores interessados em aprender e aperfeiçoar

suas técnicas de desenvolvimento para o segmento de Web
Services com C#.NET.
Pré-Requisitos
Ter concluído com êxito o curso de C# Profissional da Clarify
Treinamentos ou possuir conhecimento equivalente.
Agosto | 2015
Índice
SOBRE ESTE CURSO ........................................................................................................................................................... I
PÚBLICO ALVO ........................................................................................................................................................................... I

DESENVOLVEDORES INTERESSADOS EM APRENDER E APERFEIÇOAR SUAS TÉCNICAS DE DESENVOLVIMENTO PARA O SEGMENTO DE WEB SERVICES
COM C#.NET. ........................................................................................................................................................................... I
PRÉ-REQUISITOS ........................................................................................................................................................................ I
ÍNDICE............................................................................................................................................................................... I
COPYRIGHT ..................................................................................................................................................................... IV
EQUIPE ................................................................................................................................................................................... IV
HISTÓRICO DAS EDIÇÕES ............................................................................................................................................................ IV
CONVENÇÕES .................................................................................................................................................................. V
FONTES ................................................................................................................................................................................... V
CONFIGURAÇÃO REGIONAL.......................................................................................................................................................... V
VERSÃO ................................................................................................................................................................................... V
CAPÍTULO 01 - INTRODUÇÃO À ARQUITETURAS DE APLICAÇÕES ......................................................................................1
ARQUITETURA DE SOFTWARE .......................................................................................................................................................2

DESIGN PATTERNS .....................................................................................................................................................................2
APLICAÇÕES MULTICAMADAS ......................................................................................................................................................2
EXERCÍCIOS ..............................................................................................................................................................................3
CAPÍTULO 02 – SERVICE ORIENTED ARCHITECTURE (SOA) .................................................................................................4
O QUE É ARQUITETURA ORIENTADA A SERVIÇOS SOA ......................................................................................................................5

ENTERPRISE SERVICE BUS (ESB) ...................................................................................................................................................5
EXERCÍCIOS ..............................................................................................................................................................................6
CAPÍTULO 03 – WINDOWS COMMUNICATION FOUNDATION ...........................................................................................7
O QUE É O WCF .......................................................................................................................................................................8

O QUE PODEMOS REALIZAR COM WCF ..........................................................................................................................................8
REQUISITOS PARA O DESENVOLVIMENTO ........................................................................................................................................9
EXERCÍCIOS ............................................................................................................................................................................10
CAPÍTULO 04 – TIPOS DE PROJETO E ESTRUTURAÇÃO ....................................................................................................11
COMPREENSÃO BÁSICA .............................................................................................................................................................12

SERVICE LIBRARY X SERVICE APPLICATION (HOST ENVIRONMENT) .....................................................................................................12
EXERCÍCIOS ............................................................................................................................................................................13
CAPÍTULO 05 – FUNCIONAMENTO BÁSICO .....................................................................................................................14
SERVIÇOS ...............................................................................................................................................................................15
Anotações
Índice i
CONTRATOS........................................................................................................................................................................... 15
SERVICE CONTRACT ................................................................................................................................................................. 15
SERVICE BEHAVIOR ................................................................................................................................................................. 16
DATA CONTRACTS................................................................................................................................................................... 17
DATA MEMBERS..................................................................................................................................................................... 18
EXERCÍCIOS ............................................................................................................................................................................ 19
CAPÍTULO 06 – SOAP E REST ........................................................................................................................................... 20
SIMPLE OBJECT ACCESS PROTOCOL (SOAP) ................................................................................................................................ 21

REPRESENTATIONAL STATE TRANSFER (REST) .............................................................................................................................. 22
EXERCÍCIOS ............................................................................................................................................................................ 23
CAPÍTULO 07 – CRIANDO SERVIÇOS REST ....................................................................................................................... 24
REQUISITOS ........................................................................................................................................................................... 25
CONTRATOS........................................................................................................................................................................... 25
COMPORTAMENTOS ................................................................................................................................................................ 26
ARQUIVO DE CONFIGURAÇÕES .................................................................................................................................................. 27
EXERCÍCIOS ............................................................................................................................................................................ 29
CAPÍTULO 08 – ABC DO WCF ........................................................................................................................................... 30
ENDPOINTS............................................................................................................................................................................ 31
ADDRESS ............................................................................................................................................................................... 31
BINDING ............................................................................................................................................................................... 31
CONTRACT ............................................................................................................................................................................ 36
EXERCÍCIOS ............................................................................................................................................................................ 39
CAPÍTULO 09 – CONSUMIR WEBSERVICE SOAP COM C# ................................................................................................. 40
COMO CONSUMIR UM WEB SERVICE COM WCF TEST CLIENT C#.NET ............................................................................................. 41
EXERCÍCIOS ............................................................................................................................................................................ 49
CAPÍTULO 10 – CONSUMIR WEBSERVICE REST COM C# .................................................................................................. 50
COMO CONSUMIR UM WEB SERVICE REST COM C#.NET .............................................................................................................. 51

EXERCÍCIOS ............................................................................................................................................................................ 55
CAPÍTULO 11- PUBLICAÇÃO DO WEB SERVICE ................................................................................................................ 56
O QUE É O IIS ........................................................................................................................................................................ 57

HABILITANDO O IIS EXPRESS ..................................................................................................................................................... 57
CONFIGURAÇÕES BÁSICAS ........................................................................................................................................................ 61
PROCESSO PUBLICAÇÃO DO WEB SERVICE LOCALMENTE ................................................................................................................. 62
DISPONIBILIZAÇÃO DO WEB SERVICE ATRAVÉS DO IIS .................................................................................................................... 64
EXERCÍCIOS ............................................................................................................................................................................ 70
CAPÍTULO 12 - WINDOWS SERVICE ................................................................................................................................. 71

Anotações
ii Índice
O QUE É UM WINDOWS SERVICE ................................................................................................................................................72
CONFIGURAÇÕES BÁSICAS .........................................................................................................................................................72
PUBLICAÇÃO DO SERVIÇO NOS SERVIÇOS DO WINDOWS ..................................................................................................................77
CAPÍTULO 13 - O QUE MAIS ESTÁ POR VIR? ....................................................................................................................86
WEB COM ASP.NET MVC .......................................................................................................................................................87

MOBILE COM WINDOWS PHONE ................................................................................................................................................88
PRÓXIMOS PASSOS NA CLARIFY TREINAMENTOS ............................................................................................................................89
APÊNDICE - RESPOSTAS DOS EXERCÍCIOS ........................................................................................................................90
CAPÍTULO 01 – INTRODUÇÃO À ARQUITETURAS DE APLICAÇÕES .......................................................................................................92

CAPÍTULO 02 – SERVICE ORIENTED ARCHITECTURE (SOA) ..............................................................................................................92
CAPÍTULO 03 – WINDOWS COMMUNICATION FOUNDATION ...........................................................................................................93
CAPÍTULO 04 – TIPOS DE PROJETO E ESTRUTURAÇÃO .....................................................................................................................94
CAPÍTULO 05 – FUNCIONAMENTO BÁSICO ...................................................................................................................................94
CAPÍTULO 06 – SOAP E REST ...................................................................................................................................................95
CAPÍTULO 07 – CRIANDO SERVIÇOS REST ...................................................................................................................................95
CAPÍTULO 08 – ABC DO WCF ...................................................................................................................................................96
CAPÍTULO 09 – CONSUMIR WEB SERVICE SOAP COM C# ..............................................................................................................96
CAPÍTULO 10 – CONSUMIR WEB SERVICE REST COM C# ...............................................................................................................96
CAPÍTULO 11 – PUBLICAÇÃO DO WEB SERVICE .............................................................................................................................96
Anotações
Índice iii
Copyright
As informações contidas neste material se referem à Desenvolvimento com C#.NET, e estão sujeitas as
alterações sem comunicação prévia, não representando um compromisso por parte do autor em atualização
automática de futuras versões.
A Clarify não será responsável por quaisquer erros ou por danos acidentais ou consequenciais relacionados com
o fornecimento, desempenho, ou uso desta apostila ou os exemplos contidos aqui.
Os exemplos de empresas, organizações, produtos, nomes de domínio, endereços de e-mail, logotipos, pessoas,
lugares e eventos aqui representados são fictícios. Nenhuma associação a empresas, organizações, produtos,
nomes de domínio, endereços de e-mail, logotipos, pessoas, lugares ou eventos reais é intencional ou deve ser
inferida.
A reprodução, adaptação, ou tradução deste manual mesmo que parcial, para qualquer finalidade é proibida
sem autorização prévia por escrito da Clarify, exceto as permitidas sob as leis de direito autoral.
Texto original registrado no Escritório de Direitos Autorais da Fundação Biblioteca Nacional.
Equipe
Coordenação Conteúdos Revisão

 Lucas Tudda Schoch  Lucas Tudda Schoch  Paulo André Jesus
Histórico das Edições

Edição Idioma Edição
a
1 Português Junho de 2015
2ª Português Agosto de 2015
© Copyright 2015 Clarify. Todos os direitos reservados.

Anotações
iv Copyright
Convenções
Fontes
As convenções a seguir são usadas nos materiais do curso para diferenciar os elementos do texto.
Convenção Uso
Negrito Representa comandos, opções de comando e sintaxe que devem ser digitados exatamente
conforme mostrado. Também indica comandos em menus e botões, títulos e opções de
caixas de diálogo e nomes de ícones e menus.
Itálico Em instruções de sintaxe ou texto descritivo, indica nomes de argumentos ou espaços
reservados para informações variáveis.
O recurso de itálico também é usado para apresentar novos termos, para títulos de
capítulo e para dar ênfase ao texto.
Maiúsculas Indicam nomes de domínios, nomes de usuários, nomes de computadores, nomes de
diretórios, nomes de pastas e de arquivos, exceto quando estiverem se referindo
especificamente a nomes que fazem distinção entre maiúsculas e minúsculas.
A menos que seja indicado de outra forma, você pode usar letras minúsculas ao digitar um
nome de diretório ou arquivo em uma caixa de diálogo ou em um prompt de comando.
TODAS Indica os nomes das teclas, sequências de teclas e combinações de teclas—por exemplo,
MAIÚSCULAS ALT+BARRA DE ESPAÇOS.
Monoespaçada Representa exemplos de códigos ou de textos de tela.
[] Em elementos de sintaxe, engloba itens opcionais. Por exemplo, [nomedearquivo] na

sintaxe de comando indica que você pode digitar um nome de arquivo com o comando.
Digite apenas as informações entre colchetes, não os colchetes.
{} Em elementos de sintaxe, engloba itens obrigatórios.
Digite apenas as informações entre chaves, não as chaves.
| Em instruções de sintaxe, separa uma escolha do tipo ou/ou.
 Indica um procedimento com etapas sequenciais.
... Em instruções de sintaxe, especifica que o item anterior pode ser repetido.
. Representa uma parte omitida de um exemplo de código.
.
.
Configuração Regional
As configurações regionais e de idioma assumidas nesta apostila são Português (Brasil).
Versão
A versão utilizada para este curso é o do Visual Studio 2013 Community.
Anotações
Convenções v
Capítulo 01 - Introdução à Arquiteturas de Aplicações
Neste capítulo você irá aprender:

 Arquitetura de Software
 Design Patterns
 Aplicações Multicamadas
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 01 - Introdução à Arquiteturas de
Aplicações.
Este capítulo levará aproximadamente 60 minutos

Anotações
Capítulo 01 - Introdução à Arquiteturas de Aplicações 1

Antes de entrarmos no mundo dos Web Services e como eles funcionam, necessitamos de uma definição
razoavelmente genérica sobre alguns temas facilmente confundidos pelos desenvolvedores de software no
brasil.
Arquitetura de Software
"Arquitetura é a definição dos elementos que compõem uma estrutura e como eles se relacionam”
Um dos tópicos teóricos mais necessários aos desenvolvedores e envolvidos no processo de criação de qualquer
tipo de software, tendo finalidade comercial ou não, é a Arquitetura de Software. Em sua essência, a arquitetura
de software tem como objetivo estruturar o software/softwares envolvidos, como um todo. Consiste em
compreender a ciência de como cada ponto do software irá se comunicar com os outros.
Design Patterns
Padrões de Design – Design Patterns, tem como objetivo padronizar todo o desenvolvimento de um sistema,
tornando compreensível, ágil e de fácil manutenção um software. Diferente da arquitetura de um sistema, os
padrões de design, tem como objetivo padronizar o código em si que será escrito. Quais interfaces serão
utilizadas, o tipo de conexões com softwares externos, a maneira de criar uma nova tela do sistema, etc.
O objetivo é tornar o desenvolvedor capaz de alterar e compreender perfeitamente cada parte do sistema. A
princípio é considerado complexo, entretanto, no decorrer do desenvolvimento do produto o tempo gasto com
manutenções e correções é extremamente inferior à quando não existe um padrão.
Aplicações Multicamadas
Em aplicações complexas onde existem múltiplos acessos a bancos de dados, diversas telas e principalmente,
diversos desenvolvedores trabalhando nelas, além do Design Pattern da aplicação, temos subdivisões dentro da
aplicação, chamamos elas de Camadas. Seu objetivo é definir blocos de responsabilidade, para dessa maneira
otimizar o tempo e o reuso de códigos. Um desenvolvedor de banco de dados com pouco conhecimento em C#,
por exemplo, pode cuidar somente da parte de conexão com bancos de dados, sendo muito mais produtivo do
que quando solicitado para fazer uma página com ASP.NET MVC.
Anotações
2 Capítulo 01 - Introdução à Arquiteturas de Aplicações

Exercícios
 Faça um mapa hierárquico contendo Arquitetura, Design Pattern e Multicamadas. Dê um exemplo da
responsabilidade de cada uma das camadas.
Anotações
Capítulo 01 - Introdução à Arquiteturas de Aplicações 3

Capítulo 02 – Service Oriented Architecture (SOA)
 O que é Arquitetura Orientada a Serviços SOA

 Enterprise Service Bus (ESB)
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 02 – Service Oriented Architecture
(SOA).
Anotações
4 Capítulo 02 – Service Oriented Architecture (SOA)

O que é Arquitetura Orientada a Serviços SOA
Service Oriented Architecture – Arquitetura Orientada a Serviços é um tipo de arquitetura de software qual dita
que aplicações devem ter funcionalidades implementadas no formato de serviços. Isso significa que não caberá
a aplicação ter responsabilidades sobre nenhuma funcionalidade além da interface gráfica.
Dessa maneira, diversas aplicações podem usufruir do mesmo serviço, sem que haja a necessidade de programar
para cada uma delas a mesma lógica. As aplicações se responsabilizam somente com a maneira que o usuário
verá essa informação e interagirá com o sistema.
Enterprise Service Bus (ESB)
Enterprise Service Bus – Serviço de Barramento é uma maneira que muitas empresas estão desenvolvendo a
arquitetura orientada a serviços de seus softwares. O conceito se baseia em colocar um serviço como primeira
camada para qualquer sistema. Ou seja, nenhum software acessa nenhum tipo de informação da empresa ou
serviço necessário, sem passar por esse barramento.
É no barramento que se concentram as regras de acesso a informação, regras de negócios, conexão com os
diversos bancos de dados da organização, serviços de conexão com seus clientes e fornecedores entre outras
possibilidades.
Anotações
Capítulo 02 – Service Oriented Architecture (SOA) 5

Exercícios
1. Diferencie Arquitetura de Software e Arquitetura Orientada a Serviços.
2. Qual a utilidade de adotar um barramento através de serviço (ESB)? Cite ao menos três.
Anotações
6 Capítulo 02 – Service Oriented Architecture (SOA)

Capítulo 03 – Windows Communication Foundation

 O que é o WCF
 O que podemos realizar com WCF
 Requisitos para o desenvolvimento
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 03 – Windows Communication
Foundation.

Anotações
Capítulo 03 – Windows Communication Foundation 7

O que é o WCF
Windows Communication Foundation – WCF – é uma parte do .NET Framework que fornece um modelo
unificado de programação para construir, de forma rápida, aplicações distribuídas orientadas a serviço (SOA).
Não existente anterior ao .NET Framework 3.0, o WCF surgiu para a unificação entre tecnologias de programação
distribuídas como MSMQ, Enterprise Services, .Net Remoting e Web Services (antigo asmx).
O que podemos realizar com WCF

Ao ser acoplado ao .NET Framework, o WCF facilitou consideravelmente o desenvolvimento de aplicações
distribuídas. Através dele podemos criar serviços que permitirão aplicações de qualquer gênero acessem nossas
regras de negócio, mantendo a segurança e integridade de nossa informação.
Podemos criar:
 Windows Services
 WCF SOAP Services
Anotações
8 Capítulo 03 – Windows Communication Foundation

 WCF REST Services
Além desses serviços chave, podemos desenvolver serviços de mensageria, Rich Internet Applications e etc. A
gama de possibilidades do WCF é extremamente extensa.
Requisitos para o desenvolvimento

Para desenvolvermos WCF necessitamos de conhecimento prévio da linguagem C# ou VB.NET, entretanto, a
Microsoft oficialmente descontinuou o VB.NET para as próximas versões do .NET Framework, tornando o C#
nossa única opção.
Ao longo do desenvolvimento aparecerão objetos e sintaxes novas, que não estamos acostumados a utilizar
dentro do desenvolvimento para Windows, por exemplo. Entretanto, são extremamente simples de
compreender. O WCF é uma ferramenta fortemente configurável, muito do desenvolvimento de serviços é a
integração e interoperabilidade entre ferramentas.
Não existem pré-requisitos de software para o desenvolvimento com WCF, entretanto, a última versão do Visual
Studio, sempre será a mais aconselhável, dada a grande possibilidade de configurações extras, quando
comparada a tecnologias mais antigas.
Anotações
Capítulo 03 – Windows Communication Foundation 9

Exercícios
1. Marque Verdadeiro ou Falso. Explique sua escolha.
a. ( ) Quando desenvolvemos serviços com WCF podemos criar Web Sites e Apps para
smartphones.
b. ( ) Através do WCF podemos fornecer serviços de alta escalabilidade à Web Sites,

Apps para smartphones, aplicações Windows, MAC, Linux ou qualquer outro sistema
operacional e linguagem de programação.
c. ( ) Necessitamos instalar em nosso Visual Studio a extensão para WCF Enterprise.
d. ( ) WCF é o mais completo conjunto de ferramentas para desenvolvimento de Web

Services com as linguagens do .NET Framework.
2. Quais tipos de serviços podemos criar com WCF e o que podem fazer cada um deles (brevemente)?
Anotações
10 Capítulo 03 – Windows Communication Foundation

Capítulo 04 – Tipos de Projeto e Estruturação

 Service Library
 Service Application
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 04 – Tipos de Projeto e Estruturação.

Anotações
Capítulo 04 – Tipos de Projeto e Estruturação 11

Compreensão básica
Para introduzir a você o necessário para o desenvolvimento, projeção, implementação, e hospedagem de
serviços feitos em WCF, serão necessários alguns conceitos básicos. Dentro desses conceitos, o principal é diferir
quais os diferentes tipos de projeto que podemos criar com os templates oferecidos pelo Visual Studio. Esses
templates nos fornecem um serviço modelo que pode ser imediatamente hospedado e testado com ferramentas
de teste do próprio WCF, ou outras.
O que é um serviço WCF?

“Toda comunicação com um serviço WCF ocorre através de EndPoints do serviço. Os EndPoints fornecem aos
clientes o acesso às funcionalidades oferecida por um serviço WCF.”
O que são os EndPoints?
A
Todo serviço, seja um Web Service ou um Web Site ou um Console Application ou Windows Forms, precisa ter
um endereço, ou seja, um diretório que diz onde ele se encontra. Esse endereço é o Address do WCF.
B
Todo serviço deve possuir uma vinculação, ou seja, como deverá se comunicar com os outros aplicativos. Essa
vinculação é o Binding do WCF.
C
Todo serviço precisa de um contrato, que dita o que o serviço faz. Esse contrato é o Contract do WCF.
O relacionamento de Address, Binding e Contract é chamado de EndPoint (A+B+C).
Veremos mais detalhadamente o funcionamento desse ABC em capítulos posteriores.
Service Library x Service Application (Host Environment)

Outro detalhe sobre como funciona nosso serviço WCF é compreender o que cada template de projeto do Visual
Studio oferece e porque utilizar um ou outro. A melhor definição (e oficial da Microsoft) segue abaixo:
“Uma WCF Service Application inclui um host em forma de website já configurado pra você. Uma
WCF Service Library é uma biblioteca de serviços que um host pode referenciar e utilizar.
Se você começar com uma Service Library (recomendado), você pode mais pra frente escolher o tipo
de host você quiser (por exemplo: Windows Service, IIS/ASP.NET ou até mesmo uma Console
Application) e você só referência a sua biblioteca no seu host. Escolher uma Service Application te
limita a utilizar o host IIS/ASP.NET (apesar disso poder suprir suas necessidades, vai limitar os
protocolos que você pode utilizar).”
Anotações
12 Capítulo 04 – Tipos de Projeto e Estruturação

Exercícios
1. Seja qual for nosso Serviço, deveremos compreender onde ele se encontra, o que ele realiza e como
podemos acessa-lo. O que isso define?
2. Quando trabalhamos com o Visual Studio, podemos criar vários tipos de projetos relacionados a WCF.
Quais são os dois principais e o que os difere um do outro?
Anotações
Capítulo 04 – Tipos de Projeto e Estruturação 13

Capítulo 05 – Funcionamento Básico

 Serviços
 Contratos
 Service Contract
 Service Behavior
 Data Contracts
 Data Members
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 05 – Funcionamento Básico.

Anotações
14 Capítulo 05 – Funcionamento Básico

Serviços
Todo serviço necessita de estruturas básicas que definirão o que ele pode fazer, como faz e o que fornece para
uma melhor interoperabilidade. Essas estruturas são Contratos, Comportamentos e Atribuições,
respectivamente.
Contratos
Contratos tem como objetivo fornecer a estrutura que será acessível às aplicações que usufruírem desse serviço.
Em poucas palavras: é a estrutura de métodos que será disponibilizada para aplicações consumirem.
Service Contract
Quando desenvolvemos um serviço com Windows Communication Foundation, nossos contratos são definidos
a partir da Tag “ServiceContract”, contida em Interfaces. Essas interfaces nos fornecerão o que chamamos de
Definição do Serviço, ou seja, o que nosso(s) serviço(s) irão realizar.
Exemplo
Nesse exemplo, nosso contrato é a interface IMeuServico, qual está nos dizendo que o único comportamento
que será acessível é o RetornaNomePorID, recebendo um ID inteiro e retornando um texto. Somente teremos
Anotações
Capítulo 05 – Funcionamento Básico 15

esse método acessível devido a ele carregar o atributo “[OperationContract]”. Esse atributo é a marcação de
que esse método será disponibilizado quando hospedado nosso serviço. Métodos sem essa marcação, não serão
disponibilizados.
Service Behavior
Service Behaviors – Comportamentos do Serviço – são as implementações que foram ditadas na Interface. Ou
seja, quem realmente realiza as ações de nosso serviço. Com WCF, deveremos criar uma classe que implemente
a Interface com as ações disponíveis aos proxies.
Exemplo
Nesse momento podemos realizar qualquer regra de negócios, busca a bancos de dados (não exatamente nessa
camada, por favor), ou qualquer outra necessidade que cabe ao serviço, como formatações e etc. Esse é nosso
método já implementado. Isso não será acessível ao consumidor de nosso serviço.
Anotações

Dentro dessa classe, podem existir métodos que não sejam os métodos definidos na Interface, entretanto,
esses não serão exibidos.
Data Contracts
Nossos DataContracts serão as classes que fornecerão a estrutura compartilhada entre Serviço e Cliente. Ou
seja, são os objetos responsáveis pela interoperabilidade entre Serviço e Cliente. Os objetos do Serviço visíveis
e utilizáveis pelo Cliente. Esses objetos poderão ser utilizados tanto pelo cliente quanto pelo serviço, sendo uma
ótima pratica quando bem estruturados.
Podemos definir nossos DataContracts como simples classes, entretanto, levando como atributo a Tag
[DataContract]1.
Exemplo
Essa classe será acessível por pessoas que utilizarem esse serviço.
1
Não obrigatório para serviços que utilizem o framework 3.5 ou superior.
Anotações

Data Members
Quando definimos uma classe com o atributo DataContract, tornamos-lhe acessível a todos os sistemas que
consumirem esse serviço. Entretanto, somente as propriedades marcadas com o atributo DataMember que
serão visíveis.
Exemplo
Anotações

Exercícios
Crie um WCF Service Application contendo o conteúdo necessário para cadastrar e atualizar um Curso, sabendo
que um curso possui como propriedades:
 Nome Comercial
 Descrição
 Valor
 Carga Horária
 Professor Coordenador (Nome, Sobrenome, Endereço, Telefone e Certificações – contendo cada uma
delas Descrição e Empresa Emissora).
Anotações

Capítulo 06 – SOAP e REST

 Simple Object Access Protocol (SOAP)
 Representational State Transfer (REST)
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 06 – SOAP e RESTSOAP e REST.

Anotações
20 Capítulo 06 – SOAP e REST

Simple Object Access Protocol (SOAP)
SOAP - Simple Object Access Protocol - Protocolo Simples de Acesso a Objetos. É o meio de comunicação
utilizado entre sistemas que concentra a maior possibilidade de configurações e segurança.
Através desse protocolo as informações são enviadas no formato de um XML (eXtensible Markup Language) e
cada linguagem de programação traduz o conteúdo de dentro desse XML em objetos da própria linguagem.
Existem casos de linguagens que não eram capazes de realizar essa conversão de forma nativa, porém todas
elas são capazes de ler arquivos de texto, o que já resolve o problema.
SOAP tornou-se um dos protocolos de comunicação mais comuns e suas versões mais recentes permitem
grandes envios de informações de maneira gerenciada. No Brasil e no mundo universidades com foco em Pós-
Graduação da área de tecnologia da informação estão disponibilizando cursos para especializar o profissional
nesse segmento.
Exemplo Request
POST /InStock HTTP/1.1

Host: www.example.org
Content-Type: application/soap+xml; charset=utf-8
Content-Length: nnn
<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
<soap:Body xmlns:m="http://www.example.org/stock">
<m:GetStockPrice>
<m:StockName>IBM</m:StockName>
</m:GetStockPrice>
</soap:Body>
</soap:Envelope>
Exemplo Response
HTTP/1.1 200 OK
Content-Type: application/soap+xml; charset=utf-8
Content-Length: nnn
Anotações
Capítulo 06 – SOAP e REST 21

<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
<soap:Body xmlns:m="http://www.example.org/stock">
<m:GetStockPriceResponse>
<m:Price>34.5</m:Price>
</m:GetStockPriceResponse>
</soap:Body>
</soap:Envelope>
Representational State Transfer (REST)

Estado de transferência representacional, o REST tem um funcionamento extremamente parecido com o SOAP.
Em sua essência, ambos têm os mesmos objetivos finais, sendo o trafego de informações de um ponto a outro
através do protocolo HTTP. Entretanto, o formato REST tem como essência o trafego de informações através de
URI’s, como veremos em breve.
Além dessa diferença, normalmente vista como a maior diferença, o REST pode trafegar informações formatadas
em JSON, ao invés de XML, tornando o seu envio e retorno extremamente mais leve quando comparado ao
modelo SOAP tradicional, que contêm diversas configurações em seu cabeçalho para que sejam cumpridas
determinadas normas de segurança e padronização da aplicação.
Exemplo de Request
http://localhost:8732/Service1/GetData/10
Exemplo de Response
{“Id”:10, “Nome”:”Lucas Schoch”}

Anotações
22 Capítulo 06 – SOAP e REST

Exercícios
1. Quais as possibilidades de protocolo que trafegamos entre aplicações e web services?
2. Quais os tipos de envio suportados pelo padrão SOAP?
3. Quais os tipos de envio suportados pelo padrão REST?
4. Quando desenvolvemos aplicações de alta performance, porém precisando de segurança, qual padrão
utilizamos?
5. Quando desenvolvemos aplicações de baixa performance, não necessitando de segurança, qual padrão
utilizamos?
Anotações
Capítulo 06 – SOAP e REST 23

Capítulo 07 – Criando Serviços REST

 Requisitos
 Contratos
 Comportamentos
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 07 – Criando Serviços RESTCriando
Serviços REST.

Anotações
24 Capítulo 07 – Criando Serviços REST

Requisitos
Para construirmos serviços que utilizam REST ao invés de SOAP, não são necessários componentes extras,
entretanto, possivelmente, algumas bibliotecas seriam mais interessantes para o desenvolvimento de sistemas.
Em sua essência, entenda o seguinte: REST envia e recebe TEXTO. Não mais do que isso. Portanto, não existe
super implementações necessárias, é razoavelmente simples. Entretanto, como o texto a ser enviado deve ter
um padrão, para que torne-se compreensível a todas as extremidades, necessitamos aderir à XML ou JSON. Não
haveria muita lógica em escolhermos REST e trabalharmos com XML, uma vez que XML é melhor estruturado
dentro do padrão SOAP. Portanto devemos criar nossa lógica de envio e recebimento baseada em JSON.
Contratos
Nossos contratos continuarão sendo feitos baseados na lógica de Interface e Comportamento. Entretanto, não
teremos a possibilidade de enviar e receber Objetos desse serviço. Somente serão enviados e recebidos textos.
De maneira simples, podemos definir o contrato de um método basicamente definindo que ele receba e envie
texto, conforme abaixo:
O Attribute WebGet, adicionado acima do OperationContract, define o padrão do qual será enviada a
informação. A acessar http://meusite.com.br/Service/GetData será chamado esse método. O que vier após o
nome GetData será entendido como o valor da variável. Isso está definido no parâmetro UriTemplate.
Anotações
Capítulo 07 – Criando Serviços REST 25

O ResponseFormat define como será feita a resposta de nosso serviço. Xml ou Json, como já visto anteriormente,
são nossas opções.
Pensando dessa maneira, podemos ter o envio de uma só variável, sendo ela um Json com diversas informações.
O tráfego passará a ser somente uma variável string contendo Json formatado. Caberá a especificação fornecer
como esse Json será, para que ambas extremidades compreendam o formato.
Entretanto, caso queira mandar mais variáveis, também é possível. Podemos definir um método POST com mais
de um parâmetro implicitamente convertido à Json, da seguinte maneira:
O Attribute WebInvoke identifica que o método é POST, o endereço é “PostDataGetDataUsingDataContract”, o

envio e retorno são do tipo Json.
Comportamentos
Assim como em SOAP, nossos contratos somente definem o que nosso serviço fará. O Comportamento deverá
ser desenvolvido em uma classe que implemente a interface em questão, conforme abaixo:
Anotações

Repare que no exemplo abaixo, estamos utilizando um conversor de objetos para o formato Json. Esse conversor
é fornecido para nos pela Newtonsoft. Para que possamos utiliza-lo, necessitamos adicionar sua biblioteca
chamada “Json.NET” a nosso projeto. Utilize o NugetPackages para adiciona-la.
Arquivo de Configurações
Para que nossa aplicação possa ser compreendida como WebService, necessitamos dizer que nosso host será
um servidor Web. As seguintes configurações deverão ser feitas dentro do App.config de nossa aplicação:
Anotações

Anotações

Exercícios
Faça um RESTFul Service contendo todas as informações necessárias para cadastrar uma pessoa, a saber que
uma pessoa possui as seguintes propriedades:
 Nome
 Sobrenome
 Endereço(s)
 Telefone
 Data de Nascimento
 Cargo
 Empresa
Anotações

Capítulo 08 – ABC do WCF

 Address
 Binding
 Contract
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 08 – ABC do WCFABC do WCF.

Anotações
30 Capítulo 08 – ABC do WCF

Endpoints
Até agora vimos a base necessária via código para disponibilizar um serviço. Entretanto, podemos criar diversas
configurações para cada um de nossos serviços. Essas configurações se baseiam em uma estrutura chamada de
“ABC do WCF”. Esse ABC é a junção de Address, Binding e Contract.
Address
O Address consiste em um endereço único que dará a visibilidade aos consumidores daquele determinado
serviço, sobre o que está disponível naquele momento. Assim como vimos no capítulo anterior, utilizamos
normalmente definições de como isso ficará formatado através da Uri de nossa aplicação, diretamente
configurada na Interface.
Binding
Binding demonstra qual o topo de transporte, segurança, codificação, meios de transferência, entre outras
configurações que aquele determinado Endpoint terá.
Quando falamos sobre WCF, temos diversos tipos de Bindings possíveis e podemos criar os nossos. As variações
entre os Bindings já disponíveis são:
BasicHttpBinding  Transporte: HTTP.
 Segurança: None, Transport, Message e Mixed.
 Suporte à Transações: Não.
 Duplex: Não.
 Sessions: Não.
 Encoding: Text.
 Modos de Transferência: Streaming e Buffered.
WebHttpBinding  Transporte: HTTP.
 Segurança: None e Transport.
 Duplex: Não.
 Sessions: Não.
Anotações
Capítulo 08 – ABC do WCF 31

 Encoding: Text e MTOM.
WSHttpBinding  Transporte: HTTP.
 Suporte à Transações: Sim.
 Duplex: Sim.
 Sessions: Sim.
 Modos de Transferência: Buffered.
WSDualHttpBinding  Transporte: HTTP.
 Segurança: None, Message e Mixed.
 Duplex: Sim.
 Sessions: Sim.
WSFederationHttpBinding  Transporte: HTTP.
 Segurança: None e Message.
 Duplex: Não.
 Sessions: Sim.

Anotações

NetTcpBinding  Transporte: TCP.
 Duplex: Sim.
 Sessions: Sim.
 Encoding: Binary.
NetPeerTcpBinding  Transporte: Peer.
 Segurança: Transport.
 Duplex: Sim.
 Sessions: Não.
 Encoding: --.
NetNamedPipeBinding  Transporte: IPC.
 Segurança: None e Transport.
 Duplex: Sim.
 Sessions: Sim.

Anotações

NetMsmqBinding  Transporte: MSMQ.
 Segurança: None, Transport e Message.
 Duplex: Não.
 Sessions: Sim.
MsmqIntegrationBinding  Transporte: MSMQ.
 Segurança: Transport.
 Duplex: Não.
 Sessions: Não.
 Encoding: --.
Entenda, essas distinções são pensando em otimizar o envio e recebimento de informações entre extremidades.
Caberá ao desenvolvedor acessar essas distinções.
O WCF nos fornece uma estrutura amigável para alterar o App.config de uma maneira visual. Essa maneira
consiste em clicar com o botão direito sobre o App.Config e acessar a seguinte estrutura:
Anotações

A seguinte estrutura será aberta, viabilizando configurações de maneira mais visual:
Anotações

Contract
Como já vimos anteriormente, o contrato é representado pela Interface que definirá os comportamentos de
nosso serviço. Tudo que está definido nessa interface será implementado por nosso serviço.
Exemplo Contrato
Anotações

Exemplo Comportamento
Anotações

Anotações

Exercícios
1. Quando desejamos consumir um WCF Web Service criado por nós mesmos, em um sistema .NET,
devemos utilizar qual tipo de Binding para otimizar nosso processamento? Por quê?
2. Qual a principal finalidade do contrato de um Serviço?
3. Onde ficam administradas as informações de tipos de acesso disponíveis de nosso WCF Web Service?
4. Qual a necessidade de definição de uma classe que servirá como a realizadora da lógica contida em um
contrato WCF? Além disso, qual implementação não se faz obrigatória, entretanto é interessante que
exista para tornar explicito?
Anotações

Capítulo 09 – Consumir WebService SOAP com C#

 Como consumir um Web Service SOAP com C#.NET
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 09 – Consumir WebService SOAP
com C#Consumir WebService SOAP com C#.

Anotações
40 Capítulo 09 – Consumir WebService SOAP com C#

Como consumir um Web Service com WCF Test Client C#.NET
Pensando em contribuir com o conhecimento de Serviços, esse curso irá prover a você o aprendizado prático de
como a linguagem C# faz esse uso e como utilizar as melhores práticas nesse segmento tão procurado por
empregadores.
Antes de colocarmos isso em prática entenda, o C# é o responsável por essa comunicação e não o ASP.NET MVC.
É necessária a conexão com a internet para trafegar as informações por WebServices, porém não é necessário
que sua plataforma seja Web.
Tendo o conceito compreendido, utilizaremos para teste o WebService “CursosClarifyServices”. Esse serviço está
hospedado no endereço:
http://localhost:55132/Service.svc
Antes de abrirmos nosso novo projeto no Visual Studio, vamos entender melhor o que é e como funciona esse
WebService. Procure um programa na pasta desse curso chamado WCF Test Client. Esse é um software que vem
instalado por padrão no Visual Studio para testar WebServices. Sua interface é a seguinte:
Para adicionarmos nosso serviço e compreender o que ele é e como funciona precisamos seguir os seguintes
passos:
Anotações
Capítulo 09 – Consumir WebService SOAP com C# 41

Na caixa de diálogo que foi aberta, escreva o endereço que foi passado anteriormente:
Clique em Ok e aguarde o carregamento das informações:

Anotações

Foi adicionado ao nosso WCF Test Client o serviço que precisaremos. Dentro dos arquivos que ele nos oferece
visualizar temos o IService – nosso contrato (informa quais os métodos disponíveis, quais os envios e retornos
que eles necessitam) – e o arquivo Config File, que leva configurações para que aplicações possam utilizar esse
serviço. Não se preocupe em entender o funcionamento de configurações nesse momento.
Em nosso contrato IService nós teremos a listagem de métodos, conforme abaixo:
Anotações

Repare que para cada método foi criado um método de mesmo nome porém com o sufixo Async. São métodos
para enviar e solicitar assincronamente os métodos principais. Isso em nosso caso não será possível pois esse
webservice tem objetos específicos de envio e recebimento. Ou seja, teremos de usar os objetos que ele nos
fornece para poder enviar e receber outros objetos do serviço.
Para exemplificar um pouco esses métodos e seu funcionamento, clique duas vezes no método TodosAlunos().
Isso trará a seguinte visualização:
Anotações

Esse método é um método que não necessita parâmetros para retornar seu conteúdo. Nesse caso simplesmente
clique em Invoke para fazer com que ele traga as informações (chame o método). Trazendo assim a seguinte
visualização:
Anotações

Na coluna Name do quadrante Response, podemos ver selecionado uma linha de nome (return) e em sua coluna
Value ela leva o valor “length=149”. Como nosso método TodosAlunos tem como objetivo trazer todos os alunos
cadastrados em nosso banco de dados, ele nos trouxe 149 alunos. Cada um dos itens de “[0]” até “[148]” são
objetos Aluno, como podemos ver abaixo:
Anotações

Repare que nosso WCF Test Client ainda nos proporciona visualizar qual o tipo do dado que o objeto leva.
Assim como vimos anteriormente, o SOAP é um protocolo que trafega XML, portanto podemos visualizar tudo
que está vindo em formato XML, se assim desejarmos. Podemos fazer isso simplesmente clicando na aba “XML”
abaixo do quadrante Response e ao lado da aba “Formatted” – que nos traz o conteúdo formatado como vimos.
Sua visualização deve parecer-se com a seguinte:

Anotações

Repare que é extremamente semelhante a um XML tradicional, contendo Tags de abertura e fechamento, com
os valores dentro delas.
Anotações

Exercícios
Consuma o serviço CursosClarifyServices, disponibilizado pelo professor em sala de aula. Exiba todos os alunos
em uma aplicação console.
Anotações

Capítulo 10 – Consumir WebService REST com C#

 Como consumir um Web Service REST com C#.NET
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 10 – Consumir WebService REST com
C#Consumir WebService REST com C#.

Anotações
50 Capítulo 10 – Consumir WebService REST com C#

Nesse capítulo veremos todas as possibilidades de exclusão de dados em entidades de nosso banco de dados,
seja uma a uma, várias de uma só vez ou em cascata.
Assim como os capítulos anteriores, devemos criar um novo projeto e adicionar o “.edmx” relacionado ao banco
de dados ClarifyDB. Chame esse projeto de ExemploExclusoes.
Como consumir um Web Service REST com C#.NET
Definição
Para exemplificar o consumo de um Web Service REST com C#.NET utilizaremos o serviço criado no capítulo
“Criando Serviços REST”. O mesmo consiste na seguinte Interface e Comportamento:
E
Anotações
Capítulo 10 – Consumir WebService REST com C# 51

Implementação GET
Assim como já vimos anteriormente, só trafegaremos texto entre serviços REST. Isso nos informa,
implicitamente, que não teremos objetos de envio e recebimento desses envios e solicitações. Tudo será TEXTO.
Dessa maneira, devemos compreender bem o formato que devemos enviar nosso texto, e nesse caso, como
nosso Json ficará.
Anotações

Para acessarmos o método GetData, que é do tipo GET, somente é necessário informar o Endereço (Address).
Podendo ser testado até no Browser, conforme abaixo:
Repare que ao executar o projeto, o WCF Test Client não exibe a possibilidade de acessar esses métodos.
Deveremos testa-los diretamente no browser ou via chamada C#, que veremos logo abaixo.
Implementação POST
Quando desejamos enviar dados, formatados como Json para nosso serviço, devemos seguir a seguinte lógica:
1. Criar o Objeto que devemos serializar em Json.

2. Serializar o Objeto.
3. Enviar a informação para o Endereço correto, utilizando o ContentType correto.
4. Carregar o texto Json de resposta do serviço.
5. Corrigi-lo (se necessário).
6. Converter o texto já corrigido em um Objeto.
A implementação desses 6 passos segue abaixo:

Anotações

Anotações

Exercícios
Faça um programa Console Application capaz de consumir o Web Service RESTful criado no capítulo 07 desse
livro. Exiba o retorno do método após recebe-lo.
Anotações

Capítulo 11- Publicação do Web Service

 O que é o IIS
 Configurações Básicas
 Disponibilização do Web Service
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 11- Publicação do Web Service.

Anotações
56 Capítulo 11- Publicação do Web Service

O que é o IIS
O Internet Information Services – IIS – é o servidor Web da Microsoft, criado para prover a seus sistemas
operacionais uma plataforma para hospedagem de Sites, Serviços e Aplicativos, sendo capas de integrar as
tecnologias ASP.NET, FTP, PHP e WCF.
Seu principal uso, faz-se por hospedagem de dois tipos de aplicações: Web Pages e Web Services.
São suportadas páginas em ASP.NET utilizando padrões MVC, levando a extensão “.cshtml” e páginas Web
Forms, levando extensão “.aspx”. O suporte à Web Services vai desde o antecessor do WCF, ASMX Services, até
o mais avançado do WCF, podendo configurar diversas propriedades diretamente por ele.
A disponibilização de arquivos e hospedagem de páginas é feita através dos protocolos FTP (Para enviar os
arquivos necessários ao servidor) e Http/Https (para o envio e recebimento de solicitações).
Habilitando o IIS Express

Para que possamos utilizar o IIS Express, versão gratuita já contida em nosso Windows Server ou Windows 8.1,
necessitamos alguns passos.
Acessar o Painel de Controle -> Programas e Recursos:
Anotações
Capítulo 11- Publicação do Web Service 57

Clicar em “Ativar ou desativar recursos do Windows”
Anotações

Procurar o Internet Information Services, ou Serviços de Informações da Internet, e habilitar todos os conteúdos:
Anotações

Ao finalizar, acesse seu Browser e digite a seguinte URL:
http://localhost/
Anotações

Esse endereço lhe retornará a seguinte imagem:
Pronto, seu IIS está habilitado. Reinicie sua máquina.
Configurações Básicas
Antes de mais nada, acesse o programa “Gerenciador do Serviços de Informações da Internet (IIS)”, conforme
abaixo: Anotações

Só por sua tela inicial, já sabemos que estamos falando de um programa com diversas possibilidades. Nesse
capítulo daremos foco em como hospedar um WebService WCF.
Processo publicação do Web Service localmente

Anteriormente à disponibilização de nossos serviços, necessitamos gerar os arquivos necessários. Entenda,
muito pouco do que desenvolvemos será obrigatório para que nossa aplicação fique disponível em nosso
computador, sendo acessível à nossa rede, ou em um servidor Web, sendo acessível à qualquer um do qual
permitirmos.
Os arquivos necessários para publicação no servidor são:
 Todas as DLLs geradas no processo de compilação;

 Todas as DLLs que não forem default do .NET Framework;
 O arquivo Web.Config, responsável por todas as configurações da aplicação;
 O arquivo Service.svc, responsável por tornar acessível nosso Web Service.
Para separarmos de maneira inteligente, tudo que será necessário para a publicação de nosso WCF Service,
podemos utilizar o Publisher do Visual Studio. Para demonstrar seu uso, siga os passos abaixo:
Anotações

Anotações

Disponibilização do Web Service através do IIS
Tudo que você necessita para a disponibilização do Web Service está separado. Agora necessitará criar em seu
IIS um apontamento (diretório virtual) para tornar essa pasta acessível quando alguém solicitar o endereço
desejado via browser ou via programação. Esse passo a passo pode ser acompanhado conforme abaixo:
Anotações

Dê o nome que desejar, será o seu acesso ao Web Service (localhost:80/MeuRestService).
Anotações

O caminho físico deverá ser o mesmo que selecionou anteriormente para a publicação com o Publisher do Visual
Studio:
Tendo isso ok, somente faltará fornecer a permissão necessária ao diretório virtual criado:
Anotações

Devido a não conhecer os padrões de segurança de sua empresa, nesse exemplo darei permissão a todos os
usuários:
Anotações

Essa permissão deverá ser do tipo Controle Total.
Pronto, seu WebService está disponível para acessar de qualquer local, conforme abaixo:
Anotações

Anotações

Exercícios
Publique todos os Web Services criados e disponibilizados pelo Instrutor desse curso. Acesse todos eles através
do WCF Test Client. Após acessa-los no Test Client, faça uma chamada através de um programa C# que acessará
todos os serviços.
OBS: Somente um programa C#.

Anotações

Capítulo 12 - Windows Service

 O que é um Windows Service
 Configurações Básicas
 Disponibilização do Serviço
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 12 - Windows Service.

Anotações
Capítulo 12 - Windows Service 71

O que é um Windows Service
O sistema operacional Windows, é composto por diversas tarefas sendo executadas ao mesmo tempo. Quando
desenvolvemos um software, esse software passa a ser um processo, uma tarefa que o sistema operacional
trata para que, em paralelo a tudo que já está acontecendo, a sua aplicação seja utilizável pelo usuário.
Existem diversos tipos de processos distintos dentro do Windows. Um deles é através de Serviços. Os serviços
são aplicações que “executam em background” e não possuem interface gráfica, ou seja, não tem iteração direta
com o usuário. Muito similar ao agendamento de tarefas de um banco de dados, serviços são softwares que
estão em execução enquanto o computador estiver ligado (ou enquanto o usuário administrador desejar).
Podemos criar serviços do Windows quando desejamos que algo fique ocorrendo a todo momento, ou quando
necessitamos que algo em determinada hora do dia, ou quando algo aconteça, seja executado. Para criarmos
nosso serviço, necessitamos seguir alguns passos.
Configurações Básicas
Tipo do Projeto
Crie um projeto do tipo Windows Service (C#), conforme abaixo:
Anotações
72 Capítulo 12 - Windows Service

Nomeie o projeto como desejar e escolha o local apropriado para salvar.
Classes Envolvidas
Esse template de projeto, possui duas principais classes, a Program.cs e a Service1.cs. Além dessas duas
classes, o que difere esse projeto de um Class Library é a referência ao Namespace System.ServiceProccess,
que será o responsável por viabilizar a criação de nossos serviços.
Ao abrir a classe Service1.cs, temos a seguinte visualização:
Repare, nossa classe herda de ServiceBase, quem contém métodos para inicialização e termino de nossos
serviços.
Em nossa classe Program.cs, nada difere-se de um Windows Forms Application ou de um Class Library.
Possuímos um método Main, onde tudo que será executado acontecerá dentro dele. Entretanto, temos dentro
de nosso método, já preparado um exemplo de inicialização de nosso serviço, conforme abaixo:
Anotações

Só de analisar esse código, podemos compreender que a classe ServiceBase que executará nossos serviços, e
que todo serviço deverá ser instanciado dentro de um array do tipo ServiceBase, ficando mais explicito ainda
que nossos serviços devem herdar dessa classe.2
Execução em fase de testes (DEBUG)

Sem alterarmos nada, ao tentar executar o projeto, receberemos a seguinte mensagem:
Isso significa, que estamos tentando publicar esse serviço e testa-lo ao mesmo tempo. Esse processo ocorre
muito bem com sites, por exemplo. Entretanto, para trabalharmos com serviços, teremos de tratar se a
2
Assim como vimos nos fundamentos da linguagem C#, essa lógica de execução de serviços utiliza de Polimorfismo.
Dúvidas a respeito dessa lógica devem ser revistas nos fundamentos da linguagem.
Anotações

aplicação está sendo testada ou publicada, sendo necessário o uso de códigos específicos para questionar o
tipo de execução de nossa aplicação, conforme abaixo:
Seguindo essa lógica, necessitamos que caso não seja DEBUG (ou seja, em tempo de desenvolvimento),
devemos poder testar esse serviço. Podemos tornar isso factível executando o método OnStart de nossa classe
Service1.cs. Entretanto, esse método é protegido, não sendo possível a execução dele a partir de instancias
diretas da classe, somente por classes filhas a essa.3
Para viabilizar nossos testes, criamos um método void chamado Debugando, que simplesmente inicializa nosso
serviço, conforme abaixo:
3
Encapsulamento, fundamentos da linguagem e orientação a objetos.
Anotações

E em nossa classe Program.cs, teremos o seguinte bloco de código:
Anotações

Dessa maneira, tudo que desenvolvamos dentro do método OnStart de nossa classe Service1.cs será
executado, exatamente como se o serviço estivesse executando.
Dica:
Dentro desse método colocaremos nossas lógicas de negócios. Peço que fiquem atentos principalmente na
criação de arquivos de logs. Caso o arquivo esteja sendo escrito pelo serviço, não poderá visualizar enquanto o
processo não terminar. Trate bem em seu código para abrir e fechar os arquivos com try..catch...finally.
Publicação do serviço nos Serviços do Windows

Para que possamos testar se nosso serviço está sendo executado ou não, devemos implementar algo nos
métodos OnStart e OnStop. Faremos a criação de dois arquivos, por exemplo:
Anotações

Caso, acessemos a pasta bin de nosso projeto, teremos a seguinte estrutura:
Anotações

Caso clique no arquivo executável, da maneira em que desenvolvemos, seu programa será executado como
segundo plano e não como um serviço:
Anotações

Isso ocorre devido a nossa aplicação estar em Debug. Mude-a para Release e recompile o projeto, gerando a
seguinte estrutura na pasta Release:
Anotações

Caso clique no executável agora, terá a seguinte mensagem de erro novamente:
Não podemos executar nosso serviço como uma aplicação, necessitamos publica-lo nos serviços do Windows.
Para isso devemos seguir o seguinte passo-a-passo:
Anotações

1. Adicionar os instaladores ao projeto
Clique duas vezes no arquivo Service1.cs, abrindo seu modo designer. Adicione a ele um Instalador, conforme
abaixo:
Dê a seu instalador um nome (Será o nome visível de seu serviço nos Serviços do Windows) conforme abaixo:
Anotações

Recompile o seu projeto para garantir as mudanças na versão.
2. Developer Prompt
Execute como administrador o seguinte arquivo contido na pasta: C:\Program Files (x86)\Microsoft Visual
Studio 12.0\Common7\Tools\Shortcuts :
Anotações

Isso abrirá um prompt de comando com propriedades e funcionalidades de administrador contendo
ferramentas e comandos de desenvolvedor.
3. Siga os seguintes comandos:

Cd : (diretório Release da sua aplicação)
Dir
Installutil ClarifyWinService.exe
Possivelmente será solicitado Logon de Administrador da máquina ou do servidor da rede responsável por
essa estação. Pronto, agora você hospedou no Windows seu Serviço, consulte-o na aba de serviços do
Windows, pelo nome passado, conforme abaixo:
Anotações

4. Teste
Teste os métodos OnStart e OnStop iniciando e parando seu serviço.
Anotações

Capítulo 13 - O Que Mais Está Por Vir?

 Web com ASP.NET MVC
 Mobile com Windows Phone
 Próximos Passos na Clarify
Os exemplos e exercícios utilizados neste capítulo estão na pasta: Capítulo 13 - O Que Mais Está Por Vir?

Anotações
86 Capítulo 13 - O Que Mais Está Por Vir?

Web com ASP.NET MVC
Posteriormente ao conhecimento referente à acesso e manipulação de dados e de um banco de dados, devemos

descobrir como funcionam os Sites, Redes Sociais, Aplicativos e etc., que funcionam na internet.
Para melhor desenvolver seus projetos Web, a Microsoft criou uma linguagem acoplada ao C# chamada ASP.NET
MVC, ela visa em repartir em 3 partes a estrutura de um Site ou Intranet, dando maior praticidade, legibilidade
e manutenção dos códigos. Todo seu código é escrito em C#, porém quando falamos em tecnologias Web, temos
de trabalhar quatro ambientes, sendo eles:
 HTML
 CSS
 JavaScript
 Código em C#
O ASP.NET MVC veio para prover uma junção dessas ferramentas de uma maneira inteligente e performática.
Anotações
Capítulo 13 - O Que Mais Está Por Vir? 87

Mobile com Windows Phone
O mundo cada vez mais interage com ferramentas e aplicativos para celulares e tablets. Dada essa necessidade
de desenvolver para diversas plataformas móveis, a Microsoft lançou o SDK (Software Development Kit) para
Windows Phone.
Esse SDK juntamente com o .NET Framework, nos provê uma ferramenta fortíssima de desenvolvimento móvel,
sendo capaz de criarmos e publicarmos aplicativos no MarketPlace (Loja Microsoft) em questão de minutos.
Sendo uma das principais áreas de procura de profissional no brasil, o desenvolvedor atual não pode
desconsiderar a possibilidade de aprender uma tecnologia, seja ela qual for.
Anotações
88 Capítulo 13 - O Que Mais Está Por Vir?

Próximos Passos na Clarify Treinamentos
Anotações
Capítulo 13 - O Que Mais Está Por Vir? 89

Apêndice - Respostas dos Exercícios
Neste apêndice o aluno conhecerá as respostas dos exercícios:

 Capítulo 01 – Introdução à Arquiteturas de
Aplicações
 Capítulo 02 – Service Oriented Architecture (SOA)
 Capítulo 03 – Windows Communication
Foundation
 Capítulo 04 – Tipos de Projeto e Estruturação
 Capítulo 05 – Funcionamento Básico
 Capítulo 06 – SOAP x REST
 Capítulo 07 – Criando Serviços REST
 Capítulo 08 – ABC do WCF
 Capítulo 09 – Consumir Web Service SOAP com C#
 Capítulo 10 – Consumir Web Service REST com C#
 Capítulo 11 – Publicação do Web Service
 Capítulo 03
Anotações
90 Apêndice - Respostas dos Exercícios

Os exemplos e exercícios utilizados neste capítulo estão na pasta: Apêndice - Respostas dos Exercícios.
Anotações
Apêndice - Respostas dos Exercícios 91

Capítulo 01 – Introdução à Arquiteturas de Aplicações
 Faça um mapa hierárquico contendo Arquitetura, Design Pattern e Multicamadas. Dê um exemplo da
responsabilidade de cada uma das camadas.
Capítulo 02 – Service Oriented Architecture (SOA)

1. Diferencie Arquitetura de Software e Arquitetura Orientada a Serviços.
R:. Arquitetura de software é a maneira como a aplicação irá interagir entre seus sistemas. Arquitetura
Orientada a Serviços é tornar essa iteração somente através de serviços.
2. Qual a utilidade de adotar um barramento através de serviço (ESB)? Cite ao menos três.
R:. Barramentos através de serviço nos fornecem um ambiente único de acesso a informações complexas
e entre vários sistemas distintos. Proporciona uma fácil comunicação entre sistemas com linguagens de
programação distintas. Fornece uma estrutura inteligente para que possamos interagir facilmente com
fornecedores e clientes. Proporciona que os profissionais mais especializados, por fim mais caros, sem
reduzidos, sendo necessário um ótimo programador do Web Service, não sendo tão necessário super
programadores de todas as linguagens (IOS, Android, Windows Phone, sites, etc.).
Anotações

Capítulo 03 – Windows Communication Foundation
1. Marque Verdadeiro ou Falso. Explique sua escolha.
a. ( FALSO ) Quando desenvolvemos serviços com WCF podemos criar Web Sites e Apps
para smartphones.
R:. Não desenvolvemos sites ou aplicativos. Desenvolvemos serviços que podem ser acessados
por qualquer tipo e aplicação.
b. ( VERDADEIRO ) Através do WCF podemos fornecer serviços de alta escalabilidade à

Web Sites, Apps para smartphones, aplicações Windows, MAC, Linux ou qualquer outro sistema
operacional e linguagem de programação.
c. ( FALSO ) Necessitamos instalar em nosso Visual Studio a extensão para WCF
Enterprise.
R:. Nada é necessário além do Visual Studio.
d. ( VERDADEIRO ) WCF é o mais completo conjunto de ferramentas para

desenvolvimento de Web Services com as linguagens do .NET Framework.
2. Quais tipos de serviços podemos criar com WCF e o que podem fazer cada um deles (brevemente)?
Windows Services – Serviços para serem executados do Windows.
Web Services SOAP E REST– Métodos disponíveis através da Web.
Anotações

Capítulo 04 – Tipos de Projeto e Estruturação
1. Seja qual for nosso Serviço, deveremos compreender onde ele se encontra, o que ele realiza e como
podemos acessa-lo. O que isso define?
R:. Endpoint : Address Binding Configuration.
2. Quando trabalhamos com o Visual Studio, podemos criar vários tipos de projetos relacionados a WCF.
Quais são os dois principais e o que os difere um do outro?
Service Application e Service Library
Service Application já vem pré-configurado para ser disponibilizado através de um servidor Web.
Service Library nos provê o necessário para definirmos quem será o seu Host.
Capítulo 05 – Funcionamento Básico

Crie um WCF Service Application contendo o conteúdo necessário para cadastrar e atualizar um Curso, sabendo
que um curso possui como propriedades:
 Nome Comercial
 Descrição
 Valor
 Carga Horária
 Professor Coordenador (Nome, Sobrenome, Endereço, Telefone e Certificações – contendo cada uma
delas Descrição e Empresa Emissora).
Respondido em forma de projeto.

Anotações

Capítulo 06 – SOAP e REST
1. Quais as possibilidades de protocolo que trafegamos entre aplicações e Web Services?
SOAP e REST
2. Quais os tipos de envio suportados pelo padrão SOAP?
XML
3. Quais os tipos de envio suportados pelo padrão REST?
XML ou Json
4. Quando desenvolvemos aplicações de alta performance, porém precisando de segurança, qual padrão
utilizamos?
SOAP
5. Quando desenvolvemos aplicações de baixa performance, não necessitando de segurança, qual padrão
utilizamos?
SOAP
Capítulo 07 – Criando Serviços REST

Faça um RESTFul Service contendo todas as informações necessárias para cadastrar uma pessoa, a saber que
uma pessoa possui as seguintes propriedades:
 Nome
 Sobrenome
 Endereço(s)
 Telefone
 Data de Nascimento
 Cargo
 Empresa
Anotações

Capítulo 08 – ABC do WCF
1. Quando desejamos consumir um WCF Web Service criado por nós mesmos, em um sistema .NET,
devemos utilizar qual tipo de Binding para otimizar nosso processamento? Por quê?
NetTCPBinding – provê o conteúdo de maneira otimizada pois trafega bytecodes C#, interpretados
mais facilmente do que texto XML.
2. Qual a principal finalidade do contrato de um Serviço?
Definir o que o serviço tem como disponibilidade e qual a maneira de acessar essa informação.
3. Onde ficam administradas as informações de tipos de acesso disponíveis de nosso WCF Web Service?
Web.config
4. Qual a necessidade de definição de uma classe que servirá como a realizadora da lógica contida em um
contrato WCF? Além disso, qual implementação não se faz obrigatória, entretanto é interessante que
exista para tornar explicito?
Obrigatoriamente deverá implementar a interface que define o Contrato. Além disso, podemos
explicitar que essa classe é o “ServiceBehavior”, sendo claro ser o comportamento daquela interface
que serve como Contrato. Fazemos isso pela Tag “[ServiceBehavior]” acima da definição da classe.
Capítulo 09 – Consumir Web Service SOAP com C#

Consuma o serviço CursosClarifyServices, disponibilizado pelo professor em sala de aula. Exiba todos os alunos
em uma aplicação console.
Capítulo 10 – Consumir Web Service REST com C#

Faça um programa Console Application capaz de consumir o Web Service RESTful criado no capítulo 07 desse
livro. Exiba o retorno do método após recebe-lo.
Capítulo 11 – Publicação do Web Service

Publique todos os Web Services criados e disponibilizados pelo Instrutor desse curso. Acesse todos eles através
do WCF Test Client. Após acessa-los no Test Client, faça uma chamada através de um programa C# que acessará
todos os serviços.
OBS: Somente um programa C#.

Anotações

WC01 - WCF Com C#

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

WC01 - WCF Com C#

Enviado por

Direitos autorais:

Formatos disponíveis

WCF – Web Services

Sobre Este Curso

Desenvolvedores interessados em aprender e aperfeiçoar

PÚBLICO ALVO ........................................................................................................................................................................... I

CAPÍTULO 01 - INTRODUÇÃO À ARQUITETURAS DE APLICAÇÕES ......................................................................................1

ARQUITETURA DE SOFTWARE .......................................................................................................................................................2

CAPÍTULO 02 – SERVICE ORIENTED ARCHITECTURE (SOA) .................................................................................................4

O QUE É ARQUITETURA ORIENTADA A SERVIÇOS SOA ......................................................................................................................5

CAPÍTULO 03 – WINDOWS COMMUNICATION FOUNDATION ...........................................................................................7

O QUE É O WCF .......................................................................................................................................................................8

CAPÍTULO 04 – TIPOS DE PROJETO E ESTRUTURAÇÃO ....................................................................................................11

COMPREENSÃO BÁSICA .............................................................................................................................................................12

CAPÍTULO 05 – FUNCIONAMENTO BÁSICO .....................................................................................................................14

CAPÍTULO 06 – SOAP E REST ........................................................................................................................................... 20

SIMPLE OBJECT ACCESS PROTOCOL (SOAP) ................................................................................................................................ 21

CAPÍTULO 07 – CRIANDO SERVIÇOS REST ....................................................................................................................... 24

CAPÍTULO 08 – ABC DO WCF ........................................................................................................................................... 30

CAPÍTULO 09 – CONSUMIR WEBSERVICE SOAP COM C# ................................................................................................. 40

CAPÍTULO 10 – CONSUMIR WEBSERVICE REST COM C# .................................................................................................. 50

COMO CONSUMIR UM WEB SERVICE REST COM C#.NET .............................................................................................................. 51

CAPÍTULO 11- PUBLICAÇÃO DO WEB SERVICE ................................................................................................................ 56

O QUE É O IIS ........................................................................................................................................................................ 57

CAPÍTULO 12 - WINDOWS SERVICE ................................................................................................................................. 71

CAPÍTULO 13 - O QUE MAIS ESTÁ POR VIR? ....................................................................................................................86

WEB COM ASP.NET MVC .......................................................................................................................................................87

APÊNDICE - RESPOSTAS DOS EXERCÍCIOS ........................................................................................................................90

CAPÍTULO 01 – INTRODUÇÃO À ARQUITETURAS DE APLICAÇÕES .......................................................................................................92

Texto original registrado no Escritório de Direitos Autorais da Fundação Biblioteca Nacional.

Coordenação Conteúdos Revisão

Histórico das Edições

© Copyright 2015 Clarify. Todos os direitos reservados.

[] Em elementos de sintaxe, engloba itens opcionais. Por exemplo, [nomedearquivo] na

Neste capítulo você irá aprender:

Este capítulo levará aproximadamente 60 minutos

Capítulo 01 - Introdução à Arquiteturas de Aplicações 1

2 Capítulo 01 - Introdução à Arquiteturas de Aplicações

Capítulo 01 - Introdução à Arquiteturas de Aplicações 3

Neste capítulo você irá aprender:

 O que é Arquitetura Orientada a Serviços SOA

4 Capítulo 02 – Service Oriented Architecture (SOA)

Enterprise Service Bus (ESB)

Capítulo 02 – Service Oriented Architecture (SOA) 5

6 Capítulo 02 – Service Oriented Architecture (SOA)

Neste capítulo você irá aprender:

Este capítulo levará aproximadamente 120 minutos

Capítulo 03 – Windows Communication Foundation 7

O que podemos realizar com WCF

8 Capítulo 03 – Windows Communication Foundation

Requisitos para o desenvolvimento

Capítulo 03 – Windows Communication Foundation 9

b. ( ) Através do WCF podemos fornecer serviços de alta escalabilidade à Web Sites,

c. ( ) Necessitamos instalar em nosso Visual Studio a extensão para WCF Enterprise.

d. ( ) WCF é o mais completo conjunto de ferramentas para desenvolvimento de Web

10 Capítulo 03 – Windows Communication Foundation

Neste capítulo você irá aprender:

Este capítulo levará aproximadamente 120 minutos

Capítulo 04 – Tipos de Projeto e Estruturação 11

O que é um serviço WCF?

O que são os EndPoints?

O relacionamento de Address, Binding e Contract é chamado de EndPoint (A+B+C).

Veremos mais detalhadamente o funcionamento desse ABC em capítulos posteriores.

Service Library x Service Application (Host Environment)

12 Capítulo 04 – Tipos de Projeto e Estruturação