C# UITableView.InsertRows方法代码示例

        public override void CommitEditingStyle(UITableView tableView, UITableViewCellEditingStyle editingStyle, MonoTouch.Foundation.NSIndexPath indexPath)
        {
            switch (editingStyle) {
            case UITableViewCellEditingStyle.Delete:
                // remove the item from the underlying data source
                this.RaiseTaskDeleted(indexPath.Row);
                tableItems.RemoveAt(indexPath.Row);
                // delete the row from the table
                tableView.DeleteRows (new NSIndexPath[] { indexPath }, UITableViewRowAnimation.Fade);

                break;

            case UITableViewCellEditingStyle.Insert:
                //---- create a new item and add it to our underlying data

                Item obj = new Item();
                obj.Name = "Inserted";
                obj.Description ="Placeholder";
            //				obj.imageFileName = "second.png";

                tableItems.Insert (indexPath.Row, obj);

                //---- insert a new row in the table
                tableView.InsertRows (new NSIndexPath[] { indexPath }, UITableViewRowAnimation.Fade);
                break;

            case UITableViewCellEditingStyle.None:
                Console.WriteLine ("CommitEditingStyle:None called");
                break;
            }
        }

		void expandItemAtIndex(UITableView tableView, int index)
		{
			int insertPos = index + 1;
			key = false;

			tableView.InsertRows(new[] {NSIndexPath.FromRowSection(insertPos++, 0)}, UITableViewRowAnimation.Fade);

		}

 public TasksTableViewSource(UITableView view, ObservableCollection<TodoItem> todos)
 {
     this.todos = todos;
     todos.CollectionChanged += (object sender, NotifyCollectionChangedEventArgs e) => {
         if (e.NewItems != null) {
             var newPaths = e.NewItems.OfType<TodoItem> ().Select (ni => NSIndexPath.FromRowSection (todos.Count - 1, 0))
                 .ToArray ();
             view.InsertRows (newPaths, UITableViewRowAnimation.Top);
         }
     };
 }

		public override void ViewDidLoad ()
		{
			base.ViewDidLoad ();
			table = new UITableView(View.Bounds); // defaults to Plain style
			table.AutoresizingMask = UIViewAutoresizing.All;
			List<TableItem> tableItems = new List<TableItem>();
			
			// credit for images and content
			// http://en.wikipedia.org/wiki/List_of_culinary_vegetables
			tableItems.Add (new TableItem("Vegetables") { SubHeading="65 items", ImageName="Vegetables.jpg"});
			tableItems.Add (new TableItem("Fruits") { SubHeading="17 items", ImageName="Fruits.jpg"});
			tableItems.Add (new TableItem("Flower Buds") { SubHeading="5 items", ImageName="Flower Buds.jpg"});
			tableItems.Add (new TableItem("Legumes") { SubHeading="33 items", ImageName="Legumes.jpg"});
			tableItems.Add (new TableItem("Bulbs") { SubHeading="18 items", ImageName="Bulbs.jpg"});
			tableItems.Add (new TableItem("Tubers") { SubHeading="43 items", ImageName="Tubers.jpg"});
			tableSource = new TableSource(tableItems, this);
			table.Source = tableSource;

			// To replace the standard edit button with a "Hi" button, uncomment out
			// these lines
			 tableDelegate = new TableDelegate ();
			 table.Delegate = tableDelegate;

			
			@add = new UIBarButtonItem(UIBarButtonSystemItem.Add, (s,e)=>{
				tableItems.Insert (0, new TableItem ("(inserted)") { SubHeading="0 items"}); // default new row
				table.InsertRows (new NSIndexPath[] { NSIndexPath.FromRowSection(0,0) }, UITableViewRowAnimation.Fade);
			});

			done = new UIBarButtonItem(UIBarButtonSystemItem.Done, (s,e)=>{
				table.SetEditing (false, true);
				NavigationItem.LeftBarButtonItem = @add;
				NavigationItem.RightBarButtonItem = edit;
			});

			edit = new UIBarButtonItem(UIBarButtonSystemItem.Edit, (s,e)=>{
				if (table.Editing)
					table.SetEditing (false, true); // if we've half-swiped a row

				table.SetEditing (true, true);
				NavigationItem.LeftBarButtonItem = null;
				NavigationItem.RightBarButtonItem = done;
				
			});

			NavigationItem.RightBarButtonItem = edit;
			NavigationItem.LeftBarButtonItem = @add;


			
			Add (table);
		}

        public TasksTableViewSource(UITableView tableView, TaskManager taskManager)
        {
            _taskManager = taskManager;
            _taskManager.TodoItems.CollectionChanged += (object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => {
            //				if (e.OldItems != null)
            //				{
            //					NSIndexPath[] oldPaths = e.OldItems.OfType<TodoItem>().Select(oi => NSIndexPath.FromRowSection(tasks.IndexOf(oi), 0)).ToArray();
            //					tableView.DeleteRows(oldPaths, UITableViewRowAnimation.Top);
            //				}

                if (e.NewItems != null)
                {
                    var newPaths = e.NewItems.OfType<TodoItem>().Select(ni => NSIndexPath.FromRowSection(_taskManager.TodoItems.Count - 1, 0)).ToArray();
                    tableView.InsertRows(newPaths, UITableViewRowAnimation.Top);
                }
            };
        }

        public override void CommitEditingStyle(UITableView tableView, UITableViewCellEditingStyle editingStyle, NSIndexPath indexPath)
        {
            switch (editingStyle) {
                case UITableViewCellEditingStyle.Delete:
                    // remove the item from the underlying data source
                    tableItems.RemoveAt(indexPath.Row);
                    // delete the row from the table
                    tableView.DeleteRows (new NSIndexPath[] { indexPath }, UITableViewRowAnimation.Fade);
                    break;

                case UITableViewCellEditingStyle.Insert:
                    //---- create a new item and add it to our underlying data
                    tableItems.Insert (indexPath.Row, new TableItem ("(inserted)"));
                    //---- insert a new row in the table
                    tableView.InsertRows (new NSIndexPath[] { indexPath }, UITableViewRowAnimation.Fade);
                    break;

                case UITableViewCellEditingStyle.None:
                    Console.WriteLine ("CommitEditingStyle:None called");
                    break;
            }
        }

        public override void CommitEditingStyle(UITableView tableView, UITableViewCellEditingStyle editingStyle, MonoTouch.Foundation.NSIndexPath indexPath)
        {
            switch (editingStyle) {
                case UITableViewCellEditingStyle.Delete:
                    // remove the item from the underlying data source
                    tableItems.RemoveAt(indexPath.Row);
                    // delete the row from the table
                    tableView.DeleteRows (new NSIndexPath[] { indexPath }, UITableViewRowAnimation.Fade);

                    var path = Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments);

                    DirectoryInfo dr = new DirectoryInfo(path);
                    FileInfo [] f  =  new FileInfo [10];

                    f = dr.GetFiles();

                    foreach (var file in f) {

                        File.Delete(file.FullName);

                    }

                    break;

                case UITableViewCellEditingStyle.Insert:
                    //---- create a new item and add it to our underlying data
                    tableItems.Insert (indexPath.Row, new TableItem ("(inserted)"));
                    //---- insert a new row in the table
                    tableView.InsertRows (new NSIndexPath[] { indexPath }, UITableViewRowAnimation.Fade);
                    break;

                case UITableViewCellEditingStyle.None:
                    Console.WriteLine ("CommitEditingStyle:None called");
                    break;
            }
        }

        public void BeginEditing(UITableView tableView)
        {
            // Select all.
            for (int i = 0; i < shownCourses.Count; i++)
                tableView.SelectRow(NSIndexPath.FromRowSection((nint)i, 0), true, UITableViewScrollPosition.None);

            var hidden = HiddenPaths();
            tableView.BeginUpdates();
            tableView.InsertRows(hidden, UITableViewRowAnimation.Top);
            shownCourses = courses;
            tableView.EndUpdates();
        }

		/// <summary>
		/// Called manually when the table goes into edit mode
		/// </summary>
		public void WillBeginTableEditing(UITableView tableView)
		{
			//---- start animations
			tableView.BeginUpdates();

			//---- insert a new row in the table
			tableView.InsertRows(new NSIndexPath[] { NSIndexPath.FromRowSection(tableView.NumberOfRowsInSection(0), 0) }, UITableViewRowAnimation.Fade);
		
			//---- end animations
			tableView.EndUpdates();
		}

        public ReactiveTableViewSource(UITableView tableView, IEnumerable<TableSectionInformation> sectionInformation)
        {
            this.tableView = tableView;
            this.sectionInformation = sectionInformation.ToList();

            var compositeDisp = new CompositeDisposable();
            this.innerDisp = compositeDisp;

            for (int i=0; i < this.sectionInformation.Count; i++) {
                var current = this.sectionInformation[i].Collection;

                var section = i;
                var disp = current.Changed.Buffer(TimeSpan.FromMilliseconds(250), RxApp.MainThreadScheduler).Subscribe(xs => {
                    if (xs.Count == 0) return;

                    this.Log().Info("Changed contents: [{0}]", String.Join(",", xs.Select(x => x.Action.ToString())));
                    if (xs.Any(x => x.Action == NotifyCollectionChangedAction.Reset)) {
                        this.Log().Info("About to call ReloadData");
                        tableView.ReloadData();
                        return;
                    }

                    int prevItem = -1;
                    var changedIndexes = xs.SelectMany(x => getChangedIndexes(x)).ToList();
                    changedIndexes.Sort();
                    for(int j=0; j < changedIndexes.Count; j++) {
                        // Detect if we're changing the same cell more than 
                        // once - if so, issue a reset and be done
                        if (prevItem == changedIndexes[j] && j > 0) {
                            this.Log().Info("Detected a dupe in the changelist. Issuing Reset");
                            tableView.ReloadData();
                            return;
                        }

                        prevItem = changedIndexes[j];
                    }

                    this.Log().Info("Beginning update");
                    tableView.BeginUpdates();

                    var toChange = default(NSIndexPath[]);
                    foreach(var update in xs.Reverse()) {
                        switch(update.Action) {
                        case NotifyCollectionChangedAction.Add:
                            toChange = Enumerable.Range(update.NewStartingIndex, update.NewItems != null ? update.NewItems.Count : 1)
                                .Select(x => NSIndexPath.FromRowSection(x, section))
                                .ToArray();
                            this.Log().Info("Calling InsertRows: [{0}]", String.Join(",", toChange.Select(x => x.Section + "-" + x.Row)));
                            tableView.InsertRows(toChange, UITableViewRowAnimation.Automatic);
                            break;
                        case NotifyCollectionChangedAction.Remove:
                            toChange = Enumerable.Range(update.OldStartingIndex, update.OldItems != null ? update.OldItems.Count : 1)
                                .Select(x => NSIndexPath.FromRowSection(x, section))
                                .ToArray();
                            this.Log().Info("Calling DeleteRows: [{0}]", String.Join(",", toChange.Select(x => x.Section + "-" + x.Row)));
                            tableView.DeleteRows(toChange, UITableViewRowAnimation.Automatic);
                            break;
                        case NotifyCollectionChangedAction.Replace:
                            toChange = Enumerable.Range(update.NewStartingIndex, update.NewItems != null ? update.NewItems.Count : 1)
                                .Select(x => NSIndexPath.FromRowSection(x, section))
                                .ToArray();
                            this.Log().Info("Calling ReloadRows: [{0}]", String.Join(",", toChange.Select(x => x.Section + "-" + x.Row)));
                            tableView.ReloadRows(toChange, UITableViewRowAnimation.Automatic);
                            break;
                        case NotifyCollectionChangedAction.Move:
                            // NB: ReactiveList currently only supports single-item 
                            // moves
                            this.Log().Info("Calling MoveRow: {0}-{1} => {0}{2}", section, update.OldStartingIndex, update.NewStartingIndex);
                            tableView.MoveRow(
                                NSIndexPath.FromRowSection(update.OldStartingIndex, section),
                                NSIndexPath.FromRowSection(update.NewStartingIndex, section));
                            break;
                        default:
                            this.Log().Info("Unknown Action: {0}", update.Action);
                            break;
                        }
                    }

                    this.Log().Info("Ending update");
                    tableView.EndUpdates();
                });

                compositeDisp.Add(disp);
            }
        }

 public override void CommitEditingStyle (UITableView tableView, UITableViewCellEditingStyle editingStyle, NSIndexPath indexPath)
 {
     // check if the edit operation was a delete
     if (editingStyle == UITableViewCellEditingStyle.Delete) {
         
         // remove the customer from the underlying data
         _vc.Customers.RemoveAt (indexPath.Row);
         
         // remove the associated row from the tableView
         tableView.DeleteRows (new NSIndexPath[] { indexPath }, UITableViewRowAnimation.Middle);
     } else if (editingStyle == UITableViewCellEditingStyle.Insert) {
         _vc.Customers.Add (new Customer ("First", "Last"));
         tableView.InsertRows (new NSIndexPath[] { NSIndexPath.FromRowSection (_vc.Customers.Count - 1, 0) }, UITableViewRowAnimation.None);
     }
 }

        public override void RowSelected(UITableView tableView, NSIndexPath indexPath)
        {
            tableView.DeselectRow(indexPath, true);

            var node = Nodes[indexPath.Row];
            var children = new List<TreeNode>();
            node.IsExpanded = true;
            if (node.Children.Any())
            {
                children.AddRange(node.Children);

                var isInserted = false;

                foreach (int index in children.Select(child => Nodes.IndexOf(child)))
                {
                    isInserted = (index > 0 && index != int.MaxValue);
                    if (isInserted)
                    {
                        break;
                    }
                }

                var arrayCells = new List<NSIndexPath>();
                if (isInserted)
                {
                    ColapseRow(tableView, children);
                    tableView.ReloadData();
                }
                else
                {
                    var count = indexPath.Row + 1;

                    foreach (var treeNode in children)
                    {
                        treeNode.IsExpanded = false;
                        //if there's  Parent's children not selected remove them
                        var nodesToRemove = new List<TreeNode>();

                        if (treeNode.Parent != null)
                        {
                            if (treeNode.Parent.Children.Any() && treeNode.Parent.Parent != null)
                            {
                                nodesToRemove.AddRange(treeNode.Parent.Parent.Children.Where(x=>!x.IsExpanded));

                                if (nodesToRemove.Any())
                                {
                                    ColapseRow(tableView, nodesToRemove);
                                }
                            }
                        }

                        arrayCells.Add(NSIndexPath.FromRowSection(count, 0));
                        Nodes.Insert(count++, treeNode);
                    }

                    tableView.InsertRows(arrayCells.ToArray(), UITableViewRowAnimation.None);

                    tableView.ReloadData();
                }
            }
        }

 public void WillBeginTableEditing(UITableView tableView)
 {
     tableView.BeginUpdates ();
     // insert the 'ADD NEW' row at the end of table display
     tableView.InsertRows (new NSIndexPath[] {
         NSIndexPath.FromRowSection (tableView.NumberOfRowsInSection (0), 0)
     }, UITableViewRowAnimation.Fade);
     // create a new item and add it to our underlying data (it is not intended to be permanent)
     Item o = new Item ();
     o.Name = "(add new)";
     //			o.imageFileNames = new List<string> ();
     o.ImageFileName = "first.png";
     tableItems.Add (o);
     tableView.EndUpdates (); // applies the changes
 }

        private void InsertRows(TreeItem treeItem, UITableView tableView, int selectedItemIndex)
        {
            if (treeItem.Childrens != null) {
                var itemsToInsert = new List<TreeItem> (treeItem.Childrens);
                var itemsToInsertPath = new List<NSIndexPath> ();

                foreach (var item in itemsToInsert) {
                    selectedItemIndex++;
                    _items.Insert (selectedItemIndex, item);
                    itemsToInsertPath.Add (NSIndexPath.FromRowSection (selectedItemIndex, 0));
                }
                tableView.InsertRows (itemsToInsertPath.ToArray (), UITableViewRowAnimation.Bottom);
                treeItem.IsExpanded = true;
            }
        }

		/// <summary>
		/// Called manually when the table goes into edit mode
		/// </summary>
		public void WillBeginTableEditing (UITableView tableView)
		{
			//---- start animations
			tableView.BeginUpdates ();
			
			//---- insert a new row in the table
			tableView.InsertRows (new NSIndexPath[] { 
					NSIndexPath.FromRowSection (tableView.NumberOfRowsInSection (0), 0) 
				}, UITableViewRowAnimation.Fade);
			//---- create a new item and add it to our underlying data
			tableItems.Add (new TableItem ("(add new)"));
			
			//---- end animations
			tableView.EndUpdates ();
		}