Editorial. Preparamos para este mês de Fevereiro uma coleção de artigos compostos dos mais diversos tipos de assuntos no mundo da programação.

Caro leitor,

Preparamos para este mês de Fevereiro uma coleção de artigos compostos dos mais diversos tipos de assuntos no mundo da programação.

Para iniciar nossa série, o colunista mensal Luciano Pimenta redigiu a quarta parte do artigo sobre “XamarinForms“, o qual nos apresenta o controle “ListView”, um dos mais usados em aplicações mobiles para exibir dados em lista. Ele também irá demonstrar a facilidade de implementá-lo, customizá-lo adicionado imagens, textos e outras dicas importantes. Já nosso outro colaborador Ricardo Barbosa Crivelli escreveu o artigo “Enviando e-mails com o Laravel”. Ele nos ensina todo o conceito de “Mailable”, como gerenciar as “views” e os anexos. Ele aborda a classe “Mail” que é muito mais extensa possuindo muitas outras funcionalidades que serão comentadas em possíveis futuros artigos. Para finalizar a série sobre o framework “ASP. NET Web API”, o consultor técnico Thiago Cavalheiro Montebugnoli trouxe o artigo intitulado “ASP. NET Web API – Implementando o método PUT e DELETE”. Neste mês ele implementou os métodos para alteração e exclusão de dados, com o auxílio da ferramenta “Telerik Fiddler”, a qual faz o papel de cliente, disparando os serviços supracitados.

Desejo uma ótima leitura, um forte abraço e até o mês que vem!

Marcos César Silva

Diretor Técnico

Editorial

Xamarin Forms – ListView

Para você que está acompanhando a nossa série sobre Xamarin Forms, mostramos até agora o conceito do Xamarin Forms e a criação de aplicações nativas para as plataforms Androis, iOS e Windows Phone. Conhecemos os controles mais comuns para criação de aplicações mobile.

Neste artigo começaremos a desvendar o ListView, sem dúvida, um dos controles mais usados em aplicações mobile para apresentação de dados em forma de lista. Veremos como podemos preencher o controle (a fonte de dados), como customizar o mesmo, entre outras funcionalidades.

ListView

O ListView é um dos controles mais usados em aplicações mobile. Sua característica é mostrar uma lista de dados, onde podemos ter uma listagem simples, com imagens, agrupada, configurar cabeçalho e rodapé entre outros, ou seja, podemos customizar a lista de dados.

Os dados que preenchem o ListView podem ser originados de qualquer fonte: banco mobile, um array, consulta remota etc. O ListView tem várias funcionalidades interessantes, como “puxar” a lista para atualizar, ações de contexto (menus ao arrastar um item para o lado) etc.

Vamos criar um um novo projeto e dar o nome de “ListViewSample”. Na MainPage remova o Label e adicione o seguinte código:

<ListView x:Name="listView"/>

No MainPage.xaml.cs vamos colocar o código para preencher o ListView, conforme a Listagem 1.

private void CarregaListView()

{

List<string> lista = new List<string>();

lista.Add("C#");

lista.Add("Android");

lista.Add("iOS");

lista.Add("Xamarin Forms");

listView.ItemsSource = lista;

}

Rode o projeto e visualize os dados no ListView (Figura 1).

Figura 01. ListView com os dados

Essa é a maneira mais simples de exibir dados em um ListView, bastante semelhante quando preenchemos um Picker no artigo anterior. Para mudar o layout, temos muitas opções, onde podemos personalizar a aparência da “célula”, o item da lista etc.

Temos duas maneiras de personalização da célula: usar as do Xamarin Forms ou criar as nossas próprias configurações.

Para personalizar a célula podemos usar o TextCell, que como o próprio nome indica, mostrará um texto.

No TextCell podemos configurar a cor e também exibir um detalhe (texto abaixo do configurado no TextCell). Crie uma nova página (“ListViewCellPage.xaml”) e adicione o código do ListView para o da Listagem 2.

<ListView x:Name="listView">

<ListView.ItemTemplate>

<DataTemplate>

<TextCell Text="{Binding tecnologia}" Detail="{Binding

empresa}" /> </DataTemplate>

</ListView.ItemTemplate>

</ListView>

Listagem 2. Customizando as células do ListView

Agora, precisamos alterar o código que carrega os dados, pois temos mais de um texto, assim, vamos criar um objeto e preencher uma lista (Listagem 3). Crie o arquivo da classe e dê o nome de “DTOListView.cs”.

public class DTOListView

{

public string tecnologia {get; set; }

public string tecnologia { get; set; }

...

private void CarregaListView()

{

ObservableCollection<DTOListView> lista = new

ObservableCollection<DTOListView>(); lista.Add(newDTOListView {

tecnologia = "C#", empresa = "Microsoft" }); lista.Add((new

DTOListView { tecnologia = "Android", empresa = "Google" });

lista.Add((new DTOListView { tecnologia = "iOS", empresa = "Apple"

}); lista.Add((new DTOListView { tecnologia = "Xamarin Forms",

empresa = "Xamarin" }); listView.ItemsSource = lista;

}

Listagem 3.Mudando os dados do ListView

Usamos um ObservableCollection, classe que representa uma coleção de dados dinâmicos e que oferece suporte de notificações quando os itens dessa coleção são adicionados, removidos ou a lista é alterada.

Assim, se alterarmos a lista, não precisamos atribuir novamente a propriedade ItensSource do ListView, o Xamarin se encarrega de atualizar a lista. Rode a aplicação e veja o resultado (Figura 2).

Figura 02. Customizando as células do ListView

E se quisermos mostrar uma imagem na lista? Simples, vamos usar o ImageCell, que além de mostrar um texto, exibe uma imagem alinhada à esquerda, configurada na fonte de dados do ListView.

Primeiro, vamos mudar o carregamento dos dados, passando imagens para o objeto criado anteriormente. Para isso, basta adicionar a propriedade “imagem” na classe DTOListView e preencher a mesma no método que carrega os dados no ListView.

Nota: essas imagens foram adicionadas na pasta Resources>drawable do projeto Android e Resources no

projeto iOS.

<ImageCell Text="{Binding tecnologia}" Detail="{Binding empresa}"

ImageSource="{Binding imagem}" / >

Rode a aplicação e veja a lista com imagens (Figura 3).

Figura 03. Imagens no ListView do projeto

E se precisarmos de mais customizações? Podemos usar os recursos do Xamarin Forms e a nossa imaginação. Dentro de um DataTemplate>ViewCell podemos colocar o layout que precisamos.

De um Label até um Grid podemos usar nessa célula. Altere o código anterior para o da Listagem 4 onde vamos usar um Image e alterar a disposição dele na célula.

<ListView x:Name="listView">

<ListView.ItemTemplate>

lt;DataTemplate>

<ViewCell>

<StackLayout Orientation="Horizontal">

<Image Source="{Binding imagem}" />

<Label Text="{Binding tecnologia}" TextColor="Blue"

FontAttributes="Bold" /> <Label Text="{Binding empresa}"

HorizontalOptions="EndAndExpand"

TextColor="Gray" FontAttributes="Italic" />

</StackLayout>

</ViewCell>

</DataTemplate>

</ListView.ItemTemplate>

</ListView>

Usando Label e Image, vamos mostrar os mesmos dados, mas com disposição e configuração diferente da anterior. Veja o resultado na Figura 4.

Figura 04. Customizando o layout da célula

Como comentei, ainda podemos usar um Grid, usando o código da Listagem 5.

<ListView x:Name="listView">

<ListView.ItemTemplate>

<DataTemplate>

<ViewCell>

<StackLayout Orientation="Horizontal"

Padding="10,5,5,10"> <Grid

HorizontalOptions="FillAndExpand">

<Grid.RowDefinitions>

<RowDefinition Height="*" />

<RowDefinition Height="*" />

</Grid.RowDefinitions>

<Grid.ColumnDefinitions>

<ColumnDefinition Width="*" />

<ColumnDefinition Width="*" />

</Grid.ColumnDefinitions>

<Image Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2"

Source="{Binding imagem}" HeightRequest="50" WidthRequest="50" />

<Label Grid.Row="1" Grid.Column="0" Text="{Binding

tecnologia}" TextColor="Blue" HorizontalTextAlignment="Start"/>

<Label Grid.Row="1" Grid.Column="1" Text="{Binding

empresa}" HorizontalOptions="EndAndExpand" TextColor="Gray"

HorizontalTextAlignment="End"/>

</Grid>

</StackLayout>

</ViewCell>

</DataTemplate>

</ListView.ItemTemplate>

</ListView>

Temos algumas configurações importantes. HasUnevenRows do ListView indica que os itens tenham o mesmo tamanho, assim, não teremos problemas de imagens maiores que outras. Colocamos como FiilAndExpand a propriedade HorizontalOptions do Grid para que ele fique do tamanho da célula.

Ainda no Grid, temos referência a quantidade de colunas e linhas que ele deve ter (nesse exemplo, duas linhas e duas colunas).

Nota: O Grid NÃO é ligado a uma fonte de dados, as colunas e linhas servem para definir o layout.

Nesse exemplo, passamos “*” para a Height (para a linha) e Width (para a coluna), indicando para pegar o tamanho proporcional ao espaço restante. Mas, podemos colocar valores fixos ou usar a opção Auto que vai ajustar o tamanho ao conteúdo da linha. Como estamos customizando uma célula, o layout será replicado para cada item do ListView.

Após, definimos novamente os controles de tela (Label e Image) e note que nas propriedades dos controles devemos indicar a linha e coluna que ele deverá exibir no Grid. Na imagem, colocamos um ColumnSpan para usarmos o tamanho de duas colunas, ou seja, fazermos um “mergê” entre as colunas e vamos mostrar a imagem centralizada.

Também definimos o tamanho da imagem, para que a mesma não fique desproporcional na célula. Tome cuidado nessa configuração, é muito comum criar layouts totalmente desconfigurados em tela, por indicar incorretamente a coluna e linha. Rode o projeto e veja o novo visual da célula do ListView (Figura 5).

Figura 5. Usando um grid na célula do ListView

Nota: nesse tipo de layout, é importante usarmos o Xamarin Forms Previewer, pois podemos visualizar o layout

sem precisar ficar carregando a aplicação.

Conclusão

Vimos nesse artigo, apenas um pouco do que o ListView no Xamarin Forms nos proporciona. No próximo artigo, veremos como agrupar os itens, totalizador de itens agrupados, formatação de cabeçalho e rodapé do controle.

Também veremos como pesquisar em um ListView, algo bastante comum em qualquer aplicativo mobile.

Sobre o Autor

Luciano Pimenta (NOVO DOMINIO: www.lucianopimenta.com) é desenvolvedor Delphi/C# para aplicaÇÕes Web com ASP.NET, Windows com Win32 e Windows Forms com .NET. Palestrante da 4° edição da Borland Conference (BorCon) e da 1° Delphi Conference. É MVP Embarcadero, grupo de profissionais que ajudam a divulgar o Delphi no mundo. Atualmente é desenvolvedor da SoftDesign fábrica de softwares em Porto Alegre-RS. Autor de mais de 80 artigos e de mais de 600 vídeos aulas publicadas em revistas e sites especializados, além de treinamentos presenciais e multimídias. É consultor da FP2 Tecnologia (www.fp2.com.br) onde ministra cursos de programação e banco de dados.

Enviando e-mails com o Laravel

Introdução

Atendendo à pedidos, o artigo de hoje não será sobre o sistema de biblioteca que estava sendo desenvolvido com o Laravel. Nós vamos dar um passo a frente e falar sobre o envio de e-mails usando o framework. Como você já pode imaginar o processo, assim como quase tudo, é muito simples e fácil de ser implementado.

Criando um projeto

Para este artigo nós iremos utilizar um novo projeto, para isso execute o comando abaixo na pasta em que você deseja armazenar seu projeto. Eu irei chama-lo de Mailer:

laravel new mailer

Criando uma Mailable

Cada tipo de mensagem no Laravel é representado por uma classe que nós chamamos de Mailable. Elas são armazenadas no diretório

app/Mail,

que será criado ao gerar a sua primeira Mailable. Existe um comando que facilitamuito a nossa vida que é o

make:mail,

vamos criar uma mensagem de boas-vindas através do comando:

php artisan make:mail WelcomeMessage

Abra o arquivo gerado em app/Mail/WelcomeMessage.php e veja que ele possui duas funções já pré-implementadas: o construtor e o método

build().

Ele é muito importante, pois como o nome sugere, é o método responsável por criar todaa nossa mensagem.

Definindo o remetente

O primeiro passo é definir quem irá enviar a mensagem, ou seja, o remetente de nosso e-mail. Isso pode ser definido de duas formas, a primeira é utilizando o método

from():

public function build() {

return $this

->from('rico@capim.art.br')

->view('view.name');

}

É possível também informar o nome passando como segundo parâmetro:

public function build() {

return $this

->from('rico@capim.art.br', 'Rico Crivelli')

->view('view.name');

}

A segunda forma é declarar um “from global” acabando com a necessidade de se chamar a função

from()

...

'from' => [

'address' => env('MAIL_FROM_ADDRESS',

'rico@capim.art.br'), 'name' =>

env('MAIL_FROM_NAME', 'Rico Crivelli'),

],

...

É possível configurar um endereço para resposta diferente do remente e esse processo é muito semelhante ao passoanterior:

public function build() {

return $this->from('rico@capim.art.br', 'Rico Crivelli')

->replyTo('ricardocrivelli@gmail.com', 'Ricardo Crivelli')

->view('view.name');

}

Configurando a view

É claro que a equipe de desenvolvimento iria fazer uso do Blade para gerir a view do e-mail. Se você não conhece, o Blade é o mecanismo responsável por renderizar todas as views do Laravel. É muito prático, rápido e simples de ser utilizado, basta chamar a função

view():

public function build() {

return $this->from('rico@capim.art.br', 'Rico Crivelli')

->replyTo('ricardocrivelli@gmail.com', 'Ricardo Crivelli')

->view('emails.messages.welcome');

}

O Laravel irá buscar pelo arquivo

welcome.blade.php

em

resources/views/emails

e exibi-lo como corpo da mensagem. É claro que você pode guardar seus e-mails junto com suas views em

resources/views

,

mas para padronização e facilidade de manutenção é aconselhável mantê-las todas em uma pasta separada.

É possível enviar uma mensagem em texto puro, para em casos que o usuário não consiga renderizar o HTML ou para acessibilidade. Basta informar a view que será utilizada no método

text():

public function build() {

return $this->from('rico@capim.art.br', 'Rico Crivelli')

->replyTo('ricardocrivelli@gmail.com', 'Ricardo Crivelli')

->view('emails.messages.welcome')

->text('emails.messages.welcome_text');

}

Incluindo informações externas

Vamos supor que o usuário ao se cadastrar irá receber a última edição da The Club anexo no e-mail, e que nós queremos colocar as informações desta edição na mensagem do e-mail. Para isso vamos criar um modelo chamado Edicao:

php artisan make:model -m Edicao

Para não prolongar muito o artigo não vou criar o banco de dados e as colunas da tabela, se você ainda não souber com fazer basta dar uma olhada nos artigos anteriores.

Existem duas formas de tornar as informações disponíveis no corpo do e-mail. A primeira que a que eu recomendo é através do método

with():

<?php

namespace App\Mail;

use App\Edicao;

use Illuminate\Bus\Queueable;

use Illuminate\Mail\Mailable;

use Illuminate\Queue\SerializesModels;

use Illuminate\Contracts\Queue\ShouldQueue;

class WelcomeMessage extends Mailable {

use Queueable, SerializesModels;

/** @var Edicao */

protected $edicao;

public function __construct( Edicao $edicao ) {

$this->edicao = $edicao;

}

public function build() {

return $this->from( 'rico@capim.art.br', 'Rico Crivelli' )

->replyTo( 'ricardocrivelli@gmail.com', 'Ricardo Crivelli' )

->view( 'emails.messages.welcome' )

->text( 'emails.messages.welcome_text' )

->with( [

'mes' => $this->edicao->mes,

'ano' => $this->edicao->ano,

'numero' => $this->edicao->numero

] );

}

}

Eu prefiro este método por ser mais fácil o controle de qual informação estará disponível no e-mail, mas é claro que você pode passar o objeto

$edicao

inteiro e chamar as propriedades no corpo do e-mail (

{{ $

edicao->numero}},

por exemplo).

A segunda forma é declarando o objeto como público, pois todo objeto público está automaticamente disponível no corpo do e-mail:

<?php

namespace App\Mail;

use App\Edicao;

use Illuminate\Bus\Queueable;

use Illuminate\Mail\Mailable;

use Illuminate\Queue\SerializesModels;

use Illuminate\Contracts\Queue\ShouldQueue;

class WelcomeMessage extends Mailable {

use Queueable, SerializesModels;

/** @var Edicao */

public $edicao;

public function __construct( Edicao $edicao ) {

$this->edicao = $edicao;

}

public function build() {

return $this->from( 'rico@capim.art.br', 'Rico Crivelli' )

->replyTo( 'ricardocrivelli@gmail.com', 'Ricardo Crivelli' )

->view( 'emails.messages.welcome' )

->text( 'emails.messages.welcome_text' )

}

}

Anexos

Todo mundo que já trabalhou com e-mails no PHP sem o auxílio de um framework sabe o quão difícil esse processo pode ser, mas como você já deve estar pensando este trabalho é muito simples de ser realizado.

Se o arquivo estiver no mesmo servidor que a aplicação é possível passar o método

attach()

com o caminho para o arquivo:

public function build() {

return $this->from( 'rico@capim.art.br', 'Rico Crivelli' )

->replyTo( 'ricardocrivelli@gmail.com', 'Ricardo Crivelli' )

->view( 'emails.messages.welcome' )

->text( 'emails.messages.welcome_text' )

->attach('edicoes/' . $this->edicao->ano . '/' . $this->edicao->numero .

'.pdf');

}

Note que eu concatenei as informações da edição, então se formos anexar a edição número 10 do ano de 2019 o arquivo

edições/2019/10.pdf

será anexado, mas ele será enviado com o nome

10.pdf

.

Para alterar esse nomeou o tipo do arquivo nós podemos informa-lo no código:

public function build() {

return $this->from( 'rico@capim.art.br', 'Rico Crivelli' )

->replyTo( 'ricardocrivelli@gmail.com', 'Ricardo Crivelli' )

->view( 'emails.messages.welcome' )

->text( 'emails.messages.welcome_text' )

->attach('edicoes/' . $this->edicao->ano . '/' . $this->edição

->numero . '.pdf',

[

'as' => 'ultima-edicao.pdf',

'mime' => 'application/pdf',

]

);

Agora o mesmo arquivo será anexado, mas o seu nome será

ultima-edicao.pdf.

Enviando o e-mail

Agora que nossa mensagem está pronta é hora de enviá-la, mas lembre-se que o Mailable é somente a definição de como será o e-mail, o envio é feito pelo seu Controller.

Vamos supor que você possui um formulário de cadastro, com nome e e-mail do usuário. Para enviar a mensagem basta chamar o método

to()

da face

Mail

e informar o remente:

public function store(Request $request) {

$user = new User([

'nome' => $request->get('nome'),

'email' => $request->get('email'),

'senha' => new Password($request->get('password'))

]);

Mail::to($request->get('email'), $request->get('nome'))->send();

}

Conclusão

No artigo de hoje vimos como é simples enviar um e-mail através do Laravel. Aprendemos todo o conceito de Mailable e como gerenciar as views e os anexos. É claro que não acaba por aí! A classe Mail é muito mais extensa e possui muitas outras funcionalidades que poderemos abordar mais para frente. Espero muito que tenha gostado e até a próxima!

Sobre o Autor

Ricardo Barbosa Crivelli, mais conhecido como Rico Crivelli, é formado como Bacharel em Sistemas de Informação e Licenciado em Computação pela Universidade Estadual do Norte do Paraná e pós-graduado em Informática na Educação. Atualmente é Técnico em TI no Instituto Federal de São Paulo – Campus Avaré. Tem como especialidade a linguagem PHP e os frameworks Symfony e Laravel, apesar de adorar trabalhar com front-end e desenvolvimento mobile com Kotlin e Swift. Possui as certificações COBiT 4.1 Foundation e Delphi 2006 Developer.

ASP. NET Web API – Implementando o método

“PUT” e “DELETE”

Caro leitor,

No artigo deste mês de Fevereiro continuarei abordando sobre o assunto “ASP. NET Web API” trabalhando com os métodos “PUT” para atualizar os dados e “DELETE” para excluir os dados. Teremos como base o artigo publicado no mês de Janeiro, denominado: “ASP. NET Web API – Implementando o método “POST”, o qual servirá de base para programarmos estes novos recursos. Utilizaremos também a ferramenta Telerik Fiddler, a qual fará o papel de cliente para testarmos os nossos serviços.

Criando o exemplo

Usaremos o mesmo banco de dados criado no artigo anterior, ou seja, iremos atualizar e exlcuir os dados da tabela “Funcionario” contendo os campos: “Cod”, “Nome”, “Sobrenome”, “Setor” e “Cidade”.

Localize a Pasta “Models/FuncionarioController.cs”. É dentro desta que iremos implementar o método PUT e DELETE.

Implementando o método PUT

Por padrão este método é do tipo “VOID”, ou seja, não retorna nenhum tipo de dado. Para uma melhor adequação, retornaremos um tipo “HttpResponseMessage”, o qual nos permitirá ter acesso às mensagens de sucesso ou erro que poderá ocorrer. Listagem 01.

//Método padrão

[Cod] [int] IDENTITY(1,1) NOT NULL,

{

}

//Método modificado

public HttpResponseMessage Put(int cod,

[FromBody]Funcionario funcionario)

{

try

{

using (THECLUBEntities db = new THECLUBEntities())

{

var func = db.Funcionario.FirstOrDefault(e =>

e.Cod == cod); if (func == null)

{

return

Request.CreateErrorResponse(HttpStatusCode.NotFound,

"Não Foi encontrado o funcionário Código: " +

cod.ToString() + " para

atualização!");

}

else

{

func.Nome = funcionario.Nome;

func.Sobrenome = funcionario.Sobrenome;

func.Setor = funcionario.Setor;

func.Cidade = funcionario.Cidade;

db.SaveChanges();

return

Request.CreateResponse(HttpStatusCode.OK, func);

}

}

}

catch (Exception ex)

{

return

Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);

}

}

Listagem 01.

O atributo [FromBody] irá forçar a API para um tipo simples de leitura no corpo da solicitação. Passaremos por parâmetro o campo inteiro “Cod” (campo necessário para realizar a atualização da tabela) e a classe “Funcionario”.

Dentro de um “Try/Catch” instanciaremos o modelo “TheClubEntities” seguido de uma consulta ao modelo de dados através do campo “Cod”. Caso encontrarmos algum registro iremos alterar os campos “Nome”, “Sobrenome”, “Setor” e “Cidade”, se não receberemos uma mensagem informativa através da classe “Request. CreateErrorResponse” que o registro não foi encontrado.

O próximo passo seria compilar a solução e abrir o programa “Telerik Fiddler” para realizarmos o teste. Localize a aba “Composer” (1) e dentro da mesma a “Parsed” (2). Insira os parâmetros abaixo (3) para indicar o aplicativo cliente (Fiddler), o servidor onde o serviço está sendo disparado (localhost: 49686), o tipo de dado (json) e o tamanho do conteúdo (Content-Length).

User-Agent: Fiddler

Host: localhost:49686

Content-type: application/json

Content-Length: 101

Escolheremos “PUT” e o camimho completo de nosso serviço (4) seguido do campo “Cod”, que será o parâmetro necessário para realizar o Update da tabela. Em “request Body” inserimos os dados a serem alterados no formato correto (JSON) conforme listagem abaixo (5)

{

"Nome": "Marcos",

"Sobrenome": "Cesar",

"Setor": "Informatica",

"Cidade": "Lençois"

}

Podemos conferir todos os passos enumerados acima através da Imagem 01.

Figura 01: Serviço de PUT.

Caso não ocorra nenhum erro podemos conferir clicando sobre o serviço ou na aba “Inspetor” (1) e através do item “Raw” (2) podemos conferir os dados que foram alterados por parâmetro e na Raw (3) os dados contidos e alterados no Banco de dados.

Ver Figura 02 para todos os detalhes.

Ao acessar o SQL Server teremos o resultado a seguir (Imagem 03)

Figura 03: Alterando os Dados.

Implementando o método DELETE

Este método por padrão também é do tipo “VOID”, ou seja, não retorna nenhum tipo de dado. Faremos o mesmo que no “PUT”, retornaremos um tipo “HttpResponseMessage”, o qual nos permitirá ter acesso às mensagens de sucesso ou erro que poderá ocorrer. Listagem 02.

//Método padrão

public void Delete(int id)

{

}

Método modificado

public HttpResponseMessage Delete(int cod)

{

try

{

using (THECLUBEntities db = new THECLUBEntities())

{

var func = db.Funcionario.FirstOrDefault(e =>

e.Cod == cod); if (func == null)

{

return

Request.CreateErrorResponse(HttpStatusCode.NotFound,

"Não Foi encontrado o funcionário Código: " +

cod.ToString() + " para

exclusão!");

}

else

{

db.Funcionario.Remove(func);

db.SaveChanges();

return

Request.CreateResponse(HttpStatusCode.OK);

}

}

}

catch (Exception ex)

{

return

Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);

}

}

Listagem 02.

Passaremos por parâmetro o campo inteiro “Cod” (campo necessário para identificar o registro a ser excluído). Dentro de um “Try/Catch” instanciaremos o modelo “TheClubEntities” seguido de uma consulta ao modelo de dados através do campo “Cod”. Faremos um “IF” para filtrar o registro desejado, caso afirmativo iremos remover o mesmo, caso contrário invocaremos uma mensagem ao usuário através da classe “Request.CreateErrorResponse”.

Após a compilação da solução abriremos o programa “Telerik Fiddler” para realizarmos o teste de exclusão. Localize a aba “Composer” (1) e dentro da mesma a “Parsed” (2). Insira os parâmetros abaixo (3) para indicar o aplicativo cliente (Fiddler), o servidor onde o serviço está sendo disparado (localhost: 49686) e o tipo de dado (json).

User-Agent: Fiddler

Host: localhost:49686

Content-type: application/json

Escolheremos “DELETE” e o camimho completo de nosso serviço (4) seguido do campo “Cod”, que será o parâmetro necessário para realizar a exclusão do registro da tabela. Por final clicaremos no botão Execute (5)

Podemos conferir todos os passos enumerados acima através da Imagem 04.

Figura 04: Serviço de DELETE.

Para conferir o resultado basta seguir os mesmos passos descritos no método “PUT”, acessando a aba “Inspetor(1)”, através do item “Raw” (2) poderemos conferir todos os detalhes da exclusão.

Ver Figura 05.

Figura 05: Conferindo o método DELETE.

Conclusões

Aprendemos neste artigo os dois últimos métodos faltantes, sendo: o “PUT”, necessário para atualizar os dados de uma tabela e o “DELETE” para exclusão dos mesmos. Com o auxílio da ferramenta cliente “Telerik” a tarefa de testar estes tipos de serviços ficou muito simples e intuitiva.

Finalizamos a série de dicas para produzir um serviço de Consulta, Inclusão, Alteração e Exclusão de dados utilizando este poderoso recurso encontrado no .NET Framework, o “ASP. NET Web API”.

Desejo uma ótima leitura, um abraço e até o mês que vem! Referências

https://www.telerik.com/

Sobre o Autor

Thiago Cavalheiro Montebugnoli adora aprender novas tecnologias. Formado pela Faculdade de Tecnologia de Botucatu – SP (FATEC), já desenvolveu softwares utilizando a plataforma .NET, Delphi junto com Banco de Dados SQL Server e Firebird. Como experiências profissionais mais recentes, possui em seu currículo sua atuação no Centro de Processamento de Dados da Prefeitura Municipal de Itaí-SP e atualmente compõe a equipe da Coordenadoria Tecnologia da Informação no IFSP – Instituto Federal do Estado de São Paulo em Avaré. Além disso, é colunista mensal da Revista The Club Megazine e é consultor Técnico do The Club. Possui as seguintes certificações: MCP - Microsoft Certified Professional,MCTS - Microsoft Certified Technology Specialist, MCAD - Microsoft Certified Application Developer e MCSD - Microsoft Certified Solution Developer.