Adrian Alonso

How-to get the XML representacion of a DSL Model Element

2008-04-20T08:58:00.001-07:00

Today I had to find out how to get the XML representacion of a DSL Model Element. Here you have an extension method for Model Elements (mels) that gets the concrete serializer using the Domain XML Serializer Directory and the Domain Class Id of the target Model Element (mel).

        public static string GetXML(this ModelElement mel)
        {
            StringBuilder xml = new StringBuilder();
            
            DomainXmlSerializerDirectory directory = new DomainXmlSerializerDirectory();
            directory.AddBehavior(CoreDesignSurfaceSerializationBehavior.Instance);
            directory.AddBehavior(<#Yours DSL Serialization Behavior goes here #>.Instance);
            // Gets the serializer of the Mel

            DomainClassXmlSerializer serializer = directory.GetSerializer(mel.GetDomainClass().Id);

            if (serializer != null)
            {
                using (XmlWriter writer = XmlWriter.Create(new StringWriter(xml)))
                {
                    serializer.Write(new SerializationContext(directory), mel, writer);
                }
            }
            else
            {
                Trace.TraceWarning(Resources.UnableToGetSerializer, mel.GetType().Name);
            }

            return xml.ToString();
        }

HTH,

Adrian

Clarius T4 Editor is out!

2007-10-18T04:56:00.001-07:00

The beta version is available at http://www.t4editor.net. You can go, download it and provide some feedback at the Clarius T4 Forum which will be very valuable for us (Clarius) to prioritize the most important features for the RTM version!

Here is you have the links:

Victor's official announcement
Clarius T4 Editor Site
Clarius T4 Editor Forums
Clarius T4 Editor Download

Thanks!

Clarius is Hiring!

2007-10-17T08:49:00.001-07:00

As Pablo said in his post Clarius is looking for candidates to fill Senior Dev Positions. You can check the details in Pablo's post too and if you are interested you can ping Pablo, me (alo AT clariusconsulting DOT net or through the contact form of this blog) or send your resume directly to Clarius job alias (which you can find in www.clariusconsulting.net).

Thanks!

Clarius is Hiring!

2007-10-17T08:46:00.001-07:00

Thanks!

runas cmd makes your life easier

2007-09-27T11:37:00.001-07:00

This week I had to temporaly use a different user on my machine. So at first I thought I had to move all my settings (outlook profile, firefox bookmarks, vms, etc) from my primary user to this new one. This is not a nice task. Hopefully I remembered the runas command which allowed me to run the above programs (indeed I'm currently creating this post running WLW using runas) as my primary user from the new user session. IMO this is definitily a very good tip if you have the same scenario in the feature.

Read source code to be a better developer

2007-09-26T07:37:00.001-07:00

I want to give it a try. My idea is to take a look at one or two projects every week and post some conclusions of what I could learn of them. Here you have for example the latest Scott Hanselman's post showing his weekly results. So if you have in mind a really cool source code stuff, please feel free to ping me (leaving a comment to this post or using the contact me link) and let me know where I can get it! Thanks!

Adding a custom VS Task List Token

2007-09-11T07:44:00.001-07:00

You probably used the TODO task list token to add a comment about what it should be done. But what about if you want to use a custom token to add a different kind of comment; for example a Review(x) comment. VS allows you to add custom task list token via Tools->Options->Environment->Task List as it's shown in the following screenshot:

So then you will able to add the Review comments and these will be appearing in the Task List comments section:

My blog is also on asp.net weblogs!

2007-09-07T10:43:00.001-07:00

A few days ago I got an account to start blogging at weblogs.asp.net. So I decided to move the latest posts using a cool tool jes did and for now my idea is to post the same content in both blogger and asp.net blogs. I'm also considering the alternative of using the Cross-Post plugin kzu did. So you can check the new blog on asp.net and leave a comment if want to as well!

adalon on asp.net weblogs: http://weblogs.asp.net/adalon

TCI - Toolbox Controls Installer

2007-09-07T10:35:00.001-07:00

TCI is a VS Package that is provided by the VS SDK as a redist. TCI allows you to easily add your custom Control to the VS Toolbox. For a brief introduction to TCI you can check the VS SDK documentation. Here I will try to cover what is happening under cover:

When you want to add your custom control to the VS toolbox using the TCI VS Package all you need is to tell TCI where the assembly containing the control is and notify to TCI this event incrementing a registry key. Probably the easier way to achieve these requirements is using a WIX-based installer (as the SDK sample does).

In order to tell TCI where your control is you can use the the fully qualified type name if you are installing the control in the GAC as following:

Or provide a location where the assembly containing the control is using the CodeBase value:

Finally you have to include the MSM containing the custom actions which notify TCI that a new Control has been installed:

The custom action will increment or decrement the "Default Items" value of the following registry entry:

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\Packages\{2c298b35-07da-45f1-96a3-be55d91c8d7a}\Toolbox]
"Default Items"=dword:00000001

Note that the {2c298b35-07da-45f1-96a3-be55d91c8d7a} is the GUID for the TCI VS Package.

It's important to check if the TCI Redist is already installed before installing your custom controls if you targeting VS 2500. It's not necessary for VS codename "Orcas" because TCI Package is already installed. You can find the TCI VS Package in the VS's Private Assemblies directory.

Why a good error message is important

2007-08-27T11:41:00.001-07:00

I was trying to change my private email in one of the forums I'm subscripted. The thing is that after clicking the save button it said:

"Sorry, an Error has Occurred"

"Unfortunately an error has occurred during the processing of your page request. If you were attempting to submit a new post, your post may not have been recorded. Please accept our apologies for the inconvenience."

And some links to go back, help, etc. No helpful at all. I searched through the forum posts to find out if someone had has the same issue and I found that the private email address couldn't be duplicated. In that moment I remembered I had another user with that address so I could take the steps to be able to change it in a few seconds. If the error message had been something like "The email address is being used by another user. Please choose a different mail and try again" it would be a significant save of time.

The cause of the error is probably due to they are not validating the email address, so after receiving the generic sql error they show the generic (not useful at all) "Sorry, and Error has Occurred".

"Organize Usings" in VS code name "Orcas" ala Eclipse

2007-08-15T18:56:00.001-07:00

Those that have used Eclipse will probably miss the ctrl+shift+o shortcut ("Organize Imports") when you switch to VS. But now VS code name "Orcas" provides a "new" feature (which unofficially existed in Whidbey) that allows you to remove and sort usings:

So if you don't want miss the Eclipse feature anymore you can add the shortcut going to Tools->Options->Environment->Keyboard

Search the RemoveAndSort command and press the ctrl+shift+o combination. Note that the shorcut is currently used by the OpenProject command and it will lost if you confirm to use the combination for the RemoveAndSort command.

GAX 1.3 is out!

2007-08-05T19:01:00.001-07:00

This new version of GAX is a must if you are thinking to develop Guidance Packages using VS Codename "Orcas" (previous version of GAX didn't work with the latest version of VS) and it will also provide some new features if your are developing with VS 2005.

A welcomed “fix” is the enhancement of the registration process. Now it's smarter about whether to install VB templates based on the presence of VB as a Visual Studio's product. This means that if your Guidance Package contains VB templates (.vstemplates for VB projects or items) you won't need to add conditional logic in your installer to avoid the registration failure when the package is being installed or registered.

The GAX installer is also improved to use WIX technology but the GAT installer project that is unfolded when you create a new Guidance Package using GAT is still the same VS Setup Project.

At last, the Experimental Hive registration is now a built-in feature in GAX allowing you to register your Guidance Packages in both Normal and Experimental hives.

So it seems that this CTP is a necessary and welcomed update for the runtime but not for the UX of developing Guidance Packages.

Here you have the links:

- Grigory Melnik's announcement
- GAX July 2007 CTP download
- GAT July 2007 CTP download

Microsoft Volta

2007-08-01T15:51:00.001-07:00

What Microsoft Volta is? Take a look at these videos in channel 9:

1. Eirk Meijer: Volta - Wrapping the Cloud with .NET - Part 1
2. Eirk Meijer: Volta - Wrapping the Cloud with .NET - Part 2

From the video introduction:

"Volta is an evolving research project focused on exploring ways to innovate data-intensive programming models. Volta is currently exploring a lean-programming inspired toolkit for building web-based and mobile applications by stretching the .NET programming model to cover the Cloud.

Volta is exploring innovation that empowers programmers to delay decisions about tier-splitting to the last possible responsible moment by using either code refactoring or declarative annotations. "

Enjoy!

SFT Setup Project: Deploying many Guidance Packages and many DSLs with a single MSI!

2007-06-07T06:27:00.001-07:00

Clarius SFT June CTP is available. You can check Victor's blog in order to get an overview of the new features included in this drop. One of this new features is the capability of creating a Setup Project to generate a single MSI that installs many Guidance Packages and many DSLs. Let's take a look at how this feature works:

SFT Setup Project Feature:

This new feature allows you to create a new C# or VB wix-based project selecting which Guidance Packages or DSLs you want to include in your MSI. After running the wizard you will get a single project whose output will be a single MSI.

Here is an example:

1. In this sample we have a solution that contains the following projects:

a. A class diagram DSL project
b. A minimal language DSL project
c. A GAT-based Guidance Package
d. A SFT-based Guidance Package

The SFT Setup Project wizard is launched adding a new project to the solution. You can select between C# and VB project types.

2. The wizard is very simple. You just need to select the guidance packages and DSLs that will be included in the MSI and click finish.

3. Finally a new project will be added to the solution. At this point you should be able to build the project in order to get the MSI.

Basically you will find 3 groups of files in the SFT Setup Project:

1. Main Setup files
2. Guidance Packages files: Containg a few files by Guidance Package. You can take a look at my previous post showing how each Guidance Package setup is generated.
3. DSLs files: Each DSL setup is generated in the same way as the DSL Setup Project provided by the DSL SDK does. We chose this implementation because if you already know how to customize the DSL Setup Project you won't need to expend time understanding this new feature of SFT!

(1) Main Setup Files:
SetupMetadata.items: This is the file where you can customize the metadata for Guidance Packages, DSLs and define the projects that will be built before generating the MSI.
Setup.wxs: This is probably the most important file because it contains the setup product definition, the directory tree structure, the features (or the feature references), custom actions and the UI definition.
UI.wxs: This contains the UI definition. This is probably the main file you will need to customize to include your own branding.
Strings.wxl: Wix localization stuff file.
License\License.rtf: The license file for your Guidance Package.
Bitmaps Folder: Image files for the installer wizard branding.

Where to download SFT? Follow this link! http://www.softwarefactoriestoolkit.net/
And please let us know your feedback about you want to include or improve in the next drops! You can ping us through the Guidance Automation Forum or directly to alo -AT- clariusconsulting -DOT- net.

HowTo: Application Block Software Factory (ABSF) Part III: An example

2007-04-10T19:18:00.001-07:00

After an introduction to ABSF and a explanation about providers, here you have an example of how an application block and a provider library can be created. What I did was to take snapshots of the solution after executing each recipe:

1. New Animal Application Block
2. New Provider Factory and Base 'Animal'
3. New Provider (Typed) 'Dog'
4. New Provider (Untyped) 'Monkey'
5. New Design-Time Base Provider Node 'AnimalNode'
6. New Design-Time Provider Node 'DogNode'
7. New Provider Library
8. New Provider (Typed) 'Cat'
9. New Design-Time Provider Node 'CatNode'

The example is based on the Animal Application Block of Brian Button. Brian and Tom did a series of webcasts explaining the Entlib Core and Design-Time creating an Animal Application Block. You can download the webcasts from here and here.

The idea is that you can open each snapshot and take a look at what stuff is created after executing each recipe. In order to build the snapshots, you will have to copy the Common.dll, Configuration.Design.dll and ObjectBuilder.dll to the lib folder of each snapshot. I recommend you to unzip the snapshots in a directory near the root (c:\) because of the path length restriction (you won't be able to build the snapshots if the path is longer than 248 characters)

Finally here you have the link to the snapshots!

Enjoy!

Enterprise Library 3.0 Released!

2007-04-06T08:39:00.001-07:00

I've been part of this excited project mostly developing the Application Block Software Factory (ABSF) and some parts of the Validation Application Block (VAB) (which core and intergation support was developed by Fernando). I want to thanks all to let me be part of this great experience and learn a lot from this spectacular people.

You can download it, start using it and provide feedback! Here you have the links:

Download: http://www.microsoft.com/downloads/details.aspx?FamilyID=62ef5f79-daf2-43af-9897-d926f03b9e60&displaylang=en
Codeplex community site: http://www.codeplex.com/entlib
Tom Hollander's Blog: http://blogs.msdn.com/tomholl/
Olaf's Blog: http://bloggingabout.net/blogs/olaf

Enjoy!

.Net Generic Finder (VS Automation Model Usage)

2007-04-04T16:04:00.001-07:00

I know there are Find/FindAll methods in the System.Collection.* namespace but what I was looking for is something quite different. Here is more or less the scenario:

Suppose you have objects that can be any of the following interfaces: Solution (S), Project (P) or ProjectItem (PI). You don't have a common super type to treat all as polymorphic objects. So if you have a collection of them (Objects) you are not able to have Collection<T> where T is { S | P | PI } because you could have a mix of them (of course at least you have a Collection<Object> but in this case we would not need Generics anyway).

I wanted a finder that allows me to search for an object in this object collection but using the benefits of Generics. I wanted to use the most abstract representation of a collection I could have and I decided to use an IEnumerable parameter. Then I needed to define a Predicate<T> and what I am going to expect is a T or IEnumerable<T> result.

For example: If the col is = { S1, P1, P2, P3, PI1, PI2, PI3 }

The following tests should pass:

1. Finder.FindAll<Solution>(col, delegate( return Predicates.GetNullPredicate<T>())) contains {S1}
2. Finder.FindAll<Project>(col, delegate( return Predicates.GetNullPredicate<T>())) contains {P1, P2, P3}
3. Finder.FindAll<ProjectItem>(col, delegate( return Predicates.GetNullPredicate<T>())) contains {PI1, PI2, PI3}

So I am able to get a IEnumerable<T> where T is { S | P | PI }. I could also specify any other predicate to evaluate specific properties of each T. Notice that I am using the Predicates.Is<T> helper method I published in my previous post to validate if the predicate can be evaluated. I am also using the yield support to collect the result.

public static class Finder
{
    public static T Find<T>(IEnumerable elements, Predicate<T> predicate) where T : class
    {
        IEnumerator<T> enumerator = Find(elements, predicate, true).GetEnumerator();
        return enumerator.MoveNext() ? enumerator.Current : null;
    }

    public static IEnumerable<T> FindAll<T>(IEnumerable elements, Predicate<T> predicate) where T : class
    {
        return Find<T>(elements, predicate, false);
    }

    private static IEnumerable<T> Find<T>(IEnumerable elements, Predicate<T> predicate, bool returnFirst) where T : class
    {
        if (null != elements)
        {
            foreach (object element in elements)
            {
                if (Predicates.Is<T>(element, predicate))
                {
                    yield return (T)element;
                    if (returnFirst) yield break;
                }
            }
        }
        yield break;
    }
}

And/Or/Is Predicates

2007-04-04T15:20:00.001-07:00

The .Net fx doesn't have any support to compose Predicates so I decided to create a Predicates helper for a small project I was working on the last weeks. Here you have my composite predicate methods:

    public static class Predicates
    {
        public static Predicate<T> And<T>(Predicate<T> predicate, Predicate<T> anotherPredicate)
        {
            return delegate(T t) { return predicate(t) && anotherPredicate(t); };
        }

        public static Predicate<T> Or<T>(Predicate<T> predicate, Predicate<T> anotherPredicate)
        {
            return delegate(T t) { return predicate(t) || anotherPredicate(t); };
        }

        public static bool Is<T>(object target, Predicate<T> predicate) where T : class
        {
            T targetAsT = target as T;
            if ( null != targetAsT  )
            {
                return predicate(targetAsT);
            }
            return false;
        }

        public static Predicate<T> GetNullPredicate<T>()
        {
                return delegate(T t) { return true; }; 
        }
    }

The Is<T> method allows you to validate if the target object is of T type before evaluating the predicate. This is something I found very useful when I am working with VS Automation Model because there are "Objects" that can implement many many interfaces so you have a collection of those objects that may or not target the T type. I will publish another post with a Finder example.

Bela Fleck & the Fleckstones @ Argentina! (or it could has been Victor Wooten & the Wootenstones)

2007-03-24T06:07:00.001-07:00

Yesterday Bela Feck & the Fleckstones presented @ Argentina with a spectacular show. I listened and saw one of the most spectacular bass player performance ever seen performed by Victor Lemonte Wooten

If you enjoy listening or playing the bass guitar (in all its forms: tapping, slapping/poping, fingering, etc etc etc etc) this guy is someone you must know and listen to!

By far, Victor was the most applauded artist in the shown so in that moment you don't know if the band should be called "Bela Fleck & the Fleckstones" or "Victor Wooten & the Wootenstones"!

Clarius SFT - Wix-based Setup Projects

2007-03-21T19:37:00.001-07:00

One of the features SFT provides is support for Wix-based Setup projects. I will show how you can use and extend it to generate a MSI for your guidance package.

Wix-based Setup

When you are creating a Guidance Package with SFT, you can choose to create a VS Setup Project or a Wix-based one as is shown in the following picture:

If you select the Wix-based option, the preview setup project will be unfolded in your solution.Let's take a look at the files that are generated by the wizard:

Setup.wxs: This is probably the most important file because it contains the setup product definition, the directory tree structure, the features (or the feature references), the custom actions for registering the guidance package and the UI definition.
TemplatesContent.wxs/TemplateFeature.wxs: Both files are dynamic, this means that their content of these files will be updated every time you build the Setup Project. They will included every file inside any folder in the guidance package project output directory.
UI.wxs: This contains the UI definition. This is probably the main file you will need to customize to include your own branding.
Strings.wxl: Wix localization stuff file.
MySoftwareFactoryInstaller.config.xml: Guidance Package configuration file. For instance here you can specify here the supported runtime version.
License\License.rtf: The license file for your Guidance Package.
Bitmaps Folder: Image files for the installer wizard branding.

How it works:

The SFT Wix-based project is a standard C# or VB project (depending on what language you choose when you are creating a new MetaFactory solution). It defines the AfterBuild/AfterRebuild targets and the following import:

  <Import Project="$(MSBuildExtensionsPath)\Clarius Consulting\Software Factories Toolkit\1.0\MetaFactory\wix.targets" />

The wix.targets file contains the necessary targets to compile (Candle) and link (Light) your wix files in order to generate a MSI for your guidance package. Before that, the WixRefreshContent target is responsible for scanning all the directories in the output folder and updating the content of the TemplatesContent.wxs/TemplatesFeature files.

Customizing the Wix-based Setup Project:

There are some scenarios where you may want to customize the code that the SFT wizard generates for you. The most common scenarios could include:

Changing the UI branding: You can modify the images in the Bitmaps folder by just overwriting them. You can also customize the Dialogs order, descriptions, colors, etc just editing the UI.wxs or Strings.wxl files.
Adding dependencies: If you need to include more than the Guidance Package and Guidance Package Installer assemblies, you can add them in the Setup.wxs file just adding a <File> element inside an existing directory or you could even create your own new directory structure.
Launch Conditions: If you Guidance Package will relies on some other software components that must be installed in the target machine, you can add Wix Launch Conditions in the Setup.wxs file.

I hope this post help you to understand the SFT Wix-based Setup Project structure, how it works and how you can easily customize it with a low effort. If you have any questions about this or other features in SFT you can visit the following sites/forums:

Guidance Automation.Net: http://www.guidanceautomation.net
SFT: http://www.softwarefactoriestoolkit.com/

Enjoy!

Clarius Software Factories Toolkit (SFT) February 2007 CTP is out!!

2007-03-21T14:07:00.001-07:00

Clarius SFT Feb 2007 CTP is finally out!

The new release includes several new features and improvements. Jes has published a very interesting post describing some of them. You can also visit the SFT website to take a look at the latest videos, news, documentation, support and download it!

Some useful links:
SFT Home Page: http://softwarefactoriestoolkit.net
Support: http://softwarefactoriestoolkit.net/support.aspx
Download: http://softwarefactoriestoolkit.net/Download_Feb07CTP.aspx

Enjoy!

Windows Workflow Foundation @ MS Argentina

2007-03-20T13:48:00.001-07:00

Sole will be taking part of the "Introduction to Windows Workflow Foundation" conference jointly with Diego Gonzalez and Jorge Fioranelli. You can check the detailed event information in Sole's blog. Here is the event summary:

When? April 12 from 9 to 13
Where? Bouchard 710, 4 piso, Buenos Aires, Argentina
How to sign up? Follow this link
What is it about?

“Between the new technologies included in the recently released .Net Framework 3.0, we found Windows Workflow Foundation, which consists on the most innovating tool set included in this new framework’s version. The possibility of extracting the workflow concept from the applications as a reusable and extensible element is an extremely innovating aspect in terms of application design. Tools are also included that let you visually edit workflows, enabling analysts and users without programming knowledge to extend applications with a minimum impact in the whole application.

The conference will consist on an introduction to the technology, showing its main characteristics, a demonstration of its more relevant advanced aspects, and will end with two examples of real projects where Windows Workflow Foundation has been used in combination with other technologies to solve common issues.”

HowTo: Application Block Software Factory (ABSF) Part II: Providers

2007-03-20T11:36:00.001-07:00

This is the second part of this post. In this one I will tell you what you need to know when you are creating a new Provider (Typed or Untyped).

When you are creating a new provider for your own block you will have to specify many things (when a well known provider for an existent block is being created we already know the provider hierarchy so we don't need to ask you :)):

1. Provider Interface
2. Provider base class
3. Configuration class

There are basically two kinds of providers: Typed and Untyped.

Typed Providers: The typed providers have strongly typed configuration. This means that you have to specify every configuration property in the Configuration Class and Design-Time Class.

(1) and (2) could be the same but you will probably want to be different in order to separate the Interface from its implementation. The (3) is the base class for all configuration object in the same provider hierarchy. It provides the abstract message protocol to create specific configuration objects.

UnTyped Providers: All untyped providers have the same configuration class and it's based on key/value pairs (as strings). So the provider will receive a Name Value Collection and it will have to parse manually the values.

So if you want to create Providers with a very little effort you will probably need an Untyped Provider but if you want a fully design-time user experience you will need a Typed Provider.

Validating inputs using Validation Application Block and XmlHttpRequest (Part II): The code!

2007-03-16T09:32:00.001-07:00

Someone has left me a comment in my previous post about this topic asking for the code to take a look at the solution. So I think that instead of making you waiting for a detailed explanation of the solution you could take a look at it and see if it's useful for some specific scenarios you may be interested:

There is the code. The zip file contains the Proxy implementation, the JS function and the TypeDescriptor infrastructure you need to make the VAB get the html control value.

Of course this is draft code, and it's only for demo purposes. I hope you enjoy it and provide some feedback!

An example of how to use the Client Validation could be:

<asp:TextBox ID="TextBox1" runat="server" />
<cc2:ClientPropertyProxyValidator 
     ID="ClientPropertyProxyValidator1" runat="server" 
     ControlToValidate="lastNameTextBox" PropertyName="LastName" 
     RulesetName="RuleSetA" 
     SourceTypeName="ValidationQuickStart.BusinessEntities.Customer" />

The example was taken from the Validation Quickstarts and you can realize that you only have to change the control declaration!! (PropertyProxyValidator -> ClientPropertyProxyValidator)

Adding Refactor Context Menu in Visual Studio .Net Add-ins

2007-03-13T09:10:00.001-07:00

When you are creating a new VS .Net Add-in, you can optionally add a command in the "Tools" Command Bar. But what if you want to add your add-in in another command bar? Well, I didn't find a nice way to do that. What I needed was to add the a Command in the Refactor Command Bar (Menu and Context Menu) so what I was looking is the following result:

What you need to do is to use the "MenuBar" (the same that creates the Add-In wizard for the "Tools" Command Bar) and the "Other Context Menus" (this is the one you need to add the menu in the context menu).

here it's the (simplified) code fragment:

     CommandBar menuBarCommandBar = ((CommandBars)_applicationObject.CommandBars)["MenuBar"];
     CommandBar otherContextMenu = ((CommandBars)_applicationObject.CommandBars)["Other Context Menus"];

     CommandBarControl refactorControl = menuBarCommandBar.Controls["Refactor"];
     CommandBarPopup refactorPopup = (CommandBarPopup)refactorControl;

     CommandBarControl refactorContextControl = otherContextMenu.Controls["Refactor"];
     CommandBarPopup refactorContextPopup = (CommandBarPopup)refactorContextControl;

What I did to discover the "Other Context Menus" CommandBar name?... well take a look at this article: HOWTO: Guessing the name of a command bar to add a custom menu entry in Visual Studio .NET add-ins

VS Language Service with MPF/Managed Babel

2007-03-08T11:55:00.001-08:00

A few weeks ago I started to work on a prototype language service for Visual Studio. We want to try the new Managed Babel System... so what is that? Let's start describing the scenario: Suppose you have your own language and you want to integrate it into Visual Studio providing Syntax Coloring, Statement completion, error markers, etc. The VS SDK offers the MPF (Managed Package Framework) that provides a managed "easy" way to extend Visual Studio including support for language services.

And if you want to go a step further, you also have the Managed Babel System which lets you to specify a couple a files contaning the scanner and parser deifnition using LEX/YACC like syntax and tools (MPLEX, MPPG) to generate a lot of code you need to make the language service works.

These are the resources I found useful to start using these frameworks:

VS SDK Documentation
VS Extra Documentation: Managed Babel Overview, MPLEX and MPPG documents included in the VisualStudioIntegration\ExtraDocumentation directory (under your VS SDK installation directory)
ManagedMyC sample: Included in the VS SDK samples.
The Lex & Yacc Page
Visual Studio Extensibility Forum

-Adrian

HowTo: Application Block Software Factory (ABSF) Part I

2007-02-22T12:45:00.001-08:00

The Guidance Package included in the Enterprise Library V3 includes support for creating your own libray and application block. Here is the difference among them:

- Application Block: It contains a Provider Hierarchy (created using the "New Provider Library and Base" recipe) and may or not contain one or more provider or implementations. The provider hierarchy is the base infrastructure that is needed to create an abstraction. Then you are able to create many providers (or services) that can be used to solve the concrete problems. For example in the Logging Application Block one abstraction is the Trace Listener and the Providers are the WMI Trace Listener, the email Trace Listener, the text file Trace Listener, etc. The provider library defines the base structure that the providers need to be used without depending on the implementation because for example you ask for a name provider, say "MyTransactionTraceListener" and you don't know where it will definitely log the entries you send to it.

- Provider Library: It contains only implementations of an existent Application Block. It must reference the Application Block project (or assembly) and it should only implement new Providers. It is a mechanism to extend existent Application Blocks without modifying them.

I will use the Brian's Animal Application Block example. Brian did some webcasts explaining how to develop a new Application Block and its design-time support. Here you have the links:

http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032289570&EventCategory=5&culture=en-US&CountryCode=US

http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032291157&EventCategory=5&culture=en-US&CountryCode=US

http://www.agileprogrammer.com/oneagilecoder/archive/2006/02/09/11359.aspx

The first decision you have to make when you are using the ABSF is if you want to create a new Application Block or you want to extend an existent one (You can extend your own App Blocks or the Enterprise Library existent ones).

If you want to create a new App Block, the first recipe you should execute should be the "New Provider Library and Base" and decide if you will have many implementations of the abstraction or only one. It creates many files for you. Lets take a short look at them (Following the example, the Provider name is "Animal"):

- Interface Provider (IAnimal.cs): It allows to use the abstraction without being coupled to the implementation.
- Base class Provider (Animal.cs):
- Factory (AnimalFactory.cs): It's the facade to get the providers. It uses the InstanceFactory (AnimalInstanceFactory.cs) to create the instances.
- Configuration Data (AnimalData.cs): Base class for all configuration objects of the Provider hierarchy.
- Custom Configuration Data (CustomAnimalData.cs): The configuration of custom provider (UnType Providers) is quite different from the configuration of the Typed Providers. This configuration class should be used for your new custom providers.
- Appliction Blocks Settings: It represents the section that you will use to configure your application block. It's a Partial class because it's supposed to be extended by partial classes. Every new Provider Hierarchy will add a new partial class adding the Provider Hierarchy configuration structure.

The next step is to create the Providers (Typed or Untyped) and wire them to the Provider Hierarchy. I will post this in a future post. See you!

Validating inputs using Validation Application Block and XmlHttpRequest (Part I)

2007-02-22T07:00:00.001-08:00

Enterprise Library V3 already includes Asp.Net Validation support using the Validation Application Block (VAB). You can download it and try the quickstarts from Codeplex. Here you have a Quickstart fragment showing how to use the PropertyProxyValidator to validate a TextBox control:

<asp:TextBox ID="dateOfBirthTextBox" runat="server" />

<cc1:PropertyProxyValidator ID="dateOfBirthValidator" runat="server" ControlToValidate="dateOfBirthTextBox"
     OnValueConvert="dateOfBirthValidator_ValueConvert" PropertyName="DateOfBirth"
     RulesetName="RuleSetA" SourceTypeName="ValidationQuickStart.BusinessEntities.Customer" />

Then the IsValid property is used when the user submits the form and all input are validated using the server side configuration (this is the attributes metadata in the domain objects or the configuration file definition). But what about the client validation that provides the rest of existent Asp.Net's validators? They use fixed or custom (provided by the user) javascript code to perform the validation and the problem is that you have to duplicate the same logic in both C# and JS languages.

I don't have the answer to how to perform a fully client validation but at least I developed a first approach to the solution using XmlHttpRequest. This solution allows you to validate each Input when it loses focus and shows the user the errors before continuing with the next input:

The solution: I extended the PropertyProxyValidator and I added to it the CustomValidator behavior. The JS function is fixed and it sends the XmlHttpRequest to the server specifying the following 3 things:

1. This is a "client side" validation.
2. The value to validate.
3. The validator id.

In the OnLoad event I check the (1) and (3) parameters. Then I execute the base EvaluateIsValid method and write the response containing the validation result and the error message to be shown. The tricky part is how to provide the GetControlValidationValue(string name) because it gets the value from the property defined in the ValidatorPropertyAttribute on the Control to validate. This property could be different in each control and should be set with the value to validate (2). So with the help of reflector and kzu we realized that in the end the TypeDescriptor features are being used to get the Property value to validate. In short we registered a TypeDescriptionProvider to return the value to validate (2) before invoking the validation and we removed this after that.

I think this was too much for this post. I will continue posting more details of the the solution in future posts so stay tuned if you are interested in!

I'm back

2007-02-19T20:37:00.001-08:00

After more that 2 years without holidays I could spent a couple of weeks in Florianopolis, Brasil with my Girlfriend so I'am back again and I will try to update the blog more frequently.

This is the first time I am posting using the Windows Live Writer so I hope it works fine. In the next week I will try to post something about the App Block Software Factory included in Entlib V3 (I think I will not have enough time to some kind of tutorials but I will be able to post some basic ideas), I am doing some investigation on Babel (a managed framework for creating a new Language Service in VS) and working on a lot of cool stuff.

Application Block Software Factory

2007-01-14T12:54:00.000-08:00

I have been working as part of the Enterprise Library V3 Team in Redmond for the last few months. I have been mainly working in the new Block Factory feature; this is a Guidance Package for creating your own blocks and provider libraries. Tom has published a good introductory post about it and I am planning to post a series of entries showing how you can build your own blocks from scratch using this guidance. This probably will include:

Create your new Block
Create a Provider Hierarchy (this is the base types for your new providers)
Create you Providers and its configuration
Create the design-time support for your new block
Extend the new block creating a Provider Library

I'm it

2007-01-14T12:44:00.000-08:00

Too many months without writing a single line of code in the blog… very bad. Thought this time I am writing because I’ve been tagged by VGA (Victor). So here you have five things that you probably don’t know about me:

I used to be a bass guitar player in a rock/funk/power trio. We did a couple of live concerts but we had a many troubles trying to find a singer. I have a 5 strings bass guitar because I’ve been influenced by my first professor to use the bass as it were a guitar for some things. I am also looking for a 6 strings bass guitar… I like the Ibanez SR506 very much.
I like sports very much. I played football in many clubs when I was a boy. Then, the college, work, etc took me off the field. Nowadays, I sometimes play with my friends.
I have recently achieved my Information System Engineer grade in the UTN, a very well known university in Bs As, Argentina. I am very happy with this. I think I will have more free time to social life, catch up in other technologies apart from the ones I use every day, play the bass guitar, etc.
I started programming in Pascal, then VB5, C, C++, Smalltalk, Prolog, C#, Java. I like OOD/OOP very much. Actually, I am working for Clarius (a really cool company in Bs As) and I am part of the Enterprise Library V3 team doing really cool stuff there as well. Before, when I was working for Certant SA, we did a pseudo struts MVC for Java 1.2 with HT and HG that is working very well so far. This was my first framework/dev tool/… I will always be very happy with that work.
I met my super really cool girlfriend in my previous job. She is an engineer and works as a dev as well in a software company called Lagash Systems.

So this is it, I want to tag: Sole, HT and Gustavo Brey

Injecting Spring.Net Objects in NUnit Tests

2006-08-03T14:40:00.000-07:00

If you are using Spring.Net and NUnit, you probably have noticed that does not exist a declarative way to inject Objects (or Services). So it seems easy I search a little in google and how I did not found results in a nutshell I decided to develop a first little version of the solution I need.

First of all, I thought in an Attribute to define which Spring’s Object should be injected in a property or field… so:

///

/// The Attribute lets inject a Spring Object in properties or fields
///
[Serializable, AttributeUsage(AttributeTargets.Field | AttributeTargets.Property,
Inherited = true)]
public sealed class InjectSpringAttribute : Attribute
{
   private string objectName;
   public InjectSpringAttribute(string objectName)
   {
      this.objectName = objectName;
   }
   ///

   /// Returns the Object name that must be injected in the property or field
   ///
   public string ObjectName{get{   return this.objectName;}}
   }

Now, you could use the attribute as follows:

private FirstService service;
[InjectSpring("FirstService")]
public FirstService Service
{
get { return service; }
set { service = value; }
}
[InjectSpring("FirstService")]
private FirstService serviceField;

And you are not suppose to obtain IApplicationContext, getObject(…), bla bla.. anymore. The only issue remains is to define the way the attribute will be processed. For now, I have not a really elegant way to do this (in java I had been used AspectJ but with .Net???)… so I have a base TestCase from which all others Testcases extend and in the SetUp method I execute the following util static method: InjectObjects(instance) whose responsibility is to find all properties and fields decorated with the InjectSpringAttribute and set them the requested object.

I left you the code of the util method…

public static void InjectObjects(Object instance)
{
   Object springObject;
   BindingFlags binding = BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic;
   foreach (PropertyInfo propertyInfo in instance.GetType().GetProperties( binding ) )
   {
      if(TryGetSpringObject(propertyInfo.GetCustomAttributes(
            typeof(InjectSpringAttribute), true),out springObject))
      {
         propertyInfo.SetValue(instance, springObject, null);
      }
   }
   foreach (FieldInfo fieldInfo in instance.GetType().GetFields(binding))
   {
      if(TryGetSpringObject(fieldInfo.GetCustomAttributes(
            typeof(InjectSpringAttribute), true),out springObject))
      {
         fieldInfo.SetValue(instance, springObject);
      }
   }
}
private static bool TryGetSpringObject(Object[] customAttrs,out Object springObject )
{
   if (customAttrs != null && customAttrs.Length > 0)
   {
      foreach( object customAttr in customAttrs)
      {
         InjectSpringAttribute attr = customAttr as InjectSpringAttribute;
         if (attr != null)
         {
            springObject = ContextRegistry.GetContext().GetObject(attr.ObjectName);
            return true;
         }
      }
   }
   springObject = null;
   return false;
}

Remote Pair Programming

2006-07-11T14:08:00.000-07:00

Pair programming is a well known eXtreme Programming practice. Nowadays it is very frequent that developers aren't in the same physical place so it would be interesting that the IDEs could offer us remote functionality to develop with a person that could be in another part of the world. If you think that it would be useful, let’s try to define some of the potential add-ins to the IDE:

To have a way to edit remote code and that the changes would be saved in the remote machine. This may be something like VNC client.
To have a way to communicate with other developers without exiting the IDE. Something like a chat embedded in the IDE including text, audio and video.
...

Beyond the practice, this could help to assist junior developers in the typical problems that they usually have, yet we were in the same office (this let us not to get up of our chairs).

OB documentation and development baseline

2006-07-04T07:58:00.000-07:00

OB is a very powerful tool but it's not well documented yet, so I was thinking the didactic way to show how it can be used and extended by any project (such as tools, business projects, core utilities, etc).

The starting point is to use the existing material:

Then, I think it would be useful to meet with an “OB.chm” (or equivalent) that offers an introduction, explains the design principles to understand how to extend it, shows some scenarios where it can be used and includes the existing material and examples of the typical use cases.

Another good thing would be to have a community site where developers can upload custom strategies or policies, post comments and … well, you know. As far as I know the site’s publication is imminent.

Concerning development, a DSL (see DSL tools here or here) with a Guidance Package (see GAT) could allow an alternative to programmatic configuration and would be an excellent tool to reduce the OB’s learning curve.

As a preliminary prototype, I started a doc with the following topics:

Introduction
Terminology (LEL style - Language Extended Lexicon)
Design of OB

Policies
Design Patterns used by OB

Strategy (GoF)
Chain of Responsibility (GoF)
IoC or Dependency Injection

Extending OB

With strategies
With policies

Comparison with to Spring’s BeanFactory
Reference to how CAB and EntLib uses OB
Examples
…

As soon as I have a “cleaner” version, I will try to upload the doc to some site or keep on posting.

ObjectBuilder

2006-07-03T14:21:00.000-07:00

Let's talk about a cool tool named ObjectBuilder that is a subsystem used by CAB and EntLib to perform the repetitive job at the moment of creating objects.

ObjectBuilder (OB) is a Pattern & Practices Application Block. The owners of the project define it as “a framework for composing object-oriented systems”. OB was conceived in CAB (Composite UI Application Block). It uses the Dependency Injection pattern to populate object’s members via Constructors and Property Setters strategies. (To read more about Dependency Injection, see Martin Fowler’s article about what dependency injection is and how it is implemented by various frameworks).

OB can:

Create the appropriate objects based on configuration data.
Manage Singleton pattern.
Populate public properties and execute methods on the object.
Communicate with objects that support the IBuilderAware interface.
Provide a tear down facility that can remove settings from objects by reversing the chain of operations.

The main concepts of OB are Strategies, Policies, Locator, Lifetime Container and of course the Builder. The OB's design is based on the "GoF Builder" design pattern. This pattern is categorized as a stateful creational pattern because we first setup the builder and then tell him (yes, tell don't ask) for a new instance... so, generally an example says than a million word...

1. Builder builder = new Builder();
2. Locator locator = CreateLocator();
3. builder.Policies.Set<ISingletonPolicy>(new SingletonPolicy(true), typeof(Foo), "foo");
4. Foo obj1 = builder.BuildUp<Foo>(locator, "foo", null);
5. Foo obj2 = builder.BuildUp<Foo>(locator, "foo", null);
6. Assert.AreSame(obj1, obj2);

First, in 1 and 2 we create a Builder and a Locator. Then, a Singleton Policy is added to the builder (line 3). The line 4 tells the builder for an instance of Foo and line 5 tells for another instance. Finally, the line 6 asserts that the obj1 and obj2 references are the same so the Singleton Policy works ok.

When BuildUp method is fired, OB lunches a chain of responsibility (yes, another GoF design pattern), using all Strategies that internallyhas, in order that for each strategy uses to decide whether it must execute using the configured policy.

OB has a lot of more power but it is not well documented yet. By now, you can find some bits in CAB's documentation and in meaningful blogs as kzu and brian button

AOP and Java Annotations

2006-06-07T10:08:00.000-07:00

In this post I wish to show how the combination of annotations and AOP can be used to perform a "parameter cannot be null" validation in a class' method.

Suppose we have the following method that is executed only if the parameter value is not null:

public void serviceNotAllowedNullParameter(Object param){
if( param != null ){
System.out.println(param.toString());
//do something...
}
}

One possibility is to include the same code if (copy paste the same code pattern) in all methods that need this behavior. Another one ( much more elegant ) is design a solution based on AOP and Annotations. Let’s start by defining the NotNullParameter annotation as following:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface NotNullParameter {
}

Now, we proceed to decorate the method with the @NotNullParameter:

@NotNullParameter
public void serviceNotAllowedNullParameter(Object param){
if( param != null ){
System.out.println(param.toString());
//do something...
}
}

Though, so far we don’t do any magic. We need to find the (fashion) way to process all annotations that were defined in our code in order to add the necessary logic to perform the check validation. So… a good idea would be to use an Aspect!

void around(Object param):
execution(@NotNullParameter void ar.adalon..*.*(Object+) ) &&
args(param){
if( param == null ){
return;
}
proceed(param);
}

The preceding code is read as simple as “Intercept all the execution of any method of any package or sub package of ar.adalon that accept one parameter (of type or subtype of object… hence is any instance) and is decorated with the @NotNullParameter annotation”. The around advise allows to continue (procced) or terminate (return;) with the intercepted method’s execution. Now, we can simplify our service to:

@NotNullParameter
public void serviceNotAllowedNullParameter(Object param){
System.out.println(param.toString());
//do something...
}

By this way, I intended to show you how AOP crosscutting allow to break up the business logic and additional validations .

I leave some helpful links concerning annotations:

http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html
http://www.developer.com/java/other/article.php/10936_3556176_1
http://java.sun.com/developer/technicalArticles/releases/j2se15/
http://www-128.ibm.com/developerworks/java/library/j-annotate1/
http://www-128.ibm.com/developerworks/library/j-annotate2.html
http://www.devsource.com/article2/0,1895,1949936,00.asp

Initializing blog!

2006-03-07T18:20:00.000-08:00

Hi!, my name is Adrian Alonso. I’m a Java and .Net developer from BsAs, Argentina. I have the necessity to share my thoughts with everyone who enjoy the OOP/OOD world so I decided (like did a lot of people) to start blogging about the things that make me spend time when I supposed that I might be watching tv, sleeping or another different matter… see you soon