I've modified my code to include a file check. If the file is used by another process, we wait a moment before trying again.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.Text;
using System.IO;
using System.Threading; // Ajoutez cette directive pour utiliser la classe Thread

namespace WorkflowActivity.Scripting.CopieNATIFfromPIXItoLF
{
    /// <summary>
    /// Offre une ou plusieurs méthodes qui peuvent être exécutées au moment de l'exécution de l'activité de scriptage du flux de travail.
    /// </summary>
    public class Script1 : ScriptClass90
    {
        /// <summary>
        /// Cette méthode est exécutée quand l'activité est effectuée.
        /// </summary>
        protected override void Execute()
        {
            // Ecrivez ici votre code.
            // Get the token values for source filename, source path, and target path...
            String sourcePath = this.GetTokenValue("SourcePathN").ToString();
            String sourceFileName = this.GetTokenValue("SourceFileNameN").ToString();
            String targetPath = this.GetTokenValue("TargetPathN").ToString();
            String sourcePathAndName = Path.Combine(sourcePath, sourceFileName);
            String targetPathAndName = Path.Combine(targetPath, sourceFileName);
            Boolean fileExists = false;

            int maxAttempts = 10; // Nombre maximal de tentatives
            int delayBetweenAttempts = 60000; // Délai entre chaque tentative en millisecondes

            for (int attempt = 0; attempt < maxAttempts; attempt++)
            {
                try
                {
                    // Check to see if the source file exists...
                    if (File.Exists(sourcePathAndName))
                    {
                        using (FileStream fileStream = File.Open(sourcePathAndName, FileMode.Open, FileAccess.Read, FileShare.None))
                        {
                            fileExists = true;

                            // Check to see if the target path exists.  If not then create it...
                            if (Directory.Exists(targetPath) == false)
                            {
                                Directory.CreateDirectory(targetPath);
                            }

                            // Copy the source file to the target directory...
                            File.Copy(sourcePathAndName, targetPathAndName, true);
                        }
                        break;
                    }
                }
                catch (IOException)
                {
                    // Le fichier est verrouillé par un autre processus, attendre avant de réessayer.
                    Thread.Sleep(delayBetweenAttempts);
                }
                catch (System.Exception e)
                {
                    this.WorkflowApi.TrackError(e.Message);
                    break;
                }
            }

            // Set the result token for later processing...
            this.SetTokenValue("FileExists", fileExists);
        }
    }
}

That is going to be very inefficient if multiple instances of this workflow need to run at the same time as the instance will stay actively running for the entire minute Thread.Sleep is running and prevent other instances from running.

Try-Catch is better to delay the instance because it would allow Workflow to run other instances while this one is in a wait state.

Your catch for IOException might be too generic. I think if the disk is full or not available, you'd also get an IOException.