C# IZetboxContext.Delete方法代码示例

 private static void MakeInternal(IZetboxContext ctx, ImportedFile obj, File doc)
 {
     // Clone blob, so it could be deleted
     doc.Blob = ctx.Find<Blob>(ctx.CreateBlob(ctx.GetFileInfo(obj.Blob.ID), obj.Blob.MimeType));
     doc.Name = obj.Name;
     ctx.Delete(obj);
 }

 public override void TearDown()
 {
     ctx = GetContext();
     var tdObj = ctx.GetQuery<TestObjClass>().Where(a => a.ID == originalId);
     foreach (var o in tdObj.ToList())
     {
         ctx.Delete(o);
     }
     base.TearDown();
 }

 /// <summary>
 /// Deletes all remaining test objects.
 /// </summary>
 /// <param name="ctx">this context is used to delete the objects</param>
 public static void DeleteData(IZetboxContext ctx)
 {
     ctx.GetQuery<Kunde>().ForEach(obj => ctx.Delete(obj));
     ctx.GetQuery<Auftrag>().ForEach(obj => ctx.Delete(obj));
     ctx.GetQuery<Task>().ForEach(obj => ctx.Delete(obj));
     ctx.GetQuery<Projekt>().ForEach(obj => { ctx.Delete(obj); });
     ctx.GetQuery<Mitarbeiter>().ForEach(obj => { ctx.Delete(obj); });
 }

        public static void Deploy(IZetboxContext ctx, params IPackageProvider[] providers)
        {
            if (ctx == null) { throw new ArgumentNullException("ctx"); }
            if (providers == null) { throw new ArgumentNullException("providers"); }

            using (Log.InfoTraceMethodCall("Deploy"))
            {
                Log.InfoFormat("Starting Deployment from {0}", string.Join(", ", providers.Select(p => p.ToString()).ToArray()));
                try
                {
                    // TODO: Das muss ich z.Z. machen, weil die erste Query eine Entity Query ist und noch nix geladen wurde....
                    var testObj = ctx.GetQuery<Zetbox.App.Base.ObjectClass>().FirstOrDefault();
                    Debug.WriteLine(testObj != null ? testObj.ToString() : String.Empty);
                }
                catch
                {
                    // Ignore
                }

                Dictionary<Guid, IPersistenceObject> currentObjects = new Dictionary<Guid, IPersistenceObject>();
                Log.Info("Loading namespaces");
                var names = providers.SelectMany(p => LoadModuleNames(p)).Distinct().ToList();
                if (names.Count == 0) throw new InvalidOperationException("No modules found in import file");

                foreach (var name in names)
                {
                    Log.InfoFormat("Prefetching objects for {0}", name);
                    var module = ctx.GetQuery<Zetbox.App.Base.Module>().FirstOrDefault(m => m.Name == name);
                    if (module != null)
                    {
                        foreach (var obj in PackagingHelper.GetMetaObjects(ctx, module))
                        {
                            currentObjects[((Zetbox.App.Base.IExportable)obj).ExportGuid] = obj;
                        }
                    }
                    else
                    {
                        Log.InfoFormat("Found new Module '{0}' in XML", name);
                    }
                }

                providers.ForEach(p => p.RewindData());
                Dictionary<Guid, IPersistenceObject> importedObjects = new Dictionary<Guid, IPersistenceObject>();
                Log.Info("Loading");

                foreach (var p in providers)
                {
                    var reader = p.Reader;
                    // Find Root Element
                    while (reader.Read() && reader.NodeType != XmlNodeType.Element && reader.LocalName != "ZetboxPackaging" && reader.NamespaceURI != "http://dasz.at/Zetbox") ;

                    // Read content
                    while (reader.Read())
                    {
                        if (reader.NodeType != XmlNodeType.Element) continue;
                        var obj = ImportElement(ctx, currentObjects, p);
                        if (obj == null) throw new InvalidOperationException("Invalid import format: ImportElement returned NULL");
                        importedObjects[((IExportableInternal)obj).ExportGuid] = obj;
                    }
                }

                Log.Info("Reloading References");
                foreach (var obj in importedObjects.Values)
                {
                    obj.ReloadReferences();
                }

                var objectsToDelete = currentObjects.Where(p => !importedObjects.ContainsKey(p.Key));
                Log.InfoFormat("Deleting {0} objects marked for deletion", objectsToDelete.Count());
                foreach (var pairToDelete in objectsToDelete)
                {
                    ctx.Delete(pairToDelete.Value);
                }
                Log.Info("Deployment finished");
            }
        }

        public override void TearDown()
        {
            ctx = GetContext();
            ReloadObjects(ctx);
            ctx.Delete(one1);
            ctx.Delete(one2);
            ctx.Delete(n1);
            ctx.Delete(n2);
            ctx.SubmitChanges();

            base.TearDown();
        }

 private void DoDelete(IZetboxContext ctx, IDataObject obj)
 {
     var deactivatable = obj as IDeactivatable;
     if (deactivatable == null
         || (ctx.IsElevatedMode && ViewModelFactory.GetDecisionFromUser(CommonCommandsResources.DeleteDataObjectCommand_ElevatedDeleteDeactivated, CommonCommandsResources.DeleteDataObjectCommand_ElevatedDeleteDeactivated_Title)))
     {
         ctx.Delete(obj);
     }
     else
     {
         deactivatable.IsDeactivated = true;
     }
 }

        /// <summary>
        /// Clears the destination zetbox tables. Due to FKs, ordering is required.
        /// </summary>
        private void ClearDestination(IZetboxContext ctx)
        {
            foreach (var log in ctx.GetQuery<MigrationLog>())
            {
                ctx.Delete(log);
            }
            ctx.SubmitChanges();

            // required ordering
            //executor.CleanDestination(tables["tbl_Cars"]);
            //executor.CleanDestination(tables["tbl_Customers"]);
        }