sexta-feira, 27 de março de 2026

ORACLE PL/SQL- Tipos de JOIN (Explicação Simples)

 ## Tipos de JOIN


Vou explicar usando duas tabelas como exemplo:

- **CLIENTES** (id, nome)

- **PEDIDOS** (id, cliente_id, valor)


### 1. **INNER JOIN** (ou só JOIN)

**Retorna apenas os registros que têm correspondência em AMBAS as tabelas.**

```sql

SELECT * FROM CLIENTES c

INNER JOIN PEDIDOS p ON c.id = p.cliente_id;

**Resultado:** Só clientes que fizeram pedidos. Clientes sem pedido NÃO aparecem.

Cliente com pedido   → aparece

Cliente sem pedido   → não aparece


### 2. **LEFT JOIN** (ou LEFT OUTER JOIN)

**Retorna TODOS os registros da tabela da ESQUERDA + correspondências da direita.**

```sql

SELECT * FROM CLIENTES c

LEFT JOIN PEDIDOS p ON c.id = p.cliente_id;

**Resultado:** Todos os clientes. Quem não tem pedido fica com NULL nos campos de pedido.

Cliente com pedido   → aparece com dados do pedido

Cliente sem pedido   → aparece com NULL nos campos do pedido


### 3. **RIGHT JOIN** (ou RIGHT OUTER JOIN)

**Retorna TODOS os registros da tabela da DIREITA + correspondências da esquerda.**

```sql

SELECT * FROM CLIENTES c

RIGHT JOIN PEDIDOS p ON c.id = p.cliente_id;

**Resultado:** Todos os pedidos. Pedidos sem cliente (raro) aparecem com NULL nos campos de cliente.

Pedido com cliente   → aparece com dados do cliente

Pedido sem cliente   → aparece com NULL nos campos do cliente


### 4. **FULL JOIN** (ou FULL OUTER JOIN)

**Retorna TODOS os registros de AMBAS as tabelas.**

```sql

SELECT * FROM CLIENTES c

FULL JOIN PEDIDOS p ON c.id = p.cliente_id;

**Resultado:** Tudo. Clientes sem pedido e pedidos sem cliente aparecem com NULLs.

Clientes com e sem pedido → todos aparecem

Pedidos com e sem cliente → todos aparecem


### 5. **CROSS JOIN**

**Produto cartesiano: cada linha da primeira combina com TODAS da segunda.**

```sql

SELECT * FROM CLIENTES

CROSS JOIN PEDIDOS;

**Resultado:** Se 10 clientes e 100 pedidos → 1.000 registros (cada cliente com cada pedido)


### 6. **SELF JOIN**

**JOIN da tabela com ela mesma.** Útil para relações hierárquicas.

```sql

SELECT e.nome AS empregado, g.nome AS gerente

FROM FUNCIONARIOS e

LEFT JOIN FUNCIONARIOS g ON e.gerente_id = g.id;


## Resumo Visual

| Tipo                    | Esquerda                                       | Direita |

| **INNER**       | ✅ só correspondentes                 | ✅ só correspondentes |

| **LEFT**          | ✅ todos                                      | ✅ só correspondentes |

| **RIGHT**       | ✅ só correspondentes                 | ✅ todos |

| **FULL**         | ✅ todos                                       | ✅ todos |


## Exemplo com diagrama mental

Tabela A          Tabela B

┌─────┐          ┌─────┐

│ 1           │          │ 2           │

│ 2           │          │ 3           │

│ 3           │          │ 4           │

│ 5           │          │             │

└─────┘          └─────┘


INNER JOIN: [2, 3]        (o que tem nos dois)

LEFT JOIN:  [1, 2, 3, 5]  (tudo de A)

RIGHT JOIN: [2, 3, 4]     (tudo de B)

FULL JOIN:  [1, 2, 3, 4, 5] (tudo de ambos)

```


## Dica prática

- **INNER JOIN**: quando só importam registros relacionados

- **LEFT JOIN**: quando não quer perder os registros da tabela principal (mais comum)

- **FULL JOIN**: quando precisa ver tudo de ambos os lados

- **RIGHT JOIN**: raro, dá pra substituir por LEFT trocando ordem das tabelas

ORACLE PL/SQL - Diferença entre NOT LIKE e <>

 ## Diferença entre NOT LIKE e <>


São operadores completamente diferentes com propósitos distintos:


### **LIKE / NOT LIKE**

- Usado para **comparação de padrões** com strings

- Permite uso de curingas: `%` (qualquer sequência) e `_` (um caractere)

- Funciona **apenas com dados do tipo texto** (VARCHAR2, CHAR, etc.)


```sql

-- Exemplos com NOT LIKE

WHERE nome NOT LIKE 'João%'     -- Não começa com "João"

WHERE nome NOT LIKE '%Silva%'   -- Não contém "Silva"

WHERE nome NOT LIKE '_____'     -- Não tem exatamente 5 caracteres

```


### **<> (ou !=)**

- Usado para **desigualdade exata**

- Compara valores completos

- Funciona com **qualquer tipo de dado** (números, datas, textos)


```sql

-- Exemplos com <>

WHERE id <> 10                  -- id diferente de 10

WHERE nome <> 'João'            -- nome exatamente diferente de 'João'

WHERE data <> SYSDATE           -- data diferente de hoje

```


## Principais diferenças:


CARACTERÍSTICAS             NOT LIKE                                   <> 

 **Propósito**                            Comparação de padrão                 Desigualdade exata

 **Curingas**                             Sim (%, _)                                     Não

 **Tipo de dado**                      Apenas texto                                   Qualquer tipo 

 **NULL**                                 Retorna NULL                               Retorna NULL

 **Performance**                       Geralmente mais lento |                 Geralmente mais rápido 


## Comportamento com NULL:

**Ambos retornam NULL quando comparados com NULL:**

```sql

-- Se campo é NULL:

WHERE campo NOT LIKE '%valor%'  -- NULL (não retorna)

WHERE campo <> 'valor'          -- NULL (não retorna)


-- Para incluir NULLs, é necessário tratar:

WHERE (campo IS NULL OR campo NOT LIKE '%valor%')

```


## Exemplo prático com seu caso:


```sql

-- NOT LIKE: exclui apenas padrões específicos

WHERE PAR_X_OPERADORPARC NOT LIKE 'PARCERIA - 05'  

-- Exclui: 'PARCERIA - 05', 'PARCERIA - 05 algo', 'XPARCERIA - 05X'


-- <>: exclui apenas o valor exato

WHERE PAR_X_OPERADORPARC <> 'PARCERIA - 05'

-- Exclui APENAS: 'PARCERIA - 05' (exato, sem espaços extras)


-- Se o campo tem espaços, <> falha:

-- 'PARCERIA - 05 ' (com espaço) NÃO será excluído com <>

-- Mas será excluído com NOT LIKE 'PARCERIA - 05' (depende do padrão)

```


## Para seu cenário específico:

Se o problema é espaços em branco, considere:

```sql

-- NOT LIKE com tratamento de espaços

AND TRIM(PAR_X_OPERADORPARC) NOT LIKE 'PARCERIA - 05'


-- Ou com <> tratando espaços

AND TRIM(PAR_X_OPERADORPARC) <> 'PARCERIA - 05'

```

**Resumo:** Use `NOT LIKE` quando precisa de busca por padrão com curingas. Use `<>` para comparar valores exatos e em campos não-texto.

terça-feira, 24 de fevereiro de 2026

Visual Studio - Remover o WeatherForecast

 Se você está lendo este post, é porque você ao executar sua API, se deparou com WeatherForecast. Este é apenas um template de exemplo. São apenas dois passos para remover este template.


1 — Deletar os arquivos de exemplo

No Solution Explorer, delete:

WeatherForecast.cs (na raiz do projeto)

Controllers/WeatherForecastController.cs

Clique com botão direito em cada um → Excluir


2 — Verificar o Program.cs

Confirme que não há nenhuma referência ao WeatherForecast no seu Program.cs. O seu atual já está limpo, então não deve ter nada para remover.


Espero ter ajudado e até a próxima


segunda-feira, 23 de fevereiro de 2026

CRIAR UMA API RESTful NO VISUAL STUDIO 2022

Opção Recomendada: ASP.NET Core Web API (API Web do ASP.NET Core)


A forma mais direta é criar um projeto já configurado para API REST. Veja o passo a passo:

1. Abra o Visual Studio 2022

2. Clique em "Criar um novo projeto"

3. Pesquise por "ASP.NET Core Web API"

4. Escolha o template e clique em Avançar

5. Configure o nome e local do projeto

6. Na próxima tela, selecione: 

    o .NET 8 (LTS mais recente)

    o Marque "Use controllers" se quiser o padrão MVC, ou deixe desmarcado para usar Minimal APIs

    o Marque "Enable OpenAPI support" para ter o Swagger já configurado


Esse template já vem com tudo pronto: controller de exemplo, Swagger, configurações de CORS, etc.


Projeto Vazio com C# — Vale a pena?

Tecnicamente é possível, mas não recomendo para quem está começando ou quer agilidade. Você teria que configurar manualmente o middleware, injeção de dependência, roteamento, etc. Dá mais trabalho sem nenhum ganho real.


O que você ganha com o template Web API

Com o projeto gerado, você já tem uma estrutura como:

Controllers/ → onde ficam seus endpoints

Program.cs → configuração da aplicação

appsettings.json → configurações como connection string

Swagger disponível em /swagger ao rodar o projeto


Dica importante

Se for uma API mais simples ou moderna, o Visual Studio 2022 também oferece o template de Minimal API, que é mais enxuto e sem controllers, tudo em Program.cs. Para projetos maiores e em equipe, prefira a abordagem com Controllers.

Quer que eu te ajude com os próximos passos, como criar um CRUD completo ou conectar a um banco de dados?


ASP.NET CORE API WEB (Native AOT)

O Native AOT compila o projeto diretamente para código nativo, o que traz inicialização mais rápida e menor uso de memória. Porém tem limitações importantes:

Não suporta reflection (o que quebra muitas libs populares como Entity Framework, AutoMapper, Newtonsoft.Json, etc.)

Mais restrito e complexo de configurar

Indicado para cenários muito específicos de alta performance, como microsserviços em containers


Resumindo API Web do ASP.NET  x Core Native AOT


API Web do ASP.NET    

             

Facilidade                                 ✅ Alta

Compatibilidade com libs         ✅ Total

Performance de startup             Normal

Recomendado para iniciantes   ✅ Sim


Core Native AOT


Facilidade                                  ❌ Complexo

Compatibilidade com libs         ⚠️ Limitada

Performance de startup              Muito alta

Recomendado para iniciantes   ❌ Não


Facilidade ✅ Alta ❌ Complexo

Compatibilidade com libs ✅ Total ⚠️ Limitada

Performance de startup Normal Muito alta

Recomendado para iniciantes ✅ Sim ❌ Não


terça-feira, 17 de fevereiro de 2026

ANDROID STUDIO - OBTER SHA1 UTILIZANDO POWERSHELL

No Android Studio, abra o Terminal. Para acessar o Terminal (View > Tool Windows > Terminal).

Em seguida digite: & "C:\Program Files\Android\Android Studio\jbr\bin\keytool.exe" -list -v -alias androiddebugkey -keystore "$env:USERPROFILE\.android\debug.keystore" -storepass android -keypass android


O certificado SHA1 será exibido.


Espero ter ajudado e até a próxima.

quinta-feira, 12 de fevereiro de 2026

ORACLE PL/SQL - FETCH_LEITURA

 <<FETCH_LEITURA>> é um LABEL (rótulo) em PL/SQL.

Significado:


É um marcador/etiqueta que identifica um ponto específico no código

A sintaxe é: <<nome_do_label>>


Para que serve:


Documentação/Organização: Identificar visualmente seções do código

Referência em comandos GOTO: Permitir saltos para esse ponto (má prática)

Identificar loops: Dar nome a um loop específico para usar em EXIT ou CONTINUE


Neste código:

sqlLOOP  

    <<FETCH_LEITURA>>   

    V_DEB_LIDO  := V_DEB_LIDO + 1;

    FETCH c_IMO_LOCALID INTO ...

O label <<FETCH_LEITURA>> está apenas documentando onde começa a leitura do cursor. Não está sendo usado para nenhuma funcionalidade (não há GOTO, EXIT ou CONTINUE referenciando ele).

sexta-feira, 6 de fevereiro de 2026

FORMATAÇÃO DE DATAS C#


EXEMPLOS:


SELECT convert(datetime, 'Oct 23 2012 11:01AM', 100) -- mon dd yyyy hh:mmAM (or PM)

SELECT convert(datetime, 'Oct 23 2012 11:01AM') -- 2012-10-23 11:01:00.000

-- Without century (yy) string date conversion - convert string to datetime function

SELECT convert(datetime, 'Oct 23 12 11:01AM', 0) -- mon dd yy hh:mmAM (or PM)

SELECT convert(datetime, 'Oct 23 12 11:01AM') -- 2012-10-23 11:01:00.000

-- Convert string to datetime sql - convert string to date sql - sql dates format

-- T-SQL convert string to datetime - SQL Server convert string to date

SELECT convert(datetime, '10/23/2016', 101) -- mm/dd/yyyy

SELECT convert(datetime, '2016.10.23', 102) -- yyyy.mm.dd ANSI date with century

SELECT convert(datetime, '23/10/2016', 103) -- dd/mm/yyyy

SELECT convert(datetime, '23.10.2016', 104) -- dd.mm.yyyy

SELECT convert(datetime, '23-10-2016', 105) -- dd-mm-yyyy

-- mon types are nondeterministic conversions, dependent on language setting

SELECT convert(datetime, '23 OCT 2016', 106) -- dd mon yyyy

SELECT convert(datetime, 'Oct 23, 2016', 107) -- mon dd, yyyy

-- 2016-10-23 00:00:00.000

SELECT convert(datetime, '20:10:44', 108) -- hh:mm:ss

-- 1900-01-01 20:10:44.000

-- mon dd yyyy hh:mm:ss:mmmAM (or PM) - sql time format - SQL Server datetime format

SELECT convert(datetime, 'Oct 23 2016 11:02:44:013AM', 109) 

-- 2016-10-23 11:02:44.013

SELECT convert(datetime, '10-23-2016', 110) -- mm-dd-yyyy

SELECT convert(datetime, '2016/10/23', 111) -- yyyy/mm/dd

-- YYYYMMDD ISO date format works at any language setting - international standard

SELECT convert(datetime, '20161023')

SELECT convert(datetime, '20161023', 112) -- ISO yyyymmdd

-- 2016-10-23 00:00:00.000

SELECT convert(datetime, '23 Oct 2016 11:02:07:577', 113) -- dd mon yyyy hh:mm:ss:mmm

-- 2016-10-23 11:02:07.577

SELECT convert(datetime, '20:10:25:300', 114) -- hh:mm:ss:mmm(24h)

-- 1900-01-01 20:10:25.300

SELECT convert(datetime, '2016-10-23 20:44:11', 120) -- yyyy-mm-dd hh:mm:ss(24h)

-- 2016-10-23 20:44:11.000

SELECT convert(datetime, '2016-10-23 20:44:11.500', 121) -- yyyy-mm-dd hh:mm:ss.mmm

-- 2016-10-23 20:44:11.500

-- Style 126 is ISO 8601 format: international standard - works with any language setting

SELECT convert(datetime, '2008-10-23T18:52:47.513', 126) -- yyyy-mm-ddThh:mm:ss(.mmm)

-- 2008-10-23 18:52:47.513

SELECT convert(datetime, N'23 شوال 1429 6:52:47:513PM', 130) -- Islamic/Hijri date

SELECT convert(datetime, '23/10/1429 6:52:47:513PM', 131) -- Islamic/Hijri date

-- Convert DDMMYYYY format to datetime - sql server to date / datetime

SELECT convert(datetime, STUFF(STUFF('31012016',3,0,'-'),6,0,'-'), 105) 

-- 2016-01-31 00:00:00.000

-- SQL Server T-SQL string to datetime conversion without century - some exceptions

-- nondeterministic means language setting dependent such as Mar/Mär/mars/márc

SELECT convert(datetime, 'Oct 23 16 11:02:44AM') -- Default

SELECT convert(datetime, '10/23/16', 1) -- mm/dd/yy U.S.

SELECT convert(datetime, '16.10.23', 2) -- yy.mm.dd ANSI

SELECT convert(datetime, '23/10/16', 3) -- dd/mm/yy UK/FR

SELECT convert(datetime, '23.10.16', 4) -- dd.mm.yy German

SELECT convert(datetime, '23-10-16', 5) -- dd-mm-yy Italian

SELECT convert(datetime, '23 OCT 16', 6) -- dd mon yy non-det.

SELECT convert(datetime, 'Oct 23, 16', 7) -- mon dd, yy non-det.

SELECT convert(datetime, '20:10:44', 8) -- hh:mm:ss

SELECT convert(datetime, 'Oct 23 16 11:02:44:013AM', 9) -- Default with msec

SELECT convert(datetime, '10-23-16', 10) -- mm-dd-yy U.S.

SELECT convert(datetime, '16/10/23', 11) -- yy/mm/dd Japan

SELECT convert(datetime, '161023', 12) -- yymmdd ISO

SELECT convert(datetime, '23 Oct 16 11:02:07:577', 13) -- dd mon yy hh:mm:ss:mmm EU dflt

SELECT convert(datetime, '20:10:25:300', 14) -- hh:mm:ss:mmm(24h)

SELECT convert(datetime, '2016-10-23 20:44:11',20) -- yyyy-mm-dd hh:mm:ss(24h) ODBC can.

SELECT convert(datetime, '2016-10-23 20:44:11.500', 21)-- yyyy-mm-dd hh:mm:ss.mmm ODBC

 

Espero que seja útil. E até a próxima dica.

segunda-feira, 24 de novembro de 2025

ORACLE - Pular os 50 primeiros registros

Para pular os 50 primeiros registros em Oracle PL/SQL, você pode usar a cláusula `OFFSET` junto com `FETCH` (disponível a partir do Oracle 12c).  


Aqui está um exemplo prático:


sql

SELECT *

FROM minha_tabela

ORDER BY id

OFFSET 50 ROWS FETCH NEXT 100 ROWS ONLY;

```


Explicação:

- `ORDER BY id` → é **obrigatório** para garantir a ordem dos registros.

- `OFFSET 50 ROWS` → ignora os primeiros 50 registros.

- `FETCH NEXT 100 ROWS ONLY` → retorna os próximos 100 registros (pode ajustar conforme necessário).


### Se estiver em versão anterior ao Oracle 12c (sem suporte a `OFFSET`):

Você pode usar uma subquery com `ROWNUM`:


sql

SELECT *

FROM (

    SELECT t.*, ROWNUM r

    FROM (

        SELECT * FROM minha_tabela ORDER BY id

    ) t

    WHERE ROWNUM <= 150

)

WHERE r > 50;

```


- Aqui, a subquery interna ordena os dados.

- O filtro `ROWNUM <= 150` garante que só pegue até o registro 150.

- O filtro externo `r > 50` remove os primeiros 50.


quinta-feira, 30 de outubro de 2025

ORACLE - TOP(N) é uma sintaxe específica do SQL Server (T-SQL).

 1. A Forma Moderna (Oracle 12c e superior): FETCH

Esta é a maneira mais limpa, moderna e recomendada. É a sintaxe padrão do SQL ANSI para limitar linhas.


Para obter o equivalente exato de SELECT TOP 7 ... do SQL Server, você usaria FETCH FIRST 7 ROWS ONLY.


Exemplo:


SQL


SELECT

    nome_da_coluna,

    outra_coluna

FROM

    sua_tabela

ORDER BY

    coluna_de_ordenacao DESC  -- Importante para o "top" ter sentido

FETCH FIRST 7 ROWS ONLY;

2. A Forma Clássica (Oracle 11g e anteriores): ROWNUM

Antes da versão 12c, a única maneira de limitar linhas era usando a pseudo-coluna ROWNUM. No entanto, ela tem uma particularidade importante.


ROWNUM é atribuído antes da cláusula ORDER BY. Se você quiser as 7 primeiras linhas após a ordenação (que é o que o TOP geralmente faz), você precisa usar uma subconsulta.


Exemplo (a forma correta com ORDER BY):


SQL


SELECT *

FROM (

    SELECT

        nome_da_coluna,

        outra_coluna

    FROM

        sua_tabela

    ORDER BY

        coluna_de_ordenacao DESC

)

WHERE ROWNUM <= 7;

Por que a subconsulta é necessária? Se você fizesse isto (forma incorreta):


SQL


-- !! Cuidado: Isto NÃO é o TOP 7 !!

SELECT

    nome_da_coluna,

    outra_coluna

FROM

    sua_tabela

WHERE

    ROWNUM <= 7

ORDER BY

    coluna_de_ordenacao DESC;

O Oracle pegaria as primeiras 7 linhas que ele encontrar (em ordem aleatória de armazenamento), e depois as ordenaria. Você não obteria o "top 7" real.


Bônus: Equivalente ao TOP 7 WITH TIES

Se você precisar do equivalente ao TOP 7 WITH TIES do SQL Server (que inclui todas as linhas que empatam com a 7ª posição), a sintaxe FETCH do Oracle 12c+ também suporta isso:


SQL


SELECT

    nome_da_coluna,

    outra_coluna

FROM

    sua_tabela

ORDER BY

    coluna_de_ordenacao DESC

FETCH FIRST 7 ROWS WITH TIES;

Resumo:


Se você usa Oracle 12c ou mais recente: Use FETCH FIRST 7 ROWS ONLY.


Se você usa Oracle 11g ou mais antigo: Use a subconsulta com WHERE ROWNUM <= 7.

terça-feira, 26 de agosto de 2025

DMSII

 DMSII é a sigla para **Data Management System II**, um sistema de gerenciamento de banco de dados (SGBD) que foi desenvolvido pela Burroughs Corporation em 1972. Ele é um dos SGBDs mais antigos, e historicamente competiu com sistemas como o IMS da IBM.

O DMSII foi originalmente baseado no **modelo de rede** para organização de dados, que era um dos modelos mais populares antes do surgimento e popularização dos bancos de dados relacionais. Em um banco de dados de rede, os dados são estruturados como um grafo, permitindo que cada "registro filho" tenha vários "registros pai", o que pode ser mais complexo do que o modelo hierárquico, mas mais flexível.

Atualmente, o DMSII ainda é usado em alguns sistemas de grande porte (mainframes) da **Unisys** (empresa que surgiu da fusão da Burroughs e Sperry). Ele é parte integrante da arquitetura **ClearPath MCP** da Unisys, que é usada em várias aplicações críticas de negócios que precisam de alta disponibilidade e desempenho.

Em resumo, o DMSII é um SGBD "legado" com uma longa história, conhecido por sua robustez e uso em ambientes de mainframe, mesmo que a maioria dos bancos de dados modernos usem o modelo relacional ou NoSQL.

sexta-feira, 18 de julho de 2025

O que é Git no Visual Studio?

 

O que é Git no Visual Studio?

O Git é um sistema de controle de versão distribuído que permite a você e sua equipe rastrear mudanças no código, colaborar em projetos e gerenciar diferentes versões de um software. O Visual Studio integra ferramentas Git diretamente em sua interface, facilitando o uso dessas funcionalidades sem sair do ambiente de desenvolvimento.


1. Buscar (Fetch)

Quando você "Busca" (ou "Fetch") no Visual Studio, você está baixando as últimas mudanças do repositório remoto (online, como GitHub, Azure DevOps, GitLab, etc.) para o seu repositório local.

  • O que ele faz: Ele apenas baixa as informações sobre as novas alterações (commits) e ramificações. Ele não mescla essas mudanças com o seu código local e nem modifica seus arquivos de trabalho.

  • Quando usar: Use "Buscar" para ver o que há de novo no repositório remoto sem afetar seu trabalho atual. É uma boa prática fazer um "Fetch" regularmente para se manter atualizado sobre o progresso da equipe.


2. Efetuar Pull (Pull)

"Efetuar Pull" (ou "Pull") é uma combinação de "Buscar" e "Mesclar" (Merge). Ele baixa as últimas alterações do repositório remoto e tenta integrá-las ao seu código local.

  • O que ele faz:

    1. Busca: Baixa as novas mudanças do repositório remoto.

    2. Mescla (Merge): Tenta aplicar essas mudanças à sua branch local atual.

  • Quando usar: Use "Efetuar Pull" quando você quer atualizar seu projeto local com as últimas mudanças da equipe e continuar trabalhando a partir daí. Fique atento, pois se houver conflitos entre as mudanças remotas e suas mudanças locais, o Git irá sinalizá-los para você resolver.


3. Efetuar Push (Push)

"Efetuar Push" (ou "Push") é o oposto de "Pull". Ele envia suas alterações (commits) do seu repositório local para o repositório remoto, tornando-as visíveis para o resto da equipe.

  • O que ele faz: Envia todos os seus commits locais que ainda não estão no repositório remoto para a branch correspondente no servidor.

  • Quando usar: Use "Efetuar Push" quando você concluiu uma parte do trabalho, fez os commits necessários e quer compartilhar suas atualizações com a equipe. É crucial garantir que seu código esteja em um estado funcional antes de fazer um push.


4. Sincronizar (Sync)

A opção "Sincronizar" no Visual Studio é uma funcionalidade que combina "Pull" e "Push" para manter seu repositório local e remoto em sincronia.

  • O que ele faz:

    1. Pull (se necessário): Primeiro, ele tenta fazer um "Pull" para baixar as últimas alterações do repositório remoto.

    2. Push (se necessário): Em seguida, ele tenta fazer um "Push" para enviar seus commits locais para o repositório remoto.

  • Quando usar: "Sincronizar" é útil quando você quer garantir que seu repositório local esteja totalmente atualizado com o remoto e que suas alterações locais foram enviadas. No entanto, muitos desenvolvedores preferem usar "Pull" e "Push" separadamente para ter mais controle sobre o processo e lidar com conflitos de forma mais granular.


RESUMO:

🔄 Buscar (Fetch)

  • O que faz:
    Verifica se há atualizações no repositório remoto (como no GitHub), mas não traz as mudanças para o seu código local.

  • Exemplo prático:
    Se outra pessoa fez um commit no repositório remoto, o "Buscar" apenas avisa que há novas alterações – sem misturá-las ainda com seu código local.


⬇️ Efetuar Pull (Pull)

  • O que faz:
    Traz as mudanças do repositório remoto para seu repositório local e atualiza sua branch atual.

  • É equivalente a: git fetch + git merge

  • Exemplo prático:
    Você fez "Pull" e agora o seu código local está atualizado com tudo o que foi alterado no repositório remoto por outros colaboradores.


⬆️ Efetuar Push (Push)

  • O que faz:
    Envia seus commits locais para o repositório remoto.

  • Exemplo prático:
    Você terminou de trabalhar em uma funcionalidade, fez commit das mudanças localmente e agora usa "Push" para subir isso para o GitHub (ou outro servidor Git).


🔁 Sincronizar (Sync)

  • O que faz:
    Executa Pull + Push ao mesmo tempo:

    • Primeiro, busca e integra as mudanças do remoto (Pull).

    • Depois, envia seus commits locais (Push).

  • Exemplo prático:
    Útil quando você quer garantir que está com tudo atualizado e também subir seu trabalho em um único passo.


Resumo rápido:



BuscarVerifica atualizações no remoto, mas não altera seu código local
Efetuar PullTraz mudanças do remoto para sua branch local
Efetuar PushEnvia suas alterações locais para o repositório remoto
SincronizarFaz Pull e Push em sequência

Em resumo, essas operações Git no Visual Studio são a espinha dorsal da colaboração em projetos de código. Entender quando e como usar cada uma delas é essencial para um fluxo de trabalho eficiente e para evitar problemas de versionamento.

O Que é Web Forms?

Web Forms é um modelo de desenvolvimento web que faz parte do ASP.NET, a estrutura de desenvolvimento da Microsoft para a construção de aplicações web. Ele foi introduzido com o .NET Framework e foi uma das primeiras abordagens para criar sites dinâmicos usando C# (ou VB.NET).


A Ideia Central

A grande sacada do Web Forms era tentar trazer a experiência de desenvolvimento de aplicações desktop (como as feitas em Windows Forms) para a web. Em vez de lidar diretamente com HTML, CSS, JavaScript e o ciclo de vida HTTP de requisições e respostas, os desenvolvedores trabalhavam com controles visuais (como botões, caixas de texto, grids) que podiam ser arrastados e soltos em uma página.

Pense assim:

  • Aplicações Desktop: Você arrasta um botão para um formulário, dá um clique duplo e escreve o código que será executado quando o botão for clicado.

  • Web Forms: A Microsoft tentou replicar isso. Você arrastava um asp:Button para sua página .aspx, dava um clique duplo e escrevia o código C# (ou VB.NET) em um arquivo "code-behind" (.aspx.cs ou .aspx.vb) que seria executado no servidor quando o botão fosse clicado no navegador.


Como Funciona

  1. Páginas .aspx: São arquivos de texto que contêm o HTML estático e os controles de servidor ASP.NET (elementos com o prefixo asp:).

  2. Code-Behind (.aspx.cs ou .aspx.aspx.vb): Para cada página .aspx, há um arquivo de código separado onde você escreve a lógica de programação para os eventos dos controles, acesso a banco de dados, etc.

  3. Controles de Servidor: São objetos que você adiciona à sua página (<asp:TextBox>, <asp:Button>, <asp:GridView>, etc.). Eles são renderizados como HTML no navegador, mas você programa a lógica deles no servidor.

  4. Estado da Página (View State): Este é um conceito chave no Web Forms. Como o HTTP é "stateless" (não guarda informações de uma requisição para outra), o Web Forms usa o View State (um campo oculto na página HTML) para manter o estado dos controles entre as postbacks (envios de formulário de volta ao servidor). Isso ajudava a dar a sensação de que a página estava mantendo seu estado, como uma aplicação desktop.

  5. Ciclo de Vida da Página: Uma página Web Forms tem um ciclo de vida bem definido (inicialização, carregamento, manipulação de eventos, renderização), o que ajuda o desenvolvedor a saber quando e onde colocar seu código.

  6. Postbacks: Quando um usuário interage com um controle (como clicar em um botão), a página inteira é enviada de volta ao servidor (um "postback"), o código no servidor é executado e a página é renderizada novamente e enviada de volta ao navegador.


Vantagens do Web Forms

  • Curva de Aprendizagem Suave (para desenvolvedores desktop): Para quem vinha do desenvolvimento de aplicações Windows Forms, a transição para Web Forms era relativamente intuitiva devido ao modelo de eventos e controles.

  • Produtividade Rápida: Era possível criar formulários e aplicações simples rapidamente, arrastando e soltando controles.

  • Abstração do HTML: O desenvolvedor não precisava se preocupar tanto com os detalhes do HTML, JavaScript e CSS, pois o ASP.NET Web Forms gerava grande parte disso.

  • Rico Conjunto de Controles: Oferecia uma vasta gama de controles de servidor prontos para uso, desde caixas de texto e botões até grids de dados complexos e validadores.


Desvantagens do Web Forms

  • HTML Gerado: O HTML gerado pelo Web Forms podia ser verboso e difícil de otimizar para SEO ou para design responsivo.

  • View State Pesado: O View State, embora útil, podia inchar o tamanho da página, tornando-a mais lenta para carregar, especialmente em páginas com muitos controles ou dados.

  • Controle Limitado sobre o HTML/JavaScript: Para personalizações avançadas ou para integrar frameworks JavaScript modernos, o Web Forms podia ser um desafio, pois abstraía demais a camada front-end.

  • Acoplamento Forte: O modelo de postback e View State criava um acoplamento forte entre o cliente e o servidor, o que dificultava a criação de Single Page Applications (SPAs) ou APIs RESTful.


Onde o Web Forms se Encaixa Hoje

Embora o Web Forms ainda seja usado em muitas aplicações legadas e em algumas novas aplicações internas (onde a velocidade de desenvolvimento e a familiaridade com o modelo são prioridades), ele foi largamente substituído por abordagens mais modernas para o desenvolvimento web com .NET:

  • ASP.NET MVC (Model-View-Controller): Oferece maior controle sobre o HTML e uma separação de preocupações mais clara, sendo ideal para aplicações web complexas e públicas.

  • ASP.NET Core: A versão mais recente e multiplataforma do ASP.NET, que unifica MVC, Web API e outros modelos, sendo a escolha preferencial para novos desenvolvimentos.

  • Blazor: Permite construir interfaces de usuário interativas da web usando C# em vez de JavaScript, executando o código C# diretamente no navegador (via WebAssembly) ou no servidor.

Em resumo, o Web Forms foi um passo importante na evolução do desenvolvimento web com .NET, tornando-o acessível a muitos desenvolvedores. No entanto, o cenário web evoluiu, e outras tecnologias do ASP.NET oferecem hoje maior flexibilidade e controle para atender às demandas de aplicações web modernas.