C# EntityQuery.Execute方法代码示例

    public async Task NullForeignKey() {
      await _emTask;
      var prod1 = new Product();
      
      _em1.AttachEntity(prod1);
      prod1.ProductName = "Test";
      prod1.SupplierID = null;

      var q0 = new EntityQuery<Product>().Where(p => p.Supplier != null).Take(2).Expand(p => p.Supplier);
      var r0 = (await q0.Execute(_em1)).ToList();
      Assert.IsTrue(r0.Count() == 2);
      Assert.IsTrue(r0.All(p => p.Supplier != null));
      var p0 = r0[0];
      var p1 = r0[1];
      var s0 = p0.Supplier;
      var s1 = p1.Supplier;

      Assert.IsTrue(s0.Products.Contains(p0));
      p0.Supplier = null;
      Assert.IsTrue(p0.SupplierID == null);
      Assert.IsTrue(!s0.Products.Contains(p0));
      
      Assert.IsTrue(s1.Products.Contains(p1));
      p1.SupplierID = null;
      Assert.IsTrue(p1.Supplier == null);
      Assert.IsTrue(!s1.Products.Contains(p1));
    }

    public async Task SaveCustomersAndNewOrder() {
      var em1 = await TestFns.NewEm(_serviceName);

      var q = new EntityQuery<Customer>("Customers").Where(c => c.CompanyName.StartsWith("A"));
      var custs = await q.Execute(em1);
      Assert.IsTrue(custs.Count() > 0, "should be some results");
      custs.ForEach(c => c.Fax = TestFns.MorphString(c.Fax));
      var cust1 = em1.CreateEntity<Customer>();
      cust1.CompanyName = "Test001";
      var cust1Key = cust1.EntityAspect.EntityKey;
      var order1 = em1.CreateEntity<Order>();
      var order1Key = order1.EntityAspect.EntityKey;

      order1.Customer = cust1;
      var custCount = em1.GetEntities<Customer>().Count();
      Assert.IsTrue(em1.HasChanges(), "hasChanges should be true");
      Assert.IsTrue(em1.GetChanges().Count() > 0, "should have changes");
      var saveResult = await em1.SaveChanges();
      Assert.IsTrue(saveResult.Entities.Count == custs.Count() + 2, "should have returned the correct number of entities");
      Assert.IsTrue(order1Key != order1.EntityAspect.EntityKey, "order1 entityKey should have changed");
      Assert.IsTrue(cust1Key != cust1.EntityAspect.EntityKey, "cust1 entityKey should have changed");
      Assert.IsTrue(order1.Customer == cust1, "cust attachment should be the same");
      Assert.IsTrue(cust1.Orders.Contains(order1), "order attachment should be the same");
      Assert.IsTrue(saveResult.KeyMappings[order1Key] == order1.EntityAspect.EntityKey, "keyMapping for order should be avail");
      Assert.IsTrue(saveResult.KeyMappings[cust1Key] == cust1.EntityAspect.EntityKey, "keyMapping for order should be avail");
      Assert.IsTrue(em1.GetEntities<Customer>().Count() == custCount, "should be the same number of custs");
      Assert.IsTrue(order1.EntityAspect.EntityState.IsUnchanged());
      Assert.IsTrue(cust1.EntityAspect.EntityState.IsUnchanged());
      Assert.IsTrue(em1.HasChanges() == false, "hasChanges should be false");
      Assert.IsTrue(em1.GetChanges().Count() == 0, "should be no changes left");
    }

    public async Task CustomersStartingWith() {
      await _emTask;

      var q = new EntityQuery<Customer>("CustomersStartingWith").WithParameter("companyName", "A");
      var rp = q.GetResourcePath();
      var customers = await q.Execute(_em1);
      Assert.IsTrue(customers.Count() > 0, "should be some results");
      Assert.IsTrue(customers.All(c => c.CompanyName.StartsWith("A")));

    }

    public async Task CustomersStartingWith() {
      var em1 = await TestFns.NewEm(_serviceName);

      var q = new EntityQuery<Customer>("CustomersStartingWith").WithParameter("companyName", "A");
      var rp = q.GetResourcePath(em1.MetadataStore);
      var customers = await q.Execute(em1);
      Assert.IsTrue(customers.Count() > 0, "should be some results");
      Assert.IsTrue(customers.All(c => c.CompanyName.StartsWith("A")));

    }

 public async Task LoadNavigationPropertyNonscalar() {
   var em1 = await TestFns.NewEm(_serviceName);
   TestFns.RunInWpfSyncContext( async () =>  {
     var q0 = new EntityQuery<Customer>().Where(c => c.Orders.Any()).Take(3);
     var r0 = await q0.Execute(em1);
     // Task.WaitAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders")).ToArray());
     await Task.WhenAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders")));
     Assert.IsTrue(r0.All(c => c.Orders.Count() > 0));
   });
 }

    public async Task SimpleSelect2() {
      await _emTask;

      var q1 = new EntityQuery<Customer>().Where(c => c.CompanyName.StartsWith("C")).Expand("Orders").Select(c => c.Orders);
      var r1 = await q1.Execute(_em1);
      Assert.IsTrue(r1.Count() > 0);
      //var ok = r1.All(c => c.GetType() == typeof(Customer));
      //Assert.IsTrue(ok);


    }

    public async Task SimpleSelect() {
      await _emTask;

      var q1 = new EntityQuery<Order>().Select(o => o.Customer).Take(5);
      var r1 = await q1.Execute(_em1);
      Assert.IsTrue(r1.Count() == 5);
      var ok = r1.All(c => c.GetType() == typeof(Customer));
      Assert.IsTrue(ok);


    }

    public async Task SimpleAnonEntityCollectionSelect() {
      await _emTask;

      var q1 = new EntityQuery<Customer>().Where(c => c.CompanyName.StartsWith("C")).Select(c => new { c.Orders });
      var r1 = await q1.Execute(_em1);
      Assert.IsTrue(r1.Count() > 0);
      var ok = r1.All(r => r.Orders.Count() > 0);
      Assert.IsTrue(ok);


    }

 public async Task CompanyNamesAndIds() {
   await _emTask;
   var q = new EntityQuery<Object>("CompanyNamesAndIds");
   var rp = q.GetResourcePath();
   var companyNamesAndIds = await q.Execute(_em1);
   Assert.IsTrue(companyNamesAndIds.Count() > 0, "should be some results");
   // each item is a JObject
   var companyNamesAndIdObjects = companyNamesAndIds.Cast<JObject>();
   var item = companyNamesAndIdObjects.First();
   var companyName = item["CompanyName"].ToObject<String>();
   var id = item["CustomerID"].ToObject<Guid>();
 }

    public async Task SimpleEntitySelect() {
      Assert.Inconclusive("Known issue with OData - use an anon projection instead");
      await _emTask;
      
      var q1 = new EntityQuery<Order>().Where(o => true).Select(o => o.Customer).Take(5);
      var r1 = await q1.Execute(_em1);
      Assert.IsTrue(r1.Count() == 5);
      var ok = r1.All(r => r.GetType() == typeof(Customer));
      Assert.IsTrue(ok);


    }

    public async Task ExpEntities() {
      var em1 = await TestFns.NewEm(_serviceName);

      var q = new EntityQuery<Foo.Customer>("Customers").Take(5);

      var results = await q.Execute(em1);

      Assert.IsTrue(results.Count() > 0);
      var exportedEntities = em1.ExportEntities();

      File.WriteAllText("c:/temp/emExport.txt", exportedEntities);

    }

    public async Task ExpEntities() {
      await _emTask;

      var q = new EntityQuery<Foo.Customer>("Customers").Take(5);

      var results = await q.Execute(_em1);

      Assert.IsTrue(results.Count() > 0);
      var exportedEntities = _em1.ExportEntities();

      File.WriteAllText("c:/temp/emExport.txt", exportedEntities);

    }

    public async Task CompanyNames() {
      await _emTask;

      var q = new EntityQuery<String>("CompanyNames");
      var rp = q.GetResourcePath();
      var companyNames = await q.Execute(_em1);
      Assert.IsTrue(companyNames.Count() > 0, "should be some results");

      var q2 = new EntityQuery<Object>("CompanyNames");
      rp = q2.GetResourcePath();
      var companyNames2 = await q2.Execute(_em1);
      Assert.IsTrue(companyNames2.Count() > 0, "should be some results");
      Assert.IsTrue(companyNames.SequenceEqual(companyNames2.Cast<String>()));
    }

    public async Task ExpEntitiesWithChanges() {
      var em1 = await TestFns.NewEm(_serviceName);

      var q = new EntityQuery<Foo.Customer>("Customers").Take(5);

      var results = await q.Execute(em1);

      Assert.IsTrue(results.Count() > 0);
      var custs = results.Take(2);
      custs.ForEach(c => c.City = "Paris");
      var emp1 = em1.CreateEntity<Employee>();

      var exportedEntities = em1.ExportEntities();

      File.WriteAllText("c:/temp/emExportWithChanges.txt", exportedEntities);

    }

	public async Task ExpImpEntitiesWithEnum()
	{
      var em1 = await TestFns.NewEm(_serviceName);

      var q = new EntityQuery<Foo.Role>("Roles").Take(5);

      var results = await q.Execute(em1);

      Assert.IsTrue(results.Any());
      var exportedEntities = em1.ExportEntities();

      File.WriteAllText("c:/temp/emExportWithEnum.txt", exportedEntities);

      var em2 = new EntityManager(em1);

      em2.ImportEntities(exportedEntities);
      var roleTypes = em2.GetEntities<Role>().Select(x => x.RoleType).ToList();

	  Assert.IsTrue(roleTypes.Count == 5, "should have imported 5 entities");
	}