public async Task GetCampaignMatchDetails_IsSerializable(string guid) { var query = new GetCampaignMatchDetails() .ForMatchId(new Guid(guid)); var result = await Global.Session.Query(query); var serializationUtility = new SerializationUtility<CampaignMatch>(); serializationUtility.AssertRoundTripSerializationIsPossible(result); }
public async Task GetCompetitiveSkillRankDesignations_IsSerializable() { var query = new GetCompetitiveSkillRankDesignations() .SkipCache(); var result = await Global.Session.Query(query); var serializationUtility = new SerializationUtility<List<CompetitiveSkillRankDesignation>>(); serializationUtility.AssertRoundTripSerializationIsPossible(result); }
public async Task GetFlexibleStats_IsSerializable() { var query = new GetFlexibleStats() .SkipCache(); var result = await Global.Session.Query(query); var serializationUtility = new SerializationUtility<List<FlexibleStat>>(); serializationUtility.AssertRoundTripSerializationIsPossible(result); }
public async Task GetCustomServiceRecord_IsSerializable(string gamertag) { var query = new GetCustomServiceRecord() .ForPlayer(gamertag); var result = await Global.Session.Query(query); var serializationUtility = new SerializationUtility<CustomServiceRecord>(); serializationUtility.AssertRoundTripSerializationIsPossible(result); }
public async Task GetRequisitionPack_IsSerializable(string guid) { var query = new GetRequisitionPack() .ForRequisitionPackId(new Guid(guid)) .SkipCache(); var result = await Global.Session.Query(query); var serializationUtility = new SerializationUtility<RequisitionPack>(); serializationUtility.AssertRoundTripSerializationIsPossible(result); }
public async Task GetGameVariant_IsSerializable(string guid) { var query = new GetGameVariant() .ForGameVariantId(new Guid(guid)) .SkipCache(); var result = await Global.Session.Query(query); var serializationUtility = new SerializationUtility<GameVariant>(); serializationUtility.AssertRoundTripSerializationIsPossible(result); }
public void Test_NetPayEntityClone() { var now = DateTime.Now; NetPayInfo netpayInfo = new NetPayInfo(); netpayInfo.ApproveTime = now; netpayInfo.ApproveUserSysNo = 1; netpayInfo.ChannelID = "channel"; netpayInfo.CompanyCode = "8601"; netpayInfo.ExternalKey = "externalkey"; netpayInfo.GiftCardPayAmt = 1000; netpayInfo.MasterSoSysNo = 100000; netpayInfo.Note = "note"; netpayInfo.OrderAmt = 1000; netpayInfo.PayAmount = 1000; netpayInfo.PayTypeSysNo = 1; netpayInfo.PointPay = 1000; netpayInfo.PrePayAmt = 1000; netpayInfo.RelatedSoSysNo = 100000; netpayInfo.ReviewedTime = now; netpayInfo.ReviewedUserSysNo = 1; netpayInfo.SOSysNo = 100000; netpayInfo.Source = NetPaySource.Bank; netpayInfo.Status = NetPayStatus.Abandon; netpayInfo.SysNo = 1000; var cloneNetPayInfo = SerializationUtility.DeepClone <NetPayInfo>(netpayInfo); Assert.AreEqual(now, cloneNetPayInfo.ApproveTime); Assert.AreEqual(1, cloneNetPayInfo.ApproveUserSysNo); Assert.AreEqual("channel", cloneNetPayInfo.ChannelID); Assert.AreEqual("8601", cloneNetPayInfo.CompanyCode); Assert.AreEqual("externalkey", cloneNetPayInfo.ExternalKey); Assert.AreEqual(1000, cloneNetPayInfo.GiftCardPayAmt); Assert.AreEqual(100000, cloneNetPayInfo.MasterSoSysNo); Assert.AreEqual("note", cloneNetPayInfo.Note); Assert.AreEqual(1000, cloneNetPayInfo.OrderAmt); Assert.AreEqual(1000, cloneNetPayInfo.PayAmount); Assert.AreEqual(1, cloneNetPayInfo.PayTypeSysNo); Assert.AreEqual(1000, cloneNetPayInfo.PointPay); Assert.AreEqual(1000, cloneNetPayInfo.PrePayAmt); Assert.AreEqual(100000, cloneNetPayInfo.RelatedSoSysNo); Assert.AreEqual(now, cloneNetPayInfo.ReviewedTime); Assert.AreEqual(1, cloneNetPayInfo.ReviewedUserSysNo); Assert.AreEqual(100000, cloneNetPayInfo.SOSysNo); Assert.AreEqual(NetPaySource.Bank, cloneNetPayInfo.Source); Assert.AreEqual(NetPayStatus.Abandon, cloneNetPayInfo.Status); Assert.AreEqual(1000, cloneNetPayInfo.SysNo); }
public void SerializesCustomProperties() { var originalInnerException = new AssertException("User Message"); var originalException = new AfterTestException(originalInnerException); var deserializedException = SerializationUtility.SerializeAndDeserialize(originalException); var deserializedInnerException = Assert.Single(deserializedException.AfterExceptions); Assert.Equal(originalInnerException.Message, deserializedInnerException.Message); var deserializedAssertException = Assert.IsType <AssertException>(deserializedInnerException); Assert.Equal(originalInnerException.UserMessage, deserializedAssertException.UserMessage); }
public void SerializationUtilityCanDeserializeConfigurationNode() { InstrumentationNode instrumentationNode = new InstrumentationNode(); ApplicationNode.AddNode(instrumentationNode); string relativePathToInstrumentationNode = SerializationUtility.CreatePathRelativeToRootNode(instrumentationNode.Path, ApplicationNode.Hierarchy); Assert.IsNotNull(relativePathToInstrumentationNode); InstrumentationNode deserializedInstance = SerializationUtility.DeserializeFromString(relativePathToInstrumentationNode, typeof(InstrumentationNode), ApplicationNode.Hierarchy) as InstrumentationNode; Assert.AreEqual(instrumentationNode, deserializedInstance); }
public ActionResult AjaxAppForCertification() { var request = Request.Form["data"]; var data = SerializationUtility.JsonDeserialize2 <CertificationInfo>(Request.Form["data"]); data.SellerName = CurrUser.SellerName; data.SellerSysNo = CurrUser.SellerSysNo; data.UserID = CurrUser.UserID; data.Status = "I"; data.UserDisplayName = CurrUser.UserDisplayName; StoreService.SaveCertification(data); return(Json(new { Success = true, Message = LanguageHelper.GetText("操作成功") })); }
object DeserializeObject(DataRow data, string columnName) { object byteArrayAsObject = data[columnName]; if (byteArrayAsObject == DBNull.Value) { return(null); } else { return(SerializationUtility.ToObject((byte[])byteArrayAsObject)); } }
public static byte[] ToBytes([NotNull] object target) { #if DEV_MODE && PI_ASSERTATIONS Debug.Assert(!(target is Object)); #endif #if DONT_USE_ODIN_SERIALIZER var jsonString = JsonUtility.ToJson(target); var bytes = Encoding.UTF8.GetBytes(jsonString); return(bytes); #else return(SerializationUtility.SerializeValueWeak(target, DataFormat.Binary)); #endif }
private void HandleObjectPickerEvents() { if (this.picker.IsReadyToClaim && Event.current.type == EventType.Repaint) { var value = this.picker.ClaimObject(); object[] values = new object[this.Property.Tree.WeakTargets.Count]; values[0] = value; for (int j = 1; j < values.Length; j++) { values[j] = SerializationUtility.CreateCopy(value); } this.resolver.QueueAdd(values); } }
public string GetSuplexSecurity(string userName, string uniqueName) { SecurityLoadParameters slp = new SecurityLoadParameters() { ExternalGroupInfo = new ExternalGroupInfo(LdapRoot, true, GlobalExternalGroupsCsv), User = this.GetSuplexUser(userName) }; DataSet ds = _splxApi.GetSecurity(uniqueName, slp.User, slp.ExternalGroupInfo); SerializationUtility ser = new SerializationUtility(); return(ser.SerializeSecurityToStringFromDataSet(ds)); }
private void SolutionMenuItemCallback(object sender, EventArgs e) { var runtimeService = this.container.GetExportedValue <IRuntimeService>(); var settings = this.Solution.GetSettings(); var data = runtimeService.GetDataGenerationData(settings.Address, settings.DataBase, $"{TagInfo.All}", string.Empty, false, -1); var dataSet = SerializationUtility.Create(data); var projectInfoTable = dataSet.Tables[settings.ProjectInfo]; foreach (var item in this.Solution.GetProjects()) { this.Write(item, settings, projectInfoTable); } GenerationOutput.WriteLine(); }
static async Task WriteAsync(Settings settings) { var runtimeService = Container.Get <IRuntimeService>(); var data = await runtimeService.GetDataGenerationDataAsync(settings.Address, settings.DataBaseName, "all", null, null); var dataSet = SerializationUtility.Create(data); var projectInfoTable = dataSet.Tables[settings.ExportName]; foreach (var item in projectInfoTable.Rows) { Write(settings.OutputPath, item); } }
public static void Load(string repositoryId = null, string segmentId = null) { string path = String.Format("{0}/Data/{1}.data", Application.dataPath, repositoryId ?? DefaultRepositoryName); if (!File.Exists(path)) { return; } byte[] bytes = File.ReadAllBytes(path); var modelData = SerializationUtility.DeserializeValue <ModelData>(bytes, DataFormat.Binary); Highscores.AddRange(modelData.Highscores); }
public static MQMessage ToMessage(this byte[] data) { MQMessage message; if (data == null) { return(null); } else { message = SerializationUtility.BytesToObject <MQMessage>(data); } return(message); }
private CacheItem CreateCacheItem(DataRow dataToLoad) { string key = (string)dataToLoad["Key"]; object value = DeserializeValue(dataToLoad); CacheItemPriority scavengingPriority = (CacheItemPriority)dataToLoad["ScavengingPriority"]; object refreshAction = DeserializeObject(dataToLoad, "RefreshAction"); object expirations = SerializationUtility.ToObject((byte[])dataToLoad["Expirations"]); object timestamp = (DateTime)dataToLoad["LastAccessedTime"]; CacheItem cacheItem = new CacheItem((DateTime)timestamp, key, value, scavengingPriority, (ICacheItemRefreshAction)refreshAction, (ICacheItemExpiration[])expirations); return(cacheItem); }
private void SaveCache() { if (this.WriteToFile && this.EnableCaching) { try { this.approximateSizePerEntry = defaultApproximateSizePerEntry; string file = Path.Combine(SirenixAssetPaths.OdinTempPath, tempCacheFilename).Replace("\\", "/"); FileInfo info = new FileInfo(file); // If there's no entries, delete the old file and don't make a new one. if (this.cache.Count == 0) { if (info.Exists) { this.DeleteCache(); } } else { // Create dictionary if (!Directory.Exists(SirenixAssetPaths.OdinTempPath)) { Directory.CreateDirectory(SirenixAssetPaths.OdinTempPath); } using (FileStream stream = info.OpenWrite()) { List <UnityEngine.Object> unityReferences; SerializationUtility.SerializeValue(this.cache, stream, DataFormat.Binary, out unityReferences); // Log error if any Unity references were serialized. if (unityReferences != null && unityReferences.Count > 0) { Debug.LogError("Cannot reference UnityEngine Objects with PersistentContext."); } } // Update size estimate. this.approximateSizePerEntry = (int)(info.Length / this.EntryCount); } } catch (Exception ex) { Debug.LogError("Exception happened when saving Persistent Context to file."); Debug.LogException(ex); } } }
public override FactimeSettings Load() { if (!File.Exists(GetFileName())) { base.Save(new FactimeSettings { DefaultStart = new TimeSpan(9, 0, 0), DefaultEnd = new TimeSpan(18, 0, 0), DefaultPreHolidaysCollection = new List <DateTime>(), DefaultHolidaysCollection = new List <DateTime>() }); } return(SerializationUtility.Deserialize <FactimeSettings>(GetFileName())); }
public void ConfigurationsAreEqualWhenDeserializing() { var stringConfiguration = CreateConfiguration(); Serialize(ExternalConfigurationName); var stringConfigurationDeserialized = SerializationUtility.DeserializeJson <StringConfiguration>(ExternalConfigurationName); foreach (var charSet in stringConfiguration.Characters) { Assert.AreEqual(charSet.Name, stringConfigurationDeserialized.Characters.First(e => e.Name == charSet.Name).Name); Assert.AreEqual(charSet.Characters, stringConfigurationDeserialized.Characters.First(e => e.Characters == charSet.Characters).Characters); Assert.AreEqual(charSet.Enabled, stringConfigurationDeserialized.Characters.First(e => e.Enabled == charSet.Enabled).Enabled); } }
public string EncryptCookie <T>(T obj, Dictionary <string, string> parameters) { string strCookieValue = string.Empty; string strEncCookieValue = string.Empty; string strSHA1Sign = string.Empty; strCookieValue = SerializationUtility.JsonSerialize3(obj); strEncCookieValue = RC4Encrypt.Encrypt(strCookieValue, parameters["rc4key"], RC4Encrypt.EncoderMode.HexEncoder).Trim(); strSHA1Sign = HashEncrypt.SHA1Encrypt(strEncCookieValue + parameters["hashkey"]); strEncCookieValue = HttpUtility.UrlEncode(strEncCookieValue); strEncCookieValue = strSHA1Sign + strEncCookieValue; return(strEncCookieValue); }
public void DeepCloneTest() { var user1 = new User(0, "AAA"); var user2 = new User(1, "BBB"); var users = new List <User> { user1, user2 }; var userCollection = new UserCollection(users); var cloned = SerializationUtility.DeepClone(userCollection); Assert.AreEqual(userCollection, cloned); Assert.AreNotSame(userCollection, cloned); Assert.AreNotSame(userCollection.Users, cloned.Users); }
public override void StoreProgram(IUdonProgram udonProgram) { if (this == null) { return; } byte[] serializedProgramBytes = SerializationUtility.SerializeValue(udonProgram, DEFAULT_SERIALIZATION_DATA_FORMAT, out programUnityEngineObjects); serializedProgramBytesString = Convert.ToBase64String(serializedProgramBytes); serializationDataFormat = DEFAULT_SERIALIZATION_DATA_FORMAT; #if UNITY_EDITOR UnityEditor.EditorUtility.SetDirty(this); #endif }
public static ValueTask <int> WritePacketAsync(IByteHandler byteHandler, int sequenceNumber, ArraySegment <byte> contents, IOBehavior ioBehavior) { var bufferLength = contents.Count + 4; var buffer = ArrayPool <byte> .Shared.Rent(bufferLength); SerializationUtility.WriteUInt32((uint)contents.Count, buffer, 0, 3); buffer[3] = (byte)sequenceNumber; Buffer.BlockCopy(contents.Array, contents.Offset, buffer, 4, contents.Count); return(byteHandler.WriteBytesAsync(new ArraySegment <byte>(buffer, 0, bufferLength), ioBehavior) .ContinueWith(x => { ArrayPool <byte> .Shared.Return(buffer); return default(ValueTask <int>); })); }
public void Serialize(CompactWriter writer) { Address.WriteAddress(writer, _address); writer.WriteObject(_subgroupName); CacheStatistics.WriteCacheStatistics(writer, _stats); writer.Write(_status.Data); DataAffinity.WriteDataAffinity(writer, _dataAffinity); writer.WriteObject(_connectedClients); writer.Write(_isInproc); Address.WriteAddress(writer, _rendererAddress); writer.WriteObject(_nodeGuid); writer.Write(_statsReplicationCounter); writer.Write((byte)CacheNodeStatus); SerializationUtility.SerializeDictionary(_localConnectedClientsInfo, writer); }
public static ShoppingCart GetShoppingCartByCustomer(int userSysNo) { ShoppingCart shoppingCart = GetShoppingCartFromCookieOrCreateNew(); if (shoppingCart == null) { shoppingCart = new ShoppingCart(); } string key = CookieHelper.GetCookie <string>(MY_SHOPPINGCART_SIGN_KEY); if (String.IsNullOrEmpty(key)) { key = Guid.NewGuid().ToString("N"); CookieHelper.SaveCookie <string>(MY_SHOPPINGCART_SIGN_KEY, key); } shoppingCart.ShoppingCartID = key; if (userSysNo > 0) { //获取数据库最新数据购物车 ShoppingCartPersistent shoppingCartPersistent = ShoppingPersistentDA.GetShoppingCartByCustomer(userSysNo); ShoppingCart newShoppingCart = new ShoppingCart(); if (shoppingCartPersistent != null && !string.IsNullOrEmpty(shoppingCartPersistent.ShoppingCart)) { newShoppingCart = SerializationUtility.JsonDeserialize2 <ShoppingCart>(shoppingCartPersistent.ShoppingCart); } //判断购物车是否发生变化 if (newShoppingCart.ShoppingCartID != shoppingCart.ShoppingCartID) { newShoppingCart.ShoppingCartID = shoppingCart.ShoppingCartID; //合并购物车 MergeShoppingCart(shoppingCart, newShoppingCart); } //写入DB ShoppingPersistentDA.SaveShoppingCart(new ShoppingCartPersistent() { CustomerSysNo = userSysNo, ShoppingCart = SerializationUtility.JsonSerialize2(shoppingCart), ShoppingCartMini = "" }); } else { shoppingCart = GetShoppingCartFromCookie(); } //写入Cookie CookieHelper.SaveCookie <ShoppingCart>(MY_SHOPPINGCART_COOKIE_NAME, shoppingCart); return(shoppingCart); }
public IStorageFile CreateFile(string path, DateTime?lastWriteTime = null) { EnsurePathIsRelative(path); if (Container.BlobExists(String.Concat(_root, path))) { // MAB delete the file if it already exists DeleteFile(path); //throw new ArgumentException("File " + path + " already exists"); } // create all folder entries in the hierarchy int lastIndex; var localPath = path; while ((lastIndex = localPath.LastIndexOf('/')) > 0) { localPath = localPath.Substring(0, lastIndex); var folder = Container.GetBlockBlobReference(String.Concat(_root, Combine(localPath, FolderEntry))); folder.OpenWrite().Dispose(); } var blob = Container.GetBlockBlobReference(String.Concat(_root, path)); var contentType = GetContentType(path); if (!String.IsNullOrWhiteSpace(contentType)) { blob.Properties.ContentType = contentType; if (IsCacheable(contentType)) { blob.Properties.CacheControl = "max-age=1800, public"; } } blob.Metadata.Add("UploadedFromNode", SerializationUtility.GetLocalhostFqdn()); if (lastWriteTime.HasValue) { blob.Metadata.Add("LastWriteTime", SerializationUtility.ToUniversalString(lastWriteTime)); } using (var memoryStream = new MemoryStream(new byte[0])) { blob.UploadFromStream(memoryStream); } return(new AzureBlobFileStorage(blob, _absoluteRoot)); }
public override void GetResponseUserInfo(PartnerBackContext context) { //第一步,获取AccessToken NameValueCollection postData = new NameValueCollection(); postData.Add("client_id", context.PassportInfo.Parnter.AppID); postData.Add("client_secret", context.PassportInfo.Parnter.AppSecret); postData.Add("grant_type", "authorization_code"); postData.Add("code", context.ResponseParam["code"]); postData.Add("redirect_uri", SpecialUrlEncode(BuildActionUrl(context.PassportInfo.Base.BaseUrl, context.PassportInfo.Parnter.LoginBackUrl))); string responseData = HttpPostRequest(context.PassportInfo.Parnter.AccessTokenUrl , BuildStringFromNameValueCollection(postData) , "application/x-www-form-urlencoded" , context.PassportInfo.Parnter.Encoding); //Debug模式下记录相关信息至日志 if (context.PassportInfo.Parnter.Debug.Equals("1")) { Logger.WriteLog(string.Format("获取AccessToken响应数据:{0}", responseData), "PassportSinaWeibo", "GetAccessToken"); } SinaWeiboAccessToken returnData = SerializationUtility.JsonDeserialize <SinaWeiboAccessToken>(responseData); if (returnData == null) { throw new BusinessException("登录失败!"); } //第二步,获取用户信息 string requestParam = string.Format("access_token={0}&uid={1}", returnData.access_token, returnData.uid ); responseData = HttpGetRequest(string.Format("{0}?{1}", context.PassportInfo.Parnter.GetUserInfoUrl, requestParam) , context.PassportInfo.Parnter.Encoding); //Debug模式下记录相关信息至日志 if (context.PassportInfo.Parnter.Debug.Equals("1")) { Logger.WriteLog(string.Format("获取User响应数据:{0}", responseData), "PassportSinaWeibo", "GetUserInfo"); } SinaWeiboUserInfo userInfo = SerializationUtility.JsonDeserialize <SinaWeiboUserInfo>(responseData); context.CustomerID = string.Format("SinaWeibo_{0}", userInfo.id); context.CustomerName = userInfo.screen_name; context.CustomerSouce = Enums.CustomerSourceType.Sina; }
public void GuardarBloque(string rutaArchivo, DataFormat tipoFormato) { var bytes = SerializationUtility.SerializeValue(this, tipoFormato); if (tipoFormato == DataFormat.JSON) { string ruta = rutaArchivo + "/" + "Bloque_" + posicion.x + "_" + posicion.y + "_" + posicion.z + ".json"; var jsonString = System.Text.Encoding.UTF8.GetString(bytes); File.WriteAllText(ruta, jsonString); } else { string ruta = rutaArchivo + "/" + "Bloque_" + posicion.x + "_" + posicion.y + "_" + posicion.z + ".jcc"; File.WriteAllBytes(ruta, bytes); } }
protected virtual object ReadField(IsolatedStorageFileStream fileStream, bool encrypted) { if (fileStream.Length == 0) { return(null); } byte[] fieldBytes = new byte[fileStream.Length]; fileStream.Read(fieldBytes, 0, fieldBytes.Length); if (encrypted) { fieldBytes = DecryptValue(fieldBytes); } object fieldValue = SerializationUtility.ToObject(fieldBytes); return(fieldValue); }
public ActionResult AjaxSavePurchaseOrder() { if (string.IsNullOrWhiteSpace(Request["Data"])) { throw new BusinessException("采购单信息为空"); } PurchaseOrderInfo poInfo = SerializationUtility.JsonDeserialize2 <PurchaseOrderInfo>(Request["Data"]); SetUserInfo(poInfo); poInfo.VendorInfo = new VendorBasicInfo() { VendorID = UserAuthHelper.GetCurrentUser().SellerSysNo.ToString() }; poInfo = ProductPurchaseService.CreatePO(poInfo); return(Json(poInfo)); }
public static StorePage QueryStorePageByPageName(string pageName, int sellerSysNo) { var page = StoreDA.QueryStorePageByPageName(pageName, sellerSysNo); if (page != null) { var value = page.DataValue; if (!string.IsNullOrEmpty(value)) { var result = SerializationUtility.JsonDeserialize2 <StorePage>(value); result.SysNo = page.SysNo; return(result); } } return(null); }
public void IsSerializableTest1() { try { Type testType = null; SerializationUtility.IsSerializable(testType); Assert.Fail("Null type should cause a NullReferenceException."); } catch (NullReferenceException) { } Assert.IsFalse(SerializationUtility.IsSerializable(typeof(NotSerializable)), "Type is marked as not serializable"); Assert.IsFalse(SerializationUtility.IsSerializable(typeof(AlsoNotSerializable)), "Type's base type is marked as not serializable"); Assert.IsTrue(SerializationUtility.IsSerializable(typeof(Serializable)), "Type is serializable"); }
/* * private IEnumerable<Type> GetAllTypes() * { * List<Type> l_types = new List<Type>(); * if(ExecutedEvents != null) * { * for(int i = 0; i < ExecutedEvents.Count; i++) * { * EventEntry l_eventEntry = (EventEntry) ExecutedEvents[i]; * if (!l_types.Contains(l_eventEntry.ExecutedEvent.GetType())) * { * l_types.Add(l_eventEntry.ExecutedEvent.GetType()); * } * } * } * return l_types; * } */ protected override void OnEnable() { base.OnEnable(); ExecutedEvents = new List <object>(); EventQueue.OnEventExecuted = (AEvent p_event) => { EventEntry l_eventEntry = new EventEntry() { ExecutionTime = DateTime.Now.ToString("hh:mm:ss.fff tt"), ExecutedEvent = (AEvent)SerializationUtility.CreateCopy(p_event) }; ExecutedEvents.Add(l_eventEntry); }; }
public void SaveUserSession(UserEntity user) { var serializationUtility = new SerializationUtility(); var userJson = serializationUtility.Serialize<UserEntity>(user); //如果已经存在用户信息,那么就更新 if (ApplicationData.Current.LocalSettings.Values.ContainsKey(LoginService.USERKEY)) { ApplicationData.Current.LocalSettings.Values[LoginService.USERKEY] = userJson; } else { ApplicationData.Current.LocalSettings.Values.Add(LoginService.USERKEY, userJson); } //调用登录状态委托 if (LoginService.LoginIn != default(LoginInEventHandler)) { LoginService.LoginIn(null, new LoginEventArgs() { IsLoginIn = true, User = user }); } }
public UserEntity GetUserSession() { var serializationUtility = new SerializationUtility(); object userJson = string.Empty; ApplicationData.Current.LocalSettings.Values.TryGetValue(LoginService.USERKEY, out userJson); return serializationUtility.DeSerialize<UserEntity>(userJson == default(object) ? string.Empty : userJson.ToString()); }
public async Task GetSpartanImage_IsSerializable(string gamertag) { var query = new GetSpartanImage() .ForPlayer(gamertag); var result = await Global.Session.Query(query); var serializationUtility = new SerializationUtility<GetImage>(); serializationUtility.AssertRoundTripSerializationIsPossible(result); }
private async void DownloadProgress(DownloadOperation downloadOperation) { double percent = 0; if (downloadOperation.Progress.TotalBytesToReceive > 0) { percent = downloadOperation.Progress.BytesReceived * 100 / downloadOperation.Progress.TotalBytesToReceive; } var currentDownloadCoursePeriods = this.Course.CoursePeriods.Single<CoursePeriodEntity>(coursePeriods => coursePeriods.ID == this.ActivelyDownload.Single<KeyValuePair<Guid, DownloadOperation>>(activelyDownload => activelyDownload.Value == downloadOperation).Key); //只有当进度为100%时,才开始缓存文件信息 if (percent >= 100) { #region 缓存视频信息 var downloadedLessonDataEntityContainer = ApplicationData.Current.LocalSettings.CreateContainer(App.Settings.DownloadedLessonDataEntityContainerName, ApplicationDataCreateDisposition.Always); var serializeUtility = new SerializationUtility(); //如果本地已经存在这个Key,那么表示缓存过视频,那么就需要更新视频信息及视频流 if (downloadedLessonDataEntityContainer.Values.ContainsKey(currentDownloadCoursePeriods.ID.ToString())) { //更新视频基本信息 downloadedLessonDataEntityContainer.Values[currentDownloadCoursePeriods.ID.ToString()] = serializeUtility.Serialize<CoursePeriodEntity>(currentDownloadCoursePeriods); } //如果本地不存在这个Key,那么就表示没有缓存过视频,就需要录入视频信息及视频流 else { //录入视频基本信息 downloadedLessonDataEntityContainer.Values.Add(currentDownloadCoursePeriods.ID.ToString(), serializeUtility.Serialize<CoursePeriodEntity>(currentDownloadCoursePeriods)); } #endregion } await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(() => { currentDownloadCoursePeriods.IsDownloading = true; currentDownloadCoursePeriods.DownloadProgress = percent; })); }