WyUpdate - C # Консольное приложение, обновление не отвечает, работает ... как запустить синхронно?

Question

Если у кого-то есть отзывы о том, почему мое приложение WyUpdate не хочет работать, пожалуйста, сообщите мне.

Я пытаюсь создать базовое консольное приложение, которое запускает процесс WyUpdate, а затем по завершениивыполняет мое основное приложение (которое было только что обновлено).

Следуя инструкциям на http://wyday.com/wybuild/help/silent-update-windows-service.php, мне совсем не повезло.Приложение запускается и выполняет процесс ForceCheckForUpdate, но я не получаю никакой обратной связи: (

вот полный список моего кода.

Я добавил цикл whileнадеюсь получить ответ от auBackend, но, похоже, это не сработает. Существует ли простой способ запустить процесс синхронно и дождаться ответа перед закрытием приложения?

Заранее спасибо.

using System;
using System.Threading;
using wyDay.Controls;</p>

<p>namespace NPS.CeAUpdateLauncher
{
    class Program
    {
        private static AutomaticUpdaterBackend auBackend;
        private static bool receivedFeedback;</p>

<code>    static void Main(string[] args)
    {
        auBackend = new AutomaticUpdaterBackend
        {
            //TODO: set a unique string.
            // For instance, "appname-companyname"
            GUID = "CeALauncher_AutoUpdate",

            // With UpdateType set to Automatic, you're still in
            // charge of checking for updates, but the
            // AutomaticUpdaterBackend continues with the
            // downloading and extracting automatically.
            UpdateType = UpdateType.Automatic,
        };

        auBackend.CheckingFailed += auBackend_CheckingFailed;
        auBackend.UpdateAvailable += auBackend_UpdateAvailable;
        auBackend.DownloadingFailed += auBackend_DownloadingFailed;
        auBackend.ExtractingFailed += auBackend_ExtractingFailed;
        auBackend.ReadyToBeInstalled += auBackend_ReadyToBeInstalled;
        auBackend.UpdateSuccessful += auBackend_UpdateSuccessful;
        auBackend.UpdateFailed += auBackend_Failed;

        // Initialize() and AppLoaded() must be called after events have been set.
        // Note: If there's a pending update to be installed, wyUpdate will be
        //       started, then it will talk back and say "ready to install,
        //       you can close now" at which point your app will be closed.
        auBackend.Initialize();
        auBackend.AppLoaded();


        if (!auBackend.ClosingForInstall)
        {
            //TODO: do your normal service work
            CheckForUpdates();
        }            

        //
        while(!receivedFeedback)
            Thread.Sleep(10000);

    }

    static void CheckForUpdates()
    {
        // Only ForceCheckForUpdate() every N days!
        // You don't want to recheck for updates on every app start.

        if (//(DateTime.Now - auBackend.LastCheckDate).TotalDays > 10 &&
            auBackend.UpdateStepOn == UpdateStepOn.Nothing)
        {
            auBackend.ForceCheckForUpdate();

        }
    }

    static void auBackend_CheckingFailed(object sender, FailArgs e)
    {
        receivedFeedback = true;
    }

    static void auBackend_UpdateAvailable(object sender, EventArgs e)
    {
        receivedFeedback = true;
    }

    static void auBackend_DownloadingFailed(object sender, FailArgs e)
    {
        receivedFeedback = true;
    }

    static void auBackend_ExtractingFailed(object sender, FailArgs e)
    {
        receivedFeedback = true;
    }

    static void auBackend_ReadyToBeInstalled(object sender, EventArgs e)
    {
        // ReadyToBeInstalled event is called when
        // either the UpdateStepOn == UpdateDownloaded or UpdateReadyToInstall

        if (auBackend.UpdateStepOn == UpdateStepOn.UpdateReadyToInstall)
        {
            //TODO: Delay the installation of the update until
            //      it's appropriate for your app.

            //TODO: Do any "spin-down" operations. auBackend.InstallNow() will
            //      exit this process using Environment.Exit(0), so run
            //      cleanup functions now (close threads, close running programs,
            //      release locked files, etc.)

            // here we'll just close immediately to install the new version
            auBackend.InstallNow();
        }
        receivedFeedback = true;

    }

    static void auBackend_UpdateSuccessful(object sender, SuccessArgs e)
    {
        receivedFeedback = true;
    }

    static void auBackend_Failed(object sender, FailArgs e)
    {
        receivedFeedback = true;
    }



}
</code>

}

Answer 1

С кодом, который я прикрепил в своем первоначальном посте, проблема заключалась в том, что консольное приложение будет работать бесконечно долго.Я думал, что это потому, что процесс wyUpdate никогда не возвращал значение.Я узнал, что это потому, что я не вызывал все события.

После реализации обработчика событий для «UpToDate» я получил ответ и смог установить индикатор для успешного завершения работы приложения.

Я также заменил логический индикатор и метод while для ожидания ответа на resetEvent в соответствии с инструкциями поставщика, и он работает очень хорошо.

static readonly ManualResetEvent resetEvent = new ManualResetEvent(false);

static void Main(string[] args)
        {
          ...
          auBackend.UpToDate += auBackend_UpToDate;
          ...

          // Blocks until "resetEvent.Set()" on another thread
          resetEvent.WaitOne();

        }

static void auBackend_UpToDate(object sender, SuccessArgs e)
        {
            resetEvent.Set();
        }
    

Спасибо за ответы,

Если кому-то понадобится очень универсальное решение для обновления приложений, я бы предложил пакет wyBuild / wyUpdate.

Приятного просмотра!

Answer 2

Если вы можете использовать Reactive Extensions для .NET (Rx) , тогда у меня есть более простая альтернатива.

Пока класс AutomaticUpdaterBackend работаетего события в фоновом потоке, тогда этот код должен делать то, что вы хотите:

void Main(string[] args)
{
    var auBackend = new AutomaticUpdaterBackend
    {
        GUID = "CeALauncher_AutoUpdate",
        UpdateType = UpdateType.Automatic,
    };

    var checkingFailed = Observable.FromEvent<FailArgs>(h => auBackend.CheckingFailed += h, h => auBackend.CheckingFailed -= h);
    var updateAvailable = Observable.FromEvent<EventArgs>(h => auBackend.UpdateAvailable += h, h => auBackend.UpdateAvailable -= h);
    var downloadingFailed = Observable.FromEvent<FailArgs>(h => auBackend.DownloadingFailed += h, h => auBackend.DownloadingFailed -= h);
    var extractingFailed = Observable.FromEvent<FailArgs>(h => auBackend.ExtractingFailed += h, h => auBackend.ExtractingFailed -= h);
    var readyToBeInstalled = Observable.FromEvent<EventArgs>(h => auBackend.ReadyToBeInstalled += h, h => auBackend.ReadyToBeInstalled -= h);
    var updateSuccessful = Observable.FromEvent<SuccessArgs>(h => auBackend.UpdateSuccessful += h, h => auBackend.UpdateSuccessful -= h);
    var updateFailed = Observable.FromEvent<FailArgs>(h => auBackend.UpdateFailed += h, h => auBackend.UpdateFailed -= h);

    var readyToBeInstalledStepReady = readyToBeInstalled.Where(e => auBackend.UpdateStepOn == UpdateStepOn.UpdateReadyToInstall);
    var readyToBeInstalledStepNotReady = readyToBeInstalled.Where(e => auBackend.UpdateStepOn != UpdateStepOn.UpdateReadyToInstall);

    var failed = Observable.Merge(new []
    {
        checkingFailed.Select(e => "Checking Failed"),
        downloadingFailed.Select(e => "Downloading Failed"),
        extractingFailed.Select(e => "Extracting Failed"),
        updateFailed.Select(e => "Update Failed"),
        readyToBeInstalledStepNotReady.Select(e => "Update Not Ready"),
    });

    var success = Observable.Merge(new []
    {
        readyToBeInstalledStepReady.Select(e => "Update Ready"),
        updateSuccessful.Select(e => "Update Successful"),
    });;

    failed.Subscribe(e => Console.Error.WriteLine(e));
    success.Subscribe(e => Console.WriteLine(e));

    readyToBeInstalledStepReady.Subscribe(e => auBackend.InstallNow());

    auBackend.Initialize();
    auBackend.AppLoaded();

    if (!auBackend.ClosingForInstall)
    {
        if (auBackend.UpdateStepOn == UpdateStepOn.Nothing)
        {
            auBackend.ForceCheckForUpdate();
        }
    }            

    success.Merge(failed).First();
}

Да, нет никаких переменных уровня модуля и методов обработки событий.Просто местные жители и лямбды.: -)