C# SharpTreeNode.OfType方法代码示例

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var types = selectedNodes
                .OfType<TypeTreeNode>()
                .Select(n => HAL.Converter.Type(n.TypeDefinition))
                .ToArray();

            Services.BrowseInteractions(types, true);
        }

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var assemblyDefinitions = selectedNodes
                .OfType<AssemblyTreeNode>()
                .Select(n => n.LoadedAssembly.AssemblyDefinition)
                .ToList();

            var window = WindowManager.AssemblyBrowsers.Single();
            window.ViewModel.AddAssemblies(assemblyDefinitions);
        }

		protected override IDataObject GetDataObject(SharpTreeNode[] nodes)
		{
			string[] data = nodes
				.OfType<XamlOutlineNode>()
				.Select(item => item.GetMarkupText())
				.ToArray();
			var dataObject = new DataObject();
			dataObject.SetData(typeof(string[]), data);
			
			return dataObject;
		}

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var typeDefinition = selectedNodes
                .OfType<TypeTreeNode>()
                .Single().TypeDefinition;

            var window = new AncestryBrowserWindow(typeDefinition)
                         	{
                         		Owner = MainWindow.Instance
                         	};
            window.Show();
        }

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var assemblyDefinitions = selectedNodes
                .OfType<AssemblyTreeNode>()
                .Select(n => n.LoadedAssembly.AssemblyDefinition);

            var window = new DependencyBrowserWindow(assemblyDefinitions.Select(HAL.Converter.Assembly))
            {
                Owner = Services.MainWindow
            };
            window.Show();
        }

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var types = selectedNodes
                .OfType<TypeTreeNode>()
                .Select(n => HAL.Converter.Type(n.TypeDefinition))
                .ToArray();

            var window = new InteractionBrowserWindow(types, true)
            {
                Owner = MainWindow.Instance
            };
            window.Show();
        }

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var assemblyDefinitions = selectedNodes
                .OfType<AssemblyTreeNode>()
                .Select(n => n.LoadedAssembly.AssemblyDefinition)
                .ToList();

            var window = new AssemblyBrowserWindow(assemblyDefinitions)
                         	{
                         		Owner = MainWindow.Instance
                         	};
            window.Show();
        }

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var typeDefinition = selectedNodes
                .OfType<TypeTreeNode>()
                .Single().TypeDefinition;
            var type = HAL.Converter.Type(typeDefinition);
            var assembly = type.Module.Assembly;

            var window = new AssemblyBrowserWindow(new [] { assembly }, type)
            {
                Owner = MainWindow.Instance
            };
            window.Show();
        }

//		public override void Drop(IDataObject data, int index, DropEffect finalEffect)
//		{
//			try {
//				string insertText = (data.GetData(typeof(string[])) as string[])
//					.Aggregate((text, part) => text += part);
//				ITextAnchor marker;
//				int length = 0;
//				if (index == this.Children.Count) {
//					if (index == 0)
//						marker = null;
//					else
//						marker = (this.Children[index - 1] as XamlOutlineNode).EndMarker;
//					if (marker == null) {
//						marker = this.EndMarker;
//						length = -1; // move backwards
//					} else {
//						length = 2 + (this.Children[index - 1] as XamlOutlineNode).elementName.Length;
//					}
//				} else
//					marker = (this.Children[index] as XamlOutlineNode).Marker;
//
//				int offset = marker.Offset + length;
//				Editor.Document.Insert(offset, insertText);
//			} catch (Exception ex) {
//				throw ex;
//			}
//		}
		
		public override bool CanDelete(SharpTreeNode[] nodes)
		{
			return nodes.OfType<XamlOutlineNode>().All(n => n.Parent != null);
		}

		public override void DeleteCore(SharpTreeNode[] nodes)
		{
			foreach (XamlOutlineNode node in nodes.OfType<XamlOutlineNode>()) {
				node.Editor.Document.Remove(node.Marker.Offset, node.EndMarker.Offset - node.Marker.Offset);
			}
		}

 public override IDataObject Copy(SharpTreeNode[] nodes)
 {
     return treeNodeImpl.Data.Copy(nodes.OfType<DnSpySharpTreeNode>().Select(a => a.TreeNodeImpl.Data).ToArray());
 }

		public override IDataObject Copy(SharpTreeNode[] nodes) {
			DataObject dataObject = new DataObject();
			var listNode = GetNode<DnSpyFileListTreeNode>(this);
			if (listNode == null)
				return dataObject;
			var dict = new Dictionary<AssemblyTreeNode, int>();
			for (int i = 0; i < listNode.Children.Count; i++)
				dict.Add((AssemblyTreeNode)listNode.Children[i], i);
			var data = nodes.OfType<AssemblyTreeNode>().Where(f => dict.ContainsKey(f)).Select(f => dict[f]).ToArray();
			if (data.Length != 0)
				dataObject.SetData(DataFormat, data);
			return dataObject;
		}

 public bool IsVisible(SharpTreeNode[] selectedNodes)
 {
     return selectedNodes.OfType<AssemblyTreeNode>().Count() > 0;
 }

 public override void StartDrag(DependencyObject dragSource, SharpTreeNode[] nodes)
 {
     treeNodeImpl.Data.StartDrag(dragSource, nodes.OfType<DnSpySharpTreeNode>().Select(a => a.TreeNodeImpl.Data).ToArray());
 }

		public override void DeleteWithoutConfirmation(SharpTreeNode[] nodes)
		{
			foreach (XamlOutlineNode xamlNode in nodes.OfType<XamlOutlineNode>()) {
				xamlNode.DeleteCore();
			}
		}