Busca

Neste tutorial passo a passo, você vai aprender como usar a biblioteca Whisper da OpenAI para transcrever áudio de vídeos em texto. O Whisper é uma ferramenta poderosa para reconhecimento de fala, e neste vídeo, vamos te guiar em como configurar a biblioteca Whisper.net em um projeto .NET, extrair áudio de um vídeo e realizar a transcrição de forma eficiente. Começaremos mostrando a instalação do FFmpeg, necessário para a extração do áudio, em seguida, vamos criar uma aplicação .NET do tipo console e implementar o código que realizará a transcrição usando a biblioteca Whisper.NET. Mostraremos como baixar o modelo adequado, extrair o áudio e processá-lo para obter o texto. Se você é desenvolvedor ou apenas está começando no mundo da programação e procura aprender mais sobre transcrição de voz e processamento de áudio, este vídeo é para você! ### O que você aprenderá neste vídeo: - O que é o OpenAI Whisper e suas funcionalidades - Como instalar e configurar o FFmpeg para trabalhar com áudio - Como criar uma aplicação .NET e usar a biblioteca Whisper.NET - Extração de áudio de vídeos e transcrição automática - Dicas sobre a escolha de modelos e melhores práticas ## Índice de Capítulos 00:00:00 - Whisper da OpenAI - Estrutura e funcionamento 00:02:45 - Apresentando Whisper.net 00:03:45 - Downloads de Whisper Models 00:04:53 - Criando um projeto .NET Console 00:06:48 - Extensões de VSCode para .NET 00:09:39 - Extraindo áudio com FFmpeg 00:11:46 - Codificando o Download do modelo de transcrição 00:12:28 - Instalação do Whisper.net 00:15:39 - Codificando a transcrição do áudio 00:21:12 - Processamento e transcrição do áudio 00:22:24 - Testando modelo Medium

Aplicando IA para edição de imagens via API da OpenAI. Aprenda a criar uma aplicação em Blazor utilizando o GPT Image Edit da OpenAI para editar imagens. Neste tutorial, vamos explorar como integrar o Blazor e .NET com a API de edição de imagens da OpenAI. Você aprenderá a criar uma aplicação que permite o upload de imagens, a modificação delas por meio de prompts e a exibição dos resultados na tela. Exploraremos detalhes como a instalação dos pacotes necessários, configuração da API e as nuances do .NET Blazor. ### Índice de Capítulos 00:00:00 Explorando o portal platform.openai.com 00:03:40 Explicando campos de API do Endpoint Images/Edits para os modelos gpt-image-1 e dall-e 00:09:07 Criando uma nova aplicação Blazor no dotnet (dotnet new e list) 00:13:37 Compilando uma aplicação Blazor (dotnet build) 00:14:01 Instalando os pacotes OpenAI e DotNetEnv (nuget - dotnet add package) 00:15:19 Explicando o uso do pacote OpenAI 00:18:18 Explicando o uso do pacote DotNetEnv 00:19:09 Executando a aplicação Blazor com dotnet watch (e Hot Reload) 00:20:05 Modificando UI da página Home no Blazor (usando Bootstrap) 00:22:29 Implementando upload de imagem usando InputFile e o evento OnChange (RequestImageFile) 00:32:11 Convertendo a imagem do upload em base64 para exibi-la na página (MemoryStream) 00:36:55 Definindo e explicando rapidamente o RenderMode (InteractiveServer) 00:40:17 Enviando a imagem para a API da OpenAI usando o pacote ImageClient e model gpt-image-1 00:42:09 Criando a ligação (binding) entre as variáveis e os controles HTML da página 00:45:00 Criando API Key na plataforma OpenAI e gravando em variáveis de ambiente usando o DotNetEnv 00:45:34 Explicando opções no Dashboard da API na plataforma da OpenAI (Usage, etc.) 00:56:42 Implementando tratamento de erros e ampulheta de processamento (feedback visual) 01:06:30 Explicando a verificação de perfil para ser possível usar o Endpoint Images/Edits

Como Editar Imagens com a API GPT-Image-1 da OpenAI Usando .NET e C# (Exemplo Prático). Transforme suas imagens com IA: aprenda a criar edições visuais incríveis usando C# e OpenAI GPT-Image-1. Neste tutorial, você aprenderá a editar imagens utilizando a inteligência artificial da OpenAI através do endpoint Images Edit, com uma aplicação em .NET console. Exploramos como enviar uma imagem e solicitar modificações via prompt, retornando uma imagem editada. Demonstramos também a configuração da API Key e instalação de pacotes necessários, como OpenAI .Net e DotNetEnv, além de manipular variáveis de ambiente. ### Índice de Capítulos - 00:00:00 - Introdução ao OpenAI Images Edit Endpoint - 00:03:08 - Explicando os campos enviados no Request Images Edits (prompt, mask, quality, etc.) - 00:08:40 - Criando uma aplicação dotnet Console (dotnet new, dotnet new list ...) - 00:12:41 - Compilando e instalando os componentes NutGet OpenAi e DotNetEnv (dotnet add package) - 00:14:20 - Explicando uso do componente OpenAi - 00:16:39 - Explicando uso do componente DotNetEnv - 00:17:43 - Codificando Request à OpenAi usando o Componente ImageClient - 00:20:12 - Exibindo Extensões VS Code aconselhadas para Desenvolvimento C# .NET - 00:22:22 - Gerando a API Key OpenAI e conhecendo o Dashboard OpenAi (usage, permissões, ...) - 00:25:24 - Usando o DotNetEnv .env com boas práticas para tornar oculta a API Key OpenAi - 00:28:27 - Mostrando os métodos existentes no Componente ImageClient - 00:29:36 - Definindo os Parâmetros ImageEditOptions - 00:32:45 - Recebendo a imagem processada como bytes e gravando num arquivo (FileStream)

Nesse vídeo você irá aprender como criar um Bot para Discord em C# usando uma aplicação Console, e aprenderá também como enviar texto, imagens, links e ainda habilitar o log para facilitar a procura de erros.

Do zero ao deploy no Azure App Service com GitHub Actions: app Blazor, appsettings, variáveis, secrets e autenticação. Aprenda, passo a passo, a publicar aplicações .NET (Blazor, Web API e MVC) no Azure usando CI/CD com GitHub Actions. Neste guia prático, criamos uma aplicação Blazor, configuramos appsettings e variáveis de ambiente (local e no Azure), montamos um pipeline YAML com .NET SDK, Restore e Publish, integramos com Azure App Service via Publish Profile e Secrets do GitHub, e finalizamos com uma dica extra de autenticação para restringir acesso. Você vai ver: - Criação rápida de um app Blazor e compilação local (.NET build/watch) - Leitura de configurações: appsettings.json (incluindo objetos aninhados), ConnectionStrings e variáveis de ambiente (Environment) - Workflow GitHub Actions: checkout, setup do .NET (v9), restore, publish e deploy para Azure App Service (Linux) - Configuração de Secrets no GitHub (Publish Profile e App Name) - Criação do App Service no Azure (região, plano F1, .NET 9, Linux) - Ajuste de configurações no Azure: Application settings, Connection strings e diferença Linux/Windows (dois underlines para níveis) - Dica extra: proteger a aplicação com autenticação Microsoft (acesso interno) Pré-requisitos (sugeridos): - Conta no Azure e no GitHub - .NET SDK 9 instalado - VS Code (opcional) - Git instalado Comandos úteis: - dotnet new, dotnet build, dotnet watch, dotnet restore, dotnet publish - git init, git add/commit, git branch/checkout/switch/merge, git push origin - PowerShell: definir variável de ambiente via $env:MY_VARIABLE="valor" Resultado: um pipeline de deploy automatizado. Basta dar push no branch de publicação para que sua aplicação seja compilada, publicada e atualizada no Azure. ## Capítulos - 00:00:00 dotnet new Blazor e organização do projeto - 00:02:46 Build inicial (.NET Build) e verificação - 00:03:15 Ajustes no Home.razor e título da aplicação - 00:04:19 Execução com dotnet watch - 00:04:40 AppSettings: config e connection strings (local e produção) - 00:06:20 Código: IConfiguration, leitura de config/connection/env - 00:08:05 GetConnectionString e Environment.GetEnvironmentVariable - 00:09:11 Restart do Blazor e exibição dos valores na UI - 00:11:01 PowerShell: criando variável de ambiente local - 00:12:29 Começando o Workflow do GitHub Actions (YAML) - 00:14:47 Disparo do workflow por push no branch deploy - 00:16:01 Ubuntu-latest, checkout e setup .NET 9 no pipeline - 00:18:09 dotnet --list-sdks e versão do SDK no workflow - 00:20:17 dotnet publish e pasta de saída (publish) - 00:23:03 Inicializando Git, .gitignore e primeiro commit - 00:26:37 Repositório no GitHub e Actions - 00:27:10 Criando o App Service no Azure (Web App) - 00:31:04 Configurações: .NET 9, Linux, plano F1 - 00:35:04 Push para o branch deploy e criação do branch (Pipeline disparado) - 00:37:35 Baixando o Publish Profile no Azure - 00:39:19 Secret AZURE_WEBAPP_PUBLISH_PROFILE no GitHub - 00:40:14 Secret AZURE_WEBAPP_NAME (nome do App Service) - 00:43:06 Merge master → deploy e novo push - 00:46:02 Azure: adicionando variável de ambiente (Application settings) - 00:46:58 Azure: adicionando Connection String - 00:49:00 Linux: usando “__” para níveis em appsettings - 00:50:18 Dica extra: autenticação Microsoft (acesso interno)

Comunicação por TCP Sockets em C#: Blazor, Console e WinForms integrados em um Tutorial Completo! Este vídeo une e organiza três conteúdos completos sobre comunicação via TCP Sockets em C# e .NET, mostrando desde os conceitos iniciais até a implementação prática com Console Server, Blazor Client e WinForms Client. Você aprenderá passo a passo como: - Conceituar a comunicação por Sockets e entender diferenças para HTTP - Criar um Server TCP em .NET Console com TcpListener - Criar Clients TCP em Blazor Server e WinForms - Trabalhar com StreamReader e StreamWriter para envio/recebimento de mensagens - Gerenciar múltiplas conexões simultâneas (broadcast para todos os sockets) - Usar Task, Invoke, InvokeAsync e StateHasChanged para atualizar a UI - Tratar erros e desconexões de clientes - Integrar tudo em uma aplicação prática de comunicação cliente/servidor # Índice de Capítulos - 00:00:00 Conceitualizando a Comunicação por Sockets - 00:05:07 Criando a aplicação TCP Server .Net Console (dotnet new) - 00:10:31 Criando o Listener de TCP com o TcpListener - 00:13:15 Criando o loop para aguardar conexões TCP (AcceptTcoClient) - 00:13:48 Criando a tarefa (Task) que receberá e responderá as mensagens TCP - 00:15:16 Definindo os fluxos, geral (Stream), de envio (StreamWriter) e recebimento (StreamReader) - 00:15:41 Explicando a diferença entre conexão por Socket e comum HTTP - 00:19:57 Recebendo a mensagem TCP enviada pelo Client (Stream.ReadLine) - 00:21:53 Respondendo a mensagem TCP enviada pelo Client (Stream.WriteLine) - 00:27:29 Compilando a aplicação TCP Server .Net Console (dotnet build) - 00:27:58 Criando e executando a aplicação TCP Client em Blazor (Server) com .Net (dotnet new blazor) - 00:30:30 Criando a Interface (UI) em Blazor para o TCP Client (HTML, CSS e Bootstrap) - 00:35:00 Definindo os fluxos, geral (NetworkStream), envio (StreamWriter) e recebimento (StreamReader) - 00:39:19 Definindo os Bindings fazendo a ligação entre Interface (UI) e Código - 00:41:54 Inicializando o TCP Client (TcpClient) - 00:44:03 Criando a tarefa (Task) que define os fluxos (stream) de recebimento e resposta de mensagens TCP - 00:46:47 Atualizando, de uma Task externa, a Interface (UI) em Blazor (InvokeAsync, StateHasChange) - 00:47:36 Definindo método para envio de mensagens TCP (Stream.WriteLine) - 00:51:32 Definindo e detalhando o RenderMode InteractiveServer - 00:55:16 Tratando erros em uma aplicação .Net Blazor - 00:59:26 Compilando, executando e testando 2 aplicações .Net Blazor e Console (Client e TCP Server) - 01:02:25 Criando uma class auxiliar e um Dictionary de Streams de TcpClient - 01:07:46 Pegando o EndPoint do Client Socket conectado e incluindo no Dictionary - 01:11:24 Loop para responder a todos os Clients Socket TCP conectados (Broadcast) - 01:12:09 Verificando se o Client Socket TCP está conectado - 01:12:58 Desconectando Streams Client Socket TCP e o removendo do Dictionary - 01:14:51 Respondendo a um Client Socket TCP no seu StreamWriter - 01:16:42 Trocando um Dictionary por um ConcurrentDictionary de Clients Socket TCP - 01:19:08 Explicação completa de um Server Socket TCP em .net Console (TcpListener) - 01:28:26 Explicação completa de um Client Socket TCP em .net Blazor (TcpClient) - 01:31:35 Compilando e executando 2 aplicação Client e Server TCP em .net (Blazor e Console) - 01:43:56 Criando um Client Socket usando WinForms no Visual Studio 2022 - 01:46:03 Ajustando Componentes de interface (UI) no Winforms - 01:48:34 Conectando ao server TcpClient e definindo os fluxos (StreamReader e StreamWriter) - 01:52:23 Tratando o recebimento mensagens dos Clients usando StreamReader - 01:52:52 Usando Invoke para preencher uma ListBox na MainThread a partir de uma Task - 01:54:22 Codificando evento Click botão para enviar mensagens ao Socket Server (StreamWriter) - 01:55:54 Testando Sockets entre os Clientes Winforms e Blazor e o Server .net Console

Neste vídeo tutorial, você aprenderá a criar uma aplicação com .NET MAUI capaz de acessar hardware em diferentes dispositivos, especificamente o acelerômetro, utilizando a técnica de Custom Renders. Explore como criar aplicações que funcionam tanto em Android quanto em iOS, enquanto aprende a diferenciar códigos específicos para cada plataforma. Você verá como configurar o Visual Studio 2022 para desenvolvimento com .NET MAUI, aprenderá a criar uma interface de usuário com XAML e a implementar a lógica necessária para capturar dados do acelerômetro, usando o padrão MVVM. ### Índice de Capítulos: 00:00:00 - Visão geral sobre o acesso a sensores em dispositivos 00:02:06 - Criando e executando no emulador uma aplicação MAIU (Nativa, XAML) no Visual Studio 00:06:00 - Estrutura do projeto e criação do app .NET MAUI (pastas no Solution Explorer) 00:07:50 - Criação da interface do usuário (UI) com XAML com MAUI (layout) 00:14:48 - Criação e implementação da interface (contrato para Custom Renders) 00:18:18 - Implementação de métodos da interface para o Renderizador Personalizado no Android 00:19:06 - Injeção de dependências no .NET MAUI para Custom Renders em diferentes plataformas 00:23:35 - Adaptação do código para diferentes plataformas com Custom Renders 00:27:02 - Codificando Acelerômetro no Android (Accelerometer) 00:33:04 - Introdução ao padrão MVVM e criação do ViewModel no MAUI (BindingContext) 00:34:56 - Criando uma propriedade requerida no C# (required) 00:39:43 - Criando Command para fazer Binding com clique em botões 00:40:45 - Tornando tipada (strongly typed) a interface (UI) do usuário em XAML (DataType, BindingContext) 00:43:22 - Simulando acelerômetro no Emulador Android com MAUI 00:43:44 - Implementando INotifyPropertyChanged para conferir reatividade a interface (UI) do usuário em XAML

Aprenda como automatizar mensagens no Discord com Webhooks (e Embeds) utilizando .NET e C#. Neste vídeo, você entrará no mundo dos Webhooks do Discord. Veremos desde a criação e configuração de um servidor no Discord até a integração e envio de mensagens automatizadas usando .NET e C#. O que você aprenderá: - O que são Webhooks e como configurá-los no Discord - Como criar e enviar mensagens automatizadas utilizando .NET - Criação e organização de projetos em C# - Implementação de anotações e extensões úteis no Visual Studio Code - A instalação de pacotes - O uso de JSON para enviar conteúdos personalizados - A criação de mensagens enriquecidas com Embeds - As melhores práticas para organizar seu desenvolvimento **Capítulos do Vídeo:** - 00:00:00 O que são Webhooks no Discord? - 00:01:00 Criando URL do Webhook - 00:02:07 Organização do Ambiente de Desenvolvimento - 00:02:55 Criação de Projeto .NET para Webhooks - 00:04:01 Visual Studio Code e exibindo as extensões VSCode para dotnet - 00:05:45 Criando e Configurando de Servidor no Discord - 00:06:58 Criando e Testando o Webhook - 00:11:27 Uso do Embed Debugger do Discord para criar Webhook - 00:13:43 Convertendo JSON para Classes C# - 00:15:00 Ajustando Código e Estrutura de Classes - 00:18:10 Envio de Mensagens com Embeds - 00:26:26 Implementação da Propriedade Fields

Criando uma Azure Function para verificar preços de ações (C#) Azure Functions em C#: consulte ações e envie por e-mail com Resend (Parte 1) Crie uma Function em .NET com Timer Trigger, consuma a API Alpha Vantage e mande a cotação por e-mail Neste passo a passo você vai criar uma Azure Function em C# (.NET) com Timer Trigger para consultar a cotação de ações na API Alpha Vantage e enviar um e-mail com o último fechamento usando o serviço Resend. O vídeo cobre a instalação das ferramentas, criação do projeto com Azure Functions Core Tools, configuração de secrets no local.settings.json, debug local com Azurite, parsing do JSON (System.Text.Json), montagem de HTML e envio via HTTP (sem SDK). Ao final, é mostrado o e-mail recebido com a cotação. O que você vai aprender: - Instalar e validar Azure Functions Core Tools e Azurite - Criar Function App (.NET) e Timer Trigger (cron com segundos) - Obter e configurar API Keys (Alpha Vantage e Resend) em local.settings.json - Consumir a API TIME_SERIES_DAILY do Alpha Vantage - Parsear JSON com propriedades "peculiares" (Time Series com datas e "4. close") - Gerar HTML de e-mail e enviar via Resend com HttpClient (Authorization Bearer) - Debug local no VS Code com breakpoints - Entender cuidados: limites da API (25 req/dia na camada free), bounce de e-mails temporários Pré-requisitos: - Node.js e npm - NET SDK 8 instalado - VS Code com extensões C#, Azure Functions e Azure Resources - Conta Resend com domínio verificado (para envio) - Chave gratuita da Alpha Vantage Comandos-chave usados: - npm i -g azure-functions-core-tools@4 - npm i -g azurite - azurite --version - func --version - dotnet --list-sdks - func init nome --worker-runtime dotnet --target-framework net8.0 - func new --name FunctionName --template "Timer trigger" - F5 (debug no VS Code) Observações: - Não versionar local.settings.json (contém segredos; já está no .gitignore por padrão) - A Alpha Vantage free impõe limites (25 requisições/dia); evite intervalos muito curtos em testes - Alguns provedores bloqueiam e-mails temporários; prefira um e-mail real verificado no domínio do Resend --- ### Capítulos 00:00:00 API Alpha Vantage e recursos na descrição 00:02:31 Checando .NET e alvo em .NET 8 00:02:54 Organização de pastas do projeto 00:03:17 Instalando Azure Functions Core Tools (npm) 00:04:37 Instalando o Azurite (Storage local) 00:06:23 Preços e camada gratuita do Azure Functions 00:07:36 dotnet new vs func init; criando o projeto 00:09:38 Verificando SDKs do .NET 00:12:22 Criando a Function (func new) com Timer Trigger 00:16:22 Cron com 6 campos (inclui segundos) 00:18:31 Escolha de ativos (Petrobras, Apple, etc.) 00:19:40 Extensões VS Code recomendadas 00:21:07 Configurando Resend e gerando API Key 00:23:02 Adicionando Resend API Key no local.settings.json 00:26:17 Gerando API Key gratuita (limites da Alpha Vantage) 00:30:22 Documentação da Alpha Vantage e endpoints 00:31:30 TIME_SERIES_DAILY e base URL 00:35:37 Async/await e EnsureSuccessStatusCode 00:36:21 Subindo o Azurite e preparando o debug 00:37:01 Ajustando o timer para 2 minutos 00:42:00 Parse com JsonDocument e extração do último fechamento 00:45:03 Construindo o HTML do e-mail 00:47:03 Generalizando para "stock" (dinâmico) 00:47:31 Método de envio de e-mail via Resend 00:48:27 Payload JSON e header Authorization (Bearer) 00:51:34 Debug do envio; conferindo valores 00:57:12 Serialização e SendAsync 00:58:20 Verificando logs do Resend

Como desenvolver um chat básico tendo um cliente em WinForms e um servidor console do zero Neste tutorial, você aprenderá a criar um chat em C# usando o .NET para comunicação entre um cliente desenvolvido com Windows Forms e um servidor de console, utilizando Sockets TCP. Se você está familiarizado com o desenvolvimento de sistemas e deseja explorar a comunicação em tempo real, entender o uso de sockets será uma adição valiosa à sua caixa de ferramentas de programação. Durante iremos revisar conceitos básicos de sockets, explicar diferenças entre TCP e HTTP, e orientar cada etapa desde a criação do servidor até o teste entre múltiplos clientes. Você verá como configurar tanto o servidor quanto o cliente - aplicando conceitos de concorrência para gerenciar múltiplas conexões, enviando e recebendo mensagens quase em tempo real. O tutorial passa por configurações de ambiente como o Visual Studio 2022 e detalhes como o uso de listas e fluxos de leitura e escrita em C#. --- #### Índice de Capítulos 00:00:00 Introdução à comunicação via Socket usando .net Console (Server) e Winforms (Client) 00:02:03 Diferença entre comunicação via Socket e HTTP 00:02:44 Explicando criação do Sockets Server usando TCPListener 00:06:04 Criando a Task que irá utilizar os fluxos de leitura e escrita (Streams) de cada Client 00:07:51 Respondendo a todos os Clients conectados com StreamWriter 00:09:14 Criando um Client Socket usando WinForms no Visual Studio 2022 00:11:21 Ajustando Componentes de interface (UI) no Winforms 00:13:52 Conectando ao server TcpClient e definindo os fluxos (StreamReader e StreamWriter) 00:17:41 Tratando o recebimento mensagens dos Clients usando StreamReader 00:18:10 Usando Invoke para preencher uma ListBox na MainThread a partir de uma Task 00:19:40 Codificando evento Click botão para enviar mensagens ao Socket Server (StreamWriter) 00:21:12 Testando Sockets entre os Clientes Winforms e Blazor e o Server .net Console

Aprenda a consumir a API do MixCloud com .NET MAUI e Blazor, criando uma aplicação C# e integrando dados externos Neste vídeo tutorial, vamos explorar como construir uma aplicação multi-plataforma utilizando .NET MAUI Blazor com C#, consumindo dados da API do MixCloud. Você aprenderá desde conceitos básicos sobre .NET MAUI e Blazor até a criação de um cliente HTTP para consumir API’s de forma eficiente. O conteúdo abrange a instalação de workloads necessários, configuração de projetos MAUI Blazor, manipulação de formulários e componentes via Blazor, além de um guia passo a passo sobre como integrar e consumir o conteúdo através de chamadas HTTP. Detalhamos também a estruturação dos modelos C# para deserialização dos dados recebidos da API do MixCloud. Com um exemplo prático e didático, este vídeo é voltado para desenvolvedores iniciantes em .NET MAUI ou Blazor que desejam consolidar conceitos de integração de API em suas aplicações. ### Índice de Capítulos 00:00 - Introdução ao vídeo e objetivo 00:45 - Link dos recursos na descrição 01:18 - Explicação sobre .NET MAUI e Blazor 02:57 - Introdução à API do MixCloud 05:47 - Discussão sobre parâmetros da API 08:00 - Configuração do Base URL e parâmetros da API 12:41 - Criando projeto com .NET New 15:22 - Exploração de workloads no .NET 18:23 - Organização de soluções e projetos no .NET 24:30 - Compilação e teste inicial do projeto 27:36 - Configurando extensões recomendadas 30:06 - Trabalhando com páginas e layout no Blazor 32:15 - Construção de um formulário no Blazor 37:35 - Ajuste de layout e responsividade 47:14 - Uso do "Paste JSON as Code" para modelos 49:42 - Instalando componente (NewtonSoft.Json) 51:49 - Adicionando namespaces organizados 54:49 - Ligação de variáveis com elementos no Blazor 56:30 - Utilização do @bind e métodos de busca 1:02:09 - Exibição de resultados no layout 1:04:45 - Simplificação do modelo JSON 1:06:40 - Implementação do método de busca (Search) 1:08:58 - Introdução ao uso de await e chamadas assíncronas 1:14:15 - Testes iniciais com buscas no MixCloud 1:21:22 - Correção de erros e injeção de dependência com HttpClient 1:23:15 - Resolução de nullable warnings no C# 1:27:15 - Tratamento de erros para requisições na API

Nesse vídeo, iremos aprender como converter um endereço em coordenadas de geolocalização (geolocation) sem usar componentes extras, usando apenas o HttpClient acessando o Google Places API no Blazor Server. O tutorial fala um pouco também sobre Injeção de Dependência, interface, tipagem de dados, dentre outros assuntos interessantes.

Aprenda a criar uma Web API completa com ASP.NET Core do zero, incluindo configuração de dependências, controllers e Entity Framework.

Entenda os conceitos fundamentais do Docker e aprenda a containerizar suas aplicações .NET Core de forma eficiente.