Introdução a . Desenvolvimento NET MAUI | Trevoir Williams | Skillshare

Velocidade de reprodução


1.0x


  • 0.5x
  • 0.75x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 1.75x
  • 2x

Introdução a . Desenvolvimento NET MAUI

teacher avatar Trevoir Williams, Jamaican Software Engineer

Assista a este curso e milhares de outros

Tenha acesso ilimitado a todos os cursos
Oferecidos por líderes do setor e profissionais do mercado
Os temas incluem ilustração, design, fotografia e muito mais

Assista a este curso e milhares de outros

Tenha acesso ilimitado a todos os cursos
Oferecidos por líderes do setor e profissionais do mercado
Os temas incluem ilustração, design, fotografia e muito mais

Aulas neste curso

    • 1.

      Apresentação

      0:57

    • 2.

      Ambiente de desenvolvimento de configuração

      16:25

    • 3.

      Criar controles com C

      11:02

    • 4.

      Criar controles com XAML

      4:55

    • 5.

      Entender layouts MAUI

      7:05

    • 6.

      Definir valores de marcação globais

      5:10

    • 7.

      Definir valores específicos da plataforma

      5:24

    • 8.

      Recursos compartilhados

      5:03

    • 9.

      Como navegar em várias páginas

      6:50

    • 10.

      Conclusão

      0:57

  • --
  • Nível iniciante
  • Nível intermediário
  • Nível avançado
  • Todos os níveis

Gerado pela comunidade

O nível é determinado pela opinião da maioria dos estudantes que avaliaram este curso. Mostramos a recomendação do professor até que sejam coletadas as respostas de pelo menos 5 estudantes.

162

Estudantes

1

Projetos

Sobre este curso

. Interface de aplicativo multiplataforma (. NET MAUI) é uma estrutura multiplataforma para criar aplicativos nativos para dispositivos móveis e desktop com C# e XAML.

Neste curso, vamos explorar os conceitos básicos de . NET MAUI e obtenha uma compreensão de como XAML e C# trabalham juntos para oferecer uma experiência rica ao usuário. Também vamos rever os princípios básicos de navegação e vinculação de dados.

NET MAUI é para desenvolvedores que queiram:

  • Como criar aplicativos em várias plataformas em XAML e C#, a partir de uma única base de código compartilhada no Visual Studio.
  • Compartilhe layout de IU e design em todas as plataformas.
  • Código, testes e lógica de negócios em todas as plataformas.

Conheça seu professor

Teacher Profile Image

Trevoir Williams

Jamaican Software Engineer

Professor
Level: Beginner

Nota do curso

As expectativas foram atingidas?
    Superou!
  • 0%
  • Sim
  • 0%
  • Um pouco
  • 0%
  • Não
  • 0%

Por que fazer parte da Skillshare?

Faça cursos premiados Skillshare Original

Cada curso possui aulas curtas e projetos práticos

Sua assinatura apoia os professores da Skillshare

Aprenda em qualquer lugar

Faça cursos em qualquer lugar com o aplicativo da Skillshare. Assista no avião, no metrô ou em qualquer lugar que funcione melhor para você, por streaming ou download.

Transcrições

1. Apresentação: Bem-vindo a uma introdução ao desenvolvimento dotnet Maui. Sou seu instrutor da Williams e sou engenheiro de software e palestrante. Agora, durante a duração deste curso, você estará aprendendo desenvolvimento móvel através dos olhos do dotnet Maui.net. Maui é uma estrutura de plataforma cruzada dada a nós pontilhando-a, e nos permite ter uma base de código para muitos sistemas operacionais móveis. Então, durante este curso, você entenderá como o dotnet Maui funciona. Vamos entender a sintaxe XAML. Dê uma olhada no desenvolvimento orientado a eventos e veja outras coisas, como navegação e compreensão de recursos e layouts globais. Para este curso, vamos precisar do Visual Studio 2022, que vem com genética e emuladores Android são incorporados. Mais uma vez, bem-vindo a este curso e mal posso esperar para começar. 2. Ambiente de desenvolvimento de configuração: Ei pessoal, bem-vindos de volta. Neste episódio, vamos configurar nosso ambiente para que possamos programar com Maui. Maui no momento desta gravação está em pré-visualização, o que significa que precisamos do Visual Studio 2020 para visualizar a versão. Talvez você já tenha o Visual Studio 2022 instalado. Você vai precisar da pré-visualização. Se não, então não há problema. Vamos passar pelas etapas básicas são os passos mais necessários juntos. Então, vamos começar entrando no Visual Studio.Microsoft.com. E então, quando você estiver nessa página, você precisa ir para a pré-visualização mais recente e, em seguida, baixar a visualização. Isso baixará esse instalador para o seu computador. E quando esse lançamento for, você vai querer ter certeza que está recebendo as visualizações. Então, se você for para a seção disponível, verá 201720222019. Então você quer ter certeza de que está recebendo o que está marcado como pré-visualização, certo? Assim, podemos seguir em frente e obter as adições da Prévia da Comunidade. Eu não o tenho listado aqui. Isso porque eu já o tenho instalado. Assim, você pode ir em frente e iniciar o instalador. E o que acontecerá é que ele abrirá essa janela onde ela pergunta quais cargas de trabalho você deseja. Então você pode ver as cargas de trabalho que eu tenho. Mas os que são essenciais para este curso são ASP.net e desenvolvimento web porque você estará criando uma API. Então, precisamos da carga de trabalho da Web e você definitivamente precisa da carga de trabalho de Maui. Agora, vou estar jogando. Dado que isso é pré-visualização, tenho certeza de que essas são dobras que serão trabalhadas à medida que a equipe de desenvolvimento fica cada vez melhor ao liberar essas cargas de trabalho e esses pacotes de desenvolvimento. Mas, como está, tive que selecionar o desenvolvimento de UI multiplataforma dotnet, que é Maui, certo? Eu tive que obter o desenvolvimento da área de trabalho e também tive que obter o UWP. Tudo bem? Agora, depois de selecionar, todos eles ainda continuam com componentes individuais. E procurei pelo Android e me certifiquei de que tinha todas essas coisas marcadas. Tudo bem, então alguns deles teriam ficado marcados em virtude de você escolher as cargas de trabalho e algumas talvez não tenham sido. Então, eu me certifiquei de ter o emulador do Google Android marcado e as ferramentas de desenvolvimento do Android C Plus Plus para fazer tudo isso. Tudo bem, espero que, no momento em que você estiver fazendo este curso, talvez você não precise passar por tudo isso, ou talvez a carga de trabalho selecione tudo o que deve selecionar. Mas estou apenas mostrando essas coisas para que você possa ter o caminho de menor resistência ao passar por esse exercício. Agora, uma vez que você tenha todas essas coisas selecionadas, as instalações de carga de trabalho, pois provavelmente estaremos mais perto de cerca de 40 gigabytes. Assim, você pode ir em frente e instalar, espero que você tenha espaço suficiente. Estou confiante de que você faz, mas uma vez que você for em frente e instalar e eles terminarem, então você pode continuar este vídeo. Agora, uma vez instalado, você pode prosseguir e iniciar o Visual Studio 2022. Agora, o que vamos fazer é criar um novo projeto. E quando isso aparecer, vamos querer um dotnet Mawi para cima. Agora, se você não tem isso para a esquerda como eu, isso é porque eu criei recentemente um. Você sempre pode pesquisar e ele filtrará essa lista para você. Vá em frente e selecione dotnet Maui para cima, e então você vai dar um nome a ele. Então vou chamar isso de meu primeiro Mawi. Tudo bem? Então você pode ir em frente e nomear que este não será o projeto com o qual vamos desenvolver. Este é apenas um projeto para que possamos configurar nosso ambiente e nos acostumar com o que parece. Tudo bem, quando o Visual Studio for iniciado, então temos o arquivo XAML de ponto da página principal carregado para nós. Agora, há poucas coisas que eu quero que tomemos nota aqui. Mais uma vez, isso ainda está em pré-visualização, então eles vão ser algumas dobras pelas quais eu vou orientá-lo. E espero que você tenha a mesma experiência que estou tendo e você não terá nenhum desgaste completando essas tarefas. Então, a primeira coisa que eu quero que estejamos presentes é o fato de que este é um arquivo XAML, que é realmente um dialeto de XML. Então você pode ver aqui no topo está doendo. Você sabe, que é realmente um arquivo XML. E esta é a página principal. Então esta é a página de amostra que obtemos com essa amostra, com esse modelo de projeto praticamente. E se você acabou de lê-lo, você pode ver que ele se parece um pouco com HTML porque, mais uma vez, ambos são baseados em XML. E você verá que cada tag faz sentido. É realmente apenas inglês padrão. Então, aqui vemos que temos uma tag que diz imagem e temos alguns atributos para essa tag de imagem, temos uma tag de rótulo que tem alguns atributos e outro rótulo e botão Para cima. Certo? Agora, para cada página XAML, que realmente seria como uma página literal em seu aplicativo que você criará. Você vai ter um código atrás do arquivo. Portanto, temos a página principal não verão, e então temos a página principal não XAML dot CSS. Então, nesse arquivo CSV um, ele está sendo inicializado. Então, se você já trabalhou com WPF ou Windows Forms, esse tipo de código pareceria familiar para você, certo? Portanto, temos ou página principal de classe parcial e ela está herdando de outra classe chamada página de conteúdo. E tem uma variável global ou global para a classe pelo menos temos nosso construtor que está inicializando todos os componentes. E este é apenas um método que é executado em um dinheirinho inicializando todos os controles que serão usados em toda a aplicação ou garganta esse controle específico, certo? Então temos um método aqui que está vendo no contador clicado. Agora isso é o que chamamos de evento. Assim, no contrato clicado há um evento ou um método que será chamado sempre que o botão for clicado. Então, temos o controle de botão aqui. Deixe-me ampliar um pouco para garantir que possamos ver. Então, temos nosso controle de botão, damos um nome a ele. Então esse é um dos atributos, certo? Portanto, esse atributo name nos permite referenciá-lo a partir do código por trás. Então, se quiséssemos mudar algo sobre o botão ou o rótulo ou qualquer coisa que definimos aqui, nos certificamos de dar um nome a ele. Então temos os textos que o botão tem e, em seguida, temos propriedades semânticas, pontos, dica. E então ele nos diz que cones okayed o número de vezes que você clica e, em seguida, clicou, esse será o nosso evento de clique. E então diz que quando for clicado, chame esse método. Então, quando clicado na chamada intercalar, o que é isolado? Bem, esse é o método que temos aqui. Esse método recebe informações sobre quem chama o evento e que tipo de eventos o acionaram. Então, aqui seria capaz de saber que o botão chamou o evento, e ele foi acionado por um evento de clique. E então ele faz uma operação em que incrementa os cones previamente definidos. E então ele define o texto com base em se os cones são equivalentes a um ou maior que um, então ele envia uma mensagem para o leitor de tela semântico, já que desconhece o texto do botão Conteúdo. Então, em outras palavras, nós encadeamos. Então aqui se chama BTN. Eu disse o que e o que está contribuindo? O que está contribuindo? Esse é o nome que damos a isso um botão. Então aqui estamos vendo quando clicamos no botão, altere seu texto para ser o que eu quiser que seja. E então, incógnita na nossa tela que o texto do botão mudou, certo? Então esse leitor de tela semântico será nossa pequena ponte entre nosso código por trás e o que vemos visivelmente no aplicativo, certo? Então é para isso que serve. Nenhum outro arquivo inclui o program.cs. Então este é o bootstrapper. Com a maioria, se não todos os programas C-sharp, eles terão um program.cs, seja WinForms, WPF ou ASP.Net, ele terá um pouco distante program.cs com um método principal que será executado inicialmente. Então isso representaria esse arquivo em um MAOI up. E então vai ser, tem que criá-los todos. Ele inicia um construtor e, em seguida, diz que use up, e veremos o que há. atualização XAML está bem aqui. Então, está dizendo usar isso, configure fontes e, em seguida, crie. Tudo bem, então o que se passa? O que faz Abdul? Diz saltar para cima. Csm é um desses arquivos base, então você não deseja excluir esses arquivos. Esses arquivos são muito essenciais. Essencialmente, estamos apenas declarando alguns namespaces. Ele sabe qual é a classe, então não está acordado. É por isso que somos capazes de chamá-lo mais uma vez no acorde. Tudo bem? E, em seguida, define alguns recursos de aplicativos, alguns estilos e cores, etc. E é para isso que serve o arquivo XAML do aplicativo. Também temos o shell do aplicativo. O shell do aplicativo mais uma vez define alguns namespaces e, em seguida, esse é o conteúdo. A página inicial deveria ser a página principal. Estamos enviando isso para significar pitch assim que os envios. Então, se você quisesse criar uma página inicial diferente, você teria que ter certeza de dizer que ela não é mais a página principal. Não é uma página que criei controle autossômico que criei. Tudo bem, embora as pastas tenhamos recursos, então o que acontece? Deixe-me ir às plataformas primeiro. Então, o que acontece com Xamarin? Porque Mawi é basicamente um substituto para Xamarin. Xamarin foi pioneira no desenvolvimento de plataformas cruzadas, onde lhe dá a capacidade de ter um projeto com uma base de código. Poderia ser como sendo apenas C-sharp para atender, hum, múltiplas interfaces móveis e sistemas móveis. Agora o que acontece é o Maui, em vez de exigir que você crie um projeto diferente por curso com o Xamarin, eu teria que ter um projeto para o Android fora depois de um projeto para iOS, etc. etcetera. Em vez de fazer projeto, projeto, projeto, ele nos dá um projeto. E para quaisquer recursos exclusivos que precisamos para esse sistema operacional móvel específico, temos uma pasta. Então, em vez de vários projetos, temos um projeto com várias pastas que são capazes de armazenar as instruções e recursos específicos sobre o que for necessário para isso óleo particular. Então, vemos aqui que temos a pasta Android com canhotos da pasta iOS na qual eu acho Samsung terá Mac catalyst e temos windows, certo? Então, um baseado em código para governar todos eles, praticamente. Isso é o que vemos na pasta plataformas e, em seguida, em recursos, agora podemos ter todos os recursos de que precisamos. Porque o que aconteceria é que com o Xamarin, você pode acabar colocando um ícone na pasta ou projeto do Android e esquecendo de colocá-lo dentro do iOS. Aqui temos uma pasta. Bem, podemos colocar tudo o que precisamos para que todos os nossos aplicativos possam parecer uniformizados a partir deste chamado BCE. Agora você verá aqui que eu tenho esse pequeno ícone de aviso para dependências e você verá que eu tenho algumas dependências faltando e algumas coisas. Se eu fizer um aluguel de construção, não, vou ter um monte de erros. Agora, eu vasculhei a Internet. Então, mais uma vez, isso é pré-visualização, então tenho certeza que , uma vez lançado totalmente, eu teria que regravar esta lição e não ter que colocar o que estou prestes a compartilhar. Mas, por não, enquanto você está fazendo isso em pré-visualização, o que você quer fazer é ir para o arquivo da solução, abri-lo no terminal. Então você deseja digitar isso em.net. Coloquei um espaço lá para que seja mais espaço. Então dotnet, nova versão global, Jason, e depois dash, dash, SDK dash. E então você vai colocar a visualização do traço 6.300. Então, como eu disse, certifique-se colocar esses números exatos, certo? Então, como eu disse, isso ainda é anterior, então isso é apenas um trabalhador para garantir que todos os SDKs saibam em qual versão eles devem estar. Porque uma vez que você estiver usando a visualização do Visual Studio neste momento como no momento desta gravação, é padrão dotnet sete, que ainda não está ajustado e qualificado para Aplicativos Maui, certo? Então, certifique-se de colocar isso como você me vê com ele aqui, e então você pode pressionar enter. E o que isso fará é criar um arquivo JSON de ponto global na raiz ou no nível da solução, certo? Então, uma vez que fizermos isso, podemos fazer um Control Shift e B e permitir que ele se reconstrua. E assim que terminar de construir, você notará que esse sinal de aviso não está mais lá. E todas as nossas dependências não são Não há mais avisá-lo. Então isso é um bom sinal. Tudo bem, então vamos pular para ver como esse aplicativo se parece quando ele está sendo executado. Então, no topo, no nosso botão de jogo, vou bater a cenoura e depois vou escolher isso. Eu quero usar o, tudo bem, então vou fazer uma pausa, só sei porque eu não vi o que esperava ver. Então, mais uma vez, estou guiando você por cada passo que preciso que você esteja ciente. Se você vir apenas a máquina Windows quando soltá-la nesta cenoura e não estiver vendo tantas opções quanto estou vendo. Reinicie seu Visual Studio. estúdio de reserva tão perto relançou o projeto. Quando você fizer isso, é provável que você veja o que estou vendo, certo? Também acessamos o emulador do Android. Então, o que acontece é que eu tinha algumas instâncias já tinha algumas instâncias do dispositivo emulador em execução. Então, quando você acessa Ferramentas, você vai para o Android e em seguida, pode acessar o Gerenciador de dispositivos. E depois que for lançado, mostraremos todos os emuladores que você provavelmente tem em execução. Eu tinha três anos de corrida, certo? Eu paro este e removo os outros dois que foram lançados de meus experimentos anteriores com a MAOI. Então, entre todas essas ações, você deve ser capaz de chegar a esse ponto que você está vendo todas essas opções, certo? Então, vou até o emulador do Android e vou selecionar o emulador do Android. E então eu fui apertar o botão de reprodução porque quero ver o que isso parece no Android. Tudo bem, então aqui está nosso aplicativo móvel. E se você olhar para ele e olhar para ele com o código, você poderá mapear de volta cada elemento, certo? Então aqui está nossa imagem, o dotnet, ponto PNG. Lá vamos nós. Temos o rótulo, Hello World. Temos o que diz Welcome. E então temos nosso botão que diz clique em mim. Então, quando clico em mim, defino um ponto de interrupção no evento click e você vê ele está atingindo esse evento de clique. Então Collins é igual a 0. No primeiro sombrio, vamos ver o clique é uma vez. E então ele vai declarar ou incógnita ao leitor de tela semântico para atualizar. Então, vou bater em F5, então continua. E você pode ver aqui que diz clicado uma vez. Mas então, se eu clicar nele novamente, vai ver ou ouvir clicado duas vezes, F5. E lá vamos nós, clicamos duas vezes. Então é praticamente assim que um Mawi up funciona fora da caixa. É assim que funciona. Sim, a configuração pode ser uma dor, mas espero que você passe por esse exercício. Caso contrário, sinta-se à vontade para usar essa seção de perguntas e respostas e me avise. 3. Crie controles com C#: Tudo bem pessoal, então vamos continuar nossa descoberta de Maui. Saiba que o temos em funcionamento e estamos familiarizados com as diferentes partes móveis. Então, vamos tentar criar uma nova página. Portanto, vou clicar com o botão direito do mouse no projeto ou adicionar um novo item. E então eu vou querer da seção dotnet Maui na nova página de conteúdo, certo? E então vamos chamar esta página de teste, agradável e simples. Então, o que isso nos dá é uma nova classe C-Sharp que nos permite definir o que queremos na página. Então esta não é uma página XAML, certo? Portanto, existem duas maneiras de criar conteúdo em uma página ou páginas creed. Um deles é com o arquivo XAML com código C-Sharp de suporte. E podemos realmente ter o C-sharp gera as partes que estamos colocando na batida. Por exemplo, vou pegar esta página de teste e vou fazer dela a inicialização. Então, pulando para atualizar o XAML, vou dizer que quero, desculpe, não resumir. Shell dot XAML. Vou dizer que queria encaminhar para a página de teste. Então, a página Testes em vez de talvez. Então, vamos dar uma olhada no que temos com isso. E é isso que recebemos. Obtemos um rótulo simples com o texto. Bem-vindo ao dotnet Maui. E isso é exatamente o que temos no aplicativo, certo? Então você pode ver que nossa classe C-Sharp está funcionando. Então, vamos construir isso um pouco mais. Então, o que temos essencialmente seria um, o objeto de conteúdo aqui que representa o conteúdo da visualização, certo? E então estamos dizendo que queremos um novo layout de pilha com crianças. Portanto, este é um layout e existem diferentes tipos de layouts que você pode fazer. Então, se você simplesmente digitar o layout da palavra, bem, eles estão meio confusos aqui, mas você tem Layout Absolute. Você tem tipo de carrossel, layout de compressores, layouts flexíveis. Existem várias opções de layout. Portanto, essa opção padrão que obtivemos era um layout de pilha. E então poderíamos adicionar as crianças e poderíamos ter um novo rótulo. E então vamos fazer um exercício em que vamos colocar em alguns outros elementos. Então, vamos começar apagando tudo dentro desta classe ou desse construtor outro. Então você pode ver aqui que tudo começa com o construtor. Sim, é uma classe o que o construtor é, onde a seção ou a inicialização ocorrerá, certo? Então, o que vamos fazer é construir carregar algo semelhante ao que temos na página principal, mas só vamos usar. Legal. Então, vamos começar inicializando nosso contador para 0. E então eu vou ter um rótulo estático que eu quero chamá-lo, digamos rótulo de contador. É sempre uma boa prática, mesmo com formas de madeira são quando estamos fazendo programação visual. Ele sempre dá nomes aos nossos controles e tem prefixo ou postfix que indica que tipo de controle é. Meu general seria que eu diria como LBL e depois o nome. Certo? Portanto, a LBL é a abreviação de um rótulo. Isso é meu. Assim, você pode desenvolver sua própria técnica, se quiser. Mas geralmente é uma boa prática porque, mais tarde, quando a base de código cresce, é mais fácil identificar quando você quer rotular versus uma caixa de texto versus alguém, etc. Tudo bem, então, oh, bem antes de tudo, estes devem estar fora do construtor. Desculpas. Então cones e rótulo fora do construtor. E então, dentro do construtor, podemos definir um novo tipo de visualização. Então, vou dizer vista de rolagem. Então, vou apenas novo ou arrependido, vou apenas dizer que a visualização de rolagem var é igual a uma nova visualização de rolagem. Tudo bem? E então vou salvar meu layout de pilha é igual a um novo layout de pilha. Lá vamos nós. Em seguida, posso ver a visualização de rolagem. Então, vista de rolagem, quero que seu conteúdo seja o layout da pilha. Então, ali estou vendo uma visualização de rolagem maior dentro desta página. E então, dentro da terra, cria uma visualização de rolagem, cria um layout de pilha e, em seguida, coloque esse layout empilhado dentro da visualização de rolagem. Portanto, mesmo que a visualização de rolagem possa ser autoexplicativa, ainda vou explicar isso. É o controle que permite rolar para cima e para baixo no aplicativo móvel, certo? Portanto, o conteúdo é demais, acabamos de colocá-lo em uma visualização de rolagem. E isso lida com a rolagem para o estouro do conteúdo. Dentro do rótulo. Para o contador, vou dizer que é igual a um novo rótulo, que vou inicializar com alguns valores. Então aqui eu posso definir essas dimensões são esses atributos. Então, o que quer que você tenha colocado em decimal e nós vamos fazer um exercício onde passamos pelo XAML, certo. Vou dizer Conte, e fui colocar zeros. Então começamos com cones sendo 0. Tudo bem? Podemos definir o tamanho da fonte e quaisquer outros atributos que quisermos, a família, etc. Então eu queria definir isso como 22. O que mais queremos provavelmente querer os atributos da fonte. Vamos ver o que temos aqui. Atributos de fonte que, então isso é um enum e podemos colocá-lo em negrito, podemos colocá-lo em itálico, podemos colocá-lo em várias coisas. Bem, é muito ousado e itálico neste momento. E então temos as opções horizontais. Queremos centralizado, queremos para a esquerda ou para a direita, etc. Então fui ver opções de layout, lugar que toma o centro. Então, agora que eu construí esse controle aqui você tem o Visual Studio me guiando ali sugerindo que você adicionou ao layout da pilha. Tudo bem, então eu posso apenas pressionar Tab, deixá-lo fazer isso, são construídos do meu controle e estou vendo layout de pilha para seus filhos. Adicione esse controle. Tudo bem, vamos criar nosso botão. Então posso dizer var btn, dois pontos, dois pontos Tr é igual a um novo botão. E este novo botão, quero que ele tenha o texto que diz Clique para contar. E então também temos, digamos, a opção horizontal que o torna centralizado de todos os tipos. Então, eu só uso isso mais uma vez. Depois de termos esse botão, também podemos adicioná-lo. Então, o layout. Tudo bem, então vou copiar, colar e mudar o que sei que preciso mudar. Obviamente, as crianças seriam genéricas e todos esses controles são de um tipo padrão que pode ser adicionado quando crianças. Agora, depois de tudo isso, podemos dizer que esse conteúdo de ponto é igual ao que estiver em maio, desculpe, o que estiver na visualização de rolagem. Tudo bem. Portanto, esse conteúdo de ponto é igual à visualização de rolagem. Então, vamos rever isso muito rapidamente. Criamos uma visualização de rolagem, criamos um layout de pilha. Adicionamos o layout da pilha à visualização de rolagem. Em seguida, preenchemos o layout da pilha com controles diferentes. E então, no final de tudo, estamos vendo que o conteúdo e isso aqui representam a página de teste, certo? Então isso é apenas se você estiver familiarizado com o C-Sharp, você entenderia o que é isso. Tudo bem. Portanto, isso representa nossa página de teste. Estou vendo esta página, seu conteúdo é igual ao que estiver na visualização de rolagem. Agora, vamos dar uma olhada no que obtemos isso e eu vou correr sem depuração. Tudo bem, então estamos aqui em cima e temos nosso rótulo com um diz 22, diz cone 0. E temos nosso botão que diz clique nos cones. Agora, quando clicamos, nada está acontecendo. Por que nada está acontecendo? Bem, nós não dissemos ao botão que ele deveria estar fazendo qualquer coisa quando é clicado. Então, o que precisamos adicionar? Não, precisamos adicionar o que chamamos de nosso. Se você disse evento de clique, então você está absolutamente correto. Então, o que vou fazer aqui é dizer contador BTN, pontos, clicar ou clicar. E então direi mais igual ao clicou, certo? Ou evento onClick. Agora, o que isso está fazendo é dizer, vincule o evento click a esse método que, naturalmente, teremos definir logo abaixo do nosso construtor, que estava inicializando e criando todos os nossos controles. Sabemos que temos nosso método de vazio privado, e eu chamo isso em evento de clique. E, em seguida, nossos eventos normalmente levam o remetente do objeto, bem como uma guia chamada args de eventos. E vamos chamá-lo de E na maioria das vezes. E então temos nossos métodos. Dentro do nosso método, quero ver cones. Eu quero que você incremente a contagem mais, mais. E então eu diria LBL, contrariá-lo. Seu texto é igual a. E então eu posso ser criativo com essa mensagem. Então clique ou clique em cones. E então eu posso simplesmente colocar na minha conta. E então, como vimos no anterior, temos que dizer que o leitor de tela semântico ponto incógnitas que o texto do ponto do contador LBL mudou. E é isso mesmo. Tudo bem? Então, depois de fazer tudo isso, se você estiver executando uma máquina rápida o suficiente e ele pode manter a Emily aberta. Você pode realmente acertar o Hot Recarregar, que reconstruirá seu aplicativo para você. Mas isso geralmente funciona com as mudanças XAML. Então, o que vou fazer é executar novamente o aplicativo e nos deixar fazer isso e esperar um pouco. E agora, quando clico, você vê que ele está funcionando. Portanto, nosso evento de cliques está funcionando bem ali. Criamos nossa primeira página do MAOI. 4. Crie controles com o XAML: Tudo bem, agora que vimos como criar uma nova página e controles usando o código C-Sharp. Vamos recriar isso usando o código XAML. Tudo bem, então vamos ao nosso projeto, cria um arrependimento, adicionaremos um novo item. E então, desta vez, vamos usar o bit de conteúdo Maui. Então observe que o primeiro foi C-afiado e este é XAML. Tudo bem, então vamos selecionar esse. E isso acabou de deixar o nome padrão pois ainda estamos nos estados exploradores. Então você vê que obtemos os layouts de estoque e obtemos esses rótulos padrão. Então, vamos começar a modificar esse arbitrário. Então nosso rótulo da última vez, está vermelho e eu vou ficar virando entre o C-sharp e o XAML, só para que eu possa copiar e colar e ir um pouco mais rápido. Então o texto aqui diz cone 0. Nós conseguimos definir a opção vertical, então isso significa que seu centro verticalmente. E então definimos a horizontal para ser central também. Mas outros elementos precisávamos ter o nome, certo? Então, demos a ele o nome contador LBL. Então eu vou ver o nome x dois pontos, por favor, igual ao contador LBL. Então, dessa forma, sabemos olá para nos referir, referenciá-lo a partir do código por trás. Ele também provavelmente quer dar um tamanho de fonte. E você vê todos os atributos que eu poderia sentar no C-Sharp. Eu posso realmente sentar aqui no XAML, certo? Você pode achar essa visão um pouco mais intuitiva, mas isso depende de você. Só estou mostrando suas opções. Então, uma fonte, parafuso de atributos, certo? Então esse é o nosso rótulo. Em seguida, temos nosso botão, abra uma nova etiqueta de botão. E eu gosto de abrir e fechar ao mesmo tempo e depois preencher todos os atributos, certo? Então o texto aqui dizia que deixe-me pular para contar. Tudo bem, clique em dois cones. E o que mais nós tínhamos? Tivemos o evento click, então, seja lá o que for clicado, queremos óleo aqui. Eles estão dizendo que você pode criar um novo manipulador de eventos. Vou apenas clicar que gerou um formulário que você verá o que foi gerado para nós em alguns. Podemos dar a ele os mesmos atributos de centralização central e vertical, horizontal e vertical. E acho que vou deixar isso por enquanto. Agora vamos pular para o nosso código atrás. O código por trás do arquivo geralmente será aninhado abaixo do arquivo XAML, certo? E se você olhar para ele, verá parcial e ele tem o mesmo nome que os arquivos XAML. Portanto, parcial no C-Sharp significa apenas que eu tenho várias classes e cada um, cada arquivo de código é como uma instância dessa classe ou uma parte da definição dessa classe. Portanto, isso faz parte da definição no arquivo XAML e o arquivo C-Sharp faz parte da definição. E esse herda da página de conteúdo. Agora eu já fiz o campo privado para os cones. Temos nosso construtor e, em seguida, temos esse método chamado initialize component. Portanto, lembre-se de que a página anterior teríamos definido tudo o que estaria na parte visível da nossa página. Dentro do nosso construtor inicializará o componente exatamente isso , exceto que ele é gerado automaticamente junto com o que estamos fazendo no arquivo XAML. Então, se você olhar para ele, verá que verá os nomes e tipos de controle de acordo. Então, qualquer coisa que você vai fazer dentro do construtor, eu aconselharia antes ou depois de inicializar o componente, mas não modifique esses nove. Agora temos nosso evento de clique que foi gerado para nós. E o que vou fazer é apenas reutilizar o mesmo código de evento de clique do controle anterior, da página anterior, para que tenhamos o mesmo comportamento certo? Agora. Para testar isso, vou pular para o shell do aplicativo e vou dizer não a página de teste, mas a nova página um. Tudo bem. Então, vamos fazer uma nova página um, nossa primeira grande e testar isso. Então, quando isso carrega, obtemos um layout muito semelhante. Podemos ver no topo aqui que é nova página um. E quando clicamos, obtemos o mesmo comportamento. Então, neste ponto, você sabe, agora você sabe duas maneiras de criar uma página dentro da boca para cima, você pode usar o código C-Sharp e codificar todos os seus elementos como quiser. Ou você pode misturá-lo onde você tem o XAML, bem como o código por trás. 5. Entenda os layouts de MAUI: Tudo bem pessoal, então nesta lição vamos nos concentrar em Leodes, certo? Então, vamos começar criando uma nova página de conteúdo. Já fiz isso, mas você pode clicar com o botão direito do mouse, ir para Adicionar novo item e, em seguida, queremos uma nova página de conteúdo, chamo de exemplo de layout. Então você pode ir em frente e fazer isso. E enquanto estamos nisso, vamos deixar o nó real, esse exemplo de layout é nossa nova página inicial, certo? Então, no exemplo de layout, temos nosso layout de pilha. Já vimos esse layout de pilha. Temos outros layouts. Temos layout de pilha vertical. Tudo bem, como é esse para o tamanho? Agora, a partir do nosso layout, podemos realmente definir como margens e paddings. E se você estiver familiarizado com HTML, então você sabe que a margem significa que, onde quer que o elemento esteja, ele fará tantos espaços entre si e o elemento mais próximo em qualquer coisa direção que especificamos. Enquanto o preenchimento é a espessura holística, queremos que o próprio elemento seja que, bem, a restrição direcional também se aplica lá, assim como com a margem. Com a definição do layout, podemos dizer que queremos preenchimento. E se eu definir isso para 30 em todas as direções? Tudo bem? Então, apenas vírgulas separamos. Tudo bem, na verdade, vou usar valores diferentes para que possamos visivelmente pelo menos ver onde esses valores de preenchimento estão sendo aplicados, certo? Então, tenho certeza de que vamos ver alguns tamanhos estranhos, mas sempre podemos voltar e mudar isso. Também podemos definir a margem se quisermos. Então, só estou mostrando quais são suas opções, certo? Então essa é a pilha vertical Leo. O layout da pilha vertical significa que ele vai empilhar tudo de cima para baixo, um, em cima do outro descendo. Tudo bem. Então, o próximo muito popular seria uma grade. Não, uma grade geralmente nos dá algo como um layout de tabela, que pode ser muito útil um para um, controles ao lado do outro, etc. Então, se quisermos isso, poderíamos, na verdade, dentro dessa pilha layout, defina uma grade. Assim, podemos abrir nossa grade, abrir e fechar. E então, dentro da grade, podemos fazer nossas definições. Mas antes de fazermos nossas definições, gostaríamos de fazer definições de coluna dentro dessa grade. As definições de coluna nos permitem especificar o tamanho de cada coluna. E com base no que especificamos que o número de colunas que obteremos. Então você provavelmente veria algo como auto. Auto significa qualquer tamanho que o controle seja quando ele entra. É assim que essa coluna deve ser grande. Também podemos usar um valor mais alto e dizer, bem, conhecer essa coluna exatamente que muitos espaços. E então, como eu disse, tantas quanto colocamos em tantas colunas que recebemos. Então, neste momento, defini três colunas diferentes. Dois deles são automáticos, um é um valor fixo de 30. Certo? Agora, dentro dessas colunas, posso definir controles diferentes, certo? Então vamos dizer que eu queria um botão dentro da coluna um. E o botão é uma etiqueta de fechamento automático. E o que eu quero dentro desse botão? Primeiro de tudo, quero que ele esteja na coluna da grade. Então eu posso dizer coluna aqui. E posso ver que você deve estar na primeira coluna da grade. Então, ele começa a contar em 0. Então isso seria 012, certo? Então, vendo a posição 0 da grade, ou deixe-me digitá-la aqui. coluna de grade é igual a 0. Isso significa que eu quero você na primeira coluna. E digamos que eu queria que o texto fosse o botão Teste. E largura. Digamos que uma solicitação de largura seja 100. E se quisesse, eu clico em evento, poderíamos colocar o que quisermos, podemos colocá-lo, certo? Então, vamos ver, é isso para o primeiro. Vamos apenas duplicar essa linha. Então eu apenas controlei D. E então eu quero este na terceira série, que seria a coluna de grade dois, desculpe, na terceira coluna, que será uma coluna com o número dois. Então lembre-se 012. E este terá a mesma largura. Tudo bem, então é assim, é assim que você pode começar a definir seus controles. Realmente sabe o que acontece se eu quiser? Bem, deixe-me renunciar quaisquer outras modificações e vamos testar este antigo. Então vá em frente e execute-o. E enquanto você estiver executando, eu vou guiá-lo pelo que você está olhando na minha tela. Então você pode ver que as bordas, o layout é meio estranho e isso é por causa dos diferentes valores que usamos. Então dez estava à esquerda, 50 de cima, Haiti e depois dez abaixo, à direita. Então é esquerda, superior, direita, inferior. E então o que também notaríamos é que os botões nas colunas automáticas. E então, porque temos uma lacuna de 30, foi assim que criamos esse espaço no meio, certo? Então, essas são pequenas coisas de design. Essas são coisas que talvez você queira fazer de forma diferente. Mas o ponto é que, uma vez que você saiba ou tenha uma apreciação de como os Leodes funcionam, então você pode fazê-lo funcionar da maneira que você quer. Então você pode ir em frente e brincar com eles. Você tem layouts diferentes. Como eu disse, você tem o layout de pilha vertical. E você pode obter mais informações sobre os diferentes layouts da documentação para o layout dotnet Maui. Então você tem o layout da pilha, você tem o layout absoluto. Nós olhamos para a grade, você tem os flocos de layouts flexíveis é basicamente quase como se você usar o Bootstrap, eu vou executar paralelos porque mais do que provável você tem sido uma web desenvolvedor em algum momento e você usou o Bootstrap. Então, com o Bootstrap, você tem uma função e tem até 12 espaços de colunas. E se você exceder isso, ele para o próximo espaço. Isso é tudo o que funciona em flocos. Então você coloca tantos elementos da esquerda para a direita. Então, quando ele os excede no espaço, ele simplesmente envolve e simplesmente cai, cai e cai e cai, certo? Então eu tenho certeza que você pode, você está apenas olhando para essas coisas. Seu cérebro está enlouquecendo. E se você olhar para a esquerda aqui você verá outros tipos de Laozi da grade. Você tem o SAR que falamos sobre a grade ou ideia, o fichário. Você devia absolutamente. Você tem o layout de pilha horizontal e o que vimos, o layout da pilha vertical. 6. Defina valores globais de marcação: Bem-vindo de volta pessoal. Nesta lição, vamos olhar para XAML, marcação, neve de extensão. maior parte do tempo. Vamos ter XAML que queremos padronizar, certo? Então, vamos levar, por exemplo, voltando para a página principal, temos rótulos diferentes e pode haver momentos em que você tem vários rótulos em todo o controle específico e você gostaria que todos eles fossem do mesmo tamanho. Agora, se você tiver cinco rótulos e definir o tamanho cinco vezes, seria tedioso alterá-lo cinco vezes e depois multiplicá-lo por 50. Acho que você chega onde eu vou. Portanto, as extensões de marcação nos ajudam a sentar como um valor estático no código por trás e, em seguida, referenciar esse valor estático. Então, se tivermos que fazer uma mudança, fizemos a mudança uma vez. Então, vamos ver o que é preciso. Se passarmos para o código por trás nossa página principal sobre XAML, a primeira coisa que podemos fazer é definir nosso valor que gostaríamos. Então eu vou dizer const público, duplo. O tamanho da fonte é igual a c 22. Tudo bem? Então esse é o tamanho da fonte que sabemos que queremos. E vou seguir a convenção de nomenclatura adequada. Como é um público ou é uma propriedade, vou fazer com que ele tenha letras maiúsculas ou comece com iterado epitelial. Então, dentro dessa mesma classe, preciso definir ou, em vez do mesmo arquivo com esse namespace, terei que definir outra classe, então classe pública. E então vou dizer o tamanho global da fonte. E então a convenção de nomenclatura aqui exige que eu a acrescente com a extensão da palavra. E então vou deixar que ele herde da extensão I'm markup, que me dirá que preciso implementar a interface. Portanto, a implementação da interface para isso vem com um método chamado fornecer valor. E é preciso injetar um provedor de serviços de IA. E então temos que especificar ou o que quisermos aqui. Então, vou dizer retornar a página média, virar a página média. E esse é o nome da classe aqui. Deixe-me apenas ter certeza de que sabe, oh, eu dividi o retorno incorretamente, retorne a página principal. E então veríamos o tamanho da fonte. Então, em essência, quando isso é referência, ele só sabe retornar o tamanho da fonte ao controle da página principal. E então a página principal seria capaz acessá-la de acordo. Então, em nosso XAML, o que queremos fazer antes de tudo, é definido o namespace no topo. Então, precisamos que ele saiba que um novo namespace está aqui. Então, diremos dois pontos de namespace XML e XML e, em seguida, damos algum nome a ele. Então aqui eu posso ver o tamanho da minha fonte. Tudo bem? E então isso vai ser igual a. E então direi CLR, namespace de hífen, dois pontos e, em seguida, o namespace que causa com onde foi definido. Foi definido no namespace, meu primeiro Mawi. Então esse é o valor do namespace que está lá fora. Tudo bem. Então, tudo isso é apenas um fio para cima. Portanto, nenhuma ou página principal sabe como fazer referência ao tamanho da fonte. Agora, quando eu quiser fazer referência ao tamanho da fonte, e vamos usar esse rótulo como exemplo. Em vez de escrever o valor como dissemos, tamanho da fonte, o que farei é fazer referência a um, o alias de namespace aqui que eu defini. Então, vamos ver, vá para esse namespace e, em seguida, consiga o tamanho da fonte global. Tudo bem, então você disse que foi preenchido automaticamente para mim. Não tive que tocar nesse dedo do pé porque ele já está identificando que a partir desse namespace, posso obter esse valor. O que é o tamanho da fonte global? Mais uma vez, o tamanho global da fonte é o que definimos. Portanto, se a 12ª extensão de tamanho de fonte global for o nome da classe, no entanto, não precisamos da extensão da palavra quando estamos fazendo referência a ela no acorde. Então, apenas fazendo isso, podemos realmente ter esse bit de código em qualquer lugar sem que queiramos usar esse tamanho de fonte específico. Como você mostra, irá para o shell do aplicativo e mudamos a página principal. E quando testamos isso, você vê que nosso rótulo está aparecendo corretamente. Então, mais uma vez, o objetivo desse exercício é mostrar como você pode definir esses valores estáticos para acesso e alcance mais globais. que, se você precisar atender a mudança, você só tem um lugar feito a alteração. E isso pode afetar vários controles. 7. Defina valores específicos de plataforma: Tudo bem pessoal, então vamos dar uma olhada na marcação específica da plataforma. Então, o que acontece é aquele rumor de que temos um conjunto chamado base um de páginas e controles. E temos que atender vários dispositivos. Alguns dispositivos podem ter certas considerações de design que outros. E o Mawi facilita muito a especificação certos valores para determinados sistemas operacionais dentro do código. Portanto, ele irá contextualmente lorar ou renderizar o conteúdo de acordo com o relógio é declarado. Então, vamos começar analisando como você veria em qual dispositivo queremos, qualquer margem ou preenchimento com nosso layout de pilha vertical. Para contextos, estou de volta ao layout desse arquivo XAML. Neste arquivo, o que vou fazer é dar um joelho, certo? Então, vou ver x o nome dos dois pontos é igual a, e então isso é um C Leo. O estoque. Isso deveria ter um layout preso. Deixe-me fazer o layout da pilha. Tudo bem, agora que temos esse nome no código por trás, posso fazer referência a ele no construtor de layout. E se eu quisesse dizer que o preenchimento de pontos do layout da pilha V. Eu quero que isso seja igual a algo diferente se for uma plataforma iOS versus se for qualquer outra coisa, certo? Assim, posso ver as informações do dispositivo, que é uma classe especial dada a nós que nos permite especificar a plataforma. Então, a plataforma de pontos de informações do dispositivo, se for equivalente e, em seguida, temos acesso à plataforma do dispositivo, que é praticamente um enum. Assim que eu vejo, lá vamos nós. Então, Devise Platform. Podemos especificar para Android, iOS, Mac, catalyst, macOS, diesen, etcetera, etc. Você vê todos os dispositivos aqui que você pode realmente tentar facilitar o comércio. Então, vamos dizer que, para iOS, se a plataforma do dispositivo for para iOS, então vou usar um operador ternário aqui. Em seguida, queremos definir uma nova espessura, que é o objeto ou o traçado a ser usado para preenchimento. Então deixe-me, deixe-me voltar um pouco. Então, se for iOS, queremos uma nova espessura. E digamos que eu queria 30 por dez, por 30 por dez, etc. E então, de outra forma, eu gostaria que fossem apenas 30, todos nossos. Então eu posso apenas dizer ou provocar 25 todos os nossos, certo. E é isso. Bem ali. Só especifico que quero que o preenchimento seja diferente. Se estivermos usando um dispositivo iOS, é isso que eu quero. Caso contrário, para qualquer outro dispositivo, faça isso. Então, obviamente, se você quisesse atender a mais cenários, provavelmente gostaria de usar uma instrução if ou uma instrução switch. Para que não seja um operador ternário, estamos comparando apenas com um de cada vez. Tudo bem? Então isso é tudo o que faremos isso no, no código por trás. Não, alternativamente, na marcação, o que poderíamos fazer é colocar os atributos para que o preenchimento seja igual e então poderíamos super impor nossa própria plataforma aqui. Tão bom ver na plataforma. E então nós apenas listamos todas as plataformas em potencial. E aqui podemos começar com o iOS mais uma vez, e podemos definir os valores que acabamos de usar. Deixe-me ver se posso ir e pegá-los rapidamente. Alguns valores arbitrários. Não estou levando isso a sério, certo? Não. Mas podemos defini-los. Eles teriam que estar entre aspas simples. Aspas simples porque já estamos dentro de aspas duplas aqui. Então, para querer usar aspas simples para especificar os valores do iOS e qualquer outro valor. E então, como fizemos, fizemos iOS e, em seguida, padrão, por vírgula. E então você verá o padrão como uma das opções, o que significa que qualquer coisa que não seja iOS, qual valor você quer? Eu quero que seja, vamos ver, 30, certo? Portanto, essa é uma boa maneira de especificar que o preenchimento na plataforma iOS isso ou aquilo. Também poderíamos fazer algo com a cor de fundo, certo? Então eu poderia ver a cor de fundo aqui, certo? E então faça a mesma coisa na plataforma. Na plataforma iOS, quero que seja, vamos ver, verde, certo? No Android, quero que seja Alice, azul, etc. Para que possamos continuar e continuar. Então isso é tudo o que podemos fazer, configurações específicas da plataforma na mesma marcação. Mais uma vez, utilizando nossa base de código singular ao máximo. 8. Recursos compartilhados: Ei pessoal, bem-vindos de volta. Desta vez, vamos analisar recursos compartilhados. Recursos compartilhados seriam uma extensão do que analisamos anteriormente com a extensão, exceto que não será tão fortemente acoplado a nenhum controle, certo? Então, vamos começar adicionando uma nova classe, clique com o botão direito do mouse em Adicionar nova classe. E então vou chamá-lo recursos compartilhados. Clique em Adicionar. E então estamos fazendo este na classe estática. Portanto, essa é uma classe estática chamada recursos compartilhados. E então aqui podemos definir algumas propriedades públicas estáticas somente leitura, certo? Então, vamos começar dizendo talvez que queremos uma certa cor para nossa fonte. Então, público estático, estático , somente leitura, e eu vou chamá-lo de swell. O tipo será de cor. Então, a cor é um tipo e vamos chamá-la de cor da fonte. Eu soletro cor com um u. Então você sempre vai me ver fazer isso. E então vamos dar um valor a ele, certo? Portanto, nossa cor da fonte aqui será pontos de cor. E podemos fazer a partir do final, do RGB, etc. Vamos fazer algo RGB que é fácil o suficiente para sobreviver. Então, se quiséssemos que fosse RGB é vermelho, verde e azul, podemos usar números inteiros entre 0255. Se você estiver familiarizado com o CSS, isso não deve ser um conceito estrangeiro para você. Então podemos usar algo como 0 vírgula 0 vírgula 25 por causa de argumentos. Então isso nos daria uma cor de fonte mais azul. Tudo bem, também podemos definir outros valores para que eu possa definir minha cor de fundo, eu poderia definir a cor do primeiro plano. Eu poderia definir todos os tipos de coisas. Uma vez que eu tenha o tipo de dados, eu dou um nome a ele e, em seguida, posso dar um valor a ele. Ele pode ser colocado nesse arquivo de recursos compartilhados estáticos. Observe que para usar esse recurso ou qualquer um dos recursos desse arquivo, eu só preciso ir para um controle. Deixe-me ir para a nova página um. E então, aqui em cima, quero fazer algo semelhante onde eu tenho que incluir o namespace ou XML e S dois pontos. E então vou dar um nome a ele, vamos chamá-lo de recursos. E vou dizer que você é igual a CLR, namespace hífen, dois pontos. E o namespace do meu arquivo de recursos compartilhados ainda é meu primeiro MAOI acima uma vez, é claro, ele vai em uma pasta, não somos p e as tensões em uma estrutura de pastas são muito difíceis aqui porque eu poderia colocar isso facilmente na pasta de recursos. Então, deixe-me realmente fazer isso. Então, vou mover esse arquivo de recursos compartilhados para a pasta Recursos. E então o que vou fazer é sincronizar o namespace para que possamos garantir que ele esteja no namespace atual. Então, neste momento, quando estou incluindo-o no XAML, tenho que me certificar de que estou apontando para o namespace do carrinho. Então, éramos uma nova página um namespace CLR. O namespace, Desculpe, é o meu primeiro caminho para cima. Recursos de pontos, certo? Então agora sabemos onde está esse botão. Para fazer referência a ele no código onde quer que eu queira que essa cor seja usada. Digamos que eu o queira no rótulo aqui. Então eu escolheria o atributo que diz texto, cor é igual a. E então abra minha cinta encaracolada. Primeiro de tudo, eu diria x dois pontos estáticos. Então é isso que sabe que, ok, estou recebendo meu valor para meu membro estático. Então, membro estático, deixe-me acertar minha ortografia. E isso é igual a, e então vemos um recurso que é nosso alias para nosso novo espaço até os principais recursos, os recursos compartilhados da Sherry, que é o nome do nosso Arquivo e, em seguida, cores de fonte. Então, aqui estamos vendo ir e buscar a cor da fonte a partir desse arquivo de recursos compartilhados estáticos. Em qualquer lugar do nosso código que queremos compartilhar essa cor. Podemos fazer algo assim. E podemos ter mais uma vez, tantos recursos listados aqui que sabemos que queremos permanecer consistentes em todo o aplicativo. Então você pode ir em frente e testar esse antigo. Você pode ir em frente e executá-lo, colocá-lo em vários lugares e simplesmente ir em frente e garantir que qualquer cor que você tenha definido aqui esteja realmente sendo exibida nessas áreas. 9. Navegando em várias páginas: Nesta lição, vamos analisar a configuração da navegação fly-out, que é um tipo de navegação em que uma janela para o item de menu selecionado voa desse lado para o centro da tela. E normalmente teria o que chamamos de hambúrguer. Essas três linhas no canto superior, esquerdo ou direito da tela, acho que é mais provável que você a veja à esquerda. Mas vamos ver essas pílulas de hambúrguer aqui em cima. Quando tocarmos nele, poderemos selecionar para qual página você deseja ir e então essa página voará. Então, vamos dar uma olhada no que precisamos fazer para que isso seja aberto. Desculpe, a jornada começa com nosso shell de aplicativo. Até agora, interagimos com esse arquivo sempre que quisemos alterar a página inicial, certo? Portanto, estamos nos concentrando no exemplo de layout. Nós o mudamos, estávamos focando na página principal ou alterá-la, etc. Então, o que acontece é que podemos realmente ter vários nós dentro dessa área. Então, vou criar um para cada página que temos até agora. Então, temos layouts, exemplo, e também vou alterar o título. Então, exemplo de espaço de layout e o exemplo de layout de royalties. Também temos uma nova página um. E embora essas não sejam notícias oficiais da página, mas elas estão lá. Então, vamos trabalhar com eles. E acho que não temos outro Pedro. Sim, temos página de teste. Então eu tenho a página de teste. E eu estou apenas mostrando que não importa se é a página XAML ou a página C-sharp, cada uma delas é uma opção, certo? Mas quando executamos, nosso aplicativo não verá nada visivelmente diferente fora de talvez exibir o que está primeiro na lista. Então, o que acontece é que precisamos ver um show sobre o comportamento do fluxo. E então mudamos de deficiente para voar para fora. Tudo bem, então vamos fazer esse ajuste e teste. Quando nosso aplicativo estiver em execução, veremos que temos nossas pílulas de hambúrguer. Quando tocamos nisso, vemos que ele voa para fora. E com cada título que demos, podemos ver que ele aparece, então clicamos em Exemplo de layout. Lá vamos nós. Se escolhermos nova página, lá vamos nós. Tudo bem. Então, cada página que criamos até agora, podemos alternar facilmente entre eles usando esse método de qualquer maneira, isso foi bastante fácil. Tenho certeza que você percebe que esse foi um exercício muito fácil de concluir. Agora, se quiséssemos ícones nesses itens de menu, seria tão fácil quanto dentro do conteúdo do shell. Poderíamos apenas dizer ícone e depois dar o caminho. Então, vamos tentar talvez os bots dotnet, acho que a página principal como fazer referência ao dotnet, mas só queria ter certeza de que eu consegui esse caminho corretamente. E bem, ele só tem o caminho para lá. Então, vamos tentar isso. Vamos apenas colocar o dotnet comprado na página principal e vamos testar isso. Lá vamos nós. Então, quando coloco o ícone dotnet, mas quando toco no menu, agora estou vendo esse ícone. Então, qualquer PNG, qualquer recurso que você adicionar. E mais uma vez, você adicionaria esses recursos aqui, aquele dotnet que é encontrado aqui nas imagens. Você sempre pode adicionar essas imagens conforme você precisa delas. E então você apenas adiciona o ícone a cada item do menu. Por isso, dá ao seu aplicativo um pouco mais de caráter e um pouco mais, uma aparência mais agradável à medida que você avança. Agora, o próximo tipo de navegação que gostaríamos de ver é a navegação com guias. navegação por tabulação geralmente se origina na parte inferior da tela e, em seguida, você teria um ícone por guia que você pode selecionar e ver o período moderno inicial, certo? Então, ainda estamos aqui na concha. E o que queremos fazer é criar uma página com guias. Então, vou abrir uma nova tag, e essa será a barra de guias. E então, dentro da barra de abas, teremos abas. Então, temos a etiqueta da banheira. E, em seguida, dentro dessa tag de tabulação teria esse Conteúdo do Shell. Tudo bem, então vamos fazer alguns desses. Então, vou criar algumas banheiras, mais três banheiras, e depois colocar o conteúdo da concha em cada uma. Tudo bem, então estamos apenas transformando de apenas para a nossa navegação com abas, certo? E, como você pode ver, é bastante consistente. Portanto, a sintaxe não é a sintaxe mais difícil de se agarrar. E se você já tem a mosca ou o comportamento habilitado. Então, vou mostrar como os dois deles podem se combinar para dar uma experiência específica ao usuário. Tudo bem, então estamos aqui no aplicativo. Se eu for para as pílulas navbar, não vejo nada. Se eu olhar abaixo, não vejo nada. No entanto, quando eu clico, você notará que ele está mudando. Então, obviamente, há algo lá, mas precisamos de mais alguns elementos. Então, um deles, o ícone não estaria no Conteúdo da Shell, estaria na banheira. Portanto, a guia em si pode obter um título. Então eu poderia dizer aqui significa PH. E então eu também poderia dar esse ícone a esse. Bem, deixe-me, acho que já o tenho na área de transferência. Lá vamos nós. Tudo bem, então vamos testar esse primeiro passo. Tudo bem, então lá vamos nós. Então aqui temos a página principal com o ícone. Tudo bem, então você poderia ir em frente e fazer isso. Portanto, não tenho outros ícones ou sem manter o mesmo ícone para as outras banheiras. Mas vou mudar o rótulo, claro, layout. Esta guia seria uma nova página. E a última foi a página de teste. Então, depois de fazer todas essas alterações, executo meu aplicativo novamente. E quando eu dou uma olhada agora estou vendo minhas abas, certo? Então essa é a navegação por guias. Bom e fácil. Dois é navegar entre todas as páginas que você tem em seu aplicativo. Você tem o menu suspenso e você tem a página com guias. 10. Conclusão: Tudo bem pessoal, parabéns por chegarem até aqui. Criamos com sucesso nosso primeiro aplicativo móvel usando dotnet Maui. Saiba que não é muito, nem muito para se olhar agora. Ele realmente não tem nenhuma funcionalidade real, mas temos pelo menos os conceitos centrais sob nossos cintos. Sabemos como criar novas páginas. Entendemos onde precisamos ir para fazer certas coisas. Entendemos como navegar pelo código por trás ou configurar eventos, como podemos gerar eventos visuais usando o código C-Sharp. Temos todos esses exemplos aqui, e também sabemos como navegar entre várias páginas. Então, neste ponto, podemos simplesmente adicionar isso, o controle de origem. Você pode verificar o link relevante nos recursos anexados para este vídeo específico. E quando voltarmos, vamos criar um aplicativo real usando dotnet Maui.