C# DomainModel.Baz类代码示例

        public void AddAll()
        {
            using (ISession s = OpenSession())
            {
                Foo foo1 = new Foo();
                s.Save(foo1);
                Foo foo2 = new Foo();
                s.Save(foo2);
                Foo foo3 = new Foo();
                s.Save(foo3);
                Baz baz = new Baz();
                baz.FooSet = new HashedSet();
                baz.FooSet.Add(foo1);
                s.Save(baz);
                Assert.AreEqual(1, baz.FooSet.Count);

                IList foos = new ArrayList();
                foos.Add(foo2);
                foos.Add(foo3);
                baz.FooSet.AddAll(foos);
                Assert.AreEqual(3, baz.FooSet.Count);

                s.Flush();

                // Clean up
                foreach (Foo foo in baz.FooSet)
                {
                    s.Delete(foo);
                }

                s.Delete(baz);
                s.Flush();
            }
        }

		public void BagOneToMany()
		{
			ISession s = OpenSession();
			Baz baz = new Baz();
			IList list = new ArrayList();
			baz.Bazez = list;
			list.Add(new Baz());
			s.Save(baz);
			s.Flush();
			list.Add(new Baz());
			s.Flush();
			list.Insert(0, new Baz());
			s.Flush();
			object toDelete = list[1];
			list.RemoveAt(1);
			s.Delete(toDelete);
			s.Flush();
			s.Delete(baz);
			s.Flush();
			s.Close();
		}

		public void CascadeDeleteDetached()
		{
			Baz baz;

			using (ISession s = OpenSession())
			{
				baz = new Baz();
				IList list = new ArrayList();
				list.Add(new Fee());
				baz.Fees = list;
				s.Save(baz);
				s.Flush();
			}

			using (ISession s = OpenSession())
			{
				baz = (Baz) s.Get(typeof(Baz), baz.Code);
			}

			Assert.IsFalse(NHibernateUtil.IsInitialized(baz.Fees));

			using (ISession s = OpenSession())
			{
				s.Delete(baz);
				s.Flush();

				Assert.IsFalse(s.CreateQuery("from Fee").Enumerable().GetEnumerator().MoveNext());
			}

			using (ISession s = OpenSession())
			{
				baz = new Baz();
				IList list = new ArrayList();
				list.Add(new Fee());
				list.Add(new Fee());
				baz.Fees = list;
				s.Save(baz);
				s.Flush();
			}

			using (ISession s = OpenSession())
			{
				baz = (Baz) s.Get(typeof(Baz), baz.Code);
				NHibernateUtil.Initialize(baz.Fees);
			}

			Assert.AreEqual(2, baz.Fees.Count);

			using (ISession s = OpenSession())
			{
				s.Delete(baz);
				s.Flush();
				Assert.IsTrue(IsEmpty(s.CreateQuery("from Fee").Enumerable()));
			}
		}

		public void ProxiesInCollections()
		{
			ISession s = OpenSession();
			Baz baz = new Baz();
			Bar bar = new Bar();
			Bar bar2 = new Bar();
			s.Save(bar);
			object bar2id = s.Save(bar2);
			baz.FooArray = new Foo[] {bar, bar2};

			ISet hashset = new HashedSet();
			bar = new Bar();
			s.Save(bar);
			hashset.Add(bar);
			baz.FooSet = hashset;
			hashset = new HashedSet();
			hashset.Add(new Bar());
			hashset.Add(new Bar());
			baz.CascadingBars = hashset;
			ArrayList list = new ArrayList();
			list.Add(new Foo());
			baz.FooBag = list;
			object id = s.Save(baz);
			IEnumerator enumer = baz.CascadingBars.GetEnumerator();
			enumer.MoveNext();
			object bid = ((Bar) enumer.Current).Key;
			s.Flush();
			s.Close();

			s = OpenSession();
			BarProxy barprox = (BarProxy) s.Load(typeof(Bar), bid);
			BarProxy bar2prox = (BarProxy) s.Load(typeof(Bar), bar2id);
			Assert.IsTrue(bar2prox is INHibernateProxy);
			Assert.IsTrue(barprox is INHibernateProxy);
			baz = (Baz) s.Load(typeof(Baz), id);
			enumer = baz.CascadingBars.GetEnumerator();
			enumer.MoveNext();
			BarProxy b1 = (BarProxy) enumer.Current;
			enumer.MoveNext();
			BarProxy b2 = (BarProxy) enumer.Current;
			Assert.IsTrue(
				(b1 == barprox && !(b2 is INHibernateProxy))
				|| (b2 == barprox && !(b1 is INHibernateProxy))); //one-to-many
			Assert.IsTrue(baz.FooArray[0] is INHibernateProxy); //many-to-many
			Assert.AreEqual(bar2prox, baz.FooArray[1]);
			if (sessions.Settings.IsOuterJoinFetchEnabled)
			{
				enumer = baz.FooBag.GetEnumerator();
				enumer.MoveNext();
				Assert.IsFalse(enumer.Current is INHibernateProxy); // many-to-many outer-join="true"
			}

			enumer = baz.FooSet.GetEnumerator();
			enumer.MoveNext();
			Assert.IsFalse(enumer.Current is INHibernateProxy); //one-to-many
			s.Delete("from o in class Baz");
			s.Delete("from o in class Foo");
			s.Flush();
			s.Close();
		}

		public void OrphanDelete()
		{
			ISession s = OpenSession();
			ITransaction t = s.BeginTransaction();
			Baz baz = new Baz();
			IDictionary bars = new Hashtable();
			bars.Add(new Bar(), new object());
			bars.Add(new Bar(), new object());
			bars.Add(new Bar(), new object());
			s.Save(baz);
			t.Commit();
			s.Close();

			s = OpenSession();
			t = s.BeginTransaction();
			baz = (Baz) s.Load(typeof(Baz), baz.Code);
			IEnumerator enumer = bars.GetEnumerator();
			enumer.MoveNext();
			bars.Remove(enumer.Current);
			s.Delete(baz);
			enumer.MoveNext();
			bars.Remove(enumer.Current);
			s.Flush();

			Assert.AreEqual(0, s.CreateQuery("from Bar bar").List().Count);
			t.Commit();
			s.Close();
		}

		public void CachedCollection()
		{
			ISession s = OpenSession();
			Baz baz = new Baz();
			baz.SetDefaults();
			s.Save(baz);
			s.Flush();
			s.Close();

			s = OpenSession();
			baz = (Baz) s.Load(typeof(Baz), baz.Code);
			((FooComponent) baz.TopComponents[0]).Count = 99;
			s.Flush();
			s.Close();

			s = OpenSession();
			baz = (Baz) s.Load(typeof(Baz), baz.Code);
			Assert.AreEqual(99, ((FooComponent) baz.TopComponents[0]).Count);
			s.Delete(baz);
			s.Flush();
			s.Close();
		}

		public void ArraysOfTimes()
		{
			Baz baz;

			using (ISession s = OpenSession())
			{
				baz = new Baz();
				s.Save(baz);
				baz.SetDefaults();
				s.Flush();
			}

			using (ISession s = OpenSession())
			{
				baz.TimeArray[2] = new DateTime(123); // H2.1: new Date(123)
				baz.TimeArray[3] = new DateTime(1234); // H2.1: new java.sql.Time(1234)
				s.Update(baz); // missing in H2.1
				s.Flush();
			}

			using (ISession s = OpenSession())
			{
				baz = (Baz) s.Load(typeof(Baz), baz.Code);
				s.Delete(baz);
				s.Flush();
			}
		}

		public void CriteriaCollection()
		{
			ISession s = OpenSession();
			Baz bb = (Baz) s.CreateCriteria(typeof(Baz)).UniqueResult();
			Baz baz = new Baz();
			s.Save(baz);
			s.Flush();
			s.Close();

			s = OpenSession();
			Baz b = (Baz) s.CreateCriteria(typeof(Baz)).UniqueResult();
			Assert.IsTrue(NHibernateUtil.IsInitialized(b.TopGlarchez));
			Assert.AreEqual(0, b.TopGlarchez.Count);
			s.Delete(b);
			s.Flush();

			s.CreateCriteria(typeof(Baz))
				.CreateCriteria("TopFoos")
				.Add(Expression.IsNotNull("id"))
				.List();

			s.CreateCriteria(typeof(Baz))
				.CreateCriteria("Foo")
				.CreateCriteria("Component.Glarch")
				.CreateCriteria("ProxySet")
				.Add(Expression.IsNotNull("id"))
				.List();

			s.Close();
		}

		public void ComponentParent()
		{
			ISession s = OpenSession();
			ITransaction t = s.BeginTransaction();

			BarProxy bar = new Bar();
			bar.Component = new FooComponent();
			Baz baz = new Baz();
			baz.Components = new FooComponent[] {new FooComponent(), new FooComponent()};
			s.Save(bar);
			s.Save(baz);
			t.Commit();
			s.Close();

			s = OpenSession();
			t = s.BeginTransaction();

			bar = (BarProxy) s.Load(typeof(Bar), bar.Key);
			s.Load(baz, baz.Code);

			Assert.AreEqual(bar, bar.BarComponent.Parent);
			Assert.IsTrue(baz.Components[0].Baz == baz && baz.Components[1].Baz == baz);

			s.Delete(baz);
			s.Delete(bar);

			t.Commit();
			s.Close();
		}

		public void CollectionWhere()
		{
			Foo foo1 = new Foo();
			Foo foo2 = new Foo();
			Baz baz = new Baz();
			Foo[] arr = new Foo[10];
			arr[0] = foo1;
			arr[9] = foo2;

			ISession s = OpenSession();
			s.Save(foo1);
			s.Save(foo2);
			baz.FooArray = arr;
			s.Save(baz);
			s.Flush();
			s.Close();

			s = OpenSession();
			baz = (Baz) s.Load(typeof(Baz), baz.Code);
			Assert.AreEqual(1, baz.FooArray.Length);
			Assert.AreEqual(1, s.CreateQuery("from Baz baz join baz.FooArray foo").List().Count);
			Assert.AreEqual(2, s.CreateQuery("from Foo foo").List().Count);
			Assert.AreEqual(1, s.CreateFilter(baz.FooArray, "").List().Count);

			s.Delete("from Foo foo");
			s.Delete(baz);

			IDbCommand deleteCmd = s.Connection.CreateCommand();
			deleteCmd.CommandText = "delete from FooArray where id_='" + baz.Code + "' and i>=8";
			deleteCmd.CommandType = CommandType.Text;
			int rows = deleteCmd.ExecuteNonQuery();
			Assert.AreEqual(1, rows);

			s.Flush();
			s.Close();
		}

		public void NamedParams()
		{
			Bar bar = new Bar();
			Bar bar2 = new Bar();
			bar.Name = "Bar";
			bar2.Name = "Bar Two";
			Baz baz = new Baz();
			baz.CascadingBars = new HashedSet();
			baz.CascadingBars.Add(bar);
			bar.Baz = baz;

			ISession s = OpenSession();
			ITransaction txn = s.BeginTransaction();
			s.Save(baz);
			s.Save(bar2);

			IList list =
				s.CreateQuery("from Bar bar left join bar.Baz baz left join baz.CascadingBars b where bar.Name like 'Bar %'").List();
			object row = list[0];
			Assert.IsTrue(row is object[] && ((object[]) row).Length == 3);

			IQuery q = s.CreateQuery(
				"select bar, b " +
				"from Bar bar " +
				"left join bar.Baz baz left join baz.CascadingBars b " +
				"where (bar.Name in (:nameList) or bar.Name in (:nameList)) and bar.String = :stringVal");

			IList nameList = new ArrayList();
			nameList.Add("bar");
			nameList.Add("Bar");
			nameList.Add("Bar Two");
			q.SetParameterList("nameList", nameList);
			q.SetParameter("stringVal", "a string");
			list = q.List();
			// a check for SAPDialect here
			Assert.AreEqual(2, list.Count);

			q = s.CreateQuery(
				"select bar, b " +
				"from Bar bar " +
				"inner join bar.Baz baz inner join baz.CascadingBars b " +
				"where bar.Name like 'Bar%'");
			list = q.List();
			Assert.AreEqual(1, list.Count);

			q = s.CreateQuery(
				"select bar, b " +
				"from Bar bar " +
				"left join bar.Baz baz left join baz.CascadingBars b " +
				"where bar.Name like :name and b.Name like :name");

			// add a check for HSQLDialect
			q.SetString("name", "Bar%");
			list = q.List();
			Assert.AreEqual(1, list.Count);

			s.Delete(baz);
			s.Delete(bar2);
			txn.Commit();
			s.Close();
		}

		public void SaveAddDelete()
		{
			ISession s = OpenSession();
			Baz baz = new Baz();
			ISet bars = new HashedSet();
			baz.CascadingBars = bars;
			s.Save(baz);
			s.Flush();

			baz.CascadingBars.Add(new Bar());
			s.Delete(baz);
			s.Flush();
			s.Close();
		}

		public void IdBag()
		{
			ISession s = OpenSession();
			Baz baz = new Baz();
			s.Save(baz);

			IList l = new ArrayList();
			IList l2 = new ArrayList();

			baz.IdFooBag = l;
			baz.ByteBag = l2;

			l.Add(new Foo());
			l.Add(new Bar());

			byte[] bytes = GetBytes("ffo");
			l2.Add(bytes);
			l2.Add(GetBytes("foo"));
			s.Flush();

			l.Add(new Foo());
			l.Add(new Bar());
			l2.Add(GetBytes("bar"));
			s.Flush();

			object removedObject = l[3];
			l.RemoveAt(3);
			s.Delete(removedObject);

			bytes[1] = Convert.ToByte('o');
			s.Flush();
			s.Close();

			s = OpenSession();
			baz = (Baz) s.Load(typeof(Baz), baz.Code);
			Assert.AreEqual(3, baz.IdFooBag.Count);
			Assert.AreEqual(3, baz.ByteBag.Count);
			bytes = GetBytes("foobar");

			foreach (object obj in baz.IdFooBag)
			{
				s.Delete(obj);
			}
			baz.IdFooBag = null;
			baz.ByteBag.Add(bytes);
			baz.ByteBag.Add(bytes);
			s.Flush();
			s.Close();

			s = OpenSession();
			baz = (Baz) s.Load(typeof(Baz), baz.Code);
			Assert.AreEqual(0, baz.IdFooBag.Count);
			Assert.AreEqual(5, baz.ByteBag.Count);
			s.Delete(baz);
			s.Flush();
			s.Close();
		}

		public void ManyToManyBag()
		{
			ISession s = OpenSession();
			Baz baz = new Baz();
			object id = s.Save(baz);
			s.Flush();
			s.Close();

			s = OpenSession();
			baz = (Baz) s.Load(typeof(Baz), id);
			baz.FooBag.Add(new Foo());
			s.Flush();
			s.Close();

			s = OpenSession();
			baz = (Baz) s.Load(typeof(Baz), id);
			Assert.IsFalse(NHibernateUtil.IsInitialized(baz.FooBag));
			Assert.AreEqual(1, baz.FooBag.Count);

			Assert.IsTrue(NHibernateUtil.IsInitialized(baz.FooBag[0]));
			s.Delete(baz);
			s.Flush();
			s.Close();
		}

		public void QueryLockMode()
		{
			ISession s = OpenSession();
			ITransaction tx = s.BeginTransaction();

			Bar bar = new Bar();
			Assert.IsNull(bar.Bytes);
			s.Save(bar);
			Assert.IsNotNull(bar.Bytes);
			s.Flush();
			Assert.IsNotNull(bar.Bytes);

			bar.String = "changed";
			Baz baz = new Baz();
			baz.Foo = bar;
			s.Save(baz);
			Assert.IsNotNull(bar.Bytes);

			IQuery q = s.CreateQuery("from Foo foo, Bar bar");
			q.SetLockMode("bar", LockMode.Upgrade);
			object[] result = (object[]) q.List()[0];
			Assert.IsNotNull(bar.Bytes);

			object b = result[0];

			Assert.IsTrue(s.GetCurrentLockMode(b) == LockMode.Write && s.GetCurrentLockMode(result[1]) == LockMode.Write);
			tx.Commit();
			Assert.IsNotNull(bar.Bytes);
			s.Disconnect();

			s.Reconnect();
			tx = s.BeginTransaction();
			Assert.IsNotNull(bar.Bytes);

			Assert.AreEqual(LockMode.None, s.GetCurrentLockMode(b));
			Assert.IsNotNull(bar.Bytes);
			s.CreateQuery("from Foo foo").List();
			Assert.IsNotNull(bar.Bytes);
			Assert.AreEqual(LockMode.None, s.GetCurrentLockMode(b));
			q = s.CreateQuery("from Foo foo");
			q.SetLockMode("foo", LockMode.Read);
			q.List();

			Assert.AreEqual(LockMode.Read, s.GetCurrentLockMode(b));
			s.Evict(baz);

			tx.Commit();
			s.Disconnect();

			s.Reconnect();
			tx = s.BeginTransaction();

			Assert.AreEqual(LockMode.None, s.GetCurrentLockMode(b));
			s.Delete(s.Load(typeof(Baz), baz.Code));
			Assert.AreEqual(LockMode.None, s.GetCurrentLockMode(b));

			tx.Commit();
			s.Close();

			s = OpenSession();
			tx = s.BeginTransaction();
			q = s.CreateQuery("from Foo foo, Bar bar, Bar bar2");
			q.SetLockMode("bar", LockMode.Upgrade);
			q.SetLockMode("bar2", LockMode.Read);
			result = (object[]) q.List()[0];

			Assert.IsTrue(s.GetCurrentLockMode(result[0]) == LockMode.Upgrade &&
			              s.GetCurrentLockMode(result[1]) == LockMode.Upgrade);
			s.Delete(result[0]);
			tx.Commit();
			s.Close();
		}