I started by creating a simple WCF service with the following interface:
[ServiceContract]
public interface ICatalog
{
[OperationContract]
[WebGet(ResponseFormat = WebMessageFormat.Json, BodyStyle = WebMessageBodyStyle.Bare)]
List GetCatalog(int cid);
}
What enables the service to serve Json output is in the WebGet attribute, the ResponseFormat property that states that we will use Json in the response and the BodyStyle property that in my case states that we will use a bare Json response.

The implementation of the interface ICatalog looks in my example like this:
public class Catalog : ICatalog
{
public List GetCatalog(int cid)
{
var l = new List();
What this code does is rather self explanatory, I just retrieves some categories and products from a database, in this case a MySql database, and from the result that I get I create a list of objects containing a couple of child items.

try
{
var sql = “SELECT categoryid, categoryname ” +
“FROM mod_katalog_config”;
var constr = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
var dr = MySqlHelper.ExecuteReader(constr, sql);

if (dr.HasRows)
{
while (dr.Read())
{
var c = new CategoryData
{
CategoryId = int.Parse(dr["categoryid"].ToString()),
CategoryName = dr["categoryname"].ToString(),
CatalogItems = new List()
};
var csql = “select id, name from mod_catalog_products where categori_id = ” + c.CategoryId;
var drc = MySqlHelper.ExecuteReader(constr, csql);
if (drc.HasRows)
{
while (drc.Read())
{
c.CatalogItems.Add
(
new CatalogData
{
ProductId = int.Parse(drc["id"].ToString()),
ProductName = drc["name"].ToString()
}
);
}
}
l.Add(c);
}
}
}
catch (Exception)
{

l.Add
(
new CategoryData
{
CategoryId = 0,
CategoryName = “No items found”,
CatalogItems = new List()
}
);
}

return l;
}
}

[DataContract]
public class CatalogData
{
[DataMember]
public int ProductId { get; set; }
[DataMember]
public string ProductName { get; set; }
}

[DataContract]
public class CategoryData
{
[DataMember]
public int CategoryId { get; set; }
[DataMember]
public string CategoryName { get; set; }
[DataMember]
public List CatalogItems { get; set; }
}

To be able to use this service I also had to change some of the default behaviors that are created for my service in the web.config, namely I had to add a endpoint behavior which I called JsonBehavior and which contained just one child tag stating webHttp and I used that behavior in my endpoint entry in the services part of the web.config.

The jQuery part in the web page is according to this:

$().ready(function() {
$.getJSON("Catalog.svc/GetCatalog", function(data) {
$.each(data, function(i, data) {
var create = '';
$.each(data.CatalogItems, function(j, item) {
create += '' + item.ProductName + '';
});
create += '';
$("#categorylist").append(create);
});
}
);
$("#categorylist").change(function() {
document.location.href = "/se/courses.aspx?product_id=" + $("#categorylist").val();
});
});

and what this really does is that it retrieves tha data in the form of an ordinary list of objects, and iterates over each of the items and in turn picks out the corresponding child items that they consist of and creates a string that will be appended to the select box that is named categorylist.

Not a thorough post I know but

System.ArgumentException : Column ‘Reserved Word’ does not belong to table ReservedWords.

After some searching and digging I found that this was a common problem when upgrading to the newer versions of the MySQL .NET Connectors and the cause seemed to be that the implementation of the DbConnection.GetSchema in the System.Data.Common namespace that is used when creating .NET connectors isn’t all that clear in MSDN and MySQL had changed their own implementation.

This change caused the exception in NHibernate because in the MySQLMetaData.cs the column name is reference by a hard coded string and thus resulted in a miss match between the column names. Here is the code that caused the problem:

public override ISet<string> GetReservedWords()
  {
   var result = new HashedSet<string>();
   DataTable dtReservedWords = Connection.GetSchema(DbMetaDataCollectionNames.ReservedWords);
   foreach (DataRow row in dtReservedWords.Rows)
   {
    result.Add(row["Reserved Word"].ToString());
   }
   return result;
  }

Looking into how the MySQL team had implemented their connector and how NHibernate works and also searching through the documentation for the System.Data.Common namespace I propose a solution to this problem by using a similar approach as when calling the GetSchema with the static DbMetaDataCollectionNames.ReservedWords parameter and use the also static DbMetaDataColumnNames.ReservedWord when retrieving the reserved words column, resulting in the following:

public override ISet<string> GetReservedWords()
{
    var result = new HashedSet<string>();
    DataTable dtReservedWords = Connection.GetSchema(DbMetaDataCollectionNames.ReservedWords);

    foreach (DataRow row in dtReservedWords.Rows)
    {
        result.Add(row[DbMetaDataColumnNames.ReservedWord].ToString());
    }
    return result;
}

I have tested this solution against NHibernate 2.1.0.GA with the MySQL connectors 5.1.7, 5.2.7 and 6.0.4 and they seems to play nice with this update. See the issue here: http://nhjira.koah.net/browse/NH-1906

I’m using MySql in a lot of my projects and because of that I’m facing the problem with the MySqlDateTime object, which not always plays so nice with .Net as you would like it to. This example is about the automapping feature of FluentNHibernate and the problem that arises when you try to map a MySqlDateTime field, and then gets an Exception because this cant be converted directly into an DateTime object, or actually it can but in some cases MySql uses 0000-00-00 00:00:00 as a default value for the DateTime field and then you get a crash.

The solution

NHibernate has a very nice feature that save the day in this case, it is the IUserType that enabled you to create your own types that can be used in the mapping process. The IUserType that I’m using to solve the MySqlDateTime problem looks like this:

using System;
using System.Data;
using MySql.Data.Types;
using NHibernate.UserTypes;

namespace Project.Core.UserType
{
    public class MySqlDateTimeType : IUserType
    {
        public new bool Equals(object x, object y)
        {
            if (x == null && y == null)
                return true;
            if (x != null)
                return x.Equals(y);
            return y.Equals(x);
        }

        public int GetHashCode(object x)
        {
            return x.GetHashCode();
        }

        public object NullSafeGet(IDataReader rs, string[] names, object owner)
        {
            if (names.Length == 1)
            {
                object obj = rs[names[0]];

                if (null == obj || obj is DBNull)
                    return new DateTime?();

                if (obj is MySqlDateTime)
                {
                    var mySqlDateTime = (MySqlDateTime)obj;
                    if (mySqlDateTime.IsNull)
                        return new DateTime?();
                    if (0 == mySqlDateTime.Day || 0 == mySqlDateTime.Month || 0 == mySqlDateTime.Year)
                        return new DateTime?();
                    return mySqlDateTime.GetDateTime();
                }
                if (obj is DateTime)
                    return (DateTime)obj;

                throw new InvalidCastException(“Can not convert object of type ” +
                    obj.GetType().FullName + ” to ” + typeof(MySqlDateTime?).FullName);
            }
            throw new InvalidCastException(“Single column expected.”);

        }

        public void NullSafeSet(IDbCommand cmd, object value, int index)
        {
           var param = cmd.Parameters[index] as IDataParameter;

            if (param != null)
            {
                param.DbType = DbType.DateTime;

                if (null == value)
                {
                    param.Value = DBNull.Value;
                }
                else if (value is MySqlDateTime)
                {
                    var mySqlDateTime = (MySqlDateTime)value;
                    if (mySqlDateTime.IsNull)
                        param.Value = DBNull.Value;
                    else
                        param.Value = mySqlDateTime.GetDateTime();
                }
                else if (value is DateTime)
                {
                    param.Value = value;
                }
            }

            if (value != null)
                throw new ArgumentException(“Object of type ” + typeof(MySqlDateTime).FullName +
                                            ” expected, but object of type ” + value.GetType().FullName + ” has been passed.”);
        }

        public object DeepCopy(object value)
        {
            return value;
        }

        public object Disassemble(object value)
        {
            return DeepCopy(value);
        }
        public bool IsMutable
        {
            get { return false; }
        }

        public object Assemble(object cached, object owner)
        {
            return DeepCopy(cached);
        }

        public object Replace(object original, object target, object owner)
        {
            return original;
        }

        public Type ReturnedType
        {
            get
            {
                return typeof(DateTime?);
            }
        }

        public NHibernate.SqlTypes.SqlType[] SqlTypes
        {
            get
            {
                return new[] { NHibernate.NHibernateUtil.DateTime.SqlType };
            }
        }

    }
}

And what this really does is that when you mapps your MySqlDateTime field to a DateTime property it just converts it for you without any hassle even when you are faced with a 0000-00-00 00:00:00 default value!

To use this in your automapping you have to tell FluentNHibernate how to use it and this can be done by creating a UserTypeConvention like this:

using System;
using FluentNHibernate.Conventions;
using Roomservice.Citybreak.Core.UserType;

namespace Project.Core.Infrastructure.Convention
{
    class MySqlDateTimeTypeConvention : UserTypeConvention<MySqlDateTimeType>
    {
        public override bool Accept(Type type)
        {
            return type == typeof (DateTime);
        }

        public override void Apply(FluentNHibernate.Mapping.IProperty target)
        {
            target.CustomTypeIs<MySqlDateTimeType>();
        }
    }
}

and when you configure your mapping you can add the following to your persistence model:

ConventionDiscovery.Setup(s => { s.Add<MySqlDateTimeTypeConvention>(); }

After a lot of searching I found out that it was a simple problem with the CSS that is beeing used when rendering the default XP-theme, and more precise it was this entry in the Tabs.css that caused the strange behaviour:

.ajax__tab_tab {height:13px;padding:4px;margin:0;background:url(<%=WebResource(“AjaxControlToolkit.Tabs.tab.gif”)%>) repeat-x;}

the height of 13px is what is causing the problem since the tab is in fact 21px high and because of that the image in the tab is misplaced. To solve this problem you can correct this by changing the height to 21px and recompile the toolkit or just use you own style with the TabContainer.

I tried to apply the ordinary output caching as I’m used to in ASP.NET but found out that it wasn’t really working as I wanted and in this special case I also wanted to use partial content rendering in my application, fortunatelly I found an excellent blog post by Steve Sanderson which explained exactly what I needed, you can find the blog post here:

http://blog.codeville.net/2008/10/15/partial-output-caching-in-aspnet-mvc/

Thank you Steve, you really saved my day!

http://www.codeproject.com/KB/dotnet/mysqlnhibernate.aspx