You can think of node schemas as the DOM equivalent of each CLR object Type. This is because schemas primary serve for node reflection purposes. A singleton instance of the NSchema class is associated with each type of node instance. The respective NSchema instance can be accessed in two ways:

1. Via the Schema property of each NNode instance.
2. Via the public static readonly field that is assigned by the specific node type static constructor.

The schema created for each type of node, holds a reference to a base schema - the schema associated with the base node type. The base schema is accessible from BaseSchema property of each NSchema. In this way schemas are hierarchically organized to follow the type inheritance of each node type.

Schemas are used to define the self-properties that each specific node type declares.

Schemas are used to define the way in which a certain type of node aggregates other nodes. In case of container nodes, the schemas are also used to define the available child slots.

It is mandatory to create a schema instance for each type of node subclass that you want to create. The schema instance needs to be created in the static constructor and assigned to a public static readonly field, that follows the TypeName + "Schema" naming convention as shown in the following example:

public class MyNode : NNode
{
 public MyNode()
 {
 }
 static MyNode()
 {
   MyNodeSchema = NSchema.Create(typeof(MyNode), NNode.NNodeSchema);
   // TODO: Declare Node Children Aggregation method
   // TODO: For container nodes - Create Node Child Slots
   // TODO: Create Node Self-Properties
   // TODO: Associate Custom Metadata
 }
 public static readonly NSchema MyNodeSchema;
}

As you can see, the first thing to do in the static constructor of a certain node type is to create a singleton schema instance for it, by passing the respective node type and base schema to the NSchema.Create method, and store the returned instance in a public static readonly field, that follows the mentioned naming convention. Once you do that you can perform the following optional schema building steps:

• Declare Node Children Aggregation method 

As mentioned in the Nodes topic, each type of node can aggregate other child nodes in its children dimension in two ways - as a collection or as a container.

If you want to make a collection node, you need to call the MakeCollection(NSchema childrenBaseSchema) method of the newly created schema (see Nodes for an example). If the base schema is already defined as a collection, the childrenBaseSchema argument can only be a schema that is equal or derived from the childrenBaseSchema of the base schema. If the base schema is already defined as container the method will throw an exception.

If you want to make a container node, you need to call the MakeContainer() method of the newly created schema. If the base schema is already defined as collection the method will throw an exception.

• For container nodes - Create Node Child Slots

If you have declared the node as container you can define the node child slots by calling the AddChild method of the newly created schema (see Nodes for an example).

• Create Node Self-Properties

You can define the self-properties of the node type by calling the AddSlot and AddMember methods of the newly created schema (see Properties for an example).

• Associate Custom Metadata

You can associate custom metadata to the schema - see Schemas and Meta Units below.

See Properties topic more info.

We have already discussed that schemas defines the way in which a specific type of node aggregates other nodes. The schema ChildrenAggregation property returns the currently defined aggregation method (None, Collection or Container). In case of collection and container nodes, the ChildrenBaseSchema property returns the base schema of the possible node children.

In case the schema is defined for a container node, the following methods help you query and iterate the child slots declared with it or with any of its base schemas:

See Child Slots for more info.

The metadata available for each schema includes flags and meta units. The following table summarizes the metadata API of NSchema.