/// <summary> /// 向前台发送媒体带参消息 /// </summary> /// <typeparam name="T">消息参数的类型</typeparam> /// <param name="type">媒体消息的类型</param> /// <param name="message">消息参数</param> public static void SendMediaMessageToForeground <T>(MediaMessageTypes type, T message) { var payload = new ValueSet(); payload.Add(MessageService.MessageType, type.ToString()); payload.Add(MessageService.MessageBody, serializeService.Serialize(message)); BackgroundMediaPlayer.SendMessageToForeground(payload); }
public void SerializationCanSerializeAnonymousTypes() { // Arrange var obj = new { GhostTownsCount = 5 }; // Act var actual = _service.Serialize(obj); // Assert Assert.Contains("ghost_towns_count", actual); }
public void OnGet([FromRoute] string title) { ExistingPostKey = null; if (string.IsNullOrWhiteSpace(title)) { PostInEdit = new Post().EnsureValidKey(); SubmitButtonText = "Publish"; return; } var response = _blogService.GetPostByUrlFriendlyTitle(title); PostInEdit = response?.Post; if (PostInEdit == null) { SubmitButtonText = "Publish"; PostInEdit = new Post().EnsureValidKey(); } else { ExistingPostKey = PostInEdit.Key; ExistingPostUrlFriendlyTitle = PostInEdit.UrlFriendlyTitle; SubmitButtonText = "Update"; AllTagsInText = _serializationService .Serialize(response.AllTags is null ? new string[] { } : response.AllTags); PostImagesInText = _serializationService.Serialize(PostInEdit.Images ?? new List <PostImage>()); } }
public async Task <bool> ExportOpmlFeedsAsync(Stream stream) { var opml = new Opml { Head = new OpmlHead { Title = "Feeds from myFeed App" } }; var categories = await _categoryManager.GetAllAsync(); var outlines = categories.Select(x => new OpmlOutline { ChildOutlines = x.Channels .Select(i => new { Entity = i, Uri = new Uri(i.Uri) }) .Select(y => new OpmlOutline { HtmlUrl = $"{y.Uri.Scheme}://{y.Uri.Host}", XmlUrl = y.Uri.ToString(), Title = y.Uri.Host, Text = y.Uri.Host, Version = "rss", Type = "rss" }) .ToList(), Title = x.Title, Text = x.Title }); opml.Body = new List <OpmlOutline>(outlines); if (stream == null) { return(false); } _serializationService.Serialize(opml, stream); return(true); }
public IHttpResult <TResult> SendPostRequest <TResult, TInput>(string requestUrl, TInput obj) { try { var serializedObject = _serializationService.Serialize(obj); var data = Encoding.UTF8.GetBytes(serializedObject); var webRequest = CreateHttpRequest(requestUrl, HttpMethodType.Post); using (var requestStream = webRequest.GetRequestStream()) { requestStream.Write(data, 0, data.Length); } var webResponse = webRequest.GetResponse(); using (var responseStream = webResponse.GetResponseStream()) { string responseStr = string.Empty; if (responseStream != null) { responseStr = new StreamReader(responseStream).ReadToEnd(); } var responseObj = _serializationService.Deserialize <TResult>(responseStr); return(new HttpResult <TResult>(responseObj, null)); } } catch (WebException exception) { var error = string.Format("Message:{0}, Url:{1}", exception.Message, requestUrl); return(new HttpResult <TResult>(error)); } }
public void TestCollection() { Base a = new Base(); Base b = new Base(); Base c = new Base(); Base d = new Base(); CollectionDerived e = new CollectionDerived() { Child = a, Parents = new List <Base>() { a, b, c, d } }; TypeConfiguration.TrustedTypes = TypeMatch.Assembly(typeof(SerializerTests).Assembly); ISerializationService serializer = Container.Resolve <ISerializationService>(); string json = serializer.Serialize(e); Console.WriteLine(json); Base newE = serializer.Deserialize <Base>(json); Assert.IsInstanceOfType(newE, typeof(CollectionDerived)); var listE = (CollectionDerived)newE; Assert.IsNotNull(listE.Parents); Assert.AreEqual(4, listE.Parents.Count()); Assert.AreEqual(listE.Child, listE.Parents.ElementAt(0)); }
public async Task <bool> WriteCookieData(CookieContainer container) { try { var cookies = container.GetCookies(new Uri("https://www.flashback.org/")).Cast <Cookie>().ToList(); var dataToBeSecured = _serializationService.Serialize(cookies); var buffer = await Protect(dataToBeSecured); var storageFolder = ApplicationData.Current.LocalFolder; var sampleFile = await storageFolder.CreateFileAsync(COOKIEFILE, CreationCollisionOption.ReplaceExisting); var stream = await sampleFile.OpenAsync(FileAccessMode.ReadWrite); using (var outputStream = stream.GetOutputStreamAt(0)) { using (var dataWriter = new DataWriter(outputStream)) { dataWriter.WriteBuffer(buffer); await dataWriter.StoreAsync(); await outputStream.FlushAsync(); } } stream.Dispose(); return(true); } catch (Exception e) { Debug.WriteLine("Fel vid skrivande av cookies: " + e.Message); return(false); } }
protected async Task SendStatusAsync(long jobId, int status, CancellationToken cancellationToken, int numOfLearners = -1) { await client.PostAsync( _endPointUrl, new StringContent(_serializationService.Serialize(new JobStatusDto(jobId, status, numOfLearners)), Encoding.UTF8, "application/json"), cancellationToken); }
private void ProcessItem(NWPlayer oPC, NWItem item, Dictionary <string, PCMigrationItem> itemMap, List <int> stripItemList) { string resref = item.Resref; int quantity = item.StackSize; int baseItemTypeID = item.BaseItemType; PCMigrationItem migrationItem = itemMap[resref]; if (itemMap.ContainsKey(resref)) { item.Destroy(); if (!string.IsNullOrWhiteSpace(migrationItem.NewResref)) { NWItem newItem = NWItem.Wrap(_.CreateItemOnObject(migrationItem.NewResref, oPC.Object, quantity)); if (!newItem.Possessor.IsValid) { PCOverflowItem overflow = new PCOverflowItem { ItemResref = newItem.Resref, ItemTag = newItem.Tag, ItemName = newItem.Name, ItemObject = _serialization.Serialize(newItem), PlayerID = oPC.GlobalID }; _db.PCOverflowItems.Add(overflow); _db.SaveChanges(); newItem.Destroy(); } } } else if (stripItemList.Contains(baseItemTypeID)) { _item.StripAllItemProperties(item); } }
public void Save(UserSettings userSettings) { _cachedUserSettings = userSettings; var serializedData = _serializationService.Serialize(_cachedUserSettings); _localFileService.Save(serializedData.Value, _userSettingsPath); }
public async Task <bool> ExportOpmlFeedsAsync(Stream stream) { // Initialize new Opml instance and read categories from db. var opml = new Opml { Head = new OpmlHead { Title = "Feeds from myFeed App" } }; var categories = await _categoriesRepository.GetAllAsync(); var outlines = categories.Select(x => new OpmlOutline { ChildOutlines = x.Channels .Select(i => new { Entity = i, Uri = new Uri(i.Uri) }) .Select(y => new OpmlOutline { HtmlUrl = $"{y.Uri.Scheme}://{y.Uri.Host}", XmlUrl = y.Uri.ToString(), Title = y.Uri.Host, Text = y.Uri.Host, Version = "rss", Type = "rss" }) .ToList(), Title = x.Title, Text = x.Title }); // Fill opml with categories. opml.Body = new List <OpmlOutline>(outlines); _serializationService.Serialize(opml, stream); return(true); }
public void TestUntrustedOut() { Derived d = new Derived(); TypeConfiguration.TrustedTypes = TypeMatch.Type <Base>(); ISerializationService serializer = Container.Resolve <ISerializationService>(); Assert.ThrowsException <TypeMatchException>(() => serializer.Serialize(d)); }
public bool Run(params object[] args) { NWPlaceable terminal = Object.OBJECT_SELF; int bankID = terminal.GetLocalInt("BANK_ID"); if (bankID <= 0) { return(false); } NWPlayer player = _.GetLastDisturbed(); NWItem item = _.GetInventoryDisturbItem(); int disturbType = _.GetInventoryDisturbType(); int itemCount = terminal.InventoryItems.Count(); int itemLimit = terminal.GetLocalInt("BANK_LIMIT"); if (itemLimit <= 0) { itemLimit = 20; } Data.Entity.Bank bank = _data.Single <Data.Entity.Bank>(x => x.ID == bankID); if (disturbType == INVENTORY_DISTURB_TYPE_ADDED) { if (itemCount > itemLimit) { _item.ReturnItem(player, item); player.SendMessage(_color.Red("No more items can be placed inside.")); } else { BankItem itemEntity = new BankItem { ItemName = item.Name, ItemTag = item.Tag, ItemResref = item.Resref, ItemID = item.GlobalID.ToString(), ItemObject = _serialization.Serialize(item), BankID = bank.ID, PlayerID = player.GlobalID, DateStored = DateTime.UtcNow }; _data.SubmitDataChange(itemEntity, DatabaseActionType.Insert); } } else if (disturbType == INVENTORY_DISTURB_TYPE_REMOVED) { var record = _data.Get <BankItem>(item.GlobalID); _data.SubmitDataChange(record, DatabaseActionType.Delete); } player.SendMessage(_color.White("Item Limit: " + (itemCount > itemLimit ? itemLimit : itemCount) + " / ") + _color.Red("" + itemLimit)); return(true); }
public async Task <HttpResponseMessage> PostAsync <T>(Uri requestUri, T payload) where T : class { var requestMessage = new HttpRequestMessage(HttpMethod.Post, requestUri); var content = new StringContent(serialization.Serialize(payload)); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); requestMessage.Content = content; return(await MakeRequestAsync(requestMessage)); }
public void Write <T>(string key, T value) { var result = _serializationService.Serialize(value); if (EnableCompression) { result = result.Compress(); } _adapter.WriteString(key, result); }
public void SaveConfigData <X, T>(ConfigFile <X, T> config, T data, string pathOverride = null) where X : class where T : class { var path = pathOverride ?? $@"{_userSettingsService.Get().GameInstallLocation}\{config.GamePath}"; var xmlclasses = _mapperFactory.GetMapper(config).Convert(data); var xml = _serializationService.Serialize(data); _fileStorageService.Save(xml.Value, path); }
private void TestValue <T>(T value) { TypeConfiguration.TrustedTypes = TypeMatch.Assembly(typeof(SerializerTests).Assembly); ISerializationService serializer = Container.Resolve <ISerializationService>(); string json = serializer.Serialize(value); Console.WriteLine(json); T newVal = serializer.Deserialize <T>(json); Assert.AreEqual(value, newVal, $"Value type serialization failed on {typeof(T).Name} native serializer."); }
/// <summary> /// Сохранение структуры в файл. /// </summary> private void SaveStruct() { if (_saveFileDialog.ShowDialog() != true) { return; } using (var stream = new FileStream(_saveFileDialog.FileName, FileMode.Create, FileAccess.Write)) { _serializationService.Serialize(Root, stream); } }
public void OnChestDisturbed(NWPlaceable oChest) { int containerID = oChest.GetLocalInt("STORAGE_CONTAINER_ID"); if (containerID <= 0) { return; } NWPlayer oPC = NWPlayer.Wrap(_.GetLastDisturbed()); NWItem oItem = NWItem.Wrap(_.GetInventoryDisturbItem()); int disturbType = _.GetInventoryDisturbType(); int itemCount = CountItems(oChest); int itemLimit = oChest.GetLocalInt("STORAGE_CONTAINER_ITEM_LIMIT"); if (itemLimit <= 0) { itemLimit = 20; } StorageContainer entity = _db.StorageContainers.Single(x => x.StorageContainerID == containerID); if (disturbType == INVENTORY_DISTURB_TYPE_ADDED) { if (itemCount > itemLimit) { ReturnItem(oPC, oItem); oPC.SendMessage(_color.Red("No more items can be placed inside.")); } else { StorageItem itemEntity = new StorageItem { ItemName = oItem.Name, ItemTag = oItem.Tag, ItemResref = oItem.Resref, GlobalID = oItem.GlobalID, ItemObject = _serialization.Serialize(oItem), StorageContainerID = entity.StorageContainerID }; entity.StorageItems.Add(itemEntity); _db.SaveChanges(); } } else if (disturbType == INVENTORY_DISTURB_TYPE_REMOVED) { var record = _db.StorageItems.Single(x => x.GlobalID == oItem.GlobalID); _db.StorageItems.Remove(record); _db.SaveChanges(); } oPC.SendMessage(_color.White("Item Limit: " + itemCount + " / ") + _color.Red("" + itemLimit)); }
public void Send(IMessage message) { try { var message_ = _serializationService.Serialize(message); _serialPort.Write(message_, 0, message_.Length); } catch (Exception e) { RaiseError(e.Message); } }
/// <inheritdoc/> public bool Send(IMessage message) { lock (_sendLock) { Debug.WriteLine("[CommunicationService] Send"); _sendRetryCount = 0; while (_sendRetryCount < _sendRetryMax) { try { _waitingAck = true; var messageBytes = _serializationService.Serialize(message, _messageRevision); _serialPort.Write(messageBytes, 0, messageBytes.Length); Debug.WriteLine($"[CommunicationService] Message sent: {message.GetType()} Revision: {_messageRevision}"); _watch.Restart(); _heartbeatWatch.Restart(); } catch (Exception e) { RaiseError(e.Message); return(false); } while (_waitingAck) { if (_watch.Elapsed.TotalMilliseconds > _ackTimeout) { Debug.WriteLine($"[CommunicationService] ACK timeout Revision: {_messageRevision}"); break; } Thread.Sleep(5); } _messageRevision++; if (!_waitingAck) { return(true); } _sendRetryCount++; Debug.WriteLine($"[CommunicationService] Send retry... {_sendRetryCount}"); } RaiseError($"ACK not received for revision: {_messageRevision}"); return(false); } }
protected bool TryWrite <T>(string key, T value) { try { var result = _serializer.Serialize(value); _container.Values[key] = result.Compress(); return(true); } catch { return(false); } }
public void ExplicitValueSerialize() { Vector2 vector = new Vector2(10, 40); TypeConfiguration.TrustedTypes = TypeMatch.Type <Vector2>(); ISerializationService serializer = Container.Resolve <ISerializationService>(); string json = serializer.Serialize(vector); Console.WriteLine(json); Vector2 newVector = serializer.Deserialize <Vector2>(json); Assert.AreEqual(vector, newVector); }
public bool Run(params object[] args) { NWPlayer oPC = NWPlayer.Wrap(_.GetLastDisturbed()); NWItem item = NWItem.Wrap(_.GetInventoryDisturbItem()); NWPlaceable container = NWPlaceable.Wrap(Object.OBJECT_SELF); int disturbType = _.GetInventoryDisturbType(); int structureID = container.GetLocalInt("STRUCTURE_TEMP_STRUCTURE_ID"); PCTerritoryFlagsStructure entity = _structure.GetPCStructureByID(structureID); int itemCount = container.InventoryItems.Count; string itemResref = item.Resref; if (disturbType == INVENTORY_DISTURB_TYPE_ADDED) { if (itemCount > entity.StructureBlueprint.ItemStorageCount) { ReturnItem(oPC, item); oPC.SendMessage(_color.Red("No more items can be placed inside.")); } // Only specific types of items can be stored in resource bundles else if (!string.IsNullOrWhiteSpace(entity.StructureBlueprint.ResourceResref) && itemResref != entity.StructureBlueprint.ResourceResref) { ReturnItem(oPC, item); oPC.SendMessage(_color.Red("That item cannot be stored here.")); } else { PCTerritoryFlagsStructuresItem itemEntity = new PCTerritoryFlagsStructuresItem { ItemName = item.Name, ItemResref = itemResref, ItemTag = item.Tag, PCStructureID = entity.PCTerritoryFlagStructureID, GlobalID = item.GlobalID, ItemObject = _serialization.Serialize(item) }; entity.PCTerritoryFlagsStructuresItems.Add(itemEntity); _structure.SaveChanges(); } } else if (disturbType == INVENTORY_DISTURB_TYPE_REMOVED) { _structure.DeleteContainerItemByGlobalID(item.GlobalID); } oPC.SendMessage(_color.White("Item Limit: " + itemCount + " / ") + _color.Red(entity.StructureBlueprint.ItemStorageCount.ToString())); return(true); }
/// <summary>Serializes an object and write to file in specified storage strategy</summary> /// <typeparam name="T">Specified type of object to serialize</typeparam> /// <param name="key">Path to the file in storage</param> /// <param name="value">Instance of object to be serialized and written</param> /// <param name="location">Location storage strategy</param> public async Task <bool> WriteFileAsync <T>(string key, T value, StorageStrategies location = StorageStrategies.Local, CreationCollisionOption option = CreationCollisionOption.ReplaceExisting) { // create file var file = await CreateFileAsync(key, location, option); // convert to string var serializedValue = _serialization.Serialize(value); // save string to file await FileIO.WriteTextAsync(file, serializedValue); // result return(await FileExistsAsync(key, location)); }
//[Obsolete] public static bool TryWrite <T>(this ApplicationDataContainer container, string key, T value, bool compress = true, ISerializationService serializer = null) { try { serializer = serializer ?? GetDefaultSerializer(); var result = serializer.Serialize(value); container.Values[key] = compress ? result.Compress() : result; return(true); } catch { return(false); } }
public bool Run(params object[] args) { NWPlayer oPC = (_.GetLastDisturbed()); NWItem item = (_.GetInventoryDisturbItem()); NWPlaceable container = (Object.OBJECT_SELF); int disturbType = _.GetInventoryDisturbType(); var structureID = new Guid(container.GetLocalString("PC_BASE_STRUCTURE_ID")); var structure = _data.Single <PCBaseStructure>(x => x.ID == structureID); var baseStructure = _data.Get <BaseStructure>(structure.BaseStructureID); int itemLimit = baseStructure.Storage + structure.StructureBonus; int itemCount = container.InventoryItems.Count(); string itemResref = item.Resref; if (disturbType == INVENTORY_DISTURB_TYPE_ADDED) { if (itemCount > itemLimit) { ReturnItem(oPC, item); oPC.SendMessage(_color.Red("No more items can be placed inside.")); } else if (item.BaseItemType == BASE_ITEM_GOLD) { ReturnItem(oPC, item); oPC.SendMessage(_color.Red("Credits cannot be placed inside.")); } else { PCBaseStructureItem itemEntity = new PCBaseStructureItem { ItemName = item.Name, ItemResref = itemResref, ItemTag = item.Tag, PCBaseStructureID = structureID, ItemGlobalID = item.GlobalID.ToString(), ItemObject = _serialization.Serialize(item) }; _data.SubmitDataChange(itemEntity, DatabaseActionType.Insert); } } else if (disturbType == INVENTORY_DISTURB_TYPE_REMOVED) { var dbItem = _data.Single <PCBaseStructureItem>(x => x.ItemGlobalID == item.GlobalID.ToString()); _data.SubmitDataChange(dbItem, DatabaseActionType.Delete); } oPC.SendMessage(_color.White("Item Limit: " + itemCount + " / ") + _color.Red(itemLimit.ToString())); return(true); }
public void Impound(Guid playerID, NWItem item) { PCImpoundedItem structureImpoundedItem = new PCImpoundedItem { DateImpounded = DateTime.UtcNow, PlayerID = playerID, ItemObject = _serialization.Serialize(item), ItemTag = item.Tag, ItemResref = item.Resref, ItemName = item.Name }; _data.SubmitDataChange(structureImpoundedItem, DatabaseActionType.Insert); }
/// <summary> /// Serializes the value. /// </summary> public static object Serialize(object value) { var lastCacheValue = lastCache; if (ReferenceEquals(lastCacheValue.Item1, value)) { return(lastCacheValue.Item2); } else { var result = instance.Serialize(value); lastCache = new Tuple <object, object>(value, result); return(result); } }
public void TestParameterConstructor() { Base a = new Base(); BaseWithConst b = new BaseWithConst(a, "Fred"); TypeConfiguration.TrustedTypes = TypeMatch.Assembly(typeof(SerializerTests).Assembly); ISerializationService serializer = Container.Resolve <ISerializationService>(); string json = serializer.Serialize(b); Console.WriteLine(json); BaseWithConst newB = serializer.Deserialize <BaseWithConst>(json); Assert.IsInstanceOfType(newB.Child, typeof(Base)); Assert.AreEqual(newB.Name, "Fred"); }