{"id":173,"date":"2008-12-21T11:03:03","date_gmt":"2008-12-21T10:03:03","guid":{"rendered":"http:\/\/www.leading-edge-dev.de\/?p=173"},"modified":"2010-07-10T10:55:14","modified_gmt":"2010-07-10T09:55:14","slug":"live-framework-ctp-5-net-data-hierarchies-and-liveitem-types","status":"publish","type":"post","link":"https:\/\/www.minddriven.de\/index.php\/technology\/microsoft\/cloud-computing\/live-services\/live-framework-ctp-5-net-data-hierarchies-and-liveitem-types","title":{"rendered":"Live Framework CTP #5 – .NET: Data hierarchies and LiveItem types"},"content":{"rendered":"

Hierarchies of data entries – the problem<\/h2>\n

As stated before<\/a>, when programming against the Live Framework libraries in .NET, all data entries are located on one level below the according data feed. This very often doesn’t correspond with a programmer’s expectations, when he has a hierarchy of data entries, e.g. a hierarchy of data folders and files. As programmer you want to have a tree-like view on this data to work with it. Unfortunately, in the current LiveFx CTP this was not made possible directly.<\/p>\n

Extending DataFeed and DataEntry<\/h2>\n

The solution for this is not far away. A data entry’s resource has got an Id<\/code> and a ParentId<\/code> as properties, over which one can identify and associate an entry’s parent and its child entries. A „root entry“ has got the ParentId \"urn:uuid:00000000-0000-0000-0000-000000000000\"<\/code> or it is null<\/code>. This information is sufficient to write some extension methods on DataFeed<\/code> and DataEntry<\/code> for getting hierarchical information. Thus I’m starting to make a little class library, which I will further work on and extend it. First I’ve got a little class named „MeshConstants<\/code>„. There resides the ParentId for a root data entry:<\/p>\n

public static class MeshConstants\r\n{\r\n    public const string RootDataEntryId = \"urn:uuid:00000000-0000-0000-0000-000000000000\";\r\n}<\/pre>\n
With this it’s easy to extend DataFeed<\/code> with a method GetRootDataEntries()<\/code>, which delivers only the data entries on the top level of the hierarchy:<\/p>\n
public static ICollection<DataEntry> GetRootDataEntries(this DataFeed feed)\r\n{\r\n    return (from entry in feed.DataEntries.Entries\r\n            where entry.IsLoaded && entry.IsRootEntry()\r\n            select entry).ToList();\r\n}<\/pre>\n
This method accesses IsRootEntry()<\/code> of DataEntry<\/code>, which is an extension method, too and indicates, if a data entry is on the root level (has no parent) or not:<\/p>\n
public static bool IsRootEntry(this DataEntry entry)\r\n{\r\n    if (String.IsNullOrEmpty(entry.Resource.ParentId))\r\n        return true;\r\n\r\n    return entry.Resource.ParentId.Equals(MeshConstants.RootDataEntryId);\r\n}<\/pre>\n
Another extension method for DataEntry<\/code> gives us the child entries in return:<\/p>\n
public static ICollection<DataEntry> GetChildEntries(this DataEntry entry)\r\n{\r\n    return (from child in entry.GetDataFeed().DataEntries.Entries\r\n            where child.Resource.ParentId == entry.Resource.Id\r\n            select child).ToList();\r\n}<\/pre>\n
This makes use of the method GetDataFeed()<\/code>, which is needed for getting the data feed, this data entry is associated to. Unfortunately, the .NET libraries of the Live Framework CTP don’t come along with this possibility innately:<\/p>\n
public static DataFeed GetDataFeed(this DataEntry entry)\r\n{\r\n    return (from feed in\r\n                (from meshobj in entry.LiveOperatingEnvironment.Mesh.MeshObjects.Entries\r\n                 select meshobj.DataFeeds.Entries).Aggregate((fl1, fl2) => fl1.Union(fl2))\r\n                 where feed.DataEntries.Entries.Contains(entry)\r\n            select feed).Single();\r\n}<\/pre>\n
Example: traversing the hierarchy<\/h2>\n
Now we’ve got all together for traversing a hierarchy of data entries recursively. We just need a recursive method, which executes the wanted action for a data entry and then recursively calls itself for all child entries. The following example method builds up a WinForms TreeView<\/code> structure by adding TreeNode<\/code> elements recursively:<\/p>\n
private void addTreeNodesForChildDataEntries(DataEntry parentEntry, TreeNode parentNode)\r\n{\r\n    foreach (var childEntry in parentEntry.GetChildEntries())\r\n    {\r\n        var childNode = new TreeNode(childEntry.Resource.Title + \": \" + childEntry.Resource.Type);\r\n        parentNode.Nodes.Add(childNode);\r\n        addTreeNodesForChildDataEntries(childEntry, childNode);\r\n    }\r\n}<\/pre>\n
The result is shown below exemplarily:<\/p>\n
\"Live<\/p>\n
Types of LiveItem elements<\/h2>\n
The resources of MeshObject<\/code>, DataFeed<\/code> and DataEntry<\/code> have an associated Type<\/code> property, over which you can distinguish different types of objects. Furthermore, Type<\/code> is a string and thus allows you to define your own application-specific object types. But the Live Framework comes with some standard types by default, where the most important are:<\/p>\n
MeshObject.Type<\/code><\/strong>:<\/p>\n