private void SynchronizeAsyncWorker()
{
Exception error = null;
bool cancelled = false;
try
{
Logger.AddInternalState(this._log, "Download and install of the application started in a worker thread.");
cancelled = this.SynchronizeCore(false);
Logger.AddInternalState(this._log, "Installation is successful.");
}
catch (Exception exception2)
{
if (ExceptionUtility.IsHardException(exception2))
{
throw;
}
if (exception2 is DownloadCancelledException)
{
cancelled = true;
}
else
{
error = exception2;
}
}
finally
{
SynchronizeCompletedEventArgs arg = new SynchronizeCompletedEventArgs(error, cancelled, null, null);
this.asyncOperation.Post(this.synchronizeCompleted, arg);
}
}
private void SynchronizeGroupAsyncWorker(object arg)
{
Exception error = null;
bool cancelled = false;
string groupName = null;
object userState = null;
try
{
SyncGroupHelper sgh = (SyncGroupHelper)arg;
groupName = sgh.Group;
userState = sgh.UserState;
cancelled = this.SynchronizeGroupCore(false, sgh);
}
catch (Exception exception2)
{
if (ExceptionUtility.IsHardException(exception2))
{
throw;
}
if (exception2 is DownloadCancelledException)
{
cancelled = true;
}
else
{
error = exception2;
}
}
finally
{
SynchronizeCompletedEventArgs args = new SynchronizeCompletedEventArgs(error, cancelled, userState, groupName);
this.asyncOperation.Post(this.synchronizeCompleted, args);
}
}
private void SynchronizeGroupCompletedEventHandler(object sender, SynchronizeCompletedEventArgs e)
{
Exception exception = (Exception)null;
DeploymentManager deploymentManager = (DeploymentManager)null;
try
{
deploymentManager = (DeploymentManager)sender;
exception = e.Error;
}
catch (Exception ex)
{
if (ExceptionUtility.IsHardException(ex))
{
throw;
}
else
{
exception = ex;
}
}
finally
{
DownloadFileGroupCompletedEventArgs e1 = new DownloadFileGroupCompletedEventArgs(e.Error, e.Cancelled, e.UserState, e.Group);
DownloadFileGroupCompletedEventHandler completedEventHandler = (DownloadFileGroupCompletedEventHandler)this.Events[ApplicationDeployment.downloadFileGroupCompletedKey];
if (completedEventHandler != null)
{
completedEventHandler((object)this, e1);
}
}
}
public static ushort GetLogVerbosityLevel()
{
ushort num = 0;
try
{
using (RegistryKey key = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Classes\Software\Microsoft\Windows\CurrentVersion\Deployment", false))
{
if (key != null)
{
object obj2 = key.GetValue("LogVerbosityLevel");
if (obj2 is string)
{
Logger.AddWarningInformation(string.Format(CultureInfo.CurrentUICulture, Resources.GetString("LogVerbosityLevelSet"), new object[] { obj2 }));
num = Convert.ToUInt16(obj2, CultureInfo.InvariantCulture);
}
}
}
}
catch (Exception exception)
{
if (ExceptionUtility.IsHardException(exception))
{
throw;
}
num = 0;
}
return(num);
}
private void SynchronizeNullCompletedEventHandler(object sender, SynchronizeCompletedEventArgs e)
{
Exception error = (Exception)null;
DeploymentManager dm = (DeploymentManager)null;
new NamedPermissionSet("FullTrust").Assert();
try
{
dm = (DeploymentManager)sender;
error = e.Error;
}
catch (Exception ex)
{
if (ExceptionUtility.IsHardException(ex))
{
throw;
}
else
{
error = ex;
}
}
finally
{
CodeAccessPermission.RevertAssert();
this.EndUpdateAsync(dm, error, e.Cancelled);
}
}
public static ushort GetLogVerbosityLevel()
{
ushort num = 0;
try
{
using (RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Classes\\Software\\Microsoft\\Windows\\CurrentVersion\\Deployment", false))
{
if (registryKey != null)
{
object obj = registryKey.GetValue("LogVerbosityLevel");
if (obj is string)
{
Logger.AddWarningInformation(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, Resources.GetString("LogVerbosityLevelSet"), new object[1] {
obj
}));
num = Convert.ToUInt16(obj, (IFormatProvider)CultureInfo.InvariantCulture);
}
}
}
}
catch (Exception ex)
{
if (ExceptionUtility.IsHardException(ex))
{
throw;
}
else
{
num = (ushort)0;
}
}
return(num);
}
private void BindAsyncWorker()
{
Exception error = null;
bool cancelled = false;
string productName = null;
TempFile tempDeploy = null;
TempDirectory tempAppDir = null;
FileStream refTransaction = null;
try
{
Logger.AddInternalState(this._log, "Binding started in a worker thread.");
cancelled = this.BindCore(false, ref tempDeploy, ref tempAppDir, ref refTransaction, ref productName);
Logger.AddInternalState(this._log, "Binding is successful.");
}
catch (Exception exception2)
{
if (ExceptionUtility.IsHardException(exception2))
{
throw;
}
if (exception2 is DownloadCancelledException)
{
cancelled = true;
}
else
{
error = exception2;
}
}
finally
{
this._state = DeploymentProgressState.DownloadingApplicationFiles;
if ((error != null) || cancelled)
{
if (tempAppDir != null)
{
tempAppDir.Dispose();
}
if (tempDeploy != null)
{
tempDeploy.Dispose();
}
if (refTransaction != null)
{
refTransaction.Close();
}
}
BindCompletedEventArgs arg = new BindCompletedEventArgs(error, cancelled, null, this._actCtx, productName, this._cached);
this.asyncOperation.Post(this.bindCompleted, arg);
}
}
private void SynchronizeGroupCompletedEventHandler(object sender, SynchronizeCompletedEventArgs e)
{
try
{
DeploymentManager manager1 = (DeploymentManager)sender;
Exception error = e.Error;
}
catch (Exception exception)
{
if (ExceptionUtility.IsHardException(exception))
{
throw;
}
}
finally
{
DownloadFileGroupCompletedEventArgs args = new DownloadFileGroupCompletedEventArgs(e.Error, e.Cancelled, e.UserState, e.Group);
DownloadFileGroupCompletedEventHandler handler = (DownloadFileGroupCompletedEventHandler)this.Events[downloadFileGroupCompletedKey];
if (handler != null)
{
handler(this, args);
}
}
}
private void UpdateBindCompletedEventHandler(object sender, BindCompletedEventArgs e)
{
Exception error = (Exception)null;
DeploymentManager dm = (DeploymentManager)null;
bool flag = false;
new NamedPermissionSet("FullTrust").Assert();
try
{
dm = (DeploymentManager)sender;
if (e.Error == null && !e.Cancelled)
{
UpdateCheckInfo updateCheckResult = this.DetermineUpdateCheckResult(dm.ActivationDescription);
if (updateCheckResult.UpdateAvailable)
{
dm.DeterminePlatformRequirements();
try
{
dm.DetermineTrust(new TrustParams()
{
NoPrompt = true
});
}
catch (TrustNotGrantedException ex)
{
if (!dm.ActivationDescription.IsUpdateInPKTGroup)
{
throw;
}
}
}
this.ProcessUpdateCheckResult(updateCheckResult, dm.ActivationDescription);
if (updateCheckResult.UpdateAvailable)
{
flag = true;
dm.SynchronizeAsync();
}
if (!dm.ActivationDescription.IsUpdateInPKTGroup)
{
return;
}
this._subState = this._subStore.GetSubscriptionState(dm.ActivationDescription.DeployManifest);
}
else
{
error = e.Error;
}
}
catch (Exception ex)
{
if (ExceptionUtility.IsHardException(ex))
{
throw;
}
else
{
error = ex;
}
}
finally
{
CodeAccessPermission.RevertAssert();
if (!flag)
{
this.EndUpdateAsync(dm, error, e.Cancelled);
}
}
}
private void CheckForUpdateBindCompletedEventHandler(object sender, BindCompletedEventArgs e)
{
Exception error = (Exception)null;
DeploymentManager deploymentManager = (DeploymentManager)null;
bool updateAvailable = false;
Version availableVersion = (Version)null;
bool isUpdateRequired = false;
Version minimumRequiredVersion = (Version)null;
long updateSize = 0;
new NamedPermissionSet("FullTrust").Assert();
try
{
deploymentManager = (DeploymentManager)sender;
if (e.Error == null && !e.Cancelled)
{
UpdateCheckInfo updateCheckResult = this.DetermineUpdateCheckResult(deploymentManager.ActivationDescription);
if (updateCheckResult.UpdateAvailable)
{
deploymentManager.DeterminePlatformRequirements();
try
{
deploymentManager.DetermineTrust(new TrustParams()
{
NoPrompt = true
});
}
catch (TrustNotGrantedException ex)
{
if (!deploymentManager.ActivationDescription.IsUpdateInPKTGroup)
{
throw;
}
}
}
this.ProcessUpdateCheckResult(updateCheckResult, deploymentManager.ActivationDescription);
if (!updateCheckResult.UpdateAvailable)
{
return;
}
updateAvailable = true;
availableVersion = updateCheckResult.AvailableVersion;
isUpdateRequired = updateCheckResult.IsUpdateRequired;
minimumRequiredVersion = updateCheckResult.MinimumRequiredVersion;
updateSize = updateCheckResult.UpdateSizeBytes;
}
else
{
error = e.Error;
}
}
catch (Exception ex)
{
if (ExceptionUtility.IsHardException(ex))
{
throw;
}
else
{
error = ex;
}
}
finally
{
CodeAccessPermission.RevertAssert();
Interlocked.Exchange(ref this._guard, 0);
CheckForUpdateCompletedEventArgs e1 = new CheckForUpdateCompletedEventArgs(error, e.Cancelled, (object)null, updateAvailable, availableVersion, isUpdateRequired, minimumRequiredVersion, updateSize);
CheckForUpdateCompletedEventHandler completedEventHandler = (CheckForUpdateCompletedEventHandler)this.Events[ApplicationDeployment.checkForUpdateCompletedKey];
if (completedEventHandler != null)
{
completedEventHandler((object)this, e1);
}
if (deploymentManager != null)
{
deploymentManager.ProgressChanged -= new DeploymentProgressChangedEventHandler(this.CheckForUpdateProgressChangedEventHandler);
deploymentManager.BindCompleted -= new BindCompletedEventHandler(this.CheckForUpdateBindCompletedEventHandler);
new NamedPermissionSet("FullTrust").Assert();
try
{
deploymentManager.Dispose();
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
}
}
private void CheckForUpdateBindCompletedEventHandler(object sender, BindCompletedEventArgs e)
{
Exception error = null;
DeploymentManager manager = null;
bool updateAvailable = false;
Version availableVersion = null;
bool isUpdateRequired = false;
Version minimumRequiredVersion = null;
long updateSize = 0L;
new NamedPermissionSet("FullTrust").Assert();
try
{
manager = (DeploymentManager)sender;
if ((e.Error == null) && !e.Cancelled)
{
UpdateCheckInfo info = this.DetermineUpdateCheckResult(manager.ActivationDescription);
if (info.UpdateAvailable)
{
manager.DeterminePlatformRequirements();
try
{
TrustParams trustParams = new TrustParams {
NoPrompt = true
};
manager.DetermineTrust(trustParams);
}
catch (TrustNotGrantedException)
{
if (!manager.ActivationDescription.IsUpdateInPKTGroup)
{
throw;
}
}
}
this.ProcessUpdateCheckResult(info, manager.ActivationDescription);
if (info.UpdateAvailable)
{
updateAvailable = true;
availableVersion = info.AvailableVersion;
isUpdateRequired = info.IsUpdateRequired;
minimumRequiredVersion = info.MinimumRequiredVersion;
updateSize = info.UpdateSizeBytes;
}
}
else
{
error = e.Error;
}
}
catch (Exception exception2)
{
if (ExceptionUtility.IsHardException(exception2))
{
throw;
}
error = exception2;
}
finally
{
CodeAccessPermission.RevertAssert();
Interlocked.Exchange(ref this._guard, 0);
CheckForUpdateCompletedEventArgs args = new CheckForUpdateCompletedEventArgs(error, e.Cancelled, null, updateAvailable, availableVersion, isUpdateRequired, minimumRequiredVersion, updateSize);
CheckForUpdateCompletedEventHandler handler = (CheckForUpdateCompletedEventHandler)this.Events[checkForUpdateCompletedKey];
if (handler != null)
{
handler(this, args);
}
if (manager != null)
{
manager.ProgressChanged -= new DeploymentProgressChangedEventHandler(this.CheckForUpdateProgressChangedEventHandler);
manager.BindCompleted -= new BindCompletedEventHandler(this.CheckForUpdateBindCompletedEventHandler);
new NamedPermissionSet("FullTrust").Assert();
try
{
manager.Dispose();
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
}
}
