C# EntityManager.ImportEntities方法代码示例

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

      var emp = new Employee();
      emp.FirstName = "Test Fn";
      emp.LastName = "Test Fn";
      em1.AddEntity(emp);
      var sr = await em1.SaveChanges();

      Assert.IsTrue(sr.Entities.Count == 1, "should have saved 1 entity");
      Assert.IsTrue(sr.Entities.First() == emp, "should be the same emp");
      var em2 = new EntityManager(em1);
      em2.ImportEntities(em1.ExportEntities());
      var sameEmp = (Employee) em2.GetEntities().First();
      Assert.IsTrue(emp.EntityAspect.EntityKey == sameEmp.EntityAspect.EntityKey, "should have the same key");
      sameEmp.EntityAspect.Delete();
      Assert.IsTrue(sameEmp.EntityAspect.EntityState.IsDeleted());
      var sr2 = await em2.SaveChanges();
      Assert.IsTrue(sr2.Entities.First() == sameEmp, "should still be the same emp");
      Assert.IsTrue(sameEmp.EntityAspect.EntityState.IsDetached());
      Assert.IsTrue(em2.GetEntities().Count() == 0, "should be no entities");

    }

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

      var queryOptions = new QueryOptions(FetchStrategy.FromServer, MergeStrategy.OverwriteChanges);
      var q0 = new EntityQuery<Customer>().Where(c => c.CompanyName != null && c.City != null)
         .With(MergeStrategy.OverwriteChanges);
      var r0 = (await em1.ExecuteQuery(q0)).ToList();
      Assert.IsTrue(r0.Count > 2);
      r0[0].CompanyName = null;
      r0[1].City = null;
      var exportedEntities = em1.ExportEntities(null, false);
      var em2 = new EntityManager(em1);
      em2.ImportEntities(exportedEntities);
      var ek0 = r0[0].EntityAspect.EntityKey;
      var ek1 = r0[1].EntityAspect.EntityKey;
      var e0 = em2.FindEntityByKey<Customer>(ek0);
      Assert.IsTrue(e0.CompanyName == null, "company name should be null");
      Assert.IsTrue(e0.EntityAspect.EntityState.IsModified());
      var e1 = em2.FindEntityByKey<Customer>(ek1);
      Assert.IsTrue(e1.City == null, "city should be null");
      Assert.IsTrue(e1.EntityAspect.EntityState.IsModified());
      em2.AcceptChanges();
      var exportedEntities2 = em2.ExportEntities(null, false);
      em1.ImportEntities(exportedEntities2, new ImportOptions(MergeStrategy.OverwriteChanges));
      Assert.IsTrue(em1.GetChanges().Count() == 0);

    }

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

      var c1 = new Customer() { CompanyName = "Test_1", City = "Oakland", RowVersion = 13, Fax = "510 999-9999" };
      var c2 = new Customer() { CompanyName = "Test_2", City = "Oakland", RowVersion = 13, Fax = "510 999-9999" };
      em1.AddEntity(c1);
      em1.AddEntity(c2);
      var sr = await em1.SaveChanges();
      Assert.IsTrue(sr.Entities.Count == 2);
      c1.EntityAspect.Delete();
      c2.CompanyName = TestFns.MorphString(c2.CompanyName);
      var exportedEntities = em1.ExportEntities(null, false);
      var em2 = new EntityManager(em1);
      em2.ImportEntities(exportedEntities);
      var c1x = em2.FindEntityByKey<Customer>(c1.EntityAspect.EntityKey);
      Assert.IsTrue(c1x.EntityAspect.EntityState.IsDeleted(), "should be deleted");
      var c2x = em2.FindEntityByKey<Customer>(c2.EntityAspect.EntityKey);
      Assert.IsTrue(c2x.CompanyName == c2.CompanyName, "company names should match");
    }

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

      var q = new EntityQuery<Foo.Supplier>("Suppliers").Where(s => s.CompanyName.StartsWith("P"));

      var suppliers = await q.Execute(em1);

      Assert.IsTrue(suppliers.Count() > 0, "should be some suppliers");
      var orderIdProp = MetadataStore.Instance.GetEntityType("Order").KeyProperties[0];
      em1.KeyGenerator.GetNextTempId(orderIdProp);

      var order1 = new Order();
      var emp1 = new Employee();
      em1.AddEntity(order1); em1.AddEntity(emp1);
      emp1.LastName = "bar";
      var cust1 = new Customer() { CompanyName = "Foo" };
      order1.Employee = emp1;
      order1.Customer = cust1;
      var exportedEm = em1.ExportEntities(null, false);

      var em2 = new EntityManager(em1);
      em2.ImportEntities(exportedEm);

      var suppliers2 = em2.GetEntities<Supplier>().ToList();
      Assert.IsTrue(suppliers.Count() == suppliers2.Count, "should be the same number of suppliers");
      var addedOrders = em2.GetEntities<Order>(EntityState.Added);
      Assert.IsTrue(addedOrders.Count() == 1, "should be 1 added order");
      var order1x = addedOrders.First();
      var cust1x = order1x.Customer;
      Assert.IsTrue(cust1x.CompanyName == "Foo", "customer company name should be 'Foo'");
      var emp1x = order1x.Employee;
      Assert.IsTrue(emp1x.LastName == "bar", "lastName should be 'bar'");

    }

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

      var q = new EntityQuery<Foo.Supplier>("Suppliers").Where(s => s.CompanyName.StartsWith("P"));

      var suppliers = await q.Execute(em1);
      suppliers.ForEach((s, i) => s.Location.Address = "Foo:" + i.ToString());
      Assert.IsTrue(suppliers.All(s => s.EntityAspect.EntityState.IsModified()));
      var exportedEm = em1.ExportEntities();
      var em2 = new EntityManager(em1);
      var impResult = em2.ImportEntities(exportedEm);
      Assert.IsTrue(impResult.ImportedEntities.Count == suppliers.Count());
      impResult.ImportedEntities.Cast<Supplier>().ForEach(s => {
        Assert.IsTrue(s.EntityAspect.OriginalValuesMap.Count == 0, "supplierOriginalValuesMap should be empty");
        var location = s.Location;
        Assert.IsTrue(location.Address.StartsWith("Foo"), "address should start with 'Foo'");
        Assert.IsTrue(location.ComplexAspect.OriginalValuesMap.ContainsKey("Address"), "ComplexAspect originalValues should contain address");

      });
    }

        public async Task ExportImportFromIsolatedStorage()
        {
            var manager1 = new EntityManager(_serviceName);
            await PrimeCache(manager1);
            var expectedEntityCount = manager1.GetEntities().Count();

            var exportData = manager1.ExportEntities();

            var isoStore = IsolatedStorageFile.GetStore(IsolatedStorageScope.User | IsolatedStorageScope.Assembly, null, null);
            string importData;
            using (var isoStream = new IsolatedStorageFileStream("ExportEntities.txt", FileMode.Create, isoStore))
            {
                using (var writer = new StreamWriter(isoStream))
                {
                    writer.Write(exportData);
                }
            }

            using (var isoStream = new IsolatedStorageFileStream("ExportEntities.txt", FileMode.Open, isoStore))
            {
                using (var reader = new StreamReader(isoStream))
                {
                    importData = reader.ReadToEnd();
                }
            }
            
            // import into a new EntityManager
            var manager2 = new EntityManager(_serviceName);
            manager2.ImportEntities(importData);

            Assert.AreEqual(expectedEntityCount, manager2.GetEntities().Count());
        }

    public async Task ExpImpSelectedEntitiesWithChanges() {
      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).ToList();
      custs.ForEach(c => c.City = "Paris");
      var emp1 = em1.CreateEntity<Employee>();
      var emp2 = em1.CreateEntity<Employee>();

      var exportedEntities = em1.ExportEntities(new IEntity[] { custs[0], custs[1], emp1, emp2 }, false);

      var em2 = new EntityManager(em1);
      var impResult = em2.ImportEntities(exportedEntities);
      var allEntities = em2.GetEntities();

      Assert.IsTrue(impResult.ImportedEntities.Count == 4, "should have imported 4 entities");
      Assert.IsTrue(impResult.TempKeyMap.Count == 2);
      Assert.IsTrue(impResult.TempKeyMap.All(kvp => kvp.Key == kvp.Value), "imported entities should have same key values");
      Assert.IsTrue(allEntities.Count() == 4, "should have 4 entities in cache");
      Assert.IsTrue(em2.GetEntities<Customer>().All(c => c.EntityAspect.EntityState.IsModified()));
      Assert.IsTrue(em2.GetEntities<Employee>().All(c => c.EntityAspect.EntityState.IsAdded()));

    }

        public async Task ImportChangedEntityAndRestoreItsOriginalState()
        {
            var manager = new EntityManager(_serviceName);
            await manager.FetchMetadata(); // Metadata must be fetched before CreateEntity() can be called

            // Suppose we are editing a customer
            const string originalCustomerName = "Foo";
            var customer =
                manager.CreateEntity<Customer>(new {CustomerID = Guid.NewGuid(), CompanyName = originalCustomerName},
                                               EntityState.Unchanged);

            // We change his CompanyName
            customer.CompanyName = "Bar";

            // We export and stash these changes offline
            // because we are not ready to save them
            // (in the test we just export)
            var exportData = manager.ExportEntities();

            // We re-run the app later with a clean manager
            manager.Clear();

            var imported = manager.ImportEntities(exportData);
            customer = imported.ImportedEntities.Cast<Customer>().First();

            // We want to revert our changes and restore the customer to its original state
            customer.EntityAspect.RejectChanges();

            Assert.AreEqual(originalCustomerName, customer.CompanyName);
        }

        public async Task ExportImportUnchangedEntities()
        {
            var manager = new EntityManager(_serviceName);
            await PrimeCache(manager);

            // modify one of the entities
            var customer = manager.GetEntities<Customer>().First();
            customer.City = "Paris";
            var expectedUnchangedEntityCount = manager.GetEntities().Count() - 1;

            // export only Unchanged entities
            var exportData = manager.ExportEntities(manager.GetEntities(EntityState.Unchanged));

            // import into a new EntityManager
            var manager2 = new EntityManager(_serviceName);
            manager2.ImportEntities(exportData);

            Assert.AreEqual(expectedUnchangedEntityCount, manager2.GetEntities().Count());
        }

        public async Task ExportImportEntitiesWithoutMetadata()
        {
            var manager1 = new EntityManager(_serviceName);
            await PrimeCache(manager1);
            var selectedEntities = manager1.GetEntities<Customer>().ToList();

            // export the selected entities without metadata
            var exportData = manager1.ExportEntities(selectedEntities, false);

            //TODO: What is the equivalent in breeze.sharp?
            // a virginal manager would throw exception on import
            // because it lacks the metadata
            // var em2 = new EntityManager(); 
            
            // creates a new EntityManager with the same configuration as another EntityManager but without any entities
            var manager2 = new EntityManager(manager1);
            var importResult = manager2.ImportEntities(exportData);

            Assert.AreEqual(selectedEntities.Count(), importResult.ImportedEntities.Count);
        }

        public async Task TemporaryKeyNotPreservedOnImport()
        {
            // If an earlier test has already created an entity, a new entity will not be assigned a key value of -1
            // Simulate initial launch of the client app
            SimulateResetTempKeyGeneratorSeed();

            var manager1 = new EntityManager(_serviceName);
            await manager1.FetchMetadata(); // Metadata must be fetched before CreateEntity() can be called

            // Create a new Order. The Order key is store-generated.
            // Until saved, the new Order has a temporary key such as '-1'.
            var acme1 = manager1.CreateEntity<Order>(new {ShipName = "Acme"});
            Assert.AreEqual(-1, acme1.OrderID, "Initial entity not assigned temp key -1");
 
            // export without metadata
            var exported = manager1.ExportEntities(new IEntity[] {acme1}, false);
 
            // ... much time passes 
            // ... the client app is re-launched
            // ... the seed for the temporary id generator was reset
            SimulateResetTempKeyGeneratorSeed();

            // Create a new manager2 with metadata
            var manager2 = new EntityManager(manager1);

            // Add a new order to manager2
            // This new order has a temporary key.
            // That key could be '-1' ... the same key as acme1!!!
            var beta = (Order) manager2.CreateEntity(typeof (Order), new {ShipName = "Beta"});

            // Its key will be '-1' ... the same key as acme1!!!
            Assert.AreEqual(-1, beta.OrderID);
 
            // Import the the exported acme1 from manager1
            // and get the newly merged instance from manager2
            var imported = manager2.ImportEntities(exported);
            var acme2 = imported.ImportedEntities.Cast<Order>().First();
 
            // compare the "same" order as it is in managers #1 and #2  
            var isSameName = acme1.ShipName == acme2.ShipName; // true
            Assert.IsTrue(isSameName, "ShipNames should be the same");

            // breeze had to update the acme key in manager2 because 'beta' already has ID==-1   
            var isSameId = acme1.OrderID == acme2.OrderID; // false; temporary keys are different
            Assert.IsFalse(isSameId, "OrderIDs (temporary keys) should be different");

        }

        public async Task ExportImportSelectedEntities()
        {
            var manager = new EntityManager(_serviceName);
            var manager2 = new EntityManager(_serviceName);
            await PrimeCache(manager);
            var customers = manager.GetEntities<Customer>().ToList();

            var exportData1 = manager.ExportEntities(new IEntity[] {customers[0]}); // array with 1 customer
            var importData1 = manager2.ImportEntities(exportData1);
            Assert.AreEqual(1, importData1.ImportedEntities.Count);
            manager2.Clear();

            var exportData2 = manager.ExportEntities(new IEntity[] {customers[0], customers[1]}); // array of 2 customers
            var importData2 = manager2.ImportEntities(exportData2);
            Assert.AreEqual(2, importData2.ImportedEntities.Count);
            manager2.Clear();

            Assert.AreEqual(0, manager.GetChanges().Count());
            customers.First().City = "Paris";
            var exportData3 = manager.ExportEntities(manager.GetChanges()); // all pending changes
            var importData3 = manager2.ImportEntities(exportData3);
            Assert.AreEqual(1, importData3.ImportedEntities.Count);
            manager2.Clear();

            var selectedCustomerQuery = new EntityQuery<Customer>().Where(customer => customer.City.StartsWith("P"));
            var selectedCustomers = manager.ExecuteQueryLocally(selectedCustomerQuery); // cache-only query returns synchronously
            var exportData4 = manager.ExportEntities(selectedCustomers); // the 'P' customers 
            var importData4 = manager2.ImportEntities(exportData4);
            Assert.AreEqual(1, importData4.ImportedEntities.Count);
        }

        public async Task ExportImportEntitiesOverwriteChanges()
        {
            var manager1 = new EntityManager(_serviceName);
            await PrimeCache(manager1);

            // modify all the customers in manager1
            var parisCustomers = manager1.GetEntities<Customer>().ToList();
            parisCustomers.ForEach(c => c.City = "Paris");

            var exportData = manager1.ExportEntities();

            var manager2 = new EntityManager(_serviceName);
            await PrimeCache(manager2);

            // modify all the "same" customers in manager2 
            var londonCustomers = manager2.GetEntities<Customer>().ToList();
            londonCustomers.ForEach(c => c.City = "London");

            // overwrite changes in manager2 with the exported data
            manager2.ImportEntities(exportData, new ImportOptions(MergeStrategy.OverwriteChanges));
            // all the customers should now be in "Paris"
            Assert.IsTrue(manager2.GetEntities<Customer>().All(c => c.City == "Paris"), "All cities should = Paris");
        }

        public async Task ExportImportEntitiesPreserveChanges()
        {
            var manager1 = new EntityManager(_serviceName);
            await PrimeCache(manager1);

            // modify all the customers in manager1
            var parisCustomers = manager1.GetEntities<Customer>().ToList();
            parisCustomers.ForEach(c => c.City = "Paris");

            var exportData = manager1.ExportEntities();

            var manager2 = new EntityManager(_serviceName);
            await PrimeCache(manager2);

            // modify all the "same" customers in manager2 
            var londonCustomers = manager2.GetEntities<Customer>().ToList();
            londonCustomers.ForEach(c => c.City = "London");

            // changes in manager2 are preserved by default
            var importResult = manager2.ImportEntities(exportData);

            // so nothing should have been imported
            Assert.AreEqual(0, importResult.ImportedEntities.Count);
            Assert.AreEqual(londonCustomers.Count, manager2.GetEntities().Count());
            // all the customers should still be in "London"
            Assert.IsTrue(manager2.GetEntities<Customer>().All(c => c.City == "London"), "All cities should = London");
        }

        public async Task ExportImportEntities()
        {
            var manager1 = new EntityManager(_serviceName);
            await PrimeCache(manager1);
            var expectedEntityCount = manager1.GetEntities().Count();

            var exportData = manager1.ExportEntities();

            // import into a new EntityManager
            var manager2 = new EntityManager(_serviceName);
            manager2.ImportEntities(exportData);

            Assert.AreEqual(expectedEntityCount, manager2.GetEntities().Count());
        }