C# SQLiteAsyncConnection.DeleteAsync方法代码示例

        public async Task DeleteCounterAsync(Counter counter)
        {
            var connection = new SQLiteAsyncConnection(_dbPath);
            await connection.DeleteAsync(counter);

            OnCountersChanged();
        }

 public async static Task DeleteItems(int menuId)
 {
     SQLiteAsyncConnection sqlConnection = new SQLiteAsyncConnection(DbHelper.DB_PATH);
     var collectionItem = await sqlConnection.Table<Item>().Where(x => x.MenuId == menuId).ToListAsync();
     foreach(Item item in collectionItem)
     {
         await sqlConnection.DeleteAsync(item);
     }
 }

 public async Task Remove(TrackCollection trackCollection)
 {
     var connection = new SQLiteAsyncConnection(DbPath);
     var loadTracks = await Locator.MusicLibraryVM.TracklistItemRepository.LoadTracks(trackCollection);
     foreach (TracklistItem tracklistItem in loadTracks)
     {
         await Locator.MusicLibraryVM.TracklistItemRepository.Remove(tracklistItem);
     }
     await connection.DeleteAsync(trackCollection);
 }

 private async void Button_Click_4(object sender, RoutedEventArgs e)
 {
     SQLiteAsyncConnection conn = new SQLiteAsyncConnection(ApplicationData.Current.LocalFolder.Path + "\\people.db");
     var query = conn.Table<Person>().Where(x => x.Name == "张三");
     var result = await query.ToListAsync();
     foreach (var item in result)
     {
         await conn.DeleteAsync(item);
     }
 }

 public async static Task DeleteCounter(int counterId)
 {
     SQLiteAsyncConnection sqlConnection = new SQLiteAsyncConnection(DbHelper.DB_PATH);
     var collectionItem = await sqlConnection.Table<Counter>().Where(x => x.Id == counterId).FirstOrDefaultAsync();
     if (collectionItem != null)
     {
         await sqlConnection.DeleteAsync(collectionItem);
     }
     await CounterSubscribed();
 }

 /// <summary>
 /// Löscht einen Trainingsplan aus der lokalen DB
 /// </summary>
 /// <param name="data">Schedule</param>
 /// <param name="path">SQLite Connection String</param>
 /// <returns>1 -> Delete</returns>
 /// <returns>-1 -> Exception</returns>
 public async Task<int> deleteSchedule(Schedule data)
 {
     try
     {
         var db = new SQLiteAsyncConnection(path);
         await db.DeleteAsync(data);
         return 1;
     }
     catch (SQLiteException ex)
     {
         Console.WriteLine(ex.Message);
         return -1;
     }
 }

        private async Task DeletetaisanAsync(string name)
        {
            SQLiteAsyncConnection conn = new SQLiteAsyncConnection("moneybook.db");

            // Retrieve taisan
            var taisan = await conn.Table<taikhoan>().Where(x => x.Tentaikhoan == name).FirstOrDefaultAsync();
            if (taisan != null)
            {
                // Delete record
                await conn.DeleteAsync(taisan);
            }
        }

 public Task Remove(ArtistItem artist)
 {
     var connection = new SQLiteAsyncConnection(DbPath);
     return connection.DeleteAsync(artist);
 }

        private async Task DeleteGhichepAsync(int oldid)
        {
            SQLiteAsyncConnection conn = new SQLiteAsyncConnection("moneybook.db");

            // Retrieve taisan
            var pv = await conn.Table<ghichep>().Where(x => x.Id == oldid).FirstOrDefaultAsync();
            if (pv != null)
            {
                // Delete record
                await conn.DeleteAsync(pv);
            }
        }

        async Task PickAlbumsFromDir()
        {
            var now = DateTime.Now;
            var albumFolders = await KnownFolders.MusicLibrary.GetFoldersAsync(Windows.Storage.Search.CommonFolderQuery.GroupByArtist);
            foreach (var albumFolder in albumFolders)
            {
                Debug.WriteLine(albumFolder.Name);
                var files = from b in await albumFolder.GetFilesAsync()
                            where !b.Path.EndsWith(".jpg")
                            select b;
                var propDict = (from b in files
                                select new { b.Properties.GetMusicPropertiesAsync().AsTask().Result,
                                             Value = b }
                                ).ToDictionary(b => b.Result, b => b.Value);
                var musicProperties = from b in propDict.Keys
                                      orderby b.TrackNumber
                                      group b by b.Album;
                var albumPool = new List<Album>() { };

                foreach (var tracks in musicProperties)
                {
                    var props = tracks.ToList();
                    var paths = (from b in props
                                 select propDict[b].Path).ToList();
                    var yearDesc = 10000 - props[0].Year;
                    var albumID = $"{props[0].Artist} {yearDesc} {props[0].Album}";

                    var db1 = new SQLiteAsyncConnection("PlaneAudioU.db");
                    var album = await db1
                                      .Table<Album>()
                                      .Where(a => a.AlbumID == albumID)
                                      .FirstOrDefaultAsync();
                    var albumNew = new Album()
                    {
                        AlbumID = albumID,
                        Title = props[0].Album,
                        Artist = props[0].Artist,
                        Titles = props.Select(a => a.Title).ToList(),
                        TrackPaths = paths,
                        Length = props.Count(),
                        Added = now
                    };

                    var db2 = new SQLiteAsyncConnection("PlaneAudioU.db");
                    if (album == null)
                    {

                        await db2.InsertAsync(albumNew);
                    }
                    else
                    {
                        await db2.UpdateAsync(albumNew);
                    }

                    albumPool.Add(albumNew);
                }

                Debug.WriteLine("album pool. " + albumPool.Count.ToString());
                if (albumPool.Count() > 0)
                {
                    var albumToShow = (from a in albumPool
                                       where !shownAlbums.Contains(a.AlbumID)
                                       select a).ToList();
                    if (albumToShow.Count() > 0)
                    {
                        var artistRect = GetArtistRect(albumToShow[0].Artist);
                        albumPanel.Items.Add(artistRect);
                        foreach (var album in albumToShow.OrderBy(a => a.AlbumID))
                        {
                            var button = await album.GetButton();
                            button.Click += AlbumButton_Clicked;
                            albumPanel.Items.Add(button);
                            shownAlbums.Add(album.AlbumID);
                        }
                    }
                }

            }

            Debug.WriteLine("Saving to db.");
            var db3 = new SQLiteAsyncConnection("PlaneAudioU.db");
            foreach (var oldAlbum in await db3.Table<Album>().Where(a => now > a.Added).ToListAsync())
            {
                var db4 = new SQLiteAsyncConnection("PlaneAudioU.db");
                await db4.DeleteAsync(oldAlbum);
            }

        }

		public async Task<int> DeleteVisit(Visit visit) {
			SQLiteAsyncConnection conn = new SQLiteAsyncConnection(this.dbPath);
			return await conn.DeleteAsync(visit);
		}

 public async void DeleteDB(DB data)
 {
     SQLiteAsyncConnection conn = new SQLiteAsyncConnection("exercice");
     await conn.DeleteAsync(data);
 }

        private async void Button_Click_1(object sender, RoutedEventArgs e)
        {
            string baza = comboboxusunzbazy.SelectedValue.ToString();
            string slowko = comboboxslowkodousuniecia.SelectedValue.ToString();
            string[] tablica = slowko.Split(new[] {'.'});
            if (baza.Equals("eFiszki"))
            {
                baza = "AppData";
            }

            var path = Windows.Storage.ApplicationData.Current.LocalFolder.Path + @"\" + baza + ".sqlite";
            var db = new SQLiteAsyncConnection(path);

            var maxid = 0;
            List<UserDefaultDataBase> result = await db.QueryAsync<UserDefaultDataBase>("Select max(id) as Id From UserDefaultDataBase");
            foreach (var item in result)
            {
                maxid = item.Id;
            }

            int indeksdousuniecia = Convert.ToInt32(tablica[0]);
            var all  = await db.QueryAsync<UserDefaultDataBase>("Select * From UserDefaultDataBase");
            var del = await db.FindAsync<UserDefaultDataBase>(u => u.Id == indeksdousuniecia);
            await db.DeleteAsync(del);

            //Debug.WriteLine("maksymalny indeks: " + maxid + ", indeks do usuniecia:" + indeksdousuniecia);
            //if (maxid != indeksdousuniecia)
            //{
            //    List<UserDefaultDataBase> updateid = await db.QueryAsync<UserDefaultDataBase>("Select * From UserDefaultDataBase Where Id = ?", new object[] { maxid });
            //    var update = updateid.First();
            //    update.Id += 100;
            //    update.SlowkoEn = "toz to dziala";
            //    await db.UpdateAsync(update);
            //    Debug.WriteLine("Update indeksu:" + maxid + " na " + indeksdousuniecia);

            //    //foreach (var i in updateid)
            //    //{
            //    //    Debug.WriteLine(i.Id);
            //    //}

            //    //await db.QueryAsync<UserDefaultDataBase>("Update UserDefaultDataBase set id= ? where id=?", new object[] {maxid, indeksdousuniecia });
            //    //foreach (var i in updateid)
            //    //{
            //    //    var update = updateid.First();
            //    //    update.Id = indeksdousuniecia;
            //    //    await db.UpdateAsync(update);
            //    //} 
            //}


            comboboxslowkodousuniecia.Items.Clear();
            setcomboslowko();

            

        }

        /// <summary>
        /// Delete a record
        /// </summary>
        public async void Delete(string sensor)
        {
            SQLiteAsyncConnection connection = new SQLiteAsyncConnection(textBox.Text);

            var SensorQry = await connection.Table<Sensor>().Where(x => x.Name.StartsWith(sensor)).FirstOrDefaultAsync();

            if (SensorQry != null)
            {
                await connection.DeleteAsync(SensorQry);
            }

        }

        private async Task DeleteArticleAsync(string name)
        {
            SQLiteAsyncConnection conn = new SQLiteAsyncConnection(dbName);

            // Retrieve Article
            var article = await conn.Table<Article>().Where(x => x.Title == name).FirstOrDefaultAsync();
            if (article != null)
            {
                // Delete record
                await conn.DeleteAsync(article);
            }
        }