draw(_:) e drawRect — cosa sono, chiamata e override

Cos'è draw(_:) / drawRect

draw(_:) è un metodo di istanza di UIView che UIKit chiama per renderizzare il contenuto della vista. All'interno di questo metodo, lo sviluppatore ottiene l'accesso al contesto grafico CGContext e utilizza l'API di Core Graphics per disegnare linee, riempimenti, testo e immagini. drawRect: in Objective-C esegue la stessa funzione ma con sintassi diversa: l'unico parametro è un CGRect che specifica l'area da ridisegnare.

Secondo Apple Engineering (2024), draw(_:) funziona tramite rendering CPU su Bitmap Graphics Context, che offre la massima flessibilità ma richiede più risorse rispetto a CALayer. La decisione di utilizzare draw(_:) viene presa in base alla complessità della grafica e ai requisiti di prestazioni.

Firma del metodo in Swift e Objective-C

In Swift, il metodo viene dichiarato come override func draw(_ rect: CGRect), dove rect è il rettangolo che deve essere ridisegnato. In Objective-C, la firma è - (void)drawRect:(CGRect)rect. Il parametro rect può essere più piccolo dei bounds della vista durante il ridisegno parziale tramite setNeedsDisplay(_:).

- (void)drawRect:(CGRect)rect {
    CGContextRef context = UIGraphicsGetCurrentContext();
    CGContextSetFillColorWithColor(context, [UIColor redColor].CGColor);
    CGContextFillRect(context, rect);
}

Quando il sistema chiama draw(_:)

Il sistema chiama automaticamente draw(_:) in scenari strettamente definiti. Comprendere questi trigger aiuta a evitare ridisegni non necessari e ottimizzare le prestazioni della vista. Di seguito sono elencati tutti i casi di invocazione automatica del metodo.

• Primo rendering — quando la vista viene aggiunta per la prima volta alla gerarchia e diventa visibile sullo schermo
• setNeedsDisplay() — dopo la chiamata a questo metodo, il sistema ridisegna al prossimo ciclo di disegno
• setNeedsDisplay(_:) — come sopra, ma specificando un rettangolo concreto per il ridisegno
• contentMode — quando i bounds cambiano, se contentMode richiede il ridisegno (ad esempio .redraw)
• setNeedsLayout() — in alcuni casi, dopo la riorganizzazione delle subview, potrebbe essere necessario il ridisegno

La documentazione Apple avverte: non chiamare mai draw(_:) direttamente. Il sistema decide da solo quando eseguire il disegno, e una chiamata diretta interrompe il meccanismo interno di cache. Per richiedere un ridisegno, utilizzare sempre setNeedsDisplay() o setNeedsDisplay(_:).

Come fare l'override di draw(_:) in Swift

L'override di draw(_:) in Swift inizia con l'ottenimento del contesto grafico e le successive chiamate a Core Graphics. Si consiglia di creare metodi separati per blocchi logici di disegno — questo migliora la leggibilità e la testabilità del codice.

override func draw(_ rect: CGRect) {
    super.draw(rect)

    guard let context = UIGraphicsGetCurrentContext() else { return }

    // Line parameters
    context.setStrokeColor(UIColor.darkGray.cgColor)
    context.setLineWidth(2.0)

    // Drawing a triangle
    context.move(to: CGPoint(x: rect.midX, y: rect.minY + 10))
    context.addLine(to: CGPoint(x: rect.maxX - 10, y: rect.maxY - 10))
    context.addLine(to: CGPoint(x: rect.minX + 10, y: rect.maxY - 10))
    context.closePath()
    context.strokePath()
}

In questo esempio, draw(_:) disegna un triangolo con un contorno grigio scuro spesso 2 pixel. La chiamata a super.draw(rect) all'inizio del metodo è raccomandata da Apple per preservare la logica di disegno del genitore, sebbene l'implementazione predefinita di draw(_:) in UIView sia vuota.

La regola di idempotenza di draw(_:)

Ogni chiamata a draw(_:) deve produrre un risultato identico con gli stessi dati di input. Ciò consente al sistema di memorizzare nella cache il risultato e di non chiamare draw(_:) nuovamente se il contenuto della vista non è cambiato. Non utilizzare valori casuali, ora di sistema o richieste di rete all'interno di draw(_:).

drawRect: in Objective-C e differenze da draw(_:)

drawRect: è storicamente la prima versione del metodo, apparsa in iOS 2.0 con Objective-C. In Swift, il metodo è stato rinominato in draw(_:) utilizzando il parametro esterno _. Funzionalmente, i metodi sono identici: entrambi ricevono un CGRect dell'area da ridisegnare e utilizzano UIGraphicsGetCurrentContext() per accedere al contesto grafico.

Durante la migrazione di un progetto da Objective-C a Swift, la ridenominazione del metodo è uno dei primi compiti. Xcode fornisce un convertitore automatico, ma drawRect: richiede un aggiornamento manuale a draw(_:). Secondo Apple (2024), la versione Swift draw(_:) è preferibile per i nuovi progetti.

Ottimizzazione del disegno in draw(_:)

draw(_:) viene eseguito sulla CPU e un'implementazione non ottimale può causare cadute di fotogrammi e scarse prestazioni. Apple raccomanda diversi approcci comprovati per accelerare il disegno.

Minimizzare il numero di operazioni di disegno

Ogni operazione di Core Graphics (move(to:), addLine(to:), strokePath) ha un overhead. Raggruppare le operazioni e utilizzare CGPath per forme complesse — il percorso viene creato una volta e riutilizzato ad ogni chiamata di draw(_:).

Utilizzare UIBezierPath per oggetti vettoriali

UIBezierPath è un wrapper Objective-C di CGPath che fornisce una semplice API per creare forme. Creare UIBezierPath in anticipo (ad esempio nell'inizializzatore) e chiamare semplicemente fill() o stroke() all'interno di draw(_:).

private let starPath: UIBezierPath = {
    let path = UIBezierPath()
    // Building a star shape
    path.move(to: CGPoint(x: 50, y: 0))
    for i in 1...5 {
        let angle = CGFloat(i) * 4 * CGFloat.pi / 5
        path.addLine(to: CGPoint(x: 50 + 40 * cos(angle),
                               y: 50 + 40 * sin(angle)))
    }
    path.close()
    return path
}()

override func draw(_ rect: CGRect) {
    UIColor.systemYellow.setFill()
    starPath.fill()
}

Errori comuni quando si lavora con draw(_:)

Gli sviluppatori commettono spesso gli stessi errori quando fanno l'override di draw(_:). Conoscere questi modelli aiuta a evitare bug e degrado delle prestazioni. Vediamo i problemi più comuni e le loro soluzioni.

• Chiamata diretta a draw(_:) — non chiamare mai draw(_:) direttamente. Utilizzare setNeedsDisplay() per richiedere un ridisegno. La chiamata diretta rompe la cache e può portare a una visualizzazione errata.
• Calcoli pesanti all'interno di draw(_:) — draw(_:) dovrebbe essere il più leggero possibile. Creare UIBezierPath, immagini e altri oggetti pesanti al di fuori del metodo, inizializzandoli una sola volta.
• Creazione di oggetti all'interno di draw(_:) — le costruzioni di UIColor, UIFont e UIGraphicsImageRenderer all'interno di draw(_:) creano un carico di memoria non necessario. Spostare la creazione di oggetti nelle proprietà della classe.
• Ignorare il parametro rect — rect specifica l'area che necessita di ridisegno. Disegnare fuori da rect viene scartato dal sistema ma consuma risorse. Verificare l'intersezione con rect prima di disegnare.
• Mancanza di super.draw(rect) — sebbene l'implementazione di UIView sia vuota, Apple raccomanda di chiamare super.draw(rect) per compatibilità con future modifiche di UIKit.

Seguendo queste regole, garantirai un disegno personalizzato stabile e veloce in qualsiasi progetto iOS. Profila draw(_:) con Instruments (Core Animation) per vedere il tempo di esecuzione effettivo e i colli di bottiglia.