Sdílet prostřednictvím


Microsoft.VisualStudio.GraphModel Namespace

Classes

ActiveTransactionsChangedEventArgs

Event arguments for active transaction changes. Transactions with Disable are ignored.

DynamicGraphMetaObject
Graph

Represents a directed graph, consisting of nodes and links.

GraphCategory

Graph Categories are used to specify category information on a GraphObject, like nodes and links.

GraphCategoryChangedEventArgs
GraphCategoryCollection
GraphCommand
GraphCommandDefinition

Defines a particular command definition that can be used to group GraphCommands.

GraphCommonSchema

Class which defines a set of commonly used GraphProperty objects

GraphDataObject

This class provides IDataObject support for exchanging DGML data via the clipboard and drag/drop.

GraphDeserializationProgressEventArgs

Represents the current progress that the deserializer has made in deserializing the input.

GraphEnumerable

Extension methods for graph types.

GraphException

An exception that is thrown when a parsing error occurs during a GraphNodeId.Parse

GraphGroup

GraphGroup is a wrapper on Nodes that have IsGroup=true. They do not have a separate identity - they use the identity of the node that they wrap.

GraphLink

Represents a link in the directed graph

GraphLinkCollection

This class manages a collection of Links. This class does not preserve the order in which you added the links, so when you enumerate them you will get them back in a random order.

GraphMetadata

This class is used to provide more information about a GraphProperty, including localized strings and flags for controlling how the property appears in a Property Grid window.

GraphMetadataContainer

An object that can have graph specific metadata associated with it.

GraphNavigateToItemRanks

Common rank values for the IGraphNavigateToItem extension.

GraphNode

Represents a node in the directed graph

GraphNodeCollection

This class provides methods for manipulating a collection of Nodes. This class does not preserve the order in which you added the nodes, so when you enumerate them you will get them back in a random order.

GraphNodeId

A GraphNodeId is a name/value pair, for example "a=b". The left part of this identifier ("a") is represented by a GraphNodeIdName called the "Name" and the right hand side, "b" is the "Value" part. The value part of a GraphNodeId can be one of the following: * String * Uri * GraphNodeId * GraphNodeIdCollection Since the Value can be a GraphNodeId or GraphNodeIdCollection, we can use parentheses "()" to specify Nesting: e.g. a=(b=c) a=(b=c d=e) (a=b c=d) To construct a nested GraphNodeId list for (a=b c=d), create an GraphNodeIdCollection and assign it to a GraphNodeId:

GraphNodeId.Get(GraphNodeIdName.Nested, new GraphNodeIdCollection(
    GraphNodeId.Get(MyGraphNodeIdNames.a, "b")
    GraphNodeId.Get(MyGraphNodeIdNames.c, "d"));

You can also create this GraphNodeId using the following simple arithmetic:

GraphNodeId ab = GraphNodeId.Get("(a=b)");
GraphNodeId abcd = ab + "(c=d)";  // Yields (a=b c=d)

The result can be converted to a string using ToString() or implicit string cast operator and will produce "(a=b c=d)".

Since GraphNodeIds are stored singleton in a HashSet, they can be compared using operator ==
GraphNodeIdCollection

Contains a list of GraphNodeIds. This can be stored inside the .Value part of a GraphNodeId. This is an immutable list once created. We use an abstract class since this class does not know the formatting required to serialize the list back out to a string. The derived class will know this.

GraphNodeIdConverter

A type converter that can be used to convert to and from GraphNodeId. The editor converter derives from this one.

GraphNodeIdName

The GraphNodeIdName to give to a GraphNodeId. This forms the name and data type of the GraphNodeId.

GraphNodeIdPropertyDescriptor

This is a custom PropertyDescriptor that is used to populate a row in the PropertyGrid with XmlAttribute information and corresponding localized strings for labels and descriptions.

GraphObject

This class makes an object extensible by adding a strongly typed property bag of name/value pairs.

GraphObjectChangedEventArgs

These event args are used by the GraphNodeCollection and GraphLinkCollection Added and Removed events so you can track which nodes and links are added and removed from the graph.

GraphPathSerializationDictionary

The CommonPaths provides a way to remap certain attribute values in the DGML. For example, it is nice to have a file path be relative to the solution so the file can be found when that solution is moved. To solve this you can define a path called "SolutionDir" with the value of the full path. Then the GraphSerializer will substitute this path wherever it is found in the DGML with the syntax "$(name)" where name is the Id of the path you provided and it will write out the definition of the paths that are used in a Paths block at the end of the file.

<DirectedGraph> <Nodes> <Node Id="$(vsinstalldir);\common7\ide\microsoft.visualstudio.dll"/> </Nodes> <Paths> <Path Id="vsinstalldir" Value="c:\program files\Microsoft Visual Studio 10"/> </Path> </DirectedGraph>

When this DGML document is loaded the paths will be substituted with the values in the current CommonPaths and then all the variable references will be expanded with these new values. So this way a solution folder on your machine might be on the C: drive some place, and on the d: drive on another machine and everything will still just work as expected.

GraphPathSerializer

This class re-writes string values using the path names in the given CommonPaths. It provides a Serialize method that substitutes paths with a $(name) syntax where the name is the name of the path as registered in the CommonPaths. it also provides a Deserialize method that does the reverse. When all Serialization is done you can query the Used property to get a list of just the paths that were used by the Serialize or Deserialize methods.

GraphProperty

Graph Properties are used to annotate a GraphObject, like nodes and links.

GraphPropertyCollection
GraphProviderAttribute

Attribute to indicate that the target type is a graph provider.

GraphSchema

A GraphSchema is a simple container of a set of GraphCategory and GraphProperty objects and the GraphMetadata associated with them.

GraphSerializationErrorEventArgs

This class is used to communicate serialization errors if the caller passes a handler to the serializer.

GraphSerializationSettings

Settings for serializing a graph.

GraphTransactionCanceledException

This class can be used to cancel a graph transaction scope and communicate up to the UI layer of your application some reason for the cancelation.

GraphTransactionScope

Represents a highly optimized wrapper around System.Transactions.TransactionScope. This extensively uses thread local storage and is thus thread-bound. GraphTransactionScope is meant to be called from a using() class, same as TransactionScope.

GraphUndoManager

This class wraps the IOleUndoManager from VS and adds undo unit merging.

GraphUndoUnit

This class represents one undoable graph change which appears on the VS undo stack.

GraphUpdatedEventArgs

Provides changes to a graph object

UndoableGraphTransactionScope

This is a special graph transaction scope designed to be used for undoable edits (that show up in the host application undo stack).

Interfaces

IGraphContext

Interface representing a context which specifies a desired set of data. Providers place the requested data in the provided graph and the output nodes collection.

IGraphFormattedLabel

Interface representing an extension that can provide optional formatted labels for a GraphObject (i.e. labels that aren't permanently stored with the object).

IGraphNavigateToItem

Interface representing an extension that can navigate to the item represented by a GraphObject.

IGraphNodeBrowsablePropertiesProvider
IGraphProvider

An interface implemented by plugins that know how to return Graph data.

IGraphProviderMetadata

Metadata that describes a GraphProvider. This data is used to lazily load the provider only when necessary.

IGraphProviderRankableExtension

When more than one graph provider supports an extention type on a graph object, only one extension instance has to be choosen to be invoked. This interface represents an extension that can provide its rank and by doing that influence the selection of an extension instance to be invoked. An extention instance with the greatest rank value will be choosen.

IGraphTransactionEnlistment

Interface for IGraphTransactionEnlistment.

IGraphUndoData

Data access interface to get a hold of the data inside the undo unit

IHasGraphOwner

An interface for objects that have an owning Graph object.

IMergeableUndo

This Interface represents one Mergable graph change which appears on the VS undo stack.

IReadOnlyCollection<T>

Simple interface that exposes a Count property over a collection

Enums

AggregatorKind

Enum of the various kinds of aggregation operations for properties set by multiple IGraphProviders.

DelayedDataState

Enum for properties representing states of data that can get fetched into the graph in a delayed fashion (on-demand or asynchronously).

GraphCategoryChangeType
GraphCategoryMatchOption

This enum defines options that you have when matching categories

GraphContextDirection

Enumeration of possible GraphContext search directions.

GraphGroupStyle

Specifies the display state of an element.

GraphMetadataOptions

Bit flags used to control the behavior a GraphProperty.

GraphSearchDirection
GraphSearchOption

This enum defines the choices you have when searching the graph

GraphTransactionScopeOptions

Options for the GraphTransactionScope

UndoOption

This enum controls how the undoable operation is treated on the undo stack.