Hugo Ribeiro

Running that VM Faster

hgr — Wed, 21 Oct 2009 11:16:35 GMT

I’ve been running Windows 7 for a while and one of the things that I decided to try is to have all the development environment on a virtual machine.

That’s because my Windows 7 is running on 64 bits and I still need to run a lot of things on 32 bits.

The problem with virtual machines on this scenario is performance.

This little tweak makes my VMWare virtual machine fly. So, if anyone is having issues, try this out.

mainmem.usenamedfile="FALSE"

GASP@Porto: RIA Services

hgr — Tue, 20 Oct 2009 13:41:40 GMT

This week – tomorrow (21) to be more precise – GASP will hold a new meeting here in our premises.

This session will be about RIA Services and will be conducted by Nuno Godinho, expert on Silverlight and RIA Services and ASP.NET MVP.

If anyone wants to join us in the discussion, feel free to request it at GASP LinkedIn Group.

LOB

hgr — Tue, 20 Oct 2009 13:30:35 GMT

Great presentation about technologies (becoming) available for developing Line-of-Business Applications (whatever you may think that is…):

http://www.slideshare.net/simonguest/next-generation-lob-line-of-business-applications

Cool stuff there.

Embarrassing…

hgr — Fri, 25 Sep 2009 22:44:27 GMT

It’s absolutely incredible that I published only 6 posts this year.

The scenario is even worst if I think that 3 were just to put Feedburner running again and other 2 were just notes about something that as little to do with my work…

Well, this is the 7th… And it’s worst than the previous 6…

Well… management is really making me miserable. :)

Why Google Rocks…

hgr — Fri, 25 Sep 2009 22:37:08 GMT

Well, it’s not because of Google Docs, not because of Chrome, Wave, Mail, or whatever they do “outside the box”.

It’s just because of this:

The best search engine out there. Ever!

FeedBurner and the 512K Maximum File Size III

hgr — Fri, 10 Jul 2009 09:54:37 GMT

That’s it! The feed is back online.

FeedBurner and the 512K Maximum File Size II

hgr — Fri, 10 Jul 2009 09:50:50 GMT

It didn’t. I think that it’s just another post that needs to go...

FeedBurner and the 512K Maximum File Size

hgr — Fri, 10 Jul 2009 09:49:08 GMT

Apparently FeedBurner doesn’t swallow RSS sources that exceed 512K...

Since mine is now at 522K – I suppose because of the source code size in previous posts – this post is just a try to make the older posts go away so that the file size decreases... :)

Let’s hope it will work…

Add-in Express

hgr — Wed, 08 Jul 2009 09:56:40 GMT

These past weeks I’ve playing around with Excel add-ins.

Developing an Excel add-in with ribbon customizations, formulas, and task panes is not an easy task.

VSTO doesn’t help a lot. So I’ve been using this great toolset from Add-in Express:

Add-in Express

Try it out if you’re thinking of doing something with Office…

No Configuration Enterprise Library

hgr — Fri, 15 May 2009 11:53:25 GMT

From time to time I end up starting a new C# project and bumping into the same old infrastructure requirements like exception handling, logging, caching, etc.

At that point I always get back to Microsoft Enterprise Library... :)

I really like EntLib but this time I had other requirements that prevented me from having a configuration file.

So how the heck can you use EntLib without configuration? It turns out that it’s relatively easy but not so well documented, so that even Google had trouble finding me the solution. :)

I’ll leave it here also for future reference...

Scenario 1 – No Configuration Caching Block

Using the caching block with configuration is very simple. You create the configuration and then simply use the CacheFactory to create the manager. Something like this:

        1: ICacheManager productsCache = CacheFactory.GetCacheManager();

       2: productsCache.Add(product.ProductID, product)

To use it without configuration is a little harder.

First you need to use the CacheManagerFactory to create a factory passing in the configuration settings. Then you use that factory to create the manager.

The magic happens when you create your own class implementing the IConfigurationSource interface (available in Microsoft.Practices.EnterpriseLibrary.Common).

The final code is as follows:

       1: using Microsoft.Practices.EnterpriseLibrary.Caching.Configuration;

       2: using Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations;

       3:  

       4: namespace MyApplication

       5: {

       6:     internal class CacheServiceConfigurationSource : IConfigurationSource

       7:     {

       8:         #region Members

       9:  

        private int expirationFrequencyInSeconds;

        private int maximumElementsBeforeScavenging;

  

        #endregion

  

        #region Constructors

  

        private CacheServiceConfigurationSource()

        {

        }

  

        public CacheServiceConfigurationSource(int expirationFrequencyInSeconds, int maximumElementsBeforeScavenging)

            : this()

        {

            this.expirationFrequencyInSeconds = expirationFrequencyInSeconds;

            this.maximumElementsBeforeScavenging = maximumElementsBeforeScavenging;

        }

  

        #endregion

  

        #region Public Methods

  

        public void Add(IConfigurationParameter saveParameter, string sectionName, ConfigurationSection configurationSection)

        {

        }

  

        public void AddSectionChangeHandler(string sectionName, ConfigurationChangedEventHandler handler)

        {

        }

  

        public ConfigurationSection GetSection(string sectionName)

        {

            if (sectionName.Equals("cachingConfiguration", StringComparison.CurrentCulture))

            {

                CacheManagerSettings result = new CacheManagerSettings();

                result.DefaultCacheManager = "DefaultCacheManager";

  

                CacheStorageData storage = new CacheStorageData();

                storage.StorageEncryption = string.Empty;

                storage.Name = "NullStorage";

                storage.Type = typeof(NullBackingStore);

                result.BackingStores.Add(storage);

  

                CacheManagerData manager = new CacheManagerData();

                manager.Name = "DefaultCacheManager";

                manager.NumberToRemoveWhenScavenging = 10;

                manager.MaximumElementsInCacheBeforeScavenging = this.maximumElementsBeforeScavenging;

                manager.ExpirationPollFrequencyInSeconds = this.expirationFrequencyInSeconds;

                manager.CacheStorage = "NullStorage";

                result.CacheManagers.Add(manager);

  

                return result;

            }

  

            return null;

        }

  

        public void Remove(IConfigurationParameter removeParameter, string sectionName)

        {

        }

  

        public void RemoveSectionChangeHandler(string sectionName, ConfigurationChangedEventHandler handler)

        {

        }

  

        #endregion

    }

}

  

using System;

using System.Configuration;

using System.Text;

using Microsoft.Practices.EnterpriseLibrary.Caching;

using Microsoft.Practices.EnterpriseLibrary.Caching.Expirations;

  

namespace MyApplication

{

    public static class CacheService

    {

        #region Members

  

        private static ICacheManager manager;

  

        #endregion

  

        #region Properties

  

        private static ICacheManager Manager

        {

            get

            {

                if (manager == null)

                {

                    CacheManagerFactory factory = new CacheManagerFactory(new CacheServiceConfigurationSource(Context.Current.Settings.Cache.ExpirationFrequencyInSeconds, Context.Current.Settings.Cache.MaximumElementsBeforeScavenging));

                    manager = factory.CreateDefault();

                }

  

                return manager;

            }

        }

  

        #endregion

  

        #region Public Methods

  

        public static void AddData<T>(string key, T value)

        {

            AddData<T>(key, value, Context.Current.Settings.Cache.ExpirationTimeInSeconds);

        }

  

        internal static void AddData<T>(string key, T value, int expirationInSeconds)

        {

            // Expiration handler

  

            SlidingTime expirationHandler = new SlidingTime(new TimeSpan(0, 0, expirationInSeconds), DateTime.Now);

  

            // Add it

  

            Manager.Add(key, value, CacheItemPriority.Low, null, expirationHandler);

        }

  

        #endregion

    }

}

Notice the GetSection method in CacheServiceConfigurationSource and the Manager property in the CacheService class.

Scenario 2 – No Configuration Logging Block

The logging application block is similar.

With configuration you use the Logger class.

Without configuration you must create a LogWriter using your own IConfigurationSource also.

       1: using System;

       2: using System.Configuration;

       3: using System.Text;

       4: using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;

       5: using Microsoft.Practices.EnterpriseLibrary.Logging.Configuration;

       6: using Microsoft.Practices.EnterpriseLibrary.Logging.Formatters;

       7: using Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners;

       8:  

       9: namespace MyApplication

{

    internal class LoggingConfigurationSource : IConfigurationSource

    {

        #region Public Methods

  

        public void Add(IConfigurationParameter saveParameter, string sectionName, ConfigurationSection configurationSection)

        {

        }

  

        public void AddSectionChangeHandler(string sectionName, ConfigurationChangedEventHandler handler)

        {

        }

  

        public ConfigurationSection GetSection(string sectionName)

        {

            if (sectionName.Equals("loggingConfiguration", StringComparison.CurrentCulture))

            {

                // Logging configuration

  

                LoggingSettings result = new LoggingSettings();

                result.DefaultCategory = "General";

                result.TracingEnabled = true;

                result.LogWarningWhenNoCategoriesMatch = true;

  

                // Listners

  

                FormattedEventLogTraceListenerData listener = new FormattedEventLogTraceListenerData();

                listener.Name = "EventLogListener";

                listener.Source = "Office Extensions";

                listener.Formatter = "TextFormatter";

                listener.Log = "MyApplication";

                listener.MachineName = string.Empty;

                listener.TraceOutputOptions = System.Diagnostics.TraceOptions.None;

                listener.Filter = System.Diagnostics.SourceLevels.All;

                listener.ListenerDataType = typeof(FormattedEventLogTraceListenerData);

                listener.Type = typeof(FormattedEventLogTraceListener);

                result.TraceListeners.Add(listener);

  

                TraceListenerReferenceData listenerReference = new TraceListenerReferenceData();

                listenerReference.Name = "EventLogListener";

  

                // Formatters

  

                StringBuilder template = new StringBuilder();

                template.AppendLine("Timestamp: {timestamp}");

                template.AppendLine("Message: {message}");

                template.AppendLine("Category: {category}");

                template.AppendLine("Priority: {priority}");

                template.AppendLine("EventId: {eventid}");

                template.AppendLine("Severity: {severity}");

                template.AppendLine("Title:{title}");

                template.AppendLine("Machine: {machine}");

                template.AppendLine("Application Domain: {appDomain}");

                template.AppendLine("Process Id: {processId}");

                template.AppendLine("Process Name: {processName}");

                template.AppendLine("Win32 Thread Id: {win32ThreadId}");

                template.AppendLine("Thread Name: {threadName}");

                template.AppendLine("Extended Properties: {dictionary({key} - {value})}");

  

                TextFormatterData formatter = new TextFormatterData();

                formatter.Name = "TextFormatter";

                formatter.Type = typeof(TextFormatter);

                formatter.Template = template.ToString();

                result.Formatters.Add(formatter);

  

                // Category Sources

  

                TraceSourceData exceptionsSource = new TraceSourceData();

                exceptionsSource.TraceListeners.Add(listenerReference);

                exceptionsSource.Name = "Exceptions";

                exceptionsSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

                result.TraceSources.Add(exceptionsSource);

  

                TraceSourceData traceSource = new TraceSourceData();

                traceSource.TraceListeners.Add(listenerReference);

                traceSource.Name = "Trace";

                traceSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

                result.TraceSources.Add(traceSource);

  

                TraceSourceData generalSource = new TraceSourceData();

                generalSource.TraceListeners.Add(listenerReference);

                generalSource.Name = "General";

                generalSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

                result.TraceSources.Add(generalSource);

  

                // Special Sources

  

                result.SpecialTraceSources.AllEventsTraceSource.Name = "AllEvents";

                result.SpecialTraceSources.AllEventsTraceSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

  

                result.SpecialTraceSources.NotProcessedTraceSource.Name = "NotProcessed";

                result.SpecialTraceSources.NotProcessedTraceSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

  

                result.SpecialTraceSources.ErrorsTraceSource.Name = "LoggingErrorsAndWarnings";

                result.SpecialTraceSources.ErrorsTraceSource.DefaultLevel = System.Diagnostics.SourceLevels.All;

                result.SpecialTraceSources.ErrorsTraceSource.TraceListeners.Clear();

                result.SpecialTraceSources.ErrorsTraceSource.TraceListeners.Add(listenerReference);

  

                // Return

  

                return result;

            }

  

            return null;

        }

  

        public void Remove(IConfigurationParameter removeParameter, string sectionName)

        {

        }

  

        public void RemoveSectionChangeHandler(string sectionName, ConfigurationChangedEventHandler handler)

        {

        }

  

        #endregion

    }

}

  

using System;

using System.Diagnostics;

using System.Globalization;

using Microsoft.Practices.EnterpriseLibrary.Logging;

  

namespace MyApplication

{

    public static class LoggingHandler

    {

        #region Constants

  

        private const string CategoryExceptions = "Exceptions";

        private const int PriorityExceptions = 1000;

        private const int EventIdExceptions = 1000;

        private const string TitleExceptions = "Errors Log";

        private const TraceEventType SeverityExceptions = TraceEventType.Error;

  

        #endregion

  

        #region Members

  

        private static LogWriter writer;

  

        #endregion

  

        #region Properties

  

        internal static LogWriter Writer

        {

            get

            {

                if (writer == null)

                {

                    writer = CreateWriter();

                }

  

                return writer;

            }

        }

  

        #endregion

  

        #region Public Methods

  

        public static void Exception(Exception ex)

        {

            // Validation

  

            if (ex == null)

            {

                throw new ArgumentNullException();

            }

  

            // Log

  

            WriteEntry(CategoryExceptions, TitleExceptions, ex.ToString(), PriorityExceptions, EventIdExceptions, SeverityExceptions);

        }

  

        #endregion

  

        #region Private Methods

  

        private static void WriteEntry(string category, string title, string message, int priority, int eventId, TraceEventType severity)

        {

            LogEntry entry = new LogEntry();

            entry.Categories.Add(category);

            entry.TimeStamp = DateTime.Now;

            entry.EventId = eventId;

            entry.Message = message;

            entry.Priority = priority;

            entry.Severity = severity;

            entry.Title = title;

  

            Writer.Write(entry);

        }

  

        private static LogWriter CreateWriter()

        {

            LogWriterFactory factory = new LogWriterFactory(new LoggingConfigurationSource());

            return factory.Create();

        }

  

        #endregion

    }

}

I hope this helps someone in the future.

It turns out that the greater strength of EntLib – configuration – is also, at least in my opinion, its greater weakness. Just think of how many “real-world applications” would you want to have the user messing with the configuration file to setup event viewer listeners and things like that. :)

DSL Tools #14 - Double-click in the Model Explorer

hgr — Tue, 16 Dec 2008 16:22:16 GMT

Every DSL Tools project generates this handy model explorer where you can browse the domain classes that are on your domain model.

Something like this:

This is particularly helpful for example to change the properties of a particular domain class. You browse for in the explorer, click on it, and simply edit the properties.

Now there is a fundamental feature that the guys at Microsoft missed in the explorer. The ability to double click a domain class there and have the domain model view show that domain class centered. A feature very useful if you have a model with a few dozens of domains classes (which is very typical).

So I put my mind to implement such behavior on my various DSL explorers. It turns out that it isn't very difficult.

1. Determine the explorer class name

The model explorer class is generated as part of your DSLPackage project. The name of the class depends on the name of your DSL. To find out the correct name, browse the DSLPackage project, under GeneratedCode, and you'll find a file named ModelExplorer.cs. The name of the explorer is the name of the first class on that file.

In my example that is UserInterfaceModelExplorer:

        1: /// <summary>

       2: /// Double-derived class to allow easier code customization.

       3: /// </summary>

       4: internal partial class UserInterfaceModelExplorer : UserInterfaceModelExplorerBase

       5: {

       6:     /// <summary>

       7:     /// Constructs a new UserInterfaceModelExplorer.

       8:     /// </summary>

       9:     public UserInterfaceModelExplorer(global::System.IServiceProvider serviceProvider)

      10:         : base(serviceProvider)

      11:     {

      12:     }

      13: }

2. Create a custom class with that same name

Under the DSLPackage, you will need to create a new custom partial class with the name of your model explorer. All the magic will happen here.

3. Override the CreateElementVisitor method

Here you should subscribe to the ObjectModelBrowser.DoubleClick event:

       1: /// <summary>

       2: /// Executed when the model explorer creates the tree element visitor.

       3: /// </summary>

       4: /// <returns>The tree element visitor.</returns>

       5: protected override IElementVisitor CreateElementVisitor()

       6: {

       7:     // Subscribe double click in the tree view

       8:  

       9:     this.ObjectModelBrowser.DoubleClick += new EventHandler(this.ObjectModelBrowser_DoubleClick);

      10:  

      11:     // Default behavior

      12:  

      13:     return base.CreateElementVisitor();

      14: }

4. Implement the corresponding event handler

The magic consists in:

First, finding the element that is selected in the explorer,
Second, getting the corresponding model element,
And, finally, selecting that shape in the model viewer.

Check the full source code bellow for the implementation of these steps.

5. Transform All templates

Before you test the new behavior of the model explorer, you'll need to transform all the templates to let the DSL know that you have customized your model explorer.

And that's it. Double-click any domain class in the explorer and the model viewer will be updated accordingly.

Full Source Code

       1: using System;

       2: using System.Collections.ObjectModel;

       3: using Microsoft.VisualStudio.Modeling;

       4: using Microsoft.VisualStudio.Modeling.Diagrams;

       5: using Microsoft.VisualStudio.Modeling.Shell;

       6:  

       7: namespace MyDSL.UserInterface

       8: {

       9:     /// <summary>

    /// Custom behavior for UserInterfaceModelExplorer.

    /// </summary>

    internal partial class UserInterfaceModelExplorer

    {

        #region Public Methods

  

        /// <summary>

        /// Executed when the model explorer creates the tree element visitor.

        /// </summary>

        /// <returns>The tree element visitor.</returns>

        protected override IElementVisitor CreateElementVisitor()

        {

            // Subscribe double click in the tree view

  

            this.ObjectModelBrowser.DoubleClick += new EventHandler(this.ObjectModelBrowser_DoubleClick);

  

            // Default behavior

  

            return base.CreateElementVisitor();

        }

  

        #endregion

  

        #region Private Methods

  

        /// <summary>

        /// Selects the specified shape using the given modeling document data.

        /// </summary>

        /// <param name="shapeElement">The shape element that should be selected.</param>

        /// <param name="docData">The modeling document data.</param>

        private static void SelectShape(ShapeElement shapeElement, DocData docData)

        {

            // Validation

  

            if (shapeElement == null)

            {

                throw new ArgumentNullException("shapeElement");

            }

  

            if (docData == null)

            {

                throw new ArgumentNullException("docData");

            }

  

            // Select the shape

  

            ModelingDocView docView = docData.DocViews[0];

            if (docView != null)

            {

                docView.SelectObjects(1, new object[] { shapeElement }, 0);

            }

        }

        

        /// <summary>

        /// Gets the first shape the represents the specified model element.

        /// </summary>

        /// <param name="modelElement">The model element whose shape will be returned.</param>

        /// <returns>The first shape the represents the specified model element.</returns>

        private static ShapeElement GetModelElementFirstShape(ModelElement modelElement)

        {

            // Presentation elements

  

            LinkedElementCollection<PresentationElement> presentations = PresentationViewsSubject.GetPresentation(modelElement);

            foreach (ModelElement element in presentations)

            {

                ShapeElement shapeElement = (element as ShapeElement);

                if (shapeElement != null)

                {

                    return shapeElement;

                }

            }

  

            // Default result

  

            return null;

        }

  

        /// <summary>

        /// Return the model element which is the parent of the specified model element considering that

        /// this element is placed in a compartment.

        /// </summary>

        /// <param name="modelElement">The model element whose parent will be returned.</param>

        /// <returns>

        /// The model element which is the parent of the specified model element considering that

        /// this element is placed in a compartment.

        /// </returns>

        private static ModelElement GetCompartmentElementFirstParent(ModelElement modelElement)

        {

            // Get the domain class associated with model element.

  

            DomainClassInfo domainClass = modelElement.GetDomainClass();

            if (domainClass != null)

            {

                // A element is only considered to be in a compartment if it participates in only 1 embedding relationship

                // This might be wrong for some models

  

                if (domainClass.AllEmbeddedByDomainRoles.Count == 1)

                {

                    // Get a collection of all the links to this model element

                    // Since this is in a compartment there will only be one

  

                    ReadOnlyCollection<ElementLink> links = DomainRoleInfo.GetAllElementLinks(modelElement);

                    if (links.Count == 1)

                    {

                        // Get the model element participating in the link that isn't the current one

                        // That will be the parent

                        // Probably there is a better way to achieve the same result

  

                        foreach (ModelElement linkedElement in links[0].LinkedElements)

                        {

                            if (!modelElement.Equals(linkedElement))

                            {

                                return linkedElement;

                            }

                        }

                    }

                }

            }

  

            // Default result

  

            return null;

        }

  

        #endregion

  

        #region Event Handlers

  

        private void ObjectModelBrowser_DoubleClick(object sender, EventArgs e)

        {

            // Get the node selected in the model explorer tree

  

            ModelElementTreeNode node = (this.ObjectModelBrowser.SelectedNode as ModelElementTreeNode);

            if (node != null)

            {

                // Get the corresponding model element

  

                ModelElement element = node.ModelElement;

                if (element != null)

                {

                    // Get the corresponding shape

                    // If the model element is in a compartment the result will be null

  

                    ShapeElement shape = GetModelElementFirstShape(element);

                    if (shape == null)

                    {

                        // If the element is in a compartment, try to get the parent model element to select that

  

                        ModelElement parentElement = GetCompartmentElementFirstParent(element);

                        if (parentElement != null)

                        {

                            // Get the corresponding shape

  

                            shape = GetModelElementFirstShape(parentElement);

                        }

                    }

  

                    // Select the shape

  

                    if (shape != null)

                    {

                        SelectShape(shape, this.ModelingDocData);

                    }

                }

            }

        }

  

        #endregion

    }

}

Special thanks are in order to Oleg Sych for his fundamental tips to get this working.

Agile Prototyping

hgr — Thu, 11 Dec 2008 11:28:40 GMT

One of these days I went for a periodic review meeting of the project I'm working on. We were going to discuss the implementation of a critical piece for our next major milestone.

We invited our User Experience Specialist and he was going to present us the first UI prototypes.

I was expecting some great WPF "almost-ready" screens with great user experience stuff and a wonderful look-and-feel like all the other prototypes they did before...

This was what I got to see:

Now talk about agile prototyping. :)

DSL Tools #13 - Changing the Appearance of a Shape at Runtime

hgr — Thu, 30 Oct 2008 17:43:24 GMT

Finally I found some time to document this simple customization to the DSL Tools designers.

The requirement is as follows:

I have a given domain class - called Module Reference - that has a property called Main.
This domain property indicates if that particular class is the "most important" of that kind in the model.
This domain class as an association with another domain class - called Entity. That association allows me to connect multiple entities to any given module reference.
All the entities connected to the main module reference need to presented with a different color (different from the default shape color defined in the DSL definition model).

The domain model is the following:

Achieving this is quite simple:

1. Create a change rule to respond to the change in the Main property of the ModuleReference domain class:

        1: using System;

       2: using Microsoft.VisualStudio.Modeling;

       3: using Microsoft.VisualStudio.Modeling.Diagrams;

       4:  

       5: namespace MyModel

       6: {

       7:     /// <summary>

       8:     /// Defines a change rule for the ModuleReference domain class.

       9:     /// </summary>

    [RuleOn(typeof(Primavera.Athena.Models.Reporting.ModuleReference), FireTime = TimeToFire.TopLevelCommit)]

    public class ModuleReferenceChangeRule : ChangeRule

    {

        #region Public Methods

  

        /// <summary>

        /// Alerts listeners that a property for an element has changed.

        /// </summary>

        /// <param name="e">Provides data for the ElementPropertyChanged event.</param>

        public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e)

        {

            // Validations

  

            if (e == null)

            {

                throw new ArgumentNullException("e");

            }

  

            if (e.DomainProperty.Id.Equals(ModuleReference.MainDomainPropertyId))

            {

                HandleMainChanged(e);

            }

  

            // Default behavior

  

            base.ElementPropertyChanged(e);

        }

        

        #endregion

  

        #region Private Methods

  

        /// <summary>

        /// Handles changes in Main.

        /// </summary>

        /// <param name="e">The <see cref="Microsoft.VisualStudio.Modeling.ElementPropertyChangedEventArgs"/> instance containing the event data.</param>

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")]

        private void HandleMainChanged(ElementPropertyChangedEventArgs e)

        {

            // Something changed?

  

            if (!e.OldValue.Equals(e.NewValue))

            {

                // Get the current shape

  

                ModuleReference moduleReference = e.ModelElement as ModuleReference;

                if (moduleReference != null)

                {

                    // Update all entities colors

  

                    foreach (Entity entity in moduleReference.Entities)

                    {

                        LinkedElementCollection<PresentationElement> presentations =

                            PresentationViewsSubject.GetPresentation(entity);

                        EntityShape entityShape = null;

  

                        if (presentations.Count > 0)

                        {

                            entityShape = presentations[0] as EntityShape;

                        }

  

                        if (entityShape != null)

                        {

                            entityShape.UpdateMainModuleReferencePresentation((bool)e.NewValue);

                        }

                    }

                }

            }

        }

  

        #endregion

    }

}

Note: I first find all the EntityShape instances that are connected with the current ModuleReference and then call the UpdateMainModuleReferencePresentation passing in the new value of the Main property.

2. Register this change rule:

       1: using System;

       2:  

       3: namespace MyModel

       4: {

       5:     /// <summary>

       6:     /// Custom ReportingModel domain model methods.

       7:     /// </summary>

       8:     public partial class ReportingModelDomainModel

       9:     {

      10:         #region Protected Methods

      11:  

      12:         /// <summary>

      13:         /// Returns the non-generated domain model types.

      14:         /// </summary>

      15:         /// <returns>An array of types.</returns>

      16:         protected override Type[] GetCustomDomainModelTypes()

      17:         {

      18:             // Return the rules that should be evaluated for

      19:             // the model

      20:  

      21:             return new System.Type[] 

      22:             {

      23:                 typeof(AssociationConnectorChangeRule), typeof(GenerateDefaultListChangeRule), typeof(ModuleReferenceChangeRule)

      24:             };

      25:         }

      26:  

      27:         #endregion

      28:     }

      29: }

3. Create a new partial class for the EntityShape class and implement the UpdateMainModuleReferencePresentation method:

       1: using System;

       2: using System.Drawing;

       3: using Microsoft.VisualStudio.Modeling.Diagrams;

       4:  

       5: namespace MyModel

       6: {

       7:     /// <summary>

       8:     /// Provides custom code for the EntityShape domain class.

       9:     /// </summary>

    public partial class EntityShape

    {

        #region Internal Methods

  

        /// <summary>

        /// Updates the entity presentation to reflect if the corresponding module reference is the main.

        /// </summary>

        /// <param name="moduleRefereceIsMain">A boolean that indicates if the entity is associated with the main module.</param>

        internal void UpdateMainModuleReferencePresentation(bool moduleRefereceIsMain)

        {

            StyleSet style = this.StyleSet;

            BrushSettings brush = style.GetOverriddenBrushSettings(DiagramBrushes.ShapeBackground);

            if (brush == null)

            {

                brush = new BrushSettings();

            }

  

            if (moduleRefereceIsMain)

            {

                brush.Color = Color.FromKnownColor(KnownColor.CadetBlue);

            }

            else

            {

                brush.Color = Color.FromKnownColor(KnownColor.Lavender);

            }

  

            style.OverrideBrush(DiagramBrushes.ShapeBackground, brush);

        }

  

        #endregion

    }

}

That's it.

Visual Studio 2008 SP1, TFS, and the Experimental Hive

hgr — Wed, 29 Oct 2008 19:28:35 GMT

Every once in a while I enter the nightmare of formatting my development machine. :)

This time my "wonderful nightmare" was getting Visual Studio 2008 SP1 and the Experimental Hive (for my DSL Tools developments) working correctly (with TFS Team Explorer and TFS Source Control working on the Experimental Hive).

In the end, I think that now I would do it correctly. For the sake of documenting the procedure and the potential problems, here it is:

Install Visual Studio 2008 Team System Development Edition
Install Visual Studio 2008 Team Explorer (from the same CD)
Install Visual Studio 2008 SP1
Install Visual Studio 2008 SDK SP1

If I had followed these steps probably I wouldn't have bumped into a set of problems. But, just in case, if you find any of these difficulties after installing all these pieces, here are (possible) solutions...

If you get an WorkItemDeniedOrNotExistsException exception when editing TFS work items:

TFS Team Explorer was probably installed after VS 2008 SP1. Simply reinstall SP1 and it will work.

Reference: http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=3380330&SiteID=1

If TFS Team Explorer and Source Control are not available in the Experimental Hive:

There was something wrong with your VS 2008 installation when you installed the SDK. Resetting the Experimental Hive will probably correct the problem. Just point to All Programs \ Microsoft Visual Studio 2008 SDK \ Tools \ Reset the Visual Studio 2008 Experimental Hive.

Reference: http://social.msdn.microsoft.com/Forums/en-US/vsx/thread/b071f63c-e6eb-4ce3-844f-b9345aaf4dec/

If you build a DSL Tools solution and the designer is still not available in the Experimental Hive

Your package was not registered when you built the DSL tools project. Edit the DSLPackage project file and make sure the following piece is set to true:

Hope this helps someone out there.

NHibernate and Row Versions (Insert/Update Records)...

hgr — Thu, 09 Oct 2008 16:10:23 GMT

I don't like NHibernate! As I use it more and more, I come to terms with this fact and with the fact that I need to find a way to remove it from my projects. :)

My last problem was managing a master/detail/detail relation and making NHibernate insert and/or update the detail records independently from the value of the primary key (which is a Guid).

How? The documentation simply sucks!!! The web site sucks even more!!!

In the end someone had this same problem in the past and found the solution:

When Flushing Goes Bad: Assigned IDs in NHibernate

Note: I preferred a slightly different solution using an Int32 version attribute.

Google is a wonderful thing! :)