David Klempfner's questions

Tenho o seguinte código:

import ReactDOM from 'react-dom/client';
import { useState, useEffect } from 'react';

const App = () => {
  
  useEffect(() => { console.log('Render'); });

  const [item, setItem] = useState([]);
  const [word, setWord] = useState([]);

  return (
    <div>
      <input value={item} onChange={(e) => {setItem(e.target.value)}}></input>
      <label>{word}</label>
      <button onClick={() => setWord(new Date().toString())}>Submit</button>
    </div>
  );
}

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
    <App />
);

Por que ele console.log('Render')mostrará o número de vezes que foi impresso ao digitar <input>e o número de vezes que foi impresso ao clicar <button>?

Aqui você pode ver que ele imprimiu 'Render' três vezes quando digitei 'abc' e então iniciou uma nova contagem de 'Render' quando cliquei no botão duas vezes:

Por que não diz simplesmente 5 Render?

Estou seguindo um tutorial do React e atualmente tenho este código React:

import { useRef } from 'react';

const AddItem = ({ newItem, setNewItem, handleSubmit }) => {
    const inputRef = useRef();

    return (
        <form className="addForm" onSubmit={handleSubmit}>
            <input
                ref={inputRef}
                id="addItem"
                type="text"
                value={newItem}
                onChange={(e) => setNewItem(e.target.value)}
            />
            <button
                type="submit"
                onClick={() => inputRef.current.focus()}
                // onClick={() => document.getElementById('addItem').focus()} // What does this do differently?
            >
            </button>
        </form>
    );
};

export default AddItem;

Estou usando useRef()junto com onClick={() => inputRef.current.focus()}para garantir que a entrada de texto esteja focada depois de clicar no botão.

Posso fazer a mesma coisa sem precisar do useRefgancho usando onClick={() => document.getElementById('addItem').focus()}.

Existe algum benefício em usar o useRefmétodo em vez do getElementByIdmétodo anterior?

Eu estava lendo sobre as melhores práticas para comparar strings e vi estes dois pontos:

• Use os métodos String.Compare e String.CompareTo para classificar strings, não para verificar igualdade.
• Não use uma sobrecarga do método String.Compare ou CompareTo e teste um valor de retorno zero para determinar se duas strings são iguais.

Infelizmente, não há nenhuma explicação sobre o motivo pelo qual isso não é recomendado.

Alguém pode explicar por que é ruim usar CompareTo()para verificar igualdade?

Encontrei este método:

public async Task SomeMethod(IEnumerable<Member> members)
{
    await DoSomething(members.First());
    await DoSomethingElse(members.First());
}

Está sendo chamado assim:

List<Member> members = GetMembers();
await SomeMethod(members);

Eu sei que isso poderia ser particularmente ruim se GetMembers()retornasse um IQueryable<Member>, mas como é apenas um List<Member>, ainda é ruim ligar First()duas vezes assim? É uma prática recomendada chamar First()uma vez e armazenar o resultado em uma variável?

Meu objetivo é construir o código-fonte do ASP.NET Core para que eu possa adicionar projetos relevantes e depurá-los localmente.

Clonei https://github.com/dotnet/aspnetcore/tree/release/6.0 e segui as etapas em: https://github.com/dotnet/aspnetcore/blob/main/docs/BuildFromSource.md .

Consegui restaurar/construir tudo sem erros.

Abri Microsoft.AspNetCore.Authentication.OpenIdConnect.csprojno VS 2022 v17.9.0 Preview 1.1 e tentei construí-lo, mas recebi este erro:

Erro NETSDK1141
Não é possível resolver a versão do SDK do .NET conforme especificado no global.json localizado em C:\aspnetcore\global.json.

Microsoft.AspNetCore.Authentication.OpenIdConnect C:\Arquivos de Programas\dotnet\sdk\8.0.100\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.DefaultItems.targets 128

Este é o meu global.jsonarquivo:

{
  "sdk": {
    "version": "6.0.125"
  },
  "tools": {
    "dotnet": "6.0.125",
    "runtimes": {
      "dotnet/x64": [
        "2.1.30",
        "$(MicrosoftNETCoreBrowserDebugHostTransportVersion)"
      ],
      "dotnet/x86": [
        "$(MicrosoftNETCoreBrowserDebugHostTransportVersion)"
      ],
      "aspnetcore/x64": [
        "3.1.32"
      ]
    },
    "Git": "2.22.0",
    "jdk": "11.0.3",
    "vs": {
      "version": "16.8",
      "components": [
        "Microsoft.VisualStudio.Component.VC.ATL",
        "Microsoft.VisualStudio.Component.VC.Tools.x86.x64"
      ]
    },
    "xcopy-msbuild": "16.5.0-alpha"
  },
  "msbuild-sdks": {
    "Yarn.MSBuild": "1.22.10",
    "Microsoft.DotNet.Arcade.Sdk": "6.0.0-beta.23517.3",
    "Microsoft.DotNet.Helix.Sdk": "6.0.0-beta.23517.3"
  }
}

Com base na primeira linha, preciso baixar o .NET SDK v6.0.125.

Não consigo encontrar esta versão nos arquivos.

A versão mais próxima que encontrei foi https://github.com/dotnet/core/blob/main/release-notes/6.0/6.0.12/6.0.12.md .

No entanto, quando faço o download e instalo, ele mostra 6.0.404 como a versão do SDK e 6.0.12 como a versão de tempo de execução:

Posso ver que agora tenho estes SDKs instalados:

Como posso baixar o .NET SDK 6.0.125?