There are three overloaded methods that can be used for reading a graph into an IGraph instance:

public virtual void ReadGraph(Stream, IGraph)

public virtual void ReadGraph(StringReader, IGraph)

public virtual bool ReadGraph(HttpRequest, IGraph)

If the graph is read directly from a HTTP request, the ParamGraph parameter is used to retrieve the GraphML string from the request.

All graph reading methods will use CreateHandler to retrieve a preconfigured GraphML I/O handler.

There are two overloaded methods that can be used for serializing a graph using the roundtrip support:

public virtual void SendGraph(IGraph graph, Stream stream)

public virtual void SendGraph(IGraph graph, HttpResponse response)

Folding, i.e. expanding and collapsing group nodes, is an important means in breaking large graphs into smaller units. yFiles FLEX supports folding at the client as well as at the server side. The way folded graphs are sent is handled by the GraphRoundtripSupport.

Generally, there are two ways to send a folded graph to the client:

Proper IDs are needed for client-server communication so the client graph can be incrementally updated and the server knows which graph items to act upon. If CreateRoundtripGraph is used for creating graph instances on the server, the roundtrip support registers IMappers for node and edge IDs with the mapper registry of the graph. The corresponding mappers can be obtained from the mapper registry using the mapper keys Node2IdMapperKey and Edge2IdMapperKey. More information about handling IDs can be found in a knowledge base article about this topic.

Custom attributes associated with graph items can be easily added to the (de)serialization mechanism using the roundtrip support:

public virtual void AddMapper<K, V>(object tag,
                                       string name) where K : class, IModelItem

public virtual void AddMapper<K, V>(object tag,
                                        string name,
                                        KeyScope scopeType,
                                        KeyType keyType)

// Add an attribute mapper that contains string values for nodes. 
roundtripSupport.AddMapper<INode,string>("myNodeData", "myNodeData");

// create the IGraph instance that is used for roundtripping
IGraph graph = roundtripSupport.CreateRoundtripGraph();

// (populate the graph)

// retrieve the graph's mapper registry
IMapperRegistry registry = 
  graph.Lookup(typeof (IMapperRegistry)) as IMapperRegistry;
if (registry != null) {
  // Retrieve the IMapper from the graph's mapper registry using the tag
  // defined above
  IMapper nodeDataMapper = registry.GetMapper<INode, string>("myNodeData");

  // set the node data for each node
  int i = 0;
  foreach (INode node in graph.Nodes) {
    nodeDataMapper.SetValue(node, "node " + (i++));
  }
}

// send the graph to the client.
// the custom node data will be serialized as a custom GraphML attribute.
roundtripSupport.sendGraph(graph, httpResponse);

Alternatively, all attributes in the GraphML can automatically be read by enabling AutoReadMapperData. Mappers which are read using the auto read feature will also be written automatically if AutoWriteMapperData is set to true.

Adding custom graph item attributes for client-server roundtrips is discussed in detail in the corresponding knowledge base article.

GraphRoundtripSupport's send and read methods use a preconfigured GraphMLIOHandler that is created using the protected method CreateHandler. For additional customization of the (de)serialization process, this I/O handler can be customized by overriding the factory method. The default configuration of the I/O handler can also be replaced by a custom configuration by overriding ConfigureHandler.

protected virtual GraphMLIOHandler CreateHandler()

protected virtual void ConfigureHandler(GraphMLIOHandler handler)

The roundtrip support class can also be used to send XML formatted error messages to the client:

public virtual void SendError(Exception ex, HttpContext context)

public virtual void SendError(string message, HttpContext context)

The XML data sent to the client can be handled on the client as described in the section called “Handling Custom Errors” and is formatted as follows:

<?xml version="1.0" encoding="UTF-8"?>
  <response>
    <errors>
      <error>
        error message 
      <error>
    </errors>
  </response>