Esempio n. 1
0
        public void LocalStorage_Should_Perform_Decently_With_Large_Collections()
        {
            // arrange - create a larger collection (100K records)
            var stopwatch = Stopwatch.StartNew();
            var storage   = new LocalStorage();

            for (var i = 0; i < 100000; i++)
            {
                storage.Store(Guid.NewGuid().ToString(), i);
            }

            storage.Persist();

            // act - create new instance (e.g. load the larger collection from disk)
            var target = new LocalStorage();

            target.Clear();
            stopwatch.Stop();

            // cleanup - delete the (large!) persisted file
            target.Destroy();

            // assert - make sure the entire operation is done in < 1sec. (psychological boundry, if you will)
            stopwatch.ElapsedMilliseconds.Should().BeLessOrEqualTo(1000);
        }
Esempio n. 2
0
        private async Task LogOut()
        {
            try
            {
                // Obteniendo usuario Logiado
                var usLogged = LocalStorage.Get <Usuario>("usuario");
                if (usLogged != null)
                {
                    usLogged.Status = 0;
                    var isSuccess = await usuariosProvider.UpdateAsync(usLogged.UID, usLogged);
                }
            }
            catch (Exception)
            {
                Console.WriteLine("Error al salir");
            }

            // Clears the in-memory contents of the LocalStorage, but leaves any persisted state on disk intact.
            LocalStorage.Clear();

            // Deletes the persisted file on disk, if it exists, but keeps the in-memory data intact.
            LocalStorage.Destroy();
        }
        public void LocalStorage_Should_Perform_Decently_With_Many_Opens_And_Writes()
        {
            // arrange - iterate a lot of times through open/persist/close
            for (var i = 0; i < 1000; i++)
            {
                var storage = new LocalStorage();
                // storage.Clear();
                storage.Store(Guid.NewGuid().ToString(), i);
                storage.Persist();
            }

            // cleanup
            var store = new LocalStorage();

            store.Destroy();
        }
        public static string Clear()
        {
            string response = string.Empty;

            try
            {
                using (var storage = new LocalStorage())
                {
                    storage.Clear();
                    storage.Destroy();
                }
            }
            catch (Exception ex)
            {
                response = ex.Message;
            }
            return(response);
        }
Esempio n. 5
0
        public void LocalStorage_Destroy_Should_Delete_File_On_Disk()
        {
            // arrange
            var random_filename = Guid.NewGuid().ToString("N");
            var filepath        = FileHelpers.GetLocalStoreFilePath(random_filename);
            var config          = new LocalStorageConfiguration()
            {
                Filename = random_filename
            };

            var storage = new LocalStorage(config);

            storage.Persist();

            // act
            storage.Destroy();

            // assert
            File.Exists(filepath).Should().BeFalse();
        }
Esempio n. 6
0
 public static void Clear()
 {
     storage.Clear();
     storage.Destroy();
 }
 public static void Clear()
 {
     _storage.Destroy();
     _storage.Dispose();
 }