Developer / Architect and not the other way around

ILMerge: Getting Started, Merging, and Alternatives (to ILMerge).

2012-01-30T11:06:00.000-05:00

What is ILMerge?
ILMerge is a Microsoft produced assembly merge utility. It merges more-than-one .NET assembly (or executables) into a single assembly.

ILMerge is a command-line utility.

Installation:
To begin you will need to install ILMerge on your machine (or the machine where you are planning on merging assemblies). You can download ILMerge directly from Microsoft in the Download center at: http://www.microsoft.com/download/en/confirmation.aspx?id=17630

The installation itself is a Microsoft Installer (MSI) file named ILMerge.msi. Click on the file, and follow the pretty typical installation path: Welcome -> License Agreement (EULA) -> Install Folder > Confirm

Note: You will want to remember the installation folder, since you will have to run ILMerge from this location (or at a minimum add this file location into the windows path). My install location was C:\Program Files (x86)\Microsoft\ILMerge

Best Practices:

Script the merge process
Incorporate the assembly merge into your build process

Examples:

Merge:
ilmerge /out:Merged.dll Primary.dll Secondary1.dll Secondary2.dll

Merge with Wildcard:
ilmerge /wildcards /out:Merged.dll Primary.dll Secondary*.dll

Merge with Log:
ilmerge /log /out:Merged.dll Primary.dll Secondary1.dll Secondary2.dll
ilmerge /log:log.txt /out:Merged.dll Primary.dll Secondary1.dll Secondary2.dll

IL Merge with .NET 4.0:
... when using ILMerge with .NET 4.0 assemblies you have to set the target platform to .NET 4.0 (command line parameter: /targetplatform:v4).

... Microsoft Research (via Mike Barnett) provides an example configuration file for using ILMerge with .NET 4.0 at: http://research.microsoft.com/en-us/people/mbarnett/ilmerge-40-exe-config.aspx

This is the example:

<?xml version ="1.0"?>
<configuration>
<startup useLegacyV2RuntimeActivationPolicy="true">
<requiredRuntime safemode="true" imageVersion="v4.0.30319" version="v4.0.30319"/>
</startup>
</configuration>

Source: http://research.microsoft.com/en-us/people/mbarnett/ilmerge-40-exe-config.aspx

Are there alternatives to ILMerge (that will accomplish the same relative goal)?

Assemblies as Resources
Jeffrey Richter on the Microsoft Press blog proposed adding assemblies as resources, and loading them via reflection. You can read more about this approach here: http://blogs.msdn.com/b/microsoft_press/archive/2010/02/03/jeffrey-richter-excerpt-2-from-clr-via-c-third-edition.aspx

Using this approach, you "hook" into the assembly resolve for the AppDomain, and then load the assemblies via reflection.

AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => {
   String resourceName = "AssemblyLoadingAndReflection." + new AssemblyName(args.Name).Name + ".dll";

   using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName)) {
      Byte[] assemblyData = new Byte[stream.Length];
      stream.Read(assemblyData, 0, assemblyData.Length);
      return Assembly.Load(assemblyData);
   }
};

Source: http://blogs.msdn.com/b/microsoft_press/archive/2010/02/03/jeffrey-richter-excerpt-2-from-clr-via-c-third-edition.aspx

This blog post (Combining multiple assemblies into a single EXE for a WPF application) contains a more comprehensive approach, and includes a way to incorporate this strategy into your build process via a AfterResolveReferences target:

<Target Name="AfterResolveReferences">
  <ItemGroup>
    <EmbeddedResource Include="@(ReferenceCopyLocalPaths)" Condition="'%(ReferenceCopyLocalPaths.Extension)' == '.dll'">
      <LogicalName>%(ReferenceCopyLocalPaths.DestinationSubDirectory)%(ReferenceCopyLocalPaths.Filename)%(ReferenceCopyLocalPaths.Extension)</LogicalName>
    </EmbeddedResource>
  </ItemGroup>
</Target>

RedGate Smart Assembly
Smart Assembly from Red Gate's description is "an obfuscator that helps protect your .NET code against reverse-engineering, cracking, and modification".

Smart Assembly also has the ability to combine multiple assemblies into a single one. They describe this feature as "Simplify the deployment of your application by packaging it in one file (Dependency Embedding with compression and encryption, and Dependency Merging)."

Notes:
... ILMerge can not merge WPF assemblies (from a couple of sources). According to Mike Barnett the reason is "[WPF assemblies] contain resources with encoded assembly identities. ILMerge is unable to deserialize the resources, modify the assembly identities, and then re-serialize them. ". See Assemblies as Resources above for an alternative.

... ILMerge cannot merge C++ assemblies containing native code

... Make sure you have accounted for assembly references before attempting to merge, or you will get an exception:

Missing Reference Assembly Screenshot

An exception occurred during merging:Unresolved assembly reference not allowed: System.Data.Entity. at System.Compiler.Ir2md.GetAssemblyRefIndex(AssemblyNode assembly) at System.Compiler.Ir2md.GetTypeRefIndex(TypeNode type) at System.Compiler.Ir2md.VisitReferencedType(TypeNode type) at System.Compiler.Ir2md.VisitClass(Class Class) at System.Compiler.Ir2md.VisitModule(Module module) at System.Compiler.Ir2md.SetupMetadataWriter(String debugSymbolsLocation) at System.Compiler.Ir2md.WritePE(Module module, String debugSymbolsLocation,BinaryWriter writer) at System.Compiler.Writer.WritePE(String location, Boolean writeDebugSymbols, Module module, Boolean delaySign, String keyFileName, String keyName) at System.Compiler.Writer.WritePE(CompilerParameters compilerParameters, Module module) at ILMerging.ILMerge.Merge() at ILMerging.ILMerge.Main(String[] args)

... A few comments says it removes XML Comments from the assembly.

Resources:
ILMerge Download - The Microsoft download center web page that provides the download link to install ILMerge. The actual installation is ILMerge.msi.
Mike Barnett ILMerge
ILMerge config file for executing within the CLR v4.0 runtime
Jeffrey Richter: Excerpt #2 from CLR via C#, Third Edition
Combining multiple assemblies into a single EXE for a WPF application
RedGate Smart Assembly
Tools & Utilities

log4Net: RollingFileAppender Class

2012-01-25T09:00:00.000-05:00

What is log4net?
Apache log4net from their website: "The Apache log4net library is a tool to help the programmer output log statements to a variety of output targets. log4net is a port of the excellent Apache log4j™ framework to the Microsoft® .NET runtime."

What is the RollingFileAppender?
RollingFileAppender exists within the log4net in the log4net.Appender namespace. According to the website it's designed to append "log files based on size or date or both.". A pretty basic description, but it does describe what this logging type does: it appends we log messages to an existing log (or creates a new one if none exists), and when it reaches the roll condition it creates a new file.

The conditions under which a roll condition are reached are configured via the RollingStyle property. You can set the log to role based upon a date, file size, or a combination of the two (known as a composite in the documentation).

Configuration for the RollingFileAppender:
Configuration for the RollingFileAppender is primarily done in an xml configuration file, or your application configuration file.

The good part of a configuration based approach is the ability to customize your logging based upon your life-cycle environment (think QA logging and production logging), or client your individual customer or client's needs.

Log4net also supports run time (or in-code) configuration as well. If your interested in this type of configuration, you can get started here: http://logging.apache.org/log4net/release/manual/configuration.html

In this example, the RollingFileAppender is configured to write the a file named log.txt, with the rolling condition of size, and specifies the maximum file size. One important thing to note is the in the example below. This will cause log4net to append a count number to the end of the log file as it creates new ones (Example: log.txt.1, log.txt.2, log.txt.3)

<appender name="RollingFileAppender" type="log4net.Appender.RollingFileAppender"></appender><br />
    <file value="log.txt"></file><br />
    <appendtofile value="true"></appendtofile><br />
    <rollingstyle value="Size"></rollingstyle><br />
    <maxsizerollbackups value="10"></maxsizerollbackups><br />
    <maximumfilesize value="100KB"></maximumfilesize><br />
    <staticlogfilename value="true"></staticlogfilename><br />
    <layout type="log4net.Layout.PatternLayout"></layout><br />
        <conversionpattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline"></conversionpattern>

This example is a little different. It's rolling is determined by the date setting. Note the datePattern used to control the format of the date for file names:

<appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
    <file value="logfile">
    <appendtofile value="true">
    <rollingstyle value="Composite">
    <datepattern value="yyyyMMdd">
    <maxsizerollbackups value="10">
    <maximumfilesize value="1MB">
    <layout type="log4net.Layout.PatternLayout">
        <conversionpattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline">
    </conversionpattern></layout>
</maximumfilesize></maxsizerollbackups></datepattern></rollingstyle></appendtofile></file></appender>

This represents a typical rolling date configuration section for log4net (thanks to dommer):

<log4net>
    <appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
        <file value="c:\Logs\Today.log"/>
        <rollingStyle value="Date"/>
        <datePattern value="yyyyMMdd"/>
        <appendToFile value="true"/>
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%level %logger %date{ISO8601} - %message%newline"/>
        </layout>
    </appender>
    <root>
        <!-- Options are "ALL", "DEBUG", "INFO", "WARN", "ERROR", "FATAL" and "OFF". -->
        <level value="ERROR"/>
        <appender-ref ref="RollingFile"/>
    </root>
</log4net>

Consider your larger logging strategy with RollingFileAppender
Every single application should generate log entries. The world is an imperfect place, and the log at a minimum should tell you about those imperfections. However, depending on your logging "enthusiasm" and logging level you are going to write messages. Even a small application can generate a tremendous amount of logging data.

RollingFileAppender can help with that by:

Naturally segmenting your data into smaller files (making a potential search later on) easier
If you use the date RollingStyle then you will have files seperated by day
RollingFileAppender can also manage the destruction of older log files with the maxSizeRollBackups. This will allow you to set the number of archive files to keep online.

If you combine these features with a strategy to potentially compress, and store files (or destroy them with maxSizeRollBackups) then you can have a self-managed and effective strategy to track messages.

Notes:
... RollingFileAppender full name is log4net.Appender.RollingFileAppender

... Build this into a larger logging and archiving strategy.

... Is log4Net's RollingFileAppender class any better than any other logging libraries rolling file appender? Just is still out.

Resources:
log4net
RollingFileAppender Class
log4net Manual Configuration
log4net Tutorial

Adding CDATA - (Unparsed) Character Data to XElement

2012-01-24T09:00:00.000-05:00

When working with the System.Linq.Xml namespace, and creating an XDocument you may need to create create document data that that should not be parsed by the XML parser. For example: data with XML reserved characters, xml content, html content (or really anything you do not want to be parsed).

Creating data within a CDATA tag is simple, simply wrap the content within the XElement in an additional object called XCData.

XDocument contactsDoc =
   new XDocument(
      new XDeclaration("1.0", "utf-8", "yes"),
      new XComment("LINQ to XML Contacts XML Example"),
      new XProcessingInstruction("MyApp", "123-44-4444"),
      new XElement("contacts",
         new XElement("contact",
            new XElement("name", "Patrick Hines"), 
            new XElement("comment", new XCData("ALERT! Do not call!")),
            new XElement("address",
               new XElement("street1", "123 Main St"),
               new XElement("city", "Mercer Island"),
               new XElement("state", "WA"),
               new XElement("postal", "68042")
            )
         )
      )
   );

Sample adapted from .NET Language-Integrated Query for XML Data

References:
CDATA
.NET Language-Integrated Query for XML Data
XCData Class

Check -> Argument -> Condition: .NET 4.0 Code Contract, CuttingEdge.Conditions, Shrinkr Check

2012-01-23T09:48:00.002-05:00

An early part of designing an effective, maintainable system is consistency. The more consistent your applications responses, the better it will be in the long term. One place that breeds inconsistency in parameter validation, and exception throwing.

So I set out to find a condition checking library capable of accomplishing a few simple goals:

Must provide a simple interface for validating conditions (object and state)
Must have a consistent response algorithm or structure
Must be written in .NET
Must be open-source

With the additional side-goals (or bonus points):

A fluent interface
Documentation or code samples
NuGet package

There are plenty of libraries and source-code examples out there that accomplish these goals:

.NET 4.0 Code Contracts - Code Contracts provide a language-agnostic way to express coding assumptions in .NET programs.. The Common Language Runtime (CLR) team is introducing a library to allow programming with contracts in the Microsoft .NET Framework 4.
Shrinkr's Check - "a Url Shortening Service which demonstrates some of the best practices in developing real life web applications." and contains a fluent checking class structure.
CuttingEdge.Conditions - CuttingEdge.Conditions is a library that helps developers to write pre- and postcondition validations in their C# 3.0 and VB.NET 9.0 code base.
GuardQ - validating function arguments.
Fluent Validation - "A small validation library for .NET that uses a fluent interface and lambda expressions for building validation rules for your business objects."
FluentValidation for .NET 2.0 - Rework of the popular FluentValidation library to work in .NET 2.0. There is one minor syntax change and the LinqBridge (lambda syntax for 2.0) library is required, so please read the docs. Namespaces and licenses are similar to FluentValidation.

Here are a few:
CuttingEdge.Conditions

CuttingEdge. Condition Validation Extensions

Conditions is an open-source project (available on CodePlex) that "CuttingEdge.Conditions is a library that helps developers to write pre- and postcondition validations". The library supports a wide-variety of conditions (including those great string based IsNotNullOrEmpty). On the right is a screenshot of the condition validation extensions if you want a quick look.

The library provides a consist way to manage condition checking, and even provides a way to pass a formatted string for the exception message:
Condition.Requires(context, "id").IsNotNull("Parameter {0} cannot be a null reference");

Another feature that this library provides is the WithExceptionOnFailure (AlternativeExceptionCondition WithExceptionOnFailure() where TException : Exception) allowing you to define the exception to be raised when the condition fails. While this is not something you would generally want to do, the added flexibility is certainly appreciated.

.NET 4.0 Code Contracts

.NET Code Contracts is part of the 4.0 version of the .NET framework. From MSDN: "Code contracts provide a way to specify preconditions, postconditions, and object invariants in your code. Preconditions are requirements that must be met when entering a method or property. Postconditions describe expectations at the time the method or property code exits. Object invariants describe the expected state for a class that is in a good state."

It seems intuitive, and easy.

The downside? It requires your application run on .NET 4.0. If your already ugpraded, this seems like a great choice. I mean, it's built into the Framework (no external dependencies ++), and generally offers a comparable offering to other open-source implementations designed to provide this functionality.

Compared side-to-side with Conditions, the syntax and code appear very similar:

Contract -> Contract.Requires(context != null, "Parameter context cannot be a null reference");
Condition-> Condition.Requires(context, "context").IsNotNull("Parameter {0} cannot be a null reference");

It's slightly more flexible in it's implementation than Condition. Most notably because Condition has a default set of validations, and exceptions, and Contract is wide open.

As an additional bonus, Code Contracts offer Legacy Requires Statements. From their description it is:

Most code already contains some parameter validation in the form of if-then-throw code. The contract tools recognize if-then-throw statements as preconditions when the statements appear first inside a method, and the entire set of such statements is followed by an explicit Contract method call, such as a Requires, Ensures, EnsuresOnThrow, or EndContractBlock.

When if-then-throw statements appear in this form, the contract tools recognize them as legacy-require statements. The EndContractBlock form is used only if no other contracts follow the if-then-throw sequences, but they should still be tagged as legacy-requires.

Shrinkr's Check.Argument
Shrinkr is "a Url Shortening Service which demonstrates some of the best practices in developing real life web applications." and contains a fluent checking class structure. It's simple, clean and provides a way to validate arguments and provide predicable exception handling.

Here's an example of the Check class. I have also seen a version of this where the Check, Argument classes are not static (from another location):

public static class Check
{
    public static class Argument
    {
        public static void IsNotNull(object parameter, 
                                     string parameterName)
        { ... }

        public static void IsNotNullOrEmpty(string parameter, 
                                            string parameterName)
        { ... }

 .... etc ....
}

This provides the basic context that Conditions provides, but is a far simpler implementation. It's also more of a larger project and really out there as a stand-alone library. However, it does meet the goals above, and would be an easy addition to any enterprise's library.

End-Notes:
... I still like Conditions the best, but only slightly. Mostly it's the little things, like formatted messages (so I can extract it to a resource) or the validations already built and ready to go.

... There are plenty of options to choose from. Pick one and start using it. Almost all of these will produce better, more consistent results than role-your-own. If your code does not validate add this and get started.

... This is an easy upgrade to your library that will produce good results in the short, middle and long term.

Resources:
Shrinkr
CuttingEdge.Conditions
CuttingEdge.Conditions (NuGet)
NuGet
Fluent Validation
.NET 4.0 Code Contracts on MSDN Magazine
DevLabs Code Contracts
Fluent Validation
FluentValidation for .NET 2.0
GuardQ

Amazon DynamoDB: First Impressions

2012-01-20T09:00:00.000-05:00

An e-mail arrived this morning from Amazon Web Services (Aws):

It was a new feature announcement from Aws.

The new product is DynamoDB... a new NoSQL database engine for Amazon Web Services (Aws)

From the e-mail, it's described as "Amazon DynamoDB, a fully managed NoSQL database service that provides fast and predictable performance with seamless scalability".

It has some interesting key points:

Data on Solid State Drives (SSDs)
Replicated data synchronously across multiple zones.
Supports two types of primary keys: Hash Type and Hash and Range Type
JSON for data transport

This new product is a NoSQL database engine built into their cloud infrastructure (similar to SimpleDB as a product, but with some notable changes and upgrades).

From CTO Werner Vogels' DynamoDB blog post he states the differences between SimpleDB and DynamoDB: "While SimpleDB has been successful and powers the applications of many customers, it has some limitations that customers have consistently asked us to address." Listing: Domain scaling limitations, Predictability of Performance, and SimpleDB's Pricing complexity.

From the documentation, it appears to be similar to their existing SimpleDB offering, but is designed for large scale needs (and predictable) performance. Most notably no limits or restrictions on database size, and automatic management of scalability across multiple servers.

What is NoSQL?
According to Wikipedia's NoSQL article:

In computing, NoSQL (sometimes expanded to "not only SQL") is a broad class of database management systems that differ from the classic model of the relational database management system (RDBMS) in some significant ways, most important being they do not use SQL as their query language.

DynamoDB Storage Model (1000 ft view)
From their documentation, each object (or item) is stored within a table, with the individual values within the item stored as attributes:

From Amazon DynamoDB (beta)

Getting Started
In order to get started with DynamoDB, you have to make sure you have a couple of things:

Amazon Web Services developer account
Your AWS account has to be set up to use Amazon DynamoDB
Your AWS Access and Secret Key (in order to run the examples, or start your development project)

DynamoDB and .NET
The AWS SDK for .NET has been updated to contain samples for using DynamoDB with the .NET framework (fair warning if you have a previous version of the SDK you may have to remove it to install this one).

The SDK contains (basically) 4 samples:

Data Model Sample - creation of a context, persistence of items using the context, and some queries against the context.
Data Model Schema - Samples of objects that can be stored within DynamoDB. Specific would be the use attributes: DynamoDBTable that "Specifies that this object can be stored in DynamoDB". DynamoDBHashKey, DynamoDBProperty, and DynamoDBRangeKey to name a few.
Document Model Sample - Demonstrates the document model. Shows creation of a table, and adding documents to a table, persistence, and querying from the model.
Table Operations - Basic table operations: Contains, CreateTable, table status, table deletes.

These samples are available for VS 2008 and VS 2010. With my installation, the samples were located at C:\Program Files (x86)\AWS SDK for .NET\Samples\AmazonDynamoDB_Sample.

Pricing (as of 1/19/2012)
Notes About Amazon DynamoDB states it pretty well "pricing is based on actual write/read operations and not API calls (e.g. a query returning 100 results accounts for 100 ops and not 1 op)".

You pay a flat, hourly rate based on the capacity you reserve:

Throughput Capacity

Write Throughput: $0.01 per hour for every 10 units of Write Capacity

Read Throughput: $0.01 per hour for every 50 units of Read Capacity

The listed pricing (as of 1/19/2012) offers a free-pricing tier as well:

Free Tier*
As part of AWS’s Free Usage Tier, AWS customers can get started with Amazon DynamoDB for free. DynamoDB customers get 100 MB of free storage, as well 5 writes/second and 10 reads/second of ongoing throughput capacity.

Final Thoughts:
... What's missing: From CTO Werner Vogels' DynamoDB blog post one comment from Faraz points out one of the key components missing from DynamoDB's initial offering: "missing critical database pillar of snapshot backup and fast recovery system". Vogel's response: "we have a philosophy of launching with a minimal feature set and then quickly iterating while prioritizing based on customer feedback. Backup/Restore for DynamoDB will have high priority". While true, I'm still waiting for micro in VPC!

... "pure local emulation is not available". However, there is an open-source project to provide this emulation for SimpleDB: fakesdb (a fake version of Amazon's SimpleDB for local/integration testing).

... JSON is used for sending data and for responses, but it is not used as the native storage schema (from
Notes About Amazon DynamoDB).

... DynamoDB vs. Cassandra

Resources:
Amazon Web Services
Amazon DynamoDB
NoSQL
What is Amazon DynamoDB?
AWS SDK for .NET
SimpleDB
micro in VPC
Notes About Amazon DynamoDB
DynamoDB vs. Cassandra

StructureMap Initialize (or Configure) with ChannelFactory

2012-01-19T11:10:00.000-05:00

Trying to configure StructureMap to use the ServiceModel ChannelFactory should be pretty easy right? Unless.. it just isn't working.

The channel factory creates proxies, which StructureMap has a problem with. For instance, if you tried to create an instance of the proxy, and build the mapping:

       StructureMap.ObjectFactory.Initialize  
         (  
           z =  
           {  
             //service  
             var basicHttpBinding = new BasicHttpBinding();  
             var endpointAddress = new EndpointAddress("http://localhost:62049/SendMessage.svc");  
             var channelFactory = new ChannelFactory(basicHttpBinding, endpointAddress);  
             var proxy = channelFactory.CreateChannel();  
             z.For().Use(proxy);  
           }  
         );

You would receive a StructureMapConfigurationException:

StructureMap configuration failures:
Error: 104
Source: Registry: StructureMap.Configuration.DSL.Registry, StructureMap, Version=2.6.3.0, Culture=neutral, PublicKeyToken=e60ad81abae3c223
Type Instance 'edc26816-1ec5-4f0d-b401-b4504e8fb537' (Object: Instawares.Correspondence.Contract.ServiceContract.ISendMessage) cannot be plugged into type Instawares.Correspondence.Contract.ServiceContract.ISendMessage, Instawares.Correspondence.Contract, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
-----------------------------------------------------------------------------------------------

The resolution is much simpler, and provides more flexibility which is to allow StructureMap to handle creation of the object using the LambdaInstance Use(Func func):

StructureMap.Configuration.DSL.Expressions.CreatePluginFamilyExpression

The function will handle the creation of the service proxy (and you can control the lifecycle of the object via the configuration as well).

Here's an example:

               StructureMap.ObjectFactory.Initialize
                (
                    z =
                    {
                        //service
                        var basicHttpBinding = new BasicHttpBinding();
                        var endpointAddress = new EndpointAddress("http://localhost:62049/SendMessage.svc");
                        var channelFactory = new ChannelFactory(basicHttpBinding, endpointAddress);
                        z.For().Use(channelFactory.CreateChannel);
                    }
                );

The object creation has been been transferred to the ChannelFactory, and StructureMap handles the creation of the proxy, and the life cycle of that proxy.

Resources
StructureMap
ChannelFactory(Of TChannel) Class

Best Practices for a .NET Extension or Plug-In

2012-01-17T09:42:00.000-05:00

These are best practices that I created for writing a .NET Extension or Plug-In so some of the references and nomenclature are .NET specific, but the principals and ideas can be extended to any programming language or application design.

Best Practices for Writing a Good Extension or Plug-In:

Any extension should have logging features (and ideally support verbose, error, warning messages). Most applications provide some sort of logging capabilities you can use or extend. This is preferred to designing your own simply because you would have to monitor two sets of logs not to mention the additional configuration, and maintenance of adding a second logging mechanism. If you do have to add your own logging, try to leverage an existing logging infrastructure: log4net, Microsoft Enterprise Library.
If possible avoid any additional (and most importantly external) database or service calls. Aside from the performance hit this can add, your introducing potentially volatile resources that will affect the host systems ability to work properly.
Settle on a single purpose or function for your extension. Don't try to make it do several things, and work in several different functions. It's hard to understand, maintain, and a nightmare when 'something' inside the extension/plug in goes bad.
Limit external dependencies. If at all possible you want your extension/plug-in to be entirely self-sufficient. Any information or exchange should be provided by the host system via a state bag, or in the direct actionable items available.
Document as much of the plug-in as possible within the code module. Include references, and be explicit. You should always document, but people tend to forget about extensions and plug-ins. You write them, they get deployed, and then days, months, years later... doom. The more that's in the code when you open it back up the quicker you can fix it.
Handle and dispatch exceptions in almost all cases. If you can't handle the exception, and it needs to be raised to the host system, then make sure your logging (see #1 on this list) records the exception with as much information as possible. In my experience a host system most often reports very little useful information or (as in one case I remember) it reports absolutely nothing.
Design the functionality of the plug in! So many times, people try to write everything inline for a plug-in rather than following the same coding practices that they would in any other application or feature.
Favor robust naming if your plug-in and if possible the methods, functions, and variables within it. Often when dealing with a plug-in it needs to be self explanitory to the infastructure dude, the end-user, and in almost all cases other people.

Here's a quick example:

MyCompanyNamePlugIn - Seriously? That does that do?
MyCompanyUpdateCreatedDateOnNewRecordPlugIn - Ok, really simple. Want to guess?

Consider interprocess communication if execution is lengthy, intensive, or will impact the performance of the host system. If the action is lengthy or is going to impact the host system, then consider having your plug-in use a queue or call a service for executing the action. If performance is going to be impacted in an extreme negative, consider external executing with a service-bus or queuing system.

References:
Best Practices for Developing Your First Ektron Site
Best Practices in Plugin Development (WordCamp Seattle)

Resources:
log4net
Microsoft Enterprise Library.

JsRender: Javascript Templating. An Introduction.

2012-01-16T09:23:00.000-05:00

What is JsRender?
According to the demos index page JsRender is "Optimized for high-performance pure string-based rendering, without DOM or jQuery dependency".

In simple terms it's a way to apply templates to JSon data and render out content. If you think about it, it's really a powerful feature, and valuable to anyone that is rendering content in a web browser.

It seems that JsRender became the solution for client side templating with the discontinuation of JQuery's templates, however JsRender is something... better. Aside from having no DOM depedency, it does not even have a JQuery dependency. From Borris Moore's presentation, JsRender is "~20 times faster than jquery.tmpl for simple templates".

At a high-level is supports:
Rendering templates and data into a string (as opposed to anything in the DOM)
Templates as strings, and within script tags
Template registration
Tags within templates, including conditional statements, loops

Here's a basic sample/example of JsRender in action:

From http://borismoore.github.com/jsrender/demos/step-by-step/01_inserting-data.html

Requires Script references: jQuery, jsrender
Borris Moore offers a complete set of demos, which demonstrate much more: jsrender Demos.

What's JsRender's Future?

As a product, Borris Moore offered the following road-map for JsRender/JsView on OCTOBER 12, 2011 in this blog post: jQuery Templates and JsViews: The Roadmap

Roadmap summary:

jQuery templates
: Will remain at Beta1, and be superseded by JsRender templates, and JsViews.

JsRender
: Soon move to Beta – then on to V1

jQueryUI plan to use JsRender. (TBD whether it will migrate to jQuery project in GitHub...)

JsViews
: Move to Beta (after JsRender) and then on to V1 …

May also be used by jQueryUI

My Experiences

Most recently I've been using JsRender to render content from Ektron after designing a series of templates that would render content as JSon (see Designing Data Templates for Content Extraction with Ektron (JSon, XML) (Ektron Designing Content Delivery: Part 2) for more information).

In the past, I've also used it for rendering forms, pages, static content, large tables, dynamically loaded sections of my application. What can I say, it's easy, flexible and it works.

Resources:
jsrender on GitHub
jsrender Demos
JQuery Templates
Borris Moore "JsViews: Next-generation jQuery Templates and Data Link" Presentation
Designing Data Templates for Content Extraction with Ektron (JSon, XML) (Ektron Designing Content Delivery: Part 2

Determine your Ektron Version

2012-01-13T10:16:00.000-05:00

Determing your Ektron product version should be simple

Within the website you can view a series of keys within the Web.config file that determines the product version:

<add key="ek_InstallBuild" value="8.0.2.035SP2.01"/>
<add key="ek_ServicePack" value="SP2"/>
<add key="ek_version" value="8.02"/>

You should also note that the Ektron version is available for the end-user to view it within the Ektron work area in the top left hand-corner (see screenshot below):

After searching, it does not appear that the product version is stored within the database for Ektron. There are version columns but this appears to be for versioning data within the application and not for determining the database (or Ektron product) version. This article on the forum seems to back-up these findings: Database Version(2).

Resources:
Database Version(2)

C# JSon Pretty-Print (A simple C# JSon Presentation Formatter)

2012-01-13T09:31:00.000-05:00

When working on a recent project, I ran across a need to have the user paste into a textbox (in a WPF application) a snippet of unformatted JSon data. The data was then used with a template to render content for them to view. The hard part... the unformatted JSon data was almost impossible to read (let alone do anything with).

A quick search around on Google, and I couldn't find what I thought was pretty basic function in C#. I mean, someone, somewhere else in the world needed to be able to do this. The Javascript serializer would work if I had an object to start with, but in my case, there wasn't an object just a string. So I wrote a basic formatter for presentation of JSon data. It's not all that impressive, but it works, and creates presentable data that the user can view and work with.

I also added a quick method as well that would convert an object to a string, and then apply the same formatting algorithm in-case you have a need to present both and want to have the same presentation.

So instead of this:

You get this:

The Code:

        public class JSonPresentationFormatter
        {
            public string Format(object obj)
            {
                var serializer = new JavaScriptSerializer();
                var text = serializer.Serialize(obj);

                return Format(text);
            }

            public string Format(string text)
            {
                if (string.IsNullOrEmpty(text)) return string.Empty;
                text = text.Replace(System.Environment.NewLine, string.Empty).Replace("\t", string.Empty);

                var offset = 0;
                var output = new StringBuilder();
                Action tabs = (sb, pos) => { for (var i = 0; i &lt; pos; i++) { sb.Append("\t"); } };
                Func> previousNotEmpty = (s, i) =>
                {
                    if (string.IsNullOrEmpty(s) || i &lt;= 0) return null;

                    Nullable prev = null;

                    while (i > 0 && prev == null)
                    {
                        prev = s[i - 1];
                        if (prev.ToString() == " ") prev = null;
                        i--;
                    }

                    return prev;
                };
                Func> nextNotEmpty = (s, i) =>
                {
                    if (string.IsNullOrEmpty(s) || i >= (s.Length - 1)) return null;

                    Nullable next = null;
                    i++;

                    while (i &lt; (s.Length - 1) && next == null)
                    {
                        next = s[i++];
                        if (next.ToString() == " ") next = null;
                    }

                    return next;
                };

                for (var i = 0; i &lt; text.Length; i++)
                {
                    var chr = text[i];

                    if (chr.ToString() == "{")
                    {
                        offset++;
                        output.Append(chr);
                        output.Append(System.Environment.NewLine);
                        tabs(output, offset);
                    }
                    else if (chr.ToString() == "}")
                    {
                        offset--;
                        output.Append(System.Environment.NewLine);
                        tabs(output, offset);
                        output.Append(chr);

                    }
                    else if (chr.ToString() == ",")
                    {
                        output.Append(chr);
                        output.Append(System.Environment.NewLine);
                        tabs(output, offset);
                    }
                    else if (chr.ToString() == "[")
                    {
                        output.Append(chr);

                        var next = nextNotEmpty(text, i);

                        if (next != null && next.ToString() != "]")
                        {
                            offset++;
                            output.Append(System.Environment.NewLine);
                            tabs(output, offset);
                        }
                    }
                    else if (chr.ToString() == "]")
                    {
                        var prev = previousNotEmpty(text, i);

                        if (prev != null && prev.ToString() != "[")
                        {
                            offset--;
                            output.Append(System.Environment.NewLine);
                            tabs(output, offset);
                        }

                        output.Append(chr);
                    }
                    else
                        output.Append(chr);
                }

                return output.ToString().Trim();
            }
        }

You can download a copy of the source here: JSonPresentationFormatter

Example:

            //From object
            var employees = new[]
            {
                 new {Name= "John Vansteen",ID="1", Age="35"}
                ,new {Name = "Joe Yankin", ID = "2", Age = "44" }
                ,new {Name = "Larry Yon", ID = "3", Age = "33" }
            };
            Console.Write(new JSonPresentationFormatter().Format(employees));

            //From string
            var jSonAsString = "{\"glossary\": {\"title\": \"example glossary\",\"GlossDiv\": {\"title\": \"S\",\"GlossList\": {\"GlossEntry\": {\"ID\": \"SGML\",\"SortAs\": \"SGML\",\"GlossTerm\": \"Standard Generalized Markup Language\",\"Acronym\": \"SGML\",\"Abbrev\": \"ISO 8879:1986\",\"GlossDef\": {\"para\": \"A meta-markup language, used to create markup languages such as DocBook.\",\"GlossSeeAlso\": [\"GML\", \"XML\"]},\"GlossSee\": \"markup\"}}}}}";
            Console.Write(new JSonPresentationFormatter().Format(jSonAsString));

Key Words:
JSon C# Presentation Formatter

References:
IFormatProvider Interface

Source:
JSonPresentationFormatter

Designing a Generic Meta-Data Driven Transformation Template (Ektron Designing Content Delivery: Part 3)

2012-01-11T15:20:00.000-05:00

In the previous Ektron Designing Content Delivery post (Designing Data Templates for Content Extraction with Ektron (JSon, XML) (Ektron Designing Content Delivery: Part 2)), I outlined the basics of creating a series of templates for data extraction.

While using Ektron content as data is useful (in particular SmartForm data), there is always a need to render transformed content (as Html, Text, Csv, or other formatted content). In this post, I will outline a method to create a simple Meta-Data driven Ektron template that can use used to transform your data for presentation.

What this is useful for:

SmartForm content that needs to be displayed as Html
SmartForm content that needs to be transformed (to other Xml, Html, Text, Csv, etc)
Any Ektron content that requires transformation before being rendered, and represents stand-alone content.

A high level overview of the rendering process:

Of note: I've also created an Ektron Widget control that follows the same pattern, so that I can render out this content as part of a page-builder page without any additional work by the end user. It pretty much works the same way with the template being a page-builder widget, and the end consumption being a Page-builder page.

Transformation Template:
System/Design Requirements:
1. Support Multiple Xsl/Xslt translations against the content set
2. When not configured properly then display a simple message back for the rendered content.
3. Support different separators/delimiters within the metadata in-case there is a conflict and it needs to be changed or updated.

ASPX:

       
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="MetaDataTransformation.aspx.cs" Inherits="ContentManagement.Site.Shared.Template.Content.SmartForm.MetaDataTransformation" %>
<%@ Register Assembly="Ektron.Cms.Controls" Namespace="Ektron.Cms.Controls" TagPrefix="CMS" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head id="Head1" runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <CMS:ContentBlock ID="ContentBlock1" runat="server" />
    </div>
    </form>
</body>
</html>

Code-Behind:

using System;
using ContentManagement.Ektron.Content;
using ContentManagement.Ektron.Transformation.Xsl;
using ContentManagement.Site.Shared.Pages;
using MetaData = Ektron.Cms.API.Metadata;
using ContentManagement.Ektron.Transformation;

namespace ContentManagement.Site.Shared.Template.Content.SmartForm
{
    public partial class MetaDataTransformation : AbstractCmsPage
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            this.ContentBlock1.SetDynamicParameterToIdAndFill(); //prep content block

            Response.Clear();

            WriteCmsDataToHeader(Response);
            Response.ContentType = ContentManagement.Web.ContentTypeDefinition.Html;

            var id = this.ContentBlock1.EkItem.Id; //retrieve the id from the item


            var metaData = this.ContentBlock1.GetMetaData().GetItemByName("Transformation");

            //Note: This should be content/error content from Ektron.
            Action badRender = () => Response.Write("Oppps. It looks like this content isn't ready yet. Try back again soon.");
            
            if (metaData == null)
                //meta data not located on this item, so we do not want it to render.
                badRender();
            else
            {
                var data = new MetaData();
                var metaDataType = data.GetMetadataType(long.Parse(metaData.ID));
                var xsltTransformationFromMetaData = this.ContentBlock1.GetMetaData().GetItemByName("Transformation").Value.ToString().Split(new string[1] { metaDataType.Separater }, StringSplitOptions.RemoveEmptyEntries);

                var transform = XslTransformFactory.Get();
                var input = this.ContentBlock1.EkItem.Html;

                if (xsltTransformationFromMetaData.Length <= 0)
                    //no content, write out a simple error message. 
                    badRender();
                else if (xsltTransformationFromMetaData.Length == 1)
                {
                    //apply single transformation, and output directly to response stream
                    transform.Transform(
                             new XmlStringInput(input)
                           , new XslFileInput(TransformationPath.MapPathAndValidate(this, xsltTransformationFromMetaData[0]))
                           , Response.OutputStream
                           , Response.Output.Encoding);
                }
                else
                {
                    //apply multiple translations
                    xsltTransformationFromMetaData.ForEach(trns => input = transform.Transform(new XmlStringInput(input), new XslFileInput(TransformationPath.MapPathAndValidate(this, trns))));
                }                
            }

            Response.End();
        }
    }
}

The steps for setup and configuration are pretty simple:
Ektron Configuration

Creation of the Meta-Data within Ektron

Sample Metadata Transformation within Ektron 8.0.2

Apply the Metadata to the Content Folder(s)

Metadata applied to the content folder

Add Meta-Data Driven Transformation Template to your content

Content Configuration

Add the MetaData to the Content

Meta Data Transformation on Content (Note: This has two transformations)

Set the Template for the Content to the Transformation Template

Add the correct meta data transformation template.

Notes

If your planning on using this with any type of volume you will want to cache the output of the transformation.

It's important to note that I am not referring to adding a custom style sheet to an Ektron web control (which you can do, and is extremely flexible) in particular this template will retrieve Ektron content, apply transformations and then write the result of the transformation to the response output. The application (and usage) of this for consumption of Ektron content is quite different. If your developing pages within Ektron, and want to transform the output of the control, using Ektron's own transformation infrastructure is a much better option. Here, I am transforming, and then providing content via a push/pull to other sites for content presentation (and providing an option to present that content fully rendered).

Q & A

Q: How is this different than adding a Cms control to the page and selecting a transformation?

A: At the end of the day, it's not all that different, but I wanted a way to make this process completely configuration driven so I can set up additional content at will without having to create a page or a template for each set of content.

In my next posts
1. Designing a wrapper-API for consumption, caching and rendering of Ektron data.
2. Now look what we can do: Render Ektron client-side with data templates and JsRender (for smoking fast response times).
3. My Ektron page templates

Resources:
Designing an Ektron Content Delivery and Provider Mechanism (Part 1)
Designing Data Templates for Content Extraction with Ektron (JSon, XML) (Ektron Designing Content Delivery: Part 2)
Guest Blogger-Cameron Jordan: No More XSLT?!

Ektron: Using a SmartForm root element other than

2012-01-10T17:17:00.000-05:00

When creating an Ektron SmartForm you may want to have a root element other than the default <Root> element.

It's pretty easy to do, just follow these simple steps:
1. Select the Group Box option from the menu

2. Set the 'Field Name' on the 'General' tab to the name of the root element.
2. Select the 'Advanced' tab

3. Select 'Use this element as a root tag' from the 'Root Tag' section

4. Select 'OK'

Additional Information:

When you add the group box as designate it as the root tag, you cannot place anything outside of the group box. This makes a lot of sense, but know if your moving things around... everything has to be inside of the group box.
If you have created this SmartForm previously, this change will cause the underlying data structure be to changed in a way that will remove any previous data. If your making this change on an existing SmartForm, I would recommend creating a new one (by copying and then making the change), and then migrating content from the old SmartForm to the new one.
If your using version 8 then you might want to check out my post Smart Form with custom root element blank when editing (Version: 8.02)

Resources:
Data Designer Field Types
Smart Form with custom root element blank when editing (Version: 8.02)

Reset Crawled Content on MOSS 2007 Shared Services

2012-01-10T16:42:00.000-05:00

If you need to reset the Reset Crawled Content on MOSS 2007 Shared Services

Open SharePoint Central Administration, select Application Management
On the Application Management page, click Create or configure this farm’s shared services.
On the Manage this Farms Shared Services page, click the SSP to reset.
Select Search settings in the Search section.
On the Configure Search Settings page, click Reset all crawled content in the Crawl Settings section
By default, the Deactivate search alerts during reset check box is selected on the Reset Crawled Content page. This option prevents users who have search alerts configured from being sent unnecessary e-mail messages when the crawled content is reset. Click to clear this check box if you do not want to disable alerts during the reset operation.
Click Reset Now.
In the message box, click OK to confirm that you want to reset the search content index.

Key words
"Error The content index is corrupt. Unable to connect ..."

Resources
MOSS Search. Error The content index is corrupt. Unable to connect to the Search Service

BgInfo... it still makes sense.

2012-01-10T09:43:00.000-05:00

BgInfo places machine, networking and configuration information on the desktop by creating a desktop (background) bitmap. This simple program is very useful for helping to keep track of what machine your using, and putting important information right in front of the user.

Here's a simple screenshot of my desktop background:

While it's useful for basic information, it becomes more useful when you start to think outside of the box on what information it can display. BgInfo can use a configuration file to display additional information for you, opening the application up to provide additional information. Really anything that you can see/discover/query or otherwise on the machine or from the machine.

In an example: I've been working with Amazon Web Services (Aws), and create machines all the time. Keeping track of the machine, and it's relationship to the larger cloud was difficult. BgInfo can display not only machine information, but also information from the cloud. The blog post outlines a basic way to get Aws information onto the desktop within the cloud. It's quick, clean, effective... and most importantly reliable: EC2: Using BGINFO to display Instance Details (Instance-Id, AMI Id, Availability Zone)

The basics of BgInfo and a download can be found in this article: BgInfo v4.16. Below I've included some additional resources that provide some additional information.

This article actually outlines how to do the BgInfo configuration to a database: Use BGInfo to Build a Database of System Information of Your Network Computers. This is pretty far from what I see as it's intended usage, but demonstrates some of the flexibility of the utility.

For the record, BgInfo works on Windows XP, Windows Server 2003 (and higher). If your using a machine older than 2003 or XP, it's time to upgrade.

Resources:
BgInfo v4.16
BGInfo Keep an eye on system info
EC2: Using BGINFO to display Instance Details (Instance-Id, AMI Id, Availability Zone)
Use BGInfo to Build a Database of System Information of Your Network Computers

Smart Form with custom root element blank when editing (Version: 8.02)

2012-01-10T09:16:00.000-05:00

When creating a SmartForm with a custom root element the SmartForm created correctly without a problem. When going to edit the SmartForm content it appears blank. However, the content is viewable (when not in edit mode), and renders properly.

Investigating the problem, it appears the xml is correctly there, it just won't let you edit it.

Credit for this solution goes entirely to EktronRashmi and was posted on the Ektron forum in his post Smart Form with Custom Root Element Doesn't Allow Editing.

This forum post contained the solution (Smart Form with Custom Root Element Doesn't Allow Editing):

Here's a fix for this issue
edit sitetroot\workrarea\java\ektron.xml.js
go to line # 299 and comment out following IF statement block (5 lines)
if ("<" == xml.substr(0, 1) && xml.substr(xml.length - 7) != "")
{
xml = "" + xml + "";
bRootTagAdded = true;
}

He actually puts a nice screenshot in there as well:

Based upon this article, I completed the following steps to fix the problem:
1. Checked the file out of source control
2. Applied the fix listed in the forum post
3. Checked the file in
4. Deployed to site

References:
Smart Form with Custom Root Element Doesn't Allow Editing
EktronRashmi Profile
Using a Tag Other Than Root

Designing Data Templates for Content Extraction with Ektron (JSon, XML) (Ektron Designing Content Delivery: Part 2)

2012-01-09T10:32:00.000-05:00

In my first post Designing an Ektron Content Delivery and Provider Mechanism (Part 1) I outlined the basic steps for designing Ektron for management of the content, with the idea of pushing (or pulling) content from this system to be consumed by a host of other sites (and potentially applications).

This post will focus on designing template for the extraction of information from Ektron so that it may be pushed or pulled for consumption by other systems.

This started with basic research around how to retrieve information from Ektron.

1. API - The application itself supports a fairly extensive API which could certainly be used to interact with information. You can certainly get at your content and manipulate it. However investigation here was pretty easy. The API itself is around retrieval and content management and not around manipulation. The proof of concept certainly worked, but was a lot of work and manual code.
2. Database - Ektron maintains a SQL database, and you can see your content. You could write your own access logic, and get the information you need. However, aside from violating the best practices for Ektron (and making your new infrastructure completely Ektron version dependent), this is a tremendous amount of manual work for little or no benefit. This is possible, but so far beyond practical or reliable.
3. Templates [Selected Solution] - Out of the box Ektron supports templates. For the most part these templates are designed to render content out to the end-user... but... the design is also flexible. At the end of the day this is what Ektron is designed to do, just with a slightly different end-result or consumption. The proof of concept worked, and was easily integrated into the Ektron web-site. In other words: simplicity.
4. Ektron Web-services - Ektron supports a host of web-services for interacting with the application. Designed in a very similar fashion to their API, it works, and is practical. Built on SOAP this is a very viable option. In similar to the API it's design around retrieval and content management and not around manipulation. The proof of concept certainly worked, but was a work to create the transitions from the content type to the rendered types.

In the end the solution that worked best was to design a series of templates. Why? It was easy to do, worked well with Ektron's design and provided a tremendous amount of flexibility. This created some quick benefits to the project:

Content could be managed via a url so access via the wrapper API could be directly tied back to the content it represented. In the end, we selected manual alias names for content (as an example: [Group]/[Section]/[Content]/).
The type of content to be generated when pulled could be set/managed inside of Ektron, simple by selecting a template (JSon/Xml/Html, etc.) reducing the amount of IT management and overhead.
The templates at the end of the day are relatively simple ASPX pages, which require a small amount of development and can be managed as part of the Ektron website for lifecycle and delivery.
The paring with Ektron SmartForms makes an extremely flexible offering with control over structure, content, security and delivery.

In the end, I decided on a basic delivery set of Html, Text, Xml, JSon. In order to make the most compelling offering, these were arranged into a simple folder structure:

Content
- SmartForm Translation with MetaData
- AsJson
- AsXml
Taxonomy
- SmartForm Translation with MetaData (planned)
- AsJson
- AsXml (planned)
Note: I could do a whole post on what I am doing with Taxonomy separate from rendering content. If anyone is interested let me know.
AsJson
AsXml
AsRaw
AsRawCollection

The content templates are exactly what you think: rendering out the actual content. The other base templates render out the entire Ektron content items. However, I built those because it was easy to do, the vast majority of the items built on top of this are around the content and taxonomy templates.

Here's an example of the JSon template for content:
ASPX:

       
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="AsJSon.aspx.cs" Inherits="Shared_Template_Content_AsJSon" %>
<%@ Register Assembly="Ektron.Cms.Controls" Namespace="Ektron.Cms.Controls" TagPrefix="CMS" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <CMS:ContentBlock ID="ContentBlock1" runat="server" />
    </div>
    </form>
</body>
</html>

Code-Behind:

       
public partial class Template_Content_AsJSon : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        this.ContentBlock1.SetDynamicParameterToIdAndFill();

        var document = new XmlDocument();
        document.LoadXml(this.ContentBlock1.EkItem.Html);

        Response.Clear();
        
        Response.ContentType = Web.ContentTypeDefinition.JSon;
        Response.Write(JsonConvert.SerializeXmlNode(document).Replace("@", string.Empty).Replace("#text", "text")); 

        Response.End();
    }
}

As you can see basic and effective. Content is available to be pulled (or pushed) via a url. Content (as data, html or any other delivery) is easily track able back as a url, rather than by an id or some other abstract storage identifier. Ektron manages the content, security, data storage definitions, and management of the content/delivery mechanism.

In my next posts:
1. Designing a Generic Meta-Data Driven Transformation Template with Ektron
2. Designing a wrapper-API for consumption, caching and rendering of Ektron data
3. Now look what we can do: Render Ektron client-side with data templates and JsRender (for smoking fast response times).

Resources:
Ektron API
Ektron Best Practices
Design without Borders, yet with Structure
JsRender

Ektron: "System.Web.Services.Protocols.SoapException: Credentials must be specified"

2012-01-06T14:40:00.000-05:00

When using the Ektron.Services a feature works correctly, but when deployed to a remote machine, the content rendering fails with "System.Web.Services.Protocols.SoapException: Credentials must be specified".

Server Error in '/' Application.
--------------------------------------------------------------------------------

Credentials must be specified
Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.

Exception Details: System.Web.Services.Protocols.SoapException: Credentials must be specified

Source Error:

An unhandled exception was generated during the execution of the current web request. Information regarding the origin and location of the exception can be identified using the exception stack trace below.

Ouch.

According to this post System.Web.Services.Protocols.SoapException: Credentials must be specified "That code will work from local system but won't work from remote system because of security. Ektron does not allow unauthenticated remote calls. In order to execute WS calls remotely you need to specify username and password of a cms user."

This code will add authentication that will allow the call to complete without a SOAP exception:

Ektron.Services.AuthenticationHeaderValue = new Ektron.Services.AuthenticationHeader();
Ektron.Services.AuthenticationHeaderValue.Username = "admin";
Ektron.Services.AuthenticationHeaderValue.Password = "admin";

This is a great example where you could wrap the authentication into a factory for creation of the service wrapper objects and/or create a fluent extension method that sets credentials for each wrapper object:

var taxonomySvc = TaxonomyFactory.GetService(); OR var taxonomySvc = new Ektron.Services.Taxonomy().WithDefaultCredentials();

However, you should not a couple of things.

In my case, I was working with the Taxonomy classes, and by accident referenced: Ektron.Services.Taxonomy and NOT Ektron.Cms.API.Content.Taxonomy. Apparently they both work the same, and are available (in separate namespaces). According to the same post, the latter (Ektron.Cms.API.Content.Taxonomy) should not require credentials. Which would explain how I came across this problem in the first place.

References:
System.Web.Services.Protocols.SoapException: Credentials must be specified

Designing an Ektron Content Delivery and Provider Mechanism (Part 1)

2012-01-05T16:56:00.000-05:00

As your designing your Ekron Content Management System (CMS) you need to design the level of interaction your enterprise will have with the CMS.

From the design of Ektron you can see it prefers to be the center of your offering. Most of the controls, pages, API and other components are geared towards building a site. In that regard, it seems to be competent.

For the project I am currently working on, the idea is something very different. It's to use Ektron for management of the content, with the idea of pushing (or pulling) content from this system to be consumed by a host of other sites (and potentially applications).

In some regards, Ektron is not designed to do this type of work. The out-of-the-box offering for exporting content supports PDF, and a synronization utility integrated with the product called ESync is designed to move content through the environments, and for content generation. Their marketing literature describes ESync as: "Automate the secure provisioning of web content, code, assets, and templates from development through production. Deploy only the necessary changes, from a single content update to an entire site, speeding time to Web and eliminating site downtime.".

Based upon Ektron's functionality and the desire to use it as a content repository there is a need to:
1. Design a way to generic render XML (SmartForm) content into Html, Text, Csv
2. Design a way to extract content information (SmartForm) into Xml, JSon
3. Design a way to extract html (or Ektron rendered content) in it's native format
4. Develop an Intermediate/Proxy API capable of extracting content on demand, providing caching of that content at the destination, and providing the content when requested.
5.

These deliverables combined with Ektron as a system itself (including the best practices documentation) generated these additional constraints or parameters:
1. The content delivery and provider mechanism should not interact directly with Ektron's data-storage.
2. The system should rely heavily on using the Ektron website for content extraction, and avoid direct interaction with the database, or Ektron APIs where possible.
3. The delivery mechanism should be extremely flexible and should scale with demand.
4. Any development should wrap Ektron, and not involve changing the core application or product.
5. The strategy support upgrading Ektron at any time.

In order to achieve the deliverables and system requirements, I designed a series of extraction templates (to be included within the Ektron site), and an API for use by these templates, and for extraction of the content (in it's various forms).

This is the high-level design:

Each of the sites consuming the content access Ektron's information via the API, and then store the content within one of the caching mechanisms (file/IO, HttpContext caching, RavenDB) and retrieve any missing content on demand.

Since the API capable of retrieving, caching and filtering content it supports on-demand requests, pull-requests from sites. The next goal is to add content-push from Ektron into the caching mechanisms (proactively staging updated content for the sites to consume).

In my next post:
1. Designing Data Templates for Content Extraction with Ektron (JSon, XML)
2. Designing a Generic Meta-Data Driven Transformation Template with Ekron

References:
Ektron
ESync

Giving Node.js a Try

2012-01-04T11:35:00.000-05:00

Based upon their own description: "Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices." (-http://nodejs.org/)

Seems pretty tempting. In particular I'm interesting is using Node.js for Javascript unit testing in combination with Jasmine. As I've started creating some basic script libraries for dependency injection and publish-subscribe I need a way to unit test and a way to run these tests. It's also promising for use with JsRender as well for templating on the server-side.

This blog post (5 reasons to give node.js some love) covers what I think are the basic reasons why to give it a try:
1) You get to write Javascript on the server and the client
2) Event-based asynchronous stuff is just How Things Work in JavaScript
3) Awesome package management!
4) Community community community
5) It's easy, really easy, like super easy, We can all do it!
(-http://codeofrob.com/archive/2011/04/30/5-reasons-to-give-node-js-some-love.aspx)

The download link on the Node.js site offers three download options: Windows Installer, Mac Installer, and source. Today I am going to download both the Windows Installer and the source (to take a look). For reference the project is hosted on GitHub here: https://github.com/joyent/node. Taking a look, the project seems active and had a recent check in (43 minutes ago).

After running the installation, getting started is easy.
1. Open a command-prompt
2. Navigate to the executable path (on my machine): "C:\Program Files (x86)\nodejs\"
3. Create a small, sample script to be executed, and name it example.js. In my case I copied it from the example:

var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello World\n');
}).listen(1337, "127.0.0.1");
console.log('Server running at http://127.0.0.1:1337/');

4. Type node example.js
5. node.js will respond with the result of the executed script. In this case:

"Server running at http://127.0.0.1:1337/"

How to exit node.js:
To exit node.js you have to enter the key-combination Ctrl-C twice or Ctrl-C, Ctrl-C

References:
Node.js
Jasmine
JsRender
5 reasons to give node.js some love

ILSpy: An Alternative to .NET Reflector

2012-01-04T10:54:00.000-05:00

According to RedGate .NET Reflector is longer a free (as of February 2011, which leaves a big opening for a new assembly browser for .NET assemblies.

Today I checked out ILSpy. It is an open-source .NET assembly browser and decompiler. It runs on .NET 4.0, and from GitHub is appears to be maintained. It even has a couple of plug-ins (I didn't install any of them) available: http://wiki.sharpdevelop.net/ILSpy%20Plugins.ashx

The user interface looks familiar, almost like .NET Reflector from a few versions ago. It also supports the drag-and-drop of assemblies.

It's simple and works well. I'm going to keep it.

Next up I am going to install the Visual Studio Plug-In and see

References:
ILSpy in GitHub
ILSpy
ILSpy Visual Studio Plug-In (
(Forum Post)
.NET Reflector

Best Practices for Developing Your First Ektron Site

2012-01-03T12:21:00.001-05:00

This is a good presentation on best practices for Ektron.

Key Points:

Prefer SmartForms over HTML content - SmartForms provide a structured representation of your content allowing for greater control, and options for content re-use.

PageBuilder - The presentation recommends leveraging PageBuilder. My own experiences with PageBuilder have been mixed, but then again I am working with 8.0 and not version 8.5

Create an abstraction layer of Ektron - A key point in any application, but most definitively within Ektron. An abstraction layer to avoid directly calling the Ektron assemblies.

Have a caching strategy

Logging - The presentation recommends using the integrated Microsoft Enterprise Library logging that is already used within Ekton CMS.

Configuration - The presentation points out that the Ektron configuration, and your custom configuration should be separated into different configuration files.

Presentation:
Best Practices for Developing Your First Ektron Site

MobiGo Connecting to a Computer - Device not Found

2011-12-31T19:23:00.000-05:00

So my son received a V-Tech MobiGo "Touch Learning System" for Christmas. Both of the older boys love it, but it has a feature to connect it to a computer.

Seems simple enough: Install the software, and then connect the device. The directions point to a location of http://www.vtechkids.com/download with instructions to select "Learning Lodge Navigator" software. Ok. No problem.

After installing the software, and connecting the device, it kept giving the error "device not found". The Windows 7 PC sees the device, the driver was loaded, everything seemed to be fine... except for the software.

After searching around, it turns out there is more than one Learning Lodge Navigator, and you have to select the correct one. The actual one to download and use is located at: http://www.vtechkids.com/download/us/en/mobigo

To fix the problem: disconnect the MobiGo device. Uninstall the other version of the "Learning Lodge Navigator", go to the link above and download then install the correct version. Reconnect the device, and it will find it correctly.

References:
Yahoo Answers Article with the correct download link.

TF10121: The path '' is not found or not supported. Type or select a different path

2011-12-22T09:58:00.000-05:00

When working with a Web site within Visual Studio 2010 the Source Control window displayed the error message: TF10121: The path '[Web Site Url]' is not found or not supported. Type or select a different path.

There are a bunch of different articles out there around how to resolve this problem. Basically the reference article below titled TF10121: The path '' is not found or not supported. Type or select a different path (VS.NET) has the answer that worked. Open the affected solution (containing the web site that displays this error). Remove the affected project. Re-add the project.

This did the trick!

The article below also mentions a more low-level resolution if that does not work correctly (listed as a work-around) under which you manually remove the binding information.

Reference:
TF10121: The path '' is not found or not supported. Type or select a different path (VS.NET)

Atlanta Coworking Facilities

2011-05-06T10:27:00.001-04:00

Thanks to Google, I was able to locate a website out there that lists all of the co-working facilities in the Atlanta area:
http://wiki.coworking.info/w/page/16583399/CoworkingAtlanta

I've contacted this one: The BOX : think inside here - 145 Church St. NE Suite 210, Marietta GA 30060. Planning on checking it out in the next couple of weeks!

If your interested in co-working, check it out!

Chris

How to be an entrepreneur…with a job

2011-05-05T10:30:00.000-04:00

This is a great article. It defines quite a bit of the sentiment about the entrepreneurial spirit.

http://jeffhilimire.com/2011/02/how-to-be-an-entrepreneur-with-a-job/