Comment puis-je implémenter des opérations de copie et de renommage non bloquantes dans Qt ?

Opérations de copie et de renommage non bloquantes dans Qt

Dans les situations où les utilisateurs manipulent des fichiers volumineux et doivent interrompre les opérations de copie ou de renommage, les fonctions Qt par défaut s'avèrent insuffisantes. Cette limitation provient de la nature bloquante de ces opérations, laissant les utilisateurs attendre la fin de processus potentiellement longs même s'ils se rendent compte de leur erreur.

Opération de copie

Qt ne le fait pas fournir toute solution intégrée pour les opérations de copie non bloquantes. Pour implémenter cette fonctionnalité, une classe personnalisée avec une approche de copie fragmentée est nécessaire. Cette classe devrait permettre la copie de fichiers en morceaux, en utilisant un tampon pour permettre le suivi de la progression et la réactivité aux annulations des utilisateurs.

Opération de renommage

De même, Qt ne prend pas en charge opérations de renommage non bloquantes. Comme le renommage est généralement implémenté sous la forme d'un processus de copie puis de suppression, une classe personnalisée peut également être utilisée ici. Cette classe peut effectuer la copie de manière non bloquante, puis supprimer le fichier d'origine une fois la copie terminée.

Implémentation

Voici un exemple de classe personnalisée qui implémente opérations de copie non bloquantes :

class CopyHelper : public QObject {
    Q_OBJECT
    Q_PROPERTY(qreal progress READ progress WRITE setProgress NOTIFY progressChanged)
public:
    CopyHelper(QString sPath, QString dPath, quint64 bSize = 1024 * 1024) :
        isCancelled(false), bufferSize(bSize), prog(0.0), source(sPath), destination(dPath), position(0) { }
    ~CopyHelper() { free(buff); }

    qreal progress() const { return prog; }
    void setProgress(qreal p) {
        if (p != prog) {
            prog = p;
            emit progressChanged();
        }
    }

public slots:
    void begin() {
        // File opening, size checking, and buffer allocation
        QMetaObject::invokeMethod(this, "step", Qt::QueuedConnection);
    }
    void step() {
        // Read, write, and progress tracking
        if (isCancelled) {
            // Delete the copied portion and emit done signal
        }
        else if (position < fileSize) {
            QMetaObject::invokeMethod(this, "step", Qt::QueuedConnection);
        } else {
            // Emit done signal
        }
    }
    void cancel() { isCancelled = true; }

signals:
    void progressChanged();
    void done();

private:
    bool isCancelled;
    quint64 bufferSize;
    qreal prog;
    QFile source, destination;
    quint64 fileSize, position;
    char * buff;
};

Cette classe vous permet de lancer le processus de copie, de suivre la progression et de l'annuler si nécessaire. Il utilise une approche non bloquante pour empêcher le verrouillage du thread principal.

Conclusion

En implémentant des classes personnalisées qui exploitent des techniques non bloquantes, les développeurs peuvent fournir aux utilisateurs avec la possibilité d'interrompre les opérations de copie et de renommage de fichiers sans sacrifier la réactivité. Cette expérience utilisateur améliorée est particulièrement précieuse lorsqu'il s'agit de fichiers volumineux dont le traitement peut prendre beaucoup de temps.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!