C# Repository.Delete方法代码示例

        public void BasicCrud()
        {
            using (var trans = DataSource.BeginTransaction())
            {

                var repo = new Repository<Employee, int>(trans, EmployeeTableName);

                var emp1 = new Employee() { FirstName = "Tom", LastName = "Jones", Title = "President" };
                var echo1 = repo.Insert(emp1);

                Assert.AreNotEqual(0, echo1.EmployeeKey, "EmployeeKey was not set");
                Assert.AreEqual(emp1.FirstName, echo1.FirstName, "FirstName");
                Assert.AreEqual(emp1.LastName, echo1.LastName, "LastName");
                Assert.AreEqual(emp1.Title, echo1.Title, "Title");

                echo1.MiddleName = "G";
                repo.Update(echo1);

                var emp2 = new Employee() { FirstName = "Lisa", LastName = "Green", Title = "VP Transportation", ManagerKey = echo1.EmployeeKey };
                var echo2 = repo.Insert(emp2);
                Assert.AreNotEqual(0, echo2.EmployeeKey, "EmployeeKey was not set");
                Assert.AreEqual(emp2.FirstName, echo2.FirstName, "FirstName");
                Assert.AreEqual(emp2.LastName, echo2.LastName, "LastName");
                Assert.AreEqual(emp2.Title, echo2.Title, "Title");
                Assert.AreEqual(emp2.ManagerKey, echo2.ManagerKey, "ManagerKey");

                var list = repo.GetAll();
                Assert.IsTrue(list.Any(e => e.EmployeeKey == echo1.EmployeeKey), "Employee 1 is missing");
                Assert.IsTrue(list.Any(e => e.EmployeeKey == echo2.EmployeeKey), "Employee 2 is missing");

                var get1 = repo.Get(echo1.EmployeeKey.Value);
                Assert.AreEqual(echo1.EmployeeKey, get1.EmployeeKey);



                var whereSearch1 = repo.Query("FirstName = @FN", new { FN = "Tom" });
                Assert.IsTrue(whereSearch1.Any(x => x.EmployeeKey == echo1.EmployeeKey), "Emp1 should have been returned");
                Assert.IsTrue(whereSearch1.All(x => x.FirstName == "Tom"), "Checking for incorrect return values");

                var whereSearch2 = repo.Query(new { FirstName = "Tom" });
                Assert.IsTrue(whereSearch2.Any(x => x.EmployeeKey == echo1.EmployeeKey), "Emp1 should have been returned");
                Assert.IsTrue(whereSearch2.All(x => x.FirstName == "Tom"), "Checking for incorrect return values");


                repo.Delete(echo2.EmployeeKey.Value);
                repo.Delete(echo1.EmployeeKey.Value);

                var list2 = repo.GetAll();
                Assert.AreEqual(list.Count - 2, list2.Count);

                trans.Commit();
            }

        }

 public void DeleteArticle(Article article)
 {
     using (var repository1 = new Repository())
     {
         repository1.Delete(article);
     }
 }

        public ActionResult About()
        {
            // Generiskt Repository - Här skapas ett repository för Category
            // Repositoryt kräver typer som implementerar IEntity
            Repository<Category> categoryRepo = new Repository<Category>();

            // Samtliga metoder som finns med i det generiska repositoriet
            var categories = categoryRepo.FindAll();

            var filteredCategories = categoryRepo.FindAll(c => c.Name.Contains("sport"));

            var category = categoryRepo.FindByID(0);

            category.Name = "New Name!";
            categoryRepo.Save(category);

            categoryRepo.Delete(category);

            ProductRepository productRepo = new ProductRepository();

            var products = productRepo.FindAll(); // + övriga "grund"-metoder

            // Metoder implementerade i ProductRepository:
            var productsForCategory = productRepo.FindProductsByCategoryID(0);

            var productsWithEmptyName = productRepo.FindAll(ProductRepository
                                                            .FilterProductsWithEmptyDescription);

            return View();
        }

 public void DeleteComment(Comment comment)
 {
     using (var repository1 = new Repository())
     {
         repository1.Delete(comment);
     }
 }

        public void ShouldDelete()
        {
            // arrange
            Repository<string> r = new Repository<string>(m_session.Object);
            string s = "this";

            // act
            r.Delete(s);

            // assert
            m_session.Verify(x => x.Delete((object)s));
        }

        static void Main(string[] args)
        {
            var soapShopDb = new SoapShopDb();
            var component = new Repository(soapShopDb);

            // Adding some entity
            component.Add(new Customer { CustomerName = "Nata", CustomerPhone = "679011198" });
            component.Save();
            component.Add(new SoapProduct { Tittle = "Eucalyptus", Mass = 100, Price = 25.2M });
            component.Save();

            // Delating some entity
            var comp = soapShopDb.Set<Customer>().FirstOrDefault(i => i.CustomerName == "Nata");
            component.Delete(comp);
            component.Save();

            // Reading some entity
            var list = component.Get<Customer>();
            foreach (var item in list)
            {
                Console.WriteLine(item.Id + " " + item.CustomerName + " " + item.CustomerPhone + "\n");
            }

            // Find one
            var comp2 = component.Get<Customer>(3);
            Console.WriteLine(comp2.CustomerName);
        }

 public void Should_throw_ArgumentNullException_if_null_passed_in()
 {
     using (var context = new RepositoryTestDataContext())
     {
         var repo = new Repository<Order>(context);
         Assert.Throws<ArgumentNullException>(() => repo.Delete(null));
     }
 }

 public void Delete(string slug)
 {
     using (var repository = new Repository<Entry>())
     {
         var entry = repository.Find(slug);
         repository.Delete(entry);
     }
 }

        public void TestDeleteWorks()
        {
            Repository repository = new Repository(new SqlConnectionDev());
            Club club = new Club();
            club.clubId = 1;
            bool result = repository.Delete(club);

            Assert.IsNotNull(result);
        }

 public void SetUp()
 {
     //_repository = A.Fake<IRepository<Category>>();
     _repository = new Repository<Category>(() => new JudgifyContext());
     foreach (var category in _repository.GetAll())
     {
         _repository.Delete(category);
     }
 }

 public void DeleteEducation()
 {
     var repo = new Repository<EducationModel>(DbCollection.Education);
     var contacts = repo.Gets().Where(m => m.UserId == "5709a5b24a549a1a9873a19b");
     foreach (var item in contacts)
     {
         repo.Delete(item.Id);
     }
 }

        internal void DeleteTestAggregate(TestAggregate aggregate)
        {
            var repository = new Repository<TestAggregate, TestEntity>();
            using (var unitOfWork = new UnitOfWorkFactory(TestSettings.BoilerMongoConfiguration).CreateUnitOfWork())
            {
                repository.UnitOfWork = unitOfWork;
                repository.Delete(aggregate);

                unitOfWork.Commit();
            }
        }

 public ActionResult Delete(string id, AdminSetting model)
 {
     try
     {
         var repo = new Repository<AdminSetting>(DbCollection.AdminSetting);
         repo.Delete(new ObjectId(id));
         return RedirectToAction("Index");
     }
     catch
     {
         return View();
     }
 }

        public void Should_Delete_An_Entity()
        {
            var repository = new Repository<Author>();
            var author = repository.Insert(new Author()
            {
                FirstName = "Bruce",
                LastName = "Wayne"
            });

            repository.Delete(author.Id);
            author = repository.GetById(author.Id);
            Assert.IsNull(author);
        }

        public void Add_User_Fails_If_UserName_Not_Unique()
        {
            string userName = Guid.NewGuid().ToString();
            User user1 = new User
                            {
                                FirstName = "First",
                                LastName = "User1",
                                UserName = userName,
                                Email = "[email protected]"
                            };
            User user2 = new User
            {
                FirstName = "Second",
                LastName = "User2",
                UserName = userName,
                Email = "[email protected]"
            };

            NHibernateHelper helper = new NHibernateHelper();

            // create
            using (UnitOfWork unitOfWork = new UnitOfWork(helper.SessionFactory))
            {
                Repository<User> userRepo = new Repository<User>(unitOfWork.Session);
                Assert.IsTrue(userRepo.Add(user1));
                unitOfWork.Commit();
            }
            try
            {
                using (UnitOfWork unitOfWork = new UnitOfWork(helper.SessionFactory))
                {
                    Repository<User> userRepo = new Repository<User>(unitOfWork.Session);
                    Assert.IsTrue(userRepo.Add(user2));
                    unitOfWork.Commit();
                }
            }
            catch (NHibernate.Exceptions.GenericADOException ex)
            {
                // expected this
            }
            finally
            {
                // delete
                using (UnitOfWork unitOfWork = new UnitOfWork(helper.SessionFactory))
                {
                    Repository<User> userRepo = new Repository<User>(unitOfWork.Session);
                    Assert.IsTrue(userRepo.Delete(user1));
                    unitOfWork.Commit();
                }
            }
        }