As folks start using the Service Manager platform, I hope to have more relevant content to post for folks to help. Also, the Service Manager team blog is very active going over various features of the products and customizations and extensions that are possible.

The Service Manager team is very pleased to announce that Beta-2 for Service Manager 2010 is now available for download from connect. Details and links are below.

Download

To download, simply go to the Service Manager site on Connect www.connect.microsoft.com. Once you have successfully signed in, click the Downloads link, click Service Manager Beta-2 and then select all of the following files on the download details page:

· SMCDImage_amd64.exe

· SMCDImage_x86.exe (32 bit console)

· InstallOMMPs.exe

· AuthoringTool.exe (authoring console)

· SM_B2_Public.zip

Click download to begin the download process. Once the files have successfully downloaded, please be sure to read the release notes before installing the product as they contain some important information about the release

You can also use the public forums for feedback and support, link below
https://forums.microsoft.com/TechNet/ShowForum.aspx?ForumID=2066&SiteID=17

Please read the “Preparing for Service Manager Deployment” section of the Installation and Configuration Guide for step-by-step guidance on how to install and configure the product.

Object templates can be used to store data about classes as well as projections. They are neither classes, nor objects, but rather blueprints (stored in management packs) for creating or modifying objects. In the attached MP you will find three different object templates.

The first two set properties of a class. The Path notation is the same as used in projections, with the exception that you specify the particular property you want to set as well. You can specify as many or as few properties as you want, these objects don’t need to be complete, but we do verification to ensure property values make sense.

Projections can also be defined:

These are similar, but allow you to define a hierarchy of objects that conform to the projection definition the object template references. Whenever you want to define a new object, you need to ensure the endpoint of the relationship is concrete, or you need to specify the TypeConstraint to indicate what class you want to create, as in the example above.

In code, you can use these templates to create new objects or update existing objects:

NFL.xml

In Service Manager we've added the ability to categorize any Management Pack element via an extensible mechanism that leverages the new concept of enumerations as defined in management packs. Enumerations are essentially hierarchal extensible lists that are defined in management packs. They can be used both as values for class properties as well as values for categorization of elements. In this article, I'll be discussing the latter.

I've updated the NFL management pack I have been using and introduced a new enumeration and some categories. First, you'll find the following enumeration defined:

<EnumerationTypes>
        <EnumerationValue ID="NFL.VisibleToCallers" Accessibility="Public" />
</EnumerationTypes>

I can define enumerations to mean just about anything I want as the consumer of these enumerations and subsequent categories defines their behavior. In this case, I am defining an enumeration that categorizes elements as visible to callers via some API that I will be providing.

Once I have defined my enumeration, the next step is to categorize my elements as "in" the value. For this, I need to define category elements:

<Categories>
    <Category ID="NFL.Visibility1" Target="NFL.Conference" Value="NFL.VisibleToCallers" />
    <Category ID="NFL.Visibility2" Target="NFL.Division" Value="NFL.VisibleToCallers" />
    <Category ID="NFL.Visibility3" Target="NFL.Team" Value="NFL.VisibleToCallers" />
</Categories>

As you can see, I've placed three classes into my enumeration, thus categorizing them. But what does this mean from an API perspective? Really, it doesn't mean anything unless the consumer honors the categorization. As an example, the Service Manager UI uses various enumerations as defined in our management packs to categorize elements, such as console tasks or views, to control their visibility behavior in the UI.

Next, I'll demonstrate how a caller of the API can use this categorization. In the following sample, after importing the attached management pack, I retrieve the defined enumeration and generate criteria from it to filter out the classes I want to retrieve based on the categorization:

            // Connect to the management group
            EnterpriseManagementGroup managementGroup =
                new EnterpriseManagementGroup("localhost");

            // Get the management pack
            ManagementPack nflManagementPack = 
                managementGroup.ManagementPacks.GetManagementPack("NFL", null, new Version("1.0.0.0"));

            // Get the type enumeration value
            ManagementPackEnumeration showToCallersEnumeration =
                nflManagementPack.GetEnumeration("NFL.VisibleToCallers");

            // Create an in statement using the category property
            string classCriteria = string.Format(@"<Criteria xmlns=""https://Microsoft.EnterpriseManagement.Core.Criteria/"">
                                        <Expression>
                                            <In>
                                              <GenericProperty>Category</GenericProperty>
                                              <Values>
                                                <Value>{0}</Value>
                                              </Values>
                                            </In>
                                          </Expression>
                                        </Criteria>", showToCallersEnumeration.Id);

            // Create the criteria object
            ManagementPackClassCriteria classesVisibleToCallersCriteria = new ManagementPackClassCriteria(classCriteria);
            
            // Get classes using criteria
            IList<ManagementPackClass> classesVisibleToCallers = managementGroup.EntityTypes.GetClasses(classesVisibleToCallersCriteria);

Important Note: The criteria behaves in the following way with respect to inclusion and exclusion of categories. If you generate a query as shown earlier, it will return any class that is in this category, regardless if it is in other categories. If you change the query to ask for classes where category is not of a particular id, it will exclude the classes that are ONLY in that particular category; so if a class is in category A and B and you ask for classes not in B, you will still get the class back because A is not in B. If a class is only in category B and you ask for classes not in B, you will not get it back because that class is exclusively in B and thus NOT IN B is false. Even if this didn't make sense to you (I had to read it back several times myself :-) ), essentially what this means is that NOT EQUAL to a particular category queries just don't work the way you would expect so please don't use them or understand how they work before you do. To mitigate this problem, we are planning on caching categories client-side so users can quickly do filtering post-query for "NOT" semantics.

NFL.xml

In this post, I wanted to talk about our new criteria a little bit and introduce you to the new format and some of the new concepts. If you are familiar with OM, the criteria there was very similar to a WHERE clause in SQL. While this was very friendly from an end-user perspective, it actually was quite burdensome from a developer perspective, both in generating complicated criteria and for us in parsing it and ensuring its uniqueness. For Service Manager 2010 we decided to prioritize power and ease of programmatic manipulation over readability and the ability to quickly script the criteria. Criteria is used in for querying for a variety of objects in the SDK. Here's I'll use examples mostly around the instance and projection space.

Simple Expression
A simple expression just compares a property to a value. In this example we are comparing PropertyName on ClassName to the value 3.

               <SimpleExpression>
                <ValueExpressionLeft>
                  <Property>$Target/Property[Type='ClassName']/PropertyName$</Property>
                </ValueExpressionLeft>
                <Operator>Equal</Operator>
                <ValueExpressionRight>
                  <Value>3</Value>
                </ValueExpressionRight>
              </SimpleExpression>

For projections, a simple expression would look like this, where the property is actually a path:

              <SimpleExpression>
                <ValueExpressionLeft>
                  <Property>$Target/Path[Relationship='RelationshipName']/Property[Type='ClassName']/PropertyName$</Property>
                </ValueExpressionLeft>
                <Operator>Equal</Operator>
                <ValueExpressionRight>
                  <Value>3</Value>
                </ValueExpressionRight>
              </SimpleExpression>

Also, rather than using names, you can use Ids in the criteria:

              <SimpleExpression>
                <ValueExpressionLeft>
                  <Property>$Target/Property[Type='b982d3ec-96e0-4901-b1d9-a06196acf0bc']/b982d3ec-96e0-4901-b1d9-a06196acf0bc$</Property>
                </ValueExpressionLeft>
                <Operator>Equal</Operator>
                <ValueExpressionRight>
                  <Value>3</Value>
                </ValueExpressionRight>
              </SimpleExpression>

or:

            <SimpleExpression>
                <ValueExpressionLeft>
                  <Property>$Target/Path[Relationship='b982d3ec-96e0-4901-b1d9-a06196acf0bc']/
Property[Type='b982d3ec-96e0-4901-b1d9-a06196acf0bc']/b982d3ec-96e0-4901-b1d9-a06196acf0bc$</Property>
                </ValueExpressionLeft>
                <Operator>Equal</Operator>
                <ValueExpressionRight>
                  <Value>3</Value>
                </ValueExpressionRight>
            </SimpleExpression>

Unary/Regex Expression
These are the same as the simple expressions, but instead Unary and RegEx operators are supported. RegExExpression supports ContainsSubstring, MatchesWildcard, MatchesRegularExpression, DoesNotContainSubstring, DoesNotMatchWildcard and DoesNotMatchRegularExpression. UnaryExpression supports IsNull and IsNotNull.

Contains/NotContains/ContainedBy/NotContainedBy Expression
These expressions allow a traversal to be made either down or up containment to either include or exclude results based the existence of a relationship to other instances. The concept here is similar to an EXISTS query in SQL.

          <Contains>
            <!-- A Contains query from a particular node in the projection; this can also just drop path and the implicit path is the seed -->
            <Path>$Target/Path[Relationship='RelationshipName']$</Path>
            <Class>$MPElement[Name='System!System.Computer']$</Class>
            <Expression>
              <SimpleExpression>
                <ValueExpressionLeft>
                  <Property>$Target/Property[Type='System!System.Computer']/FQDN$</Property>
                </ValueExpressionLeft>
                <Operator>Equal</Operator>
                <ValueExpressionRight>
                  <Value>ComputerName</Value>
                </ValueExpressionRight>
              </SimpleExpression>
            </Expression>
          </Contains>

The Path element indicates where within the context of the criteria you want to perform the containment based query. If the path is excluded, it means that you want the containment query to be done on the target of the criteria, namely the projection seed class or the class in the case of regular instance queries.

As a more concrete example, given an Incident projection with System.Incident as the seed and a single related owner System.User, one can do containment based queries on either the incident or the user. If a query like “Give me all incidents that are contained by the ‘Tier 1 Incident Group’”, the path element would be excluded, the Class element would point to the Incident Group type and the expression would be empty. If there were some criteria on that group that needed to be matched, that expression would be used for that. If the query was like “Give me incidents that have a owner that is contained by “Tier 1 Users Group”, the path element would need to be populated pointing to System.User.

It is important to note that the path element indicates where in the context of the criteria you want the containment query to apply, while the class and criteria indicate what you are searching for in that containment space.

And/Or Expression
These expressions allow you to combine other expressions.

In Expression
And finally we support a basic IN clause for use with Guid fields only. The other thing to note here is that I am using a GenericProperty instead of Property element. This allows you to refer to generic properties of instances that aren't modeled. This property also has a Path attribute that allows you to point to a node in a projection for which you want the generic property to apply.

    <Expression>
      <!-- Simple IN Clause (GUID support only) -->
      <In>
        <GenericProperty>Id</GenericProperty>
        <Values>
          <Value>b982d3ec-96e0-4901-b1d9-a06196acf0bc</Value>
          <Value>b982d3ec-96e0-4901-b1d9-a06197acf0bc</Value>
          <Value>b982d3ec-96e0-4901-b1d9-a06198acf0bc</Value>
        </Values>
      </In>
    </Expression>

 SO23 Customizing and Extending Service Manager
Speaker(s): Jakub Oleksy, Travis Wright
Track(s): Operations Management
Session Type(s): Breakout Session
Products(s): Operations Manager 2007, Service Manager

A technical drill-down on the customization capabilities of Service Manager: This session will articulate how to extend and deliver Service Manager through the delivery of management packs. We will demonstrate the authoring tools to learn how to create workflows, customize templates and extend the configuration management database

On the Instances interface you will find a few methods for retrieving instances of EnterpriseManagementObjectProjection. Post Beta 1, we've actually cleaned up this interface significantly so I don't want to concentrate too much on the actual method call, but rather the parameters to it and working with the result.

In Beta 1 the method you would use looks like this:

IList<EnterpriseManagementObjectProjection> GetObjectProjections<T>(ManagementPackTypeProjection managementPackTypeProjection, 
ObjectProjectionCriteria criteria, ObjectQueryOptions queryOptions) where T : EnterpriseManagementObject;

Post Beta 1, this method is replaced by:

IObjectProjectionReader<T> GetObjectProjectionReader<T>(ObjectProjectionCriteria criteria, ObjectQueryOptions queryOptions)
            where T : EnterpriseManagementObject;

The ManagementPackTypeProjection from the first simply gets rolled into the ObjectProjectionCriteria object and the return type gets changed to support buffered reads to help with performance, however, IObjectProjectionReader can actually be used like an IList (although it doesn't implement IList); I'll discuss the reader more once we ship Beta 2 later this year. My examples below will use the latest code since that will be around longer; hopefully it is easily transferable for you to the Beta 1 API.

The first thing you need in order to get a type projection instance, is the type projection definition. This narrows down the types of instances you will get back to those that fit the structure of the type projection:

      // Connect to the management group
      EnterpriseManagementGroup managementGroup =
            new EnterpriseManagementGroup("localhost");

      // Get the management pack
      ManagementPack nflManagementPack = 
            managementGroup.ManagementPacks.GetManagementPack("NFL", null, new Version("1.0.0.0"));

      // Get the type projection
      ManagementPackTypeProjection nflProjection =
            nflManagementPack.GetTypeProjection("NFL.Conference.All");

Very simply you can retrieve projections by specifying the type:

IObjectProjectionReader<EnterpriseManagementObject> objectProjections =
      managementGroup.Instances.GetObjectProjectionReader<EnterpriseManagementObject>(
      new ObjectProjectionCriteria(nflProjection), ObjectQueryOptions.Default);

This will retrieve all projections in the system of that structure. A projection exists if the root object of the projection exists, regardless of whether any of the components are found. If you want to limit your result somehow, you will need to specify criteria to limit your result set. One example of simple criteria you could add is matching on one of the generic properties of the root object:

            string displayNameCriteria = @"<Criteria xmlns=""https://Microsoft.EnterpriseManagement.Core.Criteria/"">
                  <Expression>
                    <SimpleExpression>
                      <ValueExpressionLeft>
                        <GenericProperty>DisplayName</GenericProperty>
                      </ValueExpressionLeft>
                      <Operator>Equal</Operator>
                      <ValueExpressionRight>
                        <Value>National Football Conference</Value>
                      </ValueExpressionRight>
                    </SimpleExpression>
                  </Expression>
                </Criteria>";

            IObjectProjectionReader<EnterpriseManagementObject> objectProjectionsByDisplayName =
                 managementGroup.Instances.GetObjectProjectionReader<EnterpriseManagementObject>(
                     new ObjectProjectionCriteria(displayNameCriteria, nflProjection, managementGroup), ObjectQueryOptions.Default);

This would limit the results to any projections whose root object had a display name matching "National Football Conference." The list of available generic properties for Service Manager is Id, Name, DisplayName, LastModified and new post Beta 1 CreatedDate and LastModifiedBy.

It is also possible to query on type specific properties of the root object:

            string propertyCriteria = @"<Criteria xmlns=""https://Microsoft.EnterpriseManagement.Core.Criteria/"">
                  <Expression>
                    <SimpleExpression>
                      <ValueExpressionLeft>
                        <Property>$Target/Property[Type='NFL.Conference']/Name$</Property>
                      </ValueExpressionLeft>
                      <Operator>Equal</Operator>
                      <ValueExpressionRight>
                        <Value>NFC</Value>
                      </ValueExpressionRight>
                    </SimpleExpression>
                  </Expression>
                </Criteria>";

            IObjectProjectionReader<EnterpriseManagementObject> objectProjectionsByProperty =
                 managementGroup.Instances.GetObjectProjectionReader<EnterpriseManagementObject>(
                     new ObjectProjectionCriteria(propertyCriteria, nflProjection, nflManagementPack, managementGroup), ObjectQueryOptions.Default);

Criteria can get more complicated than the above examples, including specifying criteria on the individual components of the projection, but an in-depth discussion will happen in a later post.

Once you get an EnterpriseManagementObjectProjection, you essentially have a collection of instances organized in a hierarchy as defined by the type projection. If you run the following code:

            foreach (EnterpriseManagementObjectProjection projection in objectProjections)
            {
                Console.WriteLine("Conference: {0}", projection.Object.DisplayName);
                foreach (IComposableProjection division in projection[nflConferenceContainsDivision.Target])
                {
                    Console.WriteLine("\tDivision: {0}", division.Object.DisplayName);
                    foreach (IComposableProjection team in division[divisionContainTeam.Target])
                    {
                        Console.WriteLine("\t\tTeam: {0}", team.Object.DisplayName);
                        foreach (IComposableProjection coach in team[coachCoachesTeam.Source])
                        {
                            Console.WriteLine("\t\t\tCoach: {0}", coach.Object.DisplayName);
                        }
                    }
                }
            }

You'll get a result that shows you the structure of the projection in memory:

Conference: American Football Conference
        Division: AFC West
                Team: Oakland Raiders
                Team: Kansas City Chiefs
                Team: San Diego Chargers
                Team: Denver Broncos
        Division: AFC East
                Team: Buffalo Bills
                Team: New England Patriots
                Team: New York Jets
                Team: Miami Dolphins
        Division: AFC South
                Team: Houston Texans
                Team: Jacksonville Jaguars
                Team: Tennessee Titans
                Team: Indianapolis Colts
        Division: AFC North
                Team: Cleveland Browns
                Team: Pittsburgh Steelers
                Team: Baltimore Ravens
                Team: Cincinnati Bengals
Conference: National Football Conference
        Division: NFC North
                Team: Green Bay Packers
                Team: Chicago Bears
                        Coach: Lovie Smith
                Team: Detroit Lions
                Team: Minnesota Vikings
        Division: NFC South
                Team: Carolina Panthers
                Team: Atlanta Falcons
                Team: Tampa Bay Buccaneers
                Team: New Orleans Saints
        Division: NFC East
                Team: New York Giants
                Team: Dallas Cowboys
                Team: Philadelphia Eagles
                Team: Washington Redskins
        Division: NFC West
                Team: St. Louis Rams
                Team: Seattle Seahawks
                Team: Arizona Cardinals
                Team: San Francisco 49ers

If the line is indented, it indicates a jump across a relationship. The hierarchy is organized by the relationship types that bring in each component; put another way, as you traverse from parent to child you are traversing a relationship of a particular relationship type in one direction. So, as you go from American Football Conference to AFC West, you are moving from "Conference" to "Division" on the NFL.ConferenceHostsDivision relationship type.

Each node in an EnterpriseManagementObjectProjection implements IComposableProjection which offers various ways at traversing through the hierarchy. The object is also IEnumerable<KeyValuePair<ManagementPackRelationshipEndpoint, IComposableProjection>>, which shows that the hierarchy is organized by the relationship endpoint that brings each node in. You also get a pointer to the actual object at the node:

        /// <summary>
        /// The current object in the projection.
        /// </summary>
        EnterpriseManagementObject Object
        {
            get;
        }

The role that brought the current object into the current projection:

        /// <summary>
        /// Gets the role of this projection, relative to its parent.
        /// </summary>
        /// <value></value>
        ManagementPackRelationshipEndpoint ObjectRole
        {
            get;
        }

The object that brought the current object into the current projection:

        /// <summary>
        /// The parent object, if any, for the current object in the projection.
        /// </summary>
        IComposableProjection ParentObject
        {
            get;
        }

And a few indexers to aid in traversal, one of which we used in the sample above:

        /// <summary>
        /// Access all IComposableProjection elements of this IComposableProjection, optionally recursively.
        /// </summary>
        IList<IComposableProjection> this[TraversalDepth traversalDepth]
        {
            get;
        }

        /// <summary>
        /// Access IComposableProjection elements of this IComposableProjection, by role name.
        /// </summary>
        IList<IComposableProjection> this[string roleName]
        {
            get;
        }

        /// <summary>
        /// Access IComposableProjection elements of this IComposableProjection, by role name.
        /// </summary>
        IList<IComposableProjection> this[string roleName, ManagementPackClass classConstraint]
        {
            get;
        }

        /// <summary>
        /// Gets the IComposableProjection child of the projection by id of the contained object
        /// </summary>
        IComposableProjection this[string roleName, Guid id]
        {
            get;
        }

        /// <summary>
        /// Access IComposableProjection elements of this IComposableProjection, by relationship role.
        /// </summary>
        IList<IComposableProjection> this[ManagementPackRelationshipEndpoint role]
        {
            get;
        }

        /// <summary>
        /// Access IComposableProjection elements of this IComposableProjection, by relationship role and a class constraint.
        /// </summary>
        IList<IComposableProjection> this[ManagementPackRelationshipEndpoint role, ManagementPackClass classConstraint]
        {
            get;
        }

        /// <summary>
        /// Gets the IComposableProjection child of the projection by id of the contained object
        /// </summary>
        IComposableProjection this[ManagementPackRelationshipEndpoint role, Guid id]
        {
            get;
        }

In future posts I'll discuss more advanced concepts around working with projections instances (they're IXPathNavigable!), a deeper look at criteria, creating and editing projections and a lot more. I hope that by the time Beta 2 ships later this year to have a comprehensive list of topics that help introduce you to new API concepts.

Type projection definitions allow users to create virtual object collections through any relationships found in the system. In the previous post I showed how a projection could bring hosted and host objects together in one go. The following projection expands on that example by introducing System.Containment and System.Reference relationships, as well as introducing the concepts of type constraints and relationship direction:

      <TypeProjections>
        <TypeProjection ID="NFL.Conference.All" Accessibility="Public" Type="NFL.Conference">
          <Component Alias="Division" Path="$Target/Path[Relationship='NFL.ConferenceHostsDivision']$">
            <Component Alias="AFCTeam" Path="$Target/Path[Relationship='NFL.DivisionContainsTeam' SeedRole='Source' TypeConstraint='AFC.Team']$"/>
            <Component Alias="NFCTeam" Path="$Target/Path[Relationship='NFL.DivisionContainsTeam' SeedRole='Source' TypeConstraint='NFC.Team']$">
              <Component Alias="Coach" Path="$Target/Path[Relationship='NFL.CoachCoachesTeam' SeedRole='Target']$" />
            </Component>
          </Component>
        </TypeProjection>
      </TypeProjections>

Added to the Division component from the previous post, I've now introduced two components that bring in all the teams in the NFL. I've defined my NFL.Team class as abstract and created concrete classes, AFC.Team and NFC.Team. I've also created a relationship derived from System.Containment associating an NFL.Division to an NFL.Team. Of note is that this relationship ends with an abstract class as the target endpoint. While this is supported by type projection definitions, the projection I have defined actually demonstrates the ability to constraint a component to a particular class. The two components, AFCTeam and NFCTeam each share a relationship, however, they each add a different type constraint. Given something can't be an NFCTeam and AFCTeam at the same time, these components will introduce unique sets of data.

If I were to change the AFCTeam component to remove the type constraint, that component would return all NFL.Team instances while the NFCTeam component would return only those NFL.Team objects that are NFC.Teams as well.

Next, I added a System.Reference relationship between NFL.Coach and NFL.Team. Notice that the coach is the source of that relationship. If I want to include all coaches for NFC.Teams, I need to indicate in the type projection definition that I want to traverse the relationship from target to source. This is done via the SeedRole attribute. The "Seed" refers to the parent component of the current component; the attribute describes which role the seed should play relative to the relationship used in the current component. In the sample, the relationship is NFL.CoachCoachesTeam and the seed (NFCTeam) is the target of that relationship and hence SeedRole='Target'.

Traversing this structure is similar to the example in my previous post:

            // Connect to the management group
            EnterpriseManagementGroup managementGroup =
                new EnterpriseManagementGroup("localhost");

            // Get the management pack
            ManagementPack nflManagementPack = 
                managementGroup.ManagementPacks.GetManagementPack("NFL", null, new Version("1.0.0.0"));

            // Get the type projection
            ManagementPackTypeProjection nflProjection =
                nflManagementPack.GetTypeProjection("NFL.Conference.All");

            // Get the relationship types
            ManagementPackRelationship nflConferenceContainsDivision =
                nflManagementPack.GetRelationship("NFL.ConferenceHostsDivision");

            ManagementPackRelationship divisionContainTeam =
                nflManagementPack.GetRelationship("NFL.DivisionContainsTeam");

            ManagementPackRelationship coachCoachesTeam =
                nflManagementPack.GetRelationship("NFL.CoachCoachesTeam");

            IObjectProjectionReader<EnterpriseManagementObject> objectProjections =
                managementGroup.Instances.GetObjectProjectionReader<EnterpriseManagementObject>(
                    new ObjectProjectionCriteria(nflProjection), ObjectQueryOptions.Default);

            foreach (EnterpriseManagementObjectProjection projection in objectProjections)
            {
                Console.WriteLine("Conference: {0}", projection.Object.DisplayName);
                foreach (IComposableProjection division in projection[nflConferenceContainsDivision.Target])
                {
                    Console.WriteLine("\tDivision: {0}", division.Object.DisplayName);
                    foreach (IComposableProjection team in division[divisionContainTeam.Target])
                    {
                        Console.WriteLine("\t\tTeam: {0}", team.Object.DisplayName);
                        foreach (IComposableProjection coach in team[coachCoachesTeam.Source])
                        {
                            Console.WriteLine("\t\t\tCoach: {0}", coach.Object.DisplayName);
                        }
                    }
                }
            }

When we traverse from team to coach, we use the .Source property of the relationship which corresponds to the SeedRole description in the type projection definition. As part of traversing the projection, think of the role as where you are traversing to; in this example you are traversing from the team (the .Target property) to the coach (the .Source property).

When traversing from divisions to teams, I am using the abstract .Target property of the NFL.DivisionContainsTeam relationship. Type constraints are not expressed in the traversal mechanism for these objects; the key from going to one component to another is the relationship endpoint, save any type constraints.

Reference Code

           // Connect to the management group
            EnterpriseManagementGroup managementGroup =
                new EnterpriseManagementGroup("localhost");

            // Import the management pack
            ManagementPack managementPack = new ManagementPack("NFL.xml");
            managementGroup.ManagementPacks.ImportManagementPack(managementPack);
            managementPack = managementGroup.ManagementPacks.GetManagementPack(managementPack.Id);

            // Populate Data
            IncrementalDiscoveryData dataTransaction = new IncrementalDiscoveryData();

            // Get System.Entity class
            ManagementPackClass systemEntity = managementGroup.EntityTypes.GetClass(SystemClass.Entity);

            // Conferences
            ManagementPackClass conference = managementPack.GetClass("NFL.Conference");
            CreatableEnterpriseManagementObject nfc = new CreatableEnterpriseManagementObject(managementGroup, conference);
            nfc[conference, "Name"].Value = "NFC";
            nfc[systemEntity, "DisplayName"].Value = "National Football Conference";
            dataTransaction.Add(nfc);

            CreatableEnterpriseManagementObject afc = new CreatableEnterpriseManagementObject(managementGroup, conference);
            afc[conference, "Name"].Value = "AFC";
            afc[systemEntity, "DisplayName"].Value = "American Football Conference";
            dataTransaction.Add(afc);

            // Divisions
            Dictionary<string, List<string>> divisions = new Dictionary<string,List<string>>();
            divisions.Add("AFC North", new List<string>());
            divisions["AFC North"].Add("Baltimore Ravens");
            divisions["AFC North"].Add("Cincinnati Bengals");
            divisions["AFC North"].Add("Cleveland Browns");
            divisions["AFC North"].Add("Pittsburgh Steelers");
            divisions.Add("NFC North", new List<string>());
            divisions["NFC North"].Add("Chicago Bears");
            divisions["NFC North"].Add("Detroit Lions");
            divisions["NFC North"].Add("Green Bay Packers");
            divisions["NFC North"].Add("Minnesota Vikings");
            
            divisions.Add("AFC South", new List<string>());
            divisions["AFC South"].Add("Houston Texans");
            divisions["AFC South"].Add("Indianapolis Colts");
            divisions["AFC South"].Add("Jacksonville Jaguars");
            divisions["AFC South"].Add("Tennessee Titans");
            divisions.Add("NFC South", new List<string>());
            divisions["NFC South"].Add("Atlanta Falcons");
            divisions["NFC South"].Add("Carolina Panthers");
            divisions["NFC South"].Add("New Orleans Saints");
            divisions["NFC South"].Add("Tampa Bay Buccaneers");

            divisions.Add("AFC East", new List<string>());
            divisions["AFC East"].Add("Buffalo Bills");
            divisions["AFC East"].Add("Miami Dolphins");
            divisions["AFC East"].Add("New England Patriots");
            divisions["AFC East"].Add("New York Jets");
            divisions.Add("NFC East", new List<string>());
            divisions["NFC East"].Add("Dallas Cowboys");
            divisions["NFC East"].Add("New York Giants");
            divisions["NFC East"].Add("Philadelphia Eagles");
            divisions["NFC East"].Add("Washington Redskins");

            divisions.Add("AFC West", new List<string>());
            divisions["AFC West"].Add("Denver Broncos");
            divisions["AFC West"].Add("Kansas City Chiefs");
            divisions["AFC West"].Add("Oakland Raiders");
            divisions["AFC West"].Add("San Diego Chargers");
            divisions.Add("NFC West", new List<string>());
            divisions["NFC West"].Add("Arizona Cardinals");
            divisions["NFC West"].Add("San Francisco 49ers");
            divisions["NFC West"].Add("Seattle Seahawks");
            divisions["NFC West"].Add("St. Louis Rams");

            Dictionary<string, string> teamToCoach = new Dictionary<string, string>();
            teamToCoach.Add("Chicago Bears", "Lovie Smith");

            ManagementPackClass divisionClass = managementPack.GetClass("NFL.Division");
            ManagementPackClass nfcTeamClass = managementPack.GetClass("NFC.Team");
            ManagementPackClass afcTeamClass = managementPack.GetClass("AFC.Team");
            ManagementPackClass coachClass = managementPack.GetClass("NFL.Coach");

            ManagementPackRelationship divisionContainsTeamClass = managementPack.GetRelationship("NFL.DivisionContainsTeam");
            ManagementPackRelationship coachCoachesTeamClass = managementPack.GetRelationship("NFL.CoachCoachesTeam");
            foreach (string divisionName in divisions.Keys)
            {
                CreatableEnterpriseManagementObject division = new CreatableEnterpriseManagementObject(managementGroup, divisionClass);

                string conferenceName;
                ManagementPackClass teamClass;

                if (divisionName.Contains("AFC") == true)
                {
                    conferenceName = "AFC";
                    teamClass = afcTeamClass;
                }
                else
                {
                    conferenceName = "NFC";
                    teamClass = nfcTeamClass;
                }

                // Need to make sure to set key values of the host
                division[conference, "Name"].Value = conferenceName;
                division[divisionClass, "Name"].Value = divisionName;
                division[systemEntity, "DisplayName"].Value = divisionName;
                dataTransaction.Add(division);
                foreach (string teamName in divisions[divisionName])
                {
                    CreatableEnterpriseManagementObject team = new CreatableEnterpriseManagementObject(managementGroup, teamClass);
                    team[teamClass, "Name"].Value = teamName;
                    team[systemEntity, "DisplayName"].Value = teamName;
                    dataTransaction.Add(team);

                    CreatableEnterpriseManagementRelationshipObject divisionContainsTeam = 
                               new CreatableEnterpriseManagementRelationshipObject(managementGroup, divisionContainsTeamClass);
                    divisionContainsTeam.SetSource(division);
                    divisionContainsTeam.SetTarget(team);
                    dataTransaction.Add(divisionContainsTeam);

                    if (teamToCoach.ContainsKey(teamName) == true)
                    {
                        CreatableEnterpriseManagementObject coach = new CreatableEnterpriseManagementObject(managementGroup, coachClass);
                        coach[coachClass, "Name"].Value = teamToCoach[teamName];
                        coach[systemEntity, "DisplayName"].Value = teamToCoach[teamName];
                        dataTransaction.Add(coach);

                        CreatableEnterpriseManagementRelationshipObject coachCoachesTeam = 
                                      new CreatableEnterpriseManagementRelationshipObject(managementGroup, coachCoachesTeamClass);
                        coachCoachesTeam.SetSource(coach);
                        coachCoachesTeam.SetTarget(team);
                        dataTransaction.Add(coachCoachesTeam);
                    }
                }
            }

            // Use Overwrite instead of Commit here because I want to bypass optimistic concurrency checks which will not allow the 
            // insertion of an existing instances and I want this method to be re-runnable
            dataTransaction.Overwrite(managementGroup);

NFL.xml

For this post, I've attached a management pack (NFL.xml) that defines the classes and type projection used in the sample code. Also, I have the code I used to populate my objects in the Reference Code section below.

In the management pack you will notice two classes defined, NFL.Conference and NFL.Division, and a hosting relationship type, NFL.ConferenceHostsDivision, between them. My scenario is that I want to display all the conferences and divisions in the UI, so I define a type projection that puts the two classes together:

<TypeProjection ID="NFL.Conference.All" Accessibility="Public" Type="NFL.Conference">
     <Component Alias="Division" Path="$Target/Path[Relationship='NFL.ConferenceHostsDivision']$" />
</TypeProjection>

The first thing you should notice in the above definition is the Type property on the root element; this defines the type of instance that should exist at the root or "seed" of the projection. Next, you'll notice the projection has one component, Division, that relates to the root. The Path attribute is what defines how to find the desired component, relative to the seed. I will describe the path notation in more depth in future posts, but here Target refers to the seed element of the projection (an instance of NFL.Conference), followed by a Path construct that tells the system to follow the NFL.ConferenceHostsDivision relationship type.  This will result in a structure that looks like this:

* NFL.Conference

* NFL.Division

Now, in order to work with this, the SDK has introduced a new object type, EnterpriseManagementObjectProjection, along with an interface, IComposableProjection, to allow for retrieval of and then navigation of the returned structure. The following code shows a basic example of retrieving and iterating through the objects:

            // Connect to the management group
            EnterpriseManagementGroup managementGroup =
                new EnterpriseManagementGroup("localhost");

            // Get the management pack
            ManagementPack nflManagementPack = 
                managementGroup.ManagementPacks.GetManagementPack("NFL", null, new Version("1.0.0.0"));

            // Get the type projection
            ManagementPackTypeProjection nflProjection = 
                nflManagementPack.GetTypeProjection("NFL.Conference.All");

            // Get the relationship type
            ManagementPackRelationship nflConferenceContainsDivision = 
                nflManagementPack.GetRelationship("NFL.ConferenceHostsDivision");

            IObjectProjectionReader<EnterpriseManagementObject> objectProjections =
                managementGroup.Instances.GetObjectProjectionReader<EnterpriseManagementObject>(
                    new ObjectProjectionCriteria(nflProjection), ObjectQueryOptions.Default);

            foreach (EnterpriseManagementObjectProjection projection in objectProjections)
            {
                Console.WriteLine("Conference {0}", projection.Object.DisplayName);
                foreach (IComposableProjection division in projection[nflConferenceContainsDivision.Target])
                {
                    Console.WriteLine("Division {0}", division.Object.DisplayName);
                }
            }

The sample first connects to the server and retrieves the type projection definition which is necessary for interacting with the SDK and the relationship type definition which is necessary for navigating the resulting instance. Next, we get an IObjectProjectionReader<EnterpriseManagementObject> that will contain all instances of our type projection. Finally, the example shows how to iterate through the object and get data.

Reference Code

            // Connect to the management group
            EnterpriseManagementGroup managementGroup =
                new EnterpriseManagementGroup("localhost");

            // Import the management pack
            ManagementPack managementPack = new ManagementPack("NFL.xml");
            managementGroup.ManagementPacks.ImportManagementPack(managementPack);
            managementPack = managementGroup.ManagementPacks.GetManagementPack(managementPack.Id);

            // Populate Data
            IncrementalDiscoveryData dataTransaction = new IncrementalDiscoveryData();

            // Get System.Entity class
            ManagementPackClass systemEntity = managementGroup.EntityTypes.GetClass(SystemClass.Entity);

            // Conferences
            ManagementPackClass conference = managementPack.GetClass("NFL.Conference");
            CreatableEnterpriseManagementObject nfc = new CreatableEnterpriseManagementObject(managementGroup, conference);
            nfc[conference, "Name"].Value = "NFC";
            nfc[systemEntity, "DisplayName"].Value = "National Football Conference";
            dataTransaction.Add(nfc);

            CreatableEnterpriseManagementObject afc = new CreatableEnterpriseManagementObject(managementGroup, conference);
            afc[conference, "Name"].Value = "AFC";
            afc[systemEntity, "DisplayName"].Value = "American Football Conference";
            dataTransaction.Add(afc);

            // Divisions
            ManagementPackClass division = managementPack.GetClass("NFL.Division");
            string[] nfcDivisionNames = new string[] {
                "NFC East",
                "NFC North",
                "NFC South",
                "NFC West"
            };
            
            foreach (string nfcDivisionName in nfcDivisionNames)
            {
                CreatableEnterpriseManagementObject nfcDivision = new CreatableEnterpriseManagementObject(managementGroup, division);
                
                // Need to make sure to set key values of the host
                nfcDivision[conference, "Name"].Value = "NFC";
                
                nfcDivision[division, "Name"].Value = nfcDivisionName;
                nfcDivision[systemEntity, "DisplayName"].Value = nfcDivisionName;
                dataTransaction.Add(nfcDivision);
            }

            string[] afcDivisionNames = new string[] {
                "AFC East",
                "AFC North",
                "AFC South",
                "AFC West"
            };

            foreach (string afcDivisionName in afcDivisionNames)
            {
                CreatableEnterpriseManagementObject afcDivision = new CreatableEnterpriseManagementObject(managementGroup, division);

                // Need to make sure to set key values of the host
                afcDivision[conference, "Name"].Value = "AFC";

                afcDivision[division, "Name"].Value = afcDivisionName;
                afcDivision[systemEntity, "DisplayName"].Value = afcDivisionName;
                dataTransaction.Add(afcDivision);
            }

            // Use Overwrite instead of Commit here because I want to bypass optimistic concurrency checks which will not allow the 
            // insertion of an existing instances and I want this method to be re-runnable
            dataTransaction.Overwrite(managementGroup);

NFL.xml