UNIVERSIDADE PAULISTA – UNIP EAD

Projeto Integrado Multidisciplinar VIII

Curso Superior de Tecnologia em

Análise e Desenvolvimento de Sistemas

Bruna Regina Nunes dos Santos RA: 0606942

Diogo Cavalcanti Dos Santos RA: 0601375
Gabriel Maia de Andrade RA: 0608185
Paula Helena Câmara RA: 0605092
Natã Rodrigues Frois RA: 0601016

“SISTEMA DE MARKETPLACE PARA

COMPRA E VENDA DE PRODUTOS DIVERSOS VIA APP/WEB”

São Paulo – SP
2023
 Bruna Regina Nunes dos Santos RA: 0606942
Diogo Cavalcanti Dos Santos RA: 0601375
Gabriel Maia de Andrade RA: 0608185
Paula Helena Câmara RA: 0605092
Natã Rodrigues Frois RA: 0601016

“SISTEMA DE MARKETPLACE PARA

COMPRA E VENDA DE PRODUTOS DIVERSOS VIA APP/WEB”

Projeto Integrado Multidisciplinar VII,

apresentado a Universidade Paulista UNIP, como
exigência parcial para a conclusão do semestre no
curso Superior de Tecnologia em Análise e
Desenvolvimento de Sistemas.

Prof. Orientador: MSc.Tarcísio Peres

São Paulo - SP
2023
 UNIVERSIDADE PAULISTA – UNIP EAD
Folha De Aprovação
Bruna Regina Nunes dos Santos RA: 0606942
Diogo Cavalcanti Dos Santos RA: 0601375
Gabriel Maia de Andrade RA: 0608185
Paula Helena Câmara RA: 0605092
Natã Rodrigues Frois RA: 0601016

Projeto Integrado Multidisciplinar VIII,

apresentado a Universidade Paulista UNIP, como
exigência parcial para a conclusão do semestre no
curso Superior de Tecnologia em Análise e
Desenvolvimento de Sistemas.

PROJETO MULTIDISCIPLINAR PIM VIII: SISTEMA DE MARKETPLACE PARA

COMPRA E VENDA DE PRODUTOS DIVERSOS VIA APP/WEB.

Aprovado em:
BANCA EXAMINADORA

Prof. Nome do Professor

BANCA EXAMINADORA

Prof. Nome do Professor

BANCA EXAMINADORA

Prof. Nome do Professor

São Paulo - SP
2023
 RESUMO

Com base no conteúdo das disciplinas de Programação Orientada a Objetos II,

Desenvolvimento de Software para a Internet e Tópicos Especiais de Programação Orientada
a Objetos, este projeto aborda a criação de uma solução digital para desenvolver um
mecanismo de acesso a um banco de dados usando C#. Nossa equipe irá aprimorar um
sistema já em andamento, concentrando-se na criação de uma estrutura para acessar
informações do banco de dados. Isso inclui o desenvolvimento de protótipos de interfaces
gráficas em ASP.NET para interação do usuário e, também em Android.Este sistema
proporcionará uma experiência eficiente e amigável, tornando a compra e venda de produtos
diversos uma tarefa simples e rápida para vendedores e compradores.

PALAVRAS-CHAVE: DESENVOLVIMENTO, C#, BANCO DE DADOS.

ABSTRACT
 Based on the content of the subjects Object-Oriented Programming II, Software
Development for the Internet and Special Topics in Object-Oriented Programming, this
project addresses the creation of a digital solution to develop a database access mechanism
using C#. Our team will improve a system already in progress, focusing on creating a
structure to access information from the database. This includes the development of graphical
interface prototypes in ASP.NET for user interaction and in Android.This system will provide
an efficient and user-friendly experience, making buying and selling different products a
simple and quick task for sellers and buyers.
KEYWORDS: DEVELOPMENT, C#, DATABASE.

Sumário
1 Introdução..............................................................................................................................6
2 Tópicos Especiais De Programação Orientada A Objetos.................................................7

2.1 Código XML........................................................................................................................7

2.2 Desenvolvimento do protótipo de interface gráfica em android.....................................7

2.3 Capturas de Tela e Emulador Android.............................................................................7

2.4 Código XML do Layout das Activities..............................................................................8

3 PROGRAMAÇÃO ORIENTADA A OBJETOS II...........................................................13

3.1 A Importância do Diagrama de Classes no Desenvolvimento de um Marketplace....14

3.2 Diagrama de Classes (Entidades)....................................................................................14

3.3 Implementação das Classes de Entidades.......................................................................14

3.4 Desenvolvimento Do Mecanismo De Acesso Ao Banco De Dados E Protótipo De

Interface Gráfica Em Asp.Net...............................................................................................15

3.4.1 Criação da Classe CarrinhoRepository:......................................................................15

3.4.2 Lógica de Acesso ao Banco de Dados:..........................................................................15

4 DESENVOLVIMENTO DE SOFTWARE PARA A INTERNET....................................19

4.1 Etapas de desenvolvimento de software..........................................................................19

4.2 Levantamento de requisitos.............................................................................................20

4.3 Desenvolvimento...............................................................................................................20

4.4 Testagem.............................................................................................................................20

4.5 Protótipo de Interface Gráfica em ASP .Net..................................................................20

4.6 Capturas de Tela e Código ASP .Net...............................................................................20

5 Conclusão..............................................................................................................................24

6 Referências............................................................................................................................25
 6

1 Introdução

O crescimento dos sistemas de marketplace online é inegável, consolidando-se como

uma das principais tendências no cenário do comércio eletrônico. Esses ambientes virtuais
proporcionam uma plataforma dinâmica na qual vendedores e compradores podem interagir
de maneira direta. O diferencial em relação às lojas virtuais tradicionais reside na sua natureza
intermediária: enquanto nestas últimas um único vendedor é responsável pela comercialização
dos produtos, o marketplace atua como um facilitador, conectando diversos vendedores a uma
grande quantidade de consumidores. O objetivo principal, fundamentado nos conhecimentos
adquiridos nas disciplinas de Programação Orientada a Objetos II, Desenvolvimento de
Software para a Internet e Tópicos Especiais de Programação Orientada a Objetos, é
apresentar uma solução abrangente, focada na implementação de um mecanismo de acesso a
um banco de dados por meio da codificação em C#. A equipe assume a responsabilidade de
desenvolver uma estrutura que viabilize o acesso às informações do banco de dados. Este
esforço inclui a criação de protótipos de interfaces gráficas em ASP.NET e Android,
proporcionando interação do usuário com os dados modelados. Temos a tarefa de aprimorar a
experiência do usuário e facilitar o acesso eficiente às informações por meio de interfaces
intuitivas e funcionais.
 7

2 Tópicos Especiais De Programação Orientada A Objetos

2.1 Código XML
XML é uma sigla para Extensible Markup Language, é uma linguagem de marcação
que define um conjunto de regras para codificação de documentos.
Linguagem de marcação é um conjunto de códigos que são aplicados na leitura de dados ou
textos, feitos por computadores ou pessoas. Ela fornece uma plataforma para definir
elementos de marcação, gerando uma linguagem personalizada.
O arquivo XML, é dividido em duas partes: prolog e body.
 Prolog: Consiste em metadados administrativos, instrução de processamento opcional,
declaração de tipo de documentos e comentários.
 Body: Constituída em duas partes – estrutural e conteúdo.
Possui foco na simplicidade, generalidade e usabilidade, sendo utilizado para variados
serviços na WEB.

2.2 Desenvolvimento do protótipo de interface gráfica em android

Com foco na disciplina de Tópicos Especiais de Programação Orientada a Objetos, a

equipe direcionou seus esforços para a criação do protótipo de interface gráfica em Android
usando o Android Studio. Essa etapa do projeto visava oferecer ao usuário funcionalidades
CRUD para os dados relacionados ao trecho de banco de dados sob a responsabilidade do
CarrinhoRepository.A equipe iniciou a jornada no Android Studio, aproveitando as
ferramentas avançadas oferecidas para o desenvolvimento de interfaces gráficas no ambiente
Android. Uma Activity foi criada para representar uma tela do aplicativo, proporcionando
uma experiência interativa e amigável aos usuários. A ênfase recaiu sobre a implementação
das funcionalidades CRUD para os dados específicos gerenciados pela classe
CarrinhoRepository.

2.3 Capturas de Tela e Emulador Android

Para documentar o progresso e visualizar a aparência da interface gráfica, foram
geradas capturas de tela diretamente do editor do Android Studio e do emulador Android
utilizado durante o desenvolvimento. Essas imagens proporcionam uma visão clara das
interações e do design adotado para o aplicativo.
 8

2.4 Código XML do Layout das Activities

O trabalho incluiu a incorporação do código XML que define o layout das Activities
criadas para o protótipo. Esse código é essencial para compreender a estrutura da interface
gráfica, incluindo a disposição dos elementos visuais e a interconexão com as funcionalidades
implementadas.Essa abordagem detalhada na disciplina de Tópicos Especiais de Programação
Orientada a Objetos visa não apenas atender aos requisitos técnicos, mas também
proporcionar uma experiência de usuário otimizada. A equipe se empenhou em aplicar
conceitos avançados de programação orientada a objetos no desenvolvimento da interface
gráfica, garantindo a coesão e a modularidade necessárias para um código robusto e eficiente.
Ao integrar essa etapa com as demais disciplinas do projeto, a equipe busca criar uma solução
completa e integrada que atenda aos padrões de qualidade estabelecidos pelo ambiente
Android e pelas práticas de programação orientada a objetos. Este progresso representa um
avanço significativo no desenvolvimento do sistema de Marketplace online, garantindo uma
experiência consistente e eficaz para os usuários finais.

Figura 1 : Autoria próprio autor

 9

Imagem de Consulta de endereço

Figura 2: Autoria próprio autor

Imagens tela de alteração e Exclusão:

Figura 3: Autoria próprio autor

 10

Código Fonte:

packagebr.unip.sqlitecrud;

importandroidx.appcompat.app.AlertDialog;
importandroidx.appcompat.app.AppCompatActivity;
import android.database.Cursor; import
android.os.Bundle;import
android.view.Menu; import
android.view.MenuItem; import
android.view.View;import
android.widget.Button; import
android.widget.EditText; import
android.widget.Toast;

publicclassMainActivityextendsAppCompatActivity{ DatabaseHelpe
r myDb;
EditText editlogradouro, editnumero,editcep,editbairro,editcidade,editestado,editid; Button btnsalvar;
Buttonbtnviewall;
Buttonbtnupdate; Button
btndelete;

@Override
protectedvoidonCreate(BundlesavedInstanceState){ super.onCreate
(savedInstanceState); setContentView (R.layout.activity_main);
myDb=newDatabaseHelper(this);

editlogradouro=(EditText)findViewById(R.id.editText_logradouro); editnumero =
(EditText) findViewById (R.id.editText_numero); editcep = (EditText) findViewById
(R.id.editText_cep);
editbairro = (EditText) findViewById (R.id.editText_bairro);
editcidade=(EditText)findViewById(R.id.editText_cidade);
editestado=(EditText)findViewById(R.id.editText_estado); editid =
(EditText) findViewById (R.id.editText_id);
btnsalvar = (Button) findViewById (R.id.button_salvar); btnviewall =
(Button) findViewById (R.id.button_view);
btnupdate=(Button)findViewById(R.id.button_update); btndelete =
(Button) findViewById (R.id.button_del); Salvar ();
Viewall(); UpdateData();
DeleteData();

public void DeleteData(){ btndelete.setOnClickListener (

newView.OnClickListener(){
@Override
publicvoidonClick(Viewview){
IntegerdeleteRows=myDb.deleteData(editid.getText().toString()); if(deleteRows > 0)
Toast.makeText(MainActivity.this,"Deletadocom

Código Fonte:
 11

packagebr.unip.sqlitecrud;

importandroidx.appcompat.app.AlertDialog;
importandroidx.appcompat.app.AppCompatActivity;

import android.database.Cursor; import

android.os.Bundle;import
android.view.Menu; import
android.view.MenuItem; import
android.view.View;import
android.widget.Button; import
android.widget.EditText; import
android.widget.Toast;

publicclassMainActivityextendsAppCompatActivity{ DatabaseHelpe
r myDb;
EditText editlogradouro, editnumero,editcep,editbairro,editcidade,editestado,editid; Button btnsalvar;
Buttonbtnviewall;
Buttonbtnupdate; Button
btndelete;

@Override
protectedvoidonCreate(BundlesavedInstanceState){ super.onCreate
(savedInstanceState); setContentView (R.layout.activity_main);
myDb=newDatabaseHelper(this);

editlogradouro=(EditText)findViewById(R.id.editText_logradouro); editnumero =
(EditText) findViewById (R.id.editText_numero); editcep = (EditText) findViewById
(R.id.editText_cep);
editbairro = (EditText) findViewById (R.id.editText_bairro);
editcidade=(EditText)findViewById(R.id.editText_cidade);
editestado=(EditText)findViewById(R.id.editText_estado); editid =
(EditText) findViewById (R.id.editText_id);
btnsalvar = (Button) findViewById (R.id.button_salvar); btnviewall =
(Button) findViewById (R.id.button_view);
btnupdate=(Button)findViewById(R.id.button_update); btndelete =
(Button) findViewById (R.id.button_del); Salvar ();
Viewall(); UpdateData();
DeleteData();

}
public void DeleteData(){ btndelete.setOnClickListener (
newView.OnClickListener(){
@Override
publicvoidonClick(Viewview){
IntegerdeleteRows=myDb.deleteData(editid.getText().toString()); if(deleteRows > 0)
Toast.makeText(MainActivity.this,"Deletadocom
Sucesso",Toast.LENGTH_SHORT).show();
else
Toast.makeText(MainActivity.this,"Errona
Deleção",Toast.LENGTH_SHORT).show ();
}
}
);
}
public void UpdateData(){ btnupdate.setOnClickListener
(
newView.OnClickListener(){
@Override
publicvoidonClick(Viewview){
booleanisUpdate=myDb.updateData(editid.getText().toString (),editlogradouro.getText ().toString
 12

(),editnumero.getText ().toString (),

editcep.getText().toString(),editbairro.getText().toString
(),editcidade.getText().toString(),editestado.getText().toString()); if(isUpdate == true)
Toast.makeText(MainActivity.this,"Alteradocom
Sucesso",Toast.LENGTH_SHORT).show();
else
Toast.makeText(MainActivity.this,"Errona
Gravação",Toast.LENGTH_SHORT).show ();
}
}
);
}

public void Salvar() { btnsalvar.setOnClickListener (

newView.OnClickListener(){
@Override
publicvoidonClick(Viewview){
booleanisInserted=myDb.insertData(editlogradouro.getText().toString(), editnumero.getText ().toString
(),
editcep.getText().toString(),
editbairro.getText ().toString (),
editcidade.getText ().toString (),
editestado.getText().toString());
if(isInserted==true)
Toast.makeText(MainActivity.this,"Gravadocom
Sucesso",Toast.LENGTH_SHORT).show ();
else
Toast.makeText(MainActivity.this,"Errona
Gravação",Toast.LENGTH_SHORT).show ();
}
}
);

public void Viewall() { btnviewall.setOnClickListener (

newView.OnClickListener(){ @Override

public void onClick(View view)

{ Cursorres=myDb.getAllData(); if(res.getCount
() == 0){
//showmessage
showMessage("Erro","NãoEncontrado"); return;
}
StringBufferbuffer=newStringBuffer(); while
(res.moveToNext ()){
buffer.append("Id:"+res.getString(0)+"\n");
buffer.append("Logradouro:"+res.getString(1)+"\n"); buffer.append
("Numero :"+res.getString (2)+"\n"); buffer.append ("CEP :"+res.getString
(3)+"\n"); buffer.append ("Bairro :"+res.getString (4)+"\n"); buffer.append
("Cidade :"+res.getString (5)+"\n"); buffer.append ("Estado :"+res.getString
(6)+"\n\n");
}
//Showalldata
showMessage("Endereco",buffer.toString());
}
}
);
 13

}
public void showMessage(String title,String Message)
{ AlertDialog.Builderbuilder=newAlertDialog.Builder(this); builder.setCancelable
(true);
builder.setTitle (title); builder.setMessage
(Message); builder.show ();
}

3 PROGRAMAÇÃO ORIENTADA A OBJETOS II

Programação orientada a objetos (POO), é uma metodologia de programação
adequada para o desenvolvimento de sistemas de grande porte, trazendo modularidade e
reusabilidade. Ela introduz uma abordagem na qual o programador visualiza seu programa em
execução como uma coleção de objetos que cooperam e se comunicam entre si através de
mensagens. Cada objeto é instância de uma classe e todas as classes formam uma
hierarquia de classes via relacionamento de herança.Abaixo alguns aspectos importantes na
definição de POO.
 Utiliza objetos, e não funções como o seu bloco lógico fundamental para construção
de programas.
 Objetos se comunicam por mensagens.
 Cada objeto é uma instância de uma classe
 Classes estão relacionadas a outras via mecanismos de herança
Programação orientada a objetos dá ênfase à estrutura de dados, adicionando capacidade
de processamento a estas estruturas. Em linguagens orientadas a objetos, ao invés de passar
dados a procedimentos, requisita-se que os objetos realizem operações neles mesmos.
Alguns aspectos são fundamentais para descrever a programação orientada a objetos:
 Abstração de dados;
 Objetos;
 Mensagens;
 Classes;
 Herança;
 Polimorfismo.
3.1 A Importância do Diagrama de Classes no Desenvolvimento de um Marketplace
O Diagrama de Classes é uma etapa fundamental no desenvolvimento de um
Marketplace, representando visualmente entidades essenciais como Cliente, Carrinho, Produto
e Vendedor, proporcionando uma compreensão holística do sistema. Além de estabelecer
 14

relações entre essas entidades, como a entre Cliente e Carrinho, o diagrama traduz requisitos
de negócios em estruturas tangíveis, facilitando a comunicação da equipe. A inclusão opcional
de classes como Endereço e Categoria oferece uma modelagem mais refinada. O Diagrama de
Classes não apenas guia a estrutura, mas também auxilia em decisões de design, garantindo
coesão e simplicidade na manipulação de dados ao longo do ciclo de vida do projeto. Em
suma, é uma ferramenta essencial para criar um sistema robusto e eficaz no contexto de um
Marketplace.
3.2 Diagrama de Classes (Entidades)

O desafio de desenvolver o mecanismo de acesso ao banco de dados e o protótipo de

interface gráfica em ASP .Net para o sistema de Marketplace online começou com a tradução
cuidadosa do diagrama de classes fornecido em código funcional.
3.3 Implementação das Classes de Entidades
A equipe iniciou o processo codificando as classes de entidades conforme as
definições apresentadas no diagrama. A atenção aos detalhes foi crucial para garantir que a
estrutura das classes refletisse fielmente a modelagem das entidades, incluindo Cliente,
Carrinho, Produto e Vendedor. A equipe também avaliou a relevância das classes adicionais
sugeridas, como Endereço e Categoria, decidindo incorporá-las ao sistema para enriquecer a
representação dos dados.
 15

3.4 Desenvolvimento Do Mecanismo De Acesso Ao Banco De Dados E Protótipo De

Interface Gráfica Em Asp.Net
3.4.1 Criação da Classe CarrinhoRepository:
A classe CarrinhoRepository, o epicentro do mecanismo de acesso ao banco de
dados, foi então codificada conforme as diretrizes estabelecidas no diagrama de classes. A
equipe implementou os métodos estáticos necessários para realizar as operações CRUD,
garantindo uma manipulação eficiente e segura dos dados. O foco foi manter esses métodos
com visibilidade restrita, optando por protegidos, padrão ou privados para reforçar a
encapsulação da lógica de acesso ao banco de dados.

3.4.2 Lógica de Acesso ao Banco de Dados:

A lógica dos métodos da classe CarrinhoRepository foi meticulosamente
desenvolvida para realizar as operações específicas sobre o banco de dados. Isso envolveu a
utilização de boas práticas de programação, como a implementação de transações para
garantir a consistência dos dados e a prevenção de possíveis exceções.
Classe CLIENTE
namespace WebApplicationCRUD.Models
{
public class Endereco
{
public string Rua { get; set; }
public string Cidade { get; set; }
public string Estado { get; set; }
public string CEP { get; set; }
}

public class Cliente

{
// Propriedades
public int Id { get; set; }
public string Nome { get; set; }
public string Cpf { get; set; }
public string Email { get; set; }
public string Senha { get; set; }
public Endereco Endereco { get; set; }
}

}
Classe PRODUTO
namespace WebApplicationCRUD.Models
{
public class Produto

{
public int Id { get; set; }
public string Descricao { get; set; }
public decimal Preco { get; set; }
public string Imagem { get; set; }
public string Status { get; set; }
public Vendedor Vendedor { get; set; }
 16

public Categoria Categoria { get; set; }

}

public class Categoria

{
public int Id { get; set; }
public string Nome { get; set; }
}

}
Classe VENDEDOR
namespace WebApplicationCRUD.Models
{
public class Vendedor
{
public string RazaoSocial { get; set; }
public string NomeFantasia { get; set; }
public string Cnpj { get; set; }
public string Email { get; set; }
public string Senha { get; set; }
public decimal Comissao { get; set; }
public Endereco Endereco { get; set; }
}
}
Classe CARRINHO
namespace WebApplicationCRUD.Models
{
public class Carrinho
{
public int Id { get; set; }
public DateTime DataPedido { get; set; }
public decimal ValorTotal { get; set; }
public int StatusPedido { get; set; }
public Cliente Cliente { get; set; }
public List<Produto> Produtos { get; set; }
}
}
CarrinhoRepository (CRUD) – Com os métodos implementados
namespace WebApplicationCRUD.Controllers
{
public class CarrinhoRepositoryController : Controller
{
private readonly Contexto _context;

public CarrinhoRepositoryController(Contexto context)

{
_context = context;
}

// GET: CarrinhoRepository
public async Task<IActionResult> Index()
{
return _context.CarrinhoRepository != null ?
View(await _context.CarrinhoRepository.ToListAsync()) :
Problem("Entity set 'Contexto.CarrinhoRepository' is null.");

// GET: CarrinhoRepository/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null || _context.CarrinhoRepository == null)
{
return NotFound();
}
 17

var carrinhoRepository = await _context.CarrinhoRepository

.FirstOrDefaultAsync(m => m.Id == id);
if (carrinhoRepository == null)
{
return NotFound();
}

return View(carrinhoRepository);
}

// GET: CarrinhoRepository/Create
public IActionResult Create()
{
return View();
}

// POST: CarrinhoRepository/Create
// To protect from overposting attacks, enable the specific properties you want to bind to.
// For more details, see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create([Bind("Id,Nome")] CarrinhoRepository carrinhoRepository)
{
if (ModelState.IsValid)
{
_context.Add(carrinhoRepository);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
return View(carrinhoRepository);
}

// GET: CarrinhoRepository/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null || _context.CarrinhoRepository == null)
{
return NotFound();
}

var carrinhoRepository = await _context.CarrinhoRepository.FindAsync(id);

if (carrinhoRepository == null)
{
return NotFound();
}
return View(carrinhoRepository);
}

// POST: CarrinhoRepository/Edit/5
// To protect from overposting attacks, enable the specific properties you want to bind to.
// For more details, see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("Id,Nome")] CarrinhoRepository carrinhoRepository)
{
if (id != carrinhoRepository.Id)
{
return NotFound();
}

if (ModelState.IsValid)
 18

{
try
{
_context.Update(carrinhoRepository);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarrinhoRepositoryExists(carrinhoRepository.Id))
{
return NotFound();
}
else

{
throw;
}
}
return RedirectToAction(nameof(Index));
}
return View(carrinhoRepository);
}

// GET: CarrinhoRepository/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null || _context.CarrinhoRepository == null)
{
return NotFound();
}

var carrinhoRepository = await _context.CarrinhoRepository

.FirstOrDefaultAsync(m => m.Id == id);
if (carrinhoRepository == null)
{
return NotFound();
}

return View(carrinhoRepository);
}

// POST: CarrinhoRepository/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
if (_context.CarrinhoRepository == null)
{
return Problem("Entity set 'Contexto.CarrinhoRepository' is null.");
}
var carrinhoRepository = await _context.CarrinhoRepository.FindAsync(id);
if (carrinhoRepository != null)
{
_context.CarrinhoRepository.Remove(carrinhoRepository);
}

await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}

private bool CarrinhoRepositoryExists(int id)

{
return(_context.CarrinhoRepository?.Any(e=>e.Id== id)).GetValueOrDefault();
 19

}
}
}

ACESSO AO BANCO DE DADOS SQL SERVER

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllersWithViews();
builder.Services.AddDbContext<Contexto>
(options => options.UseSqlServer
("Data Source=LAPTOP-JVGU2G6P\\SQLSERVER;Initial Catalog=BancoDeDados;Integrated Security=True"));

var app = builder.Build();

4 DESENVOLVIMENTO DE SOFTWARE PARA A INTERNET

Desenvolvimento de software é a criação de programas de computador por
programadores. O software, um produto virtual composto por códigos em linguagem de
programação, é traduzido pela tela do dispositivo durante o uso, tornando-o invisível ao
usuário. Além de escrever códigos, os desenvolvedores lideram projetos, compreendem as
necessidades do cliente, fazem protótipos, testam, ajustam, homologam e implementam. Essa
função, de alto valor agregado, demanda conhecimento técnico extenso. No projeto em
questão, a linguagem C# é escolhida devido à sua simplicidade, orientação a objetos, tipagem
forte, geração de código gerenciado, entre outras características. Outras linguagens comuns
incluem Java, Javascript, Python, C++ e PHP.
4.1 Etapas de desenvolvimento de software
Essa fase é muito importante para conhecer as reais necessidades do cliente,
elaborando uma espécie de diagnóstico do problema a ser solucionado.Nessa fase, é sugerida
uma reunião, cujo objetivo seria repassar uma espécie de briefing do projeto. Nessa reunião,
todos os envolvidos precisam estar cientes do que o cliente precisa, quais as necessidades
atuais dele que precisam ser sanadas e, também quanto o cliente está disposto em investir
(tempo e capital). Compreender essas necessidades, é essencial para a definição de como os
recursos serão alocados no projeto.

4.2 Levantamento de requisitos

Nessa fase, serão definidos quais serão os requisitos, funcionais ou não funcionais, do
software que será desenvolvido. Precisa-se de muita cautela nesta parte, pois é preciso que as
necessidades do cliente fiquem bem esclarecidas, para que nenhum tópico seja esquecido.
Sempre há um risco do projeto ser abandonado, caso a equipe não fique atenta as
 20

necessidades do cliente. Quando surja alguma dúvida referente ao projeto, todos poderão
consultar. E qualquer passo ou alteração precisam ser documentadas.
4.3 Desenvolvimento
Durante essa etapa, será desenvolvido o código do software, além da utilização de
alguma metodologia
4.4 Testagem
Ao final de todos esses passos, é necessário começar a fase de testes, que é quando o
código é testado internamente, para verificar se há algum erro antes de entregar o projeto final
ao cliente. E sempre que possível, utilizar backups de segurança, além disso, sempre possuir
uma cópia de segurança salva e constantemente atualizada.
4.5 Protótipo de Interface Gráfica em ASP .Net
Na disciplina de Desenvolvimento de Software para Internet, a equipe focou na
criação de um protótipo de interface gráfica em ASP .Net utilizando o Visual Studio. O
objetivo era oferecer ao usuário funcionalidades CRUD para os dados relacionados ao trecho
de banco de dados sob a responsabilidade do CarrinhoRepository. Um formulário foi
desenvolvido para proporcionar uma experiência interativa e amigável aos usuários.
4.6 Capturas de Tela e Código ASP .Net
O Projeto incluiu capturas de tela das interfaces gráficas, obtidas diretamente do
Visual Studio ou de um navegador de internet. Além disso, o código ASP .Net do layout dos
formulários foi incorporado, demonstrando a estrutura e a lógica por trás da interface criada.
Nesse processo, a equipe buscou garantir não apenas a funcionalidade técnica, mas também
uma experiência de usuário eficiente e agradável. A combinação entre o mecanismo de acesso
ao banco de dados e o protótipo de interface gráfica em ASP .Net representa um avanço
significativo na implementação do sistema de Marketplace online, alinhando-se aos padrões
de qualidade estabelecidos pelas disciplinas envolvidas no projeto.
 21

Figura 4: Autoria próprio autor

Figura 5: Autoria próprio autor

Figura 6: Autoria próprio autor

 22

Figu
ra 7: Autoria próprio autor

Figura 8: Autoria próprio autor

 23

Figura 9: Autoria próprio autor

Figura 10: Autoria próprio autor

 24

5 Conclusão
Este Projeto Integrador Multidisciplinar 8, teve como objetivo o desenvolvimento do
aluno nas disciplinas de Tópicos Especiais de Programação, Desenvolvimento de Software
para a Internet e Programação Orientada a Objetos 2 as três disciplinas se entrelaçaram para
criar um marketplace voltado para smartphones que proporcionou uma experiencia
educacional rica e abrangente. A disciplina de Tópicos Especiais de Programação permitiu a
exploração de conceitos de interface gráfica utilizando a Ferramenta Android Studio e o
código XML além de desenvolver activities além das funcionalidades CRUD para os dados
relacionados ao banco de dados. Ao mesmo tempo, a disciplina de Desenvolvimento de
Software para a Internet trouxe uma perspectiva prática com ênfase em elaborar o protótipo
de interface gráfica em ASP.Net usando o Visual Studio. As interfaces gráficas ofereceram ao
usuário as funcionalidades CRUD para os dados relacionados no trecho de banco de dados
sob seus cuidados. Foi criado os formulários para isso além das capturas de tela e suas
interfaces gráficas junto com o código Aspx do layout dos formulários do protótipo. A
experiência prática adquirida nessa disciplina foi crucial para enfrentar os desafios específicos
relacionados à criação de software destinado à Internet. Por fim, a Programação Orientada a
Objetos 2 consolidou e expandiu os conhecimentos sobre esse paradigma de programação,
pois foi realizado os códigos das classes das entidades, além do código da classe
CarrinhoRepository a lógica dos métodos da classe CarrinhoRepository a fim de acessar o
banco de dados. A abordagem orientada a objetos em C# não apenas contribuiu para a
eficiência do código, mas também facilitou a colaboração entre membros da equipe,
promovendo um desenvolvimento mais ágil e colaborativo. Este Projeto Integrador
Multidisciplinar teve também o propósito de demonstrar algumas das etapas cruciais no
desenvolvimento de software além de questões técnicas envolvidas em cada área, afim de
informar o leitor de maneira mais simples e direta ,há outras questões envolvidas em
desenvolver esse produto de software no formato de marketplace ,essas questões são mais
abrangentes e não caberiam no formato padrão apresentado, em tempo sugiro ao leitor utilizar
um olhar compreensivo pois é importante considerar a dedicação e empenho aplicados nesse
projeto , para apresentar um trabalho correto e de qualidade.
 25

6 Referências
LIMA, EDWIN. C# e .NET para desenvolvedores. Eugênio Reis, Rio de Janeiro: Campus,
2002.
Desenvolvimento de Softwares: O que é, Como Funciona e Dicas. 10 de maio 2019, 17:03.
Disponível em: <https://fia.com.br/blog/desenvolvimento-de-softwares/> Acesso em
06/11/2023 às 20:08.
JUNIOR, P. Quais as etapas do Desenvolvimento de Softwares? Conheça agora.
Disponível em: <https://polijunior.com.br/blog/etapas-do-desenvolvimento-de-softwares/>
Acesso em 06/11/2023 às 20:27.
KAMIENSKI, C, A. Introdução ao Paradigma de Orientação à Objetos. João Pessoa,
julho de 1996.
SOUZA, D, I. Entenda o que é XML e quais as utilidades dessa linguagem de marcação.
13 de dezembro de 2018. Disponível em: <https://rockcontent.com/br/blog/o-que-e-xml/>
Acesso em 06/11/2023 às 21:30.