your .net design team

Intro To .net Rx Extensions

2011-06-07T09:51:00.001-04:00

Attached is the presentation and the code used in the ODNC presentation on June 6, 2011.

Visual Studio Code and presentation.
Intro To Rx Extensions Presentation

Ottawa IT Camp 2011 is scheduled

2011-01-24T15:03:00.001-05:00

I am looking forward to Ottawa IT Camp (previously called Code Camp) 2011 scheduled for Saturday, April 16, 2011.

IT Camp is a one-day training event for developers, database administrators and IT people.

We will be there to talk about some topic in Jetfire.

Building an Admin Panel using Web Parts Presentation

2010-11-24T17:00:00.001-05:00

Today I presented this topic at the Ottawa Dot Net Community. Good turn-out with about 20 people. This was a one-hour lunch-time presentation.

The agenda covered:

Web Parts Overview
Admin Panel mini-spec
Admin Panel Code Demo

The overview is a series of slides in the PowerPoint presentation providing a quick summary of Web Parts from Personalization tables to Zones for browsing, editing and catalogs.

The mini-spec is a one page summary of the key points for the Admin Panel (see slide 14).

Let’s Code

Finally the last 35 minutes looked at the key design issues and how to solve them in code:

Instantiation vs Reflection
Only display the active Web Part
Initializing the Panel

In designing an Admin Panel, I am adamant that labels on the user interface be totally customizable. This means that the labels not only map to the Web Part properties, such as Title, but also track personalization changes that a customer makes to a Web Part.

Instantiation creates objects where the properties have default values. Reflection tries to find the Web Part on the page and use the values saved in the Personalization database.

When there over three Web Parts on an Admin Page, it is important to hide the Web Parts that are not in use. I call this a “Point, click, Use” interface. Point the mouse at the link for the web part that you want to use. Click the link. Use the Web Part that appears on the screen. There should only be one Admin Web Part visible on the page.

Finally the panel is initialized when we use reflection to create Web Parts. This means that the first time that the page is displayed, all Web Parts are automatically added to the page. We are ready to customize them.

Slides and sample Demo Admin Panel Web Part code are included.

Contents include:

PowerPoint slides
DemoAdminPanelWebPart.cs
L.cs (a collection of useful statics for manipulating Web Parts)

Jetfire Version 1.3

2010-11-23T08:55:00.001-05:00

This new version of the dynamic programming language Jetfire (available for download on Codeplex) provides a number of new features and improvements. To provide these new features and improvements a new expression parser has been written to employ Linq expression trees. Version 1.3 contains both the new expression parser and the original expression interpreter. This allows the original expression interpreter to be used by simply changing a setting should any problems be encountered.

Version 1.3.x will provide the following:

Improved Performance:
The expectation over the next few releases is that performance of the Jetfire code will be close to that of C#. Jetfire version 1.3.0 is already 2x faster than V1.2.x. Benchmarks on parts of the expression parser that are still in lab indicate performance parity between C# and Jetfire. This is an ambitious, perhaps even outrageous, goal for a dynamic language. We do have a high degree of confidence that we can meet this goal.
Duck Typing:
Version 1.3.0 now supports ‘duck’ typing. This provides a very simple alternative to Interfaces. Jetfire ‘duck’ typing will be enhanced in coming releases with a simple, yet effective construct that will aid in compile time checking and auto complete (intellisense) for IDEs such as Visual Studio.
Dynamic operators:
Operators can now be dynamic. For example the following is valid Jetfire code.
string s = Add(“my”, “string”);
int i = Add(1, 6);
…
public object Add(object a, object b)
{
return a+b;
}
ReadOnly objects:
Now complete objects can be made ‘read only’ which compliments the existing ‘read only’ property functionality using roles. With release 1.3.0 the first use of a ‘read only’ object is ‘Empty’; however with future updates it will possible for objects to be dynamically ‘read only’ based on roles. This will allow an object to be ‘read write’ by, for example the object owner, some users can only read the object and while other users have no access at all to the object. When a read only object is used an exception occurs if an attempt is made to write a ‘read only’ object.
Improved Void Safety:
Void safety has made a step forward as all objects are automatically assigned the ‘read only’ ‘Empty’ object instead of null. It is still possible to assign objects to null (and still get the dreaded ‘null object exception’), but the ‘Empty’ object greatly enhances void safety. ‘Empty’ objects can be created programmatically via Jetfire software, otherwise they are automatically created.
Easy Reflection:
The plan is to add a very simple mechanism to support calling methods (very simple delegate mechanism) and creating new workflows based on string variables. For example:
string s = “MyMethod”;
Call s();
Or
string s = “MyClass”;
MyClass myClass = new s();

Auto-generate Documentation for Web Parts

2010-10-25T14:25:00.005-04:00

As a designer, I constantly struggle with the time required for designing great software programs and writing user documentation that helps people understand how to use the program. [Some people argue that if it’s a great program, it doesn’t need documentation, but I know that even the brightest users often need a push in the right direction for how to get the most out of the product.]

I am particularly interested in auto-generating documentation for Web Part Properties. The CMS Admin Panel got me thinking about this problem. The Admin Panel needed an Admin Help Index – a list of the Web Parts in the Admin Panel, who can access them and a short summary of what they do. Since this information is readily available in the Web Part itself, I decided to auto-generate this documentation.

Auto-generating the Admin Help Index

I auto-generated the Admin Help Index in a Web Part using the following algorithm:

// Order the Web Parts in alphabetical order
WebPart[] webParts = new WebPart[mgr.WebParts.Count];
mgr.WebParts.CopyTo(webParts, 0);
IEnumerable<WebPart> parts = webParts.OrderBy(x => x.DisplayTitle);
foreach (WebPart wp in parts)
{
IAdminRole admin = wp as IAdminRole;
if (admin == null)
continue;
C.AddBreak(2, this);
C.AddLabel(String.Empty, "Title: " + C.AddStyle2H3(wp.DisplayTitle), Unit.Empty, this);
C.AddBreak(1, this);
if (admin.AdminRole != String.Empty)
{
C.AddLabel(String.Empty, "* Roles required to access: " + admin.AdminRole, Unit.Empty, this);
C.AddBreak(1, this);
}
C.AddLiteral("* Description: " + wp.Description, this);
}
Code Snippet 1: Generate an Admin Help Index

Some notes about the algorithm used in Code Snippet 1:

Use the WebPartManager to find all Web Parts on the Page. The Admin Panel is on a page that contains all Web Parts indexed from the Admin Panel.
Using LINQ, order the Web Parts alphabetically. In this case, I used the DisplayTitle property as the key.
The ‘IAdminRole’ interface is used in Web Parts to identify the none, one or more roles that can access the (admin) Web Part. This comes in handy in filtering out the Admin Web Parts on the page. [There are other Web Parts on the page used for image header and navigation menu.]
Format the output as shown below.

Title: Assign Roles to CMS User
* Roles required to access: WebMaster,Admin
* Description: TrackerRealm Assign Users Web Part assigns roles to a user.

The Admin Help Index uses Web Part Properties: DisplayTitle, Description and the IAdminRole interface to create a help index.

Auto-generating Documentation for Web Part Properties

Auto-generating Documentation for Web Part properties needs to use reflection to find the properties for the Web Part (because we only have the base class). I decided to write a Web Part for auto-generating documentation for Web Part Properties. This allows me to dynamically add the Web Part to a page and change the default property values.Here are the requirements for the AutoGenWebPart:

Accept input from the query string for the type of Web Part requested.
Generate a header and list of properties showing each display name, description and default value, if used.
Output the documentation in html for display on a web page, plain text, or wiki, for inclusion in a wiki.

Query String input

/// <summary>
/// Gets and Sets the format that the documentation is output: wiki, text, html
/// </summary>
[Category("Display"), Browsable(true), Personalizable(PersonalizationScope.Shared), 
WebDisplayName("Output Type"), DisplayName("Output Type"),
Description("Describes the format that the documentation is output: wiki, text, html.")]
public OutputType OutputType
{
get { return this.op;  }
set { this.op = value;  }
}

Code Snippet 2: Sample Property for a Web Part Property

The property in Code Snippet 2 shows the Display Name and Description used in the documentation. This is meaningful to the user because the Web Part editor displays the Display Name for each Property.

string wpType = this.Context.Request.QueryString.Get("name");
if (wpType == null)
this.OutputText("No request received");
Type type = System.Web.Compilation.BuildManager.GetType(wpType, false);
if (type == null)
this.OutputText("Cannot find " + wpType);
WebPart wp = Activator.CreateInstance(type) as WebPart;
if (wp == null)
this.OutputText(wpType + " is not a Web Part");

Code Snippet 3: Create the Web Part
The first step in the Web Part is getting the requested (type) name for the Web Part from the query string. If there is no parameter for ‘name’, then the user receives no output ("No request received").

With a text version of the type present, we can use reflection to get the Class and then create an instance of the class. If the type is not a Web Part class, then the user receives no output ("Cannot find " + wpType).

Auto-generate the Documentation

sb.AppendFormat("{0}{1}{2}{3}", this.h4s, wp.Title, this.h4e, this.br);
sb.AppendFormat("{0}Description{1}: {2}{3}", this.bs, this.be, wp.Description, this.br);
sb.AppendFormat("{0}Properties{1}{2}", this.h5s, this.h5e, String.Empty);
sb.AppendFormat("Properties are listed alphabetically{0}", this.br);
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(wp);
PropertyDescriptor[] props = new PropertyDescriptor[properties.Count];
properties.CopyTo(props, 0);
IEnumerable<PropertyDescriptor> pds = props.Where<PropertyDescriptor>(x => x.Category == "Display")
 .OrderBy(x => x.DisplayName);

// Sets an PropertyDescriptor to the specific property.
foreach (PropertyDescriptor p in pds)
{
 switch (p.Name)
{
case "Title":
case "Description":
continue;
}
sb.AppendFormat("{0} {1}{2}{3}: {4}{5}", this.star, this.bs, p.DisplayName, this.be, p.Description, this.br);
object o = p.GetValue(wp);
if (o == null)
continue;
string value = o.ToString();
if (value != String.Empty)
sb.AppendFormat("{0}{1} Default Value: {2}{3}", this.tab, this.star, value, this.br);
}
Code Snippet 4: Auto-Generate the Property list for a Web Part

Code Snippet 4 shows the steps involved in auto-generating the documentation for the Web Part. It looks unnecessarily complicated with the formatting options defined by the instance variables. Let’s dissect the first statement: sb.AppendFormat("{0}{1}{2}{3}", this.h4s, wp.Title, this.h4e, this.br);

I wanted to dress up the title, so I included text formatting in the formatter.

wp.Title is the Title of the Web Part
this.h4s is the starting format for the title
this.h4e is the ending format for the title
this.br is the break between lines

Each variable was initialized with the wiki syntax. I then created a method for initializing the output of html and plain text.The key statement in the mix is getting the properties:
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(wp);
This statement uses reflection to get the properties of the Web Part.

IEnumerable<PropertyDescriptor> pds = props.Where<PropertyDescriptor>(x => x.Category == "Display")
  .OrderBy(x => x.DisplayName);

Copy the properties into an array and then using System.Linq extensions, we find the Display Category properties and order them by DisplayName.

Display the Output

private void OutputText(string text)
{
if (this.outputType == OutputType.Html)
{

  System.Text.StringBuilder sb = new System.Text.StringBuilder();
string styleSheet = String.Format("http://{0}{1}/app_themes/{2}/stylesheet.css",
  context.Request.Url.Authority, context.Request.ApplicationPath, "default");
sb.AppendFormat(@"<html><head><link href=""{0}"" type=""text/css""
  rel=""Stylesheet""/></head><body>", styleSheet);
  sb.Append("</body></html>");
// Write the content to the Web Page
  context.Response.ContentType = "text/HTML";
context.Response.Write(sb.ToString());
context.Response.End();

  return;
}
// Display the Documentation as a text file (applies to txt and wiki options)
 this.Context.Response.ContentType = "text/plain";
this.Context.Response.Write(text);
this.Context.Response.End();
}
Code Snippet 5: Output the text

The wiki and plain text format are output by writing the text to the browser.
Writing html is essentially the same, but is complicated because I like seeing the documentation with a good looking style sheet, in this case the style sheet from the default theme.
The following table shows a partial sample output of documenatation auto-generated for the CMS Admin Panel Web Part.

The following information is a brief description and list of properties for a Web Part developed by TrackerRealm. It is meant as a help summary.

CMS Admin Panel

Description: TrackerRealm CMS Admin Panel Web Part presents the administrative options for the site. The Correct Web Part is displayed for the selected action.

Properties

Properties are listed alphabetically
* Admin Role: The roles allowed to access this Web Part.
* Default Value: Admin
* Allow login to Jetfire?: Check if the login to Jetfire is allowed for users
* Default Value: False
* Back Color: Back Color for the Web Part.
* Default Value: Color [Empty]
* Devices: Devices that are allowed to see this WebPart: All, Normal, Mobile.
* Default Value: AllDevices

<--snip-->

Building a News Scroller with Jetfire

2010-10-22T14:56:00.004-04:00

Making an impact on web pages is about keeping the information concise and attractive. Most home pages use a scroller for news and/or events.

The Jetfire News Scroller makes it easy to add news to your home page. It includes:

Jetfire code
A Web Part with a Rich Text Editor for creating a news item
A Web Part with a scroller for displaying news items
jquery javascript for implementing the scroller

Jetfire code

Jetfire Persistent Scripting Language is an open source, object oriented, scripting language designed to make persistent programs, sometimes called workflows, very easy to write and maintain. The News Item displayed in the scroller is a simple program, which consists of:

Some properties that are displayed on the web page

Title of the News Item
The body of the News Item (photos and text)
An expiry date
Who created the news item
When the news item was created

A method for identifying that the News Item is Current
States for the news item

Active: Display the news item
Inactive: Don’t display the news item

namespace JetfireApps
{
// This workflow creates News Items with an expiry date.
// Use 'IsCurrent' to check the Expiry Date and identify if the News Item is current.
// state Active means that the News Item is current.
public workflow NewsItem
{
// Add workflow constructor
public NewsItem()
{
Tags = new List();
enterstate Start();
Created_Date = DateTime.Now;
Created_By = User.Login.Name;
Expiry_Date = DateTime.Today.AddYears(1);
}

// Add states to the workflow
public Start()   { }
public Active() { }
public Inactive() { }

// Add Properties
// Use Subject as News Title
// Use ToolTip as News Description
// Add Expiry Date
public bool Never_Expires
{
get;
set;
}
public DateTime Created_Date
{
get;
private set;
}
public plainString Created_By
{
get;
private set;
}
public DateTime LastUpdated_Date
{
get;
private set;
}
public plainString LastUpdated_By
{
get;
private set;
}
public DateTime Expiry_Date
{
get;
set;
}
public List Tags
{
get;
private set;
}
public bool IsCurrent
{
get
{
 if (Never_Expires)
 {
  return true;
 }
 if (DateTime.Now.Preceeds(Expiry_Date))
 {
  return true;
 }
 // This news item is now expired
 enterstate Inactive();
 return false;
}
}

// Add Command Methods
public void FinishEdit() : states(Start,Active)
{
if (Subject == "")
{
 throw exception("Enter Title");
}
if (ToolTip == "")
{
 throw exception("Enter Description");
}
LastUpdated_Date = DateTime.Now;
LastUpdated_By = User.Login.Name;
enterstate Active();
}
public void Set_Inactive() : states(Active)
{
enterstate Inactive();
}
public void Set_Active() : states(Inactive)
{
enterstate Active();
}
}
}

Rich Text Editor in a Web Part

Someone has to create the news that is displayed on the website. Figure 1 shows a portion of a Jetfire page that we use to create our news. There are two Web Parts displayed on the figure.

The Web Part on the left is a Workflows Navigation Web Part that is configured to display a list of all News Items.
The Web Part on the right is the News Item Editor. It contains:

State of the News item
Some commands that the user can to manage the news item
The Properties of the News Item: Title, Never Expires, Expiry Date and Body

The Body of the News Item is a Rich Text Editor that allows the user to input rich text, images and links.

Figure 1: News Editor in web page

News Scroller Web Part

Figure 2: News Scroller in web page

Figure 3: A subset of properties used to configure the News Scroller (below)

Figure 2 shows the News Scroller in the home page of http://www.jetfire.ca. The Web Part is configured to display a new item every 400 milli-seconds. The user may also choose to manually select a News Item.

The News Item program can be configured in different ways by a Web Master for display on the web page. Options include:

Display the Active News Items

Let the news item editor manage the states of the News Items. When a News Item has out-lived its time, the editor sets the state to Inactive

Display News Items that have not expired

Let the news item editor establish an expiry date for each news item. Some companies expect news items to be displayed at least 2 weeks. Then the news item is delisted. This option tracks expiry for the editor.

Figure 3 shows a subset of the edit properties for the News Scroller. The Web Master has a number of options that describe how the News Scroller will operate.

Select what News Items are displayed using the first propery: Filter. By providing a list of name/value pairs, the software converts this into a filter used to get the list of News Items.
Display the header option? If Checked, then the “Created on …..” is displayed. The Web Master can create the header format by editing the Header Property. The format is “Created on {0} by {1} to {2}” where {0} is the value of the Created by Property, {1} is the value of the Created Date Property and {2} is the value of the Workspace where the News Item is stored.
Auto-rotate may be enabled/disabled.
The Rotation interval may be set.

jquery javascript library

jQuery is a fast and concise JavaScript Library that simplifies HTML document traversing, event handling, animating, and Ajax interactions for rapid web development. We use this as our AJAX JavaScript library. jquery has an active community, who are constantly submitting new programs. One such program is Featured Content Glider: by http://www.dynamicdrive.com. It includes the javascript and the css stylesheet used in the news scroller.

Change Session State Programmatically

2010-10-22T11:22:00.002-04:00

Customers using Jetfire Workflows rely on websites with good connectivity to stay connected to their business and keep their business processes up-to-date. Recently, our ISP moved their Data Center to be better served by a higher speed internet connection. Web pages are definitely served faster, but I also noticed busy intervals during the day leading to page rendering delays and often dropped logins for customers. The dropped logins require users to re-login – a nuisance when you are busy.

Session State in the web.config file is set up as ‘InProc’, meaning that the Session State is stored in memory. By changing Session State to ‘SqlServer’, the goal was to avoid unnecessary re-logins.

In a hosted environment, this procedure is:

Run the sql script for the ASPState database on the local server
Change the Session State parameter in web.config to ‘SqlServer’
Set the parameters for the SqlServer Session State

In an ISP environment, step 1 is changed to create the database and upload the database schema.

For our lazy deployment person (that’s me), even this simple procedure was too complicated. I needed a one-click procedure to manage the transition automatically and minimize the amount of effort required to convert each site.

These are the design steps used to add the session state tables to an existing database and then create a Web Control to change the session state.

Create the ASPState tables in my local database
Create a script for the ASPState tables
Put a C# code wrapper around the ASPState sql script
Create a Web Control that changes Session State with one-click

The figure on the right shows the desired end result – a web control that changes Session State from memory storage to database storage and simple enough that the customer administrator can do it.

ASPState Tables

The .NET Framework includes an install database and tables script for ASP State. Since we are adding the ASPState tables to an existing database, we need to create an sql script that only addresses the tables (and stored procedures).

This involves installing the ASPState tables in my development system. The sql script, InstallSqlState.sql, to do this is found in one of the following folders; system drive\ Windows\ Microsoft.NET\ Framework\version\.

SQL Script for ASPState Tables

Once the ASPState database and tables are created, generate the script for the ASPState tables. I used the Database Publishing Wizard found in codeplex project: http://sqlhost.codeplex.com. Just follow the instructions.

C# code wrapper about sql script

The sql script is not a slam dunk at this point. There are a few gotchas that need to be addressed.

The sql script does not contain the name of the customer’s database. When ISP hosting is used, it is highly likely that every database that the ASPState tables are added to has a different name. Therefore, a name, such as ‘DatabaseNamePlaceHolder’ is embedded in the file in multiple places. (there were over 80 places where this occurs)
Delete the GO statements. Do a replace all ‘GO’ strings with ‘’ (an empty string).
strings in the file, e.g. “2” need to be converted to “”2””. [there was only one instance to change.]

Code Snippet 1: SQL Script for ASPState tables

The above code snippet shows a portion of the SQL script for installing ASPState tables.

Note: The sql script is over 1100 lines of code, which is why it is not included in its entirety.

Code Snippet 2: Create the ASPState Tables

The above code snippet creates the tables for the ASPState tables.

Get the Connection String where the tables will be added.
Instantiate an SqlConnection object. This is used to get the name of the customer’s Database.
Get the sql script and replace ‘DatabaseNamePlaceHolder’ with the name of the customer’s Database.
Execute the modified script on the database.

The end result is tables: ASPStateTempApplications and ASPStateTempSessions, along with all Stored Procedures are installed in the target database.

Web Control that changes Session State with one-click

This section addresses how to change the mode for Session State programmatically. (The user interface code is straight-forward.) The Session State is located in the web.config file at the root of the website. It is retrieved using the code found in Code Snippet 3.

this.config = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration("~/");
SystemWebSectionGroup webGroup = this.config.GetSectionGroup("system.web") as SystemWebSectionGroup;
this.sessionState = webGroup.SessionState;

Code Snippet 3: Get the Session State from web.config

The ‘ChangeMode’ method, shown in Code Snippet 4, is called from the link click event of the Web Control. Key points include:

Only SQLServer and InProc modes are supported
The session State object is updated for the selected mode
A message is printed to the user providing a positive indication of what has changed
The change is saved in the web.config file.
Text displayed on the Web Control is updated.

Code Snippet 4: Change the Mode of the Session State

There is a lot of flexibility in the SQLServer mode for Session State. Read the MSDN help closely to ensure that you engineer the correct operation for your application.

When the customer Administrator converts the storage of Session State from memory, ‘InProc’ to database, ‘SQLServer’, all users need to re-login because when the web.config is changed for this procedure and of course, because the Session State for each user is now null.

Object Serialization Gotchas

Further web testing showed that my work was not finished. There was one object that was stored correctly when the Session State Mode was ‘InProc’. However, it was real clear that the object needed to be serialized to the database when the Session State was changed to ‘SQLServer’. Whereas, ‘InProc’ stores a reference to the object in the Session memory, ‘SQLServer’ serializes the complete object to the database for each Session.

This required some re-work of the class in question and the code that used the object.

Design for a Web Part-based Admin Panel

2010-10-21T18:04:00.002-04:00

Last month, I outlined the specifications for a Web Part-based Admin Panel. This article reviews the code involved in building the Admin Panel. The code in this article relies to a limited degree on class libraries, which are not described in detail. If you are interested in more information about anything in the article, just provide a comment on the blog and answers will appear.

The Admin Panel is a Web Part. This allows the designer to include personalizable properties, which allow for customization of the Web Part. Properties include:

AdminRoles: a comma-delimited list of Roles that are allowed access to admin level functions included in the Web Part. The default Role is “Admin”.
LinkCssClass: a css class used to style the links. The default is “hyperlinkV”.
MouseOverCssClass: a css class used to style the links when the user hovers over a link. The default is “hyperlinkVMouseOver”.
TargetZone: the Web Part Zone where Web Parts are created. The default is “Row1Column2”.
NavLinksFile: an xml file that contains navigation information for the site to implement the ‘My Links” feature*. The default is the path to the NavLinksFile used in the site.
MenuName: the name of the menu to display to the user from the NavLinksFile to implement the “My Links” feature. The default menu name is “My Links”.

* The “My Links” feature was added after the specification was finished. A customer said “Wouldn’t it be nice if….” and My Links was born.

Since properties are standard items for a Web Part, the code is not included for the properties.

The Admin Panel and the Web Page

The Admin Panel is added to a web page. When the page is displayed, it displays the CMS Admin Panel shown in the figure below. Once the user is logged in, the Admin Panel Web Part can be edited to set the Personalizable properties to values other than the default values.

The categories in the Admin Panel went through extension partitioning during the design and initial beta testing. By putting the administration related functions into a single page, a number of revelations were identified:

What is the REAL purpose of the Web Part?
- Cut out the fat in the Web Part
- Keep it simple, so that default properties make the Web Part usable when initially added to the page
What is the correct partitioning of the Web Parts? (A lot of User Experience discussions went into this stage)
- How do users see administration being done?
- What is the travel required between Web Parts?
What administration-related Web Parts are missing?
- It is easy to carried away in this stage – after all, we do love to write code:-)

Figure 1: CMS Admin Panel (shown for a logged in user)

The left Admin Panel shows what a logged in user with the Admin role sees. The right Admin Panel shows what a logged in user without the Admin role sees. Both are based on the default roles included in Web Parts.

<%@ Page MasterPageFile="~/App_Master/W1MasterPage.master" Title="Jetfire Administrator's Tools" %>

<%@ Register TagPrefix="cc1" Namespace="TrackerRealm.WebPartsE" Assembly="TrackerRealm.WebPartsE" %>

<asp:Content ID="Content2" runat="server" ContentPlaceHolderID="ContentPlaceHolder1">
    <table width="100%">
    <tr valign="top"><td>
    <asp:WebPartZone ID="Row1Column1" runat="server" HeaderText="Row 1 Column 1" >
        <ZoneTemplate>
        <cc1:AdminPanelPart ID="AdminPanelPart1" runat="server" />
        </ZoneTemplate>
    </asp:WebPartZone>
    </td><td style="width:600px;">
    <asp:WebPartZone ID="Row1Column2" runat="server" HeaderText="Row 1 Column 2" >
        <ZoneTemplate>
        </ZoneTemplate>
    </asp:WebPartZone>
    </td></tr>
    </table>
</asp:Content>

Code Snippet 1: The Admin Panel in a Web Page

Admin Panel and Site Initialization

The Admin Panel has real value during the design of a new website. View the page with the Admin Panel on it for a new site and the user is prompted to create a new user. If there is at least one user present but the user is not logged in, then the user is prompted to login. One of the requirements is that users MUST be logged in to use the Admin Panel.

// Check if there are users for this domain
if (Membership.GetAllUsers().Count < 1)
{ // Starting Condition for system: Create User and Login
 this.AddError("CreateErr", "Create a CMS User");
 CC.AddCreateUserPart("Login", Unit.Empty, this);
 return;
}
if (!this.LoginProfile.CP.IsAuthenticated)
{ // User must login
 this.AddError("LoginErr", "CMS Login is required to access the CMS Admin Panel");
 CC.AddLoginPart("Login", Unit.Empty, this);
 return;
}

Code Snippet 2:  Site Initialization code

Panels

Each major category in the menu is a Panel that hides and shows the links to Web Parts. Code Snippet 3 shows the method call to create the panel. The method takes an id, title, tooltip and parent control.

Panel pnl = AdminPanelPart.AddPanel("Page", "Page Management", "Tools to manage pages", this);

Code Snippet 3: Add a panel for the links

Links to Web Parts are added to each panel. Since reflection is used to decide whether the Web Part is visible to the user, it is not known ahead of time what panels are displayed. Therefore a simple test is used to check if the panel should be visible.

pnl.Parent.Visible = pnl.Controls.Count > 0;

Code Snippet 4: Show the panel ONLY IF it contains links

Figure 2 shows the Admin Panel when a user has expanded the Page Management category. There are 4 links, each displayed using the css class defined in the site’s stylesheet.

Figure 2: CMS Admin Panel showing the Page Management menu expanded

Links

Links for a set of Web Parts are added to the panel for each category. The objective is to have a simple method for adding the link to the panel. This method contains two parameters, the first for the type of Web Part being added and the second for the panel control that the link is added to. So simple – bizarre, that it should take about 6 iterations before arriving at this.

this.AddLink(typeof(CreatePagePart), pnl);

Code Snippet 5: Add a Link to a category

Code Snippet 6 shows the code used to add a link to the panel. The Admin Panel Web Part exposes library and editor functions. That is why the logged in user must be able to enter share scope on the page. Web Parts are dynamically added the first time that the Admin Panel is run in the AdminPanelPart.GetWebPart method. The Admin Panel Web Part has over 30 Web Parts that it dynamically creates and adds to the page. To display all Web Parts to the user at once is overwhelming, so the default is to hide all of the Web Parts that are dynamically added to the page.

Each Administration Web Part adheres to the IAdminRole interface, which identifies the visibility of the Web Part in the panel for the logged in user.

Finally, a link to the Web Part is included in the Admin Panel. A number of points about this:

The Web Part Title is displayed and the Web Part Description is used as a link mouseover. By using reflection to find the Web Part on the page, the stored value of the Title and Description is retrieved from the Personalization Database to provide the customer with a customized Admin Panel. e.g. if the Customer does not like the Title: Update Page Meta Data, it is easy to change the title to something else which then is displayed in the Admin Panel.
The LinkButton control is styled using the css classes.
The Full Name of the Web Part is added to the command argument and is used in the event handler to display this Web Part as the visible Web Part.

private void AddLink(Type t, Control parent)
{
if (!this.mgr.Personalization.CanEnterSharedScope)
return;
WebPart wp = AdminPanelPart.GetWebPart(this.mgr, this.targetZone, t);
if (wp == null)
{
this.AddError("NoWP" + t.Name, "Cannot get Web Part: " + t.FullName);
return;
}
IAdminRole admin = wp as IAdminRole;
if (admin != null)
{ // Check that user is allowed access to the Web Part
if (!admin.IsAdminPanelVisible(admin.AdminRole))

return;
}
LinkButton link = C.AddLinkButton("link" + t.Name, wp.Title, wp.Description, linkCssClass, Unit.Percentage(100), parent);
C.AddStyle(link, linkCssClass, mouseOverCssClass);
C.AddBreak(1, parent);
link.CommandArgument = t.FullName;
link.Command += new CommandEventHandler(link_Command);
}

Code Snippet 6: Code for adding a link

The GetWebPart method looks through all Web Parts in the page for the requested Web Part. (this means that a single instance of any Web Part is included on the page.) If the requested Web Part is not found, then the Web Part is dynamically created (this will be the subject of another blog article). Finally, properties are set in the Web Part and the found Web Part is returned up the stack.

public static WebPart GetWebPart(WebPartManager mgr, string targetZone, Type t)
{
 foreach (WebPart wp1 in mgr.WebParts)
 {
  if (wp1.GetType().FullName != t.FullName)
   continue;
  return wp1;
 }
 string error = String.Empty;
 WebPart wp = L.CreateWebPart(mgr, t.FullName, targetZone, ref error);
 if (wp == null)
  throw new Exception("Cannot create: " + t.FullName + " " + error);
 ITWebPart iwp = wp as ITWebPart;
 if (iwp != null)
  iwp.LoginType = LoginType.COR;
 return wp;
}

Code Snippet 7: Get the requested Web Part

When the user clicks a link for a specific Web Part, the code in Code Snippet 8 is invoked. The variable, ‘wpTypes’ (Web Part Types) is a list of strings, i.e. the Full Names of the Web Parts to be displayed to the user. The list is stored in the ViewState, thus keeping the Web Part visible until it is no longer required.

void link_Command(object sender, CommandEventArgs e)
{
 string wpType = e.CommandArgument.ToString();
 this.wpTypes.Clear();
 this.wpTypes.Add(wpType);
}

Code Snippet 8: Display the Web Part

Admin Roles Interface

One of the goals of the Admin Panel is to highly customizable for each customer. It is typical that each customer partitions the work done in the organization differently. Therefore, it is important that the tools can be molded to how the customer wants to use them.

Initially, the links were added to the page by instantiating the Web Part type. The problem with this approach is that the default properties are present. It became clear quickly that Reflection was required to get the Web Part on the page and the properties that may have been changed by the customer. The Admin Role interface was a simple way to identify what roles were allowed access to each administration Web Part and hence whether it was visible to the logged in user.

By having each Administration Web Part adhering to the IAdminRole interface, this simplified the code and created consistency across the Admin Panel user interface usage.

public interface IAdminRole
{
/// <summary>
/// A comma-delimited list of Roles that are allowed to use the Web Part.
/// Used in association with Web Part that use the Admin Panel.
/// </summary>
string AdminRole
{
get;
set;
}
/// <summary>
/// Used by the Admin Panels to identify that the Web Part is visible to the user
/// </summary>
/// <param name="roles">A comma-delimited list of Roles</param>
/// <returns>true is the Web Part is visible in the Admin Panel</returns>
bool IsAdminPanelVisible(string roles);
}

Code Snippet 9: IAdminRole interface

My Links

The ‘My Links’ feature was simple to add. Just get the links from the Navigation Xml File and add each link as a LinkButton to the Web Part as part of the ‘My Links’ panel. Note that the method Link.Get includes a LoginProfile. This ensures that the links displayed match the roles of the logged in user.

if (this.navLinksFile != String.Empty)
{
 XmlDocument doc = C.ReadXmlFile(this.navLinksFile);
 List<Link> links = Link.Get(this.Context, this.LoginProfile, doc);
 List<Link> myLinks = links.FindAll(l => l.MenuName == this.menuName);
 if (myLinks.Count > 0)
 {
  Panel pnl = AdminPanelPart.AddPanel("MyLinks", "My Links", "Display a set a site favourite links", this);
  int i = 0;
  foreach (Link link in myLinks)
  {
   this.AddLink(i, link, pnl);
   i++;
  }
 }
}

Code Snippet 10: Adding My Links to the Admin Panel

The Last Word

As mentioned above, over 30 Web Parts are present on the Admin Panel page. When Editing the page, it is very confusing UNLESS the content of each Web Part is invisible, as shown in Figure 3.

Another comment is that the page with the Admin Panel should deny logged in users edit and catalog access. By doing this, as the user navigates the site, they do not have to manually change from Edit/Catalog to Browse mode for the Admin Panel page.

Figure 3: CMS Admin Panel in Edit Mode

Specification for a Web Part-based Admin Panel

2010-09-22T14:11:00.000-04:00

Building Web 2.0 enabled websites with COR – a website Content Management System and Jetfire – a workflow language means a powerful, flexible set of Web Parts available for building websites from scratch. The ASP.NET Web Part is a Microsoft custom control that is used to personalize websites. Properties in the Web Part may be decorated with the Personalization attribute that indicates that the value of the property will be stored in a database. Web Parts can easily be added to a web page from a library and then edited, saving the changes in a personalization database that comes with Visual Studio. Web Parts were initially included in Visual Studio 2.0 and owe their specification to SharePoint.

So what’s the problem? With over 100 Web Parts available to build a website, navigation to the right Web Part for inclusion on the page becomes the issue. Is there a simpler way to get the Web Part that is needed when it is needed?

Organizing Web Parts

ASP.NET Web Parts are organized in a set of catalogues with each catalogue consisting of a set of Web Parts that perform a function in a similar area, e.g. a catalogue for navigation Web Parts.

As COR was used for more websites, designer and debugging Web Parts were included.

WebPartDisplayMode

The Web Part Display Mode enumeration tracks what Zones on a page are visible and what actions can be performed on the Web Part Zone. This enumeration includes (for purposes of this article):

Browse
Catalog
Edit

The life-cycle for a Web Part on a web page can be described as:

Find the Web Part that you want added to the page
1. The Web Part Display Mode is set to Catalog. This displays the Web Part library in the Catalog Zone.
Select the Web Part that you want added to the page from a Web Part Catalog.
Add the Web Part by selecting a Zone on the page and clicking the Add button in the Web Part Library.
Change the Web Part Display Mode to Edit.
Edit the Web Part added to the page.
1. The properties of the Web Part are displayed in the Editor Zone.
Set the properties and click Ok. This saves the properties to the Personalization Database.
1. Clicking Ok also closes the editor for the Web Part.
Change the Web Part Display Mode to browse.
1. The Web Part is displayed as any visitor to the web page would see it.

Simplify, Simplify, Simplify

Any web site, whether it is 3 pages or 100 pages, has a number of required functions:

Page administration, e.g. Create a page, upload files
Site Administration, e.g. site navigation
Web Part Tools, e.g. assign roles to a folder
User management, create a user, edit a user
Roles management, create a role, edit a role, assign roles to a user

This set of functions represents over 20 CMS Web Parts that if positioned on separate pages would fill up to ten pages. That represents a lot of real estate on a website with navigation making it difficult to find the necessary function.

Certainly, we need to find a way to simplify how we find and access these Web Parts. The key questions are:

Is it possible to host these Web Parts on a single page?
How do we simplify the navigation?
How do we simplify the interface, so that we are not overwhelmed with too many Web Parts on the page?

The Admin Panel as the alternative interface

The Admin Panel is the alternative interface that combined the catalogue, edit and browse functions to create a highly functional, yet compact interface. By combining catalogue, edit and browse into a single control, the interface is simplified to these steps:

Find the Web Part that you want to use by navigating the Admin Panel navigation menu.
If the Web Part is not added to the page, then the Admin Panel code adds the Web Part automatically to the page.
The Web Part is displayed.
Wow – that simplifies how Web Parts are found and added to the page.

The Admin Panel can add a number of Web Parts to the page. If all of the Web Parts are visible on the page, this can be very confusing to the Administrator. Therefore, it is important to include a technique where all Web Parts, except the chosen one are hidden.

The above figure shows the CMS Admin Panel with the User Management and Role Management options displayed. The Manage CMS Users Web Part is displayed beside the CMS Admin Panel.

Admin Panel Strengths

By using the Admin Panel, there are a number of advantages for the website. These include:

A single page implementation for designer and debugging functions
Access to over 20 Web Parts on a single page
Reduced navigation and number of pages in the website for managing the site
The active Web Part is displayed alone on the page
A navigation menu on the Admin Panel presents the choices, making selection of the correct function easy
New system start-up prompts the user to create a new CMS user (when there are no users present)
Admin Panel start-up prompts the user to login (you must be logged in to use the Admin panel)
Access to multiple websites (Forms Authentication and the Personalization Database supports multiple websites from a single database)

Dynamic Languages – Why all the fuss?

2010-07-10T11:03:00.001-04:00

Lately there has been a surge of interest in dynamic languages, especially in the .net world with introduction of C# 4.0 that both gives C# dynamic language features and enables creation of dynamic languages with DLR. The short answer is that dynamic languages, such as Python and JavaScript, are part of a technology evolutionary process that supports developing application software that is both faster to write and faster to deploy. Dynamic languages are also part of a trend of new ‘Domain Specific Languages’ replacing traditional frameworks. Domain Specific Languages are typically dynamic languages as well.

So what is a dynamic language? The basic definition of dynamic language is one that performs operations at runtime that other languages perform at compile time or perform in multiple statements (if the operation can be performed at all).

Dynamic typing: This is the most significant attribute of many dynamic languages (and also a source of criticism). With this feature type checking is performed at runtime. This has a number of advantages such as

run time binding (note cartoon)
less code therefore faster development
no need to create interfaces
greatly reduces the need to create wrapper classes
supports Multiple Dispatch (dynamic method calls)
enables other dynamic language features

Feature	C# (rel 4.0)	Python	Javascript	Jetfire
Dynamic typing (aka Duck typing)	yes	yes	yes	yes
Strongly Typed	yes	yes	no	yes
Interface	yes	no	no	yes
Run time binding	no	yes	yes	yes
Type Checking	compile and runtime	runtime	runtime	compile and runtime
Roles	no	no	no	yes
Dynamic Access Modifiers	no	no	no	yes
Integrated ORM	no	no	no	yes
Integrated SVC	no	no	no	yes
Multiple Dispatch	with dynamic or extension	with extension	no	yes

Criticism: Dynamic languages have their share of critics. Many software developers believe that dynamic languages merely shift type checking problems to runtime. In a non-dynamic language type checking is performed by the compiler, catching many errors before the code is ever executed. With most dynamic languages typing errors are only caught at run time with real data. This rub is that a non-dynamic language applications still need to simulate dynamic typing thereby introducing the possibility of runtime errors. This handicap also needs to balanced with the other benefits of dynamic typing.

Summary: My view on this criticism is I have heard it all before. This debate has been going on since the beginning of the computer age. Whether the issue be high level languages vs assembler (yes many programmers argued against using high level languages) or managed code vs compiled code there has always been detractors arguing for the status quo. Helping blunt their criticism has been technology improvements where compilers generate code nearly as good as hand assembled code and managed code/byte code (.net, Java) becomes almost indistinguishable from compiled code. The same will be true for dynamic languages as new languages and new releases aim to fix these issues.

The bottom line is any new technology, such as dynamic languages and domain specific languages, that supports better programmer productivity will win out.

Excellent, but long video on this subject:
Dynamic Languages Strike Back

Tips to Prevent .net Memory Leaks

2010-06-25T15:31:00.001-04:00

Microsoft .net has a built-in garbage collector, yet programs can contain memory leaks. Many times these memory leaks show up during testing in Visual Studio with the dreaded “Out of Memory” error. This is a good thing allowing the problem to be identified and fixed. Sometimes the units tests are themselves the cause of the memory leak casting suspicion on the validity of the tests or masking real problems that would otherwise by uncovered by the test. This is not good.

The first question to answer is how can a memory leak occur in the first place? After all .net has a garbage collector that should prevent memory leaks.

The garbage collector works by collecting unreferenced memory. When it can’t collect some object it is because there is a reference to it. There are 2 main culprits, namely, static collections and threads.

Threads will release their memory when they terminate. Threads fail to terminate either because they are waiting for a resource or are stuck in a ‘while(forever)’ loop. The good news is that by using the Visual Studio ‘Threads’ window it is easy to spot threads that have not terminated.

Static collections can easily cause memory leaks. This because the static field storing the reference to the collection is present as long as the program is operating. The collections can also be hidden inside other objects, for example C# Events are collections therefore a static event is really a static collection. Also be aware that long lived collections, be they system objects or in your code, can behave as static collections retaining references to unused objects.

The single best way to eliminate most, if not all, memory leaks is to:

employ the ‘using’ construct (or alternately try-finally construct) for objects that support the “Idisposable” interface.
Make classes that create threads or add objects to static or a long lived collection IDisposable.

The following C# code demonstrates employing the ‘using’ construct when working with the Linq-to-Sql ‘DataContext’ object (also see using DataContext example). The Dispose method is automatically called upon exit of the using block. The ‘Dispose’ method will be called even if an exception occurs within the ‘using’ block.

using (DataContext dc = new MyDataContext(connectionString))
{
    //
    // work with ‘DataContext’ object
    //
    // Dispose method is called automatically upon exit of the using block.
    // The Dispose method will be called even if an exception occurs
    // within the ‘using’ block.
}

Summary: Tips To Prevent Memory Leaks

Don’t use static collections or static events unless absolutely necessary.
Add the IDisposable interface (and write a Dispose Method) to any class that:
- Adds an object to static or long lived collection
- Adds a event handler a static or long lived ‘Event’ (events are collections)
- Creates a thread
Use the “Using” construct to insure the ‘Dispose’ method executes for an IDisposable object.
- This is very helpful when creating Unit Tests. Unit test themselves can easily be the cause of the memory leak if they don’t employ the ‘using’ construct.
- The ‘using’ construct should be employed when creating DataContext objects with ‘linq-to-sql’. This will insure that the DataContext objects are disposed properly, as they will not release memory by simply being dereferenced.
Alternately if the using statement is not practical, then use the ‘try-catch-finally’ construct placing the ‘Dispose’ method in ‘finally’ code section. Remember you don’t need to catch exceptions, you can simply use ‘try’ and ‘finally’.

Further Reading
stackoverflow thread on memory leaks in .net
How to detect and avoid memory and resources leaks in .NET applications

Marthon Jetfire Application Example

2010-06-25T09:14:00.001-04:00

This example demonstrates how to use the integrated ORM feature of Jetfire to be able support an almost unlimited number of objects.

In this example a Marathon registration system is required to handle over 100,000 athletes. A Jetfire object will be used to represent each athlete. Over time, as the application grows, there may be multiple objects for each athlete. For performance and resource utilization reasons it is desirable that only the objects representing the athletes that are currently of interest reside in the processor memory.

Naturally we want all the objects to be permanently stored in a database. Jetfire meets these requirements by transparently storing all objects in a searchable database (SQL server 2008 is preconfigured). The database can be searched using a linq style construct from either Jetfire code or .net application code.

Here is the Jetfire code representing an athlete. The object is quite simple, but can easily be extended by adding more attributes. Later examples will show to add features such as a approval process and how to allow each individual athlete to update their own information.

namespace Marathon
{
public workflow Runner
{
    // A workspace where the 'runner' objects reside.
    static workspace wsRunners;
    public static void InitializeRunner()
    {
        wsRunners = new workspace(""Runners"");
        // The contents of the workspace are only to be cached
        // in the client nexus when they are explicitly referenced.
        wsRunners.IsAutoCached = false;
    }
    public static Runner NewRunner(string firstName, string lastName)
    {
        Runner r = new Runner() at root in wsRunners;
        r.FirstName = firstName;
        r.LastName = lastName;
        return r;
    }
    public string FirstName
    {
        get;
        private set;
    }
    public string LastName
    {
        get;
        private set;
    }
}
}

The method “InitializeRunner” creates a workspace named “wsRunners” which is used to store the athlete objects called “Runner”.

The method “NewRunner” creates a athlete object using the ‘new’ construct. The ‘at Root’ specifies the garbage collector is not collect this object even though it may have no references. The garbage collector will collect ‘Runner’ objects when they are explicitly deleted. The “in wsRunners” specifies to store the object in the workspace.

The following shows .net C# code used to create athlete objects. Note the .net code can call Jetfire methods directly.

nexus.Parse(jetfireCode);
dynamic runnerClass = nexus.FindClass<WorkflowClass>("Marathon.Runner");
runnerClass.InitializeRunner();
//
// create some runners – automatically stored in database
//
runnerClass.NewRunner("Bob", "Weave");
runnerClass.NewRunner("Bob", "Best");
runnerClass.NewRunner("Long", "Distance");
runnerClass.NewRunner("Harry", "Heart");

To search the database for objects the following construct can be used. Searching can also be performed in Jetfire code.

//
// Search the database by executing the system library
// static method 'Nexus.Search()'.
//
dynamic[] runners = nexus.NexusClass.Execute<Workflow[]>
                           ("Search",
                            "Marathon.Runner",
                           @"w.FirstName == ""Bob"" ");

For a complete listing search for ‘MarathonTest.cs’ in the codeplex download.

Jetfire objects now Support .net DLR

2010-06-18T09:00:00.001-04:00

Jetfire provides .net programmers many features not found in the standard languages. Mixing Jetfire code and .net code has always been a straight forward task. Now, with Jetfire Dynamic Language Runtime (DLR) objects that task has been made much easier. Using Visual Studio 2010 Jetfire objects can now be accessed directly from .net languages.

DLR allows .net programmers to very easily use Jetfire objects in their applications as shown the following example:

Here is a simple Jetfire program.

namespace DlrExample
{
    public workflow MyFlow
    {
        public string MyString{get; set;}
        public string MyAction(){ return this.MyString;}
        public string MyAction(string s){return s;}
    }
}

To work with Jetfire objects the following C# code can be used.

dynamic myFlow = nexus.New<Workflow>("DlrExample.MyFlow");
//
// Access the Workflow's properties and methods
//
myFlow.MyString = "some string";
Assert.AreEqual("some string", (string)myFlow.MyString);
Assert.AreEqual("some string", (string)myFlow.MyAction());
Assert.AreEqual("some other string", (string)myFlow.MyAction("some other string"));

For a complete listing search for ‘TjDlrTest.cs’ in the codeplex download.
Also see
Dynamic Method Call Simplifies C# Code
Jetfire wiki article : Application Interface

Multiple Line Lambda Expressions – New in Visual Studio 2010

2010-06-16T09:40:00.001-04:00

New is Visual Studio 2010 is the ability to write multiple line lambda Expressions. The following example a lambda expression that is assigned to the delegate ‘MyFunc’.

The type ‘Func<int, bool>’ specifies to create a delegate (a method represented as an object) with a single ‘int’ parameter and return type of ‘bool’. See Built-in Delegates type for more information on ‘Func’.

[TestMethod]
public void Lambda_MultipleLines()
{
    Func<int, bool> MyFunc = i =>
        {
            if (i == 22) return true;
            else return false;
        };
    bool flag = MyFunc(22);
    Assert.IsTrue(flag);

    flag = MyFunc(1);
    Assert.IsFalse(flag);
}

Also See:
Builtin Delegates - Methods as objects
Dynamic Method Call Simplifies C# 4.0 Code

Built-in Delegate Types - Methods as objects

2010-06-15T16:35:00.001-04:00

A delegate in .net C# is merely a reference to a method that allows you to a) programmatically call a method, b) pass a method as a method parameter or c)store a method as a variable or in a collection. In short delegates allow methods to be used like an object.

One of the issues with delegates is that declaration process is quite difficult. First declare a delegate type, then use the delegate type in a declaration. To make life simpler in C# there are 2 major built-in delegate types, ‘Action’ and ‘Func’ (Function). These built-in types provide a shorthand notation that virtually eliminate the need to declare delegate types.

Action and Func are really a shorthand notation that virtually eliminate the need to declare delegate types in C#.

Action is a delegate type that describes a method that does not return a value.

Built-in Delegate Type	Describes:
Action	a method that does not return a value and has no parameters.
Action<T>	a method that does not return a value and has 1 parameters.
Action<T1, T2>	a method that does not return a value and has 2 parameters.
Action<T1, T2, T3>	a method that does not return a value and has 3 parameters.
Action<T1, T2, T3, T4>	a method that does not return a value and has 4 parameters.

Func is a delegate type that describes a method that returns a value.

Built-in Delegate Type	Describes:
Func<TResult>	a method that returns a value and has no parameters.
Func<T, TResult>	a method that returns a value and has 1 parameters.
Func<T1, T2, TResult>	a method that returns a value and has 2 parameters.
Func<T1, T2, T3,TResult>	a method that returns a value and has 3 parameters.
Func<T1, T2, T3, T4,TResult>	a method that returns a value and has 4 parameters.

Action Example

Use Action<T> to encapsulate the instance method ‘Operation’ into a delegate object called ‘MyAction’

private int i = 0;
[TestMethod]
public void ActionExample()
{
    Action<int> MyAction = this.Operation;
    MyAction(33);
    Assert.AreEqual(34, i);
}
private void Operation(int x)
{
    i = x + 1; // doesn't do much
}

Func Example

Use Func<T, TResult> to encapsulate an anonymous method (that has an integer parameter and returns an integer) into a delegate object called ‘MyFunc’

[TestMethod]
public void FuncExampleAnonymous()
{
    Func<int, int> MyFunc = delegate(int x) { return x + 1; };
    int z = MyFunc(33);
    Assert.AreEqual(34, z);
}

Also See:
Multiple line Lamda expressions - New Visual Studio 2010

Further reading

Integrated ORM in Jetfire V1.2

2010-06-12T09:33:00.002-04:00

New in .net Jetfire language version 1.2 is an integrated transparent object relational mapping (ORM) system. The system is transparent to Jetfire programmer. The major benefit is that Jetfire now supports unlimited number of objects, constrained only by the database. Jetfire comes complete with drivers for SQL 2008 (including 2008 Express). Drivers for other database systems can easily be created if they support .net Linq.

Jetfire still contains its original prevalence object persistence mechanism. This prevalence mechanism has been enhanced by an transparent ORM system.

In the Jetfire language when objects are created or changed they are automatically placed in the public workspace. All objects in the public workspace are automatically loaded on initialization. Objects can optionally be placed in workspaces where objects are only brought into main memory if they are explicitly needed or as the result of query operation.

Linq style queries are directly supported in the Jetfire language. Queries can also be performed directly from .net C#.

Build Large Applications with Jetfire KISS

2010-06-11T12:43:00.001-04:00

A common mantra in software engineering is to keep the amount code small. This sometimes known simply as the Kiss principle (Keep it short and simple or Keep it Simple Stupid). The smaller and simpler the code the easier it is write, debug, verify correctness, comprehend, test and maintain an application. Smaller code sizes also mean that the application can be built faster. Although these benefits may come at a price of larger memory requirements and slower performance, this is a price that many will gladly pay, especially given today’s rapidly changing business environment, inexpensive memory and fast processors.

Complex things consume resources

Keeping it simple has been our main goal for the dynamic .net language Jetfire since day one. We wanted a simple programming model that can anyone can easily build a large Web applications. We believe we have been successful as we have built a number of applications with less than 1000 lines of Jetfire code, one example is the OAWA registration system.

The OAWA registration system needs to keep track of thousands of athletes. The athletes all belong to a local wrestling club as well as the provincial organization. Each local club registrar has only access to that club’s athletes; however the OAWA registrar has access to all athletes. This entire system was built with less than 1,000 lines of Jetfire code. Of those 1,000 lines of code over 90% is property definitions (eg defining variables such as FirstName, Club Name, etc.).

The Enhansoft software registration application is an embedded application. This Jetfire application is designed to track software usage of the ehansoft productivity suite. The entire registration application is only 350 lines of code.

Our main criteria for simplicity when designing Jetfire has been the number of lines of code and can a “mere mortal” understand the program. The ‘mere mortal’ part has been important because it is possible to build code in languages that is terse; however it is virtually uncompressible, at least by a ‘mere mortal’. After all we are all ‘mere mortals’.

Einstein
“Make things as simple as possible, but not simpler”

Leonardo Da Vinci
"Simplicity is the ultimate sophistication"

Case Sensitive Linq to SQL Queries

2010-06-08T19:28:00.001-04:00

By default, Linq to SQL queries are case insensitive. The C# convention is that all comparisons are case sensitive. This is a problem and begs the question ‘How to perform a case sensistive query using Linq to Sql’?

To solve this problem declare ‘string’ fields of the linq-to-sql data class to be case sensitive by specifying the server data type by using one of the following;

varchar(4000) COLLATE SQL_Latin1_General_CP1_CS_AS
or
nvarchar(Max) COLLATE SQL_Latin1_General_CP1_CS_AS

Note: The ‘CS’ in the above collation types means ‘Case Sensitive’.

This can be entered in the “Server Data Type” field when viewing a property using Visual Studio DBML Designer.

The following code demonstrates how to perform both case insensitive and case sensitive queries. First set the ‘Server Data Type’ as shown above. The code creates 2 Contact objects (database records) with the ‘Name’ field set to ‘Bob’ and ‘bob’. Performing a case sensitive query returns 1 ‘Contact’ object and performing a case insensitive search returns 2 ‘Contact’ objects.

using (SciProjectTestDataContext dc = new SciProjectTestDataContext(
    @"Data Source=Blackoak\SQLEXPRESS2008;AttachDbFilename=C:\DbSciProjectTest.mdf;Integrated Security=True"))
{
   if (dc.DatabaseExists())
      dc.DeleteDatabase();
   dc.CreateDatabase();
   Table<Contact> contact = dc.GetTable<Contact>();

   //
   // Create ‘Contact’ records in the database
   //
   Contact c1 = new Contact
   {
       Name = "Bob"
   };
   dc.Contacts.InsertOnSubmit(c1);
   Contact c2 = new Contact
   {
      Name = "bob"
   };
   dc.Contacts.InsertOnSubmit(c2);
   dc.SubmitChanges();
   //
   // Case sensitive query
   //
   Contact[] cArray = dc.Contacts.Where(c => c.Name == "bob").ToArray();
   Assert.AreEqual(1, cArray.Length);
   //
   // Case insensitive query
   //
   cArray = dc.Contacts.Where(c => c.Name.ToLower() == "bob").ToArray();
   Assert.AreEqual(2, cArray.Length);
}

Dynamic Method Call Simplifies C# Code

2010-06-06T18:10:00.001-04:00

How many times has this happened to you? You want to write elegant code, but you can’t since C# requires knowledge of the object types at compile time. This forces you to write code that determines the type of an object so that the correct overloaded method can be called. You have no choice so you end up with some pretty ugly code.

string s;
//Assume either an 'int' or 'string' object
//is returned from GetObject
object o = GetObject();
if (o is string)
s = MyMethod((string)o);
else
s = MyMethod((int)o);

The overloaded ‘MyMethod’ for this example is quite simple.

public string MyMethod(int i)
{
return "int overload called.";
}
public string MyMethod(string s)
{
return "string overload called.";
}

With Visual Studio 2010 and C# 4.0 you can now write elegant code (in this situation at least).

dynamic o = GetObject();
string s = MyMethod(o);

This is much more elegant. It works because now the type of the object 'o' is determined at runtime and the correct overloaded method is called at runtime. In effect, the underlying code is the same, but now the compiler generates this code.

So if you find yourself generating code where you are testing the type of an object, then chances are that it can be simplified by using the dynamic type in C# 4.0.

“Elegance is not a dispensable luxury but a quality that decides between success and failure.”
Edsger W. Dijkstra

Also See:
Multiple Lambda Expressions in C# 4.0

Further Reading:
Wikipedia C# 4.0
MSDN article
Wikipedia Multiple Dispatch

Jetfire V1.2 Allows Applications to have an Unlimited Number of Objects

2010-06-04T12:10:00.001-04:00

New in release V1.2 of the dynamic language Jetfire is object oriented database searching (integrated ORM), support for object references to non-cached objects and partially cached 'Workspaces'. These features allow applications to be built that contain an almost unlimited number of objects, constrained only by the size of the database. An example is a marathon registration system that was required to handle 100,000+ athletes.

Previous to V1.2 all objects were loaded every time a Jetfire application started. This provides for fast access since all objects are in memory and is great for many applications where number of objects is less than 10k to 100k. Many systems successfully use this technique. When the application has millions of objects this technique breaks down due to the time it takes to load all the objects into memory and the amount of memory required.

Jetfire is designed to be simple enough for power users,
but capable enough for programmers.

Now a .net Jetfire application (Marathon example) can choose to only cache a few objects on start up. Then the application can perform a search using a full object oriented "where" expression. In our marathon registration example a specific athlete, state, province or sports club could be the parameter of the search. This will automatically cache the found objects in memory. Should any of the Jetfire objects contain references to non-cached objects these will be transparently cached into memory as required. If an athlete object had a property that referenced their local marathon running club, then the club object would be transparently cached should the software use that club property.

Jetfire is a .net open source, object oriented ecosystem designed to make writing persistent programs, workflows and policy management rules, very easy. The Jetfire language extends the C# programming model with integrated object oriented database functions (ORM), roles (integrated security), integrated source control, states (workflow) and dynamic typing. For more details see Jetfire first class constructs.

Marathon photo by Martineric

Jetfire Object Persistence is the Tip of the Iceberg

2010-06-02T15:49:00.001-04:00

Imagine writing code without worrying about how to store and retrieve objects. We did. We have written a large amount code using .net ADO, isolated storage, XML storage and other methods. We tried almost everything that was available in dot net. The techniques we didn't try we evaluated, such as DB4O and Entity Framework. They all worked or could be made to work, but none these approaches were transparent. These approaches to persistence also required a significant amount of support code and lot of understanding by the programmer to make them operational.

Transparent object persistence was one of the motivations for creating the Jetfire language (other language motivations). We didn't want the application programmer to have to understand the underlying persistence framework. For example the following line of Jetfire code automatically stores the object 'myObj' in persistent storage, typically a SQL database.

// create an object
MyObject myObj = new MyObject();

While adding persistence traditional OO benefits, as can be found in Java or C#, such as garbage collection, have been retained. For example if there is no reference to a Jetfire object, the garbage collector reclaims the object.

This; however is all the tip of the Jetfire persistence iceberg. Intrinsic to Jetfire is the concept of a user. All code must be executed by a user, even if it is just the default user (called Guest). Also multiple users can simultaneously execute code either on the same computer or multiple computers. All this places extra requirements on Jetfire persistence.

Jetfire object persistence has the following features:

Transparent to the programmer.
All object operations and updates are atomic.
Code (classes) as well as Jetfire objects are persisted.
Built-in versioning for code(classes) supports upgrading of objects to the latest version of code.
Audit objects are created for all transactions.
Individual objects have access rights, not unlike files a multi-user file system.
- Objects can be assigned a role(s) restricting access to users that also have that same role assigned.
Objects can be placed in a directory structure, using Workspaces. Workspaces are directories for objects providing an organizational structure and access rights.
Searching for objects is supported. Searches can be performed using any field or property in the 'where' expression.

By providing these features Jetfire relieves the application programmer of a huge programming effort allowing solutions to be delivered quickly.

Links

Workflow (Jetfire wiki)

This blog has moved

2010-03-29T09:44:00.001-04:00

This blog is now located at http://yourdotnetdesignteam.blogspot.com/.
You will be automatically redirected in 30 seconds, or you may click here.

For feed subscribers, please update your feed subscriptions to
http://yourdotnetdesignteam.blogspot.com/feeds/posts/default.

ODNC Luncheon Seminar Series Presents: Test Driven Design (aRealWorldExample)

2009-11-18T15:50:00.001-05:00

The Ottawa .NET Community is please to invite you to a luncheon presentation on "Test Driven Design (aRealWorldExample)". Test Driven Design is a powerful development paradigm and there's nothing like a simple "Real World Example" to help you wrap your head around it. The presentation is scheduled for Wednesday, November 18, 2009 at 12:00 noon. Bring your lunch and see how you can use Test Driven Design in your next project.

Test Driven Design (aRealWorldExample)

This session illustrates Test Driven Design in light of a real world scenario. The scenario involves a legacy class object that needs to be upgraded to meet a new user requirement. You will be walked through the process of creating the test cases that will be used to insure that the user requirement is fully met. You will then see how the solution is developed around these test cases. Note that LINQ functionality will be included in the solution and you will have the added benefit of seeing this technology in action. At the end of this session you will have a better understanding of how to integrate Test Driven Design (and LINQ) into your next project.

About Charles Wiebe

Charles Wiebe is the co-founder of TrackerRealm, a company that specializes in workflow design. He is a Microsoft .NET software architect/designer for Windows Forms and ASP.NET solutions. Charles' expertise lies in the Application Layer, working with Web Parts, and GUI development. He is currently responsible for the User Interface components used in COR, a Content Management System and Jetfire, a workflow domain specific language. Charles is an active member of Ottawa .Net Community; he has coordinated the last 2 Ottawa Code Camps and has played a major role in several ODNC Study Groups. Charles will also be one of the presenters at this year's Microsoft Tech Days Tour taking place in Ottawa next month.

The zip file contains the Visual Studio 2008 solution and PowerPoint used in the presentation.

Presentation covers:

The objective of upgrading the legacy filter class is to migrate the 'prototype' design done in 2007 and meeting with increasing success in market to a mass deployed component. This means expanding the boundary conditions and improving the test methodology.
Test Driven Development shows how to create a test case, followed by writing the code to "make the test pass".
The legacy Filter class is upgraded to use Generic FindAll and Find methods with anonymous methods
New method is added to Filter class as an extension method – good technique to follow when you want to add code in sand-box and test before submitting to release stream.
Rhino.Mocks used to improve testing methodology.

Jetfire – Maybe we should have called it DC#

2009-04-29T16:22:00.001-04:00

We were joking around the other day trying to describe Jetfire when we hit upon DC#, for dynamic C#. Now to be fair C# does have dynamic attributes (especially C# 4.0); however most of C# functionality is determined at compile time. Generally to be considered a dynamic language such as IronRuby, or IronPython, most of a language's functionality should be determined at run time. Dynamic languages do sacrifice some performance for increased application flexibility, although some would argue that in real applications there is no sacrifice in performance.

We say Jetfire, at least in jest, should be called DC# because its syntax comes directly from C# and it is a dynamic language. Jetfire has the following dynamic attributes

Dynamic typing
Dynamic Access Modifiers
Code can be created and executed 'on the fly'

Jetfire Links

Related Articles

Modeling a Workflow in Software

2009-04-17T12:10:00.001-04:00

On the surface modeling a workflow in software might seem like a very straight forward task.

After all according to wikipedia "A workflow is a depiction of a sequence of operations…". This sounds like a great match for a computer program modeling the workflow.

You could then use the software workflow to

Guide you through the workflow process.
Perform actions through the software such as send email, operate equipment or perform a computational process such as adjust a photograph.
Facilitate approvals
Record activity especially when actions were taken.
Roll up the results and status in other documents

However there are issues (you didn't think it could be quite this simple). All of these issues are resolvable, but add an extra layer complexity to modeling a workflow in software.

Workflow programs must be able to operate for days, weeks or even years. The implication is that the workflow program must automatically preserve its status. The status must be automatically restored if the computer is restarted.
Workflows go through states when the operations occur. Operations, or commands, need to work only in the appropriate state. For example a "Complete" command may only valid once the workflow is 'started'.
Workflows are performed by more than one person. This means that the workflow must be able to support simultaneous users working on different computers or devices.
Workflows need to be shared, but also be protected from incorrect usage. For an expense workflow the user may need to be a manager to approve it. The workflow program needs support different roles for different users.
Not everyone who uses a workflow sees the same data. For example an approver's comments may need to be hidden from the applicant.
Workflows change over time. For example an 'approval' process may change while there are requests in the system. The workflow software must be able to handle 'grandfathering' the process for requests already in the system or optionally support upgrading them.
Workflow programs need to be simple to design and build.

This is rational behind the dynamic language
Jetfire. Jetfire is domain specific language that handles all these issues with ease. Applications can be built quickly. Application code isn't obscured by reams of infrastructure code. With Jetfire the designer of workflow software can concentrate on the application, not the infrastructure. All this makes the workflow program more reliable and much easier to maintain.

Links

Related Articles

Form Maker debut

2009-03-22T10:53:00.001-04:00

We have been asked a number of times "where is the Jetfire visual designer"? Our attention was aimed at getting the programmatic model correct. We are now starting to deliver purpose-built visual designers. Why multiple designers?

The objective of Jetfire visual designers is to:

Provide simple GUI's for building applications
Take the 'programming' out of 'application programming'
Easily deploy applications
Provide a one-step process to writing and deploying applications

Figure 1: Form Maker in design mode

Our first release for purpose-built visual designers includes Form Maker. It is a simple first step, but designed to be practical. The key features of Form Maker include:

Add one or more properties
Reorder properties
Identify the property type (text, date, duration, integer, and more)
Build applications based on previous programs
Form validation
One-click deployment

Figure 2: Form Maker in layout mode

Click the 'Show Form Layout' link and Form Maker displays how the Form is displayed to a user.

The differentiator of Form Maker is one-click deployment. The user creates an application and with one click adds the application to the Jetfire ecosystem – ready for use.

Figure 3: Property types

Figure 3 shows the types of properties that can be added to a form in Release 1.

'UnknownType is displayed when reviewing an existing program and the property type is unknown, e.g. an enumeration.

Supporting Quality Processes

2009-03-22T10:51:00.001-04:00

In a previous blog, we stated that the "objective of Jetfire is to simplify the workflow creation/modification process so that Power Users can build workflows and upgrade them".

In the early 90's, I worked for a large corporation that implemented ISO-9001. To be compliant with ISO-9001, each department has to show that they followed their processes. The easiest process to show compliance was the software submission process, because it was tooled. Tracking the paper processes required continuous manual intervention.

Continuous Improvement is the name of the game to improve product quality. Software that naturally reinforces the rules is required to support quality processes. Tooling with the ability to easily upgrade is required. With this back-drop, let's look at Jetfire.

New Jetfire workflows are easily added, without upgrading system software.
Jetfire workflows should easily up-version.
Light-weight workflow ecosystem

Jetfire programs are built on an object oriented ecosystem that executes Jetfire code interpretively. This approach allows Jetfire workflows to be easily uploaded, without the need to upgrade the system software.

To up-version code, version is included in every object in the system. New code creates a new version of a Workflow Class, which are related to previous versions of the named workflow class. New and previous versions of the Workflow Class are accessible with the preferred class to be instantiated being the current version.

Finally, the small size of the Jetfire ecosystem provides a compact environment that is targeted at building applications.

Writing programs for the workflow domain

2009-03-22T10:33:00.001-04:00

Jetfire is a DSL (domain specific language). So what domain are we talking about?

When we started Jetfire, the goal was to create a language that makes workflows easy to write. I can say without reservation that we have achieved that goal. Let's review the differences between Jetfire and C#.

Jetfire is based on C#, so that programmers can easily write it.
The keyword 'workflow' replaces 'class'. 'workflow' is used to activate first class support for workflow constructs.
Dynamic Access Modifiers are used to make class members public/private depending on who is using the class.

The Jetfire domain specific language incorporates first class support for workflow constructs.

Let's review some examples of how Jetfire simplifies writing workflows.

Example 1: States – Some workflows are state driven. Jetfire Methods include a new type of method: the state method. 'enterstate' is a keyword used to promote the workflow into the specified state.

public workflow MyFlow
{

// 'Start' state

Start()

{

// place code to be executed when the state is entered.

}

// constructor

public MyFlow()

{

// put the workflow into the Start state

enterstate Start()

}

Example 2: Dynamic Access Modifier example using states – the AddData method is public when the workflow is in the Start state. Otherwise, the AddData method is private.

private ArrayList dataList = new ArrayList();

// method 'AddData' has a dynamic access modifier

public void AddData(string data) : states(Start)

{

this.dataList.Add(data);

}

Example 3: Dynamic Access Modifier example using access – the DoSomething method is public if the logged in user has the Role 'Approver'. Otherwise, the DoSomething method is private.

public void DoSomething() : access("Approver")
{
...
}

These are some powerful examples how a domain specific language can simplify writing workflows.

Why a Domain Specific Language is better than a Framework!

2009-03-17T14:20:00.001-04:00

If you are a programmer you use frameworks. Some frameworks such as a collection framework are almost indistinguishable from the language. I know in my C# code I find almost all my classes contain either 'List' or 'Dictionary'.

Other frameworks such as ADO .net are very large and require quite a bit of time learn. They provide an indispensible service to your application but are very difficult to learn and use. The application code that employs the framework is almost unintelligible. Adding more comments or the more judicious use of variable names seems to have no effect on making the code look better. The problem is that most frameworks need to expose details of internal concepts to application as numerous tunable parameters and properties. This is required since a typical framework has no other mechanism of inferring intent.

The need for the framework to have numerous tunable parameters and properties (lazy loading, concurrency issues, etc) compounds usage problems. This is because in order to be used correctly they need to be understood. Subtle errors in understanding a concept of a framework produces either subtle errors in the application or causes the application not to run a peak performance.

Using a domain specific language addresses a number of these problems.

A domain specific language after all is just another language. Most languages can be learned in a few hours to a few days. When we wrote Jetfire we started with C# syntax adding few specific features. A programmer's investment in understanding languages could be reused. The additional features in Jetfire, for example, are consistent with the C# programming paradigm.
The code in a DSL is designed to be understandable and compact. Unlike working with a framework where hundreds of lines of code are required just to provide initialization, working with a DSL typically requires very little code.
When you write code in a DSL the language is able to understand the programmer's intent and therefore is able to hide most of the complexity. For example Jetfire understands that variables should be saved to persistent storage. Therefore Jetfire does this automatically without the application programmer writing extra code. Jetfire also knows if a variable is used inside a method that it doesn't need to be saved because that variable is only valid as long the method is executing.

Policy based Management with Jetfire

2008-11-12T11:38:00.001-05:00

We have started an exciting new phase of Jetfire development. Our next release is planned to support both a rules engine and transparent access to .net objects.

Using Jetfire source code a rule will look like the following:

It needs to be mentioned that Jetfire code is not what the rule writer or rule user would see. They would, in all likelihood, see some sort of form based interface. Using Jetfire it extremely easy to write such an interface since it supports programmatically accessing the code for the rule. The Jetfire code is presented here for understandability.

How the rule code operates is that when an event occurs, in the above example when a 'property' is changed in any 'MailStats' object, parameters are generated for the rule. In the example above the 'mailStats' and 'user' parameters are extracted from the event parameters. Think of this as automatic method overloading. These parameters provide a context for the rule and naturally if a parameter was requested that didn't exist in the event object it would cause a coding error.

Any legitimate code is allowed within the 'condition', including calling other rules. Calling methods within a 'condition' is not allowed unless the method is deemed to be 'rule safe'. In other words helper methods are allowed such as converting from a string to integer. This allows the compiler to check the integrity of the rule 'condition' and insure that the 'when' events are sufficient.

Jetfire Policy Based Management Advantages

Jetfire rules are easy to code and understand. The built-in integrity features makes the rules very robust.
The ability to access .net objects means that Jetfire Rules can operate with existing data. That is there is no need to convert data. The data required for a Rule is in a database it can be easily accessed using a .net Framework such as ADO.
Since Jetfire is interpreted rules can be changed without recompilation or binding.
Code changes will not impact existing working rules since Jetfire includes automatic code version control.
Since Jetfire is a highly reflective language it is easy to present the user with friendly forms based rule system.

Navigating in Visual Studio

2008-11-11T20:09:00.001-05:00

I work with Solutions that contain hundreds of files. Navigating through many levels of directories can be a cumbersome task, especially when you are not the author of the Solution. In university, using Visual Studio for assignments was never a problem, since you get to architect the structure of the Solution.

Working with a larger Solution, I was constantly performing Searches on desired keywords. This worked, but very time consuming. I needed to speed things up to increase my productivity. I wanted a mechanism to remember where sections of code are located within the Solution. Here are a couple of tips that can help:

Tip #1: Using Bookmarks

Visual Studio has a Bookmarks feature that allows you to save a specific line in a specific file. They work exactly like bookmarks used in web browsers. Simply press Ctl+k and Ctl+k to save the line as a bookmark. Note that you need to do Ctl+k twice, as I presume Visual Studio is starting to run out of shortcut keys! Once the bookmark has been saved, you can view the bookmark in the Bookmarks window that can be docked at the bottom of your window:

Instead of using the filename as the Bookmark title, try placing a comment as the title instead to remind yourself the importance of the said file, or even a "TODO" comment. I have a handful of bookmarks for files I have edited so I can quickly re-visit the file if need be.

Tip #2: Track item in Solution Explorer

Another tip to help navigate Visual Studio is to enable "Track Active Item in Solution Explorer". This allows any active file to be highlighted in the Solution Explorer. This comes in very handy when performing Searches, since double clicking a result highlights the file in Solution Explorer, giving you a general idea of the location of the file within the Solution.

This option can be enabled through Tools -> Options -> Projects and Solutions.

This behaviour is actually enabled by default, but for whatever reason, this feature was disabled one day. I went through days without this feature, so I finally made the effort to scan the long list of options under the Options dialog, and it was worth it!

Building a Color Editor using COR

2008-10-28T21:33:00.001-04:00

Check out the AJAX Color Editor control for a control that displays a color picker. This project includes source code that shows how to incorporate the Web Control in an ASP.NET page. The Color Picker is based on AJAX technology that provides partial rendering for the control, giving it the feel of a fat client.

Table 1 displays the Color Picker. The control displays 2 color palettes – one for the back color and the second for the fore color. The sample text to color shows the selected back and fore colors.

The Color Picker uses:

The COR project provides a set of public static methods for adding Controls.
AJAX technology provides partial rendering for the control, giving it the feel of a fat client

COR Project

The Color Picker is a Web Control. It is created programmatically using public static methods from the 'C' class in COR.

FAQs for COR - A Web Site Building Tool

2008-10-19T18:27:00.001-04:00

Q: What is COR?
A: COR is software that helps power users to become Web gurus by letting them build and maintain Web Sites. Users, with only browser, can log on to the Web Site to modify or create pages. Pages employ templates that support the placement and editing of web parts by the user (shown below – notice the 'Edit' and 'Delete" controls).

Q: How is COR different from web pages built using Microsoft ASP.net?
A: COR is a small layer of management software that is built directly on top of ASP.net 2.0. It takes full advantage of ASP.net Web Parts to implement its functionality. You get the full power of ASP.net 2.0 without requiring a software programmer for all, but the most complicated web pages.

Q: What Web Parts come with COR?
A: COR comes with a Library of 30 Web Parts. One notable inclusion in the library is a Word Web Part. It allows users to update content using Microsoft Word. Tables, formatting, and pictures in the Word document are automatically converted to HTML by the Word Web Part.

Q: What are some of the other key features of COR?
A: COR directly supports a menu bar across the top of the page and a menu bars on either the side of the page. COR also keeps track of the user's location in the WEB site by displaying "bread crumbs".

Q: What does COR stand for?
A: COR stands for Controls On the Right. This is because when a user is editing a page the controls are displayed on the right hand side of the page. The example below shows the 'controls on right' being employed to add a web part to the header area of the page.

Q: Why did you build COR?
A: We built COR because we needed something to build our own WEB sites. We started by building our Web sites using just ASP.net pages and eventually evolved to COR. We also use COR to build Jetfire Workflow solutions.

Q: Why not just use SharePoint?
A: Microsoft SharePoint is a wonderful product. Many of the features of COR look very similar to SharePoint. COR; however is a much lighter product that is focused on building Web sites.

Q: How much does COR cost?
A: COR is free. The source code is available and does not have any restrictive licensing requirements (BSD license). See COR-Why make it free? and Open Source License Favorites for more details.

Q: How can I extend COR or add a new WEB Part?
A: COR is well documented and uses standard Microsoft programming patterns. An experienced programmer should have no trouble extending COR or adding a Web Part. Naturally, we can be contracted to add new features or build new Web Parts (contact us).

Q: Where can I download COR?
A: www.codeplex.com/cor

Q: What is the difference between DotNetNuke and COR?
A: DotNetNuke employs Web controls and is based on .Net 1.1. Pages in DotNetNuke are built by programmers. COR uses Web Parts and is based on .net 2.0. Pages in COR are built by privileged user(s).

Q: What is required get a Web site running using COR?
A: COR can use, as the server, any Windows or Vista PC that supports Internet Information Services and Forms authentication. Many ISPs support this configuration. The ISP we use is LFC Hosting.

Q: Are there some examples of sites that use COR?
A: yes.

Jetfire
Ontario Amateur Wrestling Association
National Capital Wrestling Club
Ottawa Wrestling Festival
Canada Cup
Arbutus Associates

Displaying Line Numbers in Visual Studio

2008-10-12T13:16:00.001-04:00

You would think that the display of line numbers should just be automatic when using Visual Studio 2005 or 2008. After all when using a C# compiler all the errors are given by a line number. Also when exceptions occur the stack traces gives the line numbers of the stack (procedure calls) and the line number of the offending code that caused the exception. Unfortunately, by default the line numbers are not visible when viewing the code in Visual Studio. In fact many programmers work for months and even years before finding this important setting.

To display line numbering in Visual Studio 2005 or Visual Studio 2008 click the following sequence.

Tools/Options/Text Editor/C#/General and select "Display/Line Numbers".

Visual Studio C# text editor with line numbers off (default). Note no line numbers.

Select the Tools from the main menu bar, then Options.

Select Display/Numbers so that line numbers are displayed.

Visual Studio C# text editor with line numbers turned on. Note the line numbers on left.

Also See Related Postings
Using Regions
C#: Top 10 Coding Guidelines

Adding ASP.NET Controls programmatically

2008-09-28T14:21:00.001-04:00

If you design ASP.NET Web Controls or Composite Controls, you have designed controls programmatically. This approach is not as easy as using the Visual Designer in Visual Studio. This post explores the use of the "C class", which is part of the COR download. The "C class" is a set of public static methods for adding Controls, managing strings, XML files and more.

Personally, once I started designing Web Parts, I did not want to go back to designing controls using the Visual Designer. I actually find it easier to place controls on the page and use logic to decide what controls are being placed on the page. However, designing Web Parts with standard Web Controls leads to much code. The "C class" allows design of controls with minimum code.

// Let's review how a Label is added to a control:

Label label = new Label();

Label.ID = "ThisLabel";

label.Text = "The name to display";

label.Width = Unit.Pixel(200);

label.CssClass = "AFormatOption";

this.Controls.Add(label);

It takes five statements just to add a simple label. For complex GUI's, it is easy to get lost in the number of lines required. I started thinking: "Why not have a simple method that adds the Label with a number of parameters?". E.g. Let's review what such a method would look like.

// Using a method that does the work of assigning the values to the named properties

Label label = AddLabelMethod("ThisLabel", "The name to display", "AFormatOption", Unit.Pixel(200), this);

The AddLabelMethod takes five parameters: ID, Text, CssClass, Width and an object that the label control is added to. The AddLabelMethod returns the new label object, which typically is not required because all the work is done in the AddLabelMethod.

The C class in COR is a set of helper methods that simplify the addition of Web Controls. To add a label,

// Using the AddLabel method is the C class simplifies programmatic design.

Label label = C.AddLabel ("ThisLabel", "The name to display", "", "AFormatOption", Unit.Pixel(200), this);

Note: ToolTip is added to the list of parameters. It is shown as a blank string in the example.

The C class, over 2000 lines of code at last count, contains a number of useful methods, including:

AddTable, NewTableRow, NewTableCell
AddLabel, AddTextBox, AddLinkLabel, and a lot more
AddHiddenField and other methods to get and set the value of the hidden field
Xml file management, e.g. GetAttribute, ReadXmlFile
AddUpdatePanel, AddUpdateProgress, AddTimer (recent additions)
... and more

I find using tables to place controls on the page is now simple. E.g

// Add a table to this control

Table table = C.AddTable("table", Unit.Percentage(100), this);

// Add the first Row

TableRow row = C.NewTableRow(table);

// Add the first cell to the Row – it has text and a tooltip and is 100 pixels wide.

C.NewTableCell(row, Unit.Pixel(100), "a name to display", "a tooltip for the cell", "CellFormat");

// Add a second cell to the Row.

TableCell cell = C.NewTableCell(row);

// Add a text box to the second cell

C.AddTextBox("tb2", "", "Enter the name of something", "TextBoxFormat", Unit.Pixel(200), cell);

Using ASP.NET controls, this five-line sample would have taken about 20 lines of code. This approach has clear advantages:

Reduced footprint – The number of lines makes it easier to understand what is being done.
It is easier to add Comments that relate to what is being done.
The C class methods prompt the user for the typically used parameters. It is now easy to identify if any of the typical parameters have been forgotten.

The "C class" is available in the COR download found on Code Plex.

Related posts include: ASP.NET Life Cycle.

The Life Cycle of ASP.NET Controls

2008-09-28T09:17:00.001-04:00

Designing ASP.NET websites is easier if you understand the Life Cycle of the ASP.NET controls. Let's review the ASP.NET controls (Refer to table 1). These include:

Page (Master Page)
User Control
Web Control
Html Control
Composite Control
Web Part

From an object model perspective, the Life Cycle methods are derived from Control, Web Control and Composite Control.

The table presents ASP.NET controls mapped against Life Cycle methods. This is what I think of as the 'get started' Life Cycle for controls. There are more Life Cycle methods, e.g. Pre-Init, if you want to manage Master Pages and Themes for a page. Here are some observations:

You don't need to use all of the states when writing a control
You are best served if you match functionality to the correct Life Cycle method
- Your control will behave properly in all use cases.
- Subtle bugs can occur because you have placed functionality in a non-optimal Life Cycle method

Life Cycle Method	Member of	Page, User Control	Web Control	Composite Control, Web Part	Html Control
Inherits from ->	X	Control – Template Control	Control	Control – Web Control	Control
Init	Control	1	1	1	1
Load Control State	Control	2	2	3	2
Load View State	Web Control	3	3	4
Load	Control	4	4	5	3
Create Child Controls	(Composite) Control			2 or 6 (See Note 1)
Post back Event Handling	Web Control	5	5	7	5
Pre Render	Control	6	6	8	6
Save Control State	Control	7	7	9	7
Save View State	Web Control	8	8	10
Render	Web Control	9	9	11
Dispose	Control	10	10	12	8
Unload	Control	11	11	13	9

Table 1: Life Cycles of various ASP.NET Controls

Controls and the Life Cycle

Html Controls are simple controls that inherit from Control. As such, valid Life Cycle methods include:

Init
Load Control State
Load
Post back event handling
Pre Render
Save Control State
Dispose
Unload

Page, User Control and Web Control includes the methods above, plus:

Load View State
Save View State
Render

The Composite Control and Web Part include the base methods from above, plus:

Create Child Controls

Composite Controls

Being a Web Part designer means that I use Composite Controls. Composite Controls are different in that they have a Life Cycle method called 'CreateChildControls'. (This is probably because of the history of Web Parts and SharePoint.) Here are a couple of notes from MSDN documentation on Composite Controls.

The CompositeControl class is new in ASP.NET 2.0. If you created custom controls in ASP.NET version 1.0 or 1.1, you had to implement the INamingContainer interface to create a new naming scope for child controls. In addition, you had to override the Controls property and invoke the EnsureChildControls method. In ASP.NET 2.0, these and other steps are performed by the CompositeControl class.

You should create the child controls in the CreateChildControls method and not in OnInit or another life cycle phase. The server control architecture relies on calls to CreateChildControls whenever the Controls collection is needed, such as during data binding (if applicable).

Note 1: When the Composite Control is displayed normally, 'CreateChildControls' is called AFTER the 'Load' method. However, when a post back event occurs, 'CreateChildControls' is called AFTER the 'Init' method. This certainly makes the 'CreateChildControls' method an "interesting" aspect of the Life Cycle.

References

http://blogs.thesitedoctor.co.uk/tim/2006/06/30/Complete+Lifecycle+Of+An+ASPNet+Page+And+Controls.aspx – this shows a trace of the Life Cycles of MasterPage, Page, and various Controls.
http://msdn.microsoft.com/en-us/library/ms178472.aspx - this describes the Page Life Cycle.

Quiz made easy

2008-07-26T15:41:00.001-04:00

I just finished integrating the Jetfire Quiz into the system. The quiz that I wrote using the Jetfire scripting language was quite simple:

What is your name? __________
Are you over 18? (yes/no)
Select an age category: 18 to 25, 26-35, 36 – 45, over 45
How often do you go dancing in a year? ___

From a code perspective, the Quiz is a set of Questions and Answers. Answers may be text, numeric, yes/no, a selection from a list, date and time, and duration.

A new Web Control is provided (in the website) to iterate over the list of Questions and Answers, providing the user with the ability to input answers. The quiz can be viewed using this custom control.

The real reason for this blog is to brag about just how simple it is to write your own Quiz. My friend, Mo, wrote a quiz in 30 minutes this morning. Mo owns a Print shop in Ottawa, has a Computer Science degree from over 20 years ago and hasn't programmed in a whole lot of years. Mo is a smart guy, but not a programmer. He needed a little bit of help with syntax, but since he uses Excel extensively, he was a natural to write his first Jetfire workflow.

Since I hit him cold with "you are designing a quiz right now", most of the time was spent formulating the questions and answers about the travel quiz that he wanted to write. His travel quiz includes the following questions:

What was your favorite destination? ________
Select your Sex: Male, Female
Select a destination: North America, Europe
Select an age category: Under 18, 18 – 35, 36- 50, over 50
How often do you travel in a year? ____

Less than five minutes later, I had the privilege of being the first to fill in his quiz.

Sound like fiction? With Jetfire, you upload the Jetfire code and start using it immediately. This is possible because Jetfire is a scripting language and re-uses the Question and Answer Web Control described above.

Kudos to screwturn wiki

2008-07-04T10:44:00.001-04:00

This blog sends kudos to screwturn.eu, the creators of a .NET open source wiki implementation.

TrackerRealm has been looking for a wiki for the past year that we can use for documentation. After assessing over half a dozen versions of incomplete projects, I was getting extremely frustrated. Then while looking for a new Blog engine one day, I noticed that the Blog engine company was using screwturn for their documentation – I went whoa! – this looks like a great wiki – I wonder how much it costs. Well, the price is right.

Why do I like screwturn wiki?

Ease of installation – it was installed on my PC in 10 minutes. (ScrewTurn store the page data in xml files vs a database)
Ease of skinning – I created a new theme for http://wiki.jetfire.ca in 30 minutes. (I am not a themes expert)
Ease of administration – putting the admin password in the web.config makes it easy to change. Adding new accounts is trivial.
New pages easily created
Ease in tailoring the templates, e.g. header, footer, side panels, etc

Easy sums up what I think about our new screwturn wiki.

New Blog Editor

2008-07-03T16:17:00.001-04:00

I am writing this blog on my brand new blog editor – it's called Word 2007. I love Word. Word allows a user to post a blog to Blogger directly from Word 2007.

Word is simple - it lets me use an editor that I am familiar with and format my blog that way that I am comfortable with. And it has a spell checker.

How does it work?

Open Word 2007
Select New from the Office icon
Select 'Create new blog'
Enter Login information for Blogger
(optional) identify an image provider for uploading images (that you embed in Word)
Write Blogs in your favorite editor
Save a draft copy of your blog to polish off later or Publish the draft to your blogger
Once the Blog is finished, Publish the blog.

One gotcha is that once you publish the blog and close the Word Editor, you must use Blogger's editor, UNLESS you save a copy of the blog locally and then re-edit it.

That's it – enjoy.

ADO.Net: The Good, The Bad and The Ugly

2008-06-25T18:05:00.001-04:00

First I need to state that ADO.Net is a very good component. It does an excellent job of what it was designed to do. ADO.Net provides an object based representation of a database.

Some the excellent features ADO.Net are:

DataTables: Provide a memory representation of a database table (or combination of tables). This allows software to directly read and write to the database data. The ADO automatically takes care of concurrency issues.
DataSets: Provide a memory representation of a number of data table and the relationships between the tables. With DataSets the database schema can be represented in an object format.
XML tools: Provides ability to both input and output XML representations of data to and from data sets and data tables.
Serialization: Data sets can be serialized allowing database data to be available via a web service or remote service. This allows for rich clients to have direct access to the database.

There is an issue with ADO.Net and Data Sets (summarized in this discussion on wikipedia), but that is not bad part.

The bad part is that ADO.Net falls short of the requirements to properly support Object-Oriented design (OOD). While doing an excellent job of providing an object oriented view of a SQL database, a SQL database itself is not very object oriented. That is ADO.Net provides objects that map one to one to the features of database. In the absence of any other components what typically happens is that ADO.Net is used directly with application code. Even with careful planning it can still result in these bad design practices:

OOD tenant of encapsulation is violated. What occurs when ADO is used is that many of the SQL database issues are not encapsulated, but brought into the application code.
Complex objects and especially object composition are not used. Databases only support the storage of built-in types. The result is that the application objects that deal with the database data tend not to use software structures such as queues, FIFOs, collections, and references (object composition). Instead application objects use the built-in types almost exclusively and use the database foreign key structures directly, instead of references. In fact the code is likely not to be object oriented at all.
There is significant code that needs to be created that is dedicated to ADO configuration, setting up data tables/data sets, reading and writing to database, etc. This isn't bad code; the bad part is that it needs to be written, tested, deployed and maintained.

This results in really ugly application code. This ugly code has a number of nasty features:

Software and the database must be changed at same time. Typically changing the database schema requires changing the application software. Adding new features requires not only adding the new objects, but insuring the database is also changed.
The issue of versioning the database schema and software needs to be accommodated. For example when new features require database changes there needs to be a deployment process where the existing databases are upgraded. Alternately the software needs to handle both the old and new database schema.
The application code becomes larger than it needs to be in order to handle that lack of true objects in a database. Bugs become harder to fix. New features become more difficult to add. The code just becomes harder to understand because of its size, lack of encapsulation and use of structured programming
instead of object programmer techniques.

This begs the question, how should you employ OOD and still use a database? One answer is to use an object-relational mapping technique such as is provided by Hibernate or product such as DB4O that makes a standard SQL database look like an object oriented database. These are good, but have their draw backs. Fortunately there will shortly be solution from Microsoft that extends ADO.Net called ADO.Net Entity Framework. It may not solve all the "ugly code" issues and will certainly have some drawbacks, but is very promising. We are excited by it.

The ADO.Net Entity Framework is a very attractive solution since it is not only provides an object-relational mapping service, but will provide Query support using LINQ as well as integrating tightly with Visual Studio. This is great, but in my opinion the biggest advantage of the Entity Framework is that it allows new, and even ongoing, software projects to use OOD while using existing databases, existing database tools and practices. In other words the substantial investment in databases can be protected, while building OOD software to exploit it.

Open Source License Favorites

2008-06-20T11:54:00.001-04:00

There are lots of open source licenses in existence. Some are general purpose and some are very specific. Our favorites are BSD and GNU GPL. Many of the other open source licenses are variations of these 2 classics.

BSD is the most permissive of the 'open source' licenses. When software has a BSD license it is practically in the public domain. The only real requirement of the license is a citation provision where if BSD software is incorporated into another product, its usage must be acknowledged. Other than that provision BSD licensed code can be incorporated into other products with no restrictions. As software developers we have no qualms about using BSD licensed code.

GNU license is a little more restrictive. If you use a GNU GPL application, for example to build a web site, it is free. It is free even if you make money from the Web site. If, on the other hand, you incorporate GNU GPL code in your product you must make your product GNU GPL licensed as well. For products that are developed for profit this is a very restrictive requirement. This is why most GNU software is also available with a commercial license allowing incorporation into proprietary products. Jetfire is available with a GNU General Public License as well as a commercial license. Here is an excellent article on GNU vs commercial license.

For us when we ship a product with a BSD license we want it used everywhere. One of our goals is to get consulting revenue from customers who want special features. Another goal is to release other products that rely on it. For example Jetfire WebParts operate on top of our BSD licensed COR product. Our primary goal; however is to get attention from delivery of a valuable, quality free software product. In we effect advertising our capabilities.

When we license a product with GNU our strategy is to get is used everywhere as well, but with the twist that if it is used commercially we are also looking for revenue. We are willing to sacrifice some usage that a more permissive license would afford in return for getting revenue. Many non-commercial applications will pay for the commercial license simply to get enhanced support.

COR - Why make it free?

2008-06-19T16:22:00.000-04:00

COR, which stands for 'Controls On the Right', provides the foundation block allowing mere mortals to build and maintain web sites. That is the goal behind our new BSD licensed project.

Briefly, COR is a project available on CodePlex that allows anyone to become a guru at designing and building web sites. You probably need an expert to set it up, but once set up 'mere mortals' can develop pages and update content. It also helps if you have a graphic artist to help with the color schemes and provide some banner graphics.

We built COR because we were tired of building our site. We didn't have a lot money to hire someone build and maintain our site, so we needed to do it. We quickly became tired of constantly hand coding HTML and patching pages together from a half dozen tools. After re-building the same page a number times by hand we decided we were going to automate. Our goal for COR was that only a Web browser was required to build or change Web pages. The running joke was "After all, how hard can it be?". Well as it turns out it is always harder (and takes longer) than you think, but using ASP.Net 2.0 it was manageable. In fact using a lot of tools in .Net bag, such as the Forms Authentication, made the entire effort viable.

We really liked the modular Web Part concept and the way SharePoint allows users to create Web pages. We would have used SharePoint, but our ISP, as is the case with most ISPs, didn't support SharePoint. So both Web Parts and SharePoint style web page editing is a key feature of COR.

We use COR internally because we are also mere mortals. Our websites http://www.trackerrealm.com/ and http://www.jetfire.ca/ are built with it. We also have numerous other websites using it. We like it. We like it so much that we think it should be everywhere. We'd like to get paid for COR, but that is just not going to happen. So we decided to go for fame and glory. What better way to do that then to make it freely available, with source code, and a very permissive license.

Finally COR is a foundation block for our Jetfire Web offerings. Check out Cor on Codeplex.

Hello World with Jetfire

2008-06-12T14:57:00.000-04:00

It has become a tradition the first program to introduce a user to a programming language is "Hello World". We thought it would be appropriate to have a "Hello World" program for Jetfire (download site) as well; however we were concerned that it didn't really show how Jetfire is different from everything else. Well that is the point. Jetfire it is not different when it comes to writting code to solve a problem, but it is radically different, in that it is a whole lot simpler, when you try to solve real world problems with Jetfire.

Well what do we mean by a lot simpler. Well lets look at "Hello World".

namespace test
{
   workflow HelloWorld
   {
      DateTime creationTime = DateTime.Now;
      public string Hello
      {
           get{return "This workflow was created at:" + creationTime.ToString();}
      }
   }
}

On the surface it looks almost like C#. The only significant difference is that 'class' has been replaced by 'workflow'. Other than that it is valid C# code.

So what is the difference? Why bother with Jetfire? Well the big difference is that Jetfire really starts where C# ends. For example, once a Jetfire instance of the HelloWorld object is created it is persistent until it is deleted. That is why there is a time stamp in this example so you could see when each instance was created. Try it for yourself.

In C# to make an object persistent you need to write code to save it to database or a file. Yes, you can serialize the object; however then serialization breaks if you change the code, and so on. With Jetfire there is nothing more to do. The objects and code are persitent. When the code changes a new version is automatically created.

This is part of goal of having the programmer focus on the problem, not the programming infrastructure. Hopefully the "HelloWorld" example gives some introductory insight to the features of Jetfire.

Auto-Display for Workflows

2007-09-28T21:51:00.001-04:00

In talking with customers about the workflow creation process, one customer got quite excited about how quick and easy it is to create a workflow. Suddenly, the customer asked, "If I can create a workflow this fast, I want to create a lot of workflows. Can I display the workflow using some existing GUI without having to design a custom GUI?".

Custom GUI's take time to create. The objective of Jetfire is to simplify the workflow creation/modification process so that Power Users can build workflows and upgrade them. But what good is a simple workflow creation process if there is no GUI to use it?

This is a common problem with workflow systems. I have not seen a workflow system that provides a user GUI that adapts to new workflows. However, with the experience from Tracker, we decided that a general GUI is best addressed by a data-driven system.

Using Web Parts, we created a set of Web Parts that provide a general purpose workflow display for Jetfire. (see http://Jetfire.ca/pages/JetfireWebParts.aspx for more informaiton.)

Silverlight 1.0 Released

2007-09-28T21:24:00.000-04:00

Sep 19, 2007
Jason Beres from Infragistics in Boston, Mass was the guest speaker at Ottawa dot net community Events speaking about Silverlight. Silverlight was just released on Sep 5.

We have been testing CTP's for WPF/E, now called Silverlight, since 0.8 release. There have been some subtle changes in the interface definitions. In upgrading our Silverlight projects from 0.9 to 1.0 (see http://www.trackerrealm.com/blogs/WPFEControls/images.htm), we noticed the following changes:

Javascript is no longer a part of the Xaml file. Events have moved from the Xaml file to a "code behind"Microsoft Javascript file using an AddEventListener method.
I refer to it as a Microsoft Javascript file, because it does not conform to the standard JS file format. Rather, Microsoft have created a Javascript object model.
A number of Xaml Control properties are gone. (not deprecated, but gone)

Meanwhile, back to Jason - fantastic presenter and presentation. Jason discussed Silverlight 1.0 and 1.1. He juggled back and forth between the formal release and the CTP highlighting differences. Key points:

Silverlight is Microsoft's competitor to Adobe Flash. (great graphics and animation.)
Silverlight is a cross-browser plug-in.
Silverlight is Xaml-based.
Silverlight is a stand-alone product, ie. not dependent on .net. (Microsoft are integrating base classes from .net)
Silverlight 1.0 release is 4.6 MB. (expect Silverlight 1.1 release to be about 7 MB)
Silverlight language for the code behind file in 1.0 is Javascript
Silverlight language for the code behind file in 1.1 is C# and VB.net

Jetfire is born

2007-09-26T18:03:00.000-04:00

Blogging has taken a back seat over the past few months while we have been working on Jetfire - a new approach to designing workflows. Well, Jetfire has arrived and blogs should start coming.

Jetfire debut at Ottawa Demo Camp

2007-09-26T17:09:00.000-04:00

Monday, Sep 24, 2007
John and Charlie present Jetfire Workflows to an Ottawa developer audience. (See FAQ at http://Jetfire.ca/pages/JetfireFAQ.aspx for more info.)

The demo showed a DVD Tracking application. DVD's are added to Jetfire and tracked by Home, On Loan, Lost and Dead states. Commands, e.g. Lost, Found, Died) and Properties (On Loan To, Loan Timestamp, Returned Timestamp, and Lost Timestamp) are displayed on a general Web Demo available to ALL Jetfire workflows.

The Jetfire code, written in a C#,Java-like language was developed by John and Charlie at TrackerRealm. The language is workflow specific and makes it quick and easy to write workflows.

Demo key figures include:

Multi-language strings (see English and Swedish-Chef instructions)
Command Method and Property filtering by state (only see what you need to see)
Change state (uses keyword: 'enterstate')
Enter 'On Loan To' name causes state change, On Loan To Timestamp to be automatically updated

Bottom line: Comments like "Is that all the code there is?" tells me that we are on the right track.

Test Drive Jetfire yourself at http://jetfire.ca/Pages/JetfireDownload.aspx

The DVD workflow (100 lines of code) is shown at http://jetfire.ca/Code/Apps/DVDInventory.txt.

Using Code Creator to Create SilverLight Controls (WPF/E)

2007-05-01T10:44:00.000-04:00

SilverLight is small, efficient and has the promise of making great Web experiences for the browser user. To fufill this promise SilverLight code (Xml) must be created dynamically. This can be done via JavaScript in the client browser or at the server. We believe using CodeCreator at the server is a much simpler, faster and more maintainable approach.

Below is an example of a SilverLight control with CodeCreator constructs. This can be used to dynamically create a control demonstrated in this link.

<!--<cc:Repeat/>-->
  <Canvas >   
    <Rectangle x:Name="button0"
               Width="120"
               Height="75"
               Canvas.Left="0"
               Canvas.Top="0"
               Stretch="Fill"
               MouseEnter="javascript:ImageButtonEnter"
               MouseLeave="javascript:ImageButtonLeave"
               MouseLeftButtonDown='javascript:ImageButtonDown0'
               >
      <!--<cc:Replace Attribute="Canvas.Top">$Top$</cc:Replace>
      <cc:Replace Attribute="x:Name">button$Counter$</cc:Replace>
      <cc:Replace Attribute="MouseLeftButtonDown">
javascript:ImageButtonDown$Counter$</cc:Replace>-->
      <Rectangle.Fill>
        <ImageBrush ImageSource="images/JetSki.jpg" ></ImageBrush>
        <!--<cc:Replace Attribute="ImageSource">$Images$
        </cc:Replace>-->
      </Rectangle.Fill>
    </Rectangle>
  </Canvas>
  <!--<cc:Evaluate>Top = Top + 30;</cc:Evaluate>-->
  <!--<cc:Evaluate>Counter = Counter + 1;</cc:Evaluate>-->  
<!--<cc:RepeatEnd/>-->

CodeCreator will create the following code.
<Canvas>
<Rectangle x:Name="button0"
Width="120"
Height="75"
Canvas.Left="0"
Canvas.Top="0"
Stretch="Fill"
MouseEnter="javascript:ImageButtonEnter"
MouseLeave="javascript:ImageButtonLeave"
MouseLeftButtonDown="javascript:ImageButtonDown0"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Rectangle.Fill>
<ImageBrush ImageSource="images/cf18.jpg"></ImageBrush>
</Rectangle.Fill>
</Rectangle>
</Canvas>
<Canvas>
<Rectangle x:Name="button1"
Width="120"
Height="75"
Canvas.Left="0"
Canvas.Top="30"
Stretch="Fill"
MouseEnter="javascript:ImageButtonEnter"
MouseLeave="javascript:ImageButtonLeave"
MouseLeftButtonDown="javascript:ImageButtonDown1"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Rectangle.Fill>
<ImageBrush ImageSource="images/jetski.jpg"></ImageBrush>
</Rectangle.Fill>
</Rectangle>
</Canvas>
<Canvas>
<Rectangle x:Name="button2"
Width="120"
Height="75"
Canvas.Left="0"
Canvas.Top="60"
Stretch="Fill"
MouseEnter="javascript:ImageButtonEnter"
MouseLeave="javascript:ImageButtonLeave"
MouseLeftButtonDown="javascript:ImageButtonDown2"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Rectangle.Fill>
<ImageBrush ImageSource="images/soundbarrier.jpg"></ImageBrush>
</Rectangle.Fill>
</Rectangle>
</Canvas>

The JavaScript code will also need to be created using simalar techniques. See the CodeCreator Blog posting for more information.

Demonstrated at Ottawa Demo Camp

Code Creator - a C# based mini PHP

2007-04-28T09:28:00.000-04:00

Creating code dyanamically is a very strong requirement for any advanced programming tasks. Code Creator source will be available in the near future. The software and data files presented at Demo Camp on Apr 30th can be found here. A PowerPoint presentation that is also available.

Also see Creating as SilverLight Control with CodeCreator for an example on using CodeCreator.

Code Creator supports the creation of almost any type of code including XML.
Code Creator competes very well with PHP in the .net environment simply because it leverages .net's power. Above all Code Creator is small and simple.

An example of CodeCreator creating C# code segment.

// In a real system "nameUC" and "name" would get data
// from a database or XML data file.
// "nameUC" and "name" are 
// passed as parameters to Code Generator.
//
string[] nameUC = new string[]{"NAME", "SYSTEM", "ADMINISTRATOR"};
string[] name = new string[] {"Name", "System", "Administrator"};
...
// The next few lines of code are passed to Code Generator
// as a string.
//
//<Repeat>  -- note that Code Creator commands are
// hidden in comments.
public const string NAME = "name"; 
//<Replace>public const string $nameUC$ = "$name$";</Replace>
//</Repeat>

Will result in code be generated below:

public const string NAME = "Name";
public const string SYSTEM = "System";
public const string ADMINISTRATOR = "Administrator";

CodeCreator Uses
-Create typed classes from a database schema
---example C# classes where enumerations, string constants and properties are created dynamically
-Build powerful HTML controls easily
---example create JavaScript and HTML code dynamically from CLR objects
-Build WPE/E (SilverLight) controls

Code Creator details:
- less than 1000 lines of C# code
- few basic functions – Replace, Repeat, Declare, Evaluate
- Accepts data from XML or CLR objects (very much like WPF).
- Built primarily on
--> “StringBuilder” class.
--> Tiny Interpreter class.

Tiny Interpreter (C#)
- Implementation of “Gang of 4” interpreter class
- Uses 80 line method employing REGEX to tokenize string
- Less 1000 lines of code
- Evaluates mathematical and logical expressions
- Example:

<Evaluate>XCoord = XCoord + (30 * Height);</Evaluate>

Demonstrated at Ottawa Demo Camp

Top 10 Coding Guidelines for C#

2007-04-11T10:06:00.000-04:00

Here is a set of coding guidelines that we use to generate code. Using these guidelines we strive to build software that improves the 'able' criteria such as maintainable, readable, reliable, expandable, reusable, etc. The measurement of these criteria is somewhat subjective.

It should be noted that the biggest factors that impact the 'able' criteria are made by selecting C#, .net and Visual Studio development environment. The guidelines merely refine the results.

Here is out top 10 .net C# coding guidelines.

Use Object Oriented (00) principles.

Use unit tests.

Avoid global (or static) properties or variables.

Make extensive use of core .net classes such as Collection and Regular Expressions

Use strong typing and avoid the use of the "object" type.

Use Auto-Generated Code

Use a naming convention.

Use Static Methods and Constants

Use the "this" keyword.

Use Regions to place code in Chapters and Sections.

Make Use of #regions When Developing C# .net Code - Coding Guidlines Series

2007-04-10T17:26:00.000-04:00

The is part of a .net Coding Guidelines series of blog postings.

Making code readable is an important consideration when developing and maintaining code. The single best way to make code more organized, thus more readable, is to use "region" compiler directive. Regions effectively group your code into sections and chapters.

	This is a simple example of code without the region directive. The code is all there but even with just a few lines it can be difficult to read because nothing stands out. This only gets worse when the class is hundreds or thousands lines long.
	Here is the same code with regions. It just looks a lot cleaner.
	Now when you have found the selection that you want it is simply a matter of double clicking the region tag to see the details. (example to be added)Even code with regions can get out hand when there are a large number of regions. Then it is time to group the regions into regions.

other tips:
Tips to prevent memory leaks.
Built-in Delegate Types - Methods as Objects

Tokenize a String with C# Regular Expressions

2007-04-09T10:51:00.000-04:00

Using C# and .net regular expressions it easy to parse even the most complex string into tokens very easily.
For example convert the following string:

"365 + 6 *(6.3 + Count)"

into something like this:

Token[0], Integer, "365"
Token[1], Plus, "+"
Token[2], Integer, "6"
Token[3], Mulitply, "*"
Token[4], OpenBracket, "("
Token[5], Double, "6.3"
Token[6], Plus, "+"
Token[7], Variable, "Count"
Token[8], CloseBracket, ")"

With out using regular expressions it becomes quite a programming exercise. With regular expressions it becomes quite simple. The regular expression technique even supports simple syntax checking for invalid characters or character sequences.

Here are the steps.
1. Define a Token helper class.

public class Token
{
   public readonly string Name;
   public readonly string Value;
   public Token(string name, string value)
   {
      Name = name;
      Value = value;
   } >
}

2. Define the regular expression pattern using named groups looking something like this.

private static string pattern =
    @"(?<whitespace>\s*)|" +
    @"(?<variable>[a-zA-Z_$][a-zA-Z0-9_$]*)|" +
    @"(?<integer>[0-9]+)|" +
    @"(?<plus>\+)|" +
    @"(?<minus>-)|" +
    @"(?<multiply>\*)|" +
    @"(?<invalid>[^\s]+)";

The regular expression explained: The round brackets"(...)" define a group that support matching a subexpression. The "?" give the group a name. The "\s" matches on a white space character, with the "\s*" subexpression matching on zero or more whitespace characters in a row.
Overall the pattern directs to both match on whitespace and on one of the following groups or subexpressions such as "variable", "integer". Notice the "" character (shift backslash on keyboard) after each group which is the logical 'or' in C#; however in regular expressions it is known as the 'alternation' character with each subexpression known as the alternative. When the first alternative match is found then matching stops.
The "invalid" group will match on character string not matched by any of the other alternative groups. This supports simple syntax check.

3. Generate the regular expression code.

    Regex regexPattern = new Regex(pattern);
    MatchCollection matches = regexPattern.Matches("365 + 6 * Count");

4. Perform a "foreach" on matches to generate the tokens.

List tokenList = new List();
foreach (Match match in matches)
{
   int i = 0;
   foreach (Group group in match.Groups)
   {
      string matchValue = group.Value;
      bool success = group.Success;
      // ignore capture index 0 and 1 (general and WhiteSpace)
      if ( success && i > 1)
      {
         string groupName = regexPattern.GroupNameFromNumber(i);
         tokenList.Add(new Token(groupName , matchValue));
      }
      i++;
   }
   
}

That is all that is to it. A very small amount of code to quickly parse a string.

Note: When using regular expressions it is very easy for a single character to change the meaning of a regular expression. Techniques such as code inspection rarely will reveal a problem. It is important with all code, but especially code using regular expressions, to build a good set of unit tests that exercise most, if not all, of the combinations.

Selecting Editable Items in an .net WPF ListBox (or ComboBox)

2007-03-29T13:31:00.000-04:00

What could be simpler than selecting items from a WPF ListBox. You can even make the items have fancy formating using a TextBlock. If you want to allow the user to edit the ListBox items then there is a problem. This occurs when your ListBox items are editable objects, such as a TextBox. Selecting around the TextBox selects the appropriate ListBox item, but selecting the TextBox only selects the TextBox.

The solution to this problem is when the TextBox is selected, to also select the ListBox item. To this you need to setup an event handler and write a few lines of C# code. You want use the "GotFocus" event since the TextBox may be selected by multiple methods such as tabbing with the keyboard or clicking with the mouse.

To make things simpler you can use Expression Blend to setup the event handler and create C# shell code. To do this select the TextBox properities using Expression Blend and then select the event handlers.

Here is a C# event handler for the TextBox, which is any item in ListBox for this example.

private void TextBox_GotFocus(object sender, RoutedEventArgs e)
{
    TextBox tb = sender as TextBox;
    if (tb == null) return;
    if (tb.DataContext == null) return;
    this.listBoxDataItems.SelectedItem = tb.DataContext;
}

Where the ListBox is defined as


     ItemsSource="{Binding Path=CodeCreatorData}"
     x:Name="listBoxDataItems" />

with a template like this


          GotFocus="TextBox_GotFocus"/>

What is Workflow EcoSystem?

2007-03-16T12:13:00.000-04:00

Workflows have recently gained a lot attention since Microsoft introduced a workflow engine as part of .Net release 3.0 and have workflows integrated with Office 2007 and SharePoint. Workflows as mechanism to automate applications have been around for while. We have had a Workflow engine for several years.
What is clear is that to use workflows as sucessful automation tool a complete ecosystem is required. Our view is that a complete workflow ecosystem consists of 5 key components.
5 Key Components of a Workflow Ecosystem

Workflow Designer
User Interface
Data Persistence Layer
Data Report Generator
Workflow Engine

A white paper, Attributes of a Complete Workflow Eco-System, has been put together that describes what attributes are required of each of the key components.

Using SilverLight (WPF/E) creates clear images

2007-03-16T11:52:00.000-04:00

Remember migrating from .net 2.0 from 1.1 at your ISP? Our ISP created a separate server with .net 2.0 libraries and selected clients moved their applications to that server. Of course, if the application included Web Service, Web Pages and Windows Client, ALL code had to be converted to .net 2.0 before it was deployed.

Migrating to Microsoft .net 3.0 is MUCH simpler, because the ASPX server is still a ASP.net 2.0 Server. Of course, our ISP seems to be taking a 'measured' approach. But does that stop us from playing with .net 3.0 and wanting to show our endeavors? Of course not.

Do you get annoyed when images are not clear on web pages because of rescaling? The really cool facet of .net 3.0 is Managed Code directly accessing un-managed code, namely DirectX. Use XAML - a new, mark-up language to build user interfaces with.net 3.0 libraries. Images can be displayed with amazing clarity.

Using Microsoft Expression Design, we created a simple WPF/E image control that displays thumbnails and allows the user to select an image that scales. Look at the clarity of this image. So how did this code reach the web?
1. Post code to ISP. Problem - XAML file type not recognized and hence the control did not display at all.
2. Change XAML file type to XML file type - control now displays!
3. Login to ISP technical page and chat with support staff. Ask them to add the XAML file type to the web server (use same characteristics as XML file type).
4. WPF/E control now displays in a web page from our ISP.
5. Go to 'virgin' PC (one that hasn't used .net 3.0). Open web page with WPF/E control. Because this control is a WPF/E control, the page displays a note that the WPF/E plugin needs to be downloaded. Click to download.
6. View fantastic WPF/E image selector control with great image clarity.

SharePoint and ASP.Net Web Parts Suite

2007-03-15T16:34:00.000-04:00

Our Web Parts Suite is now here. It is free and will remain free. The big news is that it works with both SharePoint and ASP.net 2.0. In fact our web site uses these web parts.

Download the suite and tells what you think. We plan on enhancing the suite both with more parts and features.

If you want the source code or would like custom web parts built, well that's not free. Somebody has to pay the bills.

WPF/E Controls (SilverLight Controls)

2007-02-27T12:29:00.000-05:00

Lately we have looking at creating a better forms environment for our work with workflows and SharePoint. XML forms look interesting, but have a number of drawbacks. Recently we have been evaluating WPF/E for use as a Forms package base.

Here are some controls that we have created as part of a science project. The code is very crude, doesn't cover all the conditions, but you get the idea of how it can be done.

Short list of WPF/E (SilverLight) example controls.
ListBox - enhanced using a card shuffle style list. Shows some of the power WPF/E. Mouse over the thumbnails on the left to view animation.
ComboBox - Hard coded number of list items.
TextBox - Javascript code for this control only covers some of the conditions. Required is the ability to cut, paste, highlight and drag. In addition the cursor positioning (which is absolute and relative to the root canvas) needs to take into the account the scaling used, which could be difficult if this control is embedded in other controls each its own scaling factor.

The above controls are stand alone. For production they would need some sort of framework to work within (there are some examples at the Microsoft blog site).

Our conclusion (see foil) is to work with WPF/XBAP sacrificing some universality for speed of implementation. In the meantime we will continue look at putting together some controls and a framework as a continuation of this science project.