/// <summary>
/// Constructor
/// </summary>
public MyBackupService(ConfigManager configManager, ScheduleManager scheduleManager)
{
managers.Add(configManager);
managers.Add(scheduleManager);
taskDispatcher = new TaskDispatcher();
Init();
}
public void LeastIntervalTest3()
{
var tasks = new char[] { 'A', 'A', 'A', 'A', 'A', 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
var n = 2;
var expectedResult = 16;
var actualResult = new TaskDispatcher().LeastInterval(tasks, n);
Assert.AreEqual(expectedResult, actualResult);
}
public void LeastIntervalTest2()
{
var tasks = new char[] { 'A', 'A', 'A', 'B', 'B', 'B' };
var n = 0;
var expectedResult = 6;
var actualResult = new TaskDispatcher().LeastInterval(tasks, n);
Assert.AreEqual(expectedResult, actualResult);
}
/// <summary>
///
/// </summary>
public void Stop()
{
PreStop();
if (_taskDispather != null)
{
_taskDispather.Stop();
_taskDispather = null;
}
}
private void AirdropTimer_Elapsed(object sender, ElapsedEventArgs e)
{
// Make sure it's executed on the main thread
TaskDispatcher.QueueOnMainThread(() =>
{
CallAirdrop();
AirdropTimerNext = DateTime.Now.AddSeconds(Configuration.Instance.AirdropInterval);
Logger.Log("Airdrop has been sent by a timer!", ConsoleColor.Yellow);
});
}
internal ForegroundValidationSynchronizer(TaskDispatcher dispatcher, Func <ValidationReason, CancellationToken, TValidationResult> validationWork, Action <TValidationResult> updateWork)
{
Fx.Assert(dispatcher != null, "dispatcher should not be null and is ensured by caller.");
Fx.Assert(validationWork != null, "validationWork should not be null and is ensured by caller.");
Fx.Assert(updateWork != null, "updateWork should not be null and is ensured by caller.");
this.dispatcher = dispatcher;
this.validationWork = validationWork;
this.updateWork = updateWork;
}
/// <summary>
/// Safely destroys this buildable no matter which thread it is called from.
/// </summary>
public void SafeDestroy()
{
if (!Thread.CurrentThread.IsGameThread())
{
TaskDispatcher.QueueOnMainThread(UnsafeDestroy);
return;
}
UnsafeDestroy();
}
public void SafeDamage(ushort damage)
{
if (!Thread.CurrentThread.IsGameThread())
{
TaskDispatcher.QueueOnMainThread(() => UnsafeDamage(damage));
return;
}
UnsafeDamage(damage);
}
public void SafeHeal(ushort amount)
{
if (!Thread.CurrentThread.IsGameThread())
{
TaskDispatcher.QueueOnMainThread(() => UnsafeHeal(amount));
return;
}
UnsafeHeal(amount);
}
public override void Load(AssetLoaded <T> callback = null)
{
try
{
if (!waiting)
{
Logger.Log(String.Format("Updating WebXMLFileAsset {0} from {1}", typeof(T).Name, url));
waiting = true;
webclient.DownloadStringCompleted -= handler;
handler = (object sender, System.Net.DownloadStringCompletedEventArgs e) =>
{
if (e.Error != null)
{
Logger.Log(String.Format("Error retrieving WebXMLFileAsset {0} from {1}: {2}", typeof(T).Name, url, e.Error.Message));
}
else
{
try
{
using (StringReader reader = new StringReader(e.Result))
{
XmlSerializer serializer = new XmlSerializer(typeof(T), attr);
T result = (T)serializer.Deserialize(reader);
if (result != null)
{
TaskDispatcher.QueueOnMainThread(() =>
{
instance = result;
Logger.Log(String.Format("Successfully updated WebXMLFileAsset {0} from {1}", typeof(T).Name, url));
});
}
}
}
catch (Exception ex)
{
Logger.Log(String.Format("Error retrieving WebXMLFileAsset {0} from {1}: {2}", typeof(T).Name, url, ex.Message));
}
}
TaskDispatcher.QueueOnMainThread(() =>
{
callback?.Invoke(this);
waiting = false;
});
};
webclient.DownloadStringCompleted += handler;
webclient.DownloadStringAsync(url);
}
}
catch (Exception ex)
{
Logger.Log(String.Format("Error retrieving WebXMLFileAsset {0} from {1}: {2}", typeof(T).Name, url, ex.Message));
}
}
public TaskWorker Start()
{
if (isStarted) throw new Exception("already running");
dispatcher = new TaskDispatcher(queue);
dispatcher.Start();
isStarted = true;
return this;
}
private static void RunAsync(Action action)
{
ThreadPool.QueueUserWorkItem((_) =>
{
try
{
action.Invoke();
} catch (Exception e)
{
TaskDispatcher.QueueOnMainThread(() => Logger.LogException(e, $"YA'LL WANNA SINGLE SAY"));
}
});
}
public void Execute(IRocketPlayer caller, string[] command)
{
PlayerHome home;
UnturnedPlayer player = (UnturnedPlayer)caller;
home = HomesHelper.GetPlayerHome(player.CSteamID, command.ElementAtOrDefault(0));
if (home == null)
{
UnturnedChat.Say(caller, pluginInstance.Translate("NoHome"), pluginInstance.MessageColor);
return;
}
if (!ValidateTeleportation(player, home))
{
return;
}
if (pluginInstance.PlayerCooldowns.TryGetValue(caller.Id, out DateTime cooldownExpire) && cooldownExpire > DateTime.Now)
{
UnturnedChat.Say(caller, pluginInstance.Translate("HomeCooldown", System.Math.Round((cooldownExpire - DateTime.Now).TotalSeconds)),
pluginInstance.MessageColor);
return;
}
pluginInstance.PlayerCooldowns[caller.Id] = DateTime.Now.AddSeconds(VipHelper.GetPlayerHomeCooldown(caller.Id));
float delay = VipHelper.GetPlayerHomeDelay(player.Id);
if (delay > 0)
{
UnturnedChat.Say(caller, pluginInstance.Translate("HomeDelayWarn", delay), pluginInstance.MessageColor);
}
TaskDispatcher.QueueOnMainThread(() =>
{
if (!ValidateTeleportation(player, home))
{
pluginInstance.PlayerCooldowns.Remove(caller.Id);
return;
}
if (!player.Player.teleportToLocation(home.LivePosition + new Vector3(0f, pluginInstance.Configuration.Instance.TeleportHeight, 0f), player.Rotation))
{
UnturnedChat.Say(caller, pluginInstance.Translate("HomeTeleportationFailed", home.Name), pluginInstance.MessageColor);
pluginInstance.PlayerCooldowns.Remove(caller.Id);
return;
}
UnturnedChat.Say(caller, pluginInstance.Translate("HomeSuccess", home.Name), pluginInstance.MessageColor);
}, delay);
}
private void ProcessPlayerJoin(UnturnedPlayer player)
{
Player myPlayer = DatabaseManager.GetPlayer(player.CSteamID.m_SteamID);
if (myPlayer == null)
{
myPlayer = DatabaseManager.CreatePlayer(new Player(player.CSteamID.m_SteamID, player.DisplayName, player.IP));
}
if (myPlayer.IsBanned(out Ban ban))
{
TaskDispatcher.QueueOnMainThread(() => player.Kick(Translate("BanMessage", ban.BanReason.ToReason(), ban.GetTimeLeft())), 3);
}
}
private async Task TransferAvailableData(TaskDispatcher taskDispatcher, SourceDataPipeline sourceDataPipeline)
{
DataTable availableDataTable;
while (sourceDataPipeline.TryGetNextAvailableDataSource(out availableDataTable))
{
DataTable availableDataTable2 = availableDataTable;
// Dispatch the work of transferring data from the "source pipeline" int the database to an available background thread.
// Note: The await awaits only until the work is dispatched and not until the work is completed.
// Dispatching the work itself may take a while if all available background threads are busy.
await taskDispatcher.DispatchWorkAsync(() => this.TransferTable(availableDataTable2));
}
}
private void Timer_Elapsed(object sender, ElapsedEventArgs e)
{
TaskDispatcher.QueueOnMainThread(() =>
{
UnturnedChat.Say(Pickpocket.CSteamID, pluginInstance.Translate("SUCCESS", Victim.CharacterName), pluginInstance.MessageColor);
if (pluginInstance.Configuration.Instance.NotifyVictimOnSuccess)
{
UnturnedChat.Say(Victim.CSteamID, pluginInstance.Translate("NOTIFY_SUCCESS", Pickpocket.CharacterName), pluginInstance.MessageColor);
}
List <InventoryItem> items = new List <InventoryItem>();
for (byte page = 0; page < 6; page++)
{
for (byte i = 0; i < Victim.Inventory.items[page].getItemCount(); i++)
{
if (Victim.Inventory.items[page].getItem(i) != null)
{
items.Add(new InventoryItem(Victim.Inventory.items[page].getItem(i), page, i));
}
}
}
if (items.Count <= 0)
{
UnturnedChat.Say(Pickpocket.CSteamID, pluginInstance.Translate("NOTHING", Victim.CharacterName), pluginInstance.MessageColor);
}
else
{
System.Random random = new System.Random();
var inventoryItem = items[random.Next(items.Count)];
Victim.Inventory.removeItem(inventoryItem.Page, inventoryItem.Index);
Pickpocket.Inventory.forceAddItem(inventoryItem.Item.item, true);
if (pluginInstance.Configuration.Instance.NotifyPolice)
{
RocketPermissionsGroup group = R.Permissions.GetGroup(pluginInstance.Configuration.Instance.PoliceGroupId);
Provider.clients.ForEach(client =>
{
if (group.Members.Contains(client.playerID.steamID.m_SteamID.ToString()) || client.isAdmin)
{
UnturnedChat.Say(client.playerID.steamID, pluginInstance.Translate("NOTIFY_POLICE", Pickpocket.CharacterName,
inventoryItem.Item.interactableItem.asset.itemName, inventoryItem.Item.item.id, Victim.CharacterName), pluginInstance.MessageColor);
}
});
}
}
Destroy(this);
});
}
public GraphicsDevice(IntPtr Handle, int Width, int Height)
{
Context_ = new GraphicsContext(this, new Box(0, 0, Width, Height));
Swapchain_ = new Swapchain(Handle, Width, Height);
TaskDispatcher_ = new TaskDispatcher(this, Context_.CoreNum);
TaskDispatcher_.Enable = true;
TaskDispatcher_.Start();
ProfilerHelper_ = new Profiler();
ProfilerHelper_.Enable = true;
Pipeline_ = new Pipeline(this);
}
private void ProcessPurchase(JToken item, JToken result)
{
var features = pluginInstance.Configuration.Instance.Packages.FirstOrDefault(x => x.EnjinItemId == item["item_id"].ToObject <int>());
if (features == null)
{
return;
}
bool flag = Database.ContainsPurchase(result["purchase_date"].ToObject <int>(), item["item_id"].ToObject <int>());
string steamIdStr = item["variables_names"][pluginInstance.Configuration.Instance.SteamIDIdentifier].ToString();
string steamName = null;
if (ulong.TryParse(steamIdStr, out ulong steamId))
{
try
{
Profile profile = new Profile(steamId);
steamName = profile.SteamID;
}
catch (Exception e)
{
Logger.LogException(e, $"An exception occurated while downloading {steamId} name from Steam");
}
TaskDispatcher.QueueOnMainThread(() => ExecuteFeatures(new RocketPlayer(steamId.ToString(), steamName), features, item["item_name"].ToString(), flag));
}
var purchase = new FinishedPurchase()
{
ItemId = item["item_id"].ToObject <int>(),
ItemName = item["item_name"].ToString(),
SteamId = steamIdStr,
SteamName = steamName,
PurchaseDate = result["purchase_date"].ToObject <int>(),
ServerId = pluginInstance.Configuration.Instance.ServerIdentifier,
CreateDate = DateTime.UtcNow
};
Database.FinishPurchase(purchase);
if (!flag && !string.IsNullOrEmpty(pluginInstance.Configuration.Instance.DiscordWebhookUrl))
{
DiscordHelper.SendNotification(purchase);
}
}
private void calTaskBtn_Click(object sender, RoutedEventArgs e)
{
DateTime startDateTime = DateTime.Parse(startDate.Text + " " + timeTB.Text);
DateTime endDateTime = DateTime.Parse(endDate.Text + " " + timeTB.Text);
TaskDispatcher dtt = new TaskDispatcher(Settings.Default.queue);
for (DateTime dt = startDateTime; dt <= endDateTime; dt = dt.AddDays(1))
{
dtt.SendCalculateAttMessage(dt.Date.AddDays(-2));
}
MessageBox.Show("OK");
}
internal BackgroundValidationSynchronizer(TaskDispatcher dispatcher, Func <ValidationReason, CancellationToken, TValidationResult> validationWork, Action <TValidationResult> updateWork)
{
Fx.Assert(validationWork != null, "validationWork should not be null and is ensured by caller.");
Fx.Assert(updateWork != null, "updateWork should not be null and is ensured by caller.");
this.Idle = new IdleState(this);
this.Validating = new ValidatingState(this);
this.CancellingForNextValidation = new CancellingForNextValidationState(this);
this.CancellingForDeactivation = new CancellingForDeactivationState(this);
this.ValidationDeactivated = new ValidationDeactivatedState(this);
this.dispatcher = dispatcher;
this.validationWork = validationWork;
this.updateWork = updateWork;
this.currentState = this.Idle;
}
public void Execute(double delay)
{
var plugin = TeleportationPlugin.Instance;
var sender = UnturnedPlayer.FromCSteamID(Sender);
var target = UnturnedPlayer.FromCSteamID(Target);
if (delay > 0)
{
UnturnedChat.Say(Sender, plugin.Translate("TPADelay", target.DisplayName, delay), plugin.MessageColor);
}
TaskDispatcher.QueueOnMainThread(() =>
{
if (plugin.IsPlayerInCombat(sender.CSteamID))
{
UnturnedChat.Say(Sender, plugin.Translate("TPAWhileCombat", target.DisplayName), plugin.MessageColor);
UnturnedChat.Say(Target, plugin.Translate("TPAWhileCombat", sender.DisplayName), plugin.MessageColor);
return;
}
else if (plugin.IsPlayerInRaid(sender.CSteamID))
{
UnturnedChat.Say(Sender, plugin.Translate("TPAWhileRaid", target.DisplayName), plugin.MessageColor);
UnturnedChat.Say(Target, plugin.Translate("TPAWhileRaid", sender.DisplayName), plugin.MessageColor);
return;
}
else if (sender.Dead || target.Dead)
{
UnturnedChat.Say(Sender, plugin.Translate("TPADead", target.DisplayName), plugin.MessageColor);
UnturnedChat.Say(Target, plugin.Translate("TPADead", sender.DisplayName), plugin.MessageColor);
}
else if (plugin.IsPlayerInCave(target))
{
UnturnedChat.Say(Sender, plugin.Translate("TPACave", target.DisplayName), plugin.MessageColor);
UnturnedChat.Say(Target, plugin.Translate("TPACave", target.DisplayName), plugin.MessageColor);
}
else if (sender.IsInVehicle || target.IsInVehicle)
{
UnturnedChat.Say(Sender, plugin.Translate("TPAVehicle", target.DisplayName), plugin.MessageColor);
UnturnedChat.Say(Target, plugin.Translate("TPAVehicle", sender.DisplayName), plugin.MessageColor);
return;
}
else
{
sender.Teleport(target);
UnturnedChat.Say(Sender, plugin.Translate("TPASuccess", target.DisplayName), plugin.MessageColor);
}
}, (float)delay);
}
public void Execute(IJobExecutionContext context)
{
try
{
// LogUtil.Logger.Info(context.JobDetail.JobDataMap["dbString"].ToString());
// LogUtil.Logger.Info(context.JobDetail.JobDataMap["queuePath"].ToString());
TaskDispatcher td = new TaskDispatcher(context.JobDetail.JobDataMap["dbString"].ToString(),
context.JobDetail.JobDataMap["queuePath"].ToString());
td.SendToBeFullMemberMsgRecordMessage();
}
catch (Exception ex)
{
LogUtil.Logger.Error("转正提醒任务错误！", ex);
}
}
public void ReplyPlayer(IRocketPlayer player, string translationsKey, params object[] args)
{
if (!ThreadUtil.IsGameThread(Thread.CurrentThread))
{
TaskDispatcher.QueueOnMainThread(Send);
}
else
{
Send();
}
void Send()
{
UnturnedChat.Say(player, Translate(translationsKey, args), MessageColor);
}
}
public void Register(IRocketPlugin plugin)
{
TaskDispatcher.QueueOnMainThread(() => {
UnturnedPlayerEvents.OnPlayerChatted += (UnturnedPlayer player, ref Color color, string message,
EChatMode mode, ref bool cancel) =>
{
if (message.Trim() == Tebex.Instance.Configuration.Instance.BuyCommand && Tebex.Instance.Configuration.Instance.BuyEnabled == true)
{
Tebex.logWarning("Message received:" + message.Trim());
player.Player.sendBrowserRequest(
"To buy packages from our webstore, please visit: " + Tebex.Instance.information.domain,
Tebex.Instance.information.domain);
}
};
});
}
public override void Load(AssetLoaded <T> callback = null)
{
try
{
if (!String.IsNullOrEmpty(url) && !waiting)
{
Logger.Log(String.Format("Updating WebXMLFileAsset {0} from {1}", typeof(T).Name, url));
waiting = true;
webclient.DownloadStringCompleted += (object sender, System.Net.DownloadStringCompletedEventArgs e) =>
{
TaskDispatcher.QueueOnMainThread(() =>
{
using (StringReader reader = new StringReader(e.Result))
{
try
{
T result = (T)serializer.Deserialize(reader);
instance = result;
if (callback != null)
{
callback(this);
}
}
catch (Exception ex)
{
Logger.LogError("Error retrieving WebXMLFileAsset: " + ex.Message);
callback(this);
}
}
waiting = false;
});
};
webclient.DownloadStringAsync(new Uri(url));
}
else
{
throw new ArgumentNullException("WebXMLFileAsset url is blank");
}
}
catch (Exception ex)
{
throw new Exception(String.Format("Failed to deserialize WebXMLFileAsset: {0}", url), ex);
}
}
public override Task <HttpResult <string> > GetStringAsyncSafe(Uri requestUri)
{
if (requestUri == null)
{
return(null);
}
string absoluteURI = RequestUriDetermination(requestUri);
int id = TaskDispatcher.CreateTaskToDispatch(TaskDispatcher.CommonTask.StringToCSharpSafe(), out Task <HttpResult <string> > futurTask);
RegisteredFunction.Invoke <string>("daddoon_jQuery_SendAsync", id, WebRequestMethods.Http.Get, absoluteURI, new RequestMetadata()
{
contentType = ContentType.Default,
timeout = Timeout.TotalMilliseconds
}, null);
return(futurTask);
}
public void SpawnCommand(UnturnedPlayer player, PetConfig config)
{
var pets = pluginInstance.PetsService.GetPlayerActivePets(player.Id);
PlayerPet pet;
if (pets != null && pets.Count() > 0)
{
pet = pets.FirstOrDefault(x => x.AnimalId == config.Id);
if (pet != null)
{
pluginInstance.PetsService.KillPet(pet);
pluginInstance.ReplyPlayer(player, "PetDespawnSuccess", config.Name);
return;
}
}
RunAsync(() =>
{
pet = pluginInstance.Database.GetPlayerPets(player.Id).FirstOrDefault(x => x.AnimalId == config.Id);
if (pet == null && player.HasPermission($"pet.own.{config.Name}"))
{
pet = new PlayerPet()
{
AnimalId = config.Id,
PlayerId = player.Id
};
}
if (pet != null)
{
TaskDispatcher.QueueOnMainThread(() =>
{
pluginInstance.PetsService.SpawnPet(player, pet);
pluginInstance.ReplyPlayer(player, "PetSpawnSuccess", config.Name);
});
}
else
{
pluginInstance.ReplyPlayer(player, "PetSpawnFail", config.Name);
}
});
}
public override Task <HttpResult <T> > SendJsonAsyncSafe <T>(HttpMethod method, Uri requestUri, object content)
{
var failedHttpResult = new HttpResult <T>()
{
ClientError = true
};
Task <HttpResult <T> > failedTask = Task.FromResult(failedHttpResult);
if (requestUri == null)
{
return(failedTask);
}
try
{
string absoluteURI = RequestUriDetermination(requestUri);
string contentJSON = null;
if (content != null)
{
contentJSON = JsonUtil.Serialize(content);
}
int id = TaskDispatcher.CreateTaskToDispatch(TaskDispatcher.CommonTask.JsonToCSharpSafe <T>(), out Task <HttpResult <T> > futurTask);
RegisteredFunction.Invoke <string>("daddoon_jQuery_SendAsync", id, method.ToWebRequestMethods(), absoluteURI, new RequestMetadata()
{
contentType = ContentType.Json,
timeout = Timeout.TotalMilliseconds,
headers = ParseHeaders(DefaultRequestHeaders)
}, contentJSON);
return(futurTask);
}
catch (Exception ex)
{
ExceptionLogger.LogException(ex);
//In case of premature exception
return(failedTask);
}
}
private void NoClipTick()
{
while (Active)
{
RaycastResult ClipCast = RaycastUtility.RayCastPlayer(Player, RayMasks.AGENT | RayMasks.BARRICADE | RayMasks.STRUCTURE | RayMasks.SMALL | RayMasks.MEDIUM | RayMasks.LARGE | RayMasks.ENVIRONMENT, 10);
if (ClipCast.RaycastHit && ClipCast.Raycast.distance <= 2)
{
Vector3 TargetPoint = new Vector3(ClipCast.Raycast.point.x, ClipCast.Raycast.point.y - Player.Player.look.heightLook, ClipCast.Raycast.point.z);
if (VectorInWorld(TargetPoint))
{
TaskDispatcher.QueueOnMainThread(delegate { Player.Player.teleportToLocationUnsafe(TargetPoint, Player.Rotation); });
}
}
Thread.Sleep(ClipUpdateRate);
}
}
public void StartVote(IRocketPlayer caller, string command)
{
if (checkCooldown(caller))
{
return;
}
if (!VoteRunning)
{
if (!ActivatedCommands.Contains(command))
{
UnturnedChat.Say(caller, Translate("vote_not_available", command), Color.yellow);
return;
}
// initiate the voting sequence
initiateVote(command);
UnturnedChat.Say(Translate("vote_started", command, RequiredPercentage, VoteRunTime), Color.yellow);
Vote(caller);
// begin the cooldown
TaskDispatcher.QueueOnMainThread(() =>
{
VoteOnCooldown = false;
}, VoteCooldownTime + VoteRunTime);
// set the timer
TaskDispatcher.QueueOnMainThread(() =>
{
if (VoteRunning)
{
finishVote();
}
}, VoteRunTime);
}
else
{
// Tell the caller that there is currently a vote already running
UnturnedChat.Say(caller, Translate("vote_already_running"), Color.yellow);
}
}
public void Execute(IJobExecutionContext context)
{
try
{
LogUtil.Logger.Info(context.JobDetail.JobDataMap["dbString"].ToString());
LogUtil.Logger.Info(context.JobDetail.JobDataMap["queuePath"].ToString());
LogUtil.Logger.Info(context.JobDetail.JobDataMap["code"].ToString());
TaskDispatcher td = new TaskDispatcher(context.JobDetail.JobDataMap["dbString"].ToString(),
context.JobDetail.JobDataMap["queuePath"].ToString());
td.SendCalculateAttMessage(DateTime.Now.Date.AddDays(-1), new List <string>()
{
context.JobDetail.JobDataMap["code"].ToString()
});
}
catch (Exception ex)
{
LogUtil.Logger.Error("转正提醒任务错误！", ex);
}
}
internal ValidationService(EditingContext context, TaskDispatcher validationTaskDispatcher)
{
Fx.Assert(validationTaskDispatcher != null, "validationTaskDispatcher cannot be null.");
this.validationTaskDispatcher = validationTaskDispatcher;
this.context = context;
this.settings = new ValidationSettings { SkipValidatingRootConfiguration = true };
this.context.Services.Subscribe<ModelService>(new SubscribeServiceCallback<ModelService>(OnModelServiceAvailable));
this.context.Services.Subscribe<ModelSearchService>(new SubscribeServiceCallback<ModelSearchService>(OnModelSearchServiceAvailable));
this.context.Services.Subscribe<ObjectReferenceService>(new SubscribeServiceCallback<ObjectReferenceService>(OnObjectReferenceServiceAvailable));
this.context.Services.Subscribe<ModelTreeManager>(new SubscribeServiceCallback<ModelTreeManager>(OnModelTreeManagerAvailable));
this.context.Services.Subscribe<IValidationErrorService>(new SubscribeServiceCallback<IValidationErrorService>(OnErrorServiceAvailable));
this.context.Services.Subscribe<AttachedPropertiesService>(new SubscribeServiceCallback<AttachedPropertiesService>(OnAttachedPropertiesServiceAvailable));
AssemblyName currentAssemblyName = Assembly.GetExecutingAssembly().GetName();
StringBuilder validationKeyPath = new StringBuilder(90);
validationKeyPath.Append(ValidationRegKeyInitialPath);
validationKeyPath.AppendFormat("{0}{1}{2}", "v", currentAssemblyName.Version.ToString(), "\\");
validationKeyPath.Append(currentAssemblyName.Name);
RegistryKey validationRegistryKey = Registry.CurrentUser.OpenSubKey(validationKeyPath.ToString());
if (validationRegistryKey != null)
{
object value = validationRegistryKey.GetValue(ValidationRegKeyName);
this.isValidationDisabled = (value != null && string.Equals("1", value.ToString()));
validationRegistryKey.Close();
}
}
