Development With A Dot

Changing a Control’s Output Dynamically

Ricardo Peres — Sat, 04 Feb 2012 21:18:12 GMT

A question that pops up occasionally in ASP.NET forums or sites like Stack Overflow is how to change a control’s output dynamically. Well, since the CSS Friendly Control Adapters came out, I knew how to do it statically, through static registration on a .browser file (it can also be done dynamically, for all controls of a certain type, by adding a fully qualified type name to HttpContext.Current.Request.Browsers.Adapters collection), but I decided to go and try to do it dynamically, without registration. More specifically, I wanted to achieve two things:

Apply a XSL transformation to the generated output, provided it is XML-compliant;
Change the output through code in an event handler-like fashion.

So, here’s what I came up with:

        1: <%@ Register Assembly="WebApplication1" Namespace="WebApplication1" TagPrefix="web" %>

       2: ...

       3: <web:OutputAdapterControl runat="server" TargetControlID="table" OnOutput="OnOutput" XslPath="~/table.xsl" />

       4:  

       5: <asp:Table runat="server" ID="table"/>

I have two control declarations, one is for a well known asp:Table, and the other is for my OutputAdapterControl. On its declaration, I have a property that references the asp:Table through its id, one property for an external XSL transformation file and the final one for registering an event handler.

The code for the OutputAdapterControl is:

       1: namespace WebApplication1

       2: {

       3:     [NonVisualControl]

       4:     public class OutputAdapterControl : Control

       5:     {

       6:         private static readonly FieldInfo occasionalFieldsField = typeof(Control).GetField("_occasionalFields", BindingFlags.NonPublic | BindingFlags.Instance);

       7:         private static readonly FieldInfo flagsField = typeof(Control).GetField("flags", BindingFlags.NonPublic | BindingFlags.Instance);

       8:  

       9:         public OutputAdapterControl()

        {

            this.Enabled = true;

        }

  

        public String XslPath

        {

            get;

            set;

        }

  

        public String TargetControlID

        {

            get;

            set;

        }

  

        public Boolean Enabled

        {

            get;

            set;

        }

  

        public event EventHandler<OutputEventArgs> Output;

  

        private ControlAdapter getControlAdapter(Control control)

        {

            Object flags = flagsField.GetValue(control);

            MethodInfo setMethod = flags.GetType().GetMethod("Set", BindingFlags.NonPublic | BindingFlags.Instance);

            setMethod.Invoke(flags, new Object[] { 0x8000 });

  

            Object occasionalFields = occasionalFieldsField.GetValue(control);

            FieldInfo rareFieldsField = occasionalFields.GetType().GetField("RareFields");

            Object rareFields = rareFieldsField.GetValue(occasionalFields);

  

            if (rareFields == null)

            {

                rareFields = FormatterServices.GetUninitializedObject(rareFieldsField.FieldType);

                rareFieldsField.SetValue(occasionalFields, rareFields);

            }

  

            FieldInfo adapterField = rareFields.GetType().GetField("Adapter");

            ControlAdapter adapter = adapterField.GetValue(rareFields) as ControlAdapter;

  

            return (adapter);

        }

  

        private void setControlAdapter(Control control, ControlAdapter controlAdapter)

        {

            Object occasionalFields = occasionalFieldsField.GetValue(control);

            FieldInfo rareFieldsField = occasionalFields.GetType().GetField("RareFields");

            Object rareFields = rareFieldsField.GetValue(occasionalFields);

            FieldInfo adapterField = rareFields.GetType().GetField("Adapter");

            adapterField.SetValue(rareFields, controlAdapter);

        }

  

        internal void RaiseOutputEvent(OutputEventArgs e)

        {

            if (this.Output != null)

            {

                this.Output(this, e);

            }

        }

  

        protected override void OnPreRender(EventArgs e)

        {

            if ((this.Enabled == true) && (String.IsNullOrWhiteSpace(this.TargetControlID) == false))

            {

                Control control = this.FindControl(this.TargetControlID);

                ControlAdapter controlAdapter = this.getControlAdapter(control);

                OutputAdapterControlAdapter newAdapter = new OutputAdapterControlAdapter(this, controlAdapter, control, this.XslPath);

  

                this.setControlAdapter(control, newAdapter);

            }

  

            base.OnPreRender(e);

        }

    }

}

And the code for the control adapter is:

       1: namespace WebApplication1

       2: {

       3:     public class OutputAdapterControlAdapter : ControlAdapter

       4:     {

       5:         private static readonly FieldInfo controlField = typeof(ControlAdapter).GetField("_control", BindingFlags.NonPublic | BindingFlags.Instance);

       6:         private static readonly MethodInfo controlRenderMethod = typeof(Control).GetMethod("Render", BindingFlags.NonPublic | BindingFlags.Instance);

       7:         private static readonly MethodInfo controlAdapterRenderMethod = typeof(ControlAdapter).GetMethod("Render", BindingFlags.NonPublic | BindingFlags.Instance);

       8:  

       9:         public OutputAdapterControlAdapter(OutputAdapterControl outputControl, ControlAdapter original, Control control, String xslPath)

        {

            this.OutputControl = outputControl;

            this.Original = original;

            this.XslPath = xslPath;

            controlField.SetValue(this, control);

        }

  

        protected OutputAdapterControl OutputControl

        {

            get;

            private set;

        }

  

        protected String XslPath

        {

            get;

            private set;

        }

  

        protected ControlAdapter Original

        {

            get;

            private set;

        }

  

        protected override void Render(HtmlTextWriter writer)

        {

            StringBuilder builder = new StringBuilder();

            HtmlTextWriter tempWriter = new HtmlTextWriter(new StringWriter(builder));

  

            if (this.Original != null)

            {

                controlAdapterRenderMethod.Invoke(this.Original, new Object[] { tempWriter });

            }

            else

            {

                controlRenderMethod.Invoke(this.Control, new Object[] { tempWriter });

            }

  

            if (String.IsNullOrWhiteSpace(this.XslPath) == false)

            {

                String path = HttpContext.Current.Server.MapPath(this.XslPath);

  

                XmlDocument xml = new XmlDocument();

                xml.LoadXml(builder.ToString());

  

                builder.Clear();

  

                XslCompiledTransform xsl = new XslCompiledTransform();

                xsl.Load(path);

                xsl.Transform(xml, null, tempWriter);

            }

  

            OutputEventArgs e = new OutputEventArgs() { Html = builder.ToString() };

  

            this.OutputControl.RaiseOutputEvent(e);

  

            if (e.Html != builder.ToString())

            {

                builder.Clear();

                builder.Append(e.Html);

            }

  

            writer.Write(builder.ToString());

        }

    }

}

Finally there’s the event argument:

       1: namespace WebApplication1

       2: {

       3:     [Serializable]

       4:     public class OutputEventArgs : EventArgs

       5:     {

       6:         public String Html

       7:         {

       8:             get;

       9:             set;

      10:         }

      11:     }

      12: }

And a sample event handler:

       1: protected void OnOutput(object sender, OutputEventArgs e)

       2: {

       3:     e.Html = e.Html.ToUpper();

       4: }

Please note that this relies heavily on reflection, and, for that matter, will only work with ASP.NET 4.0. It can be made to work with ASP.NET 2/3.5, but you will have to change the code to get to the stored control adapter in the Control class. Thanks to João Angelo for reminding me of that!

If you look at it carefully, you will see that, if an XSL transformation file is specified, the control adapter will use it to transform the output of the target control. Either way, if an event handler is registered, it will raise the event, passing in the event argument the HTML generated by the target control, possibly modified by the XSL transformation. In the event handler, all you have to do is change the Html property of the event argument.

Let me know if this helps in some way, and have fun!

NHibernate Metadata

Ricardo Peres — Thu, 02 Feb 2012 10:07:38 GMT

I know that O/RMs like NHibernate are supposed to shield us from the gory database internals such as tables, views, columns and such; however, at times, I do have the need to know how my domain model translates to the database. NHibernate, of course, provides us with the information we need, but it isn’t always easy to find, so I wrote my own extension methods for ISessionFactory that allow me to get the metadata I need in an easy way:

        1: public static IEnumerable<PropertyInfo> GetComponents(this ISessionFactory sessionFactory, Type entityType)

       2: {

       3:     String entityName = (sessionFactory as ISessionFactoryImplementor).TryGetGuessEntityName(entityType);

       4:     IClassMetadata metadata = sessionFactory.GetClassMetadata(entityName);

       5:  

       6:     for (Int32 i = 0; i < metadata.PropertyTypes.Length; ++i)

       7:     {

       8:         IType property = metadata.PropertyTypes[i];

       9:  

        if (property is ComponentType)

        {

            String propertyName = metadata.PropertyNames[i];

            yield return (entityType.GetProperty(propertyName));

        }

    }

}

  

public static IEnumerable<PropertyInfo> GetUserTypes(this ISessionFactory sessionFactory, Type entityType)

{

    String entityName = (sessionFactory as ISessionFactoryImplementor).TryGetGuessEntityName(entityType);

    IClassMetadata metadata = sessionFactory.GetClassMetadata(entityName);

  

    for (Int32 i = 0; i < metadata.PropertyTypes.Length; ++i)

    {

        IType property = metadata.PropertyTypes[i];

  

        if (property is CustomType)

        {

            String propertyName = metadata.PropertyNames[i];

            yield return (entityType.GetProperty(propertyName));

        }

    }

}

  

public static IEnumerable<PropertyInfo> GetProperties(this ISessionFactory sessionFactory, Type entityType)

{

    String entityName = (sessionFactory as ISessionFactoryImplementor).TryGetGuessEntityName(entityType);

    IClassMetadata metadata = sessionFactory.GetClassMetadata(entityName);

    

    for (Int32 i = 0; i < metadata.PropertyTypes.Length; ++i)

    {

        IType property = metadata.PropertyTypes[i];

  

        if (!(property is OneToOneType) && !(property is ManyToOneType) && !(property is ComponentType))

        {

            String propertyName = metadata.PropertyNames[i];

            yield return (entityType.GetProperty(propertyName));                    

        }

    }

}

  

public static IEnumerable<PropertyInfo> GetAssociations(this ISessionFactory sessionFactory, Type entityType)

{

    String entityName = (sessionFactory as ISessionFactoryImplementor).TryGetGuessEntityName(entityType);

    IClassMetadata metadata = sessionFactory.GetClassMetadata(entityName);

  

    for (Int32 i = 0; i < metadata.PropertyTypes.Length; ++i)

    {

        IType property = metadata.PropertyTypes[i];

  

        if (property is OneToOneType)

        {

            String propertyName = metadata.PropertyNames[i];

            yield return (entityType.GetProperty(propertyName));

        }

        else if (property is ManyToOneType)

        {

            String propertyName = metadata.PropertyNames[i];

            yield return (entityType.GetProperty(propertyName));

        }

    }

}

  

public static PropertyInfo GetIdentifier(this ISessionFactory sessionFactory, Type entityType)

{

    String entityName = (sessionFactory as ISessionFactoryImplementor).TryGetGuessEntityName(entityType);

    AbstractEntityPersister persister = (sessionFactory as ISessionFactoryImplementor).TryGetEntityPersister(entityName) as AbstractEntityPersister;

  

    if (persister != null)

    {

        return (entityType.GetProperty(persister.IdentifierPropertyName));

    }

    else

    {

        return (null);

    }

}

  

public static IEnumerable<String> GetIdentifierColumnNames(this ISessionFactory sessionFactory, Type entityType)

{

    String entityName = (sessionFactory as ISessionFactoryImplementor).TryGetGuessEntityName(entityType);

    AbstractEntityPersister persister = (sessionFactory as ISessionFactoryImplementor).TryGetEntityPersister(entityName) as AbstractEntityPersister;

  

    if (persister != null)

    {

        return (persister.IdentifierColumnNames);

    }

    else

    {

        return (null);

    }

}

  

public static String GetColumnName(this ISessionFactory sessionFactory, Type entityType, String propertyName)

{

    String entityName = (sessionFactory as ISessionFactoryImplementor).TryGetGuessEntityName(entityType);

    AbstractEntityPersister persister = (sessionFactory as ISessionFactoryImplementor).TryGetEntityPersister(entityName) as AbstractEntityPersister;

  

    if (persister != null)

    {

        return (persister.GetPropertyColumnNames(propertyName).SingleOrDefault());

    }

    else

    {

        return (null);

    }

}

  

public static String GetTableName(this ISessionFactory sessionFactory, Type entityType)

{

    String entityName = (sessionFactory as ISessionFactoryImplementor).TryGetGuessEntityName(entityType);

    AbstractEntityPersister persister = (sessionFactory as ISessionFactoryImplementor).TryGetEntityPersister(entityName) as AbstractEntityPersister;

  

    if (persister != null)

    {

        return (persister.TableName);

    }

    else

    {

        return (null);

    }

}

  

public static IEnumerable<PropertyInfo> GetCollections(this ISessionFactory sessionFactory, Type entityType)

{

    String entityName = (sessionFactory as ISessionFactoryImplementor).TryGetGuessEntityName(entityType);

    IClassMetadata metadata = sessionFactory.GetClassMetadata(entityName);

    String prefix = String.Concat(entityName, ".");

    IDictionary<String, ICollectionMetadata> collectionMetadata = sessionFactory.GetAllCollectionMetadata().Where(x => x.Key.StartsWith(prefix)).ToDictionary(x => x.Key, x => x.Value);

  

    foreach (String key in collectionMetadata.Keys)

    {

        String propertyName = key.Replace(prefix, String.Empty);

        yield return(entityType.GetProperty(propertyName));

    }

}

A brief explanation:

GetProperties: all the mapped properties for a given entity;
GetComponents: given an entity type, returns all the properties that are mapped as components;
GetUserTypes: all the properties that are mapped as custom user types;
GetIdentifier: the property that is mapped as the identifier;
GetAssociations: properties mapped as one to one or many to one, that is, that point to another entity;
GetCollections: properties mapped as one to many, that is, collections, of any type;
GetTableName: the table or view name where the entity is stored;
GetIdentifierColumnNames: the names of the column(s) that compose the primary key for the table;
GetColumnName: the table or view column that store a given property.

Remove View State from UpdatePanel Call

Ricardo Peres — Fri, 27 Jan 2012 17:33:00 GMT

You may not be aware that view state (and control state) is included on each UpdatePanel call, even if the controls placed inside it have it disabled. As view state can get quite large, it may be useful to disable posting it during UpdatePanel calls, as long as you know what you are doing!

Here’s one possible solution, using Microsoft’s AJAX Library to intercept the asynchronous call before it is actually sent to the server:

        1: function removeViewState(body)

       2: {

       3:     var builder = new Sys.StringBuilder();

       4:     var parts = body.split('&');

       5:  

       6:     for (var i = 0; i < parts.length; ++i)

       7:     {

       8:         if (parts[i].indexOf('__VIEWSTATE=') < 0)

       9:         {

            builder.append(parts[i]);

        }

  

        if (i != parts.length - 1)

        {

            builder.append('&');

        }

    }

  

    return (builder.toString());

}

  

Sys.Net.WebRequestManager.add_invokingRequest

(

    function (s, e)

    {

        var webRequest = e.get_webRequest();

        var body = webRequest.get_body();

  

        body = removeViewState(body);

  

        webRequest.set_body(body);

    }

);

As you can see, I iterate through all of the parameters being sent along with the request, and I skip the view state.

Hope this helps!

Twitter

Ricardo Peres — Fri, 27 Jan 2012 15:15:51 GMT

Follow me at https://twitter.com/#!/RJPeres75

Detecting Authentication Expiration in ASP.NET

Ricardo Peres — Fri, 20 Jan 2012 16:41:05 GMT

I recently had to solve a problem: when issuing an asynchronous call by using an UpdatePanel, if the user is no longer authenticated – due possibly to long inactivity – this situation is silently ignored. What happens is, when an unauthenticated user tries to access a protected resource, ASP.NET redirects the request to the login page, and still returns a 302 HTTP status code (Found).

Here’s what I did: first, I hooked an event listener to the completedRequest event of the Sys.Net.WebRequestManager JavaScript object, part of Microsoft’s AJAX Library. This event fires whenever an asynchronous call, made typically by an UpdatePanel, terminates.

Inside it, I look at the response text, directly at the XMLHttpRequest instance. If it contains a text that I know only my login page contains (a comment inside , such as <!—this is the login page -->), then I know I am no longer authenticated, since my async requests are getting redirected.

All I can do at this point is give the user the option to authenticate again, by redirecting to the login page (yes, I know about application services, but that is not the point here).

So, here’s the code:

        1: Sys.Application.add_init

       2:     (

       3:         function ()

       4:         {

       5:             Sys.Net.WebRequestManager.add_completedRequest

       6:             (

       7:                 function (s, e)

       8:                 {

       9:                     if (s._xmlHttpRequest.responseText.indexOf('this is the login page') >= 0)

      10:                     {

      11:                         if (window.confirm('You are no longer authenticated. Do you wish to return to the login page?'))

      12:                         {   

      13:                             window.location.href = '/Login.aspx?ReturnURL=' + window.location.pathname;

      14:                         }

      15:                     }

      16:                 }

      17:             );

      18:         }

      19:     );

And that’s it. Just place this in your master page or on a control that goes on every page.

Querying an Uninitialized Collection with NHibernate

Ricardo Peres — Wed, 18 Jan 2012 13:09:00 GMT

I have talked before about the problem of accessing an uninitialized collection and presented a solution that allows us to see if the collection contains elements on the DB, and how many there are, without actually loading them. Now I have a general purpose solution for querying the collection on the DB.

Here it is:

        1: public static IQueryable<T> Query<T>(this IEnumerable<T> collection)

       2: {

       3:     if (collection is AbstractPersistentCollection)

       4:     {

       5:         IPersistentCollection col = collection as IPersistentCollection;

       6:  

       7:         if (col.WasInitialized == false)

       8:         {

       9:             String role = col.Role;

            Object owner = col.Owner;

            Object key = col.Key;

            ISessionImplementor sessionImpl = typeof(AbstractPersistentCollection).GetField("session", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(collection) as ISessionImplementor;

            ISession session = sessionImpl as ISession;

            ISessionFactory sessionFactory = session.SessionFactory;

            String ownerEntityName = sessionImpl.BestGuessEntityName(owner);

            Type ownerType = Type.GetType(ownerEntityName);

            IClassMetadata metadata = sessionFactory.GetClassMetadata(ownerEntityName);

            String idPropertyName = metadata.IdentifierPropertyName;

            MethodInfo ownerIdGetMethod = ownerType.GetProperty(idPropertyName).GetGetMethod();

            String childPropertyName = role.Split('.').Last();

            MethodInfo ownerChildGetMethod = ownerType.GetProperty(childPropertyName).GetGetMethod();

            Type childType = typeof(T);

            ParameterExpression a = null;

            IQueryable<T> details = typeof(Queryable).GetMethods(BindingFlags.Static | BindingFlags.Public).Where(x => x.Name == "SelectMany" && x.GetParameters().Length == 2).First().MakeGenericMethod(ownerType, childType).Invoke

            (

                null,

                new Object[]

                    {                    

                        typeof(Queryable).GetMethods(BindingFlags.Static | BindingFlags.Public).Where(x => x.Name == "Where").First().MakeGenericMethod(ownerType).Invoke

                        (

                            null,

                            new Object[]

                            {

                                typeof(LinqExtensionMethods).GetMethods(BindingFlags.Static | BindingFlags.Public).Where(x => x.Name == "Query" && x.GetParameters()[0].ParameterType == typeof(ISession)).Single().MakeGenericMethod(ownerType).Invoke

                                (

                                    null,

                                    new Object [] { session }

                                ),

                                Expression.Lambda

                                (

                                    typeof(Func<,>).MakeGenericType(ownerType, typeof(Boolean)),

                                    Expression.Equal(Expression.Property(a = Expression.Parameter(ownerType, "x"), ownerIdGetMethod), Expression.Constant(key, ownerIdGetMethod.ReturnType)), new ParameterExpression[] { a }

                                )

                            }

                        ),

                        Expression.Lambda

                        (

                            typeof(Func<,>).MakeGenericType(ownerType, typeof(IEnumerable<>).MakeGenericType(childType)),

                            Expression.Property(a = Expression.Parameter(ownerType, "x"), ownerChildGetMethod), new ParameterExpression[] { a }

                        )

                    }

            ) as IQueryable<T>;

  

            return (details);

        }

    }

  

    return (collection.AsQueryable());

}

As you can see, I first check to see the collection is an NHibernate one, if not, I fall back to LINQ to Objects; also, if the collection is already initialized, I also use LINQ to Objects.

Hope this helps!

NHibernate Pitfalls: SQL Queries and Parameter Prefix

Ricardo Peres — Sat, 07 Jan 2012 17:03:00 GMT

This is part of a series of posts about NHibernate Pitfalls. See the entire collection here.

When you execute an SQL query with NHibernate with named parameters, you would perhaps expect them to be prefixed with a symbol specific to the current DB you are accessing, for example, @ for SQL Server and : for Oracle; that is not the case. NHibernate requires that you always use it’s DB-neutral parameter prefix, :, the same that you use for HQL queries:

        1: //for SQL queries

       2: session.CreateSQLQuery("SELECT * FROM [Order] WHERE Id = :id").SetParameter("id", 1).List();

       3: //for HQL queries

       4: session.CreateQuery("from Order where id = :id").SetParameter("id", 1).List();

Inline Image in ASP.NET

Ricardo Peres — Wed, 30 Nov 2011 12:08:23 GMT

Inline images is a technique that, instead of referring to an external URL, includes all of the image’s content in the HTML itself, in the form of a Base64-encoded string.

It avoids a second browser request, at the cost of making the HTML page slightly heavier and not using cache.

Not all browsers support it, but current versions of IE, Firefox and Chrome do.

In order to use inline images, you must write the img element’s src attribute like this:

        1: <img src="data:image/gif;base64,R0lGODlhEAAOALMAAOazToeHh0tLS/7LZv/0jvb29t/f3//Ub/

       2: /ge8WSLf/rhf/3kdbW1mxsbP//mf///yH5BAAAAAAALAAAAAAQAA4AAARe8L1Ekyky67QZ1hLnjM5UUde0ECwLJoExKcpp

       3: V0aCcGCmTIHEIUEqjgaORCMxIC6e0CcguWw6aFjsVMkkIr7g77ZKPJjPZqIyd7sJAgVGoEGv2xsBxqNgYPj/gAwXEQA7" 

       4: width="16" height="14" alt="embedded folder icon"/>

The syntax is: data:[<mediatype>][;base64],<data>

I developed a simple control that allows you to use inline images in your ASP.NET pages. Here it is:

       1: public class InnerImage: Image

       2: {

       3:     protected override void OnInit(EventArgs e)

       4:     {

       5:         String imagePath = this.Context.Server.MapPath(this.ImageUrl);

       6:         String extension = Path.GetExtension(imagePath).Substring(1);

       7:         Byte[] imageData = File.ReadAllBytes(imagePath);

       8:  

       9:         this.ImageUrl = String.Format("data:image/{0};base64,{1}", extension, Convert.ToBase64String(imageData));

      10:  

      11:         base.OnInit(e);

      12:     }

      13: }

Simple, don’t you think?

Checking if an Unloaded Collection Contains Elements with NHibernate

Ricardo Peres — Mon, 14 Nov 2011 16:05:00 GMT

If you want to know if an unloaded collection in an entity contains elements, or count them, without actually loading them, you need to use a custom query; that is because the Count property (if the collection is not mapped with lazy=”extra”) and the LINQ Count() and Any() methods force the whole collection to be loaded.

You can use something like these two methods, one for checking if there are any values, the other for actually counting them:

        1: public static Boolean Exists(this ISession session, IEnumerable collection)

       2: {

       3:     if (collection is IPersistentCollection)

       4:     {

       5:         IPersistentCollection col = collection as IPersistentCollection;

       6:  

       7:         if (col.WasInitialized == false)

       8:         {

       9:                 String[] roleParts = col.Role.Split('.');

                String ownerTypeName = String.Join(".", roleParts, 0, roleParts.Length - 1);

                String ownerCollectionName = roleParts.Last();

                String hql = "select 1 from " + ownerTypeName + " it where it.id = :id and exists elements(it." + ownerCollectionName + ")";

                Boolean exists = session.CreateQuery(hql).SetParameter("id", col.Key).List().Count == 1;

  

                return (exists);

        }

    }

  

    return ((collection as IEnumerable).OfType<Object>().Any());

}

  

public static Int64 Count(this ISession session, IEnumerable collection)

{

    if (collection is IPersistentCollection)

    {

        IPersistentCollection col = collection as IPersistentCollection;

  

        if (col.WasInitialized == false)

        {

            String[] roleParts = col.Role.Split('.');

            String ownerTypeName = String.Join(".", roleParts, 0, roleParts.Length - 1);

            String ownerCollectionName = roleParts.Last();

            String hql = "select count(elements(it." + ownerCollectionName + ")) from " + ownerTypeName + " it where it.id = :id";

            Int64 count = session.CreateQuery(hql).SetParameter("id", col.Key).UniqueResult<Int64>();

  

            return (count);

        }

    }

  

    return ((collection as IEnumerable).OfType<Object>().Count());

}

Here’s how:

       1: MyEntity entity = session.Load(100);

       2:  

       3: if (session.Exists(entity.SomeCollection))

       4: {

       5:     Int32 count = session.Count(entity.SomeCollection);

       6:     //...

       7: }

NHibernate Pitfalls: Querying a Collection Count

Ricardo Peres — Sun, 06 Nov 2011 18:28:00 GMT

This is part of a series of posts about NHibernate Pitfalls. See the entire collection here.

Beware when querying a one-to-many collection (bag, set, map, list, etc) with the LINQ standard operators Any() or Count() (or even with the collection’s own Count property: if the collection is mapped as lazy = true, it will be loaded entirely from the DB (if it is not already loaded). That is because the Any() and Count() methods are from LINQ to Objects, not LINQ to NHibernate:

        1: Int32 ordersByProduct = product.OrderDetails.Count();    //causes loading of all order details

There are two possible solutions:

Map the collection with lazy = extra and use the collection's Count property;

       1: mapper.Class<Product>(ca =>

       2: {

       3:     //...

       4:     ca.Set(x => x.OrderDetails, x =>

       5:     {

       6:         x.Key(c => c.Column("`PRODUCTID`"));

       7:         x.Inverse(true);

       8:         x.Lazy(CollectionLazy.Extra);

       9:         //...

      10:     }, c => c.OneToMany());

      11: }

Perform an independent query (not on the collection) to find if the association has any elements:

       1: var existOrderForProduct = session.Query<OrderDetail>().Where(x => x.Product.Id == 100).Any();

NHibernate Pitfalls: Lazy Entities and Virtual Members

Ricardo Peres — Fri, 07 Oct 2011 13:37:00 GMT

This is part of a series of posts about NHibernate Pitfalls. See the entire collection here.

If you want to lazily load an entity as part of a many to one or one to one endpoint, you must declare it as lazy. This way, a proxy can be generated for it, by subclassing it:

        1: mapper.Class<Customer>(ca =>

       2: {

       3:     ca.Table("`CUSTOMER`");

       4:     ca.Lazy(true);

       5:     //rest goes here

       6: }

NHibernate’s built-in proxy factory requires that all properties and methods be declared virtual, not just the mapped properties, so keep this in mind.

If you want to change this behavior, you can either disable proxy validation:

       1: NHibernate.Cfg.Configuration cfg = new NHibernate.Cfg.Configuration()

       2: .SetProperty(NHibernate.Cfg.Environment.UseProxyValidator, Boolean.FalseString)

       3: //rest goes here

Or you can make all properties and methods virtual and either public, protected or protected internal - internal and private won't do.

NHibernate Pitfalls: Fetch and Lazy

Ricardo Peres — Sun, 18 Sep 2011 11:24:00 GMT

This is part of a series of posts about NHibernate Pitfalls. See the entire collection here.

When we use the fetch mode join for an association, we are implicitly using eager fetching, not lazy. Because the SELECT statement for the root entity already includes the association table, it will be loaded at the same time, so, it makes no sense to have fetch=”join” and lazy=”false” for an association; in this case, fetch will take precedence and disable lazy loading. Be aware if your association has lots of entities, and you don’t need it most of the time.

On the other hand, for many to one associations that you don't want to load immediately, you must take other steps: set fetch to select, set lazy to either proxy or no-proxy, and also set the other endpoint entity as lazy, otherwise, no proxy will be generated for it and thus it can't be lazy loaded.

NHibernate Pitfalls: SELECT N + 1

Ricardo Peres — Sun, 18 Sep 2011 11:10:36 GMT

This is part of a series of posts about NHibernate Pitfalls. See the entire collection here.

One of the recurring situations when accessing a list of entities and changing them is the SELECT N + 1 problem; it is an anti-pattern that, although won’t throw exceptions, and in this sense can be considered to be harmless, means accessing your database in a less than optimal way: one query for the list items without any of its lazy associations (1) and one additional query for each of the list items’ lazy associations (N). Of course, this only happens if you have lazy associations at all.

The way to go over it, when you absolutely know that you will need to access all associations for all entities is to preload them when you issue the query. Here’s how:

        1: IEnumerable<Order> ordersWithLinq = session.Query<Order>().Fetch(x => x.Customer).FetchMany(x => x.Details).ToList();

       2:  

       3: IEnumerable<Order> ordersWithHql = session.CreateQuery("from Order o inner join fetch o.Customer inner join fetch o.Details").List<Order>();

       4:  

       5: IEnumerable<Order> ordersWithCriteria = session.CreateCriteria<Order>().CreateAlias("Customer", "c", JoinType.InnerJoin).CreateAlias("Details", "d", JoinType.InnerJoin).List<Order>();

       6:  

       7: IEnumerable<Order> ordersWithQueryOver = session.QueryOver<Order>().Fetch(x => x.Customer).Eager.Fetch(x => x.Details).Eager.List<Order>();

NHibernate Pitfalls: Merge

Ricardo Peres — Sun, 18 Sep 2011 10:25:00 GMT

This is part of a series of posts about NHibernate Pitfalls. See the entire collection here.

Sometimes there may be the need to store a loaded entity in a place that outlives the session that retrieved it.

Later on, you need to associate this entity with a new session, in order to continue using it; for this, you tipically use the Merge method. When you do this, however, you must use a new reference to the entity returned by this method:

        1: Order order = HttpContext.Current.Session["order"] as Order;

       2:  

       3: Order savedOrder = session.Merge<Order>(order);

       4:  

       5: savedOrder.Customer = session.Load<Customer>(Int32.Parse(this.customerDropDownList.SelectedValue));

All future changes, such as setting property values, must be made to the merged entity, not the saved one, because NHibernate knows nothing about it:

       1: Boolean contains = session.Contains(order);                    //false

       2: Boolean containsSavedOrder = session.Contains(savedOrder);    //true

Now you just have to Flush your session (or, better yet, commit your transaction) and the entity will be updated in the DB. Beware, though: if you don't set ALL of your entities' properties, the record in the database will be overwritten with the current values in this instance!

Workshop Novidades ASP.NET 4.0

Ricardo Peres — Fri, 16 Sep 2011 10:38:44 GMT

No próximo dia 8 de Outubro irei dar um pequeno workshop, de 3 horas, nas instalações da Flag, em Coimbra:

Se tiverem curiosidade, apareçam!