When publishing a Web application like this, you will have your application divided in multiples assemblies, and of course it would be interesting to be able to set the version of each assembly so we can keep track of the release, and identify which versions are deployed on a client, however in Visual Studio there is no way to set the versions of an ASP.NET application assemblies, I searched for different ways to try to do this without any luck, until I found a little tool called ILMerge that allows merging assemblies, so I start digging into this and found the solution for what I wanted,  this tool also lets you apply the properties of one assembly into others, and that is when it hits me:

After publishing your Web site, I can merge the individual ASP.NET assemblies with “nothing” and provide a “dummy” assembly only with properties like version number, company, copyright. and stamp them into the original ASP.NET assembly. The result is the same assembly but with a version number!

To demonstrate this process Il will provide a step by step example:

Publish your Web site as updatable and check the  -use fixed names- option.

Inside the “bin” folder of your just published application  you will find the assemblies, for each assembly you want to version, follow the next steps:

Create an .cs file with the same name as your assembly, for example mypage_aspx_.dll, and enter the following code:

using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Windows;

// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("My App Title")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Cesar Intriago")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("Copyright © Cesar Intriago 2011")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

[assembly: AssemblyVersion("2.5.0.0")]
[assembly: AssemblyFileVersion("2.5.0.0")]

Now we are ready to stamp the above properties in our assemblies, the next step is to build that .cs code into an assembly:

csc.exe  /target:library /nologo /warn:0 mypage_aspx.cs

Move the resulting assembly into an “attributes” folder. Now we are ready to use ILMerge, we will merge only the original ASP.NET assembly into a new assembly with the same name inside a “versions” folder, and during this merge process we will apply the new assembly properties:

ilmerge.exe /attr:attributes\mypage_aspx.cs.dll

/target:library /ndebug /out: versions\mypage_aspx.cs.dll

mypage_aspx.cs.dll

The following image describes the meaning of each parameter:

This may be a cumbersome process, but it’s the way I found how to version an ASP.NET assembly, if you know another we will happy to hear it. The good news is that you can automate this process because it just uses command lines, you can even create a nice post-publish Visual Studio tool to mange and set the version of your Web Application.

ILMerge Download (from Microsoft):

http://www.microsoft.com/downloads/en/details.aspx?FamilyID=22914587-b4ad-4eae-87cf-b14ae6a939b0&displaylang=en

For daily tasks like Internet browsing, mail, music, chat, video, documents, photo editing, nothing beats the 27 inches display of the iMac.

Here you can see the current set up of my work environment. Now lets see what this new hardware can really do…

In fact, that is all I have for now, I’ll go back to continue reading that Twitter API stuff…

The Blog-Health-o-Meter™ reads Wow.

Crunchy numbers

The average container ship can carry about 4,500 containers. This blog was viewed about 19,000 times in 2010. If each view were a shipping container, your blog would have filled about 4 fully loaded ships.

In 2010, there were 4 new posts, growing the total archive of this blog to 12 posts. There were 2 pictures uploaded, taking up a total of 190kb.

The busiest day of the year was September 3rd with 409 views. The most popular post that day was ASP.NET MVC 101 Sheet.

Where did they come from?

The top referring sites in 2010 were refact.blogspot.com, elijahmanor.com, devcheatsheet.com, blog.pagesd.info, and blackout360.wordpress.com.

Some visitors came searching, mostly for asp.net mvc nhibernate, nhibernate asp.net mvc, mvc nhibernate, nhibernate mvc, and asp.net mvc 2 nhibernate.

Attractions in 2010

These are the posts and pages that got the most views in 2010.

ASP.NET MVC 101 Sheet November 2009
2 comments

Using ASP.NET MVC and NHibernate (Part 1) November 2009
7 comments

Using ASP.NET MVC and NHibernate (Part 3 – final) November 2009
3 comments

Using ASP.NET MVC and NHibernate (Part 2) November 2009
1 comment

Using ASP.NET MVC and Ajax to check names availability. October 2009
12 comments

Session[“Username”] = “cintriago”;

int hits = (int) Session[“HitCount”] ;

Session[“HitCount”] = hits +1;

The above example is a common code section that you would write in your application, but how would you like to write it like this:

Profile.Username = “cintriago”;

Profile.HitCount++;

What do you think? in ASP.NET you can use strongly typed properties to read and write data shared across a user’s session. How?, keep reading…

Using strongly typed properties  is actually not so difficult, and the best part is that we use ASP.NET framework functionality, specifically the “Profile” class (You can read more about ASP.NET Profile class here). ASP.NET uses the Profile class to save user’s specific data in SQL Server, but we can change the repository, in this case a static object!. We will use an example to illustrate how to do it:

Lets launch Visual Studio and create a new empty Web Site called “CustomASPNetProfile”, next add the “App_Code” special folder. Once ready lets create a repository  store the information we need (our Model), we will create 2 classes SessionProfile and SessionProfileData:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

public class SessionProfile
{
public SessionProfile()
{
Properties = new List<SessionProfileData>();
}

    public int ProfileId {get;set;}
public string Username {get;set;}
public string ApplicationName { get; set; }
public bool IsAnonymous { get; set; }
public DateTime LastActivity { get; set; }

    public List<SessionProfileData> Properties { get; set; }

}

public class SessionProfileData
{
public SessionProfileData()
{
}

    public object PropertyValue { get; set; }
public string PropertyName { get; set; }

}

The SessionProfile class represents each individual session in our application, that is why you can see a ProfileId property that uniquely identifies each object, we also store the Username and if the current user is logged in or not  (ASP.NET security integration!, aint that cool?).

The SessionProfileData class will keep a list of all the properties that we are going to use as strongly type accessors for our repository.

Now it is time to build our custom Profile provider class called SessionProfileProvider that will inherit the System.Web.ProfileProvider class. Our new class needs to implement some methods (many of them will not be used in this example), but before going into that, let’s create the static object that will keep users data in memory:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Profile;

/// <summary>
/// Summary description for SessionProfileProvider
/// </summary>
public class SessionProfileProvider : ProfileProvider
{
private static List<SessionProfile> m_profiles;

    public SessionProfileProvider()
{
//
// TODO: Add constructor logic here
//
}
}

In the above code, a “m_profiles” static member is created, we will use this object to read and write user data across the Web Site, let’s check the two main methods of this class: GetPropertyValues and SetPropertyValues

public override SettingsPropertyValueCollection GetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyCollection collection)
{
string username = context["UserName"].ToString();
string applicationName = (null != context["ApplicationName"] ? context["ApplicationName"].ToString() : String.Empty);
bool isAnonymous = bool.Parse(context["IsAuthenticated"].ToString());

        lock (m_profiles)
{
SessionProfile profile = m_profiles.Find(x => (x.Username == username)
&& (x.IsAnonymous == isAnonymous)
&& (x.ApplicationName == applicationName)
);

            SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();

            foreach (SettingsProperty prop in collection)
{
SessionProfileData profileProperty = null;
object value = null;

                if (profile != null)
profileProperty = profile.Properties.Find(x => x.PropertyName == prop.Name);

                if (profileProperty != null)
value = profileProperty.PropertyValue;

                SettingsPropertyValue p = new SettingsPropertyValue(prop);
Type propType = p.PropertyValue.GetType();

                if (propType == typeof(Int32) && value == null)
value = 0;

                if (propType == typeof(bool) && value == null)
value = false;

                p.PropertyValue = value;
values.Add(p);

            }

            return values;
}
}

In this method we iterate over the list of available properties (we will see how to dynamically define the list of available properties in the web.config file later) and for each one, get its corresponding value from the m_profiles list, finally a SettingsPropertyValueCollection object is returned with the properties and values.

Now let’s check the other method:

public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection collection)
{
string username = context["UserName"].ToString();
string applicationName = (null != context["ApplicationName"] ? context["ApplicationName"].ToString() : String.Empty);
bool isAnonymous = bool.Parse(context["IsAuthenticated"].ToString());
bool isNewProfile = false;

        lock (m_profiles)
{
SessionProfile profile = m_profiles.Find(x => (x.Username == username)
&& (x.IsAnonymous == isAnonymous)
&& (x.ApplicationName == applicationName)
);

            if (profile == null)
{
profile = new SessionProfile();
profile.Username = username;
profile.ApplicationName = applicationName;
profile.IsAnonymous = isAnonymous;
isNewProfile = true;
}

            foreach (SettingsPropertyValue prop in collection)
{
SessionProfileData profileProperty = profile.Properties.Find(x => x.PropertyName == prop.Name);
if (profileProperty != null)
{
profileProperty.PropertyValue = prop.PropertyValue;
}
else
{
profileProperty = new SessionProfileData();
profileProperty.PropertyValue = prop.PropertyValue;
profileProperty.PropertyName = prop.Name;
profile.Properties.Add(profileProperty);
}
}
if (isNewProfile)
m_profiles.Add(profile);
}
}

In the SetPropertyValues method we iterate again over the list of available properties, setting their values.

That is all the coding we need, now it is time to define which properties we want to use in the web.config file:

<!—This sets the custom profile provider –>
<anonymousIdentification enabled=”true”/>
<profile defaultProvider=”SessionProvider”>
<providers>
<add name=”SessionProvider” type=”SessionProfileProvider”/>
</providers>

        <properties>
<add name=”FavoriteColor” allowAnonymous=”true” type=”System.String”/>
<add name=”FavoriteName” allowAnonymous=”true” type=”System.String”/>
<add name=”UserInfo” allowAnonymous=”true” type=”PersonalData”/>
</properties>
</profile>

What we are doing in this XML section is:

1. Use our new Profile provider as the default ASP.NET Profile provider.

2. We add support for anonymous users

3. We define which properties can be used and its types, (Did you notice that we can even use custom classes like a “PersonalData” class:

public class PersonalData
{
public PersonalData()
{
}

    public string Firstname { get; set; }
public string Lastname { get; set; }

}

Now build your Web Site and create a new page, you will be able to get and set the values of your properties using the Profile class, you can add more properties to your web.config file and all you  need is to build the Web Site again:

public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Profile.FavoriteColor = “Red”;

        Response.Write(Profile.FavoriteColor);
}
}

I hope you have found this post interesting and useful, thanks for reading!. You can download the sample project here.

I was looking for a Superman wallpaper, but I couldn’t find the one I was looking for (either there is no wallpaper of Superman’s cape logo or I suck at google/bing), finally I did what any  developer would do in my place, I “build” my own wallpaper, I decided to share it with you.

I would like to share a few of my 2011 resolutions:

1. Return to bike trial.
2. Write more posts about ASP.NET, WPF and Silverlight.
3. Improve my cooking skills.

Stay tuned..

http://www.lostechies.com/blogs/hex/archive/2010/06/23/using-modelmetadata-in-asp-net-mvc-2-to-wire-up-sweet-jquery-awesomeness.aspx

Is this a problem with the theme of the blog?, do you know a better way to do it? thanks people. bye.

I’m using styles to insert the combobox inside the treeview:

   1: <Style x:Key="NavigationTreeViewItemStyle" TargetType="{x:Type TreeViewItem}">

   2:     <Setter Property="Background"

   3:         Value="Transparent"/>

   4:     <Setter Property="HorizontalContentAlignment"

   5:         Value="{Binding Path=HorizontalContentAlignment,

   6:                 RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}"/>

   7:     <Setter Property="VerticalContentAlignment"

   8:         Value="{Binding Path=VerticalContentAlignment,

   9:                 RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}"/>

  10:     <Setter Property="Padding"

  11:         Value="1,0,0,0"/>

  12:     <Setter Property="Foreground"

  13:         Value="{StaticResource NormalBrush}"/>

  14:     <Setter Property="FocusVisualStyle"

  15:         Value="{StaticResource TreeViewItemFocusVisual}"/>

  16:     <Setter Property="Template">

  17:       <Setter.Value>

  18:         <ControlTemplate TargetType="{x:Type TreeViewItem}">

  19:           <Grid>

  20:             <Grid.ColumnDefinitions>

  21:               <ColumnDefinition Width="12"/>                        

  22:               <ColumnDefinition Width="Auto"/>

  23:               <ColumnDefinition Width="20"/>

  24:             </Grid.ColumnDefinitions>

  25:             <Grid.RowDefinitions>

  26:               <RowDefinition Height="Auto"/>

  27:               <RowDefinition/>

  28:             </Grid.RowDefinitions>

  29:             <ToggleButton x:Name="Expander"

  30:                     Style="{StaticResource ExpandCollapseToggleStyle}"

  31:                     IsChecked="{Binding Path=IsExpanded,

  32:                                 RelativeSource={RelativeSource TemplatedParent}}"

  33:                     ClickMode="Press"/>

  34:             <Border Name="Bd"

  35:                 Grid.Column="1"

  36:                 Background="{TemplateBinding Background}"

  37:                 CornerRadius="4"

  38:                 BorderThickness="1">

  39:                 <ContentPresenter 

  40:                     Content="{Binding Header}"

  41:                     HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"

  42:                     VerticalAlignment="Center"

  43:                     Margin="5,0,8,0"/>

  44:             </Border>

  45:             <ComboBox 

  46:                 x:Name="cbOptions"

  47:                 Grid.Column="2"

  48:                 Visibility="Hidden"

  49:                 IsTabStop="False"

  50:                 ItemsSource="{Binding MenuItems}"/>

  51:             <ItemsPresenter x:Name="ItemsHost"

  52:                     Grid.Row="1"

  53:                     Grid.Column="1"

  54:                     Grid.ColumnSpan="2" />                    

  55:           </Grid>

  56:           <ControlTemplate.Triggers>

  57:             <Trigger Property="IsExpanded"

  58:                  Value="false">

  59:               <Setter TargetName="ItemsHost"

  60:                   Property="Visibility"

  61:                   Value="Collapsed"/>

  62:             </Trigger>

  63:             <Trigger Property="HasItems"

  64:                  Value="false">

  65:               <Setter TargetName="Expander"

  66:                   Property="Visibility"

  67:                   Value="Hidden"/>

  68:             </Trigger>

  69:         

  70:             <Trigger Property="IsSelected"

  71:                  Value="true">

  72:               <Setter TargetName="Bd" Property="Background" Value="{StaticResource SelectedBackgroundBrush}"/>

  73:               <Setter TargetName="Bd" Property="BorderBrush" Value="{StaticResource SelectedBackgroundBrush}"/>

  74:               <Setter Property="Foreground" Value="{StaticResource SelectedBrush}"/>

  75:               <Setter TargetName="cbOptions" Property="Visibility" Value="{Binding MenuVisibility}"/>

  76:             </Trigger>

  77:  

  78:             

  79:             <Trigger Property="IsEnabled"

  80:                  Value="false">

  81:               <Setter Property="Foreground"

  82:                   Value="{StaticResource DisabledForegroundBrush}"/>

  83:             </Trigger>

  84:           </ControlTemplate.Triggers>

  85:         </ControlTemplate>

  86:       </Setter.Value>

  87:     </Setter>

  88:   </Style>

And binding content of menu from code-behind.

   1: NavigationItem root = new NavigationItem();

   2:  

   3:             NavigationItem mainNode = new NavigationItem("ForerunnerG34");

   4:  

   5:             NavigationItem child = new NavigationItem("Technologies");

   6:             child.MenuItems.Add(new NavigationCommand("ASP.NET MVC 2", "Model View Controller"));

   7:             child.MenuItems.Add(new NavigationCommand("Windows Presentation Foundation", "WPF Rocks!"));

   8:             child.MenuItems.Add(new NavigationCommand("Silverlight","Light the Web"));

   9:  

  10:             NavigationItem child2 = new NavigationItem("My Blogs");

  11:             child2.MenuItems.Add(new NavigationCommand("ForerunnerG34", "forerunnerg34.wordpress.com"));

  12:             child2.MenuItems.Add(new NavigationCommand("Blackout360", "blackout360.wordpress.com"));

  13:  

  14:             mainNode.Items.Add(child2);

  15:             mainNode.Items.Add(child);

  16:             

  17:             commandMenu.DataContext = root;

This a little example of the things you can do with WPF, I hope you find this interesting and encourage you to use WPF in your applications, basically if you can dream it, you can build it.

Download Source Code