Comment puis-je lancer une méthode en arrière-plan sur mon application Xamarin?

vous pouvez utiliser ceci,

 System.Threading.Tasks.Task.Run(() =>
 {
      //Add your code here.
 }).ConfigureAwait(false);

pour exécuter une tâche de fond utilisez un Service. En général, les tâches sont classées soit comme des tâches de longue durée, soit comme des tâches périodiques.

le code pour le service sous android ressemble à ceci

[Service]
public class PeriodicService : Service
{ 
    public override IBinder OnBind(Intent intent)
    {
        return null;
    }

    public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
    {
        // From shared code or in your PCL


        return StartCommandResult.NotSticky;
    }
}

Et pour invoquer le service en arrière-plan

   var intent = new Intent (this, typeof(PeriodicService));
   StartService(intent);

Dans le cas où veut appeler et vérifier après chaque minute

private void StartBackgroundDataRefreshService ()
{
    var pt = new PeriodicTask.Builder ()
        .SetPeriod (1800) // in seconds; minimum is 30 seconds
        .SetService (Java.Lang.Class.FromType (typeof(BackgroundService)))
        .SetRequiredNetwork (0)
        .SetTag (your package name) // package name
        .Build ();

        GcmNetworkManager.GetInstance (this).Schedule (pt);
}

pour savoir quel type de service est bon de vous lire ce tutoriel Types de Services

Xamarin Blog périodique de service d'arrière-plan Xamarin Blog

L'autre exemple est

public class PeriodicService : Service
{ 
 private static Timer timer = new Timer();     
  public override IBinder OnBind(Intent intent)
    {
        return null;
    }

    public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
    {
        timer.scheduleAtFixedRate(new mainTask(), 0, 5000);
        return StartCommandResult.NotSticky;
    }

   private class mainTask extends TimerTask
    { 
        public void run() 
        {
         //your code
        }
    } 
}

voici un exemple de Code de Xamarin Android Service qui effectuera la tâche après toutes les 10 Secondes

using System;
using System.Threading;
using Android.App;
using Android.Content;
using Android.OS;
using Android.Util;

namespace SimpleService
{

[Service]
public class SimpleStartedService : Service
{
    static readonly string TAG = "X:" + typeof(SimpleStartedService).Name;
    static readonly int TimerWait = 10000;
    Timer timer;
    DateTime startTime;
    bool isStarted = false;

    public override void OnCreate()
    {
        base.OnCreate();
    }

    public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
    {
        Log.Debug(TAG, $"OnStartCommand called at {startTime}, flags={flags}, startid={startId}");
        if (isStarted)
        {
            TimeSpan runtime = DateTime.UtcNow.Subtract(startTime);
            Log.Debug(TAG, $"This service was already started, it's been running for {runtime:c}.");
        }
        else
        {
            startTime = DateTime.UtcNow;
            Log.Debug(TAG, $"Starting the service, at {startTime}.");
            timer = new Timer(HandleTimerCallback, startTime, 0, TimerWait);
            isStarted = true;
        }
        return StartCommandResult.NotSticky;
    }

    public override IBinder OnBind(Intent intent)
    {
        // This is a started service, not a bound service, so we just return null.
        return null;
    }


    public override void OnDestroy()
    {
        timer.Dispose();
        timer = null;
        isStarted = false;

        TimeSpan runtime = DateTime.UtcNow.Subtract(startTime);
        Log.Debug(TAG, $"Simple Service destroyed at {DateTime.UtcNow} after running for {runtime:c}.");
        base.OnDestroy();
    }

    void HandleTimerCallback(object state)
    {
        TimeSpan runTime = DateTime.UtcNow.Subtract(startTime);
        Log.Debug(TAG, $"This service has been running for {runTime:c} (since ${state})." );
    }
}

}

il y a plusieurs façons de faire cela dans iOS et Android. Dans les formes de Xamarin la plupart de cette fonctionnalité tombe sous le nom de semi-finition. Il y a beaucoup de tutoriels. Celui-ci est assez élaboré et mérite certainement d'être vérifié:

http://arteksoftware.com/backgrounding-with-xamarin-forms/

Dans Android une grande partie de ce travail est effectué dans un Service D'Arrière-Plan. Pour iOS regarder dans Long Cours d'exécution ou Longueur Finie Tâches. Comme vous pouvez le voir à partir de cela, il n'y a pas de Xamarin forme manière de le faire. Vous aurez besoin d'écrire Xamarin.Androïde et Xamarin.code iOS spécifique.

Vous pouvez utiliser

Device.StartTimer(TimeSpan.FromMinutes(1), () =>
{
   var shouldTimerContinueWork = true;
   /*your code*/
   return shouldTimerContinueWork;
});

cette minuterie fonctionne sur le thread d'arrière-plan, utilise des appareils horloge et entrée sûre.

Pour arrêter le minuteur lorsque l'application est en arrière-plan, vous pouvez utiliser Xamarin.Forme.Application méthode OnSleep et OnResume comme décrit ici

je fais quelque chose comme ceci est mes applications Xamarin Forms.

public void execute()
        {
            var thread = new Thread(new ThreadStart(startAuthenticationProcess))
            {
                IsBackground = true
            };
            thread.Start();
        }
 private void startAuthenticationProcess()
        {
            Thread.Sleep(2000);
            if (!Utils.isNetworkAvailable(splashActivity))
            {
                splashActivity.RunOnUiThread(() => Utils.showToast(splashActivity, splashActivity.GetString(Resource.String.r30025)));
                splashActivity.FinishAffinity();
            }
            else
            {
                try
                {
                    if (StringUtils.isBlank(strIPAdd) || (StringUtils.isNotBlank(strIPAdd) && (StringUtils.isBlank(strDbName) || "site".Equals(strDbName,StringComparison.OrdinalIgnoreCase))))
                    {
                        splashActivity.RunOnUiThread(() => DependencyService.Get<IAuthenticationDialog>().showAuthenticationDialog(new Command(() =>
                        {
                            var intent = new Intent(splashActivity, typeof(MainActivity));
                            intent.PutExtra("startLoginActivity", false);
                            splashActivity.StartActivity(intent);
                            splashActivity.Finish();
                        })));
                    }
                    else
                    {
                        gotoLoginScreen();
                    }
                }
                catch (Exception e)
                {
                    Log.Error(TAG, e.Message);
                }
            }
        }

Facile, essayez quelque chose comme ça et de mettre en œuvre votre logique de ces méthodes:

public partial class App : Application
{

   protected override void OnStart()
   {
      // Your App On start code should be here...

      // and then:
      Task.Run(() =>
        {
            //Add your code here, it might looks like:
            CheckDatabase();
            MakeAnUpdateDependingOnDatabase();
        });
   }

j'espère que cela aide.