// Expanded is passed so that the correct ContentNodes are expanded in the PositionedNode
PositionedGraph BuildPositionedGraph(ObjectGraph objectGraph, Expanded expanded)
{
var positionedNodeFor = new Dictionary <ObjectGraphNode, PositionedNode>();
var positionedGraph = new PositionedGraph();
// create empty PositionedNodes
foreach (ObjectGraphNode objectNode in objectGraph.ReachableNodes)
{
var posNode = new PositionedNode(objectNode, expanded);
posNode.MeasureVisualControl();
positionedGraph.AddNode(posNode);
positionedNodeFor[objectNode] = posNode;
}
// create edges
foreach (PositionedNode posNode in positionedGraph.Nodes)
{
foreach (PositionedNodeProperty property in posNode.Properties)
{
if (property.ObjectGraphProperty.TargetNode != null)
{
ObjectGraphNode targetObjectNode = property.ObjectGraphProperty.TargetNode;
PositionedNode edgeTarget = positionedNodeFor[targetObjectNode];
property.Edge = new PositionedEdge {
Name = property.Name, Source = property, Target = edgeTarget
};
}
}
}
positionedGraph.Root = positionedNodeFor[objectGraph.Root];
return(positionedGraph);
}
public static TreeGraphNode Create(LayoutDirection direction, ObjectGraphNode objectNode)
{
switch (direction) {
case LayoutDirection.TopBottom: return new TreeNodeTB(objectNode);
case LayoutDirection.LeftRight: return new TreeNodeLR(objectNode);
default: throw new DebuggerVisualizerException("Unsupported layout direction: " + direction.ToString());
}
}
private TreeGraphNode createNewTreeGraphNode(ObjectGraphNode objectGraphNode)
{
var newGraphNode = TreeGraphNode.Create(this.layoutDirection, objectGraphNode);
newGraphNode.HorizontalMargin = horizNodeMargin;
newGraphNode.VerticalMargin = vertNodeMargin;
return(newGraphNode);
}
private void LinkObjectToNode(ObjectGraphNode node, object targetObject)
{
if (m_links.ContainsValue(node.RefId))
{
m_links.RemoveValue(node.RefId);
}
m_links.Add(targetObject, node.RefId);
}
public static TreeGraphNode Create(LayoutDirection direction, ObjectGraphNode objectNode)
{
switch (direction)
{
case LayoutDirection.TopBottom: return(new TreeNodeTB(objectNode));
case LayoutDirection.LeftRight: return(new TreeNodeLR(objectNode));
default: throw new DebuggerVisualizerException("Unsupported layout direction: " + direction.ToString());
}
}
public IObjectGraphNode GetObjectDataForRefId(int refid)
{
ObjectGraphNode node;
if (m_refs.TryGetValue(refid, out node))
{
return(node);
}
node = new ObjectGraphNode(refid, this);
m_refs[refid] = node;
return(node);
}
private static Dictionary <ulong, List <ulong> > PathToGcRoots(ClrHeap heap, ulong objRef, ClrRoot root)
{
const int maxSteps = 65536;
var sourceNode = new ObjectGraphNode(objRef, heap.GetObjectType(objRef).Name);
var considered = new HashSet <ulong>();
var gcRootNodes = new HashSet <ulong>();
var count = 0;
var eval = new Stack <ObjectGraphNode>();
eval.Push(sourceNode);
while (eval.Count > 0)
{
var node = eval.Pop();
if (considered.Contains(node.ObjRef))
{
continue;
}
considered.Add(node.ObjRef);
if (gcRootsByRef.ContainsKey(node.ObjRef))
{
gcRootNodes.Add(node.ObjRef);
continue;
}
var type = heap.GetObjectType(node.ObjRef);
if (type == null)
{
continue;
}
count++;
if (count >= maxSteps)
{
return(null);
}
type.EnumerateRefsOfObject(node.ObjRef, (child, offset) =>
{
if (child != 0 && !considered.Contains(child))
{
var typeName = heap.GetObjectType(child).Name;
eval.Push(new ObjectGraphNode(child, typeName));
}
});
}
return(null);
}
public bool GetObjectNode(object obj, out IObjectGraphNode dataNode)
{
int id;
if (m_links.TryGetValue(obj, out id))
{
dataNode = m_refs[id];
return(false);
}
var node = new ObjectGraphNode(m_idCounter++, this);
m_refs[node.RefId] = node;
m_links[obj] = node.RefId;
dataNode = node;
return(true);
}
private PositionedGraph buildTreeGraph(ObjectGraph objectGraph, Expanded expanded)
{
var resultGraph = new PositionedGraph();
// create empty PosNodes
foreach (ObjectGraphNode objectGraphNode in objectGraph.ReachableNodes)
{
TreeGraphNode posNode = createNewTreeGraphNode(objectGraphNode);
resultGraph.AddNode(posNode);
treeNodeFor[objectGraphNode] = posNode;
posNode.InitContentFromObjectNode(expanded);
}
// create edges
foreach (PositionedGraphNode posNode in resultGraph.Nodes)
{
// create edges outgoing from this posNode
foreach (PositionedNodeProperty property in posNode.Properties)
{
//property.IsPropertyExpanded = expanded.Expressions.IsExpanded(property.Expression);
if (property.ObjectGraphProperty.TargetNode != null)
{
ObjectGraphNode targetObjectNode = property.ObjectGraphProperty.TargetNode;
PositionedGraphNode edgeTarget = treeNodeFor[targetObjectNode];
property.Edge = new TreeGraphEdge
{
IsTreeEdge = false, Name = property.Name, Source = property, Target = edgeTarget
};
}
}
}
resultGraph.Root = treeNodeFor[objectGraph.Root];
return(resultGraph);
}
protected TreeGraphNode(ObjectGraphNode objectNode) : base(objectNode)
{
}
protected TreeGraphNode(ObjectGraphNode objectNode) : base(objectNode)
{
}
/// <summary>
/// Creates new PositionedNode.
/// </summary>
/// <param name="objectNode">Underlying ObjectNode.</param>
public PositionedGraphNode(ObjectGraphNode objectNode)
{
this.objectNode = objectNode;
initVisualControl();
}
public TreeNodeTB(ObjectGraphNode objectNode) : base(objectNode)
{
}
public IGraphNode BuildNode(object obj, Type fieldType)
{
if (obj == null)
{
return(null);
}
IGraphNode result;
Type objType = obj.GetType();
if (typeof(Type).IsAssignableFrom(objType))
{
return(GetTypeEntry((Type)obj));
}
var formatter = GetFormatter(objType);
if (formatter != null)
{
var node = formatter.ObjectToGraphNode(obj, this);
var fieldTypeFormatter = fieldType != null?GetFormatter(fieldType) : null;
if (formatter != fieldTypeFormatter)
{
//Value needs to be boxed
ObjectGraphNode box = node as ObjectGraphNode;
if (box == null)
{
box = (ObjectGraphNode)CreateObjectData();
box[DEFAULT_BOXED_VALUE_FIELD_NAME] = node;
}
if (box.ObjectType == null)
{
box.ObjectType = GetTypeEntry(objType);
}
return(box);
}
return(node);
}
if (objType.IsArray || objType.IsPrimitiveData())
{
//Boxable Values (arrays, bools, numbers, strings)
IGraphNode valueNode;
if (objType.IsArray)
{
Type elemType = objType.GetElementType();
ISequenceGraphNode array = BuildSequenceNode();
IEnumerator it = ((IEnumerable)obj).GetEnumerator();
while (it.MoveNext())
{
IGraphNode elem = BuildNode(it.Current, elemType);
array.Add(elem);
}
valueNode = array;
}
else
{
//Primitive data type
if (objType == typeof(string))
{
valueNode = BuildStringNode(obj as string);
}
else
{
if (objType.IsEnum)
{
obj = Convert.ChangeType(obj, ((Enum)obj).GetTypeCode());
}
valueNode = BuildPrimitiveNode(obj as ValueType);
}
}
if (objType != fieldType)
{
//Value needs to be boxed
var boxNode = CreateObjectData();
boxNode.ObjectType = GetTypeEntry(objType);
boxNode[DEFAULT_BOXED_VALUE_FIELD_NAME] = valueNode;
valueNode = boxNode;
}
result = valueNode;
}
else
{
//Non-Boxable Values (structs and objects)
IObjectGraphNode objReturnData;
bool extractData = true;
if (objType.IsValueType)
{
//Structure
objReturnData = CreateObjectData();
}
else
{
//Classes
if (!GetObjectNode(obj, out objReturnData))
{
extractData = false;
}
}
if (extractData)
{
var surrogate = SerializationServices.GetDefaultSerializationSurrogate(objType);
surrogate.GetObjectData(obj, objReturnData);
}
if ((objReturnData.ObjectType == null) && (objType != fieldType))
{
objReturnData.ObjectType = GetTypeEntry(objType);
}
result = objReturnData;
}
return(result);
}
/// <summary>
/// Creates new PositionedNode.
/// </summary>
/// <param name="objectNode">Underlying ObjectNode.</param>
public PositionedNode(ObjectGraphNode objectNode, Expanded expanded)
{
this.ObjectNode = objectNode;
InitVisualControl();
InitContentFromObjectNode(expanded);
}
public TreeNodeTB(ObjectGraphNode objectNode) : base(objectNode)
{
}
/// <summary>
/// Creates new PositionedNode.
/// </summary>
/// <param name="objectNode">Underlying ObjectNode.</param>
public PositionedGraphNode(ObjectGraphNode objectNode)
{
this.objectNode = objectNode;
initVisualControl();
}
/// <summary>
/// Creates new PositionedNode.
/// </summary>
/// <param name="objectNode">Underlying ObjectNode.</param>
public PositionedNode(ObjectGraphNode objectNode, Expanded expanded)
{
this.ObjectNode = objectNode;
InitVisualControl();
InitContentFromObjectNode(expanded);
}
private TreeGraphNode createNewTreeGraphNode(ObjectGraphNode objectGraphNode)
{
var newGraphNode = TreeGraphNode.Create(this.layoutDirection, objectGraphNode);
newGraphNode.HorizontalMargin = horizNodeMargin;
newGraphNode.VerticalMargin = vertNodeMargin;
return newGraphNode;
}
