Premise has released a new service pack for 2.0 last Wednesday. If you happened to get this pack make sure you got the correct one. The server build should be 8351. Apparently a small but potentially bad bug was found so they quickly fix the bug and posted a corrected patch.
It was nice to see swift turn around. Also the team seems to be trying to crank out fixes as fast as they can and get them to us.
This MiniBroker lesson shows how to access child objects from the root object using C# and .Net. In addition, we will use the proprety inspector component of .Net to change some properties. This example builds upon lesson 1.
Collections
All IRemotePremiseObject objects can have a collection of child objects. Thus you can find and manipulate the children or even more nested objects. For this lesson we will use only the most basic way of iterating through the collection of child objects.
The main way to iterate though the child objects is to use the children property of IRemotePremiseObject. This property directly exposes the collection. A collection of IRemotePremiseObject is exposed via the IRemotePremiseObjectCollection. The interface exposes the following a property called Count and several methods. The Count property can be used to find out how many objects are in the collection. Their are several methods the only ones of importances are Item, Add, and Remove. Item returns the object at a given position. Essentially the collection is a zero based array. Thus the valid indexes are 0 to Count - 1. Add and Remove methods add and remove IRemotePremiseObjects from the collection. The collection is also setup to have an Enumerator method so you can use the foreach syntax. Thus we iterate through the collection using either a for loop or for each enumerator. One thing to note is that the enumeration has one annoying feature. It iterates one past the actual count and thus the last item in the foreach loop is null. I do not know if that is a Premise feature or a Microsoft COM Interop feature. So, I have learned to just use the for loop rather than rely on foreach.
To actually load the tree view we need to add the children of the root object to the tree view (See the code below). This is accomplished by creating a method to loop through the children of a IRemotePremiseObject adding them to a TreeNode. Finally, change the form load event to use the new method.
private void Form1_Load(object sender, System.EventArgs e)
{
root = miniBroker.Connect("LocalHost", null, null);
PremiseObjectTree.Nodes.Add(BuildNode(root));
}
private TreeNode BuildNode(IRemotePremiseObject parentNode)
{
TreeNode result = new TreeNode(parentNode.DisplayName);
for(int loop=0; loop < parentNode.children.Count; loop++)
{
result.Nodes.Add(BuildNode(parentNode.children.Item(loop)));
}
return result;
}
Inspecting IRemotePremiseObject
Now that we have a tree view of premise objects it would be nice to inspect each object. One little know component that comes with VS.Net is a property inspector. This component is literally the property inspector that is used by VS.Net to change properties and by default is disabled. To have it show up in your tool box you will need to do the following:
This great little component automatically finds the exposed properties of .Net objects. To use this component simply drop it onto the ObjectView panel and rename it to PremisePropertyGrid. Any object property that is read and write can be changed. The change will actually be reflected in HCS (former Sys). Add the following line of code to the load method and viola you can see the exposed properties. Unfortunately their are not many. In the next lesson we will write some code to display and manipulate Premise properties that are not directly exposed!
PremisePropertyGrid.SelectedObject = root;
Selecting Objects
Our last task is hooking up selection of an object in the tree view to view it's properties in the property grid. To accomplish this we do the following:
First question you might have is how do you fetch the IRemotePremiseObject. One of the methods available to you in IRemotePremiseObject interface is GetObject. This method returns an IRemotePremiseObject based on its relative path, absolute path, or id. The path consists of the name of the parent object followed by a /. So for example to find the path of Home you would take the root whose name is sys:/ append a / and then the name of Home which is Home. This gives you sys://Home for a path. If you look at what we are storing in the Treeview you will notice that it is the DisplayName and not any of the items we need. Oops! So we can not use our current Tree view implementation.
The easiest way to handle this is to change what we store in the tree view from DisplayName to Name. Now we only figure out the path by traversing the node selected up to the root building a path. Once we have the path we can use this to fetch the object using the root object and the path we constructed. This gives us the following code is the complete listing include the code for the AfterSelect event of the tree view.
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using Premise;
namespace PremiseClient
{
///
Play around with the object and see what you get. Next lesson we will focus on properties by looking at how we can cause all of the properties to show up in the property grid.
This article shows some basic functions of MiniBroker using C# and .Net. While I will try to keep to very simple examples a basic knowledge of programming and C# or VB.Net would be very helpful. I recommend starting with Microsoft's C# Developer Site or Visual Basic Developer Site for more information. To run this example you need the Integrator version of Premise installed.
The MiniBroker acts as a client to the Home Control Server or Sys. With it you can control or configure anything in Sys from a device, media, schedule or scenes. In todays example we will see how to connect and display information.
The example will be creating is a simple Window Application that mimics in some ways Builder. It will contain a tree view of your Premise Objects and allow you to manipulate some basic properties of the object.
Starting
To start we will use VS.Net to build the basic layout of the window.
Connecting
First thing to using the MiniBroker is to create an instance of the broker. To accomplish we must first have the program see the MiniBroker. You have two choices:
For the purposes of this example I assume that you added the Premise.dll assembly rather than create one from the COM type interface.
Now double click on the caption of the form to create an event for the OnLoad of the form. This should give you a new window with the code showing and an empty method called Form1_Load created. This is where we will create a connection to HCS aka: Sys.
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using Premise;
The ISysMiniBroker is the interface for the MiniBroker COM interface. To get the actual COM object to instantiate we need to create it using the SysMiniBrokerClass object. We will also need to create a variable called root which represents the root of HCS object tree. To set the root you need to use the Connect method of the ISysMiniBroker interface. This method takes three parameters (ServerName, UserName, and Password) and returns the root of the HCS object tree. You must have a server name either localhost, ip address, or server name. If you have specified a username and password to get to the server then you need to supply those as well otherwise you can use null or empty string as the username and password.
Finally lets add the root to the TreeView component. By default IRemotePremiseObject exposes Name, DisplayName, and Description properties directly. Other properties are exposed directly as well but we will leave that for another day. So your code should now look like the following:
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using Premise;
namespace PremiseClient
{
///
At this point make sure the program compiles and runs. You will also notice a slight lag while the form connects and fetches the root object. Your window should look like the following:
Next lesson we will see how to load the TreeView by looping through the children of the root.
If you follow Premise then you know that Premise 2.0 has been released. In the coming weeks I will show you what new goodies exist in Premise 2.0 that will make Premise that more exciting to use.
Here is just a snippet:The most useful change is allowing access from other tools besides Builder and writing modules in VB Script. The MiniBroker is a cool little COM object that exposes the functionality of Premise. With MiniBroker you can write ASP pages, Windows Applications or even .Net Managed applications and web services. It really gives developers unparalleled ability to create new kinds of interfaces and programs to interact with Premise.
For those of you interested you now check out a new forum that Premise opened to discuss the new MiniBroker.
