Gordon's questions

Tanto o ChatGPT quanto o Copilot falharam comigo. Estou tentando adicionar preenchimento a um tempo que me dá dois dígitos para segundos inteiros e três dígitos para segundos fracionários. Então, dado $timeque é produzido por

$timer = [Stopwatch]::StartNew()
$timer.Stop()
$time = $timer.Elapsed.TotalSeconds

A IA sugere coisas como

$time = [Math]::Round($time, 3)
$time = "{0:000.000}" -f $time

Quando tento usar o tempo resultante assim

"$($time): $function"

Obtenho um único 0 à esquerda do decimal e nenhum zero à direita é adicionado.

Onde eu (e a IA) estamos errando?

Estou vindo de um background do PowerShell e, no momento, estou tentando entender o Swift Concurrency. Meu primeiro projeto relacionado à simultaneidade é um utilitário para transcrever arquivos de áudio em massa, e estou quebrando a cabeça com alguns conceitos básicos.

O que estou tentando fazer aqui é simplesmente obter uma lista dos arquivos de áudio, então fazer um loop por eles exibindo aquele que está sendo trabalhado na IU e usar um cronômetro simples para simular o trabalho de transcrição por enquanto. Eu encontrei [isto][1] que pensei que me permitiria usar um asyncAftercronômetro típico, mas não está funcionando.

Minha expectativa é que a interface do usuário mostre o nome do arquivo atual e, depois de um tempo, o console mostre o mesmo enquanto a interface do usuário mostra o próximo nome do arquivo, mas a interface do usuário está mostrando apenas o último nome do arquivo e todas as gravações no console sugerem que basicamente cada temporizador está sendo executado em paralelo.

Em um mundo perfeito, eu GOSTARIA de transcrever tudo em paralelo, mas esse é outro problema, parece que SFSpeechURLRecognitionRequestnão suporta isso. De fato, mesmo apenas em sequência me deu problemas, mas não tenho nem 100% de certeza de que ESTOU fazendo isso em sequência, então estou tentando ter alguma cabeça para forçar isso, daí o código com falha aqui.

struct ContentView: View {
    @State private var fileName: String?
    @State private var files: [URL] = []
    
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("\(fileName ?? "-")")
        }
        .padding()
        .onAppear {
            files = getFiles()
            processFiles()
        }
    }
    
    
    private func getFiles() -> [URL] {
        do {
            let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
            let path = documentsURL.appendingPathComponent("Voice Memos").absoluteURL
            
            let contents = try FileManager.default.contentsOfDirectory(at: path, includingPropertiesForKeys: nil, options: [])
            
            let files = (contents.filter {$0.pathExtension == "m4a"}).sorted { url1, url2 in
                url1.path > url2.path
            }
            
            return files
        }
        catch {
            print(error.localizedDescription)
            return []
        }
    }
    
    private func processFiles() {
        for file in files {
            Task {
                await processFile(file)
            }
        }
    }
    
    private func processFile(_ url: URL) async {
        fileName = url.lastPathComponent
        let seconds = Double.random(in: 10.0...20.0)
        Task.synchronous {
            DispatchQueue.main.asyncAfter(deadline: .now() + seconds) {
                print("\(url.lastPathComponent) \(seconds)")
            }
        }
    }
}

extension Task where Failure == Error {
    /// Performs an async task in a sync context.
    ///
    /// - Note: This function blocks the thread until the given operation is finished. The caller is responsible for managing multithreading.
    static func synchronous(priority: TaskPriority? = nil, operation: @escaping @Sendable () async throws -> Success) {
        let semaphore = DispatchSemaphore(value: 0)

        Task(priority: priority) {
            defer { semaphore.signal() }
            return try await operation()
        }

        semaphore.wait()
    }
}

EDIT: Eu também tentei

let duration: UInt64 = 2_000_000_000 /* 2 seconds */
var seconds: UInt64 { duration/1_000_000_000 }
Task.synchronous { try await Task.sleep(nanoseconds: duration) }

como a função de timer, e isso simplesmente trava. Quanto a quem votou negativamente instantaneamente, você pode pelo menos explicar POR QUE essa é uma pergunta tão ofensiva?

Eu tenho uma lista genérica de tabelas hash derivadas de chaves de desinstalação no registro, que preciso pesquisar. Cada membro da lista é um dicionário ordenado contendo essas chaves. O valor real de cada chave é definido separadamente, pois alguns são valores direto do registro e outros são calculados.

[Ordered]@{
        displayName = 'DisplayName'
        displayVersion = 'DisplayVersion'
        installSource = 'InstallSource'
        publisher = 'Publisher'
        quietUninstallString = 'QuietUninstallString'
        uninstallParam = 'UninstallParam'
        uninstallPath = 'UninstallPath'
        uninstallString = 'UninstallString'
        installDate = 'InstallDate'
        keyID = '$keyID'
        keyName = '$keyName'
        keyGUID = '$keyGUID'
        keyPath = '$keyPath'
        architecture = '$architecture'
    } 

Depois de ter essa coleção em uma variável, $rawUninstallKeyspreciso pesquisá-la, e a pesquisa é complicada porque a Autodesk tende a ter várias chaves de desinstalação com dados iguais ou semelhantes, mas apenas uma funcionará. Por exemplo, haverá uma chave GUID com um DisplayNameque Autodesk Revit 2025fornece uma string de desinstalação que realmente funciona e outro GUID com um DisplayNameque Revit 2025não faz nada. Portanto, para extrair a UninstallString correta, preciso procurar uma chave que corresponda ao primeiro padrão E que tenha uma segunda chave que corresponda ao segundo padrão. E na verdade existem muitas variações porque a Autodesk é péssima em qualquer tipo de consistência. Então, estou com isso funcionando agora onde apenas faço um foreach nas chaves brutas procurando pelo primeiro padrão, e se encontrar eu derivo o segundo padrão (neste caso substituo 'Autodesk' por $null) e depois procuro com outro foreach . E funciona, mas meu Deus, é lento. Então, quero tentar usar o .Where()método da lista para obter a otimização do .NET. Mas isso significa construir uma coleção de fechamentos a serem aplicados.

Então, isso vai funcionar

$rawUninstallKeys.Where({$_.publisher -like "Autodesk*"})

mas estou lutando para descobrir como colocar o fechamento em uma variável que ainda permite $_a expansão adequada. Isso é ainda mais complicado pelo fato de que meu encerramento pode ser simplesmente {$_.DisplayName}quando eu só preciso ver se esse valor existe, ou {-not $_.DisplayName}quando eu quero apenas uma chave que não contenha essa propriedade, ou o primeiro exemplo onde preciso comparar o valor das propriedades para outro valor, que pode ser um curinga. Efetivamente, o que preciso fazer é expandir a variável na string de fechamento dentro do .Where(), mas isso não funciona

.Where({$($ExecutionContext.InvokeCommand.ExpandString($closure))})

Estou tentando modificar a visualização de classificação de Stewart Lynch para oferecer suporte a uma representação estática e um "controle" para definir a classificação. Para fazer isso, preciso de algumas propriedades opcionais para abordar as duas condições diferentes. O mesmo currentRatingacontece com a classificação atual, para criar uma visão desse número de símbolos. maxRatingé a classificação máxima possível e mutableRatingé a classificação atual vinculada, para que eu possa exibir o valor da corneta como símbolos preenchidos, com o restante dos símbolos até maxRatingnão preenchidos, bem como um símbolo não preenchido e riscado para definir a classificação como 0.

Estou tendo problemas para tornar esse parâmetro vinculado também opcional. Achei isso que sugere que deveria ser possível, mas isso também é bastante antigo. De qualquer forma, tentei várias permutações como visto nas linhas comentadas, tentando fazer a inicialização funcionar, com várias falhas diferentes.

struct RatingView: View {
    var currentRating: Int?
    
    var maxRating: Int?
    @Binding var mutableRating: Int?
    
    var width:Int
    var color: UIColor
    var sfSymbol: String
    
    public init(
        currentRating: Int? = nil,
        maxRating: Int? = nil,
        mutableRating: Binding<Int?>,
//        mutableRating: Binding<Int>?,
//        mutableRating: (Binding<Int>)?,
        width: Int = 20,
        color: UIColor = .systemYellow,
        sfSymbol: String = "star"
    ) {
        self.currentRating = currentRating
        self.maxRating = maxRating
        self._mutableRating = mutableRating
//        self._mutableRating = mutableRating ?? Binding.constant(nil)
        self.width = width
        self.color = color
        self.sfSymbol = sfSymbol
    }
    
    public var body: some View {
        Text("")
    }
}

#Preview ("mutating") {
    struct PreviewWrapper: View {
        @State var rating: Int? = 3
        
        var body: some View {
            RatingView(
                maxRating: 5,
                mutableRating: $rating,
                width: 30,
                color: .red,
                sfSymbol: "heart"
            )
        }
    }
    return PreviewWrapper()
}

#Preview ("non mutating") {
    struct PreviewWrapper: View {
        
        var body: some View {
            RatingView(
                currentRating: 3,
                width: 20,
                color: .red,
                sfSymbol: "heart"
            )
        }
    }
    return PreviewWrapper()
}

Então, minha primeira pergunta é: ainda posso fazer isso no iOS 17 e, em caso afirmativo, como? E segundo, estou curioso para saber os detalhes de qual é a diferença entre essas três abordagens para os argumentos do Init.

mutableRating: Binding<Int?>
mutableRating: Binding<Int>?
mutableRating: (Binding<Int>)?

EDIT: Esclarecimento de falhas Quando uso mutableRating: Binding<Int?> e self._mutableRating = mutableRating entro Missing argument for parameter 'mutableRating' in callna non mutatingvisualização. O que presumo significa que o parâmetro não é realmente opcional, o que faz sentido dadas as diferenças mencionadas. Se eu alterar a linha do argumento para mutableRating: Binding<Int>?tornar o parâmetro opcional, obtenho Cannot assign value of type 'Binding<Int>' to type 'Binding<Int?>' on the initialization line. One of the fix options offered suggests that this might work, self._mutableRating = mutableRating ?? nil but that producesNão é possível atribuir valor do tipo 'Binding?' para digitar 'Binding<Int?>'` o que nos leva de volta à mudança no argumento.

Tenho usado essa função para despejar XML no console para revisão enquanto trabalho no código para fazer alguma manipulação extensa de XML e, na maior parte, funciona conforme o esperado.

function Write-PxXmlToConsole {
    param (
        [Xml.XmlNode]$Xml
    )
    
    if ($Xml -is [Xml.XmlDocument]) {
        $xmlDocument = $Xml
    } else {
        $xmlDocument = [Xml.XmlDocument]::new()
        $newElement = $xmlDocument.ImportNode($Xml, $True)
        [Void]$xmlDocument.AppendChild($newElement)
    }

    $stringWriter = [System.IO.StringWriter]::new()
    $xmlWriter = [System.Xml.XmlTextWriter]::new($stringWriter)
    $xmlWriter.Formatting = "indented"

    $xmlDocument.WriteTo($xmlWriter)
    $xmlWriter.Flush()
    $stringWriter.Flush()

    Write-Host $stringWriter.ToString()
    Write-Host
}

No entanto, parece que em algum lugar as [System.IO.StringWriter]variáveis ​​estão sendo expandidas. Porque quando meu XML fica assim

$xml = [Xml]@"
<Pattern>$key.Value</Pattern>
"@
Write-PxXmlToConsole $xml

Recebo <Pattern>Autodesk Revit 2019.Value</Pattern>como saída porque em algum lugar desta sessão a variável $keyfoi preenchida. E se eu iniciar uma nova sessão, obterei <Pattern>.Value</Pattern>. Um pouco doloroso, e não consigo encontrar nada aqui que sugira uma configuração que suprima esse comportamento.