‫Bem vindo de volta.
‫E neste vídeo, vamos falar sobre propriedades de dependência, e elas são muito importantes assim que
‫chegarmos à vinculação de dados.
‫E geralmente faz sentido que você entenda como eles funcionam.
‫Então, vamos criar um botão em nossa grade.
‫E simplesmente fazemos isso criando a palavra-chave do botão, como já vimos várias vezes.
‫E aqui vou apenas atribuir uma altura de, digamos, cem pixels e uma largura de
‫duzentos pixels e, em seguida, o conteúdo do clique em mim.
‫E agora eu quero usar algo chamado background.
‫Então, há uma propriedade chamada background e quero atribuí-la a um esgoto, certo?
‫Certo.
‫Então esse vai ser o meu botão.
‫E como você pode ver agora, tem apenas uma espécie de cor.
‫Talvez devêssemos deixar vermelho.
‫Como se o vermelho fosse muito forte.
‫Violeta pálido, vermelho.
‫Isso parece bom.
‫Então, uma cor simples.
‫Portanto, a ideia por trás disso é que eu quero ir em frente e explicar a você o que são propriedades de
‫dependência, onde estão e como criar suas próprias propriedades de dependência.
‫E é muito fácil fazer isso com um botão, eu diria.
‫E, a propósito, este botão e, na verdade, vou fechá-lo assim porque quero estilizar esse botão.
‫Portanto, dentro das tags de botão, quero adicionar mais estilo a esse botão.
‫E o estilo deve ser um gatilho.
‫Então, eu quero ativar.
‫Então, se eu entrar na área dos botões, quero mudar a cor ou algo parecido.
‫Vou usar um estilo de ponto de botão.
‫Agora, esse estilo de botão precisa de um estilo aqui para que eu possa criar nosso próprio estilo aqui e vou definir um
‫destino para esse tipo de destino de estilo.
‫Vai ser um botão.
‫Agora, isso não é suficiente porque o que quero fazer agora é adicionar um gatilho para esse estilo.
‫Vou usar gatilhos de estilo.
‫Como este, e agora posso ir em frente e criar lindos gatilhos que serão disparados assim que ocorrer um evento e
‫já vimos eventos, mas esse é um evento um pouco diferente.
‫Portanto, é um gatilho que podemos usar da seguinte maneira.
‫Podemos criar um gatilho aqui e esse gatilho terá uma propriedade.
‫E aquele é, por exemplo, passar o mouse.
‫Assim, quando o mouse estiver sobre esse botão, o valor deve ser definido como verdadeiro.
‫E nesse gatilho, eu preciso ter Setas então.
‫Então, o que acontecerá se for esse o caso?
‫Portanto, o que vou fazer é definir o tamanho da fonte da propriedade para o valor de trinta porque agora o tamanho da fonte é
‫muito menor.
‫Então aqui temos o botão, que tem uma largura específica e um conteúdo e uma largura e todo esse tipo de
‫coisa.
‫E fiz um piloto com aquela carga violenta em vermelho e acrescentei um estilo a esse botão.
‫E esse estilo que adicionei é na verdade um gatilho.
‫Então, eu posso que há algo chamado gatilhos de estilo, que irá desencadear uma mudança de estilo.
‫E esse gatilho é executado assim que o mouse está sobre o botão e isso vai definir as coisas.
‫Então, o que ele fará é definir o tamanho da fonte para os valores
‫que especificamos aqui e agora aqui atribuímos esse valor verdadeiro significa que será disparado quando o mouseover for verdadeiro.
‫E isso é verdade quando passamos o mouse sobre o mouse ou quando estamos mais perto do botão.
‫Portanto, se executarmos isso, devemos ver algumas mudanças.
‫E esta é uma abordagem bastante longa para apenas ter uma funcionalidade de foco, mas é muito mais que
‫queremos usar aqui.
‫Então você vê, eu passo o mouse sobre ele e a cor muda para uma cor azulada e então temos este texto que
‫parece maior então.
‫Portanto, o valor muda para 30.
‫Então isso é ótimo e tudo.
‫Mas por que precisamos ter esse código longo?
‫Bem, o fato é que estamos usando propriedades aqui.
‫Como você pode ver, essa coisa se chama propriedade.
‫E, na verdade, a largura é uma propriedade, o conteúdo é uma propriedade, o fundo é uma propriedade.
‫E eles dependem de propriedades de dependência ou estão conectados a propriedades de dependência e são importantes
‫para mineração de dados.
‫Como eu disse, o que vamos cobrir no próximo vídeo ou em um dos próximos vídeos.
‫Mas também é importante ter esse evento de gatilho ou que o botão esteja ciente do que está
‫acontecendo.
‫Portanto, vamos criar um botão dentro do nosso método da janela principal.
‫Vou apenas criar um botão.
‫E agora eu quero dar uma olhada na própria aula.
‫Portanto, vá para a definição para que possa simplesmente pressionar F 12 para chegar à definição.
‫O que isso fará é me mostrar a classe do botão.
‫E como você pode ver, é uma classe que herda de um botão baseado.
‫Há uma propriedade de dependência estática somente leitura, que é o padrão, a propriedade é cancelada, a propriedade tem
‫a propriedade padrão.
‫Portanto, não muito.
‫Mas o que você também pode ver é que na verdade existe uma propriedade normal aqui.
‫Portanto, este é um SEAL.
‫Nossa propriedade que temos aqui, que é chamada de padrão, está cancelada e é padronizada
‫e essas propriedades estão conectadas a essas propriedades de dependência.
‫Portanto, ele representa uma propriedade que pode ser definida por meio de métodos como tiling, animação de vinculação
‫de dados e herança.
‫Portanto, a mineração de dados, como eu disse, é algo que abordaremos mais tarde em estilo.
‫Isso é bom.
‫Mas acabamos de definir o estilo de nosso botão e podemos usar animação e herança para isso.
‫Mas agora vamos dar uma olhada mais profunda na base do botão para sabermos que o botão é herdado da base do
‫botão.
‫Então podemos ir para a definição da base do botão e verificar.
‫Tudo bem.
‫É uma classe de controle de conteúdo.
‫Então a base do botão é herdada do controle de conteúdo, que, bem, a base do botão tem um evento roteado, como você pode
‫ver aqui, clique no evento.
‫E vimos da última vez que o evento DOT incluído é e tem muitas propriedades de dependência
‫também, como modo de clique pressionado, comando de propriedade, destino e assim por diante.
‫Mas ainda não tocamos em alguns deles.
‫Mas o que é ainda mais interessante, se formos ainda mais fundo no controle de conteúdo, podemos ver
‫que existe uma propriedade que diz que tem conteúdo.
‫Portanto, este está cuidando de todo o conteúdo do botão.
‫Por exemplo, o texto é um bloco de texto dentro de nosso botão.
‫Portanto, se tivermos conteúdo em nosso botão.
‫É tratado por esta classe ou por esta classe de controle de conteúdo e, na verdade, podemos ir ainda mais
‫fundo, ir para a definição e aqui encontraremos muitas propriedades de dependência e eventos de raiz.
‫E essa classe de controle tem propriedades de dependência chamadas propriedade de colocação e pincel de água.
‫Então, a cor da água, então um alinhamento vertical do conteúdo, alinhamento horizontal do conteúdo.
‫E agora aqui este é interessante para nós porque o usamos.
‫É uma propriedade de fundo e é exatamente a que definimos em nosso arquivo Zemo.
‫Como você pode ver aqui, mudamos o fundo para vermelho violeta claro para que possamos acessar essas propriedades de dependência por meio
‫de nossas propriedades aqui.
‫Então, essas são nossas propriedades como tamanho da fonte, fonte, fundo da família, primeiro plano, todos aqueles tipos
‫de coisas que usamos quando trabalhamos com controles e um botão, por exemplo, como um controle ou um bloco de texto,
‫é também um controle.
‫Então, todos eles herdam desta classe de controle e todos eles têm essas propriedades de dependência que
‫então disparam e informam sobre, bem, as mudanças.
‫Portanto, aqui também vemos que há algo importante sobre as propriedades de dependência: elas são sempre
‫estáticas e somente leitura.
‫Então, isso é muito importante.
‫Além disso, o que você pode ver é que eles sempre terminam com o nome da propriedade.
‫Portanto, aqui, sempre que definimos uma propriedade de dependência, dizemos background, que é o mesmo nome da
‫própria propriedade.
‫Então aqui, por exemplo, onde está?
‫Há um pano de fundo, mas também o termo propriedade no final.
‫É uma longa história.
‫E cavamos muito fundo.
‫Mas então mostraremos um pouco mais o que são essas propriedades de dependência e com o que estamos trabalhando o
‫tempo todo.
‫Então, estamos brincando com as propriedades, mas elas na verdade funcionam com as propriedades de dependência.
‫Por que precisamos de tudo isso?
‫Bem, só para entender o que está acontecendo aqui com este gatilho, YPF está usando uma propriedade de dependência
‫aqui.
‫Portanto, por exemplo, isso é mouseover e é mouseover fornece uma notificação em cadeia para o WPX com a ajuda
‫das propriedades de dependência e que nos permite definir o valor como through.
‫E também se você verificar, porque isso é algo que eu não toquei.
‫Na verdade, é o erro de construção de palavras.
‫Portanto, precisamos nos livrar deste botão aqui.
‫Mas ainda não cobrimos ou tocamos ainda, o que é tão importante quanto o seguinte.
‫Você pode ver que temos esse gatilho e ele diz que a propriedade é o valor do mouseover.
‫Verdade.
‫E isso vai disparar quando isso acabar, o que vai fazer?
‫Bem, ele definirá propriedades como o tamanho da fonte para trinta.
‫E deixe-me mostrar de novo, ok, entendo.
‫Mas agora, se eu deixar o botão, você pode ver como ele está mudando de volta e isso é feito por esta propriedade de
‫dependência.
‫Então ele está informando o que está acontecendo e está vendendo, ajustando o valor do tamanho da fonte de volta ao
‫seu valor original.
‫Como você pode ver, só é verdade enquanto o mouse está sobre o objeto e isso é possível por meio das propriedades de dependência.
‫Agora, outra coisa sobre as propriedades de dependência, porque eu disse que elas deveriam ser sempre estáticas e
‫somente leitura, e isso porque todos os controles deveriam ser compartilhados e disponíveis.
‫Portanto, você não deseja que um controle esteja disponível apenas uma vez.
‫Você também deseja que ele esteja disponível para outras classes e outras visualizações e assim por diante.
‫E é estático porque o valor não deve ser alterado após a inicialização.
‫E esta notificação em cadeia, o gatilho de propriedades de dependência é necessário para mineração de dados, para animação, para gatilhos,
‫como vimos aqui, para estilo e assim por diante.
‫Agora, se quiser ir em frente e criar sua própria propriedade de dependência, você pode fazer isso por um longo caminho.
‫Portanto, vou criar uma nova propriedade nesta classe aqui.
‫Vou chamá-lo, na verdade, vamos colocá-lo no topo.
‫Vou chamá-lo de público e de minha propriedade.
‫E como eu disse, esta é uma propriedade C LR.
‫E aqui eu preciso ter um get e um set.
‫Mas isso não será suficiente.
‫Vou apenas para aqueles no segundo.
‫Vamos criar uma propriedade de dependência para essa minha propriedade.
‫Portanto, vou criar uma propriedade
‫de dependência pública estática somente leitura chamada minha propriedade de dependência de propriedade de dependência.
‫E esse deve ser inicializado imediatamente com registrador de ponto de propriedade de dependência.
‫Portanto, estamos registrando uma nova propriedade de dependência e precisamos atribuir várias coisas.
‫Por exemplo, precisamos ter um nome de string.
‫Vou apenas ligar.
‫Minha propriedade, então precisamos de um tipo de propriedade, então de que tipo essa propriedade deve ser?
‫E, como vimos aqui, a propriedade que é minha propriedade é do tipo.
‫Vou usar o tipo de tipo de int a seguir.
‫Precisamos digitar o proprietário do imóvel.
‫Portanto, o proprietário do tipo e o proprietário deste tipo de minha propriedade é minha classe da janela principal porque, bem, ela está
‫na principal sem classe.
‫Então, simplesmente dizemos que tipo de será a janela principal e agora precisamos entregar também os metadados da propriedade.
‫Vou criar um novo metadado de propriedade, que será zero.
‫Vou inserir zero aqui.
‫Nada muito extravagante lá e é isso.
‫Então é assim que podemos criar uma propriedade de dependência.
‫E agora minha própria propriedade também deve ser influenciada por essa propriedade de dependência, é claro.
‫E para fazer isso, preciso ir em frente e ajustar o get e o set.
‫Portanto, Geter deve retornar nosso valor get, minha propriedade de dependência.
‫Mas agora temos o problema de que o valor da propriedade de dependência é do tipo propriedade de dependência.
‫E embora tenhamos dito que é do tipo int, ainda precisamos convertê-lo para estar nele.
‫Portanto, vou convertê-lo em um inteiro e agora podemos prosseguir e realmente fechar para espalhar a instrução.
‫Direito.
‫Melhor dito.
‫E agora o setter deve ser definido como valor.
‫E aqui eu defino minha propriedade de dependência com o valor que foi fornecido.
‫Então é isso que estamos fazendo aqui e é assim que você pode criar sua própria propriedade de dependência.
‫Então é isso que importa.
‫Somente leitura estática, você precisa criá-lo como um tipo de propriedade de dependência.
‫Você pode dar um nome a ele, então você precisa registrá-lo e você precisa dar um nome, um tipo.
‫E onde está o dono ou o que são os donos da classe em que o imóvel foi criado.
‫E então você precisa entregar alguns metadados de propriedade para que possa adicionar alguns metadados de propriedade adicionais.
‫Como você pode ver, existem quatro overlords diferentes e você pode entregar um objeto, que
‫é o valor padrão, e estou apenas dizendo, OK, valor padrão zero.
‫Portanto, minha propriedade será padronizada como zero por causa dos metadados de minha propriedade que configurei aqui.
‫Tudo certo.
‫Então, muitas coisas aqui.
‫E dependendo do que você vai desenvolver, talvez nunca crie sua própria propriedade de dependência.
‫Portanto, não se preocupe.
‫Se em algum momento você precisar usar propriedades de dependência, verifique como criar suas próprias propriedades.
‫Caso contrário, você pode simplesmente usar as propriedades que temos aqui.
‫E para um usuário final ou, digamos, para um desenvolvedor que apenas constrói a IU e não vai ser tão
‫relevante.
‫Mas eu só queria mostrar como as coisas são construídas e o que é importante aqui.
‫Tudo bem.
‫Então nos vemos no próximo vídeo.