First, we need to make sure that we know what anchors and user symbols are. Let’s briefly define these two notions:

• A user symbol is a graphic object built with the ILOG Diagrammer for .NET Diagram Designer. This designer, fully integrated into Visual Studio, is a WYSIWYG editor that produces C# or VB.NET code. Using this editor, you can build complex interactive symbols by assembling available shapes and symbols.
• An anchor is a point on a graphic object where a link can be connected. Each graphic object has a collection of anchors on which it’s possible to connect links.

Now that we know what we’re talking about, we can imagine the following scenario: A user has created a custom user symbol using our designer, and he wants to specify the exact location where links could be connected to this symbol. For example, when designing an electrical symbol, one need to specify that wires can be connected to the component terminals. Here is an example of such a symbol:

Let’s create this symbol in Visual Studio:

1. Launch Visual Studio 2005 or 2008.
2. Select File->New->Project->ILOG Diagrammer Symbol Library and name the project ElectricalSymbolsLibrary.
3. In the solution explorer, right click on the project, and choose Add New Item->UserSymbol (ILOG Diagrammer) and name the symbol Transistor.cs.
4. Choose Diagrammer->Import File and import transistor.ivn after extracting it from the following archive. Click Yes in the dialog asking if you want to import the file as vector graphics.

You should now have your transistor symbol visible in the designer:

Let’s now use this new symbol in a diagram so that we can try to connect links to it. To add a diagram to the project, right-click in the solution explorer on the project and choose Add->New Item->Diagram (ILOG Diagrammer). Compile the project (Build->Build Solution) to update the toolbox. Open the toolbox, your new transistor symbol should be available:

Drag a transistor symbol from the toolbox to the design surface. Repeat the operation to have several symbols in the diagram. You should now have something like this:

Let’s now try to connect the transistors together by creating links between them. Open the toolbox and locate the Connectors tab. Click on one of the links available in the tab, then move the mouse over one of the transistors. The anchors where the link can be connected are highlighted:

We can see that by default a user symbol has four anchors, each one located at the middle of the bounding box sides. Obviously, that’s not what we want here. One way to get the right anchors is to edit each transistor instance by modifying its anchors collection: After removing the default anchors (set the UseDefaultAnchors property to false), add three BoundsAnchor to the anchors collection (right-click on the transistor, and choose Edit Anchors…). Then, we need to move each anchor at the desired location. To do this, choose the Edit Anchors () icon from the Diagrammer toolbar and move the mouse over the transistor. It’s now possible to move the three anchors previously added to their right location by clicking each anchor and dragging it to its desired location. Then, if we go back to the link mode connection by clicking on a link in the toolbox Connectors tab, we can see by passing the mouse over it, that our transitor has now its anchors placed at their right location:

The main drawbacks of this approach are:

• The anchors are not part of the symbol itself, since they have been added after the symbol creation. If you create an instance of this symbol by code, your new anchors will not be available.
• We’re not using the default anchors feature of the graphic objects, and thus, anchors are created and added to the component model even though there are no links connected to them. This can be a performance issue if you have many objects with many anchors.

An alternative to this approach is to define the default anchors directly when designing the transistor. How can we do this ? Let’s go back to the designer view of our transistor by double clicking the Transistor.cs file in the Solution Explorer. The trick is that all the real anchors (not the default ones) defined in the sub objects of our transistor will be exposed as default anchors for our user symbol. Thus, we simply need to add three anchors on the sub objects composing our transistor. Let’s see how to do it.

If you look at the Document Outline view in Visual Studio, you will see that our transistor is composed of several shapes:

The interesting objects are the polyline1, polyline2 and line1 objects. On each one, we will add a new PolyPointsAnchor, which is a type of anchor whose location is bound to a vertex of a polyline object. Right-click on the polyline1 object in the designer view, and choose  Edit Anchors. Add a PolyPointsAnchor and click the OK button. Repeat the operation for the polyline2 and line1 objects. Note that in our example, the anchors are located on the first vertex of each polyline, which is the default for PolyPointsAnchor objects.

Let’s compile the project and switch back to our diagram view to test our transistor by double clicking the Diagram1.cs file in the Solution Explorer. To start with a fresh diagram, remove existing instances of the transistors. Then drag and drop a new transistor from the toolbox and try to connect a link to see that the highlighted anchors are the expected ones:

We’ve successfully changed the default anchors of our transistor, without having to write a single line of code.

1. Authoring licensed components.
2. Creating licences at design-time.
3. Creating licences at compile-time.
4. Creating licences at run-time.

Authoring licensed components

I’ll not spend too much time on that topic, as it’s widely documented on the web (see for example this article).

The process is simple. After creating your component, you have to:

1. Apply a LicenseProviderAttribute to the class.
2. Call LicenseManager.Validate from the class constructor to get a licence.
3. Dispose the licence in the component finalizer.

The licence provider specified by the LicenseProviderAttribute attribute in step 1 is used during step 2: Calling LicenseManager.Validate in your component constructor will create an instance of this license provider, and will call its GetLicense method to get a licence. If no licence can be found, LicenseManager.Validate will throw an exception, making your component unusable.

Specifying the licence provider has also another usage: It’s used by Visual Studio to know whether a component is licensed or not. Indeed, as we’ve seen in the first part of this article, Visual Studio manages a licenses.licx file containing all the licensed components used in a project.

Microsoft provides the LicFileLicenseProvider class, a ready-to-use licence provider. But if you need to implement your own logic, you have to create a new licence provider by subclassing the LicenseProvider class. That’s what we’ve done here at ILOG for our .NET products (ILOG Gantt for .NET and ILOG Diagrammer for .NET) because we wanted to implement ILM (ILOG License Manager). Subclassing the LicenseProvider class is relatively simple, as you just need to override the GetLicense method. We’ll see later how to implement this method.

The LicenseProvider will be used in three different contexts:

• At design-time.
• At compile-time.
• At run-time.

Creating licences at design-time

Here we assume that we’re building an application that contains licensed components using Visual Studio. The typical way to do it is to drag and drop a toolbox item onto the design surface, which results in the instantation of the component. As the licence checking is done in the component constructor, a licence has to be provided at that time. Let’s see how to handle this case in the LicenseProvider.GetLicense method through a partial implementation:

public override License GetLicense(
    LicenseContext context,
    Type type,
    object instance,
    bool allowExceptions)
{
    //
    // The context parameter indicates the context
    // in which the component is used.
    //
    bool runtime = context.UsageMode == LicenseUsageMode.Runtime;                 

    if (runtime)
    {
        //
        // Will see later what to do here
        //
    }
    else
    {
        //
        // Here we are designing our application, so we need to
        // get a licence that we will store in the context.
        //                 

        //
        // We're calling the GetDesignTimeLicenseKey() method to get a licence.
        // The code for this method is not provided here, but a simple
        // implementation could be to look in the registries or in a specific
        //  file to check that a valid licence has been installed on this computer.
        // The implementation of this method depends on the licensing schema
        // you want to set up.
        //
        string licenseKey = GetDesignTimeLicenseKey(type);                 

        //
        // If no licence was found, error
        //
        if (licenseKey == null)
        {
            if (allowExceptions)
                throw new LicenseException();
            return null;
        }                

        //
        // Save the licenseKey in the context. It will be possible at runtime to
        // retrieve it.
        //
        context.SetSavedLicenseKey(type, licenseKey);                

        //
        // We create and return a new CustomLicence object using
        // the licenseKey. The code for the CustomLicense class is
        // straightforward, as it's a simple implementation of the License
        // class. It's given below.
        //
        return new CustomLicense(licenseKey);
    }
}               

class CustomLicense : License
{
    private string _key;
    public CustomLicense(string Key)
    {
        _key = key;
    }
    public override string LicenseKey
    {
        get
        {
            return _key;
        }
    }
}

To sum up, the creation of a licence at design time is a 3 steps process:

1. Get the licence key installed on the computer. It can be a licence file, or a registry key…It depends on the way you want to manage the installation of licence keys on development computers.
2. Sets the licence key into the licence context. This will make it possible to retrieve the licence key at runtime.
3. Create a License object using this licence key.

Note : The License class is a .NET class that encapsulates the licence key, which is a simple string.

The LicenseContext used by Visual Studio and passed as the first parameter of the GetLicense method is said to be a “design-time” context, that is, a context whose UsageMode property returns LicenseUsageMode.DesignTime.

Creating licences at compile-time

Once the application has been designed, it needs to get compiled. As we’ve seen in the first part of this article, Visual Studio invokes the licence compiler to compile the licenses.licx file into an assembly resource file.

The licence compiler takes a .licx file as input and produces a resource file as output. It parses the .licx file and create an instance of each type found in it. The LicenseContext used by the licence compiler is a design-time context, an instance of the DesignTimeLicenseContext class. For each component created, a corresponding licence is also created and is stored in the licence context in a hash table. This hash table is then dumped it into a resource file.

This resource file will be used differently at run-time depending on the application type your’re creating, as explained in the first part of this article.

Creating licences at run-time

As for design-time and compile-time, licence checking will take place at run-time each time a licensed component gets instantiated. The difference is that the LicenseContext used will be a run-time licence context, that is, a context whose UsageMode property returns LicenseUsageMode.RunTime. This context will be able to retrieve the licences compiled with the licence compiler. Here is the a partial implementation of the LicenseProvider.GetLicense method:

public override License GetLicense(
    LicenseContext context,
    Type type,
    object instance,
    bool allowExceptions)
{
    //
    // The context parameter indicates the context in
    // which the component is used.
    //
    bool runtime = context.UsageMode == LicenseUsageMode.Runtime;                 

    if (runtime)
    {
        //
        // At runtime, look into the context to find the licence.
        // Depending on the application type, the context may look into
        // the application resources (Windows Forms), or the
        // App_Licenses.dll assembly (Web sites)...
        //
        string licenceKey = context.GetSavedLicenseKey(type, null);                

        if (licenceKey != null)
            return new CustomLicense(licenceKey);           

        if (allowExceptions)
            throw new LicenseException();
        else
            return null;
    }
    else
    {
        //
        // Already covered in the "design-time" section
        //
    }
}

The interesting part here is the call to the LicenseContext.GetSavedLicenseKey method. It will look into the context to see if a licence for the specified type can be found. Depending on the application type (assembly based applications, web sites, windows forms hosted in IE), the context will look in the appropriate location to find the licence.

Conclusion

We’ve seen in this article how the licences were created during the three phases of an application development: design-time, compile-time, run-time. Of course the code given was simpified for the purpose of this article, but you can imagine to enrich it by adding cryptography or anything that can make your licence management more secure.

First, what is the purpose of licensing ? It’s a mechanism that makes sure that only users with a valid licence can use a component. The .NET framework has a built-in licensing mechanism that makes it easy to author licensed components. From the component user point of view, it also has a great support in Visual Studio, which makes the use of licensed components easy. In this first article, we’ll focus on how to use licensed components.

Using Licensed Components with Visual Studio

Using licensed components inside Visual Studio is completely transparent for the user. The usual way to use components in Visual Studio is to drag and drop them from the toolbox onto a design surface: When a toolbox item is dropped onto a design surface, Visual Studio creates an instance of the component represented by the toolbox item and adds it to the designer. If the component created is a licensed component, Visual Studio also adds a licences.licx file to the Visual Studio project.

The licences.licx file contains the type names of the licensed components used in a Visual Studio project. Here is an example:

ILOG.Views.Gantt.Windows.Forms.ActivityTable, ILOG.Gantt
ILOG.Views.Gantt.Windows.Forms.ResourceTable, ILOG.Gantt
ILOG.Views.Gantt.Windows.Forms.GanttChart, ILOG.Gantt

The licences.licx file is updated each time a new licensed component is added to the designer. You can also create or edit this file by hand. You must do this for example if you don’t create the components by dragging them from the toolbox.

The .licx files are associated in Visual Studio with the licence compiler tool (lc.exe). When building your project, the license compiler is run with the licence file as parameter. Compiling the licences produces a resource file that will be used at runtime by the application. Let’s see now in details how the compiled licences are used at runtime, depending on the application type you’re building.

Assembly-based Applications

This category of applications regroups all the applications that are assembly based, that is, applications whose ouput produce an assembly. It contains Windows Forms applications, WPF applications, Silverlight applications, as well as class libraries. It also contains Web project applications. For these applications, the compiled licences are automatically embedded in the resources of the application assembly when the project gets compiled. For example, let’s say I have a Windows Forms application called GanttEditor.exe that’s using licensed components. After compiling the application, we can check that a licence resource has been added to the application resources. To do this, I use Reflector, my favorite .NET disassembler :

The licences.licx file has been compiled into a resource called GanttEditor.exe.licenses.

Web Sites Applications

In Visual Studio, a Web Site is a special project, as there’s no real project file. Instead, all the files located under the web site directory are part of the web site. When a licensed component is dropped into a Web Form designer, Visual Studio creates a licenses.licx file and adds it to the web site directory. This licence file is compiled into an assembly named App_Licenses.dll, located in the web site Bin directory. This assembly will be loaded at runtime to locate the licences. Note that you can force the generation of the App_Licenses.dll assembly by right-clicking the licenses.licx file in the solution explorer, and choosing the “Build Runtime Licenses” menu item.

Using Licensed Components without Visual Studio

For some reasons, you may not use Visual Studio to create your application. In this case, you’ll have to integrate the licence into your application by yourself. These are the steps to follow:

1. Create and edit you own licenses.licx file.
2. Compile the licenses.licx file using the licence compiler (lc.exe).
3. Integrate the compiled licence file into the application.

The last step depends on the type of application you’re building. For example, in a Windows Forms application, you have to put the compiled licence as an emdedded resource of the application (using the /resource option of the c# compiler if it’s a c# application). When hosting Windows Forms controls in IE, the process is different, and is described in the next section.

Windows Forms controls hosted in Internet Explorer

Embedding a Windows Forms control in Internet Explorer can be painful for two reasons:

• Code Access Security : When running into Internet Explorer, the hosted control doesn’t have the same permissions as if it was run as a desktop application. Configuring the CAS is not a simple task, as well as finding the minimum permissions required by a control to work properly inside IE.
• Licence Management : You have to compile the licences by yourself.

Let’s illustrate how to manage licences with a very simple example: You want to embed a GanttChart (located in the ILOG.Gantt.dll assembly) into the default.htm page. As the GanttChart is a licensed component, you’ll have to provide an entry for it in the licenses.licx file:

ILOG.Views.Gantt.Windows.Forms.GanttChart, ILOG.Gantt

Then, you’ll have to compile this file using the licence compiler:

lc.exe /target:default.htm /complist:licenses.licx /i:ILOG.Gantt.dll 

the /target parameter must be the page in which the licence will be used,

the /complist parameter is the .licx file to compile,

the /i parameter indicates the assemblies needed to compile the licence.

The licence compiler will produce a file named default.htm.licenses. Now, we need to use this file in the HTML page as shown below: 

<html>
...
<HEAD>
...
<LINK REL="licenses" href="default.htm.licenses" mce_href="default.htm.licenses" />
...
</HEAD>
...
<OBJECT id="ganttControl" height="300" width="800" classid="ILOG.Gantt.dll#ILOG.Views.Gantt.Windows.Forms.GanttChart" />
...
</html>

The <OBJECT> tag is used to insert the control in the HTML page, and the <LINK> tag is used to indicate where the licence can be found.

Conclusion 

We’ve seen two different ways to use licensed components in .NET: With or without Visual Studio. When using Visual Studio, it takes care of everything. When not using it, you need to do things by yourself.

Now, from a developper point of view, it would be interesting to understand how the licence compiler works, and how to author licensed components. That will be the subject of a second article.

In the introduction, the speaker, Dick Lantim, has redefined the RIA acronym that usually stands for “Rich Internet Application”. For Microsoft, RIA means “Rich Interactive Application”. This concept includes both RDAs (Rich Desktop Applications) and RIAs (Rich Internet Applications). For each of these applications Microsoft has an answer which is WPF for the desktop, and Silverlight for the browser. Using these technologies, the three main platforms of RIAs can be addressed : PC (WPF), Mobile and Web (Silverlight). Note that for the mobiles, Microsoft has announced that Silverlight will be available on Windows Mobile and Symbian.

Some WPF demos were shown, as well as Silverlight 2 demos. For Microsoft, the target is clearly to make Silverlight as visible as possible, and to put it as an alternative to Flash: Several Silverlight demos were based on existing applications developed with Flash, to emphasize on the Silverlight strengths.

As the release date of Silverlight 2 approaches (August 08), the differences between WPF and Silverlight in terms of features are becoming subtle. The big differences are:

• WPF can access the computer resources (files, …).
• WPF supports 3D.
• WPF can only be used on a PC where the .NET Framework is installed.

 Interesting points that were covered:

• Deep Zoom : A built-in load on demand technology for huge images on Silverlight. Huge images are tiled using the Deep Zoom Composer tool. Then, the MultiScaleImage object is used to display the tiles.
• Pages Indexation : Web sites containing dynamic pages (ASP.NET, AJAX, …) or Silverlight controls are difficult to index by search engines. Several solutions can be used to solve this problem, such as mirroring the dynamic web site by a static web site containing only HTML. Another solution is to detect that a crawler is indexing the site, and to dynamically create the pages for the crawler.

 Robert Dupuy